SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/reiserfs/super.c

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