fs/reiserfs/super.c

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