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/vfs.h>
  26 #include <linux/mnt_namespace.h>
  27 #include <linux/mount.h>
  28 #include <linux/namei.h>
  29 #include <linux/quotaops.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 journalled 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_mount(s, i);
 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(struct kmem_cache * cachep, 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 *);
 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 {
 881         int c;
 882         char *arg = NULL;
 883         char *pos;
 884         opt_desc_t opts[] = {
 885                 /* Compatibility stuff, so that -o notail for old setups still work */
 886                 {"tails",.arg_required = 't',.values = tails},
 887                 {"notail",.clrmask =
 888                  (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
 889                 {"conv",.setmask = 1 << REISERFS_CONVERT},
 890                 {"attrs",.setmask = 1 << REISERFS_ATTRS},
 891                 {"noattrs",.clrmask = 1 << REISERFS_ATTRS},
 892 #ifdef CONFIG_REISERFS_FS_XATTR
 893                 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
 894                 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
 895 #else
 896                 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
 897                 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 898 #endif
 899 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
 900                 {"acl",.setmask = 1 << REISERFS_POSIXACL},
 901                 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
 902 #else
 903                 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
 904                 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 905 #endif
 906                 {.option_name = "nolog"},
 907                 {"replayonly",.setmask = 1 << REPLAYONLY},
 908                 {"block-allocator",.arg_required = 'a',.values = balloc},
 909                 {"data",.arg_required = 'd',.values = logging_mode},
 910                 {"barrier",.arg_required = 'b',.values = barrier_mode},
 911                 {"resize",.arg_required = 'r',.values = NULL},
 912                 {"jdev",.arg_required = 'j',.values = NULL},
 913                 {"nolargeio",.arg_required = 'w',.values = NULL},
 914                 {"commit",.arg_required = 'c',.values = NULL},
 915                 {"usrquota",.setmask = 1 << REISERFS_QUOTA},
 916                 {"grpquota",.setmask = 1 << REISERFS_QUOTA},
 917                 {"noquota",.clrmask = 1 << REISERFS_QUOTA},
 918                 {"errors",.arg_required = 'e',.values = error_actions},
 919                 {"usrjquota",.arg_required =
 920                  'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
 921                 {"grpjquota",.arg_required =
 922                  'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
 923                 {"jqfmt",.arg_required = 'f',.values = NULL},
 924                 {.option_name = NULL}
 925         };
 926
 927         *blocks = 0;
 928         if (!options || !*options)
 929                 /* use default configuration: create tails, journaling on, no
 930                    conversion to newest format */
 931                 return 1;
 932
 933         for (pos = options; pos;) {
 934                 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
 935                 if (c == -1)
 936                         /* wrong option is given */
 937                         return 0;
 938
 939                 if (c == 'r') {
 940                         char *p;
 941
 942                         p = NULL;
 943                         /* "resize=NNN" or "resize=auto" */
 944
 945                         if (!strcmp(arg, "auto")) {
 946                                 /* From JFS code, to auto-get the size. */
 947                                 *blocks =
 948                                     s->s_bdev->bd_inode->i_size >> s->
 949                                     s_blocksize_bits;
 950                         } else {
 951                                 *blocks = simple_strtoul(arg, &p, 0);
 952                                 if (*p != '\0') {
 953                                         /* NNN does not look like a number */
 954                                         reiserfs_warning(s,
 955                                                          "reiserfs_parse_options: bad value %s",
 956                                                          arg);
 957                                         return 0;
 958                                 }
 959                         }
 960                 }
 961
 962                 if (c == 'c') {
 963                         char *p = NULL;
 964                         unsigned long val = simple_strtoul(arg, &p, 0);
 965                         /* commit=NNN (time in seconds) */
 966                         if (*p != '\0' || val >= (unsigned int)-1) {
 967                                 reiserfs_warning(s,
 968                                                  "reiserfs_parse_options: bad value %s",
 969                                                  arg);
 970                                 return 0;
 971                         }
 972                         *commit_max_age = (unsigned int)val;
 973                 }
 974
 975                 if (c == 'w') {
 976                         reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported");
 977                         return 0;
 978                 }
 979
 980                 if (c == 'j') {
 981                         if (arg && *arg && jdev_name) {
 982                                 if (*jdev_name) {       //Hm, already assigned?
 983                                         reiserfs_warning(s,
 984                                                          "reiserfs_parse_options: journal device was already  specified to be %s",
 985                                                          *jdev_name);
 986                                         return 0;
 987                                 }
 988                                 *jdev_name = arg;
 989                         }
 990                 }
 991 #ifdef CONFIG_QUOTA
 992                 if (c == 'u' || c == 'g') {
 993                         int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
 994
 995                         if (sb_any_quota_enabled(s)) {
 996                                 reiserfs_warning(s,
 997                                                  "reiserfs_parse_options: cannot change journalled quota options when quota turned on.");
 998                                 return 0;
 999                         }
1000                         if (*arg) {     /* Some filename specified? */
1001                                 if (REISERFS_SB(s)->s_qf_names[qtype]
1002                                     && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1003                                               arg)) {
1004                                         reiserfs_warning(s,
1005                                                          "reiserfs_parse_options: %s quota file already specified.",
1006                                                          QTYPE2NAME(qtype));
1007                                         return 0;
1008                                 }
1009                                 if (strchr(arg, '/')) {
1010                                         reiserfs_warning(s,
1011                                                          "reiserfs_parse_options: quotafile must be on filesystem root.");
1012                                         return 0;
1013                                 }
1014                                 REISERFS_SB(s)->s_qf_names[qtype] =
1015                                     kmalloc(strlen(arg) + 1, GFP_KERNEL);
1016                                 if (!REISERFS_SB(s)->s_qf_names[qtype]) {
1017                                         reiserfs_warning(s,
1018                                                          "reiserfs_parse_options: not enough memory for storing quotafile name.");
1019                                         return 0;
1020                                 }
1021                                 strcpy(REISERFS_SB(s)->s_qf_names[qtype], arg);
1022                                 *mount_options |= 1 << REISERFS_QUOTA;
1023                         } else {
1024                                 kfree(REISERFS_SB(s)->s_qf_names[qtype]);
1025                                 REISERFS_SB(s)->s_qf_names[qtype] = NULL;
1026                         }
1027                 }
1028                 if (c == 'f') {
1029                         if (!strcmp(arg, "vfsold"))
1030                                 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_OLD;
1031                         else if (!strcmp(arg, "vfsv0"))
1032                                 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V0;
1033                         else {
1034                                 reiserfs_warning(s,
1035                                                  "reiserfs_parse_options: unknown quota format specified.");
1036                                 return 0;
1037                         }
1038                 }
1039 #else
1040                 if (c == 'u' || c == 'g' || c == 'f') {
1041                         reiserfs_warning(s,
1042                                          "reiserfs_parse_options: journalled quota options not supported.");
1043                         return 0;
1044                 }
1045 #endif
1046         }
1047
1048 #ifdef CONFIG_QUOTA
1049         if (!REISERFS_SB(s)->s_jquota_fmt
1050             && (REISERFS_SB(s)->s_qf_names[USRQUOTA]
1051                 || REISERFS_SB(s)->s_qf_names[GRPQUOTA])) {
1052                 reiserfs_warning(s,
1053                                  "reiserfs_parse_options: journalled quota format not specified.");
1054                 return 0;
1055         }
1056         /* This checking is not precise wrt the quota type but for our purposes it is sufficient */
1057         if (!(*mount_options & (1 << REISERFS_QUOTA))
1058             && sb_any_quota_enabled(s)) {
1059                 reiserfs_warning(s,
1060                                  "reiserfs_parse_options: quota options must be present when quota is turned on.");
1061                 return 0;
1062         }
1063 #endif
1064
1065         return 1;
1066 }
1067
1068 static void switch_data_mode(struct super_block *s, unsigned long mode)
1069 {
1070         REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1071                                          (1 << REISERFS_DATA_ORDERED) |
1072                                          (1 << REISERFS_DATA_WRITEBACK));
1073         REISERFS_SB(s)->s_mount_opt |= (1 << mode);
1074 }
1075
1076 static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1077 {
1078         if (mount_options & (1 << REISERFS_DATA_LOG)) {
1079                 if (!reiserfs_data_log(s)) {
1080                         switch_data_mode(s, REISERFS_DATA_LOG);
1081                         reiserfs_info(s, "switching to journaled data mode\n");
1082                 }
1083         } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1084                 if (!reiserfs_data_ordered(s)) {
1085                         switch_data_mode(s, REISERFS_DATA_ORDERED);
1086                         reiserfs_info(s, "switching to ordered data mode\n");
1087                 }
1088         } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1089                 if (!reiserfs_data_writeback(s)) {
1090                         switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1091                         reiserfs_info(s, "switching to writeback data mode\n");
1092                 }
1093         }
1094 }
1095
1096 static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1097 {
1098         int flush = (1 << REISERFS_BARRIER_FLUSH);
1099         int none = (1 << REISERFS_BARRIER_NONE);
1100         int all_barrier = flush | none;
1101
1102         if (bits & all_barrier) {
1103                 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1104                 if (bits & flush) {
1105                         REISERFS_SB(s)->s_mount_opt |= flush;
1106                         printk("reiserfs: enabling write barrier flush mode\n");
1107                 } else if (bits & none) {
1108                         REISERFS_SB(s)->s_mount_opt |= none;
1109                         printk("reiserfs: write barriers turned off\n");
1110                 }
1111         }
1112 }
1113
1114 static void handle_attrs(struct super_block *s)
1115 {
1116         struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1117
1118         if (reiserfs_attrs(s)) {
1119                 if (old_format_only(s)) {
1120                         reiserfs_warning(s,
1121                                          "reiserfs: cannot support attributes on 3.5.x disk format");
1122                         REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1123                         return;
1124                 }
1125                 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1126                         reiserfs_warning(s,
1127                                          "reiserfs: cannot support attributes until flag is set in super-block");
1128                         REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1129                 }
1130         }
1131 }
1132
1133 static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
1134 {
1135         struct reiserfs_super_block *rs;
1136         struct reiserfs_transaction_handle th;
1137         unsigned long blocks;
1138         unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1139         unsigned long safe_mask = 0;
1140         unsigned int commit_max_age = (unsigned int)-1;
1141         struct reiserfs_journal *journal = SB_JOURNAL(s);
1142         char *new_opts = kstrdup(arg, GFP_KERNEL);
1143         int err;
1144 #ifdef CONFIG_QUOTA
1145         int i;
1146 #endif
1147
1148         rs = SB_DISK_SUPER_BLOCK(s);
1149
1150         if (!reiserfs_parse_options
1151             (s, arg, &mount_options, &blocks, NULL, &commit_max_age)) {
1152 #ifdef CONFIG_QUOTA
1153                 for (i = 0; i < MAXQUOTAS; i++) {
1154                         kfree(REISERFS_SB(s)->s_qf_names[i]);
1155                         REISERFS_SB(s)->s_qf_names[i] = NULL;
1156                 }
1157 #endif
1158                 err = -EINVAL;
1159                 goto out_err;
1160         }
1161
1162         handle_attrs(s);
1163
1164         /* Add options that are safe here */
1165         safe_mask |= 1 << REISERFS_SMALLTAIL;
1166         safe_mask |= 1 << REISERFS_LARGETAIL;
1167         safe_mask |= 1 << REISERFS_NO_BORDER;
1168         safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1169         safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1170         safe_mask |= 1 << REISERFS_TEST4;
1171         safe_mask |= 1 << REISERFS_ATTRS;
1172         safe_mask |= 1 << REISERFS_XATTRS_USER;
1173         safe_mask |= 1 << REISERFS_POSIXACL;
1174         safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1175         safe_mask |= 1 << REISERFS_BARRIER_NONE;
1176         safe_mask |= 1 << REISERFS_ERROR_RO;
1177         safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1178         safe_mask |= 1 << REISERFS_ERROR_PANIC;
1179         safe_mask |= 1 << REISERFS_QUOTA;
1180
1181         /* Update the bitmask, taking care to keep
1182          * the bits we're not allowed to change here */
1183         REISERFS_SB(s)->s_mount_opt =
1184             (REISERFS_SB(s)->
1185              s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
1186
1187         if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1188                 journal->j_max_commit_age = commit_max_age;
1189                 journal->j_max_trans_age = commit_max_age;
1190         } else if (commit_max_age == 0) {
1191                 /* 0 means restore defaults. */
1192                 journal->j_max_commit_age = journal->j_default_max_commit_age;
1193                 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1194         }
1195
1196         if (blocks) {
1197                 err = reiserfs_resize(s, blocks);
1198                 if (err != 0)
1199                         goto out_err;
1200         }
1201
1202         if (*mount_flags & MS_RDONLY) {
1203                 reiserfs_xattr_init(s, *mount_flags);
1204                 /* remount read-only */
1205                 if (s->s_flags & MS_RDONLY)
1206                         /* it is read-only already */
1207                         goto out_ok;
1208                 /* try to remount file system with read-only permissions */
1209                 if (sb_umount_state(rs) == REISERFS_VALID_FS
1210                     || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
1211                         goto out_ok;
1212                 }
1213
1214                 err = journal_begin(&th, s, 10);
1215                 if (err)
1216                         goto out_err;
1217
1218                 /* Mounting a rw partition read-only. */
1219                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1220                 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1221                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1222         } else {
1223                 /* remount read-write */
1224                 if (!(s->s_flags & MS_RDONLY)) {
1225                         reiserfs_xattr_init(s, *mount_flags);
1226                         goto out_ok;    /* We are read-write already */
1227                 }
1228
1229                 if (reiserfs_is_journal_aborted(journal)) {
1230                         err = journal->j_errno;
1231                         goto out_err;
1232                 }
1233
1234                 handle_data_mode(s, mount_options);
1235                 handle_barrier_mode(s, mount_options);
1236                 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1237                 s->s_flags &= ~MS_RDONLY;       /* now it is safe to call journal_begin */
1238                 err = journal_begin(&th, s, 10);
1239                 if (err)
1240                         goto out_err;
1241
1242                 /* Mount a partition which is read-only, read-write */
1243                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1244                 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1245                 s->s_flags &= ~MS_RDONLY;
1246                 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1247                 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1248                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1249                 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1250         }
1251         /* this will force a full flush of all journal lists */
1252         SB_JOURNAL(s)->j_must_wait = 1;
1253         err = journal_end(&th, s, 10);
1254         if (err)
1255                 goto out_err;
1256         s->s_dirt = 0;
1257
1258         if (!(*mount_flags & MS_RDONLY)) {
1259                 finish_unfinished(s);
1260                 reiserfs_xattr_init(s, *mount_flags);
1261         }
1262
1263 out_ok:
1264         kfree(s->s_options);
1265         s->s_options = new_opts;
1266         return 0;
1267
1268 out_err:
1269         kfree(new_opts);
1270         return err;
1271 }
1272
1273 static int read_super_block(struct super_block *s, int offset)
1274 {
1275         struct buffer_head *bh;
1276         struct reiserfs_super_block *rs;
1277         int fs_blocksize;
1278
1279         bh = sb_bread(s, offset / s->s_blocksize);
1280         if (!bh) {
1281                 reiserfs_warning(s, "sh-2006: read_super_block: "
1282                                  "bread failed (dev %s, block %lu, size %lu)",
1283                                  reiserfs_bdevname(s), offset / s->s_blocksize,
1284                                  s->s_blocksize);
1285                 return 1;
1286         }
1287
1288         rs = (struct reiserfs_super_block *)bh->b_data;
1289         if (!is_any_reiserfs_magic_string(rs)) {
1290                 brelse(bh);
1291                 return 1;
1292         }
1293         //
1294         // ok, reiserfs signature (old or new) found in at the given offset
1295         //
1296         fs_blocksize = sb_blocksize(rs);
1297         brelse(bh);
1298         sb_set_blocksize(s, fs_blocksize);
1299
1300         bh = sb_bread(s, offset / s->s_blocksize);
1301         if (!bh) {
1302                 reiserfs_warning(s, "sh-2007: read_super_block: "
1303                                  "bread failed (dev %s, block %lu, size %lu)\n",
1304                                  reiserfs_bdevname(s), offset / s->s_blocksize,
1305                                  s->s_blocksize);
1306                 return 1;
1307         }
1308
1309         rs = (struct reiserfs_super_block *)bh->b_data;
1310         if (sb_blocksize(rs) != s->s_blocksize) {
1311                 reiserfs_warning(s, "sh-2011: read_super_block: "
1312                                  "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1313                                  reiserfs_bdevname(s),
1314                                  (unsigned long long)bh->b_blocknr,
1315                                  s->s_blocksize);
1316                 brelse(bh);
1317                 return 1;
1318         }
1319
1320         if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1321                 brelse(bh);
1322                 reiserfs_warning(s,
1323                                  "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1324                                  "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1325                                  "get newer reiserfsprogs package");
1326                 return 1;
1327         }
1328
1329         SB_BUFFER_WITH_SB(s) = bh;
1330         SB_DISK_SUPER_BLOCK(s) = rs;
1331
1332         if (is_reiserfs_jr(rs)) {
1333                 /* magic is of non-standard journal filesystem, look at s_version to
1334                    find which format is in use */
1335                 if (sb_version(rs) == REISERFS_VERSION_2)
1336                         reiserfs_warning(s,
1337                                          "read_super_block: found reiserfs format \"3.6\""
1338                                          " with non-standard journal");
1339                 else if (sb_version(rs) == REISERFS_VERSION_1)
1340                         reiserfs_warning(s,
1341                                          "read_super_block: found reiserfs format \"3.5\""
1342                                          " with non-standard journal");
1343                 else {
1344                         reiserfs_warning(s,
1345                                          "sh-2012: read_super_block: found unknown "
1346                                          "format \"%u\" of reiserfs with non-standard magic",
1347                                          sb_version(rs));
1348                         return 1;
1349                 }
1350         } else
1351                 /* s_version of standard format may contain incorrect information,
1352                    so we just look at the magic string */
1353                 reiserfs_info(s,
1354                               "found reiserfs format \"%s\" with standard journal\n",
1355                               is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1356
1357         s->s_op = &reiserfs_sops;
1358         s->s_export_op = &reiserfs_export_ops;
1359 #ifdef CONFIG_QUOTA
1360         s->s_qcop = &reiserfs_qctl_operations;
1361         s->dq_op = &reiserfs_quota_operations;
1362 #endif
1363
1364         /* new format is limited by the 32 bit wide i_blocks field, want to
1365          ** be one full block below that.
1366          */
1367         s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1368         return 0;
1369 }
1370
1371 /* after journal replay, reread all bitmap and super blocks */
1372 static int reread_meta_blocks(struct super_block *s)
1373 {
1374         ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
1375         wait_on_buffer(SB_BUFFER_WITH_SB(s));
1376         if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1377                 reiserfs_warning(s,
1378                                  "reread_meta_blocks, error reading the super");
1379                 return 1;
1380         }
1381
1382         return 0;
1383 }
1384
1385 /////////////////////////////////////////////////////
1386 // hash detection stuff
1387
1388 // if root directory is empty - we set default - Yura's - hash and
1389 // warn about it
1390 // FIXME: we look for only one name in a directory. If tea and yura
1391 // bith have the same value - we ask user to send report to the
1392 // mailing list
1393 static __u32 find_hash_out(struct super_block *s)
1394 {
1395         int retval;
1396         struct inode *inode;
1397         struct cpu_key key;
1398         INITIALIZE_PATH(path);
1399         struct reiserfs_dir_entry de;
1400         __u32 hash = DEFAULT_HASH;
1401
1402         inode = s->s_root->d_inode;
1403
1404         do {                    // Some serious "goto"-hater was there ;)
1405                 u32 teahash, r5hash, yurahash;
1406
1407                 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1408                 retval = search_by_entry_key(s, &key, &path, &de);
1409                 if (retval == IO_ERROR) {
1410                         pathrelse(&path);
1411                         return UNSET_HASH;
1412                 }
1413                 if (retval == NAME_NOT_FOUND)
1414                         de.de_entry_num--;
1415                 set_de_name_and_namelen(&de);
1416                 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
1417                         /* allow override in this case */
1418                         if (reiserfs_rupasov_hash(s)) {
1419                                 hash = YURA_HASH;
1420                         }
1421                         reiserfs_warning(s, "FS seems to be empty, autodetect "
1422                                          "is using the default hash");
1423                         break;
1424                 }
1425                 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1426                 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1427                 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1428                 if (((teahash == r5hash)
1429                      &&
1430                      (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1431                       == r5hash)) || ((teahash == yurahash)
1432                                       && (yurahash ==
1433                                           GET_HASH_VALUE(deh_offset
1434                                                          (&
1435                                                           (de.
1436                                                            de_deh[de.
1437                                                                   de_entry_num])))))
1438                     || ((r5hash == yurahash)
1439                         && (yurahash ==
1440                             GET_HASH_VALUE(deh_offset
1441                                            (&(de.de_deh[de.de_entry_num])))))) {
1442                         reiserfs_warning(s,
1443                                          "Unable to automatically detect hash function. "
1444                                          "Please mount with -o hash={tea,rupasov,r5}",
1445                                          reiserfs_bdevname(s));
1446                         hash = UNSET_HASH;
1447                         break;
1448                 }
1449                 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1450                     yurahash)
1451                         hash = YURA_HASH;
1452                 else if (GET_HASH_VALUE
1453                          (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1454                         hash = TEA_HASH;
1455                 else if (GET_HASH_VALUE
1456                          (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1457                         hash = R5_HASH;
1458                 else {
1459                         reiserfs_warning(s, "Unrecognised hash function");
1460                         hash = UNSET_HASH;
1461                 }
1462         } while (0);
1463
1464         pathrelse(&path);
1465         return hash;
1466 }
1467
1468 // finds out which hash names are sorted with
1469 static int what_hash(struct super_block *s)
1470 {
1471         __u32 code;
1472
1473         code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1474
1475         /* reiserfs_hash_detect() == true if any of the hash mount options
1476          ** were used.  We must check them to make sure the user isn't
1477          ** using a bad hash value
1478          */
1479         if (code == UNSET_HASH || reiserfs_hash_detect(s))
1480                 code = find_hash_out(s);
1481
1482         if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1483                 /* detection has found the hash, and we must check against the
1484                  ** mount options
1485                  */
1486                 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1487                         reiserfs_warning(s, "Error, %s hash detected, "
1488                                          "unable to force rupasov hash",
1489                                          reiserfs_hashname(code));
1490                         code = UNSET_HASH;
1491                 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1492                         reiserfs_warning(s, "Error, %s hash detected, "
1493                                          "unable to force tea hash",
1494                                          reiserfs_hashname(code));
1495                         code = UNSET_HASH;
1496                 } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1497                         reiserfs_warning(s, "Error, %s hash detected, "
1498                                          "unable to force r5 hash",
1499                                          reiserfs_hashname(code));
1500                         code = UNSET_HASH;
1501                 }
1502         } else {
1503                 /* find_hash_out was not called or could not determine the hash */
1504                 if (reiserfs_rupasov_hash(s)) {
1505                         code = YURA_HASH;
1506                 } else if (reiserfs_tea_hash(s)) {
1507                         code = TEA_HASH;
1508                 } else if (reiserfs_r5_hash(s)) {
1509                         code = R5_HASH;
1510                 }
1511         }
1512
1513         /* if we are mounted RW, and we have a new valid hash code, update
1514          ** the super
1515          */
1516         if (code != UNSET_HASH &&
1517             !(s->s_flags & MS_RDONLY) &&
1518             code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1519                 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1520         }
1521         return code;
1522 }
1523
1524 // return pointer to appropriate function
1525 static hashf_t hash_function(struct super_block *s)
1526 {
1527         switch (what_hash(s)) {
1528         case TEA_HASH:
1529                 reiserfs_info(s, "Using tea hash to sort names\n");
1530                 return keyed_hash;
1531         case YURA_HASH:
1532                 reiserfs_info(s, "Using rupasov hash to sort names\n");
1533                 return yura_hash;
1534         case R5_HASH:
1535                 reiserfs_info(s, "Using r5 hash to sort names\n");
1536                 return r5_hash;
1537         }
1538         return NULL;
1539 }
1540
1541 // this is used to set up correct value for old partitions
1542 static int function2code(hashf_t func)
1543 {
1544         if (func == keyed_hash)
1545                 return TEA_HASH;
1546         if (func == yura_hash)
1547                 return YURA_HASH;
1548         if (func == r5_hash)
1549                 return R5_HASH;
1550
1551         BUG();                  // should never happen
1552
1553         return 0;
1554 }
1555
1556 #define SWARN(silent, s, ...)                   \
1557         if (!(silent))                          \
1558                 reiserfs_warning (s, __VA_ARGS__)
1559
1560 static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1561 {
1562         struct inode *root_inode;
1563         struct reiserfs_transaction_handle th;
1564         int old_format = 0;
1565         unsigned long blocks;
1566         unsigned int commit_max_age = 0;
1567         int jinit_done = 0;
1568         struct reiserfs_iget_args args;
1569         struct reiserfs_super_block *rs;
1570         char *jdev_name;
1571         struct reiserfs_sb_info *sbi;
1572         int errval = -EINVAL;
1573
1574         save_mount_options(s, data);
1575
1576         sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1577         if (!sbi) {
1578                 errval = -ENOMEM;
1579                 goto error;
1580         }
1581         s->s_fs_info = sbi;
1582         /* Set default values for options: non-aggressive tails, RO on errors */
1583         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1584         REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1585         /* no preallocation minimum, be smart in
1586            reiserfs_file_write instead */
1587         REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1588         /* Preallocate by 16 blocks (17-1) at once */
1589         REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1590 #ifdef CONFIG_REISERFS_FS_XATTR
1591         /* Initialize the rwsem for xattr dir */
1592         init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
1593 #endif
1594         /* setup default block allocator options */
1595         reiserfs_init_alloc_options(s);
1596
1597         jdev_name = NULL;
1598         if (reiserfs_parse_options
1599             (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
1600              &commit_max_age) == 0) {
1601                 goto error;
1602         }
1603
1604         if (blocks) {
1605                 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1606                       "for remount only");
1607                 goto error;
1608         }
1609
1610         /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1611         if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1612                 old_format = 1;
1613         /* try new format (64-th 1k block), which can contain reiserfs super block */
1614         else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1615                 SWARN(silent, s,
1616                       "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",
1617                       reiserfs_bdevname(s));
1618                 goto error;
1619         }
1620
1621         rs = SB_DISK_SUPER_BLOCK(s);
1622         /* Let's do basic sanity check to verify that underlying device is not
1623            smaller than the filesystem. If the check fails then abort and scream,
1624            because bad stuff will happen otherwise. */
1625         if (s->s_bdev && s->s_bdev->bd_inode
1626             && i_size_read(s->s_bdev->bd_inode) <
1627             sb_block_count(rs) * sb_blocksize(rs)) {
1628                 SWARN(silent, s,
1629                       "Filesystem on %s cannot be mounted because it is bigger than the device",
1630                       reiserfs_bdevname(s));
1631                 SWARN(silent, s,
1632                       "You may need to run fsck or increase size of your LVM partition");
1633                 SWARN(silent, s,
1634                       "Or may be you forgot to reboot after fdisk when it told you to");
1635                 goto error;
1636         }
1637
1638         sbi->s_mount_state = SB_REISERFS_STATE(s);
1639         sbi->s_mount_state = REISERFS_VALID_FS;
1640
1641         if ((errval = reiserfs_init_bitmap_cache(s))) {
1642                 SWARN(silent, s,
1643                       "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1644                 goto error;
1645         }
1646         errval = -EINVAL;
1647 #ifdef CONFIG_REISERFS_CHECK
1648         SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");
1649         SWARN(silent, s, "- it is slow mode for debugging.");
1650 #endif
1651
1652         /* make data=ordered the default */
1653         if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1654             !reiserfs_data_writeback(s)) {
1655                 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1656         }
1657
1658         if (reiserfs_data_log(s)) {
1659                 reiserfs_info(s, "using journaled data mode\n");
1660         } else if (reiserfs_data_ordered(s)) {
1661                 reiserfs_info(s, "using ordered data mode\n");
1662         } else {
1663                 reiserfs_info(s, "using writeback data mode\n");
1664         }
1665         if (reiserfs_barrier_flush(s)) {
1666                 printk("reiserfs: using flush barriers\n");
1667         }
1668         // set_device_ro(s->s_dev, 1) ;
1669         if (journal_init(s, jdev_name, old_format, commit_max_age)) {
1670                 SWARN(silent, s,
1671                       "sh-2022: reiserfs_fill_super: unable to initialize journal space");
1672                 goto error;
1673         } else {
1674                 jinit_done = 1; /* once this is set, journal_release must be called
1675                                  ** if we error out of the mount
1676                                  */
1677         }
1678         if (reread_meta_blocks(s)) {
1679                 SWARN(silent, s,
1680                       "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");
1681                 goto error;
1682         }
1683
1684         if (replay_only(s))
1685                 goto error;
1686
1687         if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1688                 SWARN(silent, s,
1689                       "clm-7000: Detected readonly device, marking FS readonly");
1690                 s->s_flags |= MS_RDONLY;
1691         }
1692         args.objectid = REISERFS_ROOT_OBJECTID;
1693         args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1694         root_inode =
1695             iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1696                          reiserfs_init_locked_inode, (void *)(&args));
1697         if (!root_inode) {
1698                 SWARN(silent, s,
1699                       "jmacd-10: reiserfs_fill_super: get root inode failed");
1700                 goto error;
1701         }
1702
1703         if (root_inode->i_state & I_NEW) {
1704                 reiserfs_read_locked_inode(root_inode, &args);
1705                 unlock_new_inode(root_inode);
1706         }
1707
1708         s->s_root = d_alloc_root(root_inode);
1709         if (!s->s_root) {
1710                 iput(root_inode);
1711                 goto error;
1712         }
1713         // define and initialize hash function
1714         sbi->s_hash_function = hash_function(s);
1715         if (sbi->s_hash_function == NULL) {
1716                 dput(s->s_root);
1717                 s->s_root = NULL;
1718                 goto error;
1719         }
1720
1721         if (is_reiserfs_3_5(rs)
1722             || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
1723                 set_bit(REISERFS_3_5, &(sbi->s_properties));
1724         else if (old_format)
1725                 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
1726         else
1727                 set_bit(REISERFS_3_6, &(sbi->s_properties));
1728
1729         if (!(s->s_flags & MS_RDONLY)) {
1730
1731                 errval = journal_begin(&th, s, 1);
1732                 if (errval) {
1733                         dput(s->s_root);
1734                         s->s_root = NULL;
1735                         goto error;
1736                 }
1737                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1738
1739                 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1740                 set_sb_fs_state(rs, 0);
1741
1742                 /* Clear out s_bmap_nr if it would wrap. We can handle this
1743                  * case, but older revisions can't. This will cause the
1744                  * file system to fail mount on those older implementations,
1745                  * avoiding corruption. -jeffm */
1746                 if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
1747                     sb_bmap_nr(rs) != 0) {
1748                         reiserfs_warning(s, "super-2030: This file system "
1749                                         "claims to use %u bitmap blocks in "
1750                                         "its super block, but requires %u. "
1751                                         "Clearing to zero.", sb_bmap_nr(rs),
1752                                         reiserfs_bmap_count(s));
1753
1754                         set_sb_bmap_nr(rs, 0);
1755                 }
1756
1757                 if (old_format_only(s)) {
1758                         /* filesystem of format 3.5 either with standard or non-standard
1759                            journal */
1760                         if (convert_reiserfs(s)) {
1761                                 /* and -o conv is given */
1762                                 if (!silent)
1763                                         reiserfs_info(s,
1764                                                       "converting 3.5 filesystem to the 3.6 format");
1765
1766                                 if (is_reiserfs_3_5(rs))
1767                                         /* put magic string of 3.6 format. 2.2 will not be able to
1768                                            mount this filesystem anymore */
1769                                         memcpy(rs->s_v1.s_magic,
1770                                                reiserfs_3_6_magic_string,
1771                                                sizeof
1772                                                (reiserfs_3_6_magic_string));
1773
1774                                 set_sb_version(rs, REISERFS_VERSION_2);
1775                                 reiserfs_convert_objectid_map_v1(s);
1776                                 set_bit(REISERFS_3_6, &(sbi->s_properties));
1777                                 clear_bit(REISERFS_3_5, &(sbi->s_properties));
1778                         } else if (!silent) {
1779                                 reiserfs_info(s, "using 3.5.x disk format\n");
1780                         }
1781                 }
1782
1783                 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1784                 errval = journal_end(&th, s, 1);
1785                 if (errval) {
1786                         dput(s->s_root);
1787                         s->s_root = NULL;
1788                         goto error;
1789                 }
1790
1791                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1792                         dput(s->s_root);
1793                         s->s_root = NULL;
1794                         goto error;
1795                 }
1796
1797                 /* look for files which were to be removed in previous session */
1798                 finish_unfinished(s);
1799         } else {
1800                 if (old_format_only(s) && !silent) {
1801                         reiserfs_info(s, "using 3.5.x disk format\n");
1802                 }
1803
1804                 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1805                         dput(s->s_root);
1806                         s->s_root = NULL;
1807                         goto error;
1808                 }
1809         }
1810         // mark hash in super block: it could be unset. overwrite should be ok
1811         set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1812
1813         handle_attrs(s);
1814
1815         reiserfs_proc_info_init(s);
1816
1817         init_waitqueue_head(&(sbi->s_wait));
1818         spin_lock_init(&sbi->bitmap_lock);
1819
1820         return (0);
1821
1822       error:
1823         if (jinit_done) {       /* kill the commit thread, free journal ram */
1824                 journal_release_error(NULL, s);
1825         }
1826
1827         reiserfs_free_bitmap_cache(s);
1828         if (SB_BUFFER_WITH_SB(s))
1829                 brelse(SB_BUFFER_WITH_SB(s));
1830 #ifdef CONFIG_QUOTA
1831         {
1832                 int j;
1833                 for (j = 0; j < MAXQUOTAS; j++) {
1834                         kfree(sbi->s_qf_names[j]);
1835                         sbi->s_qf_names[j] = NULL;
1836                 }
1837         }
1838 #endif
1839         kfree(sbi);
1840
1841         s->s_fs_info = NULL;
1842         return errval;
1843 }
1844
1845 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1846 {
1847         struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
1848
1849         buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1850         buf->f_bfree = sb_free_blocks(rs);
1851         buf->f_bavail = buf->f_bfree;
1852         buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1853         buf->f_bsize = dentry->d_sb->s_blocksize;
1854         /* changed to accommodate gcc folks. */
1855         buf->f_type = REISERFS_SUPER_MAGIC;
1856         return 0;
1857 }
1858
1859 #ifdef CONFIG_QUOTA
1860 static int reiserfs_dquot_initialize(struct inode *inode, int type)
1861 {
1862         struct reiserfs_transaction_handle th;
1863         int ret, err;
1864
1865         /* We may create quota structure so we need to reserve enough blocks */
1866         reiserfs_write_lock(inode->i_sb);
1867         ret =
1868             journal_begin(&th, inode->i_sb,
1869                           2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1870         if (ret)
1871                 goto out;
1872         ret = dquot_initialize(inode, type);
1873         err =
1874             journal_end(&th, inode->i_sb,
1875                         2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1876         if (!ret && err)
1877                 ret = err;
1878       out:
1879         reiserfs_write_unlock(inode->i_sb);
1880         return ret;
1881 }
1882
1883 static int reiserfs_dquot_drop(struct inode *inode)
1884 {
1885         struct reiserfs_transaction_handle th;
1886         int ret, err;
1887
1888         /* We may delete quota structure so we need to reserve enough blocks */
1889         reiserfs_write_lock(inode->i_sb);
1890         ret =
1891             journal_begin(&th, inode->i_sb,
1892                           2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1893         if (ret)
1894                 goto out;
1895         ret = dquot_drop(inode);
1896         err =
1897             journal_end(&th, inode->i_sb,
1898                         2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1899         if (!ret && err)
1900                 ret = err;
1901       out:
1902         reiserfs_write_unlock(inode->i_sb);
1903         return ret;
1904 }
1905
1906 static int reiserfs_write_dquot(struct dquot *dquot)
1907 {
1908         struct reiserfs_transaction_handle th;
1909         int ret, err;
1910
1911         reiserfs_write_lock(dquot->dq_sb);
1912         ret =
1913             journal_begin(&th, dquot->dq_sb,
1914                           REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1915         if (ret)
1916                 goto out;
1917         ret = dquot_commit(dquot);
1918         err =
1919             journal_end(&th, dquot->dq_sb,
1920                         REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1921         if (!ret && err)
1922                 ret = err;
1923       out:
1924         reiserfs_write_unlock(dquot->dq_sb);
1925         return ret;
1926 }
1927
1928 static int reiserfs_acquire_dquot(struct dquot *dquot)
1929 {
1930         struct reiserfs_transaction_handle th;
1931         int ret, err;
1932
1933         reiserfs_write_lock(dquot->dq_sb);
1934         ret =
1935             journal_begin(&th, dquot->dq_sb,
1936                           REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1937         if (ret)
1938                 goto out;
1939         ret = dquot_acquire(dquot);
1940         err =
1941             journal_end(&th, dquot->dq_sb,
1942                         REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1943         if (!ret && err)
1944                 ret = err;
1945       out:
1946         reiserfs_write_unlock(dquot->dq_sb);
1947         return ret;
1948 }
1949
1950 static int reiserfs_release_dquot(struct dquot *dquot)
1951 {
1952         struct reiserfs_transaction_handle th;
1953         int ret, err;
1954
1955         reiserfs_write_lock(dquot->dq_sb);
1956         ret =
1957             journal_begin(&th, dquot->dq_sb,
1958                           REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1959         if (ret) {
1960                 /* Release dquot anyway to avoid endless cycle in dqput() */
1961                 dquot_release(dquot);
1962                 goto out;
1963         }
1964         ret = dquot_release(dquot);
1965         err =
1966             journal_end(&th, dquot->dq_sb,
1967                         REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1968         if (!ret && err)
1969                 ret = err;
1970       out:
1971         reiserfs_write_unlock(dquot->dq_sb);
1972         return ret;
1973 }
1974
1975 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
1976 {
1977         /* Are we journalling quotas? */
1978         if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
1979             REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
1980                 dquot_mark_dquot_dirty(dquot);
1981                 return reiserfs_write_dquot(dquot);
1982         } else
1983                 return dquot_mark_dquot_dirty(dquot);
1984 }
1985
1986 static int reiserfs_write_info(struct super_block *sb, int type)
1987 {
1988         struct reiserfs_transaction_handle th;
1989         int ret, err;
1990
1991         /* Data block + inode block */
1992         reiserfs_write_lock(sb);
1993         ret = journal_begin(&th, sb, 2);
1994         if (ret)
1995                 goto out;
1996         ret = dquot_commit_info(sb, type);
1997         err = journal_end(&th, sb, 2);
1998         if (!ret && err)
1999                 ret = err;
2000       out:
2001         reiserfs_write_unlock(sb);
2002         return ret;
2003 }
2004
2005 /*
2006  * Turn on quotas during mount time - we need to find the quota file and such...
2007  */
2008 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2009 {
2010         return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2011                                   REISERFS_SB(sb)->s_jquota_fmt, type);
2012 }
2013
2014 /*
2015  * Standard function to be called on quota_on
2016  */
2017 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2018                              char *path)
2019 {
2020         int err;
2021         struct nameidata nd;
2022
2023         if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2024                 return -EINVAL;
2025         err = path_lookup(path, LOOKUP_FOLLOW, &nd);
2026         if (err)
2027                 return err;
2028         /* Quotafile not on the same filesystem? */
2029         if (nd.path.mnt->mnt_sb != sb) {
2030                 path_put(&nd.path);
2031                 return -EXDEV;
2032         }
2033         /* We must not pack tails for quota files on reiserfs for quota IO to work */
2034         if (!REISERFS_I(nd.path.dentry->d_inode)->i_flags & i_nopack_mask) {
2035                 reiserfs_warning(sb,
2036                                  "reiserfs: Quota file must have tail packing disabled.");
2037                 path_put(&nd.path);
2038                 return -EINVAL;
2039         }
2040         /* Not journalling quota? No more tests needed... */
2041         if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] &&
2042             !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) {
2043                 path_put(&nd.path);
2044                 return vfs_quota_on(sb, type, format_id, path);
2045         }
2046         /* Quotafile not of fs root? */
2047         if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)
2048                 reiserfs_warning(sb,
2049                                  "reiserfs: Quota file not on filesystem root. "
2050                                  "Journalled quota will not work.");
2051         path_put(&nd.path);
2052         return vfs_quota_on(sb, type, format_id, path);
2053 }
2054
2055 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2056  * acquiring the locks... As quota files are never truncated and quota code
2057  * itself serializes the operations (and noone else should touch the files)
2058  * we don't have to be afraid of races */
2059 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2060                                    size_t len, loff_t off)
2061 {
2062         struct inode *inode = sb_dqopt(sb)->files[type];
2063         unsigned long blk = off >> sb->s_blocksize_bits;
2064         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2065         size_t toread;
2066         struct buffer_head tmp_bh, *bh;
2067         loff_t i_size = i_size_read(inode);
2068
2069         if (off > i_size)
2070                 return 0;
2071         if (off + len > i_size)
2072                 len = i_size - off;
2073         toread = len;
2074         while (toread > 0) {
2075                 tocopy =
2076                     sb->s_blocksize - offset <
2077                     toread ? sb->s_blocksize - offset : toread;
2078                 tmp_bh.b_state = 0;
2079                 /* Quota files are without tails so we can safely use this function */
2080                 reiserfs_write_lock(sb);
2081                 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2082                 reiserfs_write_unlock(sb);
2083                 if (err)
2084                         return err;
2085                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
2086                         memset(data, 0, tocopy);
2087                 else {
2088                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2089                         if (!bh)
2090                                 return -EIO;
2091                         memcpy(data, bh->b_data + offset, tocopy);
2092                         brelse(bh);
2093                 }
2094                 offset = 0;
2095                 toread -= tocopy;
2096                 data += tocopy;
2097                 blk++;
2098         }
2099         return len;
2100 }
2101
2102 /* Write to quotafile (we know the transaction is already started and has
2103  * enough credits) */
2104 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2105                                     const char *data, size_t len, loff_t off)
2106 {
2107         struct inode *inode = sb_dqopt(sb)->files[type];
2108         unsigned long blk = off >> sb->s_blocksize_bits;
2109         int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2110         int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2111         size_t towrite = len;
2112         struct buffer_head tmp_bh, *bh;
2113
2114         if (!current->journal_info) {
2115                 printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2116                         " cancelled because transaction is not started.\n",
2117                         (unsigned long long)off, (unsigned long long)len);
2118                 return -EIO;
2119         }
2120         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2121         while (towrite > 0) {
2122                 tocopy = sb->s_blocksize - offset < towrite ?
2123                     sb->s_blocksize - offset : towrite;
2124                 tmp_bh.b_state = 0;
2125                 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2126                 if (err)
2127                         goto out;
2128                 if (offset || tocopy != sb->s_blocksize)
2129                         bh = sb_bread(sb, tmp_bh.b_blocknr);
2130                 else
2131                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
2132                 if (!bh) {
2133                         err = -EIO;
2134                         goto out;
2135                 }
2136                 lock_buffer(bh);
2137                 memcpy(bh->b_data + offset, data, tocopy);
2138                 flush_dcache_page(bh->b_page);
2139                 set_buffer_uptodate(bh);
2140                 unlock_buffer(bh);
2141                 reiserfs_prepare_for_journal(sb, bh, 1);
2142                 journal_mark_dirty(current->journal_info, sb, bh);
2143                 if (!journal_quota)
2144                         reiserfs_add_ordered_list(inode, bh);
2145                 brelse(bh);
2146                 offset = 0;
2147                 towrite -= tocopy;
2148                 data += tocopy;
2149                 blk++;
2150         }
2151 out:
2152         if (len == towrite)
2153                 return err;
2154         if (inode->i_size < off + len - towrite)
2155                 i_size_write(inode, off + len - towrite);
2156         inode->i_version++;
2157         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2158         mark_inode_dirty(inode);
2159         mutex_unlock(&inode->i_mutex);
2160         return len - towrite;
2161 }
2162
2163 #endif
2164
2165 static int get_super_block(struct file_system_type *fs_type,
2166                            int flags, const char *dev_name,
2167                            void *data, struct vfsmount *mnt)
2168 {
2169         return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2170                            mnt);
2171 }
2172
2173 static int __init init_reiserfs_fs(void)
2174 {
2175         int ret;
2176
2177         if ((ret = init_inodecache())) {
2178                 return ret;
2179         }
2180
2181         if ((ret = reiserfs_xattr_register_handlers()))
2182                 goto failed_reiserfs_xattr_register_handlers;
2183
2184         reiserfs_proc_info_global_init();
2185         reiserfs_proc_register_global("version",
2186                                       reiserfs_global_version_in_proc);
2187
2188         ret = register_filesystem(&reiserfs_fs_type);
2189
2190         if (ret == 0) {
2191                 return 0;
2192         }
2193
2194         reiserfs_xattr_unregister_handlers();
2195
2196       failed_reiserfs_xattr_register_handlers:
2197         reiserfs_proc_unregister_global("version");
2198         reiserfs_proc_info_global_done();
2199         destroy_inodecache();
2200
2201         return ret;
2202 }
2203
2204 static void __exit exit_reiserfs_fs(void)
2205 {
2206         reiserfs_xattr_unregister_handlers();
2207         reiserfs_proc_unregister_global("version");
2208         reiserfs_proc_info_global_done();
2209         unregister_filesystem(&reiserfs_fs_type);
2210         destroy_inodecache();
2211 }
2212
2213 struct file_system_type reiserfs_fs_type = {
2214         .owner = THIS_MODULE,
2215         .name = "reiserfs",
2216         .get_sb = get_super_block,
2217         .kill_sb = reiserfs_kill_sb,
2218         .fs_flags = FS_REQUIRES_DEV,
2219 };
2220
2221 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2222 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2223 MODULE_LICENSE("GPL");
2224
2225 module_init(init_reiserfs_fs);
2226 module_exit(exit_reiserfs_fs);