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