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