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