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_HWCACHE_ALIGN|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 block-allocator=" and bits which are to be set in
 553    s_mount_opt of reiserfs specific part of in-core super block */
 554 static const arg_desc_t balloc[] = {
 555     {"noborder", 1<<REISERFS_NO_BORDER, 0},
 556     {"border", 0, 1<<REISERFS_NO_BORDER},
 557     {"no_unhashed_relocation", 1<<REISERFS_NO_UNHASHED_RELOCATION, 0},
 558     {"hashed_relocation", 1<<REISERFS_HASHED_RELOCATION, 0},
 559     {"test4", 1<<REISERFS_TEST4, 0},
 560     {"notest4", 0, 1<<REISERFS_TEST4},
 561     {NULL, 0, 0}
 562 };
 563
 564 static const arg_desc_t tails[] = {
 565     {"on", 1<<REISERFS_LARGETAIL, 1<<REISERFS_SMALLTAIL},
 566     {"off", 0, (1<<REISERFS_LARGETAIL)|(1<<REISERFS_SMALLTAIL)},
 567     {"small", 1<<REISERFS_SMALLTAIL, 1<<REISERFS_LARGETAIL},
 568     {NULL, 0, 0}
 569 };
 570
 571 int reiserfs_default_io_size = 128 * 1024; /* Default recommended I/O size is 128k.
 572                                               There might be broken applications that are
 573                                               confused by this. Use nolargeio mount option
 574                                               to get usual i/o size = PAGE_SIZE.
 575                                             */
 576
 577 /* proceed only one option from a list *cur - string containing of mount options
 578    opts - array of options which are accepted
 579    opt_arg - if option is found and requires an argument and if it is specifed
 580    in the input - pointer to the argument is stored here
 581    bit_flags - if option requires to set a certain bit - it is set here
 582    return -1 if unknown option is found, opt->arg_required otherwise */
 583 static int reiserfs_getopt ( struct super_block * s, char ** cur, opt_desc_t * opts, char ** opt_arg,
 584                             unsigned long * bit_flags)
 585 {
 586     char * p;
 587     /* foo=bar,
 588        ^   ^  ^
 589        |   |  +-- option_end
 590        |   +-- arg_start
 591        +-- option_start
 592     */
 593     const opt_desc_t * opt;
 594     const arg_desc_t * arg;
 595
 596
 597     p = *cur;
 598
 599     /* assume argument cannot contain commas */
 600     *cur = strchr (p, ',');
 601     if (*cur) {
 602         *(*cur) = '\0';
 603         (*cur) ++;
 604     }
 605
 606     if ( !strncmp (p, "alloc=", 6) ) {
 607         /* Ugly special case, probably we should redo options parser so that
 608            it can understand several arguments for some options, also so that
 609            it can fill several bitfields with option values. */
 610         if ( reiserfs_parse_alloc_options( s, p + 6) ) {
 611             return -1;
 612         } else {
 613             return 0;
 614         }
 615     }
 616
 617
 618     /* for every option in the list */
 619     for (opt = opts; opt->option_name; opt ++) {
 620         if (!strncmp (p, opt->option_name, strlen (opt->option_name))) {
 621             if (bit_flags) {
 622                 *bit_flags &= ~opt->clrmask;
 623                 *bit_flags |= opt->setmask;
 624             }
 625             break;
 626         }
 627     }
 628     if (!opt->option_name) {
 629         reiserfs_warning (s, "unknown mount option \"%s\"", p);
 630         return -1;
 631     }
 632
 633     p += strlen (opt->option_name);
 634     switch (*p) {
 635     case '=':
 636         if (!opt->arg_required) {
 637             reiserfs_warning (s, "the option \"%s\" does not require an argument",
 638                     opt->option_name);
 639             return -1;
 640         }
 641         break;
 642
 643     case 0:
 644         if (opt->arg_required) {
 645             reiserfs_warning (s, "the option \"%s\" requires an argument", opt->option_name);
 646             return -1;
 647         }
 648         break;
 649     default:
 650         reiserfs_warning (s, "head of option \"%s\" is only correct", opt->option_name);
 651         return -1;
 652     }
 653
 654     /* move to the argument, or to next option if argument is not required */
 655     p ++;
 656
 657     if ( opt->arg_required && !strlen (p) ) {
 658         /* this catches "option=," */
 659         reiserfs_warning (s, "empty argument for \"%s\"", opt->option_name);
 660         return -1;
 661     }
 662
 663     if (!opt->values) {
 664         /* *=NULLopt_arg contains pointer to argument */
 665         *opt_arg = p;
 666         return opt->arg_required;
 667     }
 668
 669     /* values possible for this option are listed in opt->values */
 670     for (arg = opt->values; arg->value; arg ++) {
 671         if (!strcmp (p, arg->value)) {
 672             if (bit_flags) {
 673                 *bit_flags &= ~arg->clrmask;
 674                 *bit_flags |= arg->setmask;
 675             }
 676             return opt->arg_required;
 677         }
 678     }
 679
 680     reiserfs_warning (s, "bad value \"%s\" for option \"%s\"", p, opt->option_name);
 681     return -1;
 682 }
 683
 684 /* returns 0 if something is wrong in option string, 1 - otherwise */
 685 static int reiserfs_parse_options (struct super_block * s, char * options, /* string given via mount's -o */
 686                                    unsigned long * mount_options,
 687                                    /* after the parsing phase, contains the
 688                                       collection of bitflags defining what
 689                                       mount options were selected. */
 690                                    unsigned long * blocks, /* strtol-ed from NNN of resize=NNN */
 691                                    char ** jdev_name,
 692                                    unsigned int * commit_max_age)
 693 {
 694     int c;
 695     char * arg = NULL;
 696     char * pos;
 697     opt_desc_t opts[] = {
 698         {"tails", 't', tails, 0, 0}, /* Compatibility stuff, so that -o notail for old setups still work */
 699         {"notail", 0, 0, 0,  (1<<REISERFS_LARGETAIL)|(1<<REISERFS_SMALLTAIL)},
 700         {"conv", 0, 0, 1<<REISERFS_CONVERT, 0},
 701         {"attrs", 0, 0, 1<<REISERFS_ATTRS, 0},
 702         {"noattrs", 0, 0, 0, 1<<REISERFS_ATTRS},
 703         {"user_xattr", 0, 0, 1<<REISERFS_XATTRS_USER, 0},
 704         {"nouser_xattr", 0, 0, 0, 1<<REISERFS_XATTRS_USER},
 705 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
 706         {"acl", 0, 0, 1<<REISERFS_POSIXACL, 0},
 707         {"noacl", 0, 0, 0, 1<<REISERFS_POSIXACL},
 708 #endif
 709         {"nolog", 0, 0, 0, 0}, /* This is unsupported */
 710         {"replayonly", 0, 0, 1<<REPLAYONLY, 0},
 711         {"block-allocator", 'a', balloc, 0, 0},
 712         {"data", 'd', logging_mode, 0, 0},
 713         {"resize", 'r', 0, 0, 0},
 714         {"jdev", 'j', 0, 0, 0},
 715         {"nolargeio", 'w', 0, 0, 0},
 716         {"commit", 'c', 0, 0, 0},
 717         {"usrquota", 0, 0, 0, 0},
 718         {"grpquota", 0, 0, 0, 0},
 719         {NULL, 0, 0, 0, 0}
 720     };
 721
 722     *blocks = 0;
 723     if (!options || !*options)
 724         /* use default configuration: create tails, journaling on, no
 725            conversion to newest format */
 726         return 1;
 727
 728     for (pos = options; pos; ) {
 729         c = reiserfs_getopt (s, &pos, opts, &arg, mount_options);
 730         if (c == -1)
 731             /* wrong option is given */
 732             return 0;
 733
 734         if (c == 'r') {
 735             char * p;
 736
 737             p = 0;
 738             /* "resize=NNN" */
 739             *blocks = simple_strtoul (arg, &p, 0);
 740             if (*p != '\0') {
 741                 /* NNN does not look like a number */
 742                 reiserfs_warning (s, "reiserfs_parse_options: bad value %s", arg);
 743                 return 0;
 744             }
 745         }
 746
 747         if ( c == 'c' ) {
 748                 char *p = 0;
 749                 unsigned long val = simple_strtoul (arg, &p, 0);
 750                 /* commit=NNN (time in seconds) */
 751                 if ( *p != '\0' || val >= (unsigned int)-1) {
 752                         reiserfs_warning (s, "reiserfs_parse_options: bad value %s", arg);                      return 0;
 753                 }
 754                 *commit_max_age = (unsigned int)val;
 755         }
 756
 757         if ( c == 'w' ) {
 758                 char *p=0;
 759                 int val = simple_strtoul (arg, &p, 0);
 760
 761                 if ( *p != '\0') {
 762                     reiserfs_warning (s, "reiserfs_parse_options: non-numeric value %s for nolargeio option", arg);
 763                     return 0;
 764                 }
 765                 if ( val )
 766                     reiserfs_default_io_size = PAGE_SIZE;
 767                 else
 768                     reiserfs_default_io_size = 128 * 1024;
 769         }
 770
 771         if (c == 'j') {
 772             if (arg && *arg && jdev_name) {
 773                 if ( *jdev_name ) { //Hm, already assigned?
 774                     reiserfs_warning (s, "reiserfs_parse_options: journal device was already  specified to be %s", *jdev_name);
 775                     return 0;
 776                 }
 777                 *jdev_name = arg;
 778             }
 779         }
 780     }
 781
 782     return 1;
 783 }
 784
 785 static void switch_data_mode(struct super_block *s, unsigned long mode) {
 786     REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
 787                                        (1 << REISERFS_DATA_ORDERED) |
 788                                        (1 << REISERFS_DATA_WRITEBACK));
 789     REISERFS_SB(s)->s_mount_opt |= (1 << mode);
 790 }
 791
 792 static void handle_data_mode(struct super_block *s, unsigned long mount_options)
 793 {
 794     if (mount_options & (1 << REISERFS_DATA_LOG)) {
 795         if (!reiserfs_data_log(s)) {
 796             switch_data_mode(s, REISERFS_DATA_LOG);
 797             reiserfs_info (s, "switching to journaled data mode\n");
 798         }
 799     } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
 800         if (!reiserfs_data_ordered(s)) {
 801             switch_data_mode(s, REISERFS_DATA_ORDERED);
 802             reiserfs_info (s, "switching to ordered data mode\n");
 803         }
 804     } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
 805         if (!reiserfs_data_writeback(s)) {
 806             switch_data_mode(s, REISERFS_DATA_WRITEBACK);
 807             reiserfs_info (s, "switching to writeback data mode\n");
 808         }
 809     }
 810 }
 811
 812 static void handle_attrs( struct super_block *s )
 813 {
 814         struct reiserfs_super_block * rs;
 815
 816         if( reiserfs_attrs( s ) ) {
 817                 rs = SB_DISK_SUPER_BLOCK (s);
 818                 if( old_format_only(s) ) {
 819                         reiserfs_warning(s, "reiserfs: cannot support attributes on 3.5.x disk format" );
 820                         REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
 821                         return;
 822                 }
 823                 if( !( le32_to_cpu( rs -> s_flags ) & reiserfs_attrs_cleared ) ) {
 824                                 reiserfs_warning(s, "reiserfs: cannot support attributes until flag is set in super-block" );
 825                                 REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
 826                 }
 827         }
 828 }
 829
 830 static int reiserfs_remount (struct super_block * s, int * mount_flags, char * arg)
 831 {
 832   struct reiserfs_super_block * rs;
 833   struct reiserfs_transaction_handle th ;
 834   unsigned long blocks;
 835   unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
 836   unsigned long safe_mask = 0;
 837   unsigned int commit_max_age = (unsigned int)-1;
 838
 839   rs = SB_DISK_SUPER_BLOCK (s);
 840
 841   if (!reiserfs_parse_options(s, arg, &mount_options, &blocks, NULL, &commit_max_age))
 842     return -EINVAL;
 843
 844   handle_attrs(s);
 845
 846   /* Add options that are safe here */
 847   safe_mask |= 1 << REISERFS_SMALLTAIL;
 848   safe_mask |= 1 << REISERFS_LARGETAIL;
 849   safe_mask |= 1 << REISERFS_NO_BORDER;
 850   safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
 851   safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
 852   safe_mask |= 1 << REISERFS_TEST4;
 853   safe_mask |= 1 << REISERFS_ATTRS;
 854   safe_mask |= 1 << REISERFS_XATTRS_USER;
 855   safe_mask |= 1 << REISERFS_POSIXACL;
 856
 857   /* Update the bitmask, taking care to keep
 858    * the bits we're not allowed to change here */
 859   REISERFS_SB(s)->s_mount_opt = (REISERFS_SB(s)->s_mount_opt & ~safe_mask) |  (mount_options & safe_mask);
 860
 861   if(commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
 862     SB_JOURNAL_MAX_COMMIT_AGE(s) = commit_max_age;
 863     SB_JOURNAL_MAX_TRANS_AGE(s) = commit_max_age;
 864   }
 865   else if(commit_max_age == 0)
 866   {
 867     /* 0 means restore defaults. */
 868     SB_JOURNAL_MAX_COMMIT_AGE(s) = SB_JOURNAL_DEFAULT_MAX_COMMIT_AGE(s);
 869     SB_JOURNAL_MAX_TRANS_AGE(s) = JOURNAL_MAX_TRANS_AGE;
 870   }
 871
 872   if(blocks) {
 873     int rc = reiserfs_resize(s, blocks);
 874     if (rc != 0)
 875       return rc;
 876   }
 877
 878   if (*mount_flags & MS_RDONLY) {
 879     reiserfs_xattr_init (s, *mount_flags);
 880     /* remount read-only */
 881     if (s->s_flags & MS_RDONLY)
 882       /* it is read-only already */
 883       return 0;
 884     /* try to remount file system with read-only permissions */
 885     if (sb_umount_state(rs) == REISERFS_VALID_FS || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
 886       return 0;
 887     }
 888
 889     journal_begin(&th, s, 10) ;
 890     /* Mounting a rw partition read-only. */
 891     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
 892     set_sb_umount_state( rs, REISERFS_SB(s)->s_mount_state );
 893     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
 894   } else {
 895     /* remount read-write */
 896     if (!(s->s_flags & MS_RDONLY)) {
 897         reiserfs_xattr_init (s, *mount_flags);
 898         return 0; /* We are read-write already */
 899     }
 900
 901     handle_data_mode(s, mount_options);
 902     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs) ;
 903     s->s_flags &= ~MS_RDONLY ; /* now it is safe to call journal_begin */
 904     journal_begin(&th, s, 10) ;
 905
 906     /* Mount a partition which is read-only, read-write */
 907     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
 908     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
 909     s->s_flags &= ~MS_RDONLY;
 910     set_sb_umount_state( rs, REISERFS_ERROR_FS );
 911     /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
 912     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
 913     REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS ;
 914   }
 915   /* this will force a full flush of all journal lists */
 916   SB_JOURNAL(s)->j_must_wait = 1 ;
 917   journal_end(&th, s, 10) ;
 918   s->s_dirt = 0;
 919
 920   if (!( *mount_flags & MS_RDONLY ) ) {
 921     finish_unfinished( s );
 922     reiserfs_xattr_init (s, *mount_flags);
 923   }
 924
 925   return 0;
 926 }
 927
 928 /* load_bitmap_info_data - Sets up the reiserfs_bitmap_info structure from disk.
 929  * @sb - superblock for this filesystem
 930  * @bi - the bitmap info to be loaded. Requires that bi->bh is valid.
 931  *
 932  * This routine counts how many free bits there are, finding the first zero
 933  * as a side effect. Could also be implemented as a loop of test_bit() calls, or
 934  * a loop of find_first_zero_bit() calls. This implementation is similar to
 935  * find_first_zero_bit(), but doesn't return after it finds the first bit.
 936  * Should only be called on fs mount, but should be fairly efficient anyways.
 937  *
 938  * bi->first_zero_hint is considered unset if it == 0, since the bitmap itself
 939  * will * invariably occupt block 0 represented in the bitmap. The only
 940  * exception to this is when free_count also == 0, since there will be no
 941  * free blocks at all.
 942  */
 943
 944 static void load_bitmap_info_data (struct super_block *sb,
 945                                    struct reiserfs_bitmap_info *bi)
 946 {
 947     unsigned long *cur = (unsigned long *)bi->bh->b_data;
 948
 949     while ((char *)cur < (bi->bh->b_data + sb->s_blocksize)) {
 950
 951         /* No need to scan if all 0's or all 1's.
 952          * Since we're only counting 0's, we can simply ignore all 1's */
 953         if (*cur == 0) {
 954             if (bi->first_zero_hint == 0) {
 955                 bi->first_zero_hint = ((char *)cur - bi->bh->b_data) << 3;
 956             }
 957             bi->free_count += sizeof(unsigned long)*8;
 958         } else if (*cur != ~0L) {
 959             int b;
 960             for (b = 0; b < sizeof(unsigned long)*8; b++) {
 961                 if (!reiserfs_test_le_bit (b, cur)) {
 962                     bi->free_count ++;
 963                     if (bi->first_zero_hint == 0)
 964                         bi->first_zero_hint =
 965                                         (((char *)cur - bi->bh->b_data) << 3) + b;
 966                     }
 967                 }
 968             }
 969         cur ++;
 970     }
 971
 972 #ifdef CONFIG_REISERFS_CHECK
 973 // This outputs a lot of unneded info on big FSes
 974 //    reiserfs_warning ("bitmap loaded from block %d: %d free blocks",
 975 //                    bi->bh->b_blocknr, bi->free_count);
 976 #endif
 977 }
 978
 979 static int read_bitmaps (struct super_block * s)
 980 {
 981     int i, bmap_nr;
 982
 983     SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
 984     if (SB_AP_BITMAP (s) == 0)
 985         return 1;
 986     memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
 987     for (i = 0, bmap_nr = REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize + 1;
 988          i < SB_BMAP_NR(s); i++, bmap_nr = s->s_blocksize * 8 * i) {
 989         SB_AP_BITMAP (s)[i].bh = sb_getblk(s, bmap_nr);
 990         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh))
 991             ll_rw_block(READ, 1, &SB_AP_BITMAP(s)[i].bh);
 992     }
 993     for (i = 0; i < SB_BMAP_NR(s); i++) {
 994         wait_on_buffer(SB_AP_BITMAP (s)[i].bh);
 995         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
 996             reiserfs_warning(s,"sh-2029: reiserfs read_bitmaps: "
 997                          "bitmap block (#%lu) reading failed",
 998                          SB_AP_BITMAP(s)[i].bh->b_blocknr);
 999             for (i = 0; i < SB_BMAP_NR(s); i++)
1000                 brelse(SB_AP_BITMAP(s)[i].bh);
1001             vfree(SB_AP_BITMAP(s));
1002             SB_AP_BITMAP(s) = NULL;
1003             return 1;
1004         }
1005         load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1006     }
1007     return 0;
1008 }
1009
1010 static int read_old_bitmaps (struct super_block * s)
1011 {
1012   int i ;
1013   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK(s);
1014   int bmp1 = (REISERFS_OLD_DISK_OFFSET_IN_BYTES / s->s_blocksize) + 1;  /* first of bitmap blocks */
1015
1016   /* read true bitmap */
1017   SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1018   if (SB_AP_BITMAP (s) == 0)
1019     return 1;
1020
1021   memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1022
1023   for (i = 0; i < sb_bmap_nr(rs); i ++) {
1024     SB_AP_BITMAP (s)[i].bh = sb_bread (s, bmp1 + i);
1025     if (!SB_AP_BITMAP (s)[i].bh)
1026       return 1;
1027     load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1028   }
1029
1030   return 0;
1031 }
1032
1033 void check_bitmap (struct super_block * s)
1034 {
1035   int i = 0;
1036   int free = 0;
1037   char * buf;
1038
1039   while (i < SB_BLOCK_COUNT (s)) {
1040     buf = SB_AP_BITMAP (s)[i / (s->s_blocksize * 8)].bh->b_data;
1041     if (!reiserfs_test_le_bit (i % (s->s_blocksize * 8), buf))
1042       free ++;
1043     i ++;
1044   }
1045
1046   if (free != SB_FREE_BLOCKS (s))
1047     reiserfs_warning (s,"vs-4000: check_bitmap: %d free blocks, must be %d",
1048                       free, SB_FREE_BLOCKS (s));
1049 }
1050
1051 static int read_super_block (struct super_block * s, int offset)
1052 {
1053     struct buffer_head * bh;
1054     struct reiserfs_super_block * rs;
1055     int fs_blocksize;
1056
1057
1058     bh = sb_bread (s, offset / s->s_blocksize);
1059     if (!bh) {
1060       reiserfs_warning (s, "sh-2006: read_super_block: "
1061               "bread failed (dev %s, block %lu, size %lu)",
1062               reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1063       return 1;
1064     }
1065
1066     rs = (struct reiserfs_super_block *)bh->b_data;
1067     if (!is_any_reiserfs_magic_string (rs)) {
1068       brelse (bh);
1069       return 1;
1070     }
1071
1072     //
1073     // ok, reiserfs signature (old or new) found in at the given offset
1074     //
1075     fs_blocksize = sb_blocksize(rs);
1076     brelse (bh);
1077     sb_set_blocksize (s, fs_blocksize);
1078
1079     bh = sb_bread (s, offset / s->s_blocksize);
1080     if (!bh) {
1081         reiserfs_warning (s, "sh-2007: read_super_block: "
1082                 "bread failed (dev %s, block %lu, size %lu)\n",
1083                 reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1084         return 1;
1085     }
1086
1087     rs = (struct reiserfs_super_block *)bh->b_data;
1088     if (sb_blocksize(rs) != s->s_blocksize) {
1089         reiserfs_warning (s, "sh-2011: read_super_block: "
1090                 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1091                 reiserfs_bdevname (s), (unsigned long long)bh->b_blocknr, s->s_blocksize);
1092         brelse (bh);
1093         return 1;
1094     }
1095
1096     if ( rs->s_v1.s_root_block == -1 ) {
1097        brelse(bh) ;
1098        reiserfs_warning (s, "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1099               "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1100               "get newer reiserfsprogs package");
1101        return 1;
1102     }
1103
1104     SB_BUFFER_WITH_SB (s) = bh;
1105     SB_DISK_SUPER_BLOCK (s) = rs;
1106
1107     if (is_reiserfs_jr (rs)) {
1108         /* magic is of non-standard journal filesystem, look at s_version to
1109            find which format is in use */
1110         if (sb_version(rs) == REISERFS_VERSION_2)
1111           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.6\""
1112                   " with non-standard journal");
1113         else if (sb_version(rs) == REISERFS_VERSION_1)
1114           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.5\""
1115                   " with non-standard journal");
1116         else {
1117           reiserfs_warning (s, "sh-2012: read_super_block: found unknown "
1118                             "format \"%u\" of reiserfs with non-standard magic",
1119                             sb_version(rs));
1120         return 1;
1121         }
1122     }
1123     else
1124       /* s_version of standard format may contain incorrect information,
1125          so we just look at the magic string */
1126       reiserfs_info (s, "found reiserfs format \"%s\" with standard journal\n",
1127               is_reiserfs_3_5 (rs) ? "3.5" : "3.6");
1128
1129     s->s_op = &reiserfs_sops;
1130     s->s_export_op = &reiserfs_export_ops;
1131
1132     /* new format is limited by the 32 bit wide i_blocks field, want to
1133     ** be one full block below that.
1134     */
1135     s->s_maxbytes = (512LL << 32) - s->s_blocksize ;
1136     return 0;
1137 }
1138
1139
1140
1141 /* after journal replay, reread all bitmap and super blocks */
1142 static int reread_meta_blocks(struct super_block *s) {
1143   int i ;
1144   ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s))) ;
1145   wait_on_buffer(SB_BUFFER_WITH_SB(s)) ;
1146   if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1147     reiserfs_warning (s, "reread_meta_blocks, error reading the super") ;
1148     return 1 ;
1149   }
1150
1151   for (i = 0; i < SB_BMAP_NR(s) ; i++) {
1152     ll_rw_block(READ, 1, &(SB_AP_BITMAP(s)[i].bh)) ;
1153     wait_on_buffer(SB_AP_BITMAP(s)[i].bh) ;
1154     if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
1155       reiserfs_warning (s, "reread_meta_blocks, error reading bitmap block number %d at %llu",
1156         i, (unsigned long long)SB_AP_BITMAP(s)[i].bh->b_blocknr) ;
1157       return 1 ;
1158     }
1159   }
1160   return 0 ;
1161
1162 }
1163
1164
1165 /////////////////////////////////////////////////////
1166 // hash detection stuff
1167
1168
1169 // if root directory is empty - we set default - Yura's - hash and
1170 // warn about it
1171 // FIXME: we look for only one name in a directory. If tea and yura
1172 // bith have the same value - we ask user to send report to the
1173 // mailing list
1174 __u32 find_hash_out (struct super_block * s)
1175 {
1176     int retval;
1177     struct inode * inode;
1178     struct cpu_key key;
1179     INITIALIZE_PATH (path);
1180     struct reiserfs_dir_entry de;
1181     __u32 hash = DEFAULT_HASH;
1182
1183     inode = s->s_root->d_inode;
1184
1185     do { // Some serious "goto"-hater was there ;)
1186         u32 teahash, r5hash, yurahash;
1187
1188         make_cpu_key (&key, inode, ~0, TYPE_DIRENTRY, 3);
1189         retval = search_by_entry_key (s, &key, &path, &de);
1190         if (retval == IO_ERROR) {
1191             pathrelse (&path);
1192             return UNSET_HASH ;
1193         }
1194         if (retval == NAME_NOT_FOUND)
1195             de.de_entry_num --;
1196         set_de_name_and_namelen (&de);
1197         if (deh_offset( &(de.de_deh[de.de_entry_num]) ) == DOT_DOT_OFFSET) {
1198             /* allow override in this case */
1199             if (reiserfs_rupasov_hash(s)) {
1200                 hash = YURA_HASH ;
1201             }
1202             reiserfs_warning(s,"FS seems to be empty, autodetect "
1203                              "is using the default hash");
1204             break;
1205         }
1206         r5hash=GET_HASH_VALUE (r5_hash (de.de_name, de.de_namelen));
1207         teahash=GET_HASH_VALUE (keyed_hash (de.de_name, de.de_namelen));
1208         yurahash=GET_HASH_VALUE (yura_hash (de.de_name, de.de_namelen));
1209         if ( ( (teahash == r5hash) && (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) ) ||
1210              ( (teahash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ||
1211              ( (r5hash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ) {
1212             reiserfs_warning(s,"Unable to automatically detect hash function. "
1213                              "Please mount with -o hash={tea,rupasov,r5}",
1214                              reiserfs_bdevname (s));
1215             hash = UNSET_HASH;
1216             break;
1217         }
1218         if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == yurahash)
1219             hash = YURA_HASH;
1220         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == teahash)
1221             hash = TEA_HASH;
1222         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == r5hash)
1223             hash = R5_HASH;
1224         else {
1225             reiserfs_warning (s,"Unrecognised hash function");
1226             hash = UNSET_HASH;
1227         }
1228     } while (0);
1229
1230     pathrelse (&path);
1231     return hash;
1232 }
1233
1234 // finds out which hash names are sorted with
1235 static int what_hash (struct super_block * s)
1236 {
1237     __u32 code;
1238
1239     code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1240
1241     /* reiserfs_hash_detect() == true if any of the hash mount options
1242     ** were used.  We must check them to make sure the user isn't
1243     ** using a bad hash value
1244     */
1245     if (code == UNSET_HASH || reiserfs_hash_detect(s))
1246         code = find_hash_out (s);
1247
1248     if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1249         /* detection has found the hash, and we must check against the
1250         ** mount options
1251         */
1252         if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1253             reiserfs_warning (s, "Error, %s hash detected, "
1254                    "unable to force rupasov hash", reiserfs_hashname(code)) ;
1255             code = UNSET_HASH ;
1256         } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1257             reiserfs_warning (s, "Error, %s hash detected, "
1258                    "unable to force tea hash", reiserfs_hashname(code)) ;
1259             code = UNSET_HASH ;
1260         } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1261             reiserfs_warning (s, "Error, %s hash detected, "
1262                    "unable to force r5 hash", reiserfs_hashname(code)) ;
1263             code = UNSET_HASH ;
1264         }
1265     } else {
1266         /* find_hash_out was not called or could not determine the hash */
1267         if (reiserfs_rupasov_hash(s)) {
1268             code = YURA_HASH ;
1269         } else if (reiserfs_tea_hash(s)) {
1270             code = TEA_HASH ;
1271         } else if (reiserfs_r5_hash(s)) {
1272             code = R5_HASH ;
1273         }
1274     }
1275
1276     /* if we are mounted RW, and we have a new valid hash code, update
1277     ** the super
1278     */
1279     if (code != UNSET_HASH &&
1280         !(s->s_flags & MS_RDONLY) &&
1281         code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1282         set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1283     }
1284     return code;
1285 }
1286
1287 // return pointer to appropriate function
1288 static hashf_t hash_function (struct super_block * s)
1289 {
1290     switch (what_hash (s)) {
1291     case TEA_HASH:
1292         reiserfs_info (s, "Using tea hash to sort names\n");
1293         return keyed_hash;
1294     case YURA_HASH:
1295         reiserfs_info (s, "Using rupasov hash to sort names\n");
1296         return yura_hash;
1297     case R5_HASH:
1298         reiserfs_info (s, "Using r5 hash to sort names\n");
1299         return r5_hash;
1300     }
1301     return NULL;
1302 }
1303
1304 // this is used to set up correct value for old partitions
1305 int function2code (hashf_t func)
1306 {
1307     if (func == keyed_hash)
1308         return TEA_HASH;
1309     if (func == yura_hash)
1310         return YURA_HASH;
1311     if (func == r5_hash)
1312         return R5_HASH;
1313
1314     BUG() ; // should never happen
1315
1316     return 0;
1317 }
1318
1319 #define SWARN(silent, s, ...)                   \
1320         if (!(silent))                          \
1321                 reiserfs_warning (s, __VA_ARGS__)
1322
1323 static int reiserfs_fill_super (struct super_block * s, void * data, int silent)
1324 {
1325     struct inode *root_inode;
1326     int j;
1327     struct reiserfs_transaction_handle th ;
1328     int old_format = 0;
1329     unsigned long blocks;
1330     unsigned int commit_max_age = 0;
1331     int jinit_done = 0 ;
1332     struct reiserfs_iget_args args ;
1333     struct reiserfs_super_block * rs;
1334     char *jdev_name;
1335     struct reiserfs_sb_info *sbi;
1336     int errval = -EINVAL;
1337
1338     sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1339     if (!sbi) {
1340         errval = -ENOMEM;
1341         goto error;
1342     }
1343     s->s_fs_info = sbi;
1344     memset (sbi, 0, sizeof (struct reiserfs_sb_info));
1345     /* Set default values for options: non-aggressive tails */
1346     REISERFS_SB(s)->s_mount_opt = ( 1 << REISERFS_SMALLTAIL );
1347     /* no preallocation minimum, be smart in
1348        reiserfs_file_write instead */
1349     REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1350     /* Preallocate by 16 blocks (17-1) at once */
1351     REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1352     /* Initialize the rwsem for xattr dir */
1353     init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
1354
1355     /* setup default block allocator options */
1356     reiserfs_init_alloc_options(s);
1357
1358     jdev_name = NULL;
1359     if (reiserfs_parse_options (s, (char *) data, &(sbi->s_mount_opt), &blocks, &jdev_name, &commit_max_age) == 0) {
1360         goto error;
1361     }
1362
1363     if (blocks) {
1364         SWARN (silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1365                "for remount only");
1366         goto error;
1367     }
1368
1369     /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1370     if (!read_super_block (s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1371       old_format = 1;
1372     /* try new format (64-th 1k block), which can contain reiserfs super block */
1373     else if (read_super_block (s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1374       SWARN(silent, s, "sh-2021: reiserfs_fill_super: can not find reiserfs on %s", reiserfs_bdevname (s));
1375       goto error;
1376     }
1377
1378     rs = SB_DISK_SUPER_BLOCK (s);
1379     /* Let's do basic sanity check to verify that underlying device is not
1380        smaller than the filesystem. If the check fails then abort and scream,
1381        because bad stuff will happen otherwise. */
1382     if ( s->s_bdev && s->s_bdev->bd_inode && i_size_read(s->s_bdev->bd_inode) < sb_block_count(rs)*sb_blocksize(rs)) {
1383         SWARN (silent, s, "Filesystem on %s cannot be mounted because it is bigger than the device", reiserfs_bdevname(s));
1384         SWARN(silent, s, "You may need to run fsck or increase size of your LVM partition");
1385         SWARN(silent, s, "Or may be you forgot to reboot after fdisk when it told you to");
1386         goto error;
1387     }
1388
1389     sbi->s_mount_state = SB_REISERFS_STATE(s);
1390     sbi->s_mount_state = REISERFS_VALID_FS ;
1391
1392     if (old_format ? read_old_bitmaps(s) : read_bitmaps(s)) {
1393         SWARN(silent, s, "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1394         goto error;
1395     }
1396 #ifdef CONFIG_REISERFS_CHECK
1397     SWARN (silent, s, "CONFIG_REISERFS_CHECK is set ON");
1398     SWARN (silent, s, "- it is slow mode for debugging.");
1399 #endif
1400
1401     /* make data=ordered the default */
1402     if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1403         !reiserfs_data_writeback(s))
1404     {
1405          REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1406     }
1407
1408     if (reiserfs_data_log(s)) {
1409         reiserfs_info (s, "using journaled data mode\n");
1410     } else if (reiserfs_data_ordered(s)) {
1411         reiserfs_info (s, "using ordered data mode\n");
1412     } else {
1413         reiserfs_info (s, "using writeback data mode\n");
1414     }
1415
1416     // set_device_ro(s->s_dev, 1) ;
1417     if( journal_init(s, jdev_name, old_format, commit_max_age) ) {
1418         SWARN(silent, s, "sh-2022: reiserfs_fill_super: unable to initialize journal space") ;
1419         goto error ;
1420     } else {
1421         jinit_done = 1 ; /* once this is set, journal_release must be called
1422                          ** if we error out of the mount
1423                          */
1424     }
1425     if (reread_meta_blocks(s)) {
1426         SWARN(silent, s, "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init") ;
1427         goto error ;
1428     }
1429
1430     if (replay_only (s))
1431         goto error;
1432
1433     if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1434         SWARN(silent, s, "clm-7000: Detected readonly device, marking FS readonly") ;
1435         s->s_flags |= MS_RDONLY ;
1436     }
1437     args.objectid = REISERFS_ROOT_OBJECTID ;
1438     args.dirid = REISERFS_ROOT_PARENT_OBJECTID ;
1439     root_inode = iget5_locked (s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor, reiserfs_init_locked_inode, (void *)(&args));
1440     if (!root_inode) {
1441         SWARN(silent, s, "jmacd-10: reiserfs_fill_super: get root inode failed");
1442         goto error;
1443     }
1444
1445     if (root_inode->i_state & I_NEW) {
1446         reiserfs_read_locked_inode(root_inode, &args);
1447         unlock_new_inode(root_inode);
1448     }
1449
1450     s->s_root = d_alloc_root(root_inode);
1451     if (!s->s_root) {
1452         iput(root_inode);
1453         goto error;
1454     }
1455
1456     // define and initialize hash function
1457     sbi->s_hash_function = hash_function (s);
1458     if (sbi->s_hash_function == NULL) {
1459       dput(s->s_root) ;
1460       s->s_root = NULL ;
1461       goto error ;
1462     }
1463
1464     if (is_reiserfs_3_5 (rs) || (is_reiserfs_jr (rs) && SB_VERSION (s) == REISERFS_VERSION_1))
1465         set_bit(REISERFS_3_5, &(sbi->s_properties));
1466     else
1467         set_bit(REISERFS_3_6, &(sbi->s_properties));
1468
1469     if (!(s->s_flags & MS_RDONLY)) {
1470
1471         journal_begin(&th, s, 1) ;
1472         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1473
1474         set_sb_umount_state( rs, REISERFS_ERROR_FS );
1475         set_sb_fs_state (rs, 0);
1476
1477         if (old_format_only(s)) {
1478           /* filesystem of format 3.5 either with standard or non-standard
1479              journal */
1480           if (convert_reiserfs (s)) {
1481             /* and -o conv is given */
1482             if(!silent)
1483               reiserfs_info (s,"converting 3.5 filesystem to the 3.6 format") ;
1484
1485             if (is_reiserfs_3_5 (rs))
1486               /* put magic string of 3.6 format. 2.2 will not be able to
1487                  mount this filesystem anymore */
1488               memcpy (rs->s_v1.s_magic, reiserfs_3_6_magic_string,
1489                       sizeof (reiserfs_3_6_magic_string));
1490
1491             set_sb_version(rs,REISERFS_VERSION_2);
1492             reiserfs_convert_objectid_map_v1(s) ;
1493             set_bit(REISERFS_3_6, &(sbi->s_properties));
1494             clear_bit(REISERFS_3_5, &(sbi->s_properties));
1495           } else if (!silent){
1496             reiserfs_info (s, "using 3.5.x disk format\n") ;
1497           }
1498         }
1499
1500         journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1501         journal_end(&th, s, 1) ;
1502
1503         if (reiserfs_xattr_init (s, s->s_flags)) {
1504             dput (s->s_root);
1505             s->s_root = NULL;
1506             goto error;
1507         }
1508
1509         /* look for files which were to be removed in previous session */
1510         finish_unfinished (s);
1511     } else {
1512         if ( old_format_only(s) && !silent) {
1513             reiserfs_info (s, "using 3.5.x disk format\n") ;
1514         }
1515
1516         if (reiserfs_xattr_init (s, s->s_flags)) {
1517             dput (s->s_root);
1518             s->s_root = NULL;
1519             goto error;
1520         }
1521     }
1522     // mark hash in super block: it could be unset. overwrite should be ok
1523     set_sb_hash_function_code( rs, function2code(sbi->s_hash_function ) );
1524
1525     handle_attrs( s );
1526
1527     reiserfs_proc_info_init( s );
1528
1529     init_waitqueue_head (&(sbi->s_wait));
1530     sbi->bitmap_lock = SPIN_LOCK_UNLOCKED;
1531
1532     return (0);
1533
1534  error:
1535     if (jinit_done) { /* kill the commit thread, free journal ram */
1536         journal_release_error(NULL, s) ;
1537     }
1538     if (SB_DISK_SUPER_BLOCK (s)) {
1539         for (j = 0; j < SB_BMAP_NR (s); j ++) {
1540             if (SB_AP_BITMAP (s))
1541                 brelse (SB_AP_BITMAP (s)[j].bh);
1542         }
1543         if (SB_AP_BITMAP (s))
1544             vfree (SB_AP_BITMAP (s));
1545     }
1546     if (SB_BUFFER_WITH_SB (s))
1547         brelse(SB_BUFFER_WITH_SB (s));
1548
1549     if (sbi != NULL) {
1550         kfree(sbi);
1551     }
1552
1553     s->s_fs_info = NULL;
1554     return errval;
1555 }
1556
1557
1558 static int reiserfs_statfs (struct super_block * s, struct kstatfs * buf)
1559 {
1560   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s);
1561
1562   buf->f_namelen = (REISERFS_MAX_NAME (s->s_blocksize));
1563   buf->f_bfree   = sb_free_blocks(rs);
1564   buf->f_bavail  = buf->f_bfree;
1565   buf->f_blocks  = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1566   buf->f_bsize   = s->s_blocksize;
1567   /* changed to accommodate gcc folks.*/
1568   buf->f_type    =  REISERFS_SUPER_MAGIC;
1569   return 0;
1570 }
1571
1572 static struct super_block*
1573 get_super_block (struct file_system_type *fs_type, int flags,
1574                  const char *dev_name, void *data)
1575 {
1576         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
1577 }
1578
1579 static int __init
1580 init_reiserfs_fs ( void )
1581 {
1582         int ret;
1583
1584         if ((ret = init_inodecache ())) {
1585                 return ret;
1586         }
1587
1588         if ((ret = reiserfs_xattr_register_handlers ()))
1589             goto failed_reiserfs_xattr_register_handlers;
1590
1591         reiserfs_proc_info_global_init ();
1592         reiserfs_proc_register_global ("version", reiserfs_global_version_in_proc);
1593
1594         ret = register_filesystem (& reiserfs_fs_type);
1595
1596         if (ret == 0) {
1597                 return 0;
1598         }
1599
1600         reiserfs_xattr_unregister_handlers ();
1601
1602 failed_reiserfs_xattr_register_handlers:
1603         reiserfs_proc_unregister_global ("version");
1604         reiserfs_proc_info_global_done ();
1605         destroy_inodecache ();
1606
1607         return ret;
1608 }
1609
1610 static void __exit
1611 exit_reiserfs_fs ( void )
1612 {
1613         reiserfs_xattr_unregister_handlers ();
1614         reiserfs_proc_unregister_global ("version");
1615         reiserfs_proc_info_global_done ();
1616         unregister_filesystem (& reiserfs_fs_type);
1617         destroy_inodecache ();
1618 }
1619
1620 struct file_system_type reiserfs_fs_type = {
1621         .owner          = THIS_MODULE,
1622         .name           = "reiserfs",
1623         .get_sb         = get_super_block,
1624         .kill_sb        = kill_block_super,
1625         .fs_flags       = FS_REQUIRES_DEV,
1626 };
1627
1628 MODULE_DESCRIPTION ("ReiserFS journaled filesystem");
1629 MODULE_AUTHOR      ("Hans Reiser <reiser@namesys.com>");
1630 MODULE_LICENSE     ("GPL");
1631
1632 module_init (init_reiserfs_fs);
1633 module_exit (exit_reiserfs_fs);