fs/btrfs/super.c

   1 #include <linux/module.h>
   2 #include <linux/buffer_head.h>
   3 #include <linux/fs.h>
   4 #include <linux/pagemap.h>
   5 #include <linux/highmem.h>
   6 #include <linux/time.h>
   7 #include <linux/init.h>
   8 #include <linux/string.h>
   9 #include <linux/smp_lock.h>
  10 #include <linux/backing-dev.h>
  11 #include <linux/mpage.h>
  12 #include <linux/swap.h>
  13 #include <linux/writeback.h>
  14 #include "ctree.h"
  15 #include "disk-io.h"
  16 #include "transaction.h"
  17 #include "btrfs_inode.h"
  18
  19 #define BTRFS_SUPER_MAGIC 0x9123682E
  20
  21 static struct inode_operations btrfs_dir_inode_operations;
  22 static struct super_operations btrfs_super_ops;
  23 static struct file_operations btrfs_dir_file_operations;
  24 static struct inode_operations btrfs_file_inode_operations;
  25 static struct address_space_operations btrfs_aops;
  26 static struct file_operations btrfs_file_operations;
  27
  28 static int check_inode(struct inode *inode)
  29 {
  30         struct btrfs_inode *ei = BTRFS_I(inode);
  31         WARN_ON(ei->magic != 0xDEADBEEF);
  32         WARN_ON(ei->magic2 != 0xDEADBEAF);
  33         return 0;
  34 }
  35
  36 static void btrfs_read_locked_inode(struct inode *inode)
  37 {
  38         struct btrfs_path *path;
  39         struct btrfs_inode_item *inode_item;
  40         struct btrfs_root *root = btrfs_sb(inode->i_sb);
  41         int ret;
  42
  43         path = btrfs_alloc_path();
  44         BUG_ON(!path);
  45         btrfs_init_path(path);
  46         mutex_lock(&root->fs_info->fs_mutex);
  47
  48         check_inode(inode);
  49         ret = btrfs_lookup_inode(NULL, root, path, inode->i_ino, 0);
  50         if (ret) {
  51                 btrfs_release_path(root, path);
  52                 btrfs_free_path(path);
  53                 mutex_unlock(&root->fs_info->fs_mutex);
  54                 make_bad_inode(inode);
  55                 return;
  56         }
  57         check_inode(inode);
  58         inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
  59                                   path->slots[0],
  60                                   struct btrfs_inode_item);
  61
  62         inode->i_mode = btrfs_inode_mode(inode_item);
  63         inode->i_nlink = btrfs_inode_nlink(inode_item);
  64         inode->i_uid = btrfs_inode_uid(inode_item);
  65         inode->i_gid = btrfs_inode_gid(inode_item);
  66         inode->i_size = btrfs_inode_size(inode_item);
  67         inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
  68         inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
  69         inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
  70         inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
  71         inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
  72         inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
  73         inode->i_blocks = btrfs_inode_nblocks(inode_item);
  74         inode->i_generation = btrfs_inode_generation(inode_item);
  75
  76         btrfs_release_path(root, path);
  77         btrfs_free_path(path);
  78         inode_item = NULL;
  79
  80         mutex_unlock(&root->fs_info->fs_mutex);
  81         check_inode(inode);
  82         switch (inode->i_mode & S_IFMT) {
  83 #if 0
  84         default:
  85                 init_special_inode(inode, inode->i_mode,
  86                                    btrfs_inode_rdev(inode_item));
  87                 break;
  88 #endif
  89         case S_IFREG:
  90                 inode->i_mapping->a_ops = &btrfs_aops;
  91                 inode->i_fop = &btrfs_file_operations;
  92                 inode->i_op = &btrfs_file_inode_operations;
  93                 break;
  94         case S_IFDIR:
  95                 inode->i_op = &btrfs_dir_inode_operations;
  96                 inode->i_fop = &btrfs_dir_file_operations;
  97                 break;
  98         case S_IFLNK:
  99                 // inode->i_op = &page_symlink_inode_operations;
 100                 break;
 101         }
 102         check_inode(inode);
 103         return;
 104 }
 105
 106 static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
 107                               struct btrfs_root *root,
 108                               struct inode *dir,
 109                               struct dentry *dentry)
 110 {
 111         struct btrfs_path *path;
 112         const char *name = dentry->d_name.name;
 113         int name_len = dentry->d_name.len;
 114         int ret;
 115         u64 objectid;
 116         struct btrfs_dir_item *di;
 117
 118         path = btrfs_alloc_path();
 119         BUG_ON(!path);
 120         btrfs_init_path(path);
 121         ret = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
 122                                     name, name_len, -1);
 123         if (ret < 0)
 124                 goto err;
 125         if (ret > 0) {
 126                 ret = -ENOENT;
 127                 goto err;
 128         }
 129         di = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
 130                             struct btrfs_dir_item);
 131         objectid = btrfs_dir_objectid(di);
 132
 133         ret = btrfs_del_item(trans, root, path);
 134         BUG_ON(ret);
 135         dentry->d_inode->i_ctime = dir->i_ctime;
 136 err:
 137         btrfs_release_path(root, path);
 138         btrfs_free_path(path);
 139         if (ret == 0)
 140                 inode_dec_link_count(dentry->d_inode);
 141         return ret;
 142 }
 143
 144 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 145 {
 146         struct btrfs_root *root;
 147         struct btrfs_trans_handle *trans;
 148         int ret;
 149
 150         root = btrfs_sb(dir->i_sb);
 151         mutex_lock(&root->fs_info->fs_mutex);
 152         trans = btrfs_start_transaction(root, 1);
 153         ret = btrfs_unlink_trans(trans, root, dir, dentry);
 154         btrfs_end_transaction(trans, root);
 155         mutex_unlock(&root->fs_info->fs_mutex);
 156         return ret;
 157 }
 158
 159 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 160 {
 161         struct inode *inode = dentry->d_inode;
 162         int err;
 163         int ret;
 164         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 165         struct btrfs_path *path;
 166         struct btrfs_key key;
 167         struct btrfs_trans_handle *trans;
 168         struct btrfs_disk_key *found_key;
 169         struct btrfs_leaf *leaf;
 170
 171         path = btrfs_alloc_path();
 172         BUG_ON(!path);
 173         btrfs_init_path(path);
 174         mutex_lock(&root->fs_info->fs_mutex);
 175         trans = btrfs_start_transaction(root, 1);
 176         key.objectid = inode->i_ino;
 177         key.offset = (u64)-1;
 178         key.flags = 0;
 179         btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
 180         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 181         if (ret < 0) {
 182                 err = ret;
 183                 goto out;
 184         }
 185
 186         BUG_ON(ret == 0);
 187         BUG_ON(path->slots[0] == 0);
 188         path->slots[0]--;
 189         leaf = btrfs_buffer_leaf(path->nodes[0]);
 190         found_key = &leaf->items[path->slots[0]].key;
 191         if (btrfs_disk_key_objectid(found_key) != inode->i_ino) {
 192                 err = -ENOENT;
 193                 goto out;
 194         }
 195         if (btrfs_disk_key_type(found_key) != BTRFS_DIR_ITEM_KEY ||
 196             btrfs_disk_key_offset(found_key) != 2) {
 197                 err = -ENOTEMPTY;
 198                 goto out;
 199         }
 200         ret = btrfs_del_item(trans, root, path);
 201         BUG_ON(ret);
 202         btrfs_release_path(root, path);
 203         key.offset = 1;
 204         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 205         if (ret < 0) {
 206                 err = ret;
 207                 goto out;
 208         }
 209         if (ret > 0) {
 210                 err = -ENOTEMPTY;
 211                 goto out;
 212         }
 213         ret = btrfs_del_item(trans, root, path);
 214         if (ret) {
 215                 err = ret;
 216                 goto out;
 217         }
 218         btrfs_release_path(root, path);
 219
 220         /* now the directory is empty */
 221         err = btrfs_unlink_trans(trans, root, dir, dentry);
 222         if (!err) {
 223                 inode->i_size = 0;
 224         }
 225 out:
 226         btrfs_release_path(root, path);
 227         btrfs_free_path(path);
 228         mutex_unlock(&root->fs_info->fs_mutex);
 229         ret = btrfs_end_transaction(trans, root);
 230         if (ret && !err)
 231                 err = ret;
 232         return err;
 233 }
 234
 235 static int btrfs_free_inode(struct btrfs_trans_handle *trans,
 236                             struct btrfs_root *root,
 237                             struct inode *inode)
 238 {
 239         u64 objectid = inode->i_ino;
 240         struct btrfs_path *path;
 241         struct btrfs_inode_map_item *map;
 242         struct btrfs_key stat_data_key;
 243         int ret;
 244
 245         clear_inode(inode);
 246
 247         path = btrfs_alloc_path();
 248         BUG_ON(!path);
 249         btrfs_init_path(path);
 250         ret = btrfs_lookup_inode_map(trans, root, path, objectid, -1);
 251         if (ret) {
 252                 if (ret > 0)
 253                         ret = -ENOENT;
 254                 goto error;
 255         }
 256         map = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
 257                             struct btrfs_inode_map_item);
 258         btrfs_disk_key_to_cpu(&stat_data_key, &map->key);
 259         ret = btrfs_del_item(trans, root->fs_info->inode_root, path);
 260         BUG_ON(ret);
 261         btrfs_release_path(root, path);
 262
 263         ret = btrfs_lookup_inode(trans, root, path, objectid, -1);
 264         BUG_ON(ret);
 265         ret = btrfs_del_item(trans, root, path);
 266         BUG_ON(ret);
 267 error:
 268         btrfs_release_path(root, path);
 269         btrfs_free_path(path);
 270         return ret;
 271 }
 272
 273 static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
 274                                    struct btrfs_root *root,
 275                                    struct inode *inode)
 276 {
 277         int ret;
 278         struct btrfs_path *path;
 279         struct btrfs_key key;
 280         struct btrfs_disk_key *found_key;
 281         struct btrfs_leaf *leaf;
 282         struct btrfs_file_extent_item *fi = NULL;
 283         u64 extent_start = 0;
 284         u64 extent_num_blocks = 0;
 285         int found_extent;
 286
 287         path = btrfs_alloc_path();
 288         BUG_ON(!path);
 289         /* FIXME, add redo link to tree so we don't leak on crash */
 290         key.objectid = inode->i_ino;
 291         key.offset = (u64)-1;
 292         key.flags = 0;
 293         btrfs_set_key_type(&key, BTRFS_CSUM_ITEM_KEY);
 294         while(1) {
 295                 btrfs_init_path(path);
 296                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 297                 if (ret < 0) {
 298                         goto error;
 299                 }
 300                 if (ret > 0) {
 301                         BUG_ON(path->slots[0] == 0);
 302                         path->slots[0]--;
 303                 }
 304                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 305                 found_key = &leaf->items[path->slots[0]].key;
 306                 if (btrfs_disk_key_objectid(found_key) != inode->i_ino)
 307                         break;
 308                 if (btrfs_disk_key_type(found_key) != BTRFS_CSUM_ITEM_KEY &&
 309                     btrfs_disk_key_type(found_key) != BTRFS_EXTENT_DATA_KEY)
 310                         break;
 311                 if (btrfs_disk_key_offset(found_key) < inode->i_size)
 312                         break;
 313                 if (btrfs_disk_key_type(found_key) == BTRFS_EXTENT_DATA_KEY) {
 314                         fi = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
 315                                             path->slots[0],
 316                                             struct btrfs_file_extent_item);
 317                         extent_start = btrfs_file_extent_disk_blocknr(fi);
 318                         extent_num_blocks =
 319                                 btrfs_file_extent_disk_num_blocks(fi);
 320                         inode->i_blocks -=
 321                                 btrfs_file_extent_num_blocks(fi) >> 9;
 322                         found_extent = 1;
 323                 } else {
 324                         found_extent = 0;
 325                 }
 326                 ret = btrfs_del_item(trans, root, path);
 327                 BUG_ON(ret);
 328                 btrfs_release_path(root, path);
 329                 if (found_extent) {
 330                         ret = btrfs_free_extent(trans, root, extent_start,
 331                                                 extent_num_blocks, 0);
 332                         BUG_ON(ret);
 333                 }
 334         }
 335         ret = 0;
 336 error:
 337         btrfs_release_path(root, path);
 338         btrfs_free_path(path);
 339         return ret;
 340 }
 341
 342 static void btrfs_delete_inode(struct inode *inode)
 343 {
 344         struct btrfs_trans_handle *trans;
 345         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 346         int ret;
 347
 348         truncate_inode_pages(&inode->i_data, 0);
 349         if (is_bad_inode(inode)) {
 350                 goto no_delete;
 351         }
 352         inode->i_size = 0;
 353         mutex_lock(&root->fs_info->fs_mutex);
 354         trans = btrfs_start_transaction(root, 1);
 355         if (S_ISREG(inode->i_mode)) {
 356                 ret = btrfs_truncate_in_trans(trans, root, inode);
 357                 BUG_ON(ret);
 358         }
 359         btrfs_free_inode(trans, root, inode);
 360         btrfs_end_transaction(trans, root);
 361         mutex_unlock(&root->fs_info->fs_mutex);
 362         return;
 363 no_delete:
 364         clear_inode(inode);
 365 }
 366
 367 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
 368                               ino_t *ino)
 369 {
 370         const char *name = dentry->d_name.name;
 371         int namelen = dentry->d_name.len;
 372         struct btrfs_dir_item *di;
 373         struct btrfs_path *path;
 374         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 375         int ret;
 376
 377         path = btrfs_alloc_path();
 378         BUG_ON(!path);
 379         btrfs_init_path(path);
 380         ret = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
 381                                     namelen, 0);
 382         if (ret || !btrfs_match_dir_item_name(root, path, name, namelen)) {
 383                 *ino = 0;
 384                 ret = 0;
 385                 goto out;
 386         }
 387         di = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
 388                             struct btrfs_dir_item);
 389         *ino = btrfs_dir_objectid(di);
 390 out:
 391         btrfs_release_path(root, path);
 392         btrfs_free_path(path);
 393         check_inode(dir);
 394         return ret;
 395 }
 396
 397 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
 398                                    struct nameidata *nd)
 399 {
 400         struct inode * inode;
 401         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 402         ino_t ino;
 403         int ret;
 404
 405         if (dentry->d_name.len > BTRFS_NAME_LEN)
 406                 return ERR_PTR(-ENAMETOOLONG);
 407         mutex_lock(&root->fs_info->fs_mutex);
 408         ret = btrfs_inode_by_name(dir, dentry, &ino);
 409         mutex_unlock(&root->fs_info->fs_mutex);
 410         if (ret < 0)
 411                 return ERR_PTR(ret);
 412         inode = NULL;
 413         if (ino) {
 414                 inode = iget(dir->i_sb, ino);
 415                 if (!inode)
 416                         return ERR_PTR(-EACCES);
 417                 check_inode(inode);
 418         }
 419         check_inode(dir);
 420         return d_splice_alias(inode, dentry);
 421 }
 422
 423 static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 424 {
 425         struct inode *inode = filp->f_path.dentry->d_inode;
 426         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 427         struct btrfs_item *item;
 428         struct btrfs_dir_item *di;
 429         struct btrfs_key key;
 430         struct btrfs_path *path;
 431         int ret;
 432         u32 nritems;
 433         struct btrfs_leaf *leaf;
 434         int slot;
 435         int advance;
 436         unsigned char d_type = DT_UNKNOWN;
 437         int over = 0;
 438
 439         mutex_lock(&root->fs_info->fs_mutex);
 440         key.objectid = inode->i_ino;
 441         key.flags = 0;
 442         btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
 443         key.offset = filp->f_pos;
 444         path = btrfs_alloc_path();
 445         btrfs_init_path(path);
 446         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 447         if (ret < 0) {
 448                 goto err;
 449         }
 450         advance = 0;
 451         while(1) {
 452                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 453                 nritems = btrfs_header_nritems(&leaf->header);
 454                 slot = path->slots[0];
 455                 if (advance || slot >= nritems) {
 456                         if (slot >= nritems -1) {
 457                                 ret = btrfs_next_leaf(root, path);
 458                                 if (ret)
 459                                         break;
 460                                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 461                                 nritems = btrfs_header_nritems(&leaf->header);
 462                                 slot = path->slots[0];
 463                         } else {
 464                                 slot++;
 465                                 path->slots[0]++;
 466                         }
 467                 }
 468                 advance = 1;
 469                 item = leaf->items + slot;
 470                 if (btrfs_disk_key_objectid(&item->key) != key.objectid)
 471                         break;
 472                 if (btrfs_disk_key_type(&item->key) != BTRFS_DIR_ITEM_KEY)
 473                         continue;
 474                 if (btrfs_disk_key_offset(&item->key) < filp->f_pos)
 475                         continue;
 476
 477                 advance = 1;
 478                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
 479                 over = filldir(dirent, (const char *)(di + 1),
 480                                btrfs_dir_name_len(di),
 481                                btrfs_disk_key_offset(&item->key),
 482                                btrfs_dir_objectid(di), d_type);
 483                 if (over) {
 484                         filp->f_pos = btrfs_disk_key_offset(&item->key);
 485                         break;
 486                 }
 487                 filp->f_pos = btrfs_disk_key_offset(&item->key) + 1;
 488         }
 489         ret = 0;
 490 err:
 491         btrfs_release_path(root, path);
 492         btrfs_free_path(path);
 493         mutex_unlock(&root->fs_info->fs_mutex);
 494         return ret;
 495 }
 496
 497 static void btrfs_put_super (struct super_block * sb)
 498 {
 499         struct btrfs_root *root = btrfs_sb(sb);
 500         int ret;
 501
 502         ret = close_ctree(root);
 503         if (ret) {
 504                 printk("close ctree returns %d\n", ret);
 505         }
 506         sb->s_fs_info = NULL;
 507 }
 508
 509 static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
 510 {
 511         struct inode * inode;
 512         struct dentry * root_dentry;
 513         struct btrfs_super_block *disk_super;
 514         struct btrfs_root *root;
 515
 516         sb->s_maxbytes = MAX_LFS_FILESIZE;
 517         sb->s_magic = BTRFS_SUPER_MAGIC;
 518         sb->s_op = &btrfs_super_ops;
 519         sb->s_time_gran = 1;
 520
 521         root = open_ctree(sb);
 522
 523         if (!root) {
 524                 printk("btrfs: open_ctree failed\n");
 525                 return -EIO;
 526         }
 527         sb->s_fs_info = root;
 528         disk_super = root->fs_info->disk_super;
 529         printk("read in super total blocks %Lu root %Lu\n",
 530                btrfs_super_total_blocks(disk_super),
 531                btrfs_super_root_dir(disk_super));
 532
 533         inode = iget_locked(sb, btrfs_super_root_dir(disk_super));
 534         if (!inode)
 535                 return -ENOMEM;
 536         if (inode->i_state & I_NEW) {
 537                 btrfs_read_locked_inode(inode);
 538                 unlock_new_inode(inode);
 539         }
 540
 541         root_dentry = d_alloc_root(inode);
 542         if (!root_dentry) {
 543                 iput(inode);
 544                 return -ENOMEM;
 545         }
 546         sb->s_root = root_dentry;
 547
 548         return 0;
 549 }
 550
 551 static void fill_inode_item(struct btrfs_inode_item *item,
 552                             struct inode *inode)
 553 {
 554         btrfs_set_inode_uid(item, inode->i_uid);
 555         btrfs_set_inode_gid(item, inode->i_gid);
 556         btrfs_set_inode_size(item, inode->i_size);
 557         btrfs_set_inode_mode(item, inode->i_mode);
 558         btrfs_set_inode_nlink(item, inode->i_nlink);
 559         btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
 560         btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
 561         btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
 562         btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
 563         btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
 564         btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
 565         btrfs_set_inode_nblocks(item, inode->i_blocks);
 566         btrfs_set_inode_generation(item, inode->i_generation);
 567         check_inode(inode);
 568 }
 569
 570 static int btrfs_update_inode(struct btrfs_trans_handle *trans,
 571                               struct btrfs_root *root,
 572                               struct inode *inode)
 573 {
 574         struct btrfs_inode_item *inode_item;
 575         struct btrfs_path *path;
 576         int ret;
 577
 578         path = btrfs_alloc_path();
 579         BUG_ON(!path);
 580         btrfs_init_path(path);
 581
 582         ret = btrfs_lookup_inode(trans, root, path, inode->i_ino, 1);
 583         if (ret) {
 584                 if (ret > 0)
 585                         ret = -ENOENT;
 586                 goto failed;
 587         }
 588
 589         inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
 590                                   path->slots[0],
 591                                   struct btrfs_inode_item);
 592
 593         fill_inode_item(inode_item, inode);
 594         btrfs_mark_buffer_dirty(path->nodes[0]);
 595 failed:
 596         btrfs_release_path(root, path);
 597         btrfs_free_path(path);
 598         check_inode(inode);
 599         return 0;
 600 }
 601
 602 static int btrfs_write_inode(struct inode *inode, int wait)
 603 {
 604         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 605         struct btrfs_trans_handle *trans;
 606         int ret;
 607
 608         mutex_lock(&root->fs_info->fs_mutex);
 609         trans = btrfs_start_transaction(root, 1);
 610         ret = btrfs_update_inode(trans, root, inode);
 611         if (wait)
 612                 btrfs_commit_transaction(trans, root);
 613         else
 614                 btrfs_end_transaction(trans, root);
 615         mutex_unlock(&root->fs_info->fs_mutex);
 616         check_inode(inode);
 617         return ret;
 618 }
 619
 620 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
 621                                      struct inode *dir, int mode)
 622 {
 623         struct inode *inode;
 624         struct btrfs_inode_item inode_item;
 625         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 626         struct btrfs_key key;
 627         int ret;
 628         u64 objectid;
 629
 630         inode = new_inode(dir->i_sb);
 631         if (!inode)
 632                 return ERR_PTR(-ENOMEM);
 633
 634         check_inode(inode);
 635         ret = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
 636         BUG_ON(ret);
 637
 638         inode->i_uid = current->fsuid;
 639         inode->i_gid = current->fsgid;
 640         inode->i_mode = mode;
 641         inode->i_ino = objectid;
 642         inode->i_blocks = 0;
 643         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
 644         fill_inode_item(&inode_item, inode);
 645
 646         key.objectid = objectid;
 647         key.flags = 0;
 648         key.offset = 0;
 649         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
 650         ret = btrfs_insert_inode_map(trans, root, objectid, &key);
 651         BUG_ON(ret);
 652
 653         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
 654         BUG_ON(ret);
 655
 656         insert_inode_hash(inode);
 657         check_inode(inode);
 658         check_inode(dir);
 659         return inode;
 660 }
 661
 662 static int btrfs_add_link(struct btrfs_trans_handle *trans,
 663                             struct dentry *dentry, struct inode *inode)
 664 {
 665         int ret;
 666         ret = btrfs_insert_dir_item(trans, btrfs_sb(inode->i_sb),
 667                                     dentry->d_name.name, dentry->d_name.len,
 668                                     dentry->d_parent->d_inode->i_ino,
 669                                     inode->i_ino, 0);
 670         if (ret == 0) {
 671                 dentry->d_parent->d_inode->i_size += dentry->d_name.len;
 672                 ret = btrfs_update_inode(trans, btrfs_sb(inode->i_sb),
 673                                          dentry->d_parent->d_inode);
 674         }
 675         check_inode(inode);
 676         check_inode(dentry->d_parent->d_inode);
 677         return ret;
 678 }
 679
 680 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
 681                             struct dentry *dentry, struct inode *inode)
 682 {
 683         int err = btrfs_add_link(trans, dentry, inode);
 684         if (!err) {
 685                 d_instantiate(dentry, inode);
 686                 return 0;
 687         }
 688         if (err > 0)
 689                 err = -EEXIST;
 690         check_inode(inode);
 691         return err;
 692 }
 693
 694 static int btrfs_create(struct inode *dir, struct dentry *dentry,
 695                         int mode, struct nameidata *nd)
 696 {
 697         struct btrfs_trans_handle *trans;
 698         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 699         struct inode *inode;
 700         int err;
 701         int drop_inode = 0;
 702
 703         mutex_lock(&root->fs_info->fs_mutex);
 704         trans = btrfs_start_transaction(root, 1);
 705         inode = btrfs_new_inode(trans, dir, mode);
 706         err = PTR_ERR(inode);
 707         if (IS_ERR(inode))
 708                 goto out_unlock;
 709         // FIXME mark the inode dirty
 710         err = btrfs_add_nondir(trans, dentry, inode);
 711         if (err)
 712                 drop_inode = 1;
 713         else {
 714                 inode->i_mapping->a_ops = &btrfs_aops;
 715                 inode->i_fop = &btrfs_file_operations;
 716                 inode->i_op = &btrfs_file_inode_operations;
 717         }
 718         dir->i_sb->s_dirt = 1;
 719 out_unlock:
 720         btrfs_end_transaction(trans, root);
 721         mutex_unlock(&root->fs_info->fs_mutex);
 722         check_inode(inode);
 723         check_inode(dir);
 724
 725         if (drop_inode) {
 726                 inode_dec_link_count(inode);
 727                 iput(inode);
 728         }
 729         return err;
 730 }
 731
 732 static int btrfs_make_empty_dir(struct btrfs_trans_handle *trans,
 733                                 struct inode *inode, struct inode *dir)
 734 {
 735         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 736         int ret;
 737         char buf[2];
 738         buf[0] = '.';
 739         buf[1] = '.';
 740
 741         ret = btrfs_insert_dir_item(trans, root, buf, 1, inode->i_ino,
 742                                     inode->i_ino, 1);
 743         if (ret)
 744                 goto error;
 745         ret = btrfs_insert_dir_item(trans, root, buf, 2, inode->i_ino,
 746                                     dir->i_ino, 1);
 747         if (ret)
 748                 goto error;
 749         inode->i_size = 3;
 750         ret = btrfs_update_inode(trans, root, inode);
 751 error:
 752         return ret;
 753 }
 754
 755 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 756 {
 757         struct inode *inode;
 758         struct btrfs_trans_handle *trans;
 759         struct btrfs_root *root = btrfs_sb(dir->i_sb);
 760         int err = 0;
 761         int drop_on_err = 0;
 762
 763         mutex_lock(&root->fs_info->fs_mutex);
 764         trans = btrfs_start_transaction(root, 1);
 765         if (IS_ERR(trans)) {
 766                 err = PTR_ERR(trans);
 767                 goto out_unlock;
 768         }
 769         inode = btrfs_new_inode(trans, dir, S_IFDIR | mode);
 770         if (IS_ERR(inode)) {
 771                 err = PTR_ERR(inode);
 772                 goto out_fail;
 773         }
 774         drop_on_err = 1;
 775         inode->i_op = &btrfs_dir_inode_operations;
 776         inode->i_fop = &btrfs_dir_file_operations;
 777
 778         err = btrfs_make_empty_dir(trans, inode, dir);
 779         if (err)
 780                 goto out_fail;
 781         err = btrfs_add_link(trans, dentry, inode);
 782         if (err)
 783                 goto out_fail;
 784         d_instantiate(dentry, inode);
 785         drop_on_err = 0;
 786
 787 out_fail:
 788         btrfs_end_transaction(trans, root);
 789 out_unlock:
 790         mutex_unlock(&root->fs_info->fs_mutex);
 791         if (drop_on_err)
 792                 iput(inode);
 793         return err;
 794 }
 795
 796 static int btrfs_sync_fs(struct super_block *sb, int wait)
 797 {
 798         struct btrfs_trans_handle *trans;
 799         struct btrfs_root *root;
 800         int ret;
 801         root = btrfs_sb(sb);
 802
 803         sb->s_dirt = 0;
 804         if (!wait) {
 805                 filemap_flush(root->fs_info->btree_inode->i_mapping);
 806                 return 0;
 807         }
 808         filemap_write_and_wait(root->fs_info->btree_inode->i_mapping);
 809         mutex_lock(&root->fs_info->fs_mutex);
 810         trans = btrfs_start_transaction(root, 1);
 811         ret = btrfs_commit_transaction(trans, root);
 812         sb->s_dirt = 0;
 813         BUG_ON(ret);
 814 printk("btrfs sync_fs\n");
 815         mutex_unlock(&root->fs_info->fs_mutex);
 816         return 0;
 817 }
 818
 819 static int btrfs_get_block_inline(struct inode *inode, sector_t iblock,
 820                            struct buffer_head *result, int create)
 821 {
 822         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 823         struct btrfs_path *path;
 824         struct btrfs_key key;
 825         struct btrfs_leaf *leaf;
 826         int num_bytes = result->b_size;
 827         int item_size;
 828         int ret;
 829         u64 pos;
 830         char *ptr;
 831         int copy_size;
 832         int err = 0;
 833         char *safe_ptr;
 834         char *data_ptr;
 835
 836         path = btrfs_alloc_path();
 837         BUG_ON(!path);
 838
 839         WARN_ON(create);
 840         if (create) {
 841                 return 0;
 842         }
 843         pos = iblock << inode->i_blkbits;
 844         key.objectid = inode->i_ino;
 845         key.flags = 0;
 846         btrfs_set_key_type(&key, BTRFS_INLINE_DATA_KEY);
 847         ptr = kmap(result->b_page);
 848         safe_ptr = ptr;
 849         ptr += (pos & (PAGE_CACHE_SIZE -1));
 850 again:
 851         key.offset = pos;
 852         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 853         if (ret) {
 854                 if (ret < 0)
 855                         err = ret;
 856                 else
 857                         err = 0;
 858                 goto out;
 859         }
 860         leaf = btrfs_buffer_leaf(path->nodes[0]);
 861         item_size = btrfs_item_size(leaf->items + path->slots[0]);
 862         copy_size = min(num_bytes, item_size);
 863         data_ptr = btrfs_item_ptr(leaf, path->slots[0], char);
 864         WARN_ON(safe_ptr + PAGE_CACHE_SIZE < ptr + copy_size);
 865         memcpy(ptr, data_ptr, copy_size);
 866         pos += copy_size;
 867         num_bytes -= copy_size;
 868         WARN_ON(num_bytes < 0);
 869         ptr += copy_size;
 870         btrfs_release_path(root, path);
 871         if (num_bytes != 0) {
 872                 if (pos >= i_size_read(inode))
 873                         memset(ptr, 0, num_bytes);
 874                 else
 875                         goto again;
 876         }
 877         set_buffer_uptodate(result);
 878         map_bh(result, inode->i_sb, 0);
 879         err = 0;
 880 out:
 881         btrfs_free_path(path);
 882         kunmap(result->b_page);
 883         return err;
 884 }
 885
 886 static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
 887                            struct buffer_head *result, int create)
 888 {
 889         int ret;
 890         int err = 0;
 891         u64 blocknr;
 892         u64 extent_start = 0;
 893         u64 extent_end = 0;
 894         u64 objectid = inode->i_ino;
 895         struct btrfs_path *path;
 896         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 897         struct btrfs_trans_handle *trans = NULL;
 898         struct btrfs_file_extent_item *item;
 899         struct btrfs_leaf *leaf;
 900         struct btrfs_disk_key *found_key;
 901
 902         path = btrfs_alloc_path();
 903         BUG_ON(!path);
 904         btrfs_init_path(path);
 905         if (create)
 906                 trans = btrfs_start_transaction(root, 1);
 907
 908
 909         ret = btrfs_lookup_file_extent(trans, root, path,
 910                                        inode->i_ino,
 911                                        iblock << inode->i_blkbits, 0);
 912         if (ret < 0) {
 913                 err = ret;
 914                 goto out;
 915         }
 916
 917         if (ret != 0) {
 918                 if (path->slots[0] == 0) {
 919                         btrfs_release_path(root, path);
 920                         goto allocate;
 921                 }
 922                 path->slots[0]--;
 923         }
 924
 925         item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
 926                               struct btrfs_file_extent_item);
 927         leaf = btrfs_buffer_leaf(path->nodes[0]);
 928         blocknr = btrfs_file_extent_disk_blocknr(item);
 929         blocknr += btrfs_file_extent_offset(item);
 930
 931         /* exact match found, use it */
 932         if (ret == 0) {
 933                 err = 0;
 934                 map_bh(result, inode->i_sb, blocknr);
 935                 goto out;
 936         }
 937
 938         /* are we inside the extent that was found? */
 939         found_key = &leaf->items[path->slots[0]].key;
 940         if (btrfs_disk_key_objectid(found_key) != objectid ||
 941             btrfs_disk_key_type(found_key) != BTRFS_EXTENT_DATA_KEY) {
 942                 extent_end = 0;
 943                 extent_start = 0;
 944                 btrfs_release_path(root, path);
 945                 goto allocate;
 946         }
 947
 948         extent_start = btrfs_disk_key_offset(&leaf->items[path->slots[0]].key);
 949         extent_start = extent_start >> inode->i_blkbits;
 950         extent_start += btrfs_file_extent_offset(item);
 951         extent_end = extent_start + btrfs_file_extent_num_blocks(item);
 952         if (iblock >= extent_start && iblock < extent_end) {
 953                 err = 0;
 954                 map_bh(result, inode->i_sb, blocknr + iblock - extent_start);
 955                 goto out;
 956         }
 957 allocate:
 958         /* ok, create a new extent */
 959         if (!create) {
 960                 err = 0;
 961                 goto out;
 962         }
 963         ret = btrfs_alloc_file_extent(trans, root, objectid,
 964                                       iblock << inode->i_blkbits,
 965                                       1, extent_end, &blocknr);
 966         if (ret) {
 967                 err = ret;
 968                 goto out;
 969         }
 970         inode->i_blocks += inode->i_sb->s_blocksize >> 9;
 971         set_buffer_new(result);
 972         map_bh(result, inode->i_sb, blocknr);
 973
 974 out:
 975         btrfs_release_path(root, path);
 976         btrfs_free_path(path);
 977         if (trans)
 978                 btrfs_end_transaction(trans, root);
 979         return err;
 980 }
 981
 982 static int btrfs_get_block(struct inode *inode, sector_t iblock,
 983                            struct buffer_head *result, int create)
 984 {
 985         int err;
 986         struct btrfs_root *root = btrfs_sb(inode->i_sb);
 987         mutex_lock(&root->fs_info->fs_mutex);
 988         // err = btrfs_get_block_lock(inode, iblock, result, create);
 989         err = btrfs_get_block_inline(inode, iblock, result, create);
 990         mutex_unlock(&root->fs_info->fs_mutex);
 991         return err;
 992 }
 993
 994 static int btrfs_prepare_write(struct file *file, struct page *page,
 995                                unsigned from, unsigned to)
 996 {
 997         WARN_ON(1);
 998         return nobh_prepare_write(page, from, to, btrfs_get_block);
 999 }
