git.oblomov.eu Git - linux-2.6/blob - fs/reiserfs/super.c

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  *
   4  * Trivial changes by Alan Cox to add the LFS fixes
   5  *
   6  * Trivial Changes:
   7  * Rights granted to Hans Reiser to redistribute under other terms providing
   8  * he accepts all liability including but not limited to patent, fitness
   9  * for purpose, and direct or indirect claims arising from failure to perform.
  10  *
  11  * NO WARRANTY
  12  */
  13
  14 #include <linux/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                 if (!old_format_only(s))
1284                         set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1285                 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1286                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1287                 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1288         }
1289         /* this will force a full flush of all journal lists */
1290         SB_JOURNAL(s)->j_must_wait = 1;
1291         err = journal_end(&th, s, 10);
1292         if (err)
1293                 goto out_err;
1294         s->s_dirt = 0;
1295
1296         if (!(*mount_flags & MS_RDONLY)) {
1297                 finish_unfinished(s);
1298                 reiserfs_xattr_init(s, *mount_flags);
1299         }
1300
1301 out_ok:
1302         kfree(s->s_options);
1303         s->s_options = new_opts;
1304         return 0;
1305
1306 out_err:
1307         kfree(new_opts);
1308         return err;
1309 }
1310
1311 static int read_super_block(struct super_block *s, int offset)
1312 {
1313         struct buffer_head *bh;
1314         struct reiserfs_super_block *rs;
1315         int fs_blocksize;
1316
1317         bh = sb_bread(s, offset / s->s_blocksize);
1318         if (!bh) {
1319                 reiserfs_warning(s, "sh-2006: read_super_block: "
1320                                  "bread failed (dev %s, block %lu, size %lu)",
1321                                  reiserfs_bdevname(s), offset / s->s_blocksize,
1322                                  s->s_blocksize);
1323                 return 1;
1324         }
1325
1326         rs = (struct reiserfs_super_block *)bh->b_data;
1327         if (!is_any_reiserfs_magic_string(rs)) {
1328                 brelse(bh);
1329                 return 1;
1330         }
1331         //
1332         // ok, reiserfs signature (old or new) found in at the given offset
1333         //
1334         fs_blocksize = sb_blocksize(rs);
1335         brelse(bh);
1336         sb_set_blocksize(s, fs_blocksize);
1337
1338         bh = sb_bread(s, offset / s->s_blocksize);
1339         if (!bh) {
1340                 reiserfs_warning(s, "sh-2007: read_super_block: "
1341                                  "bread failed (dev %s, block %lu, size %lu)\n",
1342                                  reiserfs_bdevname(s), offset / s->s_blocksize,
1343                                  s->s_blocksize);
1344                 return 1;
1345         }
1346
1347         rs = (struct reiserfs_super_block *)bh->b_data;
1348         if (sb_blocksize(rs) != s->s_blocksize) {
1349                 reiserfs_warning(s, "sh-2011: read_super_block: "
1350                                  "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1351                                  reiserfs_bdevname(s),
1352                                  (unsigned long long)bh->b_blocknr,
1353                                  s->s_blocksize);
1354                 brelse(bh);
1355                 return 1;
1356         }
1357
1358         if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1359                 brelse(bh);
1360                 reiserfs_warning(s,
1361                                  "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1362                                  "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1363                                  "get newer reiserfsprogs package");
1364                 return 1;
1365         }
1366
1367         SB_BUFFER_WITH_SB(s) = bh;
1368         SB_DISK_SUPER_BLOCK(s) = rs;
1369
1370         if (is_reiserfs_jr(rs)) {
1371                 /* magic is of non-standard journal filesystem, look at s_version to
1372                    find which format is in use */
1373                 if (sb_version(rs) == REISERFS_VERSION_2)
1374                         reiserfs_info(s, "found reiserfs format \"3.6\""
1375                                       " with non-standard journal\n");
1376                 else if (sb_version(rs) == REISERFS_VERSION_1)
1377                         reiserfs_info(s, "found reiserfs format \"3.5\""
1378                                       " with non-standard journal\n");
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_info(s, "FS seems to be empty, autodetect "
1458                                          "is using the default hash\n");
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                 } else
1823                         set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1824
1825
1826                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1827                 errval = journal_end(&th, s, 1);
1828                 if (errval) {
1829                         dput(s->s_root);
1830                         s->s_root = NULL;
1831                         goto error;
1832                 }
1833
1834                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1835                         dput(s->s_root);
1836                         s->s_root = NULL;
1837                         goto error;
1838                 }
1839
1840                 /* look for files which were to be removed in previous session */
1841                 finish_unfinished(s);
1842         } else {
1843                 if (old_format_only(s) && !silent) {
1844                         reiserfs_info(s, "using 3.5.x disk format\n");
1845                 }
1846
1847                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1848                         dput(s->s_root);
1849                         s->s_root = NULL;
1850                         goto error;
1851                 }
1852         }
1853         // mark hash in super block: it could be unset. overwrite should be ok
1854         set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1855
1856         handle_attrs(s);
1857
1858         reiserfs_proc_info_init(s);
1859
1860         init_waitqueue_head(&(sbi->s_wait));
1861         spin_lock_init(&sbi->bitmap_lock);
1862
1863         return (0);
1864
1865 error:
1866         if (jinit_done) {       /* kill the commit thread, free journal ram */
1867                 journal_release_error(NULL, s);
1868         }
1869
1870         reiserfs_free_bitmap_cache(s);
1871         if (SB_BUFFER_WITH_SB(s))
1872                 brelse(SB_BUFFER_WITH_SB(s));
1873 #ifdef CONFIG_QUOTA
1874         {
1875                 int j;
1876                 for (j = 0; j < MAXQUOTAS; j++)
1877                         kfree(qf_names[j]);
1878         }
1879 #endif
1880         kfree(sbi);
1881
1882         s->s_fs_info = NULL;
1883         return errval;
1884 }
1885
1886 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1887 {
1888         struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
1889
1890         buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1891         buf->f_bfree = sb_free_blocks(rs);
1892         buf->f_bavail = buf->f_bfree;
1893         buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1894         buf->f_bsize = dentry->d_sb->s_blocksize;
1895         /* changed to accommodate gcc folks. */
1896         buf->f_type = REISERFS_SUPER_MAGIC;
1897         return 0;
1898 }
1899
1900 #ifdef CONFIG_QUOTA
1901 static int reiserfs_dquot_initialize(struct inode *inode, int type)
1902 {
1903         struct reiserfs_transaction_handle th;
1904         int ret, err;
1905
1906         /* We may create quota structure so we need to reserve enough blocks */
1907         reiserfs_write_lock(inode->i_sb);
1908         ret =
1909             journal_begin(&th, inode->i_sb,
1910                           2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1911         if (ret)
1912                 goto out;
1913         ret = dquot_initialize(inode, type);
1914         err =
1915             journal_end(&th, inode->i_sb,
1916                         2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1917         if (!ret && err)
1918                 ret = err;
1919       out:
1920         reiserfs_write_unlock(inode->i_sb);
1921         return ret;
1922 }
1923
1924 static int reiserfs_dquot_drop(struct inode *inode)
1925 {
1926         struct reiserfs_transaction_handle th;
1927         int ret, err;
1928
1929         /* We may delete quota structure so we need to reserve enough blocks */
1930         reiserfs_write_lock(inode->i_sb);
1931         ret =
1932             journal_begin(&th, inode->i_sb,
1933                           2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1934         if (ret) {
1935                 /*
1936                  * We call dquot_drop() anyway to at least release references
1937                  * to quota structures so that umount does not hang.
1938                  */
1939                 dquot_drop(inode);
1940                 goto out;
1941         }
1942         ret = dquot_drop(inode);
1943         err =
1944             journal_end(&th, inode->i_sb,
1945                         2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1946         if (!ret && err)
1947                 ret = err;
1948       out:
1949         reiserfs_write_unlock(inode->i_sb);
1950         return ret;
1951 }
1952
1953 static int reiserfs_write_dquot(struct dquot *dquot)
1954 {
1955         struct reiserfs_transaction_handle th;
1956         int ret, err;
1957
1958         reiserfs_write_lock(dquot->dq_sb);
1959         ret =
1960             journal_begin(&th, dquot->dq_sb,
1961                           REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1962         if (ret)
1963                 goto out;
1964         ret = dquot_commit(dquot);
1965         err =
1966             journal_end(&th, dquot->dq_sb,
1967                         REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1968         if (!ret && err)
1969                 ret = err;
1970       out:
1971         reiserfs_write_unlock(dquot->dq_sb);
1972         return ret;
1973 }
1974
1975 static int reiserfs_acquire_dquot(struct dquot *dquot)
1976 {
1977         struct reiserfs_transaction_handle th;
1978         int ret, err;
1979
1980         reiserfs_write_lock(dquot->dq_sb);
1981         ret =
1982             journal_begin(&th, dquot->dq_sb,
1983                           REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1984         if (ret)
1985                 goto out;
1986         ret = dquot_acquire(dquot);
1987         err =
1988             journal_end(&th, dquot->dq_sb,
1989                         REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1990         if (!ret && err)
1991                 ret = err;
1992       out:
1993         reiserfs_write_unlock(dquot->dq_sb);
1994         return ret;
1995 }
1996
1997 static int reiserfs_release_dquot(struct dquot *dquot)
1998 {
1999         struct reiserfs_transaction_handle th;
2000         int ret, err;
2001
2002         reiserfs_write_lock(dquot->dq_sb);
2003         ret =
2004             journal_begin(&th, dquot->dq_sb,
2005                           REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2006         if (ret) {
2007                 /* Release dquot anyway to avoid endless cycle in dqput() */
2008                 dquot_release(dquot);
2009                 goto out;
2010         }
2011         ret = dquot_release(dquot);
2012         err =
2013             journal_end(&th, dquot->dq_sb,
2014                         REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2015         if (!ret && err)
2016                 ret = err;
2017       out:
2018         reiserfs_write_unlock(dquot->dq_sb);
2019         return ret;
2020 }
2021
2022 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2023 {
2024         /* Are we journaling quotas? */
2025         if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2026             REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2027                 dquot_mark_dquot_dirty(dquot);
2028                 return reiserfs_write_dquot(dquot);
2029         } else
2030                 return dquot_mark_dquot_dirty(dquot);
2031 }
2032
2033 static int reiserfs_write_info(struct super_block *sb, int type)
2034 {
2035         struct reiserfs_transaction_handle th;
2036         int ret, err;
2037
2038         /* Data block + inode block */
2039         reiserfs_write_lock(sb);
2040         ret = journal_begin(&th, sb, 2);
2041         if (ret)
2042                 goto out;
2043         ret = dquot_commit_info(sb, type);
2044         err = journal_end(&th, sb, 2);
2045         if (!ret && err)
2046                 ret = err;
2047       out:
2048         reiserfs_write_unlock(sb);
2049         return ret;
2050 }
2051
2052 /*
2053  * Turn on quotas during mount time - we need to find the quota file and such...
2054  */
2055 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2056 {
2057         return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2058                                   REISERFS_SB(sb)->s_jquota_fmt, type);
2059 }
2060
2061 /*
2062  * Standard function to be called on quota_on
2063  */
2064 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2065                              char *name, int remount)
2066 {
2067         int err;
2068         struct path path;
2069         struct inode *inode;
2070         struct reiserfs_transaction_handle th;
2071
2072         if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2073                 return -EINVAL;
2074         /* No more checks needed? Path and format_id are bogus anyway... */
2075         if (remount)
2076                 return vfs_quota_on(sb, type, format_id, name, 1);
2077         err = kern_path(name, LOOKUP_FOLLOW, &path);
2078         if (err)
2079                 return err;
2080         /* Quotafile not on the same filesystem? */
2081         if (path.mnt->mnt_sb != sb) {
2082                 err = -EXDEV;
2083                 goto out;
2084         }
2085         inode = path.dentry->d_inode;
2086         /* We must not pack tails for quota files on reiserfs for quota IO to work */
2087         if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2088                 err = reiserfs_unpack(inode, NULL);
2089                 if (err) {
2090                         reiserfs_warning(sb,
2091                                 "reiserfs: Unpacking tail of quota file failed"
2092                                 " (%d). Cannot turn on quotas.", err);
2093                         err = -EINVAL;
2094                         goto out;
2095                 }
2096                 mark_inode_dirty(inode);
2097         }
2098         /* Journaling quota? */
2099         if (REISERFS_SB(sb)->s_qf_names[type]) {
2100                 /* Quotafile not of fs root? */
2101                 if (path.dentry->d_parent != sb->s_root)
2102                         reiserfs_warning(sb,
2103                                  "reiserfs: Quota file not on filesystem root. "
2104                                  "Journalled quota will not work.");
2105         }
2106
2107         /*
2108          * When we journal data on quota file, we have to flush journal to see
2109          * all updates to the file when we bypass pagecache...
2110          */
2111         if (reiserfs_file_data_log(inode)) {
2112                 /* Just start temporary transaction and finish it */
2113                 err = journal_begin(&th, sb, 1);
2114                 if (err)
2115                         goto out;
2116                 err = journal_end_sync(&th, sb, 1);
2117                 if (err)
2118                         goto out;
2119         }
2120         err = vfs_quota_on_path(sb, type, format_id, &path);
2121 out:
2122         path_put(&path);
2123         return err;
2124 }
2125
2126 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2127  * acquiring the locks... As quota files are never truncated and quota code
2128  * itself serializes the operations (and noone else should touch the files)
2129  * we don't have to be afraid of races */
2130 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2131                                    size_t len, loff_t off)
2132 {
2133         struct inode *inode = sb_dqopt(sb)->files[type];
2134         unsigned long blk = off >> sb->s_blocksize_bits;
2135         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2136         size_t toread;
2137         struct buffer_head tmp_bh, *bh;
2138         loff_t i_size = i_size_read(inode);
2139
2140         if (off > i_size)
2141                 return 0;
2142         if (off + len > i_size)
2143                 len = i_size - off;
2144         toread = len;
2145         while (toread > 0) {
2146                 tocopy =
2147                     sb->s_blocksize - offset <
2148                     toread ? sb->s_blocksize - offset : toread;
2149                 tmp_bh.b_state = 0;
2150                 /* Quota files are without tails so we can safely use this function */
2151                 reiserfs_write_lock(sb);
2152                 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2153                 reiserfs_write_unlock(sb);
2154                 if (err)
2155                         return err;
2156                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
2157                         memset(data, 0, tocopy);
2158                 else {
2159                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2160                         if (!bh)
2161                                 return -EIO;
2162                         memcpy(data, bh->b_data + offset, tocopy);
2163                         brelse(bh);
2164                 }
2165                 offset = 0;
2166                 toread -= tocopy;
2167                 data += tocopy;
2168                 blk++;
2169         }
2170         return len;
2171 }
2172
2173 /* Write to quotafile (we know the transaction is already started and has
2174  * enough credits) */
2175 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2176                                     const char *data, size_t len, loff_t off)
2177 {
2178         struct inode *inode = sb_dqopt(sb)->files[type];
2179         unsigned long blk = off >> sb->s_blocksize_bits;
2180         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2181         int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2182         size_t towrite = len;
2183         struct buffer_head tmp_bh, *bh;
2184
2185         if (!current->journal_info) {
2186                 printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2187                         " cancelled because transaction is not started.\n",
2188                         (unsigned long long)off, (unsigned long long)len);
2189                 return -EIO;
2190         }
2191         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2192         while (towrite > 0) {
2193                 tocopy = sb->s_blocksize - offset < towrite ?
2194                     sb->s_blocksize - offset : towrite;
2195                 tmp_bh.b_state = 0;
2196                 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2197                 if (err)
2198                         goto out;
2199                 if (offset || tocopy != sb->s_blocksize)
2200                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2201                 else
2202                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
2203                 if (!bh) {
2204                         err = -EIO;
2205                         goto out;
2206                 }
2207                 lock_buffer(bh);
2208                 memcpy(bh->b_data + offset, data, tocopy);
2209                 flush_dcache_page(bh->b_page);
2210                 set_buffer_uptodate(bh);
2211                 unlock_buffer(bh);
2212                 reiserfs_prepare_for_journal(sb, bh, 1);
2213                 journal_mark_dirty(current->journal_info, sb, bh);
2214                 if (!journal_quota)
2215                         reiserfs_add_ordered_list(inode, bh);
2216                 brelse(bh);
2217                 offset = 0;
2218                 towrite -= tocopy;
2219                 data += tocopy;
2220                 blk++;
2221         }
2222 out:
2223         if (len == towrite) {
2224                 mutex_unlock(&inode->i_mutex);
2225                 return err;
2226         }
2227         if (inode->i_size < off + len - towrite)
2228                 i_size_write(inode, off + len - towrite);
2229         inode->i_version++;
2230         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2231         mark_inode_dirty(inode);
2232         mutex_unlock(&inode->i_mutex);
2233         return len - towrite;
2234 }
2235
2236 #endif
2237
2238 static int get_super_block(struct file_system_type *fs_type,
2239                            int flags, const char *dev_name,
2240                            void *data, struct vfsmount *mnt)
2241 {
2242         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2243                            mnt);
2244 }
2245
2246 static int __init init_reiserfs_fs(void)
2247 {
2248         int ret;
2249
2250         if ((ret = init_inodecache())) {
2251                 return ret;
2252         }
2253
2254         if ((ret = reiserfs_xattr_register_handlers()))
2255                 goto failed_reiserfs_xattr_register_handlers;
2256
2257         reiserfs_proc_info_global_init();
2258         reiserfs_proc_register_global("version",
2259                                       reiserfs_global_version_in_proc);
2260
2261         ret = register_filesystem(&reiserfs_fs_type);
2262
2263         if (ret == 0) {
2264                 return 0;
2265         }
2266
2267         reiserfs_xattr_unregister_handlers();
2268
2269       failed_reiserfs_xattr_register_handlers:
2270         reiserfs_proc_unregister_global("version");
2271         reiserfs_proc_info_global_done();
2272         destroy_inodecache();
2273
2274         return ret;
2275 }
2276
2277 static void __exit exit_reiserfs_fs(void)
2278 {
2279         reiserfs_xattr_unregister_handlers();
2280         reiserfs_proc_unregister_global("version");
2281         reiserfs_proc_info_global_done();
2282         unregister_filesystem(&reiserfs_fs_type);
2283         destroy_inodecache();
2284 }
2285
2286 struct file_system_type reiserfs_fs_type = {
2287         .owner = THIS_MODULE,
2288         .name = "reiserfs",
2289         .get_sb = get_super_block,
2290         .kill_sb = reiserfs_kill_sb,
2291         .fs_flags = FS_REQUIRES_DEV,
2292 };
2293
2294 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2295 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2296 MODULE_LICENSE("GPL");
2297
2298 module_init(init_reiserfs_fs);
2299 module_exit(exit_reiserfs_fs);