SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <linux/statfs.h>
  15 #include "ctree.h"
  16 #include "disk-io.h"
  17 #include "transaction.h"
  18 #include "btrfs_inode.h"
  19 #include "ioctl.h"
  20
  21 void btrfs_fsinfo_release(struct kobject *obj)
  22 {
  23         struct btrfs_fs_info *fsinfo = container_of(obj,
  24                                             struct btrfs_fs_info, kobj);
  25         kfree(fsinfo);
  26 }
  27
  28 struct kobj_type btrfs_fsinfo_ktype = {
  29         .release = btrfs_fsinfo_release,
  30 };
  31
  32 struct btrfs_iget_args {
  33         u64 ino;
  34         struct btrfs_root *root;
  35 };
  36
  37 decl_subsys(btrfs, &btrfs_fsinfo_ktype, NULL);
  38
  39 #define BTRFS_SUPER_MAGIC 0x9123682E
  40
  41 static struct inode_operations btrfs_dir_inode_operations;
  42 static struct inode_operations btrfs_dir_ro_inode_operations;
  43 static struct super_operations btrfs_super_ops;
  44 static struct file_operations btrfs_dir_file_operations;
  45 static struct inode_operations btrfs_file_inode_operations;
  46 static struct address_space_operations btrfs_aops;
  47 static struct file_operations btrfs_file_operations;
  48
  49 static void btrfs_read_locked_inode(struct inode *inode)
  50 {
  51         struct btrfs_path *path;
  52         struct btrfs_inode_item *inode_item;
  53         struct btrfs_root *root = BTRFS_I(inode)->root;
  54         struct btrfs_key location;
  55         int ret;
  56
  57         path = btrfs_alloc_path();
  58         BUG_ON(!path);
  59         btrfs_init_path(path);
  60         mutex_lock(&root->fs_info->fs_mutex);
  61
  62         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
  63         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
  64         if (ret) {
  65                 btrfs_free_path(path);
  66                 goto make_bad;
  67         }
  68         inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
  69                                   path->slots[0],
  70                                   struct btrfs_inode_item);
  71
  72         inode->i_mode = btrfs_inode_mode(inode_item);
  73         inode->i_nlink = btrfs_inode_nlink(inode_item);
  74         inode->i_uid = btrfs_inode_uid(inode_item);
  75         inode->i_gid = btrfs_inode_gid(inode_item);
  76         inode->i_size = btrfs_inode_size(inode_item);
  77         inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
  78         inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
  79         inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
  80         inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
  81         inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
  82         inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
  83         inode->i_blocks = btrfs_inode_nblocks(inode_item);
  84         inode->i_generation = btrfs_inode_generation(inode_item);
  85
  86         btrfs_free_path(path);
  87         inode_item = NULL;
  88
  89         mutex_unlock(&root->fs_info->fs_mutex);
  90
  91         switch (inode->i_mode & S_IFMT) {
  92 #if 0
  93         default:
  94                 init_special_inode(inode, inode->i_mode,
  95                                    btrfs_inode_rdev(inode_item));
  96                 break;
  97 #endif
  98         case S_IFREG:
  99                 inode->i_mapping->a_ops = &btrfs_aops;
 100                 inode->i_fop = &btrfs_file_operations;
 101                 inode->i_op = &btrfs_file_inode_operations;
 102                 break;
 103         case S_IFDIR:
 104                 inode->i_fop = &btrfs_dir_file_operations;
 105                 if (root == root->fs_info->tree_root)
 106                         inode->i_op = &btrfs_dir_ro_inode_operations;
 107                 else
 108                         inode->i_op = &btrfs_dir_inode_operations;
 109                 break;
 110         case S_IFLNK:
 111                 // inode->i_op = &page_symlink_inode_operations;
 112                 break;
 113         }
 114         return;
 115
 116 make_bad:
 117         btrfs_release_path(root, path);
 118         btrfs_free_path(path);
 119         mutex_unlock(&root->fs_info->fs_mutex);
 120         make_bad_inode(inode);
 121 }
 122
 123 static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
 124                               struct btrfs_root *root,
 125                               struct inode *dir,
 126                               struct dentry *dentry)
 127 {
 128         struct btrfs_path *path;
 129         const char *name = dentry->d_name.name;
 130         int name_len = dentry->d_name.len;
 131         int ret = 0;
 132         u64 objectid;
 133         struct btrfs_dir_item *di;
 134
 135         path = btrfs_alloc_path();
 136         BUG_ON(!path);
 137         btrfs_init_path(path);
 138         di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
 139                                     name, name_len, -1);
 140         if (IS_ERR(di)) {
 141                 ret = PTR_ERR(di);
 142                 goto err;
 143         }
 144         if (!di) {
 145                 ret = -ENOENT;
 146                 goto err;
 147         }
 148         objectid = btrfs_disk_key_objectid(&di->location);
 149         ret = btrfs_delete_one_dir_name(trans, root, path, di);
 150         BUG_ON(ret);
 151         btrfs_release_path(root, path);
 152
 153         di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
 154                                          objectid, name, name_len, -1);
 155         if (IS_ERR(di)) {
 156                 ret = PTR_ERR(di);
 157                 goto err;
 158         }
 159         if (!di) {
 160                 ret = -ENOENT;
 161                 goto err;
 162         }
 163         ret = btrfs_delete_one_dir_name(trans, root, path, di);
 164         BUG_ON(ret);
 165
 166         dentry->d_inode->i_ctime = dir->i_ctime;
 167 err:
 168         btrfs_free_path(path);
 169         if (ret == 0) {
 170                 inode_dec_link_count(dentry->d_inode);
 171                 dir->i_size -= name_len * 2;
 172                 mark_inode_dirty(dir);
 173         }
 174         return ret;
 175 }
 176
 177 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 178 {
 179         struct btrfs_root *root;
 180         struct btrfs_trans_handle *trans;
 181         int ret;
 182
 183         root = BTRFS_I(dir)->root;
 184         mutex_lock(&root->fs_info->fs_mutex);
 185         trans = btrfs_start_transaction(root, 1);
 186         ret = btrfs_unlink_trans(trans, root, dir, dentry);
 187         btrfs_end_transaction(trans, root);
 188         mutex_unlock(&root->fs_info->fs_mutex);
 189         return ret;
 190 }
 191
 192 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 193 {
 194         struct inode *inode = dentry->d_inode;
 195         int err;
 196         int ret;
 197         struct btrfs_root *root = BTRFS_I(dir)->root;
 198         struct btrfs_path *path;
 199         struct btrfs_key key;
 200         struct btrfs_trans_handle *trans;
 201         struct btrfs_key found_key;
 202         int found_type;
 203         struct btrfs_leaf *leaf;
 204         char *goodnames = "..";
 205
 206         path = btrfs_alloc_path();
 207         BUG_ON(!path);
 208         btrfs_init_path(path);
 209         mutex_lock(&root->fs_info->fs_mutex);
 210         trans = btrfs_start_transaction(root, 1);
 211         key.objectid = inode->i_ino;
 212         key.offset = (u64)-1;
 213         key.flags = (u32)-1;
 214         while(1) {
 215                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 216                 if (ret < 0) {
 217                         err = ret;
 218                         goto out;
 219                 }
 220                 BUG_ON(ret == 0);
 221                 if (path->slots[0] == 0) {
 222                         err = -ENOENT;
 223                         goto out;
 224                 }
 225                 path->slots[0]--;
 226                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 227                 btrfs_disk_key_to_cpu(&found_key,
 228                                       &leaf->items[path->slots[0]].key);
 229                 found_type = btrfs_key_type(&found_key);
 230                 if (found_key.objectid != inode->i_ino) {
 231                         err = -ENOENT;
 232                         goto out;
 233                 }
 234                 if ((found_type != BTRFS_DIR_ITEM_KEY &&
 235                      found_type != BTRFS_DIR_INDEX_KEY) ||
 236                     (!btrfs_match_dir_item_name(root, path, goodnames, 2) &&
 237                     !btrfs_match_dir_item_name(root, path, goodnames, 1))) {
 238                         err = -ENOTEMPTY;
 239                         goto out;
 240                 }
 241                 ret = btrfs_del_item(trans, root, path);
 242                 BUG_ON(ret);
 243
 244                 if (found_type == BTRFS_DIR_ITEM_KEY && found_key.offset == 1)
 245                         break;
 246                 btrfs_release_path(root, path);
 247         }
 248         ret = 0;
 249         btrfs_release_path(root, path);
 250
 251         /* now the directory is empty */
 252         err = btrfs_unlink_trans(trans, root, dir, dentry);
 253         if (!err) {
 254                 inode->i_size = 0;
 255         }
 256 out:
 257         btrfs_release_path(root, path);
 258         btrfs_free_path(path);
 259         mutex_unlock(&root->fs_info->fs_mutex);
 260         ret = btrfs_end_transaction(trans, root);
 261         if (ret && !err)
 262                 err = ret;
 263         return err;
 264 }
 265
 266 static int btrfs_free_inode(struct btrfs_trans_handle *trans,
 267                             struct btrfs_root *root,
 268                             struct inode *inode)
 269 {
 270         struct btrfs_path *path;
 271         int ret;
 272
 273         clear_inode(inode);
 274
 275         path = btrfs_alloc_path();
 276         BUG_ON(!path);
 277         btrfs_init_path(path);
 278         ret = btrfs_lookup_inode(trans, root, path,
 279                                  &BTRFS_I(inode)->location, -1);
 280         BUG_ON(ret);
 281         ret = btrfs_del_item(trans, root, path);
 282         BUG_ON(ret);
 283         btrfs_free_path(path);
 284         return ret;
 285 }
 286
 287 static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
 288                                    struct btrfs_root *root,
 289                                    struct inode *inode)
 290 {
 291         int ret;
 292         struct btrfs_path *path;
 293         struct btrfs_key key;
 294         struct btrfs_disk_key *found_key;
 295         struct btrfs_leaf *leaf;
 296         struct btrfs_file_extent_item *fi = NULL;
 297         u64 extent_start = 0;
 298         u64 extent_num_blocks = 0;
 299         int found_extent;
 300
 301         path = btrfs_alloc_path();
 302         BUG_ON(!path);
 303         /* FIXME, add redo link to tree so we don't leak on crash */
 304         key.objectid = inode->i_ino;
 305         key.offset = (u64)-1;
 306         key.flags = 0;
 307         /*
 308          * use BTRFS_CSUM_ITEM_KEY because it is larger than inline keys
 309          * or extent data
 310          */
 311         btrfs_set_key_type(&key, BTRFS_CSUM_ITEM_KEY);
 312         while(1) {
 313                 btrfs_init_path(path);
 314                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 315                 if (ret < 0) {
 316                         goto error;
 317                 }
 318                 if (ret > 0) {
 319                         BUG_ON(path->slots[0] == 0);
 320                         path->slots[0]--;
 321                 }
 322                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 323                 found_key = &leaf->items[path->slots[0]].key;
 324                 if (btrfs_disk_key_objectid(found_key) != inode->i_ino)
 325                         break;
 326                 if (btrfs_disk_key_type(found_key) != BTRFS_CSUM_ITEM_KEY &&
 327                     btrfs_disk_key_type(found_key) != BTRFS_INLINE_DATA_KEY &&
 328                     btrfs_disk_key_type(found_key) != BTRFS_EXTENT_DATA_KEY)
 329                         break;
 330                 if (btrfs_disk_key_offset(found_key) < inode->i_size)
 331                         break;
 332                 found_extent = 0;
 333                 if (btrfs_disk_key_type(found_key) == BTRFS_EXTENT_DATA_KEY) {
 334                         fi = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
 335                                             path->slots[0],
 336                                             struct btrfs_file_extent_item);
 337                         if (btrfs_file_extent_type(fi) !=
 338                             BTRFS_FILE_EXTENT_INLINE) {
 339                                 extent_start =
 340                                         btrfs_file_extent_disk_blocknr(fi);
 341                                 extent_num_blocks =
 342                                         btrfs_file_extent_disk_num_blocks(fi);
 343                                 /* FIXME blocksize != 4096 */
 344                                 inode->i_blocks -=
 345                                         btrfs_file_extent_num_blocks(fi) << 3;
 346                                 found_extent = 1;
 347                         }
 348                 }
 349                 ret = btrfs_del_item(trans, root, path);
 350                 BUG_ON(ret);
 351                 btrfs_release_path(root, path);
 352                 if (found_extent) {
 353                         ret = btrfs_free_extent(trans, root, extent_start,
 354                                                 extent_num_blocks, 0);
 355                         BUG_ON(ret);
 356                 }
 357         }
 358         ret = 0;
 359 error:
 360         btrfs_release_path(root, path);
 361         btrfs_free_path(path);
 362         return ret;
 363 }
 364
 365 static void btrfs_delete_inode(struct inode *inode)
 366 {
 367         struct btrfs_trans_handle *trans;
 368         struct btrfs_root *root = BTRFS_I(inode)->root;
 369         int ret;
 370
 371         truncate_inode_pages(&inode->i_data, 0);
 372         if (is_bad_inode(inode)) {
 373                 goto no_delete;
 374         }
 375         inode->i_size = 0;
 376         mutex_lock(&root->fs_info->fs_mutex);
 377         trans = btrfs_start_transaction(root, 1);
 378         if (S_ISREG(inode->i_mode)) {
 379                 ret = btrfs_truncate_in_trans(trans, root, inode);
 380                 BUG_ON(ret);
 381         }
 382         btrfs_free_inode(trans, root, inode);
 383         btrfs_end_transaction(trans, root);
 384         mutex_unlock(&root->fs_info->fs_mutex);
 385         return;
 386 no_delete:
 387         clear_inode(inode);
 388 }
 389
 390 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
 391                                struct btrfs_key *location)
 392 {
 393         const char *name = dentry->d_name.name;
 394         int namelen = dentry->d_name.len;
 395         struct btrfs_dir_item *di;
 396         struct btrfs_path *path;
 397         struct btrfs_root *root = BTRFS_I(dir)->root;
 398         int ret;
 399
 400         path = btrfs_alloc_path();
 401         BUG_ON(!path);
 402         btrfs_init_path(path);
 403         di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
 404                                     namelen, 0);
 405         if (!di || IS_ERR(di)) {
 406                 location->objectid = 0;
 407                 ret = 0;
 408                 goto out;
 409         }
 410         btrfs_disk_key_to_cpu(location, &di->location);
 411 out:
 412         btrfs_release_path(root, path);
 413         btrfs_free_path(path);
 414         return ret;
 415 }
 416
 417 int fixup_tree_root_location(struct btrfs_root *root,
 418                              struct btrfs_key *location,
 419                              struct btrfs_root **sub_root)
 420 {
 421         struct btrfs_path *path;
 422         struct btrfs_root_item *ri;
 423
 424         if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
 425                 return 0;
 426         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
 427                 return 0;
 428
 429         path = btrfs_alloc_path();
 430         BUG_ON(!path);
 431         mutex_lock(&root->fs_info->fs_mutex);
 432
 433         *sub_root = btrfs_read_fs_root(root->fs_info, location);
 434         if (IS_ERR(*sub_root))
 435                 return PTR_ERR(*sub_root);
 436
 437         ri = &(*sub_root)->root_item;
 438         location->objectid = btrfs_root_dirid(ri);
 439         location->flags = 0;
 440         btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
 441         location->offset = 0;
 442
 443         btrfs_free_path(path);
 444         mutex_unlock(&root->fs_info->fs_mutex);
 445         return 0;
 446 }
 447
 448 int btrfs_init_locked_inode(struct inode *inode, void *p)
 449 {
 450         struct btrfs_iget_args *args = p;
 451         inode->i_ino = args->ino;
 452         BTRFS_I(inode)->root = args->root;
 453         return 0;
 454 }
 455
 456 int btrfs_find_actor(struct inode *inode, void *opaque)
 457 {
 458         struct btrfs_iget_args *args = opaque;
 459         return (args->ino == inode->i_ino &&
 460                 args->root == BTRFS_I(inode)->root);
 461 }
 462
 463 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
 464                                 struct btrfs_root *root)
 465 {
 466         struct inode *inode;
 467         struct btrfs_iget_args args;
 468         args.ino = objectid;
 469         args.root = root;
 470
 471         inode = iget5_locked(s, objectid, btrfs_find_actor,
 472                              btrfs_init_locked_inode,
 473                              (void *)&args);
 474         return inode;
 475 }
 476
 477 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
 478                                    struct nameidata *nd)
 479 {
 480         struct inode * inode;
 481         struct btrfs_inode *bi = BTRFS_I(dir);
 482         struct btrfs_root *root = bi->root;
 483         struct btrfs_root *sub_root = root;
 484         struct btrfs_key location;
 485         int ret;
 486
 487         if (dentry->d_name.len > BTRFS_NAME_LEN)
 488                 return ERR_PTR(-ENAMETOOLONG);
 489         mutex_lock(&root->fs_info->fs_mutex);
 490         ret = btrfs_inode_by_name(dir, dentry, &location);
 491         mutex_unlock(&root->fs_info->fs_mutex);
 492         if (ret < 0)
 493                 return ERR_PTR(ret);
 494         inode = NULL;
 495         if (location.objectid) {
 496                 ret = fixup_tree_root_location(root, &location, &sub_root);
 497                 if (ret < 0)
 498                         return ERR_PTR(ret);
 499                 if (ret > 0)
 500                         return ERR_PTR(-ENOENT);
 501                 inode = btrfs_iget_locked(dir->i_sb, location.objectid,
 502                                           sub_root);
 503                 if (!inode)
 504                         return ERR_PTR(-EACCES);
 505                 if (inode->i_state & I_NEW) {
 506                         if (sub_root != root) {
 507 printk("adding new root for inode %lu root %p (found %p)\n", inode->i_ino, sub_root, BTRFS_I(inode)->root);
 508                                 igrab(inode);
 509                                 sub_root->inode = inode;
 510                         }
 511                         BTRFS_I(inode)->root = sub_root;
 512                         memcpy(&BTRFS_I(inode)->location, &location,
 513                                sizeof(location));
 514                         btrfs_read_locked_inode(inode);
 515                         unlock_new_inode(inode);
 516                 }
 517         }
 518         return d_splice_alias(inode, dentry);
 519 }
 520
 521 static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 522 {
 523         struct inode *inode = filp->f_path.dentry->d_inode;
 524         struct btrfs_root *root = BTRFS_I(inode)->root;
 525         struct btrfs_item *item;
 526         struct btrfs_dir_item *di;
 527         struct btrfs_key key;
 528         struct btrfs_path *path;
 529         int ret;
 530         u32 nritems;
 531         struct btrfs_leaf *leaf;
 532         int slot;
 533         int advance;
 534         unsigned char d_type = DT_UNKNOWN;
 535         int over = 0;
 536         u32 di_cur;
 537         u32 di_total;
 538         u32 di_len;
 539         int key_type = BTRFS_DIR_INDEX_KEY;
 540
 541         /* FIXME, use a real flag for deciding about the key type */
 542         if (root->fs_info->tree_root == root)
 543                 key_type = BTRFS_DIR_ITEM_KEY;
 544         mutex_lock(&root->fs_info->fs_mutex);
 545         key.objectid = inode->i_ino;
 546         key.flags = 0;
 547         btrfs_set_key_type(&key, key_type);
 548         key.offset = filp->f_pos;
 549         path = btrfs_alloc_path();
 550         btrfs_init_path(path);
 551         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 552         if (ret < 0)
 553                 goto err;
 554         advance = 0;
 555         while(1) {
 556                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 557                 nritems = btrfs_header_nritems(&leaf->header);
 558                 slot = path->slots[0];
 559                 if (advance || slot >= nritems) {
 560                         if (slot >= nritems -1) {
 561                                 ret = btrfs_next_leaf(root, path);
 562                                 if (ret)
 563                                         break;
 564                                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 565                                 nritems = btrfs_header_nritems(&leaf->header);
 566                                 slot = path->slots[0];
 567                         } else {
 568                                 slot++;
 569                                 path->slots[0]++;
 570                         }
 571                 }
 572                 advance = 1;
 573                 item = leaf->items + slot;
 574                 if (btrfs_disk_key_objectid(&item->key) != key.objectid)
 575                         break;
 576                 if (btrfs_disk_key_type(&item->key) != key_type)
 577                         break;
 578                 if (btrfs_disk_key_offset(&item->key) < filp->f_pos)
 579                         continue;
 580                 filp->f_pos = btrfs_disk_key_offset(&item->key);
 581                 advance = 1;
 582                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
 583                 di_cur = 0;
 584                 di_total = btrfs_item_size(leaf->items + slot);
 585                 while(di_cur < di_total) {
 586                         over = filldir(dirent, (const char *)(di + 1),
 587                                        btrfs_dir_name_len(di),
 588                                        btrfs_disk_key_offset(&item->key),
 589                                        btrfs_disk_key_objectid(&di->location),
 590                                        d_type);
 591                         if (over)
 592                                 goto nopos;
 593                         di_len = btrfs_dir_name_len(di) + sizeof(*di);
 594                         di_cur += di_len;
 595                         di = (struct btrfs_dir_item *)((char *)di + di_len);
 596                 }
 597         }
 598         filp->f_pos++;
 599 nopos:
 600         ret = 0;
 601 err:
 602         btrfs_release_path(root, path);
 603         btrfs_free_path(path);
 604         mutex_unlock(&root->fs_info->fs_mutex);
 605         return ret;
 606 }
 607
 608 static void btrfs_put_super (struct super_block * sb)
 609 {
 610         struct btrfs_root *root = btrfs_sb(sb);
 611         int ret;
 612
 613         ret = close_ctree(root);
 614         if (ret) {
 615                 printk("close ctree returns %d\n", ret);
 616         }
 617         sb->s_fs_info = NULL;
 618 }
 619
 620 static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
 621 {
 622         struct inode * inode;
 623         struct dentry * root_dentry;
 624         struct btrfs_super_block *disk_super;
 625         struct btrfs_root *tree_root;
 626         struct btrfs_inode *bi;
 627
 628         sb->s_maxbytes = MAX_LFS_FILESIZE;
 629         sb->s_magic = BTRFS_SUPER_MAGIC;
 630         sb->s_op = &btrfs_super_ops;
 631         sb->s_time_gran = 1;
 632
 633         tree_root = open_ctree(sb);
 634
 635         if (!tree_root) {
 636                 printk("btrfs: open_ctree failed\n");
 637                 return -EIO;
 638         }
 639         sb->s_fs_info = tree_root;
 640         disk_super = tree_root->fs_info->disk_super;
 641         printk("read in super total blocks %Lu root %Lu\n",
 642                btrfs_super_total_blocks(disk_super),
 643                btrfs_super_root_dir(disk_super));
 644
 645         inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
 646                                   tree_root);
 647         bi = BTRFS_I(inode);
 648         bi->location.objectid = inode->i_ino;
 649         bi->location.offset = 0;
 650         bi->location.flags = 0;
 651         bi->root = tree_root;
 652         btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
 653
 654         if (!inode)
 655                 return -ENOMEM;
 656         if (inode->i_state & I_NEW) {
 657                 btrfs_read_locked_inode(inode);
 658                 unlock_new_inode(inode);
 659         }
 660
 661         root_dentry = d_alloc_root(inode);
 662         if (!root_dentry) {
 663                 iput(inode);
 664                 return -ENOMEM;
 665         }
 666         sb->s_root = root_dentry;
 667
 668         return 0;
 669 }
 670
 671 static void fill_inode_item(struct btrfs_inode_item *item,
 672                             struct inode *inode)
 673 {
 674         btrfs_set_inode_uid(item, inode->i_uid);
 675         btrfs_set_inode_gid(item, inode->i_gid);
 676         btrfs_set_inode_size(item, inode->i_size);
 677         btrfs_set_inode_mode(item, inode->i_mode);
 678         btrfs_set_inode_nlink(item, inode->i_nlink);
 679         btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
 680         btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
 681         btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
 682         btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
 683         btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
 684         btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
 685         btrfs_set_inode_nblocks(item, inode->i_blocks);
 686         btrfs_set_inode_generation(item, inode->i_generation);
 687 }
 688
 689 static int btrfs_update_inode(struct btrfs_trans_handle *trans,
 690                               struct btrfs_root *root,
 691                               struct inode *inode)
 692 {
 693         struct btrfs_inode_item *inode_item;
 694         struct btrfs_path *path;
 695         int ret;
 696
 697         path = btrfs_alloc_path();
 698         BUG_ON(!path);
 699         btrfs_init_path(path);
 700         ret = btrfs_lookup_inode(trans, root, path,
 701                                  &BTRFS_I(inode)->location, 1);
 702         if (ret) {
 703                 if (ret > 0)
 704                         ret = -ENOENT;
 705                 goto failed;
 706         }
 707
 708         inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
 709                                   path->slots[0],
 710                                   struct btrfs_inode_item);
 711
 712         fill_inode_item(inode_item, inode);
 713         btrfs_mark_buffer_dirty(path->nodes[0]);
 714         ret = 0;
 715 failed:
 716         btrfs_release_path(root, path);
 717         btrfs_free_path(path);
 718         return ret;
 719 }
 720
 721 static int btrfs_write_inode(struct inode *inode, int wait)
 722 {
 723         struct btrfs_root *root = BTRFS_I(inode)->root;
 724         struct btrfs_trans_handle *trans;
 725         int ret;
 726
 727         mutex_lock(&root->fs_info->fs_mutex);
 728         trans = btrfs_start_transaction(root, 1);
 729         ret = btrfs_update_inode(trans, root, inode);
 730         if (wait)
 731                 btrfs_commit_transaction(trans, root);
 732         else
 733                 btrfs_end_transaction(trans, root);
 734         mutex_unlock(&root->fs_info->fs_mutex);
 735         return ret;
 736 }
 737
 738 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
 739                                      struct btrfs_root *root,
 740                                      u64 objectid, int mode)
 741 {
 742         struct inode *inode;
 743         struct btrfs_inode_item inode_item;
 744         struct btrfs_key *location;
 745         int ret;
 746
 747         inode = new_inode(root->fs_info->sb);
 748         if (!inode)
 749                 return ERR_PTR(-ENOMEM);
 750
 751         BTRFS_I(inode)->root = root;
 752
 753         inode->i_uid = current->fsuid;
 754         inode->i_gid = current->fsgid;
 755         inode->i_mode = mode;
 756         inode->i_ino = objectid;
 757         inode->i_blocks = 0;
 758         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 759         fill_inode_item(&inode_item, inode);
 760         location = &BTRFS_I(inode)->location;
 761         location->objectid = objectid;
 762         location->flags = 0;
 763         location->offset = 0;
 764         btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
 765
 766         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
 767         BUG_ON(ret);
 768
 769         insert_inode_hash(inode);
 770         return inode;
 771 }
 772
 773 static int btrfs_add_link(struct btrfs_trans_handle *trans,
 774                             struct dentry *dentry, struct inode *inode)
 775 {
 776         int ret;
 777         struct btrfs_key key;
 778         struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
 779         key.objectid = inode->i_ino;
 780         key.flags = 0;
 781         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
 782         key.offset = 0;
 783
 784         ret = btrfs_insert_dir_item(trans, root,
 785                                     dentry->d_name.name, dentry->d_name.len,
 786                                     dentry->d_parent->d_inode->i_ino,
 787                                     &key, 0);
 788         if (ret == 0) {
 789                 dentry->d_parent->d_inode->i_size += dentry->d_name.len * 2;
 790                 ret = btrfs_update_inode(trans, root,
 791                                          dentry->d_parent->d_inode);
 792         }
 793         return ret;
 794 }
 795
 796 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
 797                             struct dentry *dentry, struct inode *inode)
 798 {
 799         int err = btrfs_add_link(trans, dentry, inode);
 800         if (!err) {
 801                 d_instantiate(dentry, inode);
 802                 return 0;
 803         }
 804         if (err > 0)
 805                 err = -EEXIST;
 806         return err;
 807 }
 808
 809 static int btrfs_create(struct inode *dir, struct dentry *dentry,
 810                         int mode, struct nameidata *nd)
 811 {
 812         struct btrfs_trans_handle *trans;
 813         struct btrfs_root *root = BTRFS_I(dir)->root;
 814         struct inode *inode;
 815         int err;
 816         int drop_inode = 0;
 817         u64 objectid;
 818
 819         mutex_lock(&root->fs_info->fs_mutex);
 820         trans = btrfs_start_transaction(root, 1);
 821
 822         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
 823         if (err) {
 824                 err = -ENOSPC;
 825                 goto out_unlock;
 826         }
 827
 828         inode = btrfs_new_inode(trans, root, objectid, mode);
 829         err = PTR_ERR(inode);
 830         if (IS_ERR(inode))
 831                 goto out_unlock;
 832         // FIXME mark the inode dirty
 833         err = btrfs_add_nondir(trans, dentry, inode);
 834         if (err)
 835                 drop_inode = 1;
 836         else {
 837                 inode->i_mapping->a_ops = &btrfs_aops;
 838                 inode->i_fop = &btrfs_file_operations;
 839                 inode->i_op = &btrfs_file_inode_operations;
 840         }
 841         dir->i_sb->s_dirt = 1;
 842 out_unlock:
 843         btrfs_end_transaction(trans, root);
 844         mutex_unlock(&root->fs_info->fs_mutex);
 845
 846         if (drop_inode) {
 847                 inode_dec_link_count(inode);
 848                 iput(inode);
 849         }
 850         return err;
 851 }
 852
 853 static int btrfs_make_empty_dir(struct btrfs_trans_handle *trans,
 854                                 struct btrfs_root *root,
 855                                 u64 objectid, u64 dirid)
 856 {
 857         int ret;
 858         char buf[2];
 859         struct btrfs_key key;
 860
 861         buf[0] = '.';
 862         buf[1] = '.';
 863
 864         key.objectid = objectid;
 865         key.offset = 0;
 866         key.flags = 0;
 867         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
 868
 869         ret = btrfs_insert_dir_item(trans, root, buf, 1, objectid,
 870                                     &key, 1);
 871         if (ret)
 872                 goto error;
 873         key.objectid = dirid;
 874         ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
 875                                     &key, 1);
 876         if (ret)
 877                 goto error;
 878 error:
 879         return ret;
 880 }
 881
 882 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 883 {
 884         struct inode *inode;
 885         struct btrfs_trans_handle *trans;
 886         struct btrfs_root *root = BTRFS_I(dir)->root;
 887         int err = 0;
 888         int drop_on_err = 0;
 889         u64 objectid;
 890
 891         mutex_lock(&root->fs_info->fs_mutex);
 892         trans = btrfs_start_transaction(root, 1);
 893         if (IS_ERR(trans)) {
 894                 err = PTR_ERR(trans);
 895                 goto out_unlock;
 896         }
 897
 898         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
 899         if (err) {
 900                 err = -ENOSPC;
 901                 goto out_unlock;
 902         }
 903
 904         inode = btrfs_new_inode(trans, root, objectid, S_IFDIR | mode);
 905         if (IS_ERR(inode)) {
 906                 err = PTR_ERR(inode);
 907                 goto out_fail;
 908         }
 909         drop_on_err = 1;
 910         inode->i_op = &btrfs_dir_inode_operations;
 911         inode->i_fop = &btrfs_dir_file_operations;
 912
 913         err = btrfs_make_empty_dir(trans, root, inode->i_ino, dir->i_ino);
 914         if (err)
 915                 goto out_fail;
 916
 917         inode->i_size = 6;
 918         err = btrfs_update_inode(trans, root, inode);
 919         if (err)
 920                 goto out_fail;
 921         err = btrfs_add_link(trans, dentry, inode);
 922         if (err)
 923                 goto out_fail;
 924         d_instantiate(dentry, inode);
 925         drop_on_err = 0;
 926
 927 out_fail:
 928         btrfs_end_transaction(trans, root);
 929 out_unlock:
 930         mutex_unlock(&root->fs_info->fs_mutex);
 931         if (drop_on_err)
 932                 iput(inode);
 933         return err;
 934 }
 935
 936 static int btrfs_sync_file(struct file *file,
 937                            struct dentry *dentry, int datasync)
 938 {
 939         struct inode *inode = dentry->d_inode;
 940         struct btrfs_root *root = BTRFS_I(inode)->root;
 941         int ret;
 942         struct btrfs_trans_handle *trans;
 943
 944         mutex_lock(&root->fs_info->fs_mutex);
 945         trans = btrfs_start_transaction(root, 1);
 946         if (!trans) {
 947                 ret = -ENOMEM;
 948                 goto out;
 949         }
 950         ret = btrfs_commit_transaction(trans, root);
 951         mutex_unlock(&root->fs_info->fs_mutex);
 952 out:
 953         return ret > 0 ? EIO : ret;
 954 }
 955
 956 static int btrfs_sync_fs(struct super_block *sb, int wait)
 957 {
 958         struct btrfs_trans_handle *trans;
 959         struct btrfs_root *root;
 960         int ret;
 961         root = btrfs_sb(sb);
 962
 963         sb->s_dirt = 0;
 964         if (!wait) {
 965                 filemap_flush(root->fs_info->btree_inode->i_mapping);
 966                 return 0;
 967         }
 968         filemap_write_and_wait(root->fs_info->btree_inode->i_mapping);
 969         mutex_lock(&root->fs_info->fs_mutex);
 970         trans = btrfs_start_transaction(root, 1);
 971         ret = btrfs_commit_transaction(trans, root);
 972         sb->s_dirt = 0;
 973         BUG_ON(ret);
 974 printk("btrfs sync_fs\n");
 975         mutex_unlock(&root->fs_info->fs_mutex);
 976         return 0;
 977 }
 978
 979 static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
 980                            struct buffer_head *result, int create)
 981 {
 982         int ret;
 983         int err = 0;
 984         u64 blocknr;
 985         u64 extent_start = 0;
 986         u64 extent_end = 0;
 987         u64 objectid = inode->i_ino;
 988         u32 found_type;
 989         struct btrfs_path *path;
 990         struct btrfs_root *root = BTRFS_I(inode)->root;
 991         struct btrfs_file_extent_item *item;
 992         struct btrfs_leaf *leaf;
 993         struct btrfs_disk_key *found_key;
 994
 995         path = btrfs_alloc_path();
 996         BUG_ON(!path);
 997         btrfs_init_path(path);
 998         if (create) {
 999                 WARN_ON(1);
1000         }
1001
1002         ret = btrfs_lookup_file_extent(NULL, root, path,
1003                                        inode->i_ino,
1004                                        iblock << inode->i_blkbits, 0);
1005         if (ret < 0) {
1006                 err = ret;
1007                 goto out;
1008         }
1009
1010         if (ret != 0) {
1011                 if (path->slots[0] == 0) {
1012                         btrfs_release_path(root, path);
1013                         goto out;
1014                 }
1015                 path->slots[0]--;
1016         }
1017
1018         item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
1019                               struct btrfs_file_extent_item);
1020         leaf = btrfs_buffer_leaf(path->nodes[0]);
1021         blocknr = btrfs_file_extent_disk_blocknr(item);
1022         blocknr += btrfs_file_extent_offset(item);
1023
1024         /* are we inside the extent that was found? */
1025         found_key = &leaf->items[path->slots[0]].key;
1026         found_type = btrfs_disk_key_type(found_key);
1027         if (btrfs_disk_key_objectid(found_key) != objectid ||
1028             found_type != BTRFS_EXTENT_DATA_KEY) {
1029                 extent_end = 0;
1030                 extent_start = 0;
1031                 btrfs_release_path(root, path);
1032                 goto out;
1033         }
1034         found_type = btrfs_file_extent_type(item);
1035         extent_start = btrfs_disk_key_offset(&leaf->items[path->slots[0]].key);
1036         if (found_type == BTRFS_FILE_EXTENT_REG) {
1037                 extent_start = extent_start >> inode->i_blkbits;
1038                 extent_end = extent_start + btrfs_file_extent_num_blocks(item);
1039                 if (iblock >= extent_start && iblock < extent_end) {
1040                         err = 0;
1041                         btrfs_map_bh_to_logical(root, result, blocknr +
1042                                                 iblock - extent_start);
1043                         goto out;
1044                 }
1045         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
1046                 char *ptr;
1047                 char *map;
1048                 u32 size;
1049                 size = btrfs_file_extent_inline_len(leaf->items +
1050                                                     path->slots[0]);
1051                 extent_end = (extent_start + size) >> inode->i_blkbits;
1052                 extent_start >>= inode->i_blkbits;
1053                 if (iblock < extent_start || iblock > extent_end) {
1054                         goto out;
1055                 }
1056                 ptr = btrfs_file_extent_inline_start(item);
1057                 map = kmap(result->b_page);
1058                 memcpy(map, ptr, size);
1059                 memset(map + size, 0, PAGE_CACHE_SIZE - size);
1060                 flush_dcache_page(result->b_page);
1061                 kunmap(result->b_page);
1062                 set_buffer_uptodate(result);
1063                 SetPageChecked(result->b_page);
1064                 btrfs_map_bh_to_logical(root, result, 0);
1065         }
1066 out:
1067         btrfs_release_path(root, path);
1068         btrfs_free_path(path);
1069         return err;
1070 }
1071
1072 static int btrfs_get_block(struct inode *inode, sector_t iblock,
1073                            struct buffer_head *result, int create)
1074 {
1075         int err;
1076         struct btrfs_root *root = BTRFS_I(inode)->root;
1077         mutex_lock(&root->fs_info->fs_mutex);
1078         err = btrfs_get_block_lock(inode, iblock, result, create);
1079         mutex_unlock(&root->fs_info->fs_mutex);
1080         return err;
1081 }
1082
1083 static int btrfs_prepare_write(struct file *file, struct page *page,
1084                                unsigned from, unsigned to)
1085 {
1086         return nobh_prepare_write(page, from, to, btrfs_get_block);
1087 }
1088
1089 static void btrfs_write_super(struct super_block *sb)
1090 {
1091         btrfs_sync_fs(sb, 1);
1092 }
1093
1094 static int btrfs_readpage(struct file *file, struct page *page)
1095 {
1096         return mpage_readpage(page, btrfs_get_block);
1097 }
1098
1099 /*
1100  * While block_write_full_page is writing back the dirty buffers under
1101  * the page lock, whoever dirtied the buffers may decide to clean them
1102  * again at any time.  We handle that by only looking at the buffer
1103  * state inside lock_buffer().
1104  *
1105  * If block_write_full_page() is called for regular writeback
1106  * (wbc->sync_mode == WB_SYNC_NONE) then it will redirty a page which has a
1107  * locked buffer.   This only can happen if someone has written the buffer
1108  * directly, with submit_bh().  At the address_space level PageWriteback
1109  * prevents this contention from occurring.
1110  */
1111 static int __btrfs_write_full_page(struct inode *inode, struct page *page,
1112                                    struct writeback_control *wbc)
1113 {
1114         int err;
1115         sector_t block;
1116         sector_t last_block;
1117         struct buffer_head *bh, *head;
1118         const unsigned blocksize = 1 << inode->i_blkbits;
1119         int nr_underway = 0;
1120
1121         BUG_ON(!PageLocked(page));
1122
1123         last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
1124
1125         if (!page_has_buffers(page)) {
1126                 create_empty_buffers(page, blocksize,
1127                                         (1 << BH_Dirty)|(1 << BH_Uptodate));
1128         }
1129
1130         /*
1131          * Be very careful.  We have no exclusion from __set_page_dirty_buffers
1132          * here, and the (potentially unmapped) buffers may become dirty at
1133          * any time.  If a buffer becomes dirty here after we've inspected it
1134          * then we just miss that fact, and the page stays dirty.
1135          *
1136          * Buffers outside i_size may be dirtied by __set_page_dirty_buffers;
1137          * handle that here by just cleaning them.
1138          */
1139
1140         block = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
1141         head = page_buffers(page);
1142         bh = head;
1143
1144         /*
1145          * Get all the dirty buffers mapped to disk addresses and
1146          * handle any aliases from the underlying blockdev's mapping.
1147          */
1148         do {
1149                 if (block > last_block) {
1150                         /*
1151                          * mapped buffers outside i_size will occur, because
1152                          * this page can be outside i_size when there is a
1153                          * truncate in progress.
1154                          */
1155                         /*
1156                          * The buffer was zeroed by block_write_full_page()
1157                          */
1158                         clear_buffer_dirty(bh);
1159                         set_buffer_uptodate(bh);
1160                 } else if (!buffer_mapped(bh) && buffer_dirty(bh)) {
1161                         WARN_ON(bh->b_size != blocksize);
1162                         err = btrfs_get_block(inode, block, bh, 0);
1163                         if (err)
1164                                 goto recover;
1165                         if (buffer_new(bh)) {
1166                                 /* blockdev mappings never come here */
1167                                 clear_buffer_new(bh);
1168                                 unmap_underlying_metadata(bh->b_bdev,
1169                                                         bh->b_blocknr);
1170                         }
1171                 }
1172                 bh = bh->b_this_page;
1173                 block++;
1174         } while (bh != head);
1175
1176         do {
1177                 if (!buffer_mapped(bh))
1178                         continue;
1179                 /*
1180                  * If it's a fully non-blocking write attempt and we cannot
1181                  * lock the buffer then redirty the page.  Note that this can
1182                  * potentially cause a busy-wait loop from pdflush and kswapd
1183                  * activity, but those code paths have their own higher-level
1184                  * throttling.
1185                  */
1186                 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
1187                         lock_buffer(bh);
1188                 } else if (test_set_buffer_locked(bh)) {
1189                         redirty_page_for_writepage(wbc, page);
1190                         continue;
1191                 }
1192                 if (test_clear_buffer_dirty(bh) && bh->b_blocknr != 0) {
1193                         mark_buffer_async_write(bh);
1194                 } else {
1195                         unlock_buffer(bh);
1196                 }
1197         } while ((bh = bh->b_this_page) != head);
1198
1199         /*
1200          * The page and its buffers are protected by PageWriteback(), so we can
1201          * drop the bh refcounts early.
1202          */
1203         BUG_ON(PageWriteback(page));
1204         set_page_writeback(page);
1205
1206         do {
1207                 struct buffer_head *next = bh->b_this_page;
1208                 if (buffer_async_write(bh)) {
1209                         submit_bh(WRITE, bh);
1210                         nr_underway++;
1211                 }
1212                 bh = next;
1213         } while (bh != head);
1214         unlock_page(page);
1215
1216         err = 0;
1217 done:
1218         if (nr_underway == 0) {
1219                 /*
1220                  * The page was marked dirty, but the buffers were
1221                  * clean.  Someone wrote them back by hand with
1222                  * ll_rw_block/submit_bh.  A rare case.
1223                  */
1224                 int uptodate = 1;
1225                 do {
1226                         if (!buffer_uptodate(bh)) {
1227                                 uptodate = 0;
1228                                 break;
1229                         }
1230                         bh = bh->b_this_page;
1231                 } while (bh != head);
1232                 if (uptodate)
1233                         SetPageUptodate(page);
1234                 end_page_writeback(page);
1235                 /*
1236                  * The page and buffer_heads can be released at any time from
1237                  * here on.
1238                  */
1239                 wbc->pages_skipped++;   /* We didn't write this page */
1240         }
1241         return err;
1242
1243 recover:
1244         /*
1245          * ENOSPC, or some other error.  We may already have added some
1246          * blocks to the file, so we need to write these out to avoid
1247          * exposing stale data.
1248          * The page is currently locked and not marked for writeback
1249          */
1250         bh = head;
1251         /* Recovery: lock and submit the mapped buffers */
1252         do {
1253                 if (buffer_mapped(bh) && buffer_dirty(bh)) {
1254                         lock_buffer(bh);
1255                         mark_buffer_async_write(bh);
1256                 } else {
1257                         /*
1258                          * The buffer may have been set dirty during
1259                          * attachment to a dirty page.
1260                          */
1261                         clear_buffer_dirty(bh);
1262                 }
1263         } while ((bh = bh->b_this_page) != head);
1264         SetPageError(page);
1265         BUG_ON(PageWriteback(page));
1266         set_page_writeback(page);
1267         do {
1268                 struct buffer_head *next = bh->b_this_page;
1269                 if (buffer_async_write(bh)) {
1270                         clear_buffer_dirty(bh);
1271                         submit_bh(WRITE, bh);
1272                         nr_underway++;
1273                 }
1274                 bh = next;
1275         } while (bh != head);
1276         unlock_page(page);
1277         goto done;
1278 }
1279
1280 /*
1281  * The generic ->writepage function for buffer-backed address_spaces
1282  */
1283 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
1284 {
1285         struct inode * const inode = page->mapping->host;
1286         loff_t i_size = i_size_read(inode);
1287         const pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
1288         unsigned offset;
1289         void *kaddr;
1290
1291         /* Is the page fully inside i_size? */
1292         if (page->index < end_index)
1293                 return __btrfs_write_full_page(inode, page, wbc);
1294
1295         /* Is the page fully outside i_size? (truncate in progress) */
1296         offset = i_size & (PAGE_CACHE_SIZE-1);
1297         if (page->index >= end_index+1 || !offset) {
1298                 /*
1299                  * The page may have dirty, unmapped buffers.  For example,
1300                  * they may have been added in ext3_writepage().  Make them
1301                  * freeable here, so the page does not leak.
1302                  */
1303                 block_invalidatepage(page, 0);
1304                 unlock_page(page);
1305                 return 0; /* don't care */
1306         }
1307
1308         /*
1309          * The page straddles i_size.  It must be zeroed out on each and every
1310          * writepage invokation because it may be mmapped.  "A file is mapped
1311          * in multiples of the page size.  For a file that is not a multiple of
1312          * the  page size, the remaining memory is zeroed when mapped, and
1313          * writes to that region are not written out to the file."
1314          */
1315         kaddr = kmap_atomic(page, KM_USER0);
1316         memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
1317         flush_dcache_page(page);
1318         kunmap_atomic(kaddr, KM_USER0);
1319         return __btrfs_write_full_page(inode, page, wbc);
1320 }
1321
1322 static void btrfs_truncate(struct inode *inode)
1323 {
1324         struct btrfs_root *root = BTRFS_I(inode)->root;
1325         int ret;
1326         struct btrfs_trans_handle *trans;
1327
1328         if (!S_ISREG(inode->i_mode))
1329                 return;
1330         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1331                 return;
1332
1333         nobh_truncate_page(inode->i_mapping, inode->i_size);
1334
1335         /* FIXME, add redo link to tree so we don't leak on crash */
1336         mutex_lock(&root->fs_info->fs_mutex);
1337         trans = btrfs_start_transaction(root, 1);
1338         ret = btrfs_truncate_in_trans(trans, root, inode);
1339         BUG_ON(ret);
1340         ret = btrfs_end_transaction(trans, root);
1341         BUG_ON(ret);
1342         mutex_unlock(&root->fs_info->fs_mutex);
1343         mark_inode_dirty(inode);
1344 }
1345
1346 /*
1347  * Make sure any changes to nobh_commit_write() are reflected in
1348  * nobh_truncate_page(), since it doesn't call commit_write().
1349  */
1350 static int btrfs_commit_write(struct file *file, struct page *page,
1351                               unsigned from, unsigned to)
1352 {
1353         struct inode *inode = page->mapping->host;
1354         struct buffer_head *bh;
1355         loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1356
1357         SetPageUptodate(page);
1358         bh = page_buffers(page);
1359         if (buffer_mapped(bh) && bh->b_blocknr != 0) {
1360                 set_page_dirty(page);
1361         }
1362         if (pos > inode->i_size) {
1363                 i_size_write(inode, pos);
1364                 mark_inode_dirty(inode);
1365         }
1366         return 0;
1367 }
1368
1369 static int btrfs_copy_from_user(loff_t pos, int num_pages, int write_bytes,
1370                                 struct page **prepared_pages,
1371                                 const char __user * buf)
1372 {
1373         long page_fault = 0;
1374         int i;
1375         int offset = pos & (PAGE_CACHE_SIZE - 1);
1376
1377         for (i = 0; i < num_pages && write_bytes > 0; i++, offset = 0) {
1378                 size_t count = min_t(size_t,
1379                                      PAGE_CACHE_SIZE - offset, write_bytes);
1380                 struct page *page = prepared_pages[i];
1381                 fault_in_pages_readable(buf, count);
1382
1383                 /* Copy data from userspace to the current page */
1384                 kmap(page);
1385                 page_fault = __copy_from_user(page_address(page) + offset,
1386                                               buf, count);
1387                 /* Flush processor's dcache for this page */
1388                 flush_dcache_page(page);
1389                 kunmap(page);
1390                 buf += count;
1391                 write_bytes -= count;
1392
1393                 if (page_fault)
1394                         break;
1395         }
1396         return page_fault ? -EFAULT : 0;
1397 }
1398
1399 static void btrfs_drop_pages(struct page **pages, size_t num_pages)
1400 {
1401         size_t i;
1402         for (i = 0; i < num_pages; i++) {
1403                 if (!pages[i])
1404                         break;
1405                 unlock_page(pages[i]);
1406                 mark_page_accessed(pages[i]);
1407                 page_cache_release(pages[i]);
1408         }
1409 }
1410 static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
1411                                    struct btrfs_root *root,
1412                                    struct file *file,
1413                                    struct page **pages,
1414                                    size_t num_pages,
1415                                    loff_t pos,
1416                                    size_t write_bytes)
1417 {
1418         int i;
1419         int offset;
1420         int err = 0;
1421         int ret;
1422         int this_write;
1423         struct inode *inode = file->f_path.dentry->d_inode;
1424         struct buffer_head *bh;
1425         struct btrfs_file_extent_item *ei;
1426
1427         for (i = 0; i < num_pages; i++) {
1428                 offset = pos & (PAGE_CACHE_SIZE -1);
1429                 this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
1430                 /* FIXME, one block at a time */
1431
1432                 mutex_lock(&root->fs_info->fs_mutex);
1433                 trans = btrfs_start_transaction(root, 1);
1434
1435                 bh = page_buffers(pages[i]);
1436                 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
1437                         struct btrfs_key key;
1438                         struct btrfs_path *path;
1439                         char *ptr;
1440                         u32 datasize;
1441
1442                         path = btrfs_alloc_path();
1443                         BUG_ON(!path);
1444                         key.objectid = inode->i_ino;
1445                         key.offset = pages[i]->index << PAGE_CACHE_SHIFT;
1446                         key.flags = 0;
1447                         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
1448                         BUG_ON(write_bytes >= PAGE_CACHE_SIZE);
1449                         datasize = offset +
1450                                 btrfs_file_extent_calc_inline_size(write_bytes);
1451                         ret = btrfs_insert_empty_item(trans, root, path, &key,
1452                                                       datasize);
1453                         BUG_ON(ret);
1454                         ei = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
1455                                path->slots[0], struct btrfs_file_extent_item);
1456                         btrfs_set_file_extent_generation(ei, trans->transid);
1457                         btrfs_set_file_extent_type(ei,
1458                                                    BTRFS_FILE_EXTENT_INLINE);
1459                         ptr = btrfs_file_extent_inline_start(ei);
1460                         memcpy(ptr, bh->b_data, offset + write_bytes);
1461                         mark_buffer_dirty(path->nodes[0]);
1462                         btrfs_free_path(path);
1463                 } else {
1464                         btrfs_csum_file_block(trans, root, inode->i_ino,
1465                                       pages[i]->index << PAGE_CACHE_SHIFT,
1466                                       kmap(pages[i]), PAGE_CACHE_SIZE);
1467                         kunmap(pages[i]);
1468                 }
1469                 SetPageChecked(pages[i]);
1470                 ret = btrfs_end_transaction(trans, root);
1471                 BUG_ON(ret);
1472                 mutex_unlock(&root->fs_info->fs_mutex);
1473
1474                 ret = btrfs_commit_write(file, pages[i], offset,
1475                                          offset + this_write);
1476                 pos += this_write;
1477                 if (ret) {
1478                         err = ret;
1479                         goto failed;
1480                 }
1481                 WARN_ON(this_write > write_bytes);
1482                 write_bytes -= this_write;
1483         }
1484 failed:
1485         return err;
1486 }
1487
1488 static int drop_extents(struct btrfs_trans_handle *trans,
1489                           struct btrfs_root *root,
1490                           struct inode *inode,
1491                           u64 start, u64 end)
1492 {
1493         int ret;
1494         struct btrfs_key key;
1495         struct btrfs_leaf *leaf;
1496         int slot;
1497         struct btrfs_file_extent_item *extent;
1498         u64 extent_end = 0;
1499         int keep;
1500         struct btrfs_file_extent_item old;
1501         struct btrfs_path *path;
1502         u64 search_start = start;
1503         int bookend;
1504         int found_type;
1505         int found_extent;
1506         int found_inline;
1507
1508         path = btrfs_alloc_path();
1509         if (!path)
1510                 return -ENOMEM;
1511         while(1) {
1512                 btrfs_release_path(root, path);
1513                 ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
1514                                                search_start, -1);
1515                 if (ret < 0)
1516                         goto out;
1517                 if (ret > 0) {
1518                         if (path->slots[0] == 0) {
1519                                 ret = 0;
1520                                 goto out;
1521                         }
1522                         path->slots[0]--;
1523                 }
1524                 keep = 0;
1525                 bookend = 0;
1526                 found_extent = 0;
1527                 found_inline = 0;
1528                 extent = NULL;
1529                 leaf = btrfs_buffer_leaf(path->nodes[0]);
1530                 slot = path->slots[0];
1531                 btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key);
1532                 if (key.offset >= end || key.objectid != inode->i_ino) {
1533                         ret = 0;
1534                         goto out;
1535                 }
1536                 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY) {
1537                         ret = 0;
1538                         goto out;
1539                 }
1540                 extent = btrfs_item_ptr(leaf, slot,
1541                                         struct btrfs_file_extent_item);
1542                 found_type = btrfs_file_extent_type(extent);
1543                 if (found_type == BTRFS_FILE_EXTENT_REG) {
1544                         extent_end = key.offset +
1545                                 (btrfs_file_extent_num_blocks(extent) <<
1546                                  inode->i_blkbits);
1547                         found_extent = 1;
1548                 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
1549                         found_inline = 1;
1550                         extent_end = key.offset +
1551                              btrfs_file_extent_inline_len(leaf->items + slot);
1552                 }
1553
1554                 if (!found_extent && !found_inline) {
1555                         ret = 0;
1556                         goto out;
1557                 }
1558
1559                 if (search_start >= extent_end) {
1560                         ret = 0;
1561                         goto out;
1562                 }
1563
1564                 search_start = extent_end;
1565
1566                 if (end < extent_end && end >= key.offset) {
1567                         if (found_extent) {
1568                                 memcpy(&old, extent, sizeof(old));
1569                                 ret = btrfs_inc_extent_ref(trans, root,
1570                                       btrfs_file_extent_disk_blocknr(&old),
1571                                       btrfs_file_extent_disk_num_blocks(&old));
1572                                 BUG_ON(ret);
1573                         }
1574                         WARN_ON(found_inline);
1575                         bookend = 1;
1576                 }
1577
1578                 if (start > key.offset) {
1579                         u64 new_num;
1580                         u64 old_num;
1581                         /* truncate existing extent */
1582                         keep = 1;
1583                         WARN_ON(start & (root->blocksize - 1));
1584                         if (found_extent) {
1585                                 new_num = (start - key.offset) >>
1586                                         inode->i_blkbits;
1587                                 old_num = btrfs_file_extent_num_blocks(extent);
1588                                 inode->i_blocks -= (old_num - new_num) << 3;
1589                                 btrfs_set_file_extent_num_blocks(extent,
1590                                                                  new_num);
1591                                 mark_buffer_dirty(path->nodes[0]);
1592                         } else {
1593                                 WARN_ON(1);
1594                                 /*
1595                                 ret = btrfs_truncate_item(trans, root, path,
1596                                                           start - key.offset);
1597                                 BUG_ON(ret);
1598                                 */
1599                         }
1600                 }
1601                 if (!keep) {
1602                         u64 disk_blocknr = 0;
1603                         u64 disk_num_blocks = 0;
1604                         u64 extent_num_blocks = 0;
1605                         if (found_extent) {
1606                                 disk_blocknr =
1607                                       btrfs_file_extent_disk_blocknr(extent);
1608                                 disk_num_blocks =
1609                                       btrfs_file_extent_disk_num_blocks(extent);
1610                                 extent_num_blocks =
1611                                       btrfs_file_extent_num_blocks(extent);
1612                         }
1613                         ret = btrfs_del_item(trans, root, path);
1614                         BUG_ON(ret);
1615                         btrfs_release_path(root, path);
1616                         if (found_extent) {
1617                                 inode->i_blocks -=
1618                                 btrfs_file_extent_num_blocks(extent) << 3;
1619                                 ret = btrfs_free_extent(trans, root,
1620                                                         disk_blocknr,
1621                                                         disk_num_blocks, 0);
1622                         }
1623
1624                         BUG_ON(ret);
1625                         if (!bookend && search_start >= end) {
1626                                 ret = 0;
1627                                 goto out;
1628                         }
1629                         if (!bookend)
1630                                 continue;
1631                 }
1632                 if (bookend && found_extent) {
1633                         /* create bookend */
1634                         struct btrfs_key ins;
1635                         ins.objectid = inode->i_ino;
1636                         ins.offset = end;
1637                         ins.flags = 0;
1638                         btrfs_set_key_type(&ins, BTRFS_EXTENT_DATA_KEY);
1639
1640                         btrfs_release_path(root, path);
1641                         ret = btrfs_insert_empty_item(trans, root, path, &ins,
1642                                                       sizeof(*extent));
1643                         BUG_ON(ret);
1644                         extent = btrfs_item_ptr(
1645                                     btrfs_buffer_leaf(path->nodes[0]),
1646                                     path->slots[0],
1647                                     struct btrfs_file_extent_item);
1648                         btrfs_set_file_extent_disk_blocknr(extent,
1649                                     btrfs_file_extent_disk_blocknr(&old));
1650                         btrfs_set_file_extent_disk_num_blocks(extent,
1651                                     btrfs_file_extent_disk_num_blocks(&old));
1652
1653                         btrfs_set_file_extent_offset(extent,
1654                                     btrfs_file_extent_offset(&old) +
1655                                     ((end - key.offset) >> inode->i_blkbits));
1656                         WARN_ON(btrfs_file_extent_num_blocks(&old) <
1657                                 (end - key.offset) >> inode->i_blkbits);
1658                         btrfs_set_file_extent_num_blocks(extent,
1659                                     btrfs_file_extent_num_blocks(&old) -
1660                                     ((end - key.offset) >> inode->i_blkbits));
1661
1662                         btrfs_set_file_extent_type(extent,
1663                                                    BTRFS_FILE_EXTENT_REG);
1664                         btrfs_set_file_extent_generation(extent,
1665                                     btrfs_file_extent_generation(&old));
1666                         btrfs_mark_buffer_dirty(path->nodes[0]);
1667                         inode->i_blocks +=
1668                                 btrfs_file_extent_num_blocks(extent) << 3;
1669                         ret = 0;
1670                         goto out;
1671                 }
1672         }
1673 out:
1674         btrfs_free_path(path);
1675         return ret;
1676 }
1677
1678 static int prepare_pages(struct btrfs_root *root,
1679                          struct file *file,
1680                          struct page **pages,
1681                          size_t num_pages,
1682                          loff_t pos,
1683                          unsigned long first_index,
1684                          unsigned long last_index,
1685                          size_t write_bytes,
1686                          u64 alloc_extent_start)
1687 {
1688         int i;
1689         unsigned long index = pos >> PAGE_CACHE_SHIFT;
1690         struct inode *inode = file->f_path.dentry->d_inode;
1691         int offset;
1692         int err = 0;
1693         int this_write;
1694         struct buffer_head *bh;
1695         struct buffer_head *head;
1696         loff_t isize = i_size_read(inode);
1697
1698         memset(pages, 0, num_pages * sizeof(struct page *));
1699
1700         for (i = 0; i < num_pages; i++) {
1701                 pages[i] = grab_cache_page(inode->i_mapping, index + i);
1702                 if (!pages[i]) {
1703                         err = -ENOMEM;
1704                         goto failed_release;
1705                 }
1706                 offset = pos & (PAGE_CACHE_SIZE -1);
1707                 this_write = min(PAGE_CACHE_SIZE - offset, write_bytes);
1708                 create_empty_buffers(pages[i], root->fs_info->sb->s_blocksize,
1709                                      (1 << BH_Uptodate));
1710                 head = page_buffers(pages[i]);
1711                 bh = head;
1712                 do {
1713                         err = btrfs_map_bh_to_logical(root, bh,
1714                                                       alloc_extent_start);
1715                         BUG_ON(err);
1716                         if (err)
1717                                 goto failed_truncate;
1718                         bh = bh->b_this_page;
1719                         if (alloc_extent_start)
1720                                 alloc_extent_start++;
1721                 } while (bh != head);
1722                 pos += this_write;
1723                 WARN_ON(this_write > write_bytes);
1724                 write_bytes -= this_write;
1725         }
1726         return 0;
1727
1728 failed_release:
1729         btrfs_drop_pages(pages, num_pages);
1730         return err;
1731
1732 failed_truncate:
1733         btrfs_drop_pages(pages, num_pages);
1734         if (pos > isize)
1735                 vmtruncate(inode, isize);
1736         return err;
1737 }
1738
1739 static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
1740                                 size_t count, loff_t *ppos)
1741 {
1742         loff_t pos;
1743         size_t num_written = 0;
1744         int err = 0;
1745         int ret = 0;
1746         struct inode *inode = file->f_path.dentry->d_inode;
1747         struct btrfs_root *root = BTRFS_I(inode)->root;
1748         struct page *pages[8];
1749         struct page *pinned[2] = { NULL, NULL };
1750         unsigned long first_index;
1751         unsigned long last_index;
1752         u64 start_pos;
1753         u64 num_blocks;
1754         u64 alloc_extent_start;
1755         struct btrfs_trans_handle *trans;
1756         struct btrfs_key ins;
1757
1758         if (file->f_flags & O_DIRECT)
1759                 return -EINVAL;
1760         pos = *ppos;
1761         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
1762         current->backing_dev_info = inode->i_mapping->backing_dev_info;
1763         err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
1764         if (err)
1765                 goto out;
1766         if (count == 0)
1767                 goto out;
1768         err = remove_suid(file->f_path.dentry);
1769         if (err)
1770                 goto out;
1771         file_update_time(file);
1772
1773         start_pos = pos & ~((u64)PAGE_CACHE_SIZE - 1);
1774         num_blocks = (count + pos - start_pos + root->blocksize - 1) >>
1775                         inode->i_blkbits;
1776
1777         mutex_lock(&inode->i_mutex);
1778         first_index = pos >> PAGE_CACHE_SHIFT;
1779         last_index = (pos + count) >> PAGE_CACHE_SHIFT;
1780
1781         if ((first_index << PAGE_CACHE_SHIFT) < inode->i_size &&
1782             (pos & (PAGE_CACHE_SIZE - 1))) {
1783                 pinned[0] = grab_cache_page(inode->i_mapping, first_index);
1784                 if (!PageUptodate(pinned[0])) {
1785                         ret = mpage_readpage(pinned[0], btrfs_get_block);
1786                         BUG_ON(ret);
1787                 } else {
1788                         unlock_page(pinned[0]);
1789                 }
1790         }
1791         if (first_index != last_index &&
1792             (last_index << PAGE_CACHE_SHIFT) < inode->i_size &&
1793             (count & (PAGE_CACHE_SIZE - 1))) {
1794                 pinned[1] = grab_cache_page(inode->i_mapping, last_index);
1795                 if (!PageUptodate(pinned[1])) {
1796                         ret = mpage_readpage(pinned[1], btrfs_get_block);
1797                         BUG_ON(ret);
1798                 } else {
1799                         unlock_page(pinned[1]);
1800                 }
1801         }
1802
1803         mutex_lock(&root->fs_info->fs_mutex);
1804         trans = btrfs_start_transaction(root, 1);
1805         if (!trans) {
1806                 err = -ENOMEM;
1807                 mutex_unlock(&root->fs_info->fs_mutex);
1808                 goto out_unlock;
1809         }
1810         /* FIXME blocksize != 4096 */
1811         inode->i_blocks += num_blocks << 3;
1812         if (start_pos < inode->i_size) {
1813                 /* FIXME blocksize != pagesize */
1814                 ret = drop_extents(trans, root, inode,
1815                                    start_pos,
1816                                    (pos + count + root->blocksize -1) &
1817                                    ~((u64)root->blocksize - 1));
1818                 BUG_ON(ret);
1819         }
1820         if (inode->i_size >= PAGE_CACHE_SIZE || pos + count < inode->i_size ||
1821             pos + count - start_pos > BTRFS_MAX_INLINE_DATA_SIZE(root)) {
1822                 ret = btrfs_alloc_extent(trans, root, inode->i_ino,
1823                                          BTRFS_EXTENT_FILE, num_blocks, 1,
1824                                          (u64)-1, &ins);
1825                 BUG_ON(ret);
1826                 ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
1827                                        start_pos, ins.objectid, ins.offset);
1828                 BUG_ON(ret);
1829         } else {
1830                 ins.offset = 0;
1831                 ins.objectid = 0;
1832         }
1833         BUG_ON(ret);
1834         alloc_extent_start = ins.objectid;
1835         ret = btrfs_end_transaction(trans, root);
1836         mutex_unlock(&root->fs_info->fs_mutex);
1837
1838         while(count > 0) {
1839                 size_t offset = pos & (PAGE_CACHE_SIZE - 1);
1840                 size_t write_bytes = min(count, PAGE_CACHE_SIZE - offset);
1841                 size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
1842                                         PAGE_CACHE_SHIFT;
1843
1844                 memset(pages, 0, sizeof(pages));
1845                 ret = prepare_pages(root, file, pages, num_pages,
1846                                     pos, first_index, last_index,
1847                                     write_bytes, alloc_extent_start);
1848                 BUG_ON(ret);
1849
1850                 /* FIXME blocks != pagesize */
1851                 if (alloc_extent_start)
1852                         alloc_extent_start += num_pages;
1853                 ret = btrfs_copy_from_user(pos, num_pages,
1854                                            write_bytes, pages, buf);
1855                 BUG_ON(ret);
1856
1857                 ret = dirty_and_release_pages(NULL, root, file, pages,
1858                                               num_pages, pos, write_bytes);
1859                 BUG_ON(ret);
1860                 btrfs_drop_pages(pages, num_pages);
1861
1862                 buf += write_bytes;
1863                 count -= write_bytes;
1864                 pos += write_bytes;
1865                 num_written += write_bytes;
1866
1867                 balance_dirty_pages_ratelimited(inode->i_mapping);
1868                 cond_resched();
1869         }
1870 out_unlock:
1871         mutex_unlock(&inode->i_mutex);
1872 out:
1873         if (pinned[0])
1874                 page_cache_release(pinned[0]);
1875         if (pinned[1])
1876                 page_cache_release(pinned[1]);
1877         *ppos = pos;
1878         current->backing_dev_info = NULL;
1879         mark_inode_dirty(inode);
1880         return num_written ? num_written : err;
1881 }
1882
1883 static int btrfs_read_actor(read_descriptor_t *desc, struct page *page,
1884                         unsigned long offset, unsigned long size)
1885 {
1886         char *kaddr;
1887         unsigned long left, count = desc->count;
1888         struct inode *inode = page->mapping->host;
1889
1890         if (size > count)
1891                 size = count;
1892
1893         if (!PageChecked(page)) {
1894                 /* FIXME, do it per block */
1895                 struct btrfs_root *root = BTRFS_I(inode)->root;
1896
1897                 int ret = btrfs_csum_verify_file_block(root,
1898                                   page->mapping->host->i_ino,
1899                                   page->index << PAGE_CACHE_SHIFT,
1900                                   kmap(page), PAGE_CACHE_SIZE);
1901                 if (ret) {
1902                         printk("failed to verify ino %lu page %lu\n",
1903                                page->mapping->host->i_ino,
1904                                page->index);
1905                         memset(page_address(page), 0, PAGE_CACHE_SIZE);
1906                 }
1907                 SetPageChecked(page);
1908                 kunmap(page);
1909         }
1910         /*
1911          * Faults on the destination of a read are common, so do it before
1912          * taking the kmap.
1913          */
1914         if (!fault_in_pages_writeable(desc->arg.buf, size)) {
1915                 kaddr = kmap_atomic(page, KM_USER0);
1916                 left = __copy_to_user_inatomic(desc->arg.buf,
1917                                                 kaddr + offset, size);
1918                 kunmap_atomic(kaddr, KM_USER0);
1919                 if (left == 0)
1920                         goto success;
1921         }
1922
1923         /* Do it the slow way */
1924         kaddr = kmap(page);
1925         left = __copy_to_user(desc->arg.buf, kaddr + offset, size);
1926         kunmap(page);
1927
1928         if (left) {
1929                 size -= left;
1930                 desc->error = -EFAULT;
1931         }
1932 success:
1933         desc->count = count - size;
1934         desc->written += size;
1935         desc->arg.buf += size;
1936         return size;
1937 }
1938
1939 /**
1940  * btrfs_file_aio_read - filesystem read routine
1941  * @iocb:       kernel I/O control block
1942  * @iov:        io vector request
1943  * @nr_segs:    number of segments in the iovec
1944  * @pos:        current file position
1945  */
1946 static ssize_t btrfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1947                                    unsigned long nr_segs, loff_t pos)
1948 {
1949         struct file *filp = iocb->ki_filp;
1950         ssize_t retval;
1951         unsigned long seg;
1952         size_t count;
1953         loff_t *ppos = &iocb->ki_pos;
1954
1955         count = 0;
1956         for (seg = 0; seg < nr_segs; seg++) {
1957                 const struct iovec *iv = &iov[seg];
1958
1959                 /*
1960                  * If any segment has a negative length, or the cumulative
1961                  * length ever wraps negative then return -EINVAL.
1962                  */
1963                 count += iv->iov_len;
1964                 if (unlikely((ssize_t)(count|iv->iov_len) < 0))
1965                         return -EINVAL;
1966                 if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
1967                         continue;
1968                 if (seg == 0)
1969                         return -EFAULT;
1970                 nr_segs = seg;
1971                 count -= iv->iov_len;   /* This segment is no good */
1972                 break;
1973         }
1974         retval = 0;
1975         if (count) {
1976                 for (seg = 0; seg < nr_segs; seg++) {
1977                         read_descriptor_t desc;
1978
1979                         desc.written = 0;
1980                         desc.arg.buf = iov[seg].iov_base;
1981                         desc.count = iov[seg].iov_len;
1982                         if (desc.count == 0)
1983                                 continue;
1984                         desc.error = 0;
1985                         do_generic_file_read(filp, ppos, &desc,
1986                                              btrfs_read_actor);
1987                         retval += desc.written;
1988                         if (desc.error) {
1989                                 retval = retval ?: desc.error;
1990                                 break;
1991                         }
1992                 }
1993         }
1994         return retval;
1995 }
1996
1997 static int create_subvol(struct btrfs_root *root, char *name, int namelen)
1998 {
1999         struct btrfs_trans_handle *trans;
2000         struct btrfs_key key;
2001         struct btrfs_root_item root_item;
2002         struct btrfs_inode_item *inode_item;
2003         struct buffer_head *subvol;
2004         struct btrfs_leaf *leaf;
2005         struct btrfs_root *new_root;
2006         struct inode *inode;
2007         int ret;
2008         u64 objectid;
2009         u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
2010
2011         mutex_lock(&root->fs_info->fs_mutex);
2012         trans = btrfs_start_transaction(root, 1);
2013         BUG_ON(!trans);
2014
2015         subvol = btrfs_alloc_free_block(trans, root);
2016         leaf = btrfs_buffer_leaf(subvol);
2017         btrfs_set_header_nritems(&leaf->header, 0);
2018         btrfs_set_header_level(&leaf->header, 0);
2019         btrfs_set_header_blocknr(&leaf->header, bh_blocknr(subvol));
2020         btrfs_set_header_generation(&leaf->header, trans->transid);
2021         btrfs_set_header_owner(&leaf->header, root->root_key.objectid);
2022         memcpy(leaf->header.fsid, root->fs_info->disk_super->fsid,
2023                sizeof(leaf->header.fsid));
2024         mark_buffer_dirty(subvol);
2025         brelse(subvol);
2026         subvol = NULL;
2027
2028         inode_item = &root_item.inode;
2029         memset(inode_item, 0, sizeof(*inode_item));
2030         btrfs_set_inode_generation(inode_item, 1);
2031         btrfs_set_inode_size(inode_item, 3);
2032         btrfs_set_inode_nlink(inode_item, 1);
2033         btrfs_set_inode_nblocks(inode_item, 1);
2034         btrfs_set_inode_mode(inode_item, S_IFDIR | 0755);
2035
2036         btrfs_set_root_blocknr(&root_item, bh_blocknr(subvol));
2037         btrfs_set_root_refs(&root_item, 1);
2038
2039         ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
2040                                        0, &objectid);
2041         BUG_ON(ret);
2042
2043         btrfs_set_root_dirid(&root_item, new_dirid);
2044
2045         key.objectid = objectid;
2046         key.offset = 1;
2047         key.flags = 0;
2048         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
2049         ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
2050                                 &root_item);
2051         BUG_ON(ret);
2052
2053         /*
2054          * insert the directory item
2055          */
2056         key.offset = (u64)-1;
2057         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
2058                                     name, namelen,
2059                                     root->fs_info->sb->s_root->d_inode->i_ino,
2060                                     &key, 0);
2061         BUG_ON(ret);
2062
2063         ret = btrfs_commit_transaction(trans, root);
2064         BUG_ON(ret);
2065
2066         new_root = btrfs_read_fs_root(root->fs_info, &key);
2067         BUG_ON(!new_root);
2068
2069         trans = btrfs_start_transaction(new_root, 1);
2070         BUG_ON(!trans);
2071
2072         inode = btrfs_new_inode(trans, new_root, new_dirid, S_IFDIR | 0700);
2073         inode->i_op = &btrfs_dir_inode_operations;
2074         inode->i_fop = &btrfs_dir_file_operations;
2075
2076         ret = btrfs_make_empty_dir(trans, new_root, new_dirid, new_dirid);
2077         BUG_ON(ret);
2078
2079         inode->i_nlink = 1;
2080         inode->i_size = 6;
2081         ret = btrfs_update_inode(trans, new_root, inode);
2082         BUG_ON(ret);
2083
2084         ret = btrfs_commit_transaction(trans, new_root);
2085         BUG_ON(ret);
2086
2087         iput(inode);
2088
2089         mutex_unlock(&root->fs_info->fs_mutex);
2090         return 0;
2091 }
2092
2093 static int create_snapshot(struct btrfs_root *root, char *name, int namelen)
2094 {
2095         struct btrfs_trans_handle *trans;
2096         struct btrfs_key key;
2097         struct btrfs_root_item new_root_item;
2098         int ret;
2099         u64 objectid;
2100
2101         if (!root->ref_cows)
2102                 return -EINVAL;
2103
2104         mutex_lock(&root->fs_info->fs_mutex);
2105         trans = btrfs_start_transaction(root, 1);
2106         BUG_ON(!trans);
2107
2108         ret = btrfs_update_inode(trans, root, root->inode);
2109         BUG_ON(ret);
2110
2111         ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
2112                                        0, &objectid);
2113         BUG_ON(ret);
2114
2115         memcpy(&new_root_item, &root->root_item,
2116                sizeof(new_root_item));
2117
2118         key.objectid = objectid;
2119         key.offset = 1;
2120         key.flags = 0;
2121         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
2122         btrfs_set_root_blocknr(&new_root_item, bh_blocknr(root->node));
2123
2124         ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
2125                                 &new_root_item);
2126         BUG_ON(ret);
2127
2128         /*
2129          * insert the directory item
2130          */
2131         key.offset = (u64)-1;
2132         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
2133                                     name, namelen,
2134                                     root->fs_info->sb->s_root->d_inode->i_ino,
2135                                     &key, 0);
2136
2137         BUG_ON(ret);
2138
2139         ret = btrfs_inc_root_ref(trans, root);
2140         BUG_ON(ret);
2141
2142         ret = btrfs_commit_transaction(trans, root);
2143         BUG_ON(ret);
2144         mutex_unlock(&root->fs_info->fs_mutex);
2145         return 0;
2146 }
2147
2148 static int add_disk(struct btrfs_root *root, char *name, int namelen)
2149 {
2150         struct block_device *bdev;
2151         struct btrfs_path *path;
2152         struct super_block *sb = root->fs_info->sb;
2153         struct btrfs_root *dev_root = root->fs_info->dev_root;
2154         struct btrfs_trans_handle *trans;
2155         struct btrfs_device_item *dev_item;
2156         struct btrfs_key key;
2157         u16 item_size;
2158         u64 num_blocks;
2159         u64 new_blocks;
2160         u64 device_id;
2161         int ret;
2162
2163 printk("adding disk %s\n", name);
2164         path = btrfs_alloc_path();
2165         if (!path)
2166                 return -ENOMEM;
2167         num_blocks = btrfs_super_total_blocks(root->fs_info->disk_super);
2168         bdev = open_bdev_excl(name, O_RDWR, sb);
2169         if (IS_ERR(bdev)) {
2170                 ret = PTR_ERR(bdev);
2171 printk("open bdev excl failed ret %d\n", ret);
2172                 goto out_nolock;
2173         }
2174         set_blocksize(bdev, sb->s_blocksize);
2175         new_blocks = bdev->bd_inode->i_size >> sb->s_blocksize_bits;
2176         key.objectid = num_blocks;
2177         key.offset = new_blocks;
2178         key.flags = 0;
2179         btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY);
2180
2181         mutex_lock(&dev_root->fs_info->fs_mutex);
2182         trans = btrfs_start_transaction(dev_root, 1);
2183         item_size = sizeof(*dev_item) + namelen;
2184 printk("insert empty on %Lu %Lu %u size %d\n", num_blocks, new_blocks, key.flags, item_size);
2185         ret = btrfs_insert_empty_item(trans, dev_root, path, &key, item_size);
2186         if (ret) {
2187 printk("insert failed %d\n", ret);
2188                 close_bdev_excl(bdev);
2189                 if (ret > 0)
2190                         ret = -EEXIST;
2191                 goto out;
2192         }
2193         dev_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
2194                                   path->slots[0], struct btrfs_device_item);
2195         btrfs_set_device_pathlen(dev_item, namelen);
2196         memcpy(dev_item + 1, name, namelen);
2197
2198         device_id = btrfs_super_last_device_id(root->fs_info->disk_super) + 1;
2199         btrfs_set_super_last_device_id(root->fs_info->disk_super, device_id);
2200         btrfs_set_device_id(dev_item, device_id);
2201         mark_buffer_dirty(path->nodes[0]);
2202
2203         ret = btrfs_insert_dev_radix(root, bdev, device_id, num_blocks,
2204                                      new_blocks);
2205
2206         if (!ret) {
2207                 btrfs_set_super_total_blocks(root->fs_info->disk_super,
2208                                              num_blocks + new_blocks);
2209                 i_size_write(root->fs_info->btree_inode,
2210                              (num_blocks + new_blocks) <<
2211                              root->fs_info->btree_inode->i_blkbits);
2212         }
2213
2214 out:
2215         ret = btrfs_commit_transaction(trans, dev_root);
2216         BUG_ON(ret);
2217         mutex_unlock(&root->fs_info->fs_mutex);
2218 out_nolock:
2219         btrfs_free_path(path);
2220
2221         return ret;
2222 }
2223
2224 static int btrfs_ioctl(struct inode *inode, struct file *filp, unsigned int
2225                        cmd, unsigned long arg)
2226 {
2227         struct btrfs_root *root = BTRFS_I(inode)->root;
2228         struct btrfs_ioctl_vol_args vol_args;
2229         int ret = 0;
2230         struct btrfs_dir_item *di;
2231         int namelen;
2232         struct btrfs_path *path;
2233         u64 root_dirid;
2234
2235         switch (cmd) {
2236         case BTRFS_IOC_SNAP_CREATE:
2237                 if (copy_from_user(&vol_args,
2238                                    (struct btrfs_ioctl_vol_args __user *)arg,
2239                                    sizeof(vol_args)))
2240                         return -EFAULT;
2241                 namelen = strlen(vol_args.name);
2242                 if (namelen > BTRFS_VOL_NAME_MAX)
2243                         return -EINVAL;
2244                 path = btrfs_alloc_path();
2245                 if (!path)
2246                         return -ENOMEM;
2247                 root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
2248                 mutex_lock(&root->fs_info->fs_mutex);
2249                 di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
2250                                     path, root_dirid,
2251                                     vol_args.name, namelen, 0);
2252                 mutex_unlock(&root->fs_info->fs_mutex);
2253                 btrfs_free_path(path);
2254                 if (di && !IS_ERR(di))
2255                         return -EEXIST;
2256
2257                 if (root == root->fs_info->tree_root)
2258                         ret = create_subvol(root, vol_args.name, namelen);
2259                 else
2260                         ret = create_snapshot(root, vol_args.name, namelen);
2261                 WARN_ON(ret);
2262                 break;
2263         case BTRFS_IOC_ADD_DISK:
2264                 if (copy_from_user(&vol_args,
2265                                    (struct btrfs_ioctl_vol_args __user *)arg,
2266                                    sizeof(vol_args)))
2267                         return -EFAULT;
2268                 namelen = strlen(vol_args.name);
2269                 if (namelen > BTRFS_VOL_NAME_MAX)
2270                         return -EINVAL;
2271                 vol_args.name[namelen] = '\0';
2272                 ret = add_disk(root, vol_args.name, namelen);
2273                 break;
2274         default:
2275                 return -ENOTTY;
2276         }
2277         return ret;
2278 }
2279
2280 static struct kmem_cache *btrfs_inode_cachep;
2281 struct kmem_cache *btrfs_trans_handle_cachep;
2282 struct kmem_cache *btrfs_transaction_cachep;
2283 struct kmem_cache *btrfs_bit_radix_cachep;
2284 struct kmem_cache *btrfs_path_cachep;
2285
2286 /*
2287  * Called inside transaction, so use GFP_NOFS
2288  */
2289 static struct inode *btrfs_alloc_inode(struct super_block *sb)
2290 {
2291         struct btrfs_inode *ei;
2292
2293         ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
2294         if (!ei)
2295                 return NULL;
2296         return &ei->vfs_inode;
2297 }
2298
2299 static void btrfs_destroy_inode(struct inode *inode)
2300 {
2301         WARN_ON(!list_empty(&inode->i_dentry));
2302         WARN_ON(inode->i_data.nrpages);
2303
2304         kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
2305 }
2306
2307 static void init_once(void * foo, struct kmem_cache * cachep,
2308                       unsigned long flags)
2309 {
2310         struct btrfs_inode *ei = (struct btrfs_inode *) foo;
2311
2312         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
2313             SLAB_CTOR_CONSTRUCTOR) {
2314                 inode_init_once(&ei->vfs_inode);
2315         }
2316 }
2317
2318 static int init_inodecache(void)
2319 {
2320         btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
2321                                              sizeof(struct btrfs_inode),
2322                                              0, (SLAB_RECLAIM_ACCOUNT|
2323                                                 SLAB_MEM_SPREAD),
2324                                              init_once, NULL);
2325         btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
2326                                              sizeof(struct btrfs_trans_handle),
2327                                              0, (SLAB_RECLAIM_ACCOUNT|
2328                                                 SLAB_MEM_SPREAD),
2329                                              NULL, NULL);
2330         btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
2331                                              sizeof(struct btrfs_transaction),
2332                                              0, (SLAB_RECLAIM_ACCOUNT|
2333                                                 SLAB_MEM_SPREAD),
2334                                              NULL, NULL);
2335         btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
2336                                              sizeof(struct btrfs_transaction),
2337                                              0, (SLAB_RECLAIM_ACCOUNT|
2338                                                 SLAB_MEM_SPREAD),
2339                                              NULL, NULL);
2340         btrfs_bit_radix_cachep = kmem_cache_create("btrfs_radix",
2341                                              256,
2342                                              0, (SLAB_RECLAIM_ACCOUNT|
2343                                                 SLAB_MEM_SPREAD |
2344                                                 SLAB_DESTROY_BY_RCU),
2345                                              NULL, NULL);
2346         if (btrfs_inode_cachep == NULL || btrfs_trans_handle_cachep == NULL ||
2347             btrfs_transaction_cachep == NULL || btrfs_bit_radix_cachep == NULL)
2348                 return -ENOMEM;
2349         return 0;
2350 }
2351
2352 static void destroy_inodecache(void)
2353 {
2354         kmem_cache_destroy(btrfs_inode_cachep);
2355         kmem_cache_destroy(btrfs_trans_handle_cachep);
2356         kmem_cache_destroy(btrfs_transaction_cachep);
2357         kmem_cache_destroy(btrfs_bit_radix_cachep);
2358         kmem_cache_destroy(btrfs_path_cachep);
2359 }
2360
2361 static int btrfs_get_sb(struct file_system_type *fs_type,
2362         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
2363 {
2364         return get_sb_bdev(fs_type, flags, dev_name, data,
2365                            btrfs_fill_super, mnt);
2366 }
2367
2368
2369 static int btrfs_getattr(struct vfsmount *mnt,
2370                          struct dentry *dentry, struct kstat *stat)
2371 {
2372         struct inode *inode = dentry->d_inode;
2373         generic_fillattr(inode, stat);
2374         stat->blksize = 256 * 1024;
2375         return 0;
2376 }
2377
2378 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
2379 {
2380         struct btrfs_root *root = btrfs_sb(dentry->d_sb);
2381         struct btrfs_super_block *disk_super = root->fs_info->disk_super;
2382
2383         buf->f_namelen = BTRFS_NAME_LEN;
2384         buf->f_blocks = btrfs_super_total_blocks(disk_super);
2385         buf->f_bfree = buf->f_blocks - btrfs_super_blocks_used(disk_super);
2386         buf->f_bavail = buf->f_bfree;
2387         buf->f_bsize = dentry->d_sb->s_blocksize;
2388         buf->f_type = BTRFS_SUPER_MAGIC;
2389         return 0;
2390 }
2391 static struct file_system_type btrfs_fs_type = {
2392         .owner          = THIS_MODULE,
2393         .name           = "btrfs",
2394         .get_sb         = btrfs_get_sb,
2395         .kill_sb        = kill_block_super,
2396         .fs_flags       = FS_REQUIRES_DEV,
2397 };
2398
2399 static struct super_operations btrfs_super_ops = {
2400         .delete_inode   = btrfs_delete_inode,
2401         .put_super      = btrfs_put_super,
2402         .read_inode     = btrfs_read_locked_inode,
2403         .write_super    = btrfs_write_super,
2404         .sync_fs        = btrfs_sync_fs,
2405         .write_inode    = btrfs_write_inode,
2406         .alloc_inode    = btrfs_alloc_inode,
2407         .destroy_inode  = btrfs_destroy_inode,
2408         .statfs         = btrfs_statfs,
2409 };
2410
2411 static struct inode_operations btrfs_dir_inode_operations = {
2412         .lookup         = btrfs_lookup,
2413         .create         = btrfs_create,
2414         .unlink         = btrfs_unlink,
2415         .mkdir          = btrfs_mkdir,
2416         .rmdir          = btrfs_rmdir,
2417 };
2418
2419 static struct inode_operations btrfs_dir_ro_inode_operations = {
2420         .lookup         = btrfs_lookup,
2421 };
2422
2423 static struct file_operations btrfs_dir_file_operations = {
2424         .llseek         = generic_file_llseek,
2425         .read           = generic_read_dir,
2426         .readdir        = btrfs_readdir,
2427         .ioctl          = btrfs_ioctl,
2428 };
2429
2430 static struct address_space_operations btrfs_aops = {
2431         .readpage       = btrfs_readpage,
2432         .writepage      = btrfs_writepage,
2433         .sync_page      = block_sync_page,
2434         .prepare_write  = btrfs_prepare_write,
2435         .commit_write   = btrfs_commit_write,
2436 };
2437
2438 static struct inode_operations btrfs_file_inode_operations = {
2439         .truncate       = btrfs_truncate,
2440         .getattr        = btrfs_getattr,
2441 };
2442
2443 static struct file_operations btrfs_file_operations = {
2444         .llseek         = generic_file_llseek,
2445         .read           = do_sync_read,
2446         .aio_read       = btrfs_file_aio_read,
2447         .write          = btrfs_file_write,
2448         .mmap           = generic_file_mmap,
2449         .open           = generic_file_open,
2450         .ioctl          = btrfs_ioctl,
2451         .fsync          = btrfs_sync_file,
2452 };
2453
2454 static int __init init_btrfs_fs(void)
2455 {
2456         int err;
2457         printk("btrfs loaded!\n");
2458         err = init_inodecache();
2459         if (err)
2460                 return err;
2461         kset_set_kset_s(&btrfs_subsys, fs_subsys);
2462         err = subsystem_register(&btrfs_subsys);
2463         if (err)
2464                 goto out;
2465         return register_filesystem(&btrfs_fs_type);
2466 out:
2467         destroy_inodecache();
2468         return err;
2469 }
2470
2471 static void __exit exit_btrfs_fs(void)
2472 {
2473         destroy_inodecache();
2474         unregister_filesystem(&btrfs_fs_type);
2475         subsystem_unregister(&btrfs_subsys);
2476         printk("btrfs unloaded\n");
2477 }
2478
2479 module_init(init_btrfs_fs)
2480 module_exit(exit_btrfs_fs)
2481
2482 MODULE_LICENSE("GPL");