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