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

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