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