fs/reiserfs/super.c

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