SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 = SB_DISK_SUPER_BLOCK (s);
1057
1058         if( reiserfs_attrs( s ) ) {
1059                 if( old_format_only(s) ) {
1060                         reiserfs_warning(s, "reiserfs: cannot support attributes on 3.5.x disk format" );
1061                         REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
1062                         return;
1063                 }
1064                 if( !( le32_to_cpu( rs -> s_flags ) & reiserfs_attrs_cleared ) ) {
1065                                 reiserfs_warning(s, "reiserfs: cannot support attributes until flag is set in super-block" );
1066                                 REISERFS_SB(s) -> s_mount_opt &= ~ ( 1 << REISERFS_ATTRS );
1067                 }
1068         } else if (le32_to_cpu( rs -> s_flags ) & reiserfs_attrs_cleared) {
1069                 REISERFS_SB(s)->s_mount_opt |= REISERFS_ATTRS;
1070         }
1071 }
1072
1073 static int reiserfs_remount (struct super_block * s, int * mount_flags, char * arg)
1074 {
1075   struct reiserfs_super_block * rs;
1076   struct reiserfs_transaction_handle th ;
1077   unsigned long blocks;
1078   unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1079   unsigned long safe_mask = 0;
1080   unsigned int commit_max_age = (unsigned int)-1;
1081   struct reiserfs_journal *journal = SB_JOURNAL(s);
1082   int err;
1083 #ifdef CONFIG_QUOTA
1084   int i;
1085 #endif
1086
1087   rs = SB_DISK_SUPER_BLOCK (s);
1088
1089   if (!reiserfs_parse_options(s, arg, &mount_options, &blocks, NULL, &commit_max_age)) {
1090 #ifdef CONFIG_QUOTA
1091     for (i = 0; i < MAXQUOTAS; i++)
1092         if (REISERFS_SB(s)->s_qf_names[i]) {
1093             kfree(REISERFS_SB(s)->s_qf_names[i]);
1094             REISERFS_SB(s)->s_qf_names[i] = NULL;
1095         }
1096 #endif
1097     return -EINVAL;
1098   }
1099
1100   handle_attrs(s);
1101
1102   /* Add options that are safe here */
1103   safe_mask |= 1 << REISERFS_SMALLTAIL;
1104   safe_mask |= 1 << REISERFS_LARGETAIL;
1105   safe_mask |= 1 << REISERFS_NO_BORDER;
1106   safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1107   safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1108   safe_mask |= 1 << REISERFS_TEST4;
1109   safe_mask |= 1 << REISERFS_ATTRS;
1110   safe_mask |= 1 << REISERFS_XATTRS_USER;
1111   safe_mask |= 1 << REISERFS_POSIXACL;
1112   safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1113   safe_mask |= 1 << REISERFS_BARRIER_NONE;
1114   safe_mask |= 1 << REISERFS_ERROR_RO;
1115   safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1116   safe_mask |= 1 << REISERFS_ERROR_PANIC;
1117   safe_mask |= 1 << REISERFS_QUOTA;
1118
1119   /* Update the bitmask, taking care to keep
1120    * the bits we're not allowed to change here */
1121   REISERFS_SB(s)->s_mount_opt = (REISERFS_SB(s)->s_mount_opt & ~safe_mask) |  (mount_options & safe_mask);
1122
1123   if(commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1124     journal->j_max_commit_age = commit_max_age;
1125     journal->j_max_trans_age = commit_max_age;
1126   }
1127   else if(commit_max_age == 0)
1128   {
1129     /* 0 means restore defaults. */
1130     journal->j_max_commit_age = journal->j_default_max_commit_age;
1131     journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1132   }
1133
1134   if(blocks) {
1135     int rc = reiserfs_resize(s, blocks);
1136     if (rc != 0)
1137       return rc;
1138   }
1139
1140   if (*mount_flags & MS_RDONLY) {
1141     reiserfs_xattr_init (s, *mount_flags);
1142     /* remount read-only */
1143     if (s->s_flags & MS_RDONLY)
1144       /* it is read-only already */
1145       return 0;
1146     /* try to remount file system with read-only permissions */
1147     if (sb_umount_state(rs) == REISERFS_VALID_FS || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
1148       return 0;
1149     }
1150
1151     err = journal_begin(&th, s, 10) ;
1152     if (err)
1153         return err;
1154
1155     /* Mounting a rw partition read-only. */
1156     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1157     set_sb_umount_state( rs, REISERFS_SB(s)->s_mount_state );
1158     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1159   } else {
1160     /* remount read-write */
1161     if (!(s->s_flags & MS_RDONLY)) {
1162         reiserfs_xattr_init (s, *mount_flags);
1163         return 0; /* We are read-write already */
1164     }
1165
1166     if (reiserfs_is_journal_aborted (journal))
1167         return journal->j_errno;
1168
1169     handle_data_mode(s, mount_options);
1170     handle_barrier_mode(s, mount_options);
1171     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs) ;
1172     s->s_flags &= ~MS_RDONLY ; /* now it is safe to call journal_begin */
1173     err = journal_begin(&th, s, 10) ;
1174     if (err)
1175         return err;
1176
1177     /* Mount a partition which is read-only, read-write */
1178     reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1179     REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1180     s->s_flags &= ~MS_RDONLY;
1181     set_sb_umount_state( rs, REISERFS_ERROR_FS );
1182     /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1183     journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1184     REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS ;
1185   }
1186   /* this will force a full flush of all journal lists */
1187   SB_JOURNAL(s)->j_must_wait = 1 ;
1188   err = journal_end(&th, s, 10) ;
1189   if (err)
1190     return err;
1191   s->s_dirt = 0;
1192
1193   if (!( *mount_flags & MS_RDONLY ) ) {
1194     finish_unfinished( s );
1195     reiserfs_xattr_init (s, *mount_flags);
1196   }
1197
1198   return 0;
1199 }
1200
1201 /* load_bitmap_info_data - Sets up the reiserfs_bitmap_info structure from disk.
1202  * @sb - superblock for this filesystem
1203  * @bi - the bitmap info to be loaded. Requires that bi->bh is valid.
1204  *
1205  * This routine counts how many free bits there are, finding the first zero
1206  * as a side effect. Could also be implemented as a loop of test_bit() calls, or
1207  * a loop of find_first_zero_bit() calls. This implementation is similar to
1208  * find_first_zero_bit(), but doesn't return after it finds the first bit.
1209  * Should only be called on fs mount, but should be fairly efficient anyways.
1210  *
1211  * bi->first_zero_hint is considered unset if it == 0, since the bitmap itself
1212  * will * invariably occupt block 0 represented in the bitmap. The only
1213  * exception to this is when free_count also == 0, since there will be no
1214  * free blocks at all.
1215  */
1216
1217 static void load_bitmap_info_data (struct super_block *sb,
1218                                    struct reiserfs_bitmap_info *bi)
1219 {
1220     unsigned long *cur = (unsigned long *)bi->bh->b_data;
1221
1222     while ((char *)cur < (bi->bh->b_data + sb->s_blocksize)) {
1223
1224         /* No need to scan if all 0's or all 1's.
1225          * Since we're only counting 0's, we can simply ignore all 1's */
1226         if (*cur == 0) {
1227             if (bi->first_zero_hint == 0) {
1228                 bi->first_zero_hint = ((char *)cur - bi->bh->b_data) << 3;
1229             }
1230             bi->free_count += sizeof(unsigned long)*8;
1231         } else if (*cur != ~0L) {
1232             int b;
1233             for (b = 0; b < sizeof(unsigned long)*8; b++) {
1234                 if (!reiserfs_test_le_bit (b, cur)) {
1235                     bi->free_count ++;
1236                     if (bi->first_zero_hint == 0)
1237                         bi->first_zero_hint =
1238                                         (((char *)cur - bi->bh->b_data) << 3) + b;
1239                     }
1240                 }
1241             }
1242         cur ++;
1243     }
1244
1245 #ifdef CONFIG_REISERFS_CHECK
1246 // This outputs a lot of unneded info on big FSes
1247 //    reiserfs_warning ("bitmap loaded from block %d: %d free blocks",
1248 //                    bi->bh->b_blocknr, bi->free_count);
1249 #endif
1250 }
1251
1252 static int read_bitmaps (struct super_block * s)
1253 {
1254     int i, bmap_nr;
1255
1256     SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
1257     if (SB_AP_BITMAP (s) == 0)
1258         return 1;
1259     memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
1260     for (i = 0, bmap_nr = REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize + 1;
1261          i < SB_BMAP_NR(s); i++, bmap_nr = s->s_blocksize * 8 * i) {
1262         SB_AP_BITMAP (s)[i].bh = sb_getblk(s, bmap_nr);
1263         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh))
1264             ll_rw_block(READ, 1, &SB_AP_BITMAP(s)[i].bh);
1265     }
1266     for (i = 0; i < SB_BMAP_NR(s); i++) {
1267         wait_on_buffer(SB_AP_BITMAP (s)[i].bh);
1268         if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
1269             reiserfs_warning(s,"sh-2029: reiserfs read_bitmaps: "
1270                          "bitmap block (#%lu) reading failed",
1271                          SB_AP_BITMAP(s)[i].bh->b_blocknr);
1272             for (i = 0; i < SB_BMAP_NR(s); i++)
1273                 brelse(SB_AP_BITMAP(s)[i].bh);
1274             vfree(SB_AP_BITMAP(s));
1275             SB_AP_BITMAP(s) = NULL;
1276             return 1;
1277         }
1278         load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1279     }
1280     return 0;
1281 }
1282
1283 static int read_old_bitmaps (struct super_block * s)
1284 {
1285   int i ;
1286   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK(s);
1287   int bmp1 = (REISERFS_OLD_DISK_OFFSET_IN_BYTES / s->s_blocksize) + 1;  /* first of bitmap blocks */
1288
1289   /* read true bitmap */
1290   SB_AP_BITMAP (s) = vmalloc (sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1291   if (SB_AP_BITMAP (s) == 0)
1292     return 1;
1293
1294   memset (SB_AP_BITMAP (s), 0, sizeof (struct reiserfs_buffer_info *) * sb_bmap_nr(rs));
1295
1296   for (i = 0; i < sb_bmap_nr(rs); i ++) {
1297     SB_AP_BITMAP (s)[i].bh = sb_bread (s, bmp1 + i);
1298     if (!SB_AP_BITMAP (s)[i].bh)
1299       return 1;
1300     load_bitmap_info_data (s, SB_AP_BITMAP (s) + i);
1301   }
1302
1303   return 0;
1304 }
1305
1306 static int read_super_block (struct super_block * s, int offset)
1307 {
1308     struct buffer_head * bh;
1309     struct reiserfs_super_block * rs;
1310     int fs_blocksize;
1311
1312
1313     bh = sb_bread (s, offset / s->s_blocksize);
1314     if (!bh) {
1315       reiserfs_warning (s, "sh-2006: read_super_block: "
1316               "bread failed (dev %s, block %lu, size %lu)",
1317               reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1318       return 1;
1319     }
1320
1321     rs = (struct reiserfs_super_block *)bh->b_data;
1322     if (!is_any_reiserfs_magic_string (rs)) {
1323       brelse (bh);
1324       return 1;
1325     }
1326
1327     //
1328     // ok, reiserfs signature (old or new) found in at the given offset
1329     //
1330     fs_blocksize = sb_blocksize(rs);
1331     brelse (bh);
1332     sb_set_blocksize (s, fs_blocksize);
1333
1334     bh = sb_bread (s, offset / s->s_blocksize);
1335     if (!bh) {
1336         reiserfs_warning (s, "sh-2007: read_super_block: "
1337                 "bread failed (dev %s, block %lu, size %lu)\n",
1338                 reiserfs_bdevname (s), offset / s->s_blocksize, s->s_blocksize);
1339         return 1;
1340     }
1341
1342     rs = (struct reiserfs_super_block *)bh->b_data;
1343     if (sb_blocksize(rs) != s->s_blocksize) {
1344         reiserfs_warning (s, "sh-2011: read_super_block: "
1345                 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1346                 reiserfs_bdevname (s), (unsigned long long)bh->b_blocknr, s->s_blocksize);
1347         brelse (bh);
1348         return 1;
1349     }
1350
1351     if ( rs->s_v1.s_root_block == cpu_to_le32(-1) ) {
1352        brelse(bh) ;
1353        reiserfs_warning (s, "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1354               "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1355               "get newer reiserfsprogs package");
1356        return 1;
1357     }
1358
1359     SB_BUFFER_WITH_SB (s) = bh;
1360     SB_DISK_SUPER_BLOCK (s) = rs;
1361
1362     if (is_reiserfs_jr (rs)) {
1363         /* magic is of non-standard journal filesystem, look at s_version to
1364            find which format is in use */
1365         if (sb_version(rs) == REISERFS_VERSION_2)
1366           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.6\""
1367                   " with non-standard journal");
1368         else if (sb_version(rs) == REISERFS_VERSION_1)
1369           reiserfs_warning (s, "read_super_block: found reiserfs format \"3.5\""
1370                   " with non-standard journal");
1371         else {
1372           reiserfs_warning (s, "sh-2012: read_super_block: found unknown "
1373                             "format \"%u\" of reiserfs with non-standard magic",
1374                             sb_version(rs));
1375         return 1;
1376         }
1377     }
1378     else
1379       /* s_version of standard format may contain incorrect information,
1380          so we just look at the magic string */
1381       reiserfs_info (s, "found reiserfs format \"%s\" with standard journal\n",
1382               is_reiserfs_3_5 (rs) ? "3.5" : "3.6");
1383
1384     s->s_op = &reiserfs_sops;
1385     s->s_export_op = &reiserfs_export_ops;
1386 #ifdef CONFIG_QUOTA
1387     s->s_qcop = &reiserfs_qctl_operations;
1388     s->dq_op = &reiserfs_quota_operations;
1389 #endif
1390
1391     /* new format is limited by the 32 bit wide i_blocks field, want to
1392     ** be one full block below that.
1393     */
1394     s->s_maxbytes = (512LL << 32) - s->s_blocksize ;
1395     return 0;
1396 }
1397
1398
1399
1400 /* after journal replay, reread all bitmap and super blocks */
1401 static int reread_meta_blocks(struct super_block *s) {
1402   int i ;
1403   ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s))) ;
1404   wait_on_buffer(SB_BUFFER_WITH_SB(s)) ;
1405   if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1406     reiserfs_warning (s, "reread_meta_blocks, error reading the super") ;
1407     return 1 ;
1408   }
1409
1410   for (i = 0; i < SB_BMAP_NR(s) ; i++) {
1411     ll_rw_block(READ, 1, &(SB_AP_BITMAP(s)[i].bh)) ;
1412     wait_on_buffer(SB_AP_BITMAP(s)[i].bh) ;
1413     if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {
1414       reiserfs_warning (s, "reread_meta_blocks, error reading bitmap block number %d at %llu",
1415         i, (unsigned long long)SB_AP_BITMAP(s)[i].bh->b_blocknr) ;
1416       return 1 ;
1417     }
1418   }
1419   return 0 ;
1420
1421 }
1422
1423
1424 /////////////////////////////////////////////////////
1425 // hash detection stuff
1426
1427
1428 // if root directory is empty - we set default - Yura's - hash and
1429 // warn about it
1430 // FIXME: we look for only one name in a directory. If tea and yura
1431 // bith have the same value - we ask user to send report to the
1432 // mailing list
1433 static __u32 find_hash_out (struct super_block * s)
1434 {
1435     int retval;
1436     struct inode * inode;
1437     struct cpu_key key;
1438     INITIALIZE_PATH (path);
1439     struct reiserfs_dir_entry de;
1440     __u32 hash = DEFAULT_HASH;
1441
1442     inode = s->s_root->d_inode;
1443
1444     do { // Some serious "goto"-hater was there ;)
1445         u32 teahash, r5hash, yurahash;
1446
1447         make_cpu_key (&key, inode, ~0, TYPE_DIRENTRY, 3);
1448         retval = search_by_entry_key (s, &key, &path, &de);
1449         if (retval == IO_ERROR) {
1450             pathrelse (&path);
1451             return UNSET_HASH ;
1452         }
1453         if (retval == NAME_NOT_FOUND)
1454             de.de_entry_num --;
1455         set_de_name_and_namelen (&de);
1456         if (deh_offset( &(de.de_deh[de.de_entry_num]) ) == DOT_DOT_OFFSET) {
1457             /* allow override in this case */
1458             if (reiserfs_rupasov_hash(s)) {
1459                 hash = YURA_HASH ;
1460             }
1461             reiserfs_warning(s,"FS seems to be empty, autodetect "
1462                              "is using the default hash");
1463             break;
1464         }
1465         r5hash=GET_HASH_VALUE (r5_hash (de.de_name, de.de_namelen));
1466         teahash=GET_HASH_VALUE (keyed_hash (de.de_name, de.de_namelen));
1467         yurahash=GET_HASH_VALUE (yura_hash (de.de_name, de.de_namelen));
1468         if ( ( (teahash == r5hash) && (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) ) ||
1469              ( (teahash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ||
1470              ( (r5hash == yurahash) && (yurahash == GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])))) ) ) {
1471             reiserfs_warning(s,"Unable to automatically detect hash function. "
1472                              "Please mount with -o hash={tea,rupasov,r5}",
1473                              reiserfs_bdevname (s));
1474             hash = UNSET_HASH;
1475             break;
1476         }
1477         if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == yurahash)
1478             hash = YURA_HASH;
1479         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == teahash)
1480             hash = TEA_HASH;
1481         else if (GET_HASH_VALUE( deh_offset(&(de.de_deh[de.de_entry_num])) ) == r5hash)
1482             hash = R5_HASH;
1483         else {
1484             reiserfs_warning (s,"Unrecognised hash function");
1485             hash = UNSET_HASH;
1486         }
1487     } while (0);
1488
1489     pathrelse (&path);
1490     return hash;
1491 }
1492
1493 // finds out which hash names are sorted with
1494 static int what_hash (struct super_block * s)
1495 {
1496     __u32 code;
1497
1498     code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1499
1500     /* reiserfs_hash_detect() == true if any of the hash mount options
1501     ** were used.  We must check them to make sure the user isn't
1502     ** using a bad hash value
1503     */
1504     if (code == UNSET_HASH || reiserfs_hash_detect(s))
1505         code = find_hash_out (s);
1506
1507     if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1508         /* detection has found the hash, and we must check against the
1509         ** mount options
1510         */
1511         if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1512             reiserfs_warning (s, "Error, %s hash detected, "
1513                    "unable to force rupasov hash", reiserfs_hashname(code)) ;
1514             code = UNSET_HASH ;
1515         } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1516             reiserfs_warning (s, "Error, %s hash detected, "
1517                    "unable to force tea hash", reiserfs_hashname(code)) ;
1518             code = UNSET_HASH ;
1519         } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1520             reiserfs_warning (s, "Error, %s hash detected, "
1521                    "unable to force r5 hash", reiserfs_hashname(code)) ;
1522             code = UNSET_HASH ;
1523         }
1524     } else {
1525         /* find_hash_out was not called or could not determine the hash */
1526         if (reiserfs_rupasov_hash(s)) {
1527             code = YURA_HASH ;
1528         } else if (reiserfs_tea_hash(s)) {
1529             code = TEA_HASH ;
1530         } else if (reiserfs_r5_hash(s)) {
1531             code = R5_HASH ;
1532         }
1533     }
1534
1535     /* if we are mounted RW, and we have a new valid hash code, update
1536     ** the super
1537     */
1538     if (code != UNSET_HASH &&
1539         !(s->s_flags & MS_RDONLY) &&
1540         code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1541         set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1542     }
1543     return code;
1544 }
1545
1546 // return pointer to appropriate function
1547 static hashf_t hash_function (struct super_block * s)
1548 {
1549     switch (what_hash (s)) {
1550     case TEA_HASH:
1551         reiserfs_info (s, "Using tea hash to sort names\n");
1552         return keyed_hash;
1553     case YURA_HASH:
1554         reiserfs_info (s, "Using rupasov hash to sort names\n");
1555         return yura_hash;
1556     case R5_HASH:
1557         reiserfs_info (s, "Using r5 hash to sort names\n");
1558         return r5_hash;
1559     }
1560     return NULL;
1561 }
1562
1563 // this is used to set up correct value for old partitions
1564 static int function2code (hashf_t func)
1565 {
1566     if (func == keyed_hash)
1567         return TEA_HASH;
1568     if (func == yura_hash)
1569         return YURA_HASH;
1570     if (func == r5_hash)
1571         return R5_HASH;
1572
1573     BUG() ; // should never happen
1574
1575     return 0;
1576 }
1577
1578 #define SWARN(silent, s, ...)                   \
1579         if (!(silent))                          \
1580                 reiserfs_warning (s, __VA_ARGS__)
1581
1582 static int reiserfs_fill_super (struct super_block * s, void * data, int silent)
1583 {
1584     struct inode *root_inode;
1585     int j;
1586     struct reiserfs_transaction_handle th ;
1587     int old_format = 0;
1588     unsigned long blocks;
1589     unsigned int commit_max_age = 0;
1590     int jinit_done = 0 ;
1591     struct reiserfs_iget_args args ;
1592     struct reiserfs_super_block * rs;
1593     char *jdev_name;
1594     struct reiserfs_sb_info *sbi;
1595     int errval = -EINVAL;
1596
1597     sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1598     if (!sbi) {
1599         errval = -ENOMEM;
1600         goto error;
1601     }
1602     s->s_fs_info = sbi;
1603     memset (sbi, 0, sizeof (struct reiserfs_sb_info));
1604     /* Set default values for options: non-aggressive tails, RO on errors */
1605     REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1606     REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1607     /* no preallocation minimum, be smart in
1608        reiserfs_file_write instead */
1609     REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1610     /* Preallocate by 16 blocks (17-1) at once */
1611     REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1612     /* Initialize the rwsem for xattr dir */
1613     init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
1614
1615     /* setup default block allocator options */
1616     reiserfs_init_alloc_options(s);
1617
1618     jdev_name = NULL;
1619     if (reiserfs_parse_options (s, (char *) data, &(sbi->s_mount_opt), &blocks, &jdev_name, &commit_max_age) == 0) {
1620         goto error;
1621     }
1622
1623     if (blocks) {
1624         SWARN (silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1625                "for remount only");
1626         goto error;
1627     }
1628
1629     /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1630     if (!read_super_block (s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1631       old_format = 1;
1632     /* try new format (64-th 1k block), which can contain reiserfs super block */
1633     else if (read_super_block (s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1634       SWARN(silent, s, "sh-2021: reiserfs_fill_super: can not find reiserfs on %s", reiserfs_bdevname (s));
1635       goto error;
1636     }
1637
1638     rs = SB_DISK_SUPER_BLOCK (s);
1639     /* Let's do basic sanity check to verify that underlying device is not
1640        smaller than the filesystem. If the check fails then abort and scream,
1641        because bad stuff will happen otherwise. */
1642     if ( s->s_bdev && s->s_bdev->bd_inode && i_size_read(s->s_bdev->bd_inode) < sb_block_count(rs)*sb_blocksize(rs)) {
1643         SWARN (silent, s, "Filesystem on %s cannot be mounted because it is bigger than the device", reiserfs_bdevname(s));
1644         SWARN(silent, s, "You may need to run fsck or increase size of your LVM partition");
1645         SWARN(silent, s, "Or may be you forgot to reboot after fdisk when it told you to");
1646         goto error;
1647     }
1648
1649     sbi->s_mount_state = SB_REISERFS_STATE(s);
1650     sbi->s_mount_state = REISERFS_VALID_FS ;
1651
1652     if (old_format ? read_old_bitmaps(s) : read_bitmaps(s)) {
1653         SWARN(silent, s, "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1654         goto error;
1655     }
1656 #ifdef CONFIG_REISERFS_CHECK
1657     SWARN (silent, s, "CONFIG_REISERFS_CHECK is set ON");
1658     SWARN (silent, s, "- it is slow mode for debugging.");
1659 #endif
1660
1661     /* make data=ordered the default */
1662     if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1663         !reiserfs_data_writeback(s))
1664     {
1665          REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1666     }
1667
1668     if (reiserfs_data_log(s)) {
1669         reiserfs_info (s, "using journaled data mode\n");
1670     } else if (reiserfs_data_ordered(s)) {
1671         reiserfs_info (s, "using ordered data mode\n");
1672     } else {
1673         reiserfs_info (s, "using writeback data mode\n");
1674     }
1675     if (reiserfs_barrier_flush(s)) {
1676         printk("reiserfs: using flush barriers\n");
1677     }
1678
1679     // set_device_ro(s->s_dev, 1) ;
1680     if( journal_init(s, jdev_name, old_format, commit_max_age) ) {
1681         SWARN(silent, s, "sh-2022: reiserfs_fill_super: unable to initialize journal space") ;
1682         goto error ;
1683     } else {
1684         jinit_done = 1 ; /* once this is set, journal_release must be called
1685                          ** if we error out of the mount
1686                          */
1687     }
1688     if (reread_meta_blocks(s)) {
1689         SWARN(silent, s, "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init") ;
1690         goto error ;
1691     }
1692
1693     if (replay_only (s))
1694         goto error;
1695
1696     if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1697         SWARN(silent, s, "clm-7000: Detected readonly device, marking FS readonly") ;
1698         s->s_flags |= MS_RDONLY ;
1699     }
1700     args.objectid = REISERFS_ROOT_OBJECTID ;
1701     args.dirid = REISERFS_ROOT_PARENT_OBJECTID ;
1702     root_inode = iget5_locked (s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor, reiserfs_init_locked_inode, (void *)(&args));
1703     if (!root_inode) {
1704         SWARN(silent, s, "jmacd-10: reiserfs_fill_super: get root inode failed");
1705         goto error;
1706     }
1707
1708     if (root_inode->i_state & I_NEW) {
1709         reiserfs_read_locked_inode(root_inode, &args);
1710         unlock_new_inode(root_inode);
1711     }
1712
1713     s->s_root = d_alloc_root(root_inode);
1714     if (!s->s_root) {
1715         iput(root_inode);
1716         goto error;
1717     }
1718
1719     // define and initialize hash function
1720     sbi->s_hash_function = hash_function (s);
1721     if (sbi->s_hash_function == NULL) {
1722       dput(s->s_root) ;
1723       s->s_root = NULL ;
1724       goto error ;
1725     }
1726
1727     if (is_reiserfs_3_5 (rs) || (is_reiserfs_jr (rs) && SB_VERSION (s) == REISERFS_VERSION_1))
1728         set_bit(REISERFS_3_5, &(sbi->s_properties));
1729     else
1730         set_bit(REISERFS_3_6, &(sbi->s_properties));
1731
1732     if (!(s->s_flags & MS_RDONLY)) {
1733
1734         errval = journal_begin(&th, s, 1) ;
1735         if (errval) {
1736             dput (s->s_root);
1737             s->s_root = NULL;
1738             goto error;
1739         }
1740         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
1741
1742         set_sb_umount_state( rs, REISERFS_ERROR_FS );
1743         set_sb_fs_state (rs, 0);
1744
1745         if (old_format_only(s)) {
1746           /* filesystem of format 3.5 either with standard or non-standard
1747              journal */
1748           if (convert_reiserfs (s)) {
1749             /* and -o conv is given */
1750             if(!silent)
1751               reiserfs_info (s,"converting 3.5 filesystem to the 3.6 format") ;
1752
1753             if (is_reiserfs_3_5 (rs))
1754               /* put magic string of 3.6 format. 2.2 will not be able to
1755                  mount this filesystem anymore */
1756               memcpy (rs->s_v1.s_magic, reiserfs_3_6_magic_string,
1757                       sizeof (reiserfs_3_6_magic_string));
1758
1759             set_sb_version(rs,REISERFS_VERSION_2);
1760             reiserfs_convert_objectid_map_v1(s) ;
1761             set_bit(REISERFS_3_6, &(sbi->s_properties));
1762             clear_bit(REISERFS_3_5, &(sbi->s_properties));
1763           } else if (!silent){
1764             reiserfs_info (s, "using 3.5.x disk format\n") ;
1765           }
1766         }
1767
1768         journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
1769         errval = journal_end(&th, s, 1) ;
1770         if (errval) {
1771             dput (s->s_root);
1772             s->s_root = NULL;
1773             goto error;
1774         }
1775
1776         if ((errval = reiserfs_xattr_init (s, s->s_flags))) {
1777             dput (s->s_root);
1778             s->s_root = NULL;
1779             goto error;
1780         }
1781
1782         /* look for files which were to be removed in previous session */
1783         finish_unfinished (s);
1784     } else {
1785         if ( old_format_only(s) && !silent) {
1786             reiserfs_info (s, "using 3.5.x disk format\n") ;
1787         }
1788
1789         if ((errval = reiserfs_xattr_init (s, s->s_flags))) {
1790             dput (s->s_root);
1791             s->s_root = NULL;
1792             goto error;
1793         }
1794     }
1795     // mark hash in super block: it could be unset. overwrite should be ok
1796     set_sb_hash_function_code( rs, function2code(sbi->s_hash_function ) );
1797
1798     handle_attrs( s );
1799
1800     reiserfs_proc_info_init( s );
1801
1802     init_waitqueue_head (&(sbi->s_wait));
1803     spin_lock_init(&sbi->bitmap_lock);
1804
1805     return (0);
1806
1807  error:
1808     if (jinit_done) { /* kill the commit thread, free journal ram */
1809         journal_release_error(NULL, s) ;
1810     }
1811     if (SB_DISK_SUPER_BLOCK (s)) {
1812         for (j = 0; j < SB_BMAP_NR (s); j ++) {
1813             if (SB_AP_BITMAP (s))
1814                 brelse (SB_AP_BITMAP (s)[j].bh);
1815         }
1816         if (SB_AP_BITMAP (s))
1817             vfree (SB_AP_BITMAP (s));
1818     }
1819     if (SB_BUFFER_WITH_SB (s))
1820         brelse(SB_BUFFER_WITH_SB (s));
1821 #ifdef CONFIG_QUOTA
1822     for (j = 0; j < MAXQUOTAS; j++) {
1823         if (sbi->s_qf_names[j])
1824             kfree(sbi->s_qf_names[j]);
1825     }
1826 #endif
1827     if (sbi != NULL) {
1828         kfree(sbi);
1829     }
1830
1831     s->s_fs_info = NULL;
1832     return errval;
1833 }
1834
1835
1836 static int reiserfs_statfs (struct super_block * s, struct kstatfs * buf)
1837 {
1838   struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s);
1839
1840   buf->f_namelen = (REISERFS_MAX_NAME (s->s_blocksize));
1841   buf->f_bfree   = sb_free_blocks(rs);
1842   buf->f_bavail  = buf->f_bfree;
1843   buf->f_blocks  = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1844   buf->f_bsize   = s->s_blocksize;
1845   /* changed to accommodate gcc folks.*/
1846   buf->f_type    =  REISERFS_SUPER_MAGIC;
1847   return 0;
1848 }
1849
1850 #ifdef CONFIG_QUOTA
1851 static int reiserfs_dquot_initialize(struct inode *inode, int type)
1852 {
1853     struct reiserfs_transaction_handle th;
1854     int ret, err;
1855
1856     /* We may create quota structure so we need to reserve enough blocks */
1857     reiserfs_write_lock(inode->i_sb);
1858     ret = journal_begin(&th, inode->i_sb, 2*REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1859     if (ret)
1860         goto out;
1861     ret = dquot_initialize(inode, type);
1862     err = journal_end(&th, inode->i_sb, 2*REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1863     if (!ret && err)
1864         ret = err;
1865 out:
1866     reiserfs_write_unlock(inode->i_sb);
1867     return ret;
1868 }
1869
1870 static int reiserfs_dquot_drop(struct inode *inode)
1871 {
1872     struct reiserfs_transaction_handle th;
1873     int ret, err;
1874
1875     /* We may delete quota structure so we need to reserve enough blocks */
1876     reiserfs_write_lock(inode->i_sb);
1877     ret = journal_begin(&th, inode->i_sb, 2*REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1878     if (ret)
1879         goto out;
1880     ret = dquot_drop(inode);
1881     err = journal_end(&th, inode->i_sb, 2*REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1882     if (!ret && err)
1883         ret = err;
1884 out:
1885     reiserfs_write_unlock(inode->i_sb);
1886     return ret;
1887 }
1888
1889 static int reiserfs_write_dquot(struct dquot *dquot)
1890 {
1891     struct reiserfs_transaction_handle th;
1892     int ret, err;
1893
1894     reiserfs_write_lock(dquot->dq_sb);
1895     ret = journal_begin(&th, dquot->dq_sb, REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1896     if (ret)
1897         goto out;
1898     ret = dquot_commit(dquot);
1899     err = journal_end(&th, dquot->dq_sb, REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1900     if (!ret && err)
1901         ret = err;
1902 out:
1903     reiserfs_write_unlock(dquot->dq_sb);
1904     return ret;
1905 }
1906
1907 static int reiserfs_acquire_dquot(struct dquot *dquot)
1908 {
1909     struct reiserfs_transaction_handle th;
1910     int ret, err;
1911
1912     reiserfs_write_lock(dquot->dq_sb);
1913     ret = journal_begin(&th, dquot->dq_sb, REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1914     if (ret)
1915         goto out;
1916     ret = dquot_acquire(dquot);
1917     err = journal_end(&th, dquot->dq_sb, REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1918     if (!ret && err)
1919         ret = err;
1920 out:
1921     reiserfs_write_unlock(dquot->dq_sb);
1922     return ret;
1923 }
1924
1925 static int reiserfs_release_dquot(struct dquot *dquot)
1926 {
1927     struct reiserfs_transaction_handle th;
1928     int ret, err;
1929
1930     reiserfs_write_lock(dquot->dq_sb);
1931     ret = journal_begin(&th, dquot->dq_sb, REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1932     if (ret)
1933         goto out;
1934     ret = dquot_release(dquot);
1935     err = journal_end(&th, dquot->dq_sb, REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1936     if (!ret && err)
1937         ret = err;
1938 out:
1939     reiserfs_write_unlock(dquot->dq_sb);
1940     return ret;
1941 }
1942
1943 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
1944 {
1945     /* Are we journalling quotas? */
1946     if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
1947         REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
1948         dquot_mark_dquot_dirty(dquot);
1949         return reiserfs_write_dquot(dquot);
1950     }
1951     else
1952         return dquot_mark_dquot_dirty(dquot);
1953 }
1954
1955 static int reiserfs_write_info(struct super_block *sb, int type)
1956 {
1957     struct reiserfs_transaction_handle th;
1958     int ret, err;
1959
1960     /* Data block + inode block */
1961     reiserfs_write_lock(sb);
1962     ret = journal_begin(&th, sb, 2);
1963     if (ret)
1964         goto out;
1965     ret = dquot_commit_info(sb, type);
1966     err = journal_end(&th, sb, 2);
1967     if (!ret && err)
1968         ret = err;
1969 out:
1970     reiserfs_write_unlock(sb);
1971     return ret;
1972 }
1973
1974 /*
1975  * Turn on quotas during mount time - we need to find the quota file and such...
1976  */
1977 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
1978 {
1979         return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
1980                         REISERFS_SB(sb)->s_jquota_fmt, type);
1981 }
1982
1983 /*
1984  * Standard function to be called on quota_on
1985  */
1986 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id, char *path)
1987 {
1988     int err;
1989     struct nameidata nd;
1990
1991     if (!(REISERFS_SB(sb)->s_mount_opt & (1<<REISERFS_QUOTA)))
1992         return -EINVAL;
1993     err = path_lookup(path, LOOKUP_FOLLOW, &nd);
1994     if (err)
1995         return err;
1996     /* Quotafile not on the same filesystem? */
1997     if (nd.mnt->mnt_sb != sb) {
1998         path_release(&nd);
1999         return -EXDEV;
2000     }
2001     /* We must not pack tails for quota files on reiserfs for quota IO to work */
2002     if (!REISERFS_I(nd.dentry->d_inode)->i_flags & i_nopack_mask) {
2003         reiserfs_warning(sb, "reiserfs: Quota file must have tail packing disabled.");
2004         path_release(&nd);
2005         return -EINVAL;
2006     }
2007     /* Not journalling quota? No more tests needed... */
2008     if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] &&
2009         !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) {
2010         path_release(&nd);
2011         return vfs_quota_on(sb, type, format_id, path);
2012     }
2013     /* Quotafile not of fs root? */
2014     if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)
2015         reiserfs_warning(sb, "reiserfs: Quota file not on filesystem root. "
2016                              "Journalled quota will not work.");
2017     path_release(&nd);
2018     return vfs_quota_on(sb, type, format_id, path);
2019 }
2020
2021 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2022  * acquiring the locks... As quota files are never truncated and quota code
2023  * itself serializes the operations (and noone else should touch the files)
2024  * we don't have to be afraid of races */
2025 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2026                                    size_t len, loff_t off)
2027 {
2028     struct inode *inode = sb_dqopt(sb)->files[type];
2029     unsigned long blk = off >> sb->s_blocksize_bits;
2030     int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2031     size_t toread;
2032     struct buffer_head tmp_bh, *bh;
2033     loff_t i_size = i_size_read(inode);
2034
2035     if (off > i_size)
2036         return 0;
2037     if (off+len > i_size)
2038         len = i_size-off;
2039     toread = len;
2040     while (toread > 0) {
2041         tocopy = sb->s_blocksize - offset < toread ? sb->s_blocksize - offset : toread;
2042         tmp_bh.b_state = 0;
2043         /* Quota files are without tails so we can safely use this function */
2044         reiserfs_write_lock(sb);
2045         err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2046         reiserfs_write_unlock(sb);
2047         if (err)
2048             return err;
2049         if (!buffer_mapped(&tmp_bh))    /* A hole? */
2050             memset(data, 0, tocopy);
2051         else {
2052             bh = sb_bread(sb, tmp_bh.b_blocknr);
2053             if (!bh)
2054                 return -EIO;
2055             memcpy(data, bh->b_data+offset, tocopy);
2056             brelse(bh);
2057         }
2058         offset = 0;
2059         toread -= tocopy;
2060         data += tocopy;
2061         blk++;
2062     }
2063     return len;
2064 }
2065
2066 /* Write to quotafile (we know the transaction is already started and has
2067  * enough credits) */
2068 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2069                                     const char *data, size_t len, loff_t off)
2070 {
2071     struct inode *inode = sb_dqopt(sb)->files[type];
2072     unsigned long blk = off >> sb->s_blocksize_bits;
2073     int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2074     int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2075     size_t towrite = len;
2076     struct buffer_head tmp_bh, *bh;
2077
2078     down(&inode->i_sem);
2079     while (towrite > 0) {
2080         tocopy = sb->s_blocksize - offset < towrite ?
2081                  sb->s_blocksize - offset : towrite;
2082         tmp_bh.b_state = 0;
2083         err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2084         if (err)
2085             goto out;
2086         if (offset || tocopy != sb->s_blocksize)
2087             bh = sb_bread(sb, tmp_bh.b_blocknr);
2088         else
2089             bh = sb_getblk(sb, tmp_bh.b_blocknr);
2090         if (!bh) {
2091             err = -EIO;
2092             goto out;
2093         }
2094         lock_buffer(bh);
2095         memcpy(bh->b_data+offset, data, tocopy);
2096         flush_dcache_page(bh->b_page);
2097         set_buffer_uptodate(bh);
2098         unlock_buffer(bh);
2099         reiserfs_prepare_for_journal(sb, bh, 1);
2100         journal_mark_dirty(current->journal_info, sb, bh);
2101         if (!journal_quota)
2102                 reiserfs_add_ordered_list(inode, bh);
2103         brelse(bh);
2104         offset = 0;
2105         towrite -= tocopy;
2106         data += tocopy;
2107         blk++;
2108     }
2109 out:
2110     if (len == towrite)
2111         return err;
2112     if (inode->i_size < off+len-towrite)
2113         i_size_write(inode, off+len-towrite);
2114     inode->i_version++;
2115     inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2116     mark_inode_dirty(inode);
2117     up(&inode->i_sem);
2118     return len - towrite;
2119 }
2120
2121 #endif
2122
2123 static struct super_block*
2124 get_super_block (struct file_system_type *fs_type, int flags,
2125                  const char *dev_name, void *data)
2126 {
2127         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
2128 }
2129
2130 static int __init
2131 init_reiserfs_fs ( void )
2132 {
2133         int ret;
2134
2135         if ((ret = init_inodecache ())) {
2136                 return ret;
2137         }
2138
2139         if ((ret = reiserfs_xattr_register_handlers ()))
2140             goto failed_reiserfs_xattr_register_handlers;
2141
2142         reiserfs_proc_info_global_init ();
2143         reiserfs_proc_register_global ("version", reiserfs_global_version_in_proc);
2144
2145         ret = register_filesystem (& reiserfs_fs_type);
2146
2147         if (ret == 0) {
2148                 return 0;
2149         }
2150
2151         reiserfs_xattr_unregister_handlers ();
2152
2153 failed_reiserfs_xattr_register_handlers:
2154         reiserfs_proc_unregister_global ("version");
2155         reiserfs_proc_info_global_done ();
2156         destroy_inodecache ();
2157
2158         return ret;
2159 }
2160
2161 static void __exit
2162 exit_reiserfs_fs ( void )
2163 {
2164         reiserfs_xattr_unregister_handlers ();
2165         reiserfs_proc_unregister_global ("version");
2166         reiserfs_proc_info_global_done ();
2167         unregister_filesystem (& reiserfs_fs_type);
2168         destroy_inodecache ();
2169 }
2170
2171 struct file_system_type reiserfs_fs_type = {
2172         .owner          = THIS_MODULE,
2173         .name           = "reiserfs",
2174         .get_sb         = get_super_block,
2175         .kill_sb        = kill_block_super,
2176         .fs_flags       = FS_REQUIRES_DEV,
2177 };
2178
2179 MODULE_DESCRIPTION ("ReiserFS journaled filesystem");
2180 MODULE_AUTHOR      ("Hans Reiser <reiser@namesys.com>");
2181 MODULE_LICENSE     ("GPL");
2182
2183 module_init (init_reiserfs_fs);
2184 module_exit (exit_reiserfs_fs);