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