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