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