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