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