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

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