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