err.no 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 if (old_format)
1822                 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
1823         else
1824                 set_bit(REISERFS_3_6, &(sbi->s_properties));
1825
1826         if (!(s->s_flags & MS_RDONLY)) {
1827
1828                 errval = journal_begin(&th, s, 1);
1829                 if (errval) {
1830                         dput(s->s_root);
1831                         s->s_root = NULL;
1832                         goto error;
1833                 }
1834                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1835
1836                 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1837                 set_sb_fs_state(rs, 0);
1838
1839                 if (old_format_only(s)) {
1840                         /* filesystem of format 3.5 either with standard or non-standard
1841                            journal */
1842                         if (convert_reiserfs(s)) {
1843                                 /* and -o conv is given */
1844                                 if (!silent)
1845                                         reiserfs_info(s,
1846                                                       "converting 3.5 filesystem to the 3.6 format");
1847
1848                                 if (is_reiserfs_3_5(rs))
1849                                         /* put magic string of 3.6 format. 2.2 will not be able to
1850                                            mount this filesystem anymore */
1851                                         memcpy(rs->s_v1.s_magic,
1852                                                reiserfs_3_6_magic_string,
1853                                                sizeof
1854                                                (reiserfs_3_6_magic_string));
1855
1856                                 set_sb_version(rs, REISERFS_VERSION_2);
1857                                 reiserfs_convert_objectid_map_v1(s);
1858                                 set_bit(REISERFS_3_6, &(sbi->s_properties));
1859                                 clear_bit(REISERFS_3_5, &(sbi->s_properties));
1860                         } else if (!silent) {
1861                                 reiserfs_info(s, "using 3.5.x disk format\n");
1862                         }
1863                 }
1864
1865                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1866                 errval = journal_end(&th, s, 1);
1867                 if (errval) {
1868                         dput(s->s_root);
1869                         s->s_root = NULL;
1870                         goto error;
1871                 }
1872
1873                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1874                         dput(s->s_root);
1875                         s->s_root = NULL;
1876                         goto error;
1877                 }
1878
1879                 /* look for files which were to be removed in previous session */
1880                 finish_unfinished(s);
1881         } else {
1882                 if (old_format_only(s) && !silent) {
1883                         reiserfs_info(s, "using 3.5.x disk format\n");
1884                 }
1885
1886                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1887                         dput(s->s_root);
1888                         s->s_root = NULL;
1889                         goto error;
1890                 }
1891         }
1892         // mark hash in super block: it could be unset. overwrite should be ok
1893         set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1894
1895         handle_attrs(s);
1896
1897         reiserfs_proc_info_init(s);
1898
1899         init_waitqueue_head(&(sbi->s_wait));
1900         spin_lock_init(&sbi->bitmap_lock);
1901
1902         return (0);
1903
1904       error:
1905         if (jinit_done) {       /* kill the commit thread, free journal ram */
1906                 journal_release_error(NULL, s);
1907         }
1908         if (SB_DISK_SUPER_BLOCK(s)) {
1909                 for (j = 0; j < SB_BMAP_NR(s); j++) {
1910                         if (SB_AP_BITMAP(s))
1911                                 brelse(SB_AP_BITMAP(s)[j].bh);
1912                 }
1913                 vfree(SB_AP_BITMAP(s));
1914         }
1915         if (SB_BUFFER_WITH_SB(s))
1916                 brelse(SB_BUFFER_WITH_SB(s));
1917 #ifdef CONFIG_QUOTA
1918         for (j = 0; j < MAXQUOTAS; j++) {
1919                 kfree(sbi->s_qf_names[j]);
1920                 sbi->s_qf_names[j] = NULL;
1921         }
1922 #endif
1923         kfree(sbi);
1924
1925         s->s_fs_info = NULL;
1926         return errval;
1927 }
1928
1929 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1930 {
1931         struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
1932
1933         buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1934         buf->f_bfree = sb_free_blocks(rs);
1935         buf->f_bavail = buf->f_bfree;
1936         buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1937         buf->f_bsize = dentry->d_sb->s_blocksize;
1938         /* changed to accommodate gcc folks. */
1939         buf->f_type = REISERFS_SUPER_MAGIC;
1940         return 0;
1941 }
1942
1943 #ifdef CONFIG_QUOTA
1944 static int reiserfs_dquot_initialize(struct inode *inode, int type)
1945 {
1946         struct reiserfs_transaction_handle th;
1947         int ret, err;
1948
1949         /* We may create quota structure so we need to reserve enough blocks */
1950         reiserfs_write_lock(inode->i_sb);
1951         ret =
1952             journal_begin(&th, inode->i_sb,
1953                           2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1954         if (ret)
1955                 goto out;
1956         ret = dquot_initialize(inode, type);
1957         err =
1958             journal_end(&th, inode->i_sb,
1959                         2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1960         if (!ret && err)
1961                 ret = err;
1962       out:
1963         reiserfs_write_unlock(inode->i_sb);
1964         return ret;
1965 }
1966
1967 static int reiserfs_dquot_drop(struct inode *inode)
1968 {
1969         struct reiserfs_transaction_handle th;
1970         int ret, err;
1971
1972         /* We may delete quota structure so we need to reserve enough blocks */
1973         reiserfs_write_lock(inode->i_sb);
1974         ret =
1975             journal_begin(&th, inode->i_sb,
1976                           2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1977         if (ret)
1978                 goto out;
1979         ret = dquot_drop(inode);
1980         err =
1981             journal_end(&th, inode->i_sb,
1982                         2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1983         if (!ret && err)
1984                 ret = err;
1985       out:
1986         reiserfs_write_unlock(inode->i_sb);
1987         return ret;
1988 }
1989
1990 static int reiserfs_write_dquot(struct dquot *dquot)
1991 {
1992         struct reiserfs_transaction_handle th;
1993         int ret, err;
1994
1995         reiserfs_write_lock(dquot->dq_sb);
1996         ret =
1997             journal_begin(&th, dquot->dq_sb,
1998                           REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1999         if (ret)
2000                 goto out;
2001         ret = dquot_commit(dquot);
2002         err =
2003             journal_end(&th, dquot->dq_sb,
2004                         REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2005         if (!ret && err)
2006                 ret = err;
2007       out:
2008         reiserfs_write_unlock(dquot->dq_sb);
2009         return ret;
2010 }
2011
2012 static int reiserfs_acquire_dquot(struct dquot *dquot)
2013 {
2014         struct reiserfs_transaction_handle th;
2015         int ret, err;
2016
2017         reiserfs_write_lock(dquot->dq_sb);
2018         ret =
2019             journal_begin(&th, dquot->dq_sb,
2020                           REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2021         if (ret)
2022                 goto out;
2023         ret = dquot_acquire(dquot);
2024         err =
2025             journal_end(&th, dquot->dq_sb,
2026                         REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2027         if (!ret && err)
2028                 ret = err;
2029       out:
2030         reiserfs_write_unlock(dquot->dq_sb);
2031         return ret;
2032 }
2033
2034 static int reiserfs_release_dquot(struct dquot *dquot)
2035 {
2036         struct reiserfs_transaction_handle th;
2037         int ret, err;
2038
2039         reiserfs_write_lock(dquot->dq_sb);
2040         ret =
2041             journal_begin(&th, dquot->dq_sb,
2042                           REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2043         if (ret)
2044                 goto out;
2045         ret = dquot_release(dquot);
2046         err =
2047             journal_end(&th, dquot->dq_sb,
2048                         REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2049         if (!ret && err)
2050                 ret = err;
2051       out:
2052         reiserfs_write_unlock(dquot->dq_sb);
2053         return ret;
2054 }
2055
2056 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2057 {
2058         /* Are we journalling quotas? */
2059         if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2060             REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2061                 dquot_mark_dquot_dirty(dquot);
2062                 return reiserfs_write_dquot(dquot);
2063         } else
2064                 return dquot_mark_dquot_dirty(dquot);
2065 }
2066
2067 static int reiserfs_write_info(struct super_block *sb, int type)
2068 {
2069         struct reiserfs_transaction_handle th;
2070         int ret, err;
2071
2072         /* Data block + inode block */
2073         reiserfs_write_lock(sb);
2074         ret = journal_begin(&th, sb, 2);
2075         if (ret)
2076                 goto out;
2077         ret = dquot_commit_info(sb, type);
2078         err = journal_end(&th, sb, 2);
2079         if (!ret && err)
2080                 ret = err;
2081       out:
2082         reiserfs_write_unlock(sb);
2083         return ret;
2084 }
2085
2086 /*
2087  * Turn on quotas during mount time - we need to find the quota file and such...
2088  */
2089 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2090 {
2091         return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2092                                   REISERFS_SB(sb)->s_jquota_fmt, type);
2093 }
2094
2095 /*
2096  * Standard function to be called on quota_on
2097  */
2098 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2099                              char *path)
2100 {
2101         int err;
2102         struct nameidata nd;
2103
2104         if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2105                 return -EINVAL;
2106         err = path_lookup(path, LOOKUP_FOLLOW, &nd);
2107         if (err)
2108                 return err;
2109         /* Quotafile not on the same filesystem? */
2110         if (nd.mnt->mnt_sb != sb) {
2111                 path_release(&nd);
2112                 return -EXDEV;
2113         }
2114         /* We must not pack tails for quota files on reiserfs for quota IO to work */
2115         if (!REISERFS_I(nd.dentry->d_inode)->i_flags & i_nopack_mask) {
2116                 reiserfs_warning(sb,
2117                                  "reiserfs: Quota file must have tail packing disabled.");
2118                 path_release(&nd);
2119                 return -EINVAL;
2120         }
2121         /* Not journalling quota? No more tests needed... */
2122         if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] &&
2123             !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) {
2124                 path_release(&nd);
2125                 return vfs_quota_on(sb, type, format_id, path);
2126         }
2127         /* Quotafile not of fs root? */
2128         if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)
2129                 reiserfs_warning(sb,
2130                                  "reiserfs: Quota file not on filesystem root. "
2131                                  "Journalled quota will not work.");
2132         path_release(&nd);
2133         return vfs_quota_on(sb, type, format_id, path);
2134 }
2135
2136 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2137  * acquiring the locks... As quota files are never truncated and quota code
2138  * itself serializes the operations (and noone else should touch the files)
2139  * we don't have to be afraid of races */
2140 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2141                                    size_t len, loff_t off)
2142 {
2143         struct inode *inode = sb_dqopt(sb)->files[type];
2144         unsigned long blk = off >> sb->s_blocksize_bits;
2145         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2146         size_t toread;
2147         struct buffer_head tmp_bh, *bh;
2148         loff_t i_size = i_size_read(inode);
2149
2150         if (off > i_size)
2151                 return 0;
2152         if (off + len > i_size)
2153                 len = i_size - off;
2154         toread = len;
2155         while (toread > 0) {
2156                 tocopy =
2157                     sb->s_blocksize - offset <
2158                     toread ? sb->s_blocksize - offset : toread;
2159                 tmp_bh.b_state = 0;
2160                 /* Quota files are without tails so we can safely use this function */
2161                 reiserfs_write_lock(sb);
2162                 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2163                 reiserfs_write_unlock(sb);
2164                 if (err)
2165                         return err;
2166                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
2167                         memset(data, 0, tocopy);
2168                 else {
2169                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2170                         if (!bh)
2171                                 return -EIO;
2172                         memcpy(data, bh->b_data + offset, tocopy);
2173                         brelse(bh);
2174                 }
2175                 offset = 0;
2176                 toread -= tocopy;
2177                 data += tocopy;
2178                 blk++;
2179         }
2180         return len;
2181 }
2182
2183 /* Write to quotafile (we know the transaction is already started and has
2184  * enough credits) */
2185 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2186                                     const char *data, size_t len, loff_t off)
2187 {
2188         struct inode *inode = sb_dqopt(sb)->files[type];
2189         unsigned long blk = off >> sb->s_blocksize_bits;
2190         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2191         int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2192         size_t towrite = len;
2193         struct buffer_head tmp_bh, *bh;
2194
2195         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2196         while (towrite > 0) {
2197                 tocopy = sb->s_blocksize - offset < towrite ?
2198                     sb->s_blocksize - offset : towrite;
2199                 tmp_bh.b_state = 0;
2200                 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2201                 if (err)
2202                         goto out;
2203                 if (offset || tocopy != sb->s_blocksize)
2204                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2205                 else
2206                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
2207                 if (!bh) {
2208                         err = -EIO;
2209                         goto out;
2210                 }
2211                 lock_buffer(bh);
2212                 memcpy(bh->b_data + offset, data, tocopy);
2213                 flush_dcache_page(bh->b_page);
2214                 set_buffer_uptodate(bh);
2215                 unlock_buffer(bh);
2216                 reiserfs_prepare_for_journal(sb, bh, 1);
2217                 journal_mark_dirty(current->journal_info, sb, bh);
2218                 if (!journal_quota)
2219                         reiserfs_add_ordered_list(inode, bh);
2220                 brelse(bh);
2221                 offset = 0;
2222                 towrite -= tocopy;
2223                 data += tocopy;
2224                 blk++;
2225         }
2226       out:
2227         if (len == towrite)
2228                 return err;
2229         if (inode->i_size < off + len - towrite)
2230                 i_size_write(inode, off + len - towrite);
2231         inode->i_version++;
2232         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2233         mark_inode_dirty(inode);
2234         mutex_unlock(&inode->i_mutex);
2235         return len - towrite;
2236 }
2237
2238 #endif
2239
2240 static int get_super_block(struct file_system_type *fs_type,
2241                            int flags, const char *dev_name,
2242                            void *data, struct vfsmount *mnt)
2243 {
2244         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2245                            mnt);
2246 }
2247
2248 static int __init init_reiserfs_fs(void)
2249 {
2250         int ret;
2251
2252         if ((ret = init_inodecache())) {
2253                 return ret;
2254         }
2255
2256         if ((ret = reiserfs_xattr_register_handlers()))
2257                 goto failed_reiserfs_xattr_register_handlers;
2258
2259         reiserfs_proc_info_global_init();
2260         reiserfs_proc_register_global("version",
2261                                       reiserfs_global_version_in_proc);
2262
2263         ret = register_filesystem(&reiserfs_fs_type);
2264
2265         if (ret == 0) {
2266                 return 0;
2267         }
2268
2269         reiserfs_xattr_unregister_handlers();
2270
2271       failed_reiserfs_xattr_register_handlers:
2272         reiserfs_proc_unregister_global("version");
2273         reiserfs_proc_info_global_done();
2274         destroy_inodecache();
2275
2276         return ret;
2277 }
2278
2279 static void __exit exit_reiserfs_fs(void)
2280 {
2281         reiserfs_xattr_unregister_handlers();
2282         reiserfs_proc_unregister_global("version");
2283         reiserfs_proc_info_global_done();
2284         unregister_filesystem(&reiserfs_fs_type);
2285         destroy_inodecache();
2286 }
2287
2288 struct file_system_type reiserfs_fs_type = {
2289         .owner = THIS_MODULE,
2290         .name = "reiserfs",
2291         .get_sb = get_super_block,
2292         .kill_sb = kill_block_super,
2293         .fs_flags = FS_REQUIRES_DEV,
2294 };
2295
2296 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2297 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2298 MODULE_LICENSE("GPL");
2299
2300 module_init(init_reiserfs_fs);
2301 module_exit(exit_reiserfs_fs);