fs/reiserfs/super.c

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  *
   4  * Trivial changes by Alan Cox to add the LFS fixes
   5  *
   6  * Trivial Changes:
   7  * Rights granted to Hans Reiser to redistribute under other terms providing
   8  * he accepts all liability including but not limited to patent, fitness
   9  * for purpose, and direct or indirect claims arising from failure to perform.
  10  *
  11  * NO WARRANTY
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/module.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/time.h>
  18 #include <asm/uaccess.h>
  19 #include <linux/reiserfs_fs.h>
  20 #include <linux/reiserfs_acl.h>
  21 #include <linux/reiserfs_xattr.h>
  22 #include <linux/smp_lock.h>
  23 #include <linux/init.h>
  24 #include <linux/blkdev.h>
  25 #include <linux/buffer_head.h>
  26 #include <linux/vfs.h>
  27 #include <linux/namespace.h>
  28
  29 struct file_system_type reiserfs_fs_type;
  30
  31 const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;
  32 const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;
  33 const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;
  34
  35 int is_reiserfs_3_5 (struct reiserfs_super_block * rs)
  36 {
  37   return !strncmp (rs->s_v1.s_magic, reiserfs_3_5_magic_string,
  38                    strlen (reiserfs_3_5_magic_string));
  39 }
  40
  41
  42 int is_reiserfs_3_6 (struct reiserfs_super_block * rs)
  43 {
  44   return !strncmp (rs->s_v1.s_magic, reiserfs_3_6_magic_string,
  45                    strlen (reiserfs_3_6_magic_string));
  46 }
  47
  48
  49 int is_reiserfs_jr (struct reiserfs_super_block * rs)
  50 {
  51   return !strncmp (rs->s_v1.s_magic, reiserfs_jr_magic_string,
  52                    strlen (reiserfs_jr_magic_string));
  53 }
  54
  55
  56 static int is_any_reiserfs_magic_string (struct reiserfs_super_block * rs)
  57 {
  58   return (is_reiserfs_3_5 (rs) || is_reiserfs_3_6 (rs) ||
  59           is_reiserfs_jr (rs));
  60 }
  61
  62 static int reiserfs_remount (struct super_block * s, int * flags, char * data);
  63 static int reiserfs_statfs (struct super_block * s, struct kstatfs * buf);
  64
  65 static void reiserfs_sync_fs (struct super_block * s)
  66 {
  67     if (!(s->s_flags & MS_RDONLY)) {
  68         struct reiserfs_transaction_handle th;
  69         reiserfs_write_lock(s);
  70         if (!journal_begin(&th, s, 1))
  71             if (!journal_end_sync(&th, s, 1))
  72                 reiserfs_flush_old_commits(s);
  73         s->s_dirt = 0; /* Even if it's not true.
  74                         * We'll loop forever in sync_supers otherwise */
  75         reiserfs_write_unlock(s);
  76     } else {
  77         s->s_dirt = 0;
  78     }
  79 }
  80
  81 static void reiserfs_write_super(struct super_block *s)
  82 {
  83     reiserfs_sync_fs(s);
  84 }
  85
  86 static void reiserfs_write_super_lockfs (struct super_block * s)
  87 {
  88   struct reiserfs_transaction_handle th ;
  89   reiserfs_write_lock(s);
  90   if (!(s->s_flags & MS_RDONLY)) {
  91     int err = journal_begin(&th, s, 1) ;
  92     if (err) {
  93         reiserfs_block_writes(&th) ;
  94     } else {
  95         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
  96         journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
  97         reiserfs_block_writes(&th) ;
  98         journal_end_sync(&th, s, 1) ;
  99     }
 100   }
 101   s->s_dirt = 0;
 102   reiserfs_write_unlock(s);
 103 }
 104
 105 void reiserfs_unlockfs(struct super_block *s) {
 106   reiserfs_allow_writes(s) ;
 107 }
 108
 109 extern const struct reiserfs_key  MAX_KEY;
 110
 111
 112 /* this is used to delete "save link" when there are no items of a
 113    file it points to. It can either happen if unlink is completed but
 114    "save unlink" removal, or if file has both unlink and truncate
 115    pending and as unlink completes first (because key of "save link"
 116    protecting unlink is bigger that a key lf "save link" which
 117    protects truncate), so there left no items to make truncate
 118    completion on */
 119 static int remove_save_link_only (struct super_block * s, struct reiserfs_key * key, int oid_free)
 120 {
 121     struct reiserfs_transaction_handle th;
 122     int err;
 123
 124      /* we are going to do one balancing */
 125      err = journal_begin (&th, s, JOURNAL_PER_BALANCE_CNT);
 126      if (err)
 127         return err;
 128
 129      reiserfs_delete_solid_item (&th, NULL, key);
 130      if (oid_free)
 131         /* removals are protected by direct items */
 132         reiserfs_release_objectid (&th, le32_to_cpu (key->k_objectid));
 133
 134      return journal_end (&th, s, JOURNAL_PER_BALANCE_CNT);
 135 }
 136
 137
 138 /* look for uncompleted unlinks and truncates and complete them */
 139 static int finish_unfinished (struct super_block * s)
 140 {
 141     INITIALIZE_PATH (path);
 142     struct cpu_key max_cpu_key, obj_key;
 143     struct reiserfs_key save_link_key;
 144     int retval = 0;
 145     struct item_head * ih;
 146     struct buffer_head * bh;
 147     int item_pos;
 148     char * item;
 149     int done;
 150     struct inode * inode;
 151     int truncate;
 152
 153
 154     /* compose key to look for "save" links */
 155     max_cpu_key.version = KEY_FORMAT_3_5;
 156     max_cpu_key.on_disk_key = MAX_KEY;
 157     max_cpu_key.key_length = 3;
 158
 159     done = 0;
 160     REISERFS_SB(s)->s_is_unlinked_ok = 1;
 161     while (!retval) {
 162         retval = search_item (s, &max_cpu_key, &path);
 163         if (retval != ITEM_NOT_FOUND) {
 164             reiserfs_warning (s, "vs-2140: finish_unfinished: search_by_key returned %d",
 165                               retval);
 166             break;
 167         }
 168
 169         bh = get_last_bh (&path);
 170         item_pos = get_item_pos (&path);
 171         if (item_pos != B_NR_ITEMS (bh)) {
 172             reiserfs_warning (s, "vs-2060: finish_unfinished: wrong position found");
 173             break;
 174         }
 175         item_pos --;
 176         ih = B_N_PITEM_HEAD (bh, item_pos);
 177
 178         if (le32_to_cpu (ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
 179             /* there are no "save" links anymore */
 180             break;
 181
 182         save_link_key = ih->ih_key;
 183         if (is_indirect_le_ih (ih))
 184             truncate = 1;
 185         else
 186             truncate = 0;
 187
 188         /* reiserfs_iget needs k_dirid and k_objectid only */
 189         item = B_I_PITEM (bh, ih);
 190         obj_key.on_disk_key.k_dir_id = le32_to_cpu (*(__u32 *)item);
 191         obj_key.on_disk_key.k_objectid = le32_to_cpu (ih->ih_key.k_objectid);
 192         obj_key.on_disk_key.u.k_offset_v1.k_offset = 0;
 193         obj_key.on_disk_key.u.k_offset_v1.k_uniqueness = 0;
 194
 195         pathrelse (&path);
 196
 197         inode = reiserfs_iget (s, &obj_key);
 198         if (!inode) {
 199             /* the unlink almost completed, it just did not manage to remove
 200                "save" link and release objectid */
 201             reiserfs_warning (s, "vs-2180: finish_unfinished: iget failed for %K",
 202                               &obj_key);
 203             retval = remove_save_link_only (s, &save_link_key, 1);
 204             continue;
 205         }
 206
 207         if (!truncate && inode->i_nlink) {
 208             /* file is not unlinked */
 209             reiserfs_warning (s, "vs-2185: finish_unfinished: file %K is not unlinked",
 210                               &obj_key);
 211             retval = remove_save_link_only (s, &save_link_key, 0);
 212             continue;
 213         }
 214
 215         if (truncate && S_ISDIR (inode->i_mode) ) {
 216             /* We got a truncate request for a dir which is impossible.
 217                The only imaginable way is to execute unfinished truncate request
 218                then boot into old kernel, remove the file and create dir with
 219                the same key. */
 220             reiserfs_warning(s, "green-2101: impossible truncate on a directory %k. Please report", INODE_PKEY (inode));
 221             retval = remove_save_link_only (s, &save_link_key, 0);
 222             truncate = 0;
 223             iput (inode);
 224             continue;
 225         }
 226
 227         if (truncate) {
 228             REISERFS_I(inode) -> i_flags |= i_link_saved_truncate_mask;
 229             /* not completed truncate found. New size was committed together
 230                with "save" link */
 231             reiserfs_info (s, "Truncating %k to %Ld ..",
 232                               INODE_PKEY (inode), inode->i_size);
 233             reiserfs_truncate_file (inode, 0/*don't update modification time*/);
 234             retval = remove_save_link (inode, truncate);
 235         } else {
 236             REISERFS_I(inode) -> i_flags |= i_link_saved_unlink_mask;
 237             /* not completed unlink (rmdir) found */
 238             reiserfs_info (s, "Removing %k..", INODE_PKEY (inode));
 239             /* removal gets completed in iput */
 240             retval = 0;
 241         }
 242
 243         iput (inode);
 244         printk ("done\n");
 245         done ++;
 246     }
 247     REISERFS_SB(s)->s_is_unlinked_ok = 0;
 248
 249     pathrelse (&path);
 250     if (done)
 251         reiserfs_info (s, "There were %d uncompleted unlinks/truncates. "
 252                           "Completed\n", done);
 253     return retval;
 254 }
 255
 256 /* to protect file being unlinked from getting lost we "safe" link files
 257    being unlinked. This link will be deleted in the same transaction with last
 258    item of file. mounting the filesytem we scan all these links and remove
 259    files which almost got lost */
 260 void add_save_link (struct reiserfs_transaction_handle * th,
 261                     struct inode * inode, int truncate)
 262 {
 263     INITIALIZE_PATH (path);
 264     int retval;
 265     struct cpu_key key;
 266     struct item_head ih;
 267     __u32 link;
 268
 269     BUG_ON (!th->t_trans_id);
 270
 271     /* file can only get one "save link" of each kind */
 272     RFALSE( truncate &&
 273             ( REISERFS_I(inode) -> i_flags & i_link_saved_truncate_mask ),
 274             "saved link already exists for truncated inode %lx",
 275             ( long ) inode -> i_ino );
 276     RFALSE( !truncate &&
 277             ( REISERFS_I(inode) -> i_flags & i_link_saved_unlink_mask ),
 278             "saved link already exists for unlinked inode %lx",
 279             ( long ) inode -> i_ino );
 280
 281     /* setup key of "save" link */
 282     key.version = KEY_FORMAT_3_5;
 283     key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
 284     key.on_disk_key.k_objectid = inode->i_ino;
 285     if (!truncate) {
 286         /* unlink, rmdir, rename */
 287         set_cpu_key_k_offset (&key, 1 + inode->i_sb->s_blocksize);
 288         set_cpu_key_k_type (&key, TYPE_DIRECT);
 289
 290         /* item head of "safe" link */
 291         make_le_item_head (&ih, &key, key.version, 1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
 292                            4/*length*/, 0xffff/*free space*/);
 293     } else {
 294         /* truncate */
 295         if (S_ISDIR (inode->i_mode))
 296             reiserfs_warning(inode->i_sb, "green-2102: Adding a truncate savelink for a directory %k! Please report", INODE_PKEY(inode));
 297         set_cpu_key_k_offset (&key, 1);
 298         set_cpu_key_k_type (&key, TYPE_INDIRECT);
 299
 300         /* item head of "safe" link */
 301         make_le_item_head (&ih, &key, key.version, 1, TYPE_INDIRECT,
 302                            4/*length*/, 0/*free space*/);
 303     }
 304     key.key_length = 3;
 305
 306     /* look for its place in the tree */
 307     retval = search_item (inode->i_sb, &key, &path);
 308     if (retval != ITEM_NOT_FOUND) {
 309         if ( retval != -ENOSPC )
 310             reiserfs_warning (inode->i_sb, "vs-2100: add_save_link:"
 311                           "search_by_key (%K) returned %d", &key, retval);
 312         pathrelse (&path);
 313         return;
 314     }
 315
 316     /* body of "save" link */
 317     link = INODE_PKEY (inode)->k_dir_id;
 318
 319     /* put "save" link inot tree, don't charge quota to anyone */
 320     retval = reiserfs_insert_item (th, &path, &key, &ih, NULL, (char *)&link);
 321     if (retval) {
 322         if (retval != -ENOSPC)
 323             reiserfs_warning (inode->i_sb, "vs-2120: add_save_link: insert_item returned %d",
 324                           retval);
 325     } else {
 326         if( truncate )
 327             REISERFS_I(inode) -> i_flags |= i_link_saved_truncate_mask;
 328         else
 329             REISERFS_I(inode) -> i_flags |= i_link_saved_unlink_mask;
 330     }
 331 }
 332
 333
 334 /* this opens transaction unlike add_save_link */
 335 int remove_save_link (struct inode * inode, int truncate)
 336 {
 337     struct reiserfs_transaction_handle th;
 338     struct reiserfs_key key;
 339     int err;
 340
 341     /* we are going to do one balancing only */
 342     err = journal_begin (&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
 343     if (err)
 344         return err;
 345
 346     /* setup key of "save" link */
 347     key.k_dir_id = cpu_to_le32 (MAX_KEY_OBJECTID);
 348     key.k_objectid = INODE_PKEY (inode)->k_objectid;
 349     if (!truncate) {
 350         /* unlink, rmdir, rename */
 351         set_le_key_k_offset (KEY_FORMAT_3_5, &key,
 352                              1 + inode->i_sb->s_blocksize);
 353         set_le_key_k_type (KEY_FORMAT_3_5, &key, TYPE_DIRECT);
 354     } else {
 355         /* truncate */
 356         set_le_key_k_offset (KEY_FORMAT_3_5, &key, 1);
 357         set_le_key_k_type (KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
 358     }
 359
 360     if( ( truncate &&
 361           ( REISERFS_I(inode) -> i_flags & i_link_saved_truncate_mask ) ) ||
 362         ( !truncate &&
 363           ( REISERFS_I(inode) -> i_flags & i_link_saved_unlink_mask ) ) )
 364         /* don't take quota bytes from anywhere */
 365         reiserfs_delete_solid_item (&th, NULL, &key);
 366     if (!truncate) {
 367         reiserfs_release_objectid (&th, inode->i_ino);
 368         REISERFS_I(inode) -> i_flags &= ~i_link_saved_unlink_mask;
 369     } else
 370         REISERFS_I(inode) -> i_flags &= ~i_link_saved_truncate_mask;
 371
 372     return journal_end (&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
 373 }
 374
 375
 376 static void reiserfs_put_super (struct super_block * s)
 377 {
 378   int i;
 379   struct reiserfs_transaction_handle th ;
 380   th.t_trans_id = 0;
 381
 382   if (REISERFS_SB(s)->xattr_root) {
 383     d_invalidate (REISERFS_SB(s)->xattr_root);
 384     dput (REISERFS_SB(s)->xattr_root);
 385   }
 386
 387   if (REISERFS_SB(s)->priv_root) {
 388     d_invalidate (REISERFS_SB(s)->priv_root);
 389     dput (REISERFS_SB(s)->priv_root);
 390   }
 391
 392   /* change file system state to current state if it was mounted with read-write permissions */
 393   if (!(s->s_flags & MS_RDONLY)) {
 394     if (!journal_begin(&th, s, 10)) {
 395         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
 396         set_sb_umount_state( SB_DISK_SUPER_BLOCK(s), REISERFS_SB(s)->s_mount_state );
 397         journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
 398     }
 399   }
 400
 401   /* note, journal_release checks for readonly mount, and can decide not
 402   ** to do a journal_end
 403   */
 404   journal_release(&th, s) ;
 405
 406   for (i = 0; i < SB_BMAP_NR (s); i ++)
 407     brelse (SB_AP_BITMAP (s)[i].bh);
 408
 409   vfree (SB_AP_BITMAP (s));
 410
 411   brelse (SB_BUFFER_WITH_SB (s));
 412
 413   print_statistics (s);
 414
 415   if (REISERFS_SB(s)->s_kmallocs != 0) {
 416     reiserfs_warning (s, "vs-2004: reiserfs_put_super: allocated memory left %d",
 417                       REISERFS_SB(s)->s_kmallocs);
 418   }
 419
 420   if (REISERFS_SB(s)->reserved_blocks != 0) {
 421     reiserfs_warning (s, "green-2005: reiserfs_put_super: reserved blocks left %d",
 422                       REISERFS_SB(s)->reserved_blocks);
 423   }
 424
 425   reiserfs_proc_info_done( s );
 426
 427   kfree(s->s_fs_info);
 428   s->s_fs_info = NULL;
 429
 430   return;
 431 }
 432
 433 static kmem_cache_t * reiserfs_inode_cachep;
 434
 435 static struct inode *reiserfs_alloc_inode(struct super_block *sb)
 436 {
 437         struct reiserfs_inode_info *ei;
 438         ei = (struct reiserfs_inode_info *)kmem_cache_alloc(reiserfs_inode_cachep, SLAB_KERNEL);
 439         if (!ei)
 440                 return NULL;
 441         return &ei->vfs_inode;
 442 }
 443
 444 static void reiserfs_destroy_inode(struct inode *inode)
 445 {
 446         kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 447 }
 448
 449 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
 450 {
 451         struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *) foo;
 452
 453         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 454             SLAB_CTOR_CONSTRUCTOR) {
 455                 INIT_LIST_HEAD(&ei->i_prealloc_list) ;
 456                 inode_init_once(&ei->vfs_inode);
 457                 ei->i_acl_access = NULL;
 458                 ei->i_acl_default = NULL;
 459         }
 460 }
 461
 462 static int init_inodecache(void)
 463 {
 464         reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
 465                                              sizeof(struct reiserfs_inode_info),
 466                                              0, SLAB_RECLAIM_ACCOUNT,
 467                                              init_once, NULL);
 468         if (reiserfs_inode_cachep == NULL)
 469                 return -ENOMEM;
 470         return 0;
 471 }
 472
 473 static void destroy_inodecache(void)
 474 {
 475         if (kmem_cache_destroy(reiserfs_inode_cachep))
 476                 reiserfs_warning (NULL, "reiserfs_inode_cache: not all structures were freed");
 477 }
 478
 479 /* we don't mark inodes dirty, we just log them */
 480 static void reiserfs_dirty_inode (struct inode * inode) {
 481     struct reiserfs_transaction_handle th ;
 482
 483     int err = 0;
 484     if (inode->i_sb->s_flags & MS_RDONLY) {
 485         reiserfs_warning(inode->i_sb, "clm-6006: writing inode %lu on readonly FS",
 486                           inode->i_ino) ;
 487         return ;
 488     }
 489     reiserfs_write_lock(inode->i_sb);
 490
 491     /* this is really only used for atime updates, so they don't have
 492     ** to be included in O_SYNC or fsync
 493     */
 494     err = journal_begin(&th, inode->i_sb, 1) ;
 495     if (err) {
 496         reiserfs_write_unlock (inode->i_sb);
 497         return;
 498     }
 499     reiserfs_update_sd (&th, inode);
 500     journal_end(&th, inode->i_sb, 1) ;
 501     reiserfs_write_unlock(inode->i_sb);
 502 }
 503
 504 static void reiserfs_clear_inode (struct inode *inode)
 505 {
 506     struct posix_acl *acl;
 507
 508     acl = REISERFS_I(inode)->i_acl_access;
 509     if (acl && !IS_ERR (acl))
 510         posix_acl_release (acl);
 511     REISERFS_I(inode)->i_acl_access = NULL;
 512
 513     acl = REISERFS_I(inode)->i_acl_default;
 514     if (acl && !IS_ERR (acl))
 515         posix_acl_release (acl);
 516     REISERFS_I(inode)->i_acl_default = NULL;
 517 }
 518
 519 struct super_operations reiserfs_sops =
 520 {
 521   .alloc_inode = reiserfs_alloc_inode,
 522   .destroy_inode = reiserfs_destroy_inode,
 523   .write_inode = reiserfs_write_inode,
 524   .dirty_inode = reiserfs_dirty_inode,
 525   .delete_inode = reiserfs_delete_inode,
 526   .clear_inode  = reiserfs_clear_inode,
 527   .put_super = reiserfs_put_super,
 528   .write_super = reiserfs_write_super,
 529   .write_super_lockfs = reiserfs_write_super_lockfs,
 530   .unlockfs = reiserfs_unlockfs,
 531   .statfs = reiserfs_statfs,
 532   .remount_fs = reiserfs_remount,
 533
 534 };
 535
 536 static struct export_operations reiserfs_export_ops = {
 537   .encode_fh = reiserfs_encode_fh,
 538   .decode_fh = reiserfs_decode_fh,
 539   .get_parent = reiserfs_get_parent,
 540   .get_dentry = reiserfs_get_dentry,
 541 } ;
 542
 543 /* this struct is used in reiserfs_getopt () for containing the value for those
 544    mount options that have values rather than being toggles. */
 545 typedef struct {
 546     char * value;
 547     int setmask; /* bitmask which is to set on mount_options bitmask when this
 548                     value is found, 0 is no bits are to be changed. */
 549     int clrmask; /* bitmask which is to clear on mount_options bitmask when  this
 550                     value is found, 0 is no bits are to be changed. This is
 551                     applied BEFORE setmask */
 552 } arg_desc_t;
 553
 554
 555 /* this struct is used in reiserfs_getopt() for describing the set of reiserfs
 556    mount options */
 557 typedef struct {
 558     char * option_name;
 559     int arg_required; /* 0 if argument is not required, not 0 otherwise */
 560     const arg_desc_t * values; /* list of values accepted by an option */
 561     int setmask; /* bitmask which is to set on mount_options bitmask when this
 562                     value is found, 0 is no bits are to be changed. */
 563     int clrmask; /* bitmask which is to clear on mount_options bitmask when  this
 564                     value is found, 0 is no bits are to be changed. This is
 565                     applied BEFORE setmask */
 566 } opt_desc_t;
 567
 568 /* possible values for -o data= */
 569 static const arg_desc_t logging_mode[] = {
 570     {"ordered", 1<<REISERFS_DATA_ORDERED, (1<<REISERFS_DATA_LOG|1<<REISERFS_DATA_WRITEBACK)},
 571     {"journal", 1<<REISERFS_DATA_LOG, (1<<REISERFS_DATA_ORDERED|1<<REISERFS_DATA_WRITEBACK)},
 572     {"writeback", 1<<REISERFS_DATA_WRITEBACK, (1<<REISERFS_DATA_ORDERED|1<<REISERFS_DATA_LOG)},
 573     {NULL, 0}
 574 };
 575
 576 /* possible values for -o barrier= */
 577 static const arg_desc_t barrier_mode[] = {
 578     {"none", 1<<REISERFS_BARRIER_NONE, 1<<REISERFS_BARRIER_FLUSH},
 579     {"flush", 1<<REISERFS_BARRIER_FLUSH, 1<<REISERFS_BARRIER_NONE},
 580     {NULL, 0}
 581 };
 582
 583 /* possible values for "-o block-allocator=" and bits which are to be set in
 584    s_mount_opt of reiserfs specific part of in-core super block */
 585 static const arg_desc_t balloc[] = {
 586     {"noborder", 1<<REISERFS_NO_BORDER, 0},
 587     {"border", 0, 1<<REISERFS_NO_BORDER},
 588     {"no_unhashed_relocation", 1<<REISERFS_NO_UNHASHED_RELOCATION, 0},
 589     {"hashed_relocation", 1<<REISERFS_HASHED_RELOCATION, 0},
 590     {"test4", 1<<REISERFS_TEST4, 0},
 591     {"notest4", 0, 1<<REISERFS_TEST4},
 592     {NULL, 0, 0}
 593 };
 594
 595 static const arg_desc_t tails[] = {
 596     {"on", 1<<REISERFS_LARGETAIL, 1<<REISERFS_SMALLTAIL},
 597     {"off", 0, (1<<REISERFS_LARGETAIL)|(1<<REISERFS_SMALLTAIL)},
 598     {"small", 1<<REISERFS_SMALLTAIL, 1<<REISERFS_LARGETAIL},
 599     {NULL, 0, 0}
 600 };
 601
 602 static const arg_desc_t error_actions[] = {
 603     {"panic", 1 << REISERFS_ERROR_PANIC,
 604               (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)},
 605     {"ro-remount", 1 << REISERFS_ERROR_RO,
 606               (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)},
 607 #ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
 608     {"continue", 1 << REISERFS_ERROR_CONTINUE,
 609               (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
 610 #endif
 611     {NULL, 0, 0},
 612 };
 613
 614 int reiserfs_default_io_size = 128 * 1024; /* Default recommended I/O size is 128k.
 615                                               There might be broken applications that are
 616                                               confused by this. Use nolargeio mount option
 617                                               to get usual i/o size = PAGE_SIZE.
 618                                             */
 619
 620 /* proceed only one option from a list *cur - string containing of mount options
 621    opts - array of options which are accepted
 622    opt_arg - if option is found and requires an argument and if it is specifed
 623    in the input - pointer to the argument is stored here
 624    bit_flags - if option requires to set a certain bit - it is set here
 625    return -1 if unknown option is found, opt->arg_required otherwise */
 626 static int reiserfs_getopt ( struct super_block * s, char ** cur, opt_desc_t * opts, char ** opt_arg,
 627                             unsigned long * bit_flags)
 628 {
 629     char * p;
 630     /* foo=bar,
 631        ^   ^  ^
 632        |   |  +-- option_end
 633        |   +-- arg_start
 634        +-- option_start
 635     */
 636     const opt_desc_t * opt;
 637     const arg_desc_t * arg;
 638
 639
 640     p = *cur;
 641
 642     /* assume argument cannot contain commas */
 643     *cur = strchr (p, ',');
 644     if (*cur) {
 645         *(*cur) = '\0';
 646         (*cur) ++;
 647     }
 648
 649     if ( !strncmp (p, "alloc=", 6) ) {
 650         /* Ugly special case, probably we should redo options parser so that
 651            it can understand several arguments for some options, also so that
 652            it can fill several bitfields with option values. */
 653         if ( reiserfs_parse_alloc_options( s, p + 6) ) {
 654             return -1;
 655         } else {
 656             return 0;
 657         }
 658     }
 659
 660
 661     /* for every option in the list */
 662     for (opt = opts; opt->option_name; opt ++) {
 663         if (!strncmp (p, opt->option_name, strlen (opt->option_name))) {
 664             if (bit_flags) {
 665                 if (opt->clrmask == (1 << REISERFS_UNSUPPORTED_OPT))
 666                     reiserfs_warning (s, "%s not supported.", p);
 667                 else
 668                     *bit_flags &= ~opt->clrmask;
 669                 if (opt->setmask == (1 << REISERFS_UNSUPPORTED_OPT))
 670                     reiserfs_warning (s, "%s not supported.", p);
 671                 else
 672                     *bit_flags |= opt->setmask;
 673             }
 674             break;
 675         }
 676     }
 677     if (!opt->option_name) {
 678         reiserfs_warning (s, "unknown mount option \"%s\"", p);
 679         return -1;
 680     }
 681
 682     p += strlen (opt->option_name);
 683     switch (*p) {
 684     case '=':
 685         if (!opt->arg_required) {
 686             reiserfs_warning (s, "the option \"%s\" does not require an argument",
 687                     opt->option_name);
 688             return -1;
 689         }
 690         break;
 691
 692     case 0:
 693         if (opt->arg_required) {
 694             reiserfs_warning (s, "the option \"%s\" requires an argument", opt->option_name);
 695             return -1;
 696         }
 697         break;
 698     default:
 699         reiserfs_warning (s, "head of option \"%s\" is only correct", opt->option_name);
 700         return -1;
 701     }
 702
 703     /* move to the argument, or to next option if argument is not required */
 704     p ++;
 705
 706     if ( opt->arg_required && !strlen (p) ) {
 707         /* this catches "option=," */
 708         reiserfs_warning (s, "empty argument for \"%s\"", opt->option_name);
 709         return -1;
 710     }
 711
 712     if (!opt->values) {
 713         /* *=NULLopt_arg contains pointer to argument */
 714         *opt_arg = p;
 715         return opt->arg_required;
 716     }
 717
 718     /* values possible for this option are listed in opt->values */
 719     for (arg = opt->values; arg->value; arg ++) {
 720         if (!strcmp (p, arg->value)) {
 721             if (bit_flags) {
 722                 *bit_flags &= ~arg->clrmask;
 723                 *bit_flags |= arg->setmask;
 724             }
 725             return opt->arg_required;
 726         }
 727     }
 728
 729     reiserfs_warning (s, "bad value \"%s\" for option \"%s\"", p, opt->option_name);
 730     return -1;
 731 }
 732
 733 /* returns 0 if something is wrong in option string, 1 - otherwise */
 734 static int reiserfs_parse_options (struct super_block * s, char * options, /* string given via mount's -o */
 735                                    unsigned long * mount_options,
 736                                    /* after the parsing phase, contains the
 737                                       collection of bitflags defining what
 738                                       mount options were selected. */
 739                                    unsigned long * blocks, /* strtol-ed from NNN of resize=NNN */
 740                                    char ** jdev_name,
 741                                    unsigned int * commit_max_age)
 742 {
 743     int c;
 744     char * arg = NULL;
 745     char * pos;
 746     opt_desc_t opts[] = {
 747         /* Compatibility stuff, so that -o notail for old setups still work */
 748         {"tails",       .arg_required = 't', .values = tails},
 749         {"notail",      .clrmask = (1<<REISERFS_LARGETAIL)|(1<<REISERFS_SMALLTAIL)},
 750         {"conv",        .setmask = 1<<REISERFS_CONVERT},
 751         {"attrs",       .setmask = 1<<REISERFS_ATTRS},
 752         {"noattrs",     .clrmask = 1<<REISERFS_ATTRS},
 753 #ifdef CONFIG_REISERFS_FS_XATTR
 754         {"user_xattr",  .setmask = 1<<REISERFS_XATTRS_USER},
 755         {"nouser_xattr",.clrmask = 1<<REISERFS_XATTRS_USER},
 756 #else
 757         {"user_xattr",  .setmask = 1<<REISERFS_UNSUPPORTED_OPT},
 758         {"nouser_xattr",.clrmask = 1<<REISERFS_UNSUPPORTED_OPT},
 759 #endif
 760 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
 761         {"acl",         .setmask = 1<<REISERFS_POSIXACL},
 762         {"noacl",       .clrmask = 1<<REISERFS_POSIXACL},
 763 #else
 764         {"acl",         .setmask = 1<<REISERFS_UNSUPPORTED_OPT},
 765         {"noacl",       .clrmask = 1<<REISERFS_UNSUPPORTED_OPT},
 766 #endif
 767         {"nolog",},      /* This is unsupported */
 768         {"replayonly",  .setmask = 1<<REPLAYONLY},
 769         {"block-allocator", .arg_required = 'a', .values = balloc},
 770         {"data",        .arg_required = 'd', .values = logging_mode},
 771         {"barrier",     .arg_required = 'b', .values = barrier_mode},
 772         {"resize",      .arg_required = 'r', .values = NULL},
 773         {"jdev",        .arg_required = 'j', .values = NULL},
 774         {"nolargeio",   .arg_required = 'w', .values = NULL},
 775         {"commit",      .arg_required = 'c', .values = NULL},
 776         {"usrquota",},
 777         {"grpquota",},
 778         {"errors",      .arg_required = 'e', .values = error_actions},
 779         {NULL,}
 780     };
 781
 782     *blocks = 0;
 783     if (!options || !*options)
 784         /* use default configuration: create tails, journaling on, no
 785            conversion to newest format */
 786         return 1;
 787
 788     for (pos = options; pos; ) {
 789         c = reiserfs_getopt (s, &pos, opts, &arg, mount_options);
 790         if (c == -1)
 791             /* wrong option is given */
 792             return 0;
 793
 794         if (c == 'r') {
 795             char * p;
 796
 797             p = NULL;
 798             /* "resize=NNN" */
 799             *blocks = simple_strtoul (arg, &p, 0);
 800             if (*p != '\0') {
 801                 /* NNN does not look like a number */
 802                 reiserfs_warning (s, "reiserfs_parse_options: bad value %s", arg);
 803                 return 0;
 804             }
 805         }
 806
 807         if ( c == 'c' ) {
 808                 char *p = NULL;
 809                 unsigned long val = simple_strtoul (arg, &p, 0);
 810                 /* commit=NNN (time in seconds) */
 811                 if ( *p != '\0' || val >= (unsigned int)-1) {
 812                         reiserfs_warning (s, "reiserfs_parse_options: bad value %s", arg);                      return 0;
 813                 }
 814                 *commit_max_age = (unsigned int)val;
 815         }
 816
 817         if ( c == 'w' ) {
 818                 char *p=NULL;
 819                 int val = simple_strtoul (arg, &p, 0);
 820
 821                 if ( *p != '\0') {
 822                     reiserfs_warning (s, "reiserfs_parse_options: non-numeric value %s for nolargeio option", arg);
 823                     return 0;
 824                 }
 825                 if ( val )
 826                     reiserfs_default_io_size = PAGE_SIZE;
 827                 else
 828                     reiserfs_default_io_size = 128 * 1024;
 829         }
 830
 831         if (c == 'j') {
 832             if (arg && *arg && jdev_name) {
 833                 if ( *jdev_name ) { //Hm, already assigned?
 834                     reiserfs_warning (s, "reiserfs_parse_options: journal device was already  specified to be %s", *jdev_name);
 835                     return 0;
 836                 }
 837                 *jdev_name = arg;
 838             }
 839         }
 840     }
 841
 842     return 1;
 843 }
 844
 845 static void switch_data_mode(struct super_block *s, unsigned long mode) {
 846     REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
 847                                        (1 << REISERFS_DATA_ORDERED) |
 848                                        (1 << REISERFS_DATA_WRITEBACK));
 849     REISERFS_SB(s)->s_mount_opt |= (1 << mode);
 850 }
 851
 852 static void handle_data_mode(struct super_block *s, unsigned long mount_options)
 853 {
 854     if (mount_options & (1 << REISERFS_DATA_LOG)) {
 855         if (!reiserfs_data_log(s)) {
 856             switch_data_mode(s, REISERFS_DATA_LOG);
 857             reiserfs_info (s, "switching to journaled data mode\n");
 858         }
 859     } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
 860         if (!reiserfs_data_ordered(s)) {
 861             switch_data_mode(s, REISERFS_DATA_ORDERED);
 862             reiserfs_info (s, "switching to ordered data mode\n");
 863         }
 864     } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
 865         if (!reiserfs_data_writeback(s)) {
 866             switch_data_mode(s, REISERFS_DATA_WRITEBACK);
 867             reiserfs_info (s, "switching to writeback data mode\n");
 868         }
 869     }
 870 }
 871
 872 static void handle_barrier_mode(struct super_block *s, unsigned long bits) {
 873     int flush = (1 << REISERFS_BARRIER_FLUSH);
 874     int none = (1 << REISERFS_BARRIER_NONE);
 875     int all_barrier = flush | none;
 876
 877     if (bits & all_barrier) {
 878         REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
 879         if (bits & flush) {
 880             REISERFS_SB(s)->s_mount_opt |= flush;
 881             printk("reiserfs: enabling write barrier flush mode\n");
 882         } else if (bits & none) {
 883             REISERFS_SB(s)->s_mount_opt |= none;
 884             printk("reiserfs: write barriers turned off\n");
 885         }
 886    }
 887 }
 888
 889 static void handle_attrs( struct super_block *s )
 890 {
 891         struct reiserfs_super_block * rs;
 892
 893         if( reiserfs_attrs( s ) ) {
 894                 rs = SB_DISK_SUPER_BLOCK (s);
 895                 if( old_format_only(s) ) {
 896                         reiserfs_warning(s, "reiserfs: cannot support attributes on 3.5.x disk format" );
 897                         REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
 898                         return;
 899                 }
 900                 if( !( le32_to_cpu( rs -> s_flags ) & reiserfs_attrs_cleared ) ) {
 901                                 reiserfs_warning(s, "reiserfs: cannot support attributes until flag is set in super-block" );
 902                                 REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
 903                 }
 904         }
 905 }
 906
 907 static int reiserfs_remount (struct super_block * s, int * mount_flags, char * arg)
 908 {
 909   struct reiserfs_super_block * rs;
 910   struct reiserfs_transaction_handle th ;
 911   unsigned long blocks;
 912   unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
 913   unsigned long safe_mask = 0;
 914   unsigned int commit_max_age = (unsigned int)-1;
 915   struct reiserfs_journal *journal = SB_JOURNAL(s);
 916   int err;
 917
 918   rs = SB_DISK_SUPER_BLOCK (s);
 919
 920   if (!reiserfs_parse_options(s, arg, &mount_options, &blocks, NULL, &commit_max_age))
 921     return -EINVAL;
 922
 923   handle_attrs(s);
 924
 925   /* Add options that are safe here */
 926   safe_mask |= 1 << REISERFS_SMALLTAIL;
 927   safe_mask |= 1 << REISERFS_LARGETAIL;
 928   safe_mask |= 1 << REISERFS_NO_BORDER;
 929   safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
 930   safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
 931   safe_mask |= 1 << REISERFS_TEST4;
 932   safe_mask |= 1 << REISERFS_ATTRS;
 933   safe_mask |= 1 << REISERFS_XATTRS_USER;
 934   safe_mask |= 1 << REISERFS_POSIXACL;
 935   safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
 936   safe_mask |= 1 << REISERFS_BARRIER_NONE;
 937   safe_mask |= 1 << REISERFS_ERROR_RO;
 938   safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
 939   safe_mask |= 1 << REISERFS_ERROR_PANIC;
 940
 941   /* Update the bitmask, taking care to keep
 942    * the bits we're not allowed to change here */
 943   REISERFS_SB(s)->s_mount_opt = (REISERFS_SB(s)->s_mount_opt & ~safe_mask) |  (mount_options & safe_mask);
 944
 945   if(commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
 946     journal->j_max_commit_age = commit_max_age;
 947     journal->j_max_trans_age = commit_max_age;
 948   }
 949   else if(commit_max_age == 0)
 950   {
 951     /* 0 means restore defaults. */
 952     journal->j_max_commit_age = journal->j_default_max_commit_age;
 953     journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
 954   }
 955
 956   if(blocks) {
 957     int rc = reiserfs_resize(s, blocks);
 958     if (rc != 0)
 959       return rc;
 960   }
 961
 962   if (*mount_flags & MS_RDONLY) {
 963     reiserfs_xattr_init (s, *mount_flags);
 964     /* remount read-only */
 965     if (s->s_flags & MS_RDONLY)
 966       /* it is read-only already */
 967       return 0;
 968     /* try to remount file system with read-only permissions */
 969     if (sb_umount_state(rs) == REISERFS_VALID_FS || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
 970       return 0;
 971     }
 972
 973     err = journal_begin(&th, s, 10) ;
 974     if (err)
 975         return err;
 976
 977     /* Mounting a rw partition read-only. */
 978     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
 979     set_sb_umount_state( rs, REISERFS_SB(s)->s_mount_state );
 980     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
 981   } else {
 982     /* remount read-write */
 983     if (!(s->s_flags & MS_RDONLY)) {
 984         reiserfs_xattr_init (s, *mount_flags);
 985         return 0; /* We are read-write already */
 986     }
 987
 988     if (reiserfs_is_journal_aborted (journal))
 989         return journal->j_errno;
 990
 991     handle_data_mode(s, mount_options);
 992     handle_barrier_mode(s, mount_options);
 993     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs) ;
 994     s->s_flags &= ~MS_RDONLY ; /* now it is safe to call journal_begin */
 995     err = journal_begin(&th, s, 10) ;
 996     if (err)
 997         return err;
 998
 999     /* Mount a partition which is read-only, read-write */
1000     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1001     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1002     s->s_flags &= ~MS_RDONLY;
1003     set_sb_umount_state( rs, REISERFS_ERROR_FS );
1004     /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1005     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1006     REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS ;
1007   }
1008   /* this will force a full flush of all journal lists */
1009   SB_JOURNAL(s)->j_must_wait = 1 ;
1010   err = journal_end(&th, s, 10) ;
1011   if (err)
1012     return err;
1013   s->s_dirt = 0;
1014
1015   if (!( *mount_flags & MS_RDONLY ) ) {
1016     finish_unfinished( s );
1017     reiserfs_xattr_init (s, *mount_flags);
1018   }
1019
1020   return 0;
1021 }
1022
1023 /* load_bitmap_info_data - Sets up the reiserfs_bitmap_info structure from disk.
1024  * @sb - superblock for this filesystem
1025  * @bi - the bitmap info to be loaded. Requires that bi->bh is valid.
1026  *
1027  * This routine counts how many free bits there are, finding the first zero
1028  * as a side effect. Could also be implemented as a loop of test_bit() calls, or
1029  * a loop of find_first_zero_bit() calls. This implementation is similar to
1030  * find_first_zero_bit(), but doesn't return after it finds the first bit.
1031  * Should only be called on fs mount, but should be fairly efficient anyways.
1032  *
1033  * bi->first_zero_hint is considered unset if it == 0, since the bitmap itself
1034  * will * invariably occupt block 0 represented in the bitmap. The only
1035  * exception to this is when free_count also == 0, since there will be no
1036  * free blocks at all.
1037  */
1038
1039 static void load_bitmap_info_data (struct super_block *sb,
1040                                    struct reiserfs_bitmap_info *bi)
1041 {
1042     unsigned long *cur = (unsigned long *)bi->bh->b_data;
1043
1044     while ((char *)cur < (bi->bh->b_data + sb->s_blocksize)) {
1045
1046         /* No need to scan if all 0's or all 1's.
1047          * Since we're only counting 0's, we can simply ignore all 1's */
1048         if (*cur == 0) {
1049             if (bi->first_zero_hint == 0) {
1050                 bi->first_zero_hint = ((char *)cur - bi->bh->b_data) << 3;
1051             }
1052             bi->free_count += sizeof(unsigned long)*8;
1053         } else if (*cur != ~0L) {
1054             int b;
1055             for (b = 0; b < sizeof(unsigned long)*8; b++) {
1056                 if (!reiserfs_test_le_bit (b, cur)) {
1057                     bi->free_count ++;
1058                     if (bi->first_zero_hint == 0)
1059                         bi->first_zero_hint =
1060                                         (((char *)cur - bi->bh->b_data) << 3) + b;
1061                     }
1062                 }
1063             }
1064         cur ++;
1065     }
1066
1067 #ifdef CONFIG_REISERFS_CHECK
1068 // This outputs a lot of unneded info on big FSes
1069 //    reiserfs_warning ("bitmap loaded from block %d: %d free blocks",
1070 //                    bi->bh->b_blocknr, bi->free_count);
1071 #endif
1072 }
1073
1074 static int read_bitmaps (struct super_block * s)
1075 {
1076     int i, bmap_nr;
1077
1078     SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
1079     if (SB_AP_BITMAP (s) == 0)
1080         return 1;
1081     memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
1082     for (i = 0, bmap_nr = REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize + 1;
1083          i < SB_BMAP_NR(s); i++, bmap_nr = s->s_blocksize * 8 * i) {
1084         SB_AP_BITMAP (s)[i].bh = sb_getblk(s, bmap_nr);
1085         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh))
1086             ll_rw_block(READ, 1, &SB_AP_BITMAP(s)[i].bh);
1087     }
1088     for (i = 0; i < SB_BMAP_NR(s); i++) {
1089         wait_on_buffer(SB_AP_BITMAP (s)[i].bh);
1090         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
1091             reiserfs_warning(s,"sh-2029: reiserfs read_bitmaps: "
1092                          "bitmap block (#%lu) reading failed",
1093                          SB_AP_BITMAP(s)[i].bh->b_blocknr);
1094             for (i = 0; i < SB_BMAP_NR(s); i++)
1095                 brelse(SB_AP_BITMAP(s)[i].bh);
1096             vfree(SB_AP_BITMAP(s));
1097             SB_AP_BITMAP(s) = NULL;
1098             return 1;
1099         }
1100         load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1101     }
1102     return 0;
1103 }
1104
1105 static int read_old_bitmaps (struct super_block * s)
1106 {
1107   int i ;
1108   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK(s);
1109   int bmp1 = (REISERFS_OLD_DISK_OFFSET_IN_BYTES / s->s_blocksize) + 1;  /* first of bitmap blocks */
1110
1111   /* read true bitmap */
1112   SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1113   if (SB_AP_BITMAP (s) == 0)
1114     return 1;
1115
1116   memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1117
1118   for (i = 0; i < sb_bmap_nr(rs); i ++) {
1119     SB_AP_BITMAP (s)[i].bh = sb_bread (s, bmp1 + i);
1120     if (!SB_AP_BITMAP (s)[i].bh)
1121       return 1;
1122     load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1123   }
1124
1125   return 0;
1126 }
1127
1128 void check_bitmap (struct super_block * s)
1129 {
1130   int i = 0;
1131   int free = 0;
1132   char * buf;
1133
1134   while (i < SB_BLOCK_COUNT (s)) {
1135     buf = SB_AP_BITMAP (s)[i / (s->s_blocksize * 8)].bh->b_data;
1136     if (!reiserfs_test_le_bit (i % (s->s_blocksize * 8), buf))
1137       free ++;
1138     i ++;
1139   }
1140
1141   if (free != SB_FREE_BLOCKS (s))
1142     reiserfs_warning (s,"vs-4000: check_bitmap: %d free blocks, must be %d",
1143                       free, SB_FREE_BLOCKS (s));
1144 }
1145
1146 static int read_super_block (struct super_block * s, int offset)
1147 {
1148     struct buffer_head * bh;
1149     struct reiserfs_super_block * rs;
1150     int fs_blocksize;
1151
1152
1153     bh = sb_bread (s, offset / s->s_blocksize);
1154     if (!bh) {
1155       reiserfs_warning (s, "sh-2006: read_super_block: "
1156               "bread failed (dev %s, block %lu, size %lu)",
1157               reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1158       return 1;
1159     }
1160
1161     rs = (struct reiserfs_super_block *)bh->b_data;
1162     if (!is_any_reiserfs_magic_string (rs)) {
1163       brelse (bh);
1164       return 1;
1165     }
1166
1167     //
1168     // ok, reiserfs signature (old or new) found in at the given offset
1169     //
1170     fs_blocksize = sb_blocksize(rs);
1171     brelse (bh);
1172     sb_set_blocksize (s, fs_blocksize);
1173
1174     bh = sb_bread (s, offset / s->s_blocksize);
1175     if (!bh) {
1176         reiserfs_warning (s, "sh-2007: read_super_block: "
1177                 "bread failed (dev %s, block %lu, size %lu)\n",
1178                 reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1179         return 1;
1180     }
1181
1182     rs = (struct reiserfs_super_block *)bh->b_data;
1183     if (sb_blocksize(rs) != s->s_blocksize) {
1184         reiserfs_warning (s, "sh-2011: read_super_block: "
1185                 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1186                 reiserfs_bdevname (s), (unsigned long long)bh->b_blocknr, s->s_blocksize);
1187         brelse (bh);
1188         return 1;
1189     }
1190
1191     if ( rs->s_v1.s_root_block == -1 ) {
1192        brelse(bh) ;
1193        reiserfs_warning (s, "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1194               "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1195               "get newer reiserfsprogs package");
1196        return 1;
1197     }
1198
1199     SB_BUFFER_WITH_SB (s) = bh;
1200     SB_DISK_SUPER_BLOCK (s) = rs;
1201
1202     if (is_reiserfs_jr (rs)) {
1203         /* magic is of non-standard journal filesystem, look at s_version to
1204            find which format is in use */
1205         if (sb_version(rs) == REISERFS_VERSION_2)
1206           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.6\""
1207                   " with non-standard journal");
1208         else if (sb_version(rs) == REISERFS_VERSION_1)
1209           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.5\""
1210                   " with non-standard journal");
1211         else {
1212           reiserfs_warning (s, "sh-2012: read_super_block: found unknown "
1213                             "format \"%u\" of reiserfs with non-standard magic",
1214                             sb_version(rs));
1215         return 1;
1216         }
1217     }
1218     else
1219       /* s_version of standard format may contain incorrect information,
1220          so we just look at the magic string */
1221       reiserfs_info (s, "found reiserfs format \"%s\" with standard journal\n",
1222               is_reiserfs_3_5 (rs) ? "3.5" : "3.6");
1223
1224     s->s_op = &reiserfs_sops;
1225     s->s_export_op = &reiserfs_export_ops;
1226
1227     /* new format is limited by the 32 bit wide i_blocks field, want to
1228     ** be one full block below that.
1229     */
1230     s->s_maxbytes = (512LL << 32) - s->s_blocksize ;
1231     return 0;
1232 }
1233
1234
1235
1236 /* after journal replay, reread all bitmap and super blocks */
1237 static int reread_meta_blocks(struct super_block *s) {
1238   int i ;
1239   ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s))) ;
1240   wait_on_buffer(SB_BUFFER_WITH_SB(s)) ;
1241   if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1242     reiserfs_warning (s, "reread_meta_blocks, error reading the super") ;
1243     return 1 ;
1244   }
1245
1246   for (i = 0; i < SB_BMAP_NR(s) ; i++) {
1247     ll_rw_block(READ, 1, &(SB_AP_BITMAP(s)[i].bh)) ;
1248     wait_on_buffer(SB_AP_BITMAP(s)[i].bh) ;
1249     if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
1250       reiserfs_warning (s, "reread_meta_blocks, error reading bitmap block number %d at %llu",
1251         i, (unsigned long long)SB_AP_BITMAP(s)[i].bh->b_blocknr) ;
1252       return 1 ;
1253     }
1254   }
1255   return 0 ;
1256
1257 }
1258
1259
1260 /////////////////////////////////////////////////////
1261 // hash detection stuff
1262
1263
1264 // if root directory is empty - we set default - Yura's - hash and
1265 // warn about it
1266 // FIXME: we look for only one name in a directory. If tea and yura
1267 // bith have the same value - we ask user to send report to the
1268 // mailing list
1269 __u32 find_hash_out (struct super_block * s)
1270 {
1271     int retval;
1272     struct inode * inode;
1273     struct cpu_key key;
1274     INITIALIZE_PATH (path);
1275     struct reiserfs_dir_entry de;
1276     __u32 hash = DEFAULT_HASH;
1277
1278     inode = s->s_root->d_inode;
1279
1280     do { // Some serious "goto"-hater was there ;)
1281         u32 teahash, r5hash, yurahash;
1282
1283         make_cpu_key (&key, inode, ~0, TYPE_DIRENTRY, 3);
1284         retval = search_by_entry_key (s, &key, &path, &de);
1285         if (retval == IO_ERROR) {
1286             pathrelse (&path);
1287             return UNSET_HASH ;
1288         }
1289         if (retval == NAME_NOT_FOUND)
1290             de.de_entry_num --;
1291         set_de_name_and_namelen (&de);
1292         if (deh_offset( &(de.de_deh[de.de_entry_num]) ) == DOT_DOT_OFFSET) {
1293             /* allow override in this case */
1294             if (reiserfs_rupasov_hash(s)) {
1295                 hash = YURA_HASH ;
1296             }
1297             reiserfs_warning(s,"FS seems to be empty, autodetect "
1298                              "is using the default hash");
1299             break;
1300         }
1301         r5hash=GET_HASH_VALUE (r5_hash (de.de_name, de.de_namelen));
1302         teahash=GET_HASH_VALUE (keyed_hash (de.de_name, de.de_namelen));
1303         yurahash=GET_HASH_VALUE (yura_hash (de.de_name, de.de_namelen));
1304         if ( ( (teahash == r5hash) && (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) ) ||
1305              ( (teahash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ||
1306              ( (r5hash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ) {
1307             reiserfs_warning(s,"Unable to automatically detect hash function. "
1308                              "Please mount with -o hash={tea,rupasov,r5}",
1309                              reiserfs_bdevname (s));
1310             hash = UNSET_HASH;
1311             break;
1312         }
1313         if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == yurahash)
1314             hash = YURA_HASH;
1315         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == teahash)
1316             hash = TEA_HASH;
1317         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == r5hash)
1318             hash = R5_HASH;
1319         else {
1320             reiserfs_warning (s,"Unrecognised hash function");
1321             hash = UNSET_HASH;
1322         }
1323     } while (0);
1324
1325     pathrelse (&path);
1326     return hash;
1327 }
1328
1329 // finds out which hash names are sorted with
1330 static int what_hash (struct super_block * s)
1331 {
1332     __u32 code;
1333
1334     code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1335
1336     /* reiserfs_hash_detect() == true if any of the hash mount options
1337     ** were used.  We must check them to make sure the user isn't
1338     ** using a bad hash value
1339     */
1340     if (code == UNSET_HASH || reiserfs_hash_detect(s))
1341         code = find_hash_out (s);
1342
1343     if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1344         /* detection has found the hash, and we must check against the
1345         ** mount options
1346         */
1347         if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1348             reiserfs_warning (s, "Error, %s hash detected, "
1349                    "unable to force rupasov hash", reiserfs_hashname(code)) ;
1350             code = UNSET_HASH ;
1351         } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1352             reiserfs_warning (s, "Error, %s hash detected, "
1353                    "unable to force tea hash", reiserfs_hashname(code)) ;
1354             code = UNSET_HASH ;
1355         } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1356             reiserfs_warning (s, "Error, %s hash detected, "
1357                    "unable to force r5 hash", reiserfs_hashname(code)) ;
1358             code = UNSET_HASH ;
1359         }
1360     } else {
1361         /* find_hash_out was not called or could not determine the hash */
1362         if (reiserfs_rupasov_hash(s)) {
1363             code = YURA_HASH ;
1364         } else if (reiserfs_tea_hash(s)) {
1365             code = TEA_HASH ;
1366         } else if (reiserfs_r5_hash(s)) {
1367             code = R5_HASH ;
1368         }
1369     }
1370
1371     /* if we are mounted RW, and we have a new valid hash code, update
1372     ** the super
1373     */
1374     if (code != UNSET_HASH &&
1375         !(s->s_flags & MS_RDONLY) &&
1376         code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1377         set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1378     }
1379     return code;
1380 }
1381
1382 // return pointer to appropriate function
1383 static hashf_t hash_function (struct super_block * s)
1384 {
1385     switch (what_hash (s)) {
1386     case TEA_HASH:
1387         reiserfs_info (s, "Using tea hash to sort names\n");
1388         return keyed_hash;
1389     case YURA_HASH:
1390         reiserfs_info (s, "Using rupasov hash to sort names\n");
1391         return yura_hash;
1392     case R5_HASH:
1393         reiserfs_info (s, "Using r5 hash to sort names\n");
1394         return r5_hash;
1395     }
1396     return NULL;
1397 }
1398
1399 // this is used to set up correct value for old partitions
1400 int function2code (hashf_t func)
1401 {
1402     if (func == keyed_hash)
1403         return TEA_HASH;
1404     if (func == yura_hash)
1405         return YURA_HASH;
1406     if (func == r5_hash)
1407         return R5_HASH;
1408
1409     BUG() ; // should never happen
1410
1411     return 0;
1412 }
1413
1414 #define SWARN(silent, s, ...)                   \
1415         if (!(silent))                          \
1416                 reiserfs_warning (s, __VA_ARGS__)
1417
1418 static int reiserfs_fill_super (struct super_block * s, void * data, int silent)
1419 {
1420     struct inode *root_inode;
1421     int j;
1422     struct reiserfs_transaction_handle th ;
1423     int old_format = 0;
1424     unsigned long blocks;
1425     unsigned int commit_max_age = 0;
1426     int jinit_done = 0 ;
1427     struct reiserfs_iget_args args ;
1428     struct reiserfs_super_block * rs;
1429     char *jdev_name;
1430     struct reiserfs_sb_info *sbi;
1431     int errval = -EINVAL;
1432
1433     sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1434     if (!sbi) {
1435         errval = -ENOMEM;
1436         goto error;
1437     }
1438     s->s_fs_info = sbi;
1439     memset (sbi, 0, sizeof (struct reiserfs_sb_info));
1440     /* Set default values for options: non-aggressive tails, RO on errors */
1441     REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1442     REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1443     /* no preallocation minimum, be smart in
1444        reiserfs_file_write instead */
1445     REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1446     /* Preallocate by 16 blocks (17-1) at once */
1447     REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1448     /* Initialize the rwsem for xattr dir */
1449     init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
1450
1451     /* setup default block allocator options */
1452     reiserfs_init_alloc_options(s);
1453
1454     jdev_name = NULL;
1455     if (reiserfs_parse_options (s, (char *) data, &(sbi->s_mount_opt), &blocks, &jdev_name, &commit_max_age) == 0) {
1456         goto error;
1457     }
1458
1459     if (blocks) {
1460         SWARN (silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1461                "for remount only");
1462         goto error;
1463     }
1464
1465     /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1466     if (!read_super_block (s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1467       old_format = 1;
1468     /* try new format (64-th 1k block), which can contain reiserfs super block */
1469     else if (read_super_block (s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1470       SWARN(silent, s, "sh-2021: reiserfs_fill_super: can not find reiserfs on %s", reiserfs_bdevname (s));
1471       goto error;
1472     }
1473
1474     rs = SB_DISK_SUPER_BLOCK (s);
1475     /* Let's do basic sanity check to verify that underlying device is not
1476        smaller than the filesystem. If the check fails then abort and scream,
1477        because bad stuff will happen otherwise. */
1478     if ( s->s_bdev && s->s_bdev->bd_inode && i_size_read(s->s_bdev->bd_inode) < sb_block_count(rs)*sb_blocksize(rs)) {
1479         SWARN (silent, s, "Filesystem on %s cannot be mounted because it is bigger than the device", reiserfs_bdevname(s));
1480         SWARN(silent, s, "You may need to run fsck or increase size of your LVM partition");
1481         SWARN(silent, s, "Or may be you forgot to reboot after fdisk when it told you to");
1482         goto error;
1483     }
1484
1485     sbi->s_mount_state = SB_REISERFS_STATE(s);
1486     sbi->s_mount_state = REISERFS_VALID_FS ;
1487
1488     if (old_format ? read_old_bitmaps(s) : read_bitmaps(s)) {
1489         SWARN(silent, s, "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1490         goto error;
1491     }
1492 #ifdef CONFIG_REISERFS_CHECK
1493     SWARN (silent, s, "CONFIG_REISERFS_CHECK is set ON");
1494     SWARN (silent, s, "- it is slow mode for debugging.");
1495 #endif
1496
1497     /* make data=ordered the default */
1498     if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1499         !reiserfs_data_writeback(s))
1500     {
1501          REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1502     }
1503
1504     if (reiserfs_data_log(s)) {
1505         reiserfs_info (s, "using journaled data mode\n");
1506     } else if (reiserfs_data_ordered(s)) {
1507         reiserfs_info (s, "using ordered data mode\n");
1508     } else {
1509         reiserfs_info (s, "using writeback data mode\n");
1510     }
1511     if (reiserfs_barrier_flush(s)) {
1512         printk("reiserfs: using flush barriers\n");
1513     }
1514
1515     // set_device_ro(s->s_dev, 1) ;
1516     if( journal_init(s, jdev_name, old_format, commit_max_age) ) {
1517         SWARN(silent, s, "sh-2022: reiserfs_fill_super: unable to initialize journal space") ;
1518         goto error ;
1519     } else {
1520         jinit_done = 1 ; /* once this is set, journal_release must be called
1521                          ** if we error out of the mount
1522                          */
1523     }
1524     if (reread_meta_blocks(s)) {
1525         SWARN(silent, s, "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init") ;
1526         goto error ;
1527     }
1528
1529     if (replay_only (s))
1530         goto error;
1531
1532     if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1533         SWARN(silent, s, "clm-7000: Detected readonly device, marking FS readonly") ;
1534         s->s_flags |= MS_RDONLY ;
1535     }
1536     args.objectid = REISERFS_ROOT_OBJECTID ;
1537     args.dirid = REISERFS_ROOT_PARENT_OBJECTID ;
1538     root_inode = iget5_locked (s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor, reiserfs_init_locked_inode, (void *)(&args));
1539     if (!root_inode) {
1540         SWARN(silent, s, "jmacd-10: reiserfs_fill_super: get root inode failed");
1541         goto error;
1542     }
1543
1544     if (root_inode->i_state & I_NEW) {
1545         reiserfs_read_locked_inode(root_inode, &args);
1546         unlock_new_inode(root_inode);
1547     }
1548
1549     s->s_root = d_alloc_root(root_inode);
1550     if (!s->s_root) {
1551         iput(root_inode);
1552         goto error;
1553     }
1554
1555     // define and initialize hash function
1556     sbi->s_hash_function = hash_function (s);
1557     if (sbi->s_hash_function == NULL) {
1558       dput(s->s_root) ;
1559       s->s_root = NULL ;
1560       goto error ;
1561     }
1562
1563     if (is_reiserfs_3_5 (rs) || (is_reiserfs_jr (rs) && SB_VERSION (s) == REISERFS_VERSION_1))
1564         set_bit(REISERFS_3_5, &(sbi->s_properties));
1565     else
1566         set_bit(REISERFS_3_6, &(sbi->s_properties));
1567
1568     if (!(s->s_flags & MS_RDONLY)) {
1569
1570         errval = journal_begin(&th, s, 1) ;
1571         if (errval) {
1572             dput (s->s_root);
1573             s->s_root = NULL;
1574             goto error;
1575         }
1576         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1577
1578         set_sb_umount_state( rs, REISERFS_ERROR_FS );
1579         set_sb_fs_state (rs, 0);
1580
1581         if (old_format_only(s)) {
1582           /* filesystem of format 3.5 either with standard or non-standard
1583              journal */
1584           if (convert_reiserfs (s)) {
1585             /* and -o conv is given */
1586             if(!silent)
1587               reiserfs_info (s,"converting 3.5 filesystem to the 3.6 format") ;
1588
1589             if (is_reiserfs_3_5 (rs))
1590               /* put magic string of 3.6 format. 2.2 will not be able to
1591                  mount this filesystem anymore */
1592               memcpy (rs->s_v1.s_magic, reiserfs_3_6_magic_string,
1593                       sizeof (reiserfs_3_6_magic_string));
1594
1595             set_sb_version(rs,REISERFS_VERSION_2);
1596             reiserfs_convert_objectid_map_v1(s) ;
1597             set_bit(REISERFS_3_6, &(sbi->s_properties));
1598             clear_bit(REISERFS_3_5, &(sbi->s_properties));
1599           } else if (!silent){
1600             reiserfs_info (s, "using 3.5.x disk format\n") ;
1601           }
1602         }
1603
1604         journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1605         errval = journal_end(&th, s, 1) ;
1606         if (errval) {
1607             dput (s->s_root);
1608             s->s_root = NULL;
1609             goto error;
1610         }
1611
1612         if ((errval = reiserfs_xattr_init (s, s->s_flags))) {
1613             dput (s->s_root);
1614             s->s_root = NULL;
1615             goto error;
1616         }
1617
1618         /* look for files which were to be removed in previous session */
1619         finish_unfinished (s);
1620     } else {
1621         if ( old_format_only(s) && !silent) {
1622             reiserfs_info (s, "using 3.5.x disk format\n") ;
1623         }
1624
1625         if ((errval = reiserfs_xattr_init (s, s->s_flags))) {
1626             dput (s->s_root);
1627             s->s_root = NULL;
1628             goto error;
1629         }
1630     }
1631     // mark hash in super block: it could be unset. overwrite should be ok
1632     set_sb_hash_function_code( rs, function2code(sbi->s_hash_function ) );
1633
1634     handle_attrs( s );
1635
1636     reiserfs_proc_info_init( s );
1637
1638     init_waitqueue_head (&(sbi->s_wait));
1639     sbi->bitmap_lock = SPIN_LOCK_UNLOCKED;
1640
1641     return (0);
1642
1643  error:
1644     if (jinit_done) { /* kill the commit thread, free journal ram */
1645         journal_release_error(NULL, s) ;
1646     }
1647     if (SB_DISK_SUPER_BLOCK (s)) {
1648         for (j = 0; j < SB_BMAP_NR (s); j ++) {
1649             if (SB_AP_BITMAP (s))
1650                 brelse (SB_AP_BITMAP (s)[j].bh);
1651         }
1652         if (SB_AP_BITMAP (s))
1653             vfree (SB_AP_BITMAP (s));
1654     }
1655     if (SB_BUFFER_WITH_SB (s))
1656         brelse(SB_BUFFER_WITH_SB (s));
1657
1658     if (sbi != NULL) {
1659         kfree(sbi);
1660     }
1661
1662     s->s_fs_info = NULL;
1663     return errval;
1664 }
1665
1666
1667 static int reiserfs_statfs (struct super_block * s, struct kstatfs * buf)
1668 {
1669   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s);
1670
1671   buf->f_namelen = (REISERFS_MAX_NAME (s->s_blocksize));
1672   buf->f_bfree   = sb_free_blocks(rs);
1673   buf->f_bavail  = buf->f_bfree;
1674   buf->f_blocks  = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1675   buf->f_bsize   = s->s_blocksize;
1676   /* changed to accommodate gcc folks.*/
1677   buf->f_type    =  REISERFS_SUPER_MAGIC;
1678   return 0;
1679 }
1680
1681 static struct super_block*
1682 get_super_block (struct file_system_type *fs_type, int flags,
1683                  const char *dev_name, void *data)
1684 {
1685         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
1686 }
1687
1688 static int __init
1689 init_reiserfs_fs ( void )
1690 {
1691         int ret;
1692
1693         if ((ret = init_inodecache ())) {
1694                 return ret;
1695         }
1696
1697         if ((ret = reiserfs_xattr_register_handlers ()))
1698             goto failed_reiserfs_xattr_register_handlers;
1699
1700         reiserfs_proc_info_global_init ();
1701         reiserfs_proc_register_global ("version", reiserfs_global_version_in_proc);
1702
1703         ret = register_filesystem (& reiserfs_fs_type);
1704
1705         if (ret == 0) {
1706                 return 0;
1707         }
1708
1709         reiserfs_xattr_unregister_handlers ();
1710
1711 failed_reiserfs_xattr_register_handlers:
1712         reiserfs_proc_unregister_global ("version");
1713         reiserfs_proc_info_global_done ();
1714         destroy_inodecache ();
1715
1716         return ret;
1717 }
1718
1719 static void __exit
1720 exit_reiserfs_fs ( void )
1721 {
1722         reiserfs_xattr_unregister_handlers ();
1723         reiserfs_proc_unregister_global ("version");
1724         reiserfs_proc_info_global_done ();
1725         unregister_filesystem (& reiserfs_fs_type);
1726         destroy_inodecache ();
1727 }
1728
1729 struct file_system_type reiserfs_fs_type = {
1730         .owner          = THIS_MODULE,
1731         .name           = "reiserfs",
1732         .get_sb         = get_super_block,
1733         .kill_sb        = kill_block_super,
1734         .fs_flags       = FS_REQUIRES_DEV,
1735 };
1736
1737 MODULE_DESCRIPTION ("ReiserFS journaled filesystem");
1738 MODULE_AUTHOR      ("Hans Reiser <reiser@namesys.com>");
1739 MODULE_LICENSE     ("GPL");
1740
1741 module_init (init_reiserfs_fs);
1742 module_exit (exit_reiserfs_fs);