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