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

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