1000 static int btrfs_commit_write(struct file *file, struct page *page,
1001                                unsigned from, unsigned to)
1002 {
1003         WARN_ON(1);
1004         return nobh_commit_write(file, page, from, to);
1005 }
1006
1007 static void btrfs_write_super(struct super_block *sb)
1008 {
1009         btrfs_sync_fs(sb, 1);
1010 }
1011
1012 static int btrfs_readpage(struct file *file, struct page *page)
1013 {
1014         return mpage_readpage(page, btrfs_get_block);
1015 }
1016
1017 static int btrfs_readpages(struct file *file, struct address_space *mapping,
1018                            struct list_head *pages, unsigned nr_pages)
1019 {
1020         return mpage_readpages(mapping, pages, nr_pages, btrfs_get_block);
1021 }
1022
1023 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
1024 {
1025         return nobh_writepage(page, btrfs_get_block, wbc);
1026 }
1027
1028 static void btrfs_truncate(struct inode *inode)
1029 {
1030         struct btrfs_root *root = btrfs_sb(inode->i_sb);
1031         int ret;
1032         struct btrfs_trans_handle *trans;
1033
1034         if (!S_ISREG(inode->i_mode))
1035                 return;
1036         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1037                 return;
1038
1039         nobh_truncate_page(inode->i_mapping, inode->i_size);
1040
1041         /* FIXME, add redo link to tree so we don't leak on crash */
1042         mutex_lock(&root->fs_info->fs_mutex);
1043         trans = btrfs_start_transaction(root, 1);
1044         ret = btrfs_truncate_in_trans(trans, root, inode);
1045         BUG_ON(ret);
1046         ret = btrfs_end_transaction(trans, root);
1047         BUG_ON(ret);
1048         mutex_unlock(&root->fs_info->fs_mutex);
1049         mark_inode_dirty(inode);
1050 }
1051
1052 static int btrfs_copy_from_user(loff_t pos, int num_pages, int write_bytes,
1053                                 struct page **prepared_pages,
1054                                 const char __user * buf)
1055 {
1056         long page_fault = 0;
1057         int i;
1058         int offset = pos & (PAGE_CACHE_SIZE - 1);
1059
1060         for (i = 0; i < num_pages && write_bytes > 0; i++, offset = 0) {
1061                 size_t count = min_t(size_t,
1062                                      PAGE_CACHE_SIZE - offset, write_bytes);
1063                 struct page *page = prepared_pages[i];
1064                 fault_in_pages_readable(buf, count);
1065
1066                 /* Copy data from userspace to the current page */
1067                 kmap(page);
1068                 page_fault = __copy_from_user(page_address(page) + offset,
1069                                               buf, count);
1070                 /* Flush processor's dcache for this page */
1071                 flush_dcache_page(page);
1072                 kunmap(page);
1073                 buf += count;
1074                 write_bytes -= count;
1075
1076                 if (page_fault)
1077                         break;
1078         }
1079         return page_fault ? -EFAULT : 0;
1080 }
1081
1082 static void btrfs_drop_pages(struct page **pages, size_t num_pages)
1083 {
1084         size_t i;
1085         for (i = 0; i < num_pages; i++) {
1086                 if (!pages[i])
1087                         break;
1088                 unlock_page(pages[i]);
1089                 mark_page_accessed(pages[i]);
1090                 page_cache_release(pages[i]);
1091         }
1092 }
1093 static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
1094                                    struct btrfs_root *root,
1095                                    struct file *file,
1096                                    struct page **pages,
1097                                    size_t num_pages,
1098                                    loff_t pos,
1099                                    size_t write_bytes)
1100 {
1101         int i;
1102         int offset;
1103         int err = 0;
1104         int ret;
1105         int this_write;
1106         struct inode *inode = file->f_path.dentry->d_inode;
1107
1108         for (i = 0; i < num_pages; i++) {
1109                 offset = pos & (PAGE_CACHE_SIZE -1);
1110                 this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
1111                 /* FIXME, one block at a time */
1112
1113                 mutex_lock(&root->fs_info->fs_mutex);
1114                 trans = btrfs_start_transaction(root, 1);
1115                 btrfs_csum_file_block(trans, root, inode->i_ino,
1116                                       pages[i]->index << PAGE_CACHE_SHIFT,
1117                                       kmap(pages[i]), PAGE_CACHE_SIZE);
1118                 kunmap(pages[i]);
1119                 SetPageChecked(pages[i]);
1120                 ret = btrfs_end_transaction(trans, root);
1121                 BUG_ON(ret);
1122                 mutex_unlock(&root->fs_info->fs_mutex);
1123
1124                 ret = nobh_commit_write(file, pages[i], offset,
1125                                          offset + this_write);
1126                 pos += this_write;
1127                 if (ret) {
1128                         err = ret;
1129                         goto failed;
1130                 }
1131                 WARN_ON(this_write > write_bytes);
1132                 write_bytes -= this_write;
1133         }
1134 failed:
1135         return err;
1136 }
1137
1138 static int prepare_pages(struct btrfs_trans_handle *trans,
1139                          struct btrfs_root *root,
1140                          struct file *file,
1141                          struct page **pages,
1142                          size_t num_pages,
1143                          loff_t pos,
1144                          size_t write_bytes)
1145 {
1146         int i;
1147         unsigned long index = pos >> PAGE_CACHE_SHIFT;
1148         struct inode *inode = file->f_path.dentry->d_inode;
1149         int offset;
1150         int err = 0;
1151         int ret;
1152         int this_write;
1153         loff_t isize = i_size_read(inode);
1154
1155         memset(pages, 0, num_pages * sizeof(struct page *));
1156
1157         for (i = 0; i < num_pages; i++) {
1158                 pages[i] = grab_cache_page(inode->i_mapping, index + i);
1159                 if (!pages[i]) {
1160                         err = -ENOMEM;
1161                         goto failed_release;
1162                 }
1163                 offset = pos & (PAGE_CACHE_SIZE -1);
1164                 this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
1165                 ret = nobh_prepare_write(pages[i], offset,
1166                                          offset + this_write,
1167                                          btrfs_get_block);
1168                 pos += this_write;
1169                 if (ret) {
1170                         err = ret;
1171                         goto failed_truncate;
1172                 }
1173                 WARN_ON(this_write > write_bytes);
1174                 write_bytes -= this_write;
1175         }
1176         return 0;
1177
1178 failed_release:
1179         btrfs_drop_pages(pages, num_pages);
1180         return err;
1181
1182 failed_truncate:
1183         btrfs_drop_pages(pages, num_pages);
1184         if (pos > isize)
1185                 vmtruncate(inode, isize);
1186         return err;
1187 }
1188
1189 static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
1190                                 size_t count, loff_t *ppos)
1191 {
1192         loff_t pos;
1193         size_t num_written = 0;
1194         int err = 0;
1195         int ret = 0;
1196         struct inode *inode = file->f_path.dentry->d_inode;
1197         struct btrfs_root *root = btrfs_sb(inode->i_sb);
1198         struct page *pages[1];
1199
1200         if (file->f_flags & O_DIRECT)
1201                 return -EINVAL;
1202         pos = *ppos;
1203
1204         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
1205         current->backing_dev_info = inode->i_mapping->backing_dev_info;
1206         err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
1207         if (err)
1208                 goto out;
1209         if (count == 0)
1210                 goto out;
1211         err = remove_suid(file->f_path.dentry);
1212         if (err)
1213                 goto out;
1214         file_update_time(file);
1215         mutex_lock(&inode->i_mutex);
1216         while(count > 0) {
1217                 size_t offset = pos & (PAGE_CACHE_SIZE - 1);
1218                 size_t write_bytes = min(count, PAGE_CACHE_SIZE - offset);
1219                 size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
1220                                         PAGE_CACHE_SHIFT;
1221                 ret = prepare_pages(NULL, root, file, pages, num_pages,
1222                                     pos, write_bytes);
1223                 BUG_ON(ret);
1224                 ret = btrfs_copy_from_user(pos, num_pages,
1225                                            write_bytes, pages, buf);
1226                 BUG_ON(ret);
1227
1228                 ret = dirty_and_release_pages(NULL, root, file, pages,
1229                                               num_pages, pos, write_bytes);
1230                 BUG_ON(ret);
1231                 btrfs_drop_pages(pages, num_pages);
1232
1233                 buf += write_bytes;
1234                 count -= write_bytes;
1235                 pos += write_bytes;
1236                 num_written += write_bytes;
1237
1238                 balance_dirty_pages_ratelimited(inode->i_mapping);
1239                 cond_resched();
1240         }
1241         mutex_unlock(&inode->i_mutex);
1242 out:
1243         *ppos = pos;
1244         current->backing_dev_info = NULL;
1245         return num_written ? num_written : err;
1246 }
1247
1248 static ssize_t inline_one_page(struct btrfs_root *root, struct inode *inode,
1249                            struct page *page, loff_t pos,
1250                            size_t offset, size_t write_bytes)
1251 {
1252         struct btrfs_path *path;
1253         struct btrfs_trans_handle *trans;
1254         struct btrfs_key key;
1255         struct btrfs_leaf *leaf;
1256         struct btrfs_key found_key;
1257         int ret;
1258         size_t copy_size = 0;
1259         char *dst = NULL;
1260         int err = 0;
1261         size_t num_written = 0;
1262
1263         path = btrfs_alloc_path();
1264         BUG_ON(!path);
1265         mutex_lock(&root->fs_info->fs_mutex);
1266         trans = btrfs_start_transaction(root, 1);
1267         key.objectid = inode->i_ino;
1268         key.flags = 0;
1269         btrfs_set_key_type(&key, BTRFS_INLINE_DATA_KEY);
1270
1271 again:
1272         key.offset = pos;
1273         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1274         if (ret < 0) {
1275                 err = ret;
1276                 goto out;
1277         }
1278         if (ret == 0) {
1279                 leaf = btrfs_buffer_leaf(path->nodes[0]);
1280                 btrfs_disk_key_to_cpu(&found_key,
1281                                       &leaf->items[path->slots[0]].key);
1282                 copy_size = btrfs_item_size(leaf->items + path->slots[0]);
1283                 dst = btrfs_item_ptr(leaf, path->slots[0], char);
1284                 copy_size = min(write_bytes, copy_size);
1285                 goto copyit;
1286         } else {
1287                 int slot = path->slots[0];
1288                 if (slot > 0) {
1289                         slot--;
1290                 }
1291                 // FIXME find max key
1292                 leaf = btrfs_buffer_leaf(path->nodes[0]);
1293                 btrfs_disk_key_to_cpu(&found_key,
1294                                       &leaf->items[slot].key);
1295                 if (found_key.objectid != inode->i_ino)
1296                         goto insert;
1297                 if (btrfs_key_type(&found_key) != BTRFS_INLINE_DATA_KEY)
1298                         goto insert;
1299                 copy_size = btrfs_item_size(leaf->items + slot);
1300                 if (found_key.offset + copy_size <= pos)
1301                         goto insert;
1302                 dst = btrfs_item_ptr(leaf, path->slots[0], char);
1303                 dst += pos - found_key.offset;
1304                 copy_size = copy_size - (pos - found_key.offset);
1305                 BUG_ON(copy_size < 0);
1306                 copy_size = min(write_bytes, copy_size);
1307                 WARN_ON(copy_size == 0);
1308                 goto copyit;
1309         }
1310 insert:
1311         btrfs_release_path(root, path);
1312         copy_size = min(write_bytes, (size_t)512);
1313         ret = btrfs_insert_empty_item(trans, root, path, &key, copy_size);
1314         BUG_ON(ret);
1315         dst = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
1316                              path->slots[0], char);
1317 copyit:
1318         WARN_ON(copy_size == 0);
1319         WARN_ON(dst + copy_size >
1320                 btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
1321                                                  path->slots[0], char) +
1322                 btrfs_item_size(btrfs_buffer_leaf(path->nodes[0])->items +
1323                                                   path->slots[0]));
1324         btrfs_memcpy(root, path->nodes[0]->b_data, dst,
1325                      page_address(page) + offset, copy_size);
1326         mark_buffer_dirty(path->nodes[0]);
1327         btrfs_release_path(root, path);
1328         pos += copy_size;
1329         offset += copy_size;
1330         num_written += copy_size;
1331         write_bytes -= copy_size;
1332         if (write_bytes)
1333                 goto again;
1334 out:
1335         btrfs_free_path(path);
1336         ret = btrfs_end_transaction(trans, root);
1337         BUG_ON(ret);
1338         mutex_unlock(&root->fs_info->fs_mutex);
1339         return num_written ? num_written : err;
1340 }
1341
1342 static ssize_t btrfs_file_inline_write(struct file *file,
1343                                        const char __user *buf,
1344                                        size_t count, loff_t *ppos)
1345 {
1346         loff_t pos;
1347         size_t num_written = 0;
1348         int err = 0;
1349         int ret = 0;
1350         struct inode *inode = file->f_path.dentry->d_inode;
1351         struct btrfs_root *root = btrfs_sb(inode->i_sb);
1352         unsigned long page_index;
1353
1354         if (file->f_flags & O_DIRECT)
1355                 return -EINVAL;
1356         pos = *ppos;
1357
1358         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
1359         current->backing_dev_info = inode->i_mapping->backing_dev_info;
1360         err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
1361         if (err)
1362                 goto out;
1363         if (count == 0)
1364                 goto out;
1365         err = remove_suid(file->f_path.dentry);
1366         if (err)
1367                 goto out;
1368         file_update_time(file);
1369         mutex_lock(&inode->i_mutex);
1370         while(count > 0) {
1371                 size_t offset = pos & (PAGE_CACHE_SIZE - 1);
1372                 size_t write_bytes = min(count, PAGE_CACHE_SIZE - offset);
1373                 struct page *page;
1374
1375                 page_index = pos >> PAGE_CACHE_SHIFT;
1376                 page = grab_cache_page(inode->i_mapping, page_index);
1377                 if (!PageUptodate(page)) {
1378                         ret = mpage_readpage(page, btrfs_get_block);
1379                         BUG_ON(ret);
1380                         lock_page(page);
1381                 }
1382                 ret = btrfs_copy_from_user(pos, 1,
1383                                            write_bytes, &page, buf);
1384                 BUG_ON(ret);
1385                 write_bytes = inline_one_page(root, inode, page, pos,
1386                                       offset, write_bytes);
1387                 SetPageUptodate(page);
1388                 if (write_bytes > 0 && pos + write_bytes > inode->i_size) {
1389                         i_size_write(inode, pos + write_bytes);
1390                         mark_inode_dirty(inode);
1391                 }
1392                 page_cache_release(page);
1393                 unlock_page(page);
1394                 if (write_bytes < 0)
1395                         goto out_unlock;
1396                 buf += write_bytes;
1397                 count -= write_bytes;
1398                 pos += write_bytes;
1399                 num_written += write_bytes;
1400
1401                 balance_dirty_pages_ratelimited(inode->i_mapping);
1402                 cond_resched();
1403         }
1404 out_unlock:
1405         mutex_unlock(&inode->i_mutex);
1406 out:
1407         *ppos = pos;
1408         current->backing_dev_info = NULL;
1409         return num_written ? num_written : err;
1410 }
1411
1412 static int btrfs_read_actor(read_descriptor_t *desc, struct page *page,
1413                         unsigned long offset, unsigned long size)
1414 {
1415         char *kaddr;
1416         unsigned long left, count = desc->count;
1417
1418         if (size > count)
1419                 size = count;
1420
1421         if (!PageChecked(page)) {
1422                 /* FIXME, do it per block */
1423                 struct btrfs_root *root = btrfs_sb(page->mapping->host->i_sb);
1424                 int ret = btrfs_csum_verify_file_block(root,
1425                                           page->mapping->host->i_ino,
1426                                           page->index << PAGE_CACHE_SHIFT,
1427                                           kmap(page), PAGE_CACHE_SIZE);
1428                 if (ret) {
1429                         printk("failed to verify ino %lu page %lu\n",
1430                                page->mapping->host->i_ino,
1431                                page->index);
1432                         memset(page_address(page), 0, PAGE_CACHE_SIZE);
1433                 }
1434                 SetPageChecked(page);
1435                 kunmap(page);
1436         }
1437         /*
1438          * Faults on the destination of a read are common, so do it before
1439          * taking the kmap.
1440          */
1441         if (!fault_in_pages_writeable(desc->arg.buf, size)) {
1442                 kaddr = kmap_atomic(page, KM_USER0);
1443                 left = __copy_to_user_inatomic(desc->arg.buf,
1444                                                 kaddr + offset, size);
1445                 kunmap_atomic(kaddr, KM_USER0);
1446                 if (left == 0)
1447                         goto success;
1448         }
1449
1450         /* Do it the slow way */
1451         kaddr = kmap(page);
1452         left = __copy_to_user(desc->arg.buf, kaddr + offset, size);
1453         kunmap(page);
1454
1455         if (left) {
1456                 size -= left;
1457                 desc->error = -EFAULT;
1458         }
1459 success:
1460         desc->count = count - size;
1461         desc->written += size;
1462         desc->arg.buf += size;
1463         return size;
1464 }
1465
1466 /**
1467  * btrfs_file_aio_read - filesystem read routine
1468  * @iocb:       kernel I/O control block
1469  * @iov:        io vector request
1470  * @nr_segs:    number of segments in the iovec
1471  * @pos:        current file position
1472  */
1473 static ssize_t btrfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1474                                    unsigned long nr_segs, loff_t pos)
1475 {
1476         struct file *filp = iocb->ki_filp;
1477         ssize_t retval;
1478         unsigned long seg;
1479         size_t count;
1480         loff_t *ppos = &iocb->ki_pos;
1481
1482         count = 0;
1483         for (seg = 0; seg < nr_segs; seg++) {
1484                 const struct iovec *iv = &iov[seg];
1485
1486                 /*
1487                  * If any segment has a negative length, or the cumulative
1488                  * length ever wraps negative then return -EINVAL.
1489                  */
1490                 count += iv->iov_len;
1491                 if (unlikely((ssize_t)(count|iv->iov_len) < 0))
1492                         return -EINVAL;
1493                 if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
1494                         continue;
1495                 if (seg == 0)
1496                         return -EFAULT;
1497                 nr_segs = seg;
1498                 count -= iv->iov_len;   /* This segment is no good */
1499                 break;
1500         }
1501         retval = 0;
1502         if (count) {
1503                 for (seg = 0; seg < nr_segs; seg++) {
1504                         read_descriptor_t desc;
1505
1506                         desc.written = 0;
1507                         desc.arg.buf = iov[seg].iov_base;
1508                         desc.count = iov[seg].iov_len;
1509                         if (desc.count == 0)
1510                                 continue;
1511                         desc.error = 0;
1512                         do_generic_file_read(filp, ppos, &desc,
1513                                              btrfs_read_actor);
1514                         retval += desc.written;
1515                         if (desc.error) {
1516                                 retval = retval ?: desc.error;
1517                                 break;
1518                         }
1519                 }
1520         }
1521         return retval;
1522 }
1523
1524 static struct kmem_cache *btrfs_inode_cachep;
1525 struct kmem_cache *btrfs_trans_handle_cachep;
1526 struct kmem_cache *btrfs_transaction_cachep;
1527 struct kmem_cache *btrfs_bit_radix_cachep;
1528 struct kmem_cache *btrfs_path_cachep;
1529
1530 /*
1531  * Called inside transaction, so use GFP_NOFS
1532  */
1533 static struct inode *btrfs_alloc_inode(struct super_block *sb)
1534 {
1535         struct btrfs_inode *ei;
1536
1537         ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
1538         if (!ei)
1539                 return NULL;
1540         ei->magic = 0xDEADBEEF;
1541         ei->magic2 = 0xDEADBEAF;
1542         return &ei->vfs_inode;
1543 }
1544
1545 static void btrfs_destroy_inode(struct inode *inode)
1546 {
1547         struct btrfs_inode *ei = BTRFS_I(inode);
1548         WARN_ON(ei->magic != 0xDEADBEEF);
1549         WARN_ON(ei->magic2 != 0xDEADBEAF);
1550         WARN_ON(!list_empty(&inode->i_dentry));
1551         WARN_ON(inode->i_data.nrpages);
1552
1553         ei->magic = 0;
1554         ei->magic2 = 0;
1555         kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
1556 }
1557
1558 static void init_once(void * foo, struct kmem_cache * cachep,
1559                       unsigned long flags)
1560 {
1561         struct btrfs_inode *ei = (struct btrfs_inode *) foo;
1562
1563         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
1564             SLAB_CTOR_CONSTRUCTOR) {
1565                 inode_init_once(&ei->vfs_inode);
1566         }
1567 }
1568
1569 static int init_inodecache(void)
1570 {
1571         btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
1572                                              sizeof(struct btrfs_inode),
1573                                              0, (SLAB_RECLAIM_ACCOUNT|
1574                                                 SLAB_MEM_SPREAD),
1575                                              init_once, NULL);
1576         btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
1577                                              sizeof(struct btrfs_trans_handle),
1578                                              0, (SLAB_RECLAIM_ACCOUNT|
1579                                                 SLAB_MEM_SPREAD),
1580                                              NULL, NULL);
1581         btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
1582                                              sizeof(struct btrfs_transaction),
1583                                              0, (SLAB_RECLAIM_ACCOUNT|
1584                                                 SLAB_MEM_SPREAD),
1585                                              NULL, NULL);
1586         btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
1587                                              sizeof(struct btrfs_transaction),
1588                                              0, (SLAB_RECLAIM_ACCOUNT|
1589                                                 SLAB_MEM_SPREAD),
1590                                              NULL, NULL);
1591         btrfs_bit_radix_cachep = kmem_cache_create("btrfs_radix",
1592                                              256,
1593                                              0, (SLAB_RECLAIM_ACCOUNT|
1594                                                 SLAB_MEM_SPREAD |
1595                                                 SLAB_DESTROY_BY_RCU),
1596                                              NULL, NULL);
1597         if (btrfs_inode_cachep == NULL || btrfs_trans_handle_cachep == NULL ||
1598             btrfs_transaction_cachep == NULL || btrfs_bit_radix_cachep == NULL)
1599                 return -ENOMEM;
1600         return 0;
1601 }
1602
1603 static void destroy_inodecache(void)
1604 {
1605         kmem_cache_destroy(btrfs_inode_cachep);
1606         kmem_cache_destroy(btrfs_trans_handle_cachep);
1607         kmem_cache_destroy(btrfs_transaction_cachep);
1608         kmem_cache_destroy(btrfs_bit_radix_cachep);
1609         kmem_cache_destroy(btrfs_path_cachep);
1610 }
1611
1612 static int btrfs_get_sb(struct file_system_type *fs_type,
1613         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1614 {
1615         return get_sb_bdev(fs_type, flags, dev_name, data,
1616                            btrfs_fill_super, mnt);
1617 }
1618
1619 static struct file_system_type btrfs_fs_type = {
1620         .owner          = THIS_MODULE,
1621         .name           = "btrfs",
1622         .get_sb         = btrfs_get_sb,
1623         .kill_sb        = kill_block_super,
1624         .fs_flags       = FS_REQUIRES_DEV,
1625 };
1626
1627 static struct super_operations btrfs_super_ops = {
1628         .statfs         = simple_statfs,
1629         .delete_inode   = btrfs_delete_inode,
1630         .put_super      = btrfs_put_super,
1631         .read_inode     = btrfs_read_locked_inode,
1632         .write_super    = btrfs_write_super,
1633         .sync_fs        = btrfs_sync_fs,
1634         .write_inode    = btrfs_write_inode,
1635         .alloc_inode    = btrfs_alloc_inode,
1636         .destroy_inode  = btrfs_destroy_inode,
1637 };
1638
1639 static struct inode_operations btrfs_dir_inode_operations = {
1640         .lookup         = btrfs_lookup,
1641         .create         = btrfs_create,
1642         .unlink         = btrfs_unlink,
1643         .mkdir          = btrfs_mkdir,
1644         .rmdir          = btrfs_rmdir,
1645 };
1646
1647 static struct file_operations btrfs_dir_file_operations = {
1648         .llseek         = generic_file_llseek,
1649         .read           = generic_read_dir,
1650         .readdir        = btrfs_readdir,
1651 };
1652
1653 static struct address_space_operations btrfs_aops = {
1654         .readpage       = btrfs_readpage,
1655         // .readpages   = btrfs_readpages,
1656         .writepage      = btrfs_writepage,
1657         .sync_page      = block_sync_page,
1658         .prepare_write  = btrfs_prepare_write,
1659         .commit_write   = btrfs_commit_write,
1660 };
1661
1662 static struct inode_operations btrfs_file_inode_operations = {
1663         .truncate       = btrfs_truncate,
1664 };
1665
1666 static struct file_operations btrfs_file_operations = {
1667         .llseek         = generic_file_llseek,
1668         .read           = do_sync_read,
1669         .aio_read       = generic_file_aio_read,
1670         .write          = btrfs_file_inline_write,
1671         .mmap           = generic_file_mmap,
1672         .open           = generic_file_open,
1673 };
1674
1675 static int __init init_btrfs_fs(void)
1676 {
1677         int err;
1678         printk("btrfs loaded!\n");
1679         err = init_inodecache();
1680         if (err)
1681                 return err;
1682         return register_filesystem(&btrfs_fs_type);
1683 }
1684
1685 static void __exit exit_btrfs_fs(void)
1686 {
1687         destroy_inodecache();
1688         unregister_filesystem(&btrfs_fs_type);
1689         printk("btrfs unloaded\n");
1690 }
1691
1692 module_init(init_btrfs_fs)
1693 module_exit(exit_btrfs_fs)
1694
1695 MODULE_LICENSE("GPL");