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

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