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

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