2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
4 * Trivial changes by Alan Cox to add the LFS fixes
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.
14 #include <linux/module.h>
15 #include <linux/vmalloc.h>
16 #include <linux/time.h>
17 #include <asm/uaccess.h>
18 #include <linux/reiserfs_fs.h>
19 #include <linux/reiserfs_acl.h>
20 #include <linux/reiserfs_xattr.h>
21 #include <linux/init.h>
22 #include <linux/blkdev.h>
23 #include <linux/buffer_head.h>
24 #include <linux/exportfs.h>
25 #include <linux/quotaops.h>
26 #include <linux/vfs.h>
27 #include <linux/mnt_namespace.h>
28 #include <linux/mount.h>
29 #include <linux/namei.h>
31 struct file_system_type reiserfs_fs_type;
33 static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;
34 static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;
35 static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;
37 int is_reiserfs_3_5(struct reiserfs_super_block *rs)
39 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
40 strlen(reiserfs_3_5_magic_string));
43 int is_reiserfs_3_6(struct reiserfs_super_block *rs)
45 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
46 strlen(reiserfs_3_6_magic_string));
49 int is_reiserfs_jr(struct reiserfs_super_block *rs)
51 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
52 strlen(reiserfs_jr_magic_string));
55 static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
57 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
61 static int reiserfs_remount(struct super_block *s, int *flags, char *data);
62 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
64 static int reiserfs_sync_fs(struct super_block *s, int wait)
66 if (!(s->s_flags & MS_RDONLY)) {
67 struct reiserfs_transaction_handle th;
68 reiserfs_write_lock(s);
69 if (!journal_begin(&th, s, 1))
70 if (!journal_end_sync(&th, s, 1))
71 reiserfs_flush_old_commits(s);
72 s->s_dirt = 0; /* Even if it's not true.
73 * We'll loop forever in sync_supers otherwise */
74 reiserfs_write_unlock(s);
81 static void reiserfs_write_super(struct super_block *s)
83 reiserfs_sync_fs(s, 1);
86 static int reiserfs_freeze(struct super_block *s)
88 struct reiserfs_transaction_handle th;
89 reiserfs_write_lock(s);
90 if (!(s->s_flags & MS_RDONLY)) {
91 int err = journal_begin(&th, s, 1);
93 reiserfs_block_writes(&th);
95 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
97 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
98 reiserfs_block_writes(&th);
99 journal_end_sync(&th, s, 1);
103 reiserfs_write_unlock(s);
107 static int reiserfs_unfreeze(struct super_block *s)
109 reiserfs_allow_writes(s);
113 extern const struct in_core_key MAX_IN_CORE_KEY;
115 /* this is used to delete "save link" when there are no items of a
116 file it points to. It can either happen if unlink is completed but
117 "save unlink" removal, or if file has both unlink and truncate
118 pending and as unlink completes first (because key of "save link"
119 protecting unlink is bigger that a key lf "save link" which
120 protects truncate), so there left no items to make truncate
122 static int remove_save_link_only(struct super_block *s,
123 struct reiserfs_key *key, int oid_free)
125 struct reiserfs_transaction_handle th;
128 /* we are going to do one balancing */
129 err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);
133 reiserfs_delete_solid_item(&th, NULL, key);
135 /* removals are protected by direct items */
136 reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid));
138 return journal_end(&th, s, JOURNAL_PER_BALANCE_CNT);
142 static int reiserfs_quota_on_mount(struct super_block *, int);
145 /* look for uncompleted unlinks and truncates and complete them */
146 static int finish_unfinished(struct super_block *s)
148 INITIALIZE_PATH(path);
149 struct cpu_key max_cpu_key, obj_key;
150 struct reiserfs_key save_link_key, last_inode_key;
152 struct item_head *ih;
153 struct buffer_head *bh;
164 /* compose key to look for "save" links */
165 max_cpu_key.version = KEY_FORMAT_3_5;
166 max_cpu_key.on_disk_key.k_dir_id = ~0U;
167 max_cpu_key.on_disk_key.k_objectid = ~0U;
168 set_cpu_key_k_offset(&max_cpu_key, ~0U);
169 max_cpu_key.key_length = 3;
171 memset(&last_inode_key, 0, sizeof(last_inode_key));
174 /* Needed for iput() to work correctly and not trash data */
175 if (s->s_flags & MS_ACTIVE) {
179 s->s_flags |= MS_ACTIVE;
181 /* Turn on quotas so that they are updated correctly */
182 for (i = 0; i < MAXQUOTAS; i++) {
183 if (REISERFS_SB(s)->s_qf_names[i]) {
184 int ret = reiserfs_quota_on_mount(s, i);
187 "reiserfs: cannot turn on journaled quota: error %d",
194 REISERFS_SB(s)->s_is_unlinked_ok = 1;
196 retval = search_item(s, &max_cpu_key, &path);
197 if (retval != ITEM_NOT_FOUND) {
199 "vs-2140: finish_unfinished: search_by_key returned %d",
204 bh = get_last_bh(&path);
205 item_pos = get_item_pos(&path);
206 if (item_pos != B_NR_ITEMS(bh)) {
208 "vs-2060: finish_unfinished: wrong position found");
212 ih = B_N_PITEM_HEAD(bh, item_pos);
214 if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
215 /* there are no "save" links anymore */
218 save_link_key = ih->ih_key;
219 if (is_indirect_le_ih(ih))
224 /* reiserfs_iget needs k_dirid and k_objectid only */
225 item = B_I_PITEM(bh, ih);
226 obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item);
227 obj_key.on_disk_key.k_objectid =
228 le32_to_cpu(ih->ih_key.k_objectid);
229 obj_key.on_disk_key.k_offset = 0;
230 obj_key.on_disk_key.k_type = 0;
234 inode = reiserfs_iget(s, &obj_key);
236 /* the unlink almost completed, it just did not manage to remove
237 "save" link and release objectid */
239 "vs-2180: finish_unfinished: iget failed for %K",
241 retval = remove_save_link_only(s, &save_link_key, 1);
245 if (!truncate && inode->i_nlink) {
246 /* file is not unlinked */
248 "vs-2185: finish_unfinished: file %K is not unlinked",
250 retval = remove_save_link_only(s, &save_link_key, 0);
255 if (truncate && S_ISDIR(inode->i_mode)) {
256 /* We got a truncate request for a dir which is impossible.
257 The only imaginable way is to execute unfinished truncate request
258 then boot into old kernel, remove the file and create dir with
261 "green-2101: impossible truncate on a directory %k. Please report",
263 retval = remove_save_link_only(s, &save_link_key, 0);
270 REISERFS_I(inode)->i_flags |=
271 i_link_saved_truncate_mask;
272 /* not completed truncate found. New size was committed together
274 reiserfs_info(s, "Truncating %k to %Ld ..",
275 INODE_PKEY(inode), inode->i_size);
276 reiserfs_truncate_file(inode,
278 /*don't update modification time */
280 retval = remove_save_link(inode, truncate);
282 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
283 /* not completed unlink (rmdir) found */
284 reiserfs_info(s, "Removing %k..", INODE_PKEY(inode));
285 if (memcmp(&last_inode_key, INODE_PKEY(inode),
286 sizeof(last_inode_key))){
287 last_inode_key = *INODE_PKEY(inode);
288 /* removal gets completed in iput */
291 reiserfs_warning(s, "Dead loop in "
292 "finish_unfinished detected, "
293 "just remove save link\n");
294 retval = remove_save_link_only(s,
303 REISERFS_SB(s)->s_is_unlinked_ok = 0;
306 /* Turn quotas off */
307 for (i = 0; i < MAXQUOTAS; i++) {
308 if (sb_dqopt(s)->files[i])
309 vfs_quota_off(s, i, 0);
312 /* Restore the flag back */
313 s->s_flags &= ~MS_ACTIVE;
317 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
318 "Completed\n", done);
322 /* to protect file being unlinked from getting lost we "safe" link files
323 being unlinked. This link will be deleted in the same transaction with last
324 item of file. mounting the filesystem we scan all these links and remove
325 files which almost got lost */
326 void add_save_link(struct reiserfs_transaction_handle *th,
327 struct inode *inode, int truncate)
329 INITIALIZE_PATH(path);
335 BUG_ON(!th->t_trans_id);
337 /* file can only get one "save link" of each kind */
339 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask),
340 "saved link already exists for truncated inode %lx",
343 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask),
344 "saved link already exists for unlinked inode %lx",
347 /* setup key of "save" link */
348 key.version = KEY_FORMAT_3_5;
349 key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
350 key.on_disk_key.k_objectid = inode->i_ino;
352 /* unlink, rmdir, rename */
353 set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize);
354 set_cpu_key_k_type(&key, TYPE_DIRECT);
356 /* item head of "safe" link */
357 make_le_item_head(&ih, &key, key.version,
358 1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
359 4 /*length */ , 0xffff /*free space */ );
362 if (S_ISDIR(inode->i_mode))
363 reiserfs_warning(inode->i_sb,
364 "green-2102: Adding a truncate savelink for a directory %k! Please report",
366 set_cpu_key_k_offset(&key, 1);
367 set_cpu_key_k_type(&key, TYPE_INDIRECT);
369 /* item head of "safe" link */
370 make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT,
371 4 /*length */ , 0 /*free space */ );
375 /* look for its place in the tree */
376 retval = search_item(inode->i_sb, &key, &path);
377 if (retval != ITEM_NOT_FOUND) {
378 if (retval != -ENOSPC)
379 reiserfs_warning(inode->i_sb, "vs-2100: add_save_link:"
380 "search_by_key (%K) returned %d", &key,
386 /* body of "save" link */
387 link = INODE_PKEY(inode)->k_dir_id;
389 /* put "save" link inot tree, don't charge quota to anyone */
391 reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
393 if (retval != -ENOSPC)
394 reiserfs_warning(inode->i_sb,
395 "vs-2120: add_save_link: insert_item returned %d",
399 REISERFS_I(inode)->i_flags |=
400 i_link_saved_truncate_mask;
402 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
406 /* this opens transaction unlike add_save_link */
407 int remove_save_link(struct inode *inode, int truncate)
409 struct reiserfs_transaction_handle th;
410 struct reiserfs_key key;
413 /* we are going to do one balancing only */
414 err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
418 /* setup key of "save" link */
419 key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID);
420 key.k_objectid = INODE_PKEY(inode)->k_objectid;
422 /* unlink, rmdir, rename */
423 set_le_key_k_offset(KEY_FORMAT_3_5, &key,
424 1 + inode->i_sb->s_blocksize);
425 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);
428 set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1);
429 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
433 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||
435 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask)))
436 /* don't take quota bytes from anywhere */
437 reiserfs_delete_solid_item(&th, NULL, &key);
439 reiserfs_release_objectid(&th, inode->i_ino);
440 REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;
442 REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;
444 return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
447 static void reiserfs_kill_sb(struct super_block *s)
449 if (REISERFS_SB(s)) {
450 #ifdef CONFIG_REISERFS_FS_XATTR
451 if (REISERFS_SB(s)->xattr_root) {
452 d_invalidate(REISERFS_SB(s)->xattr_root);
453 dput(REISERFS_SB(s)->xattr_root);
454 REISERFS_SB(s)->xattr_root = NULL;
457 if (REISERFS_SB(s)->priv_root) {
458 d_invalidate(REISERFS_SB(s)->priv_root);
459 dput(REISERFS_SB(s)->priv_root);
460 REISERFS_SB(s)->priv_root = NULL;
467 static void reiserfs_put_super(struct super_block *s)
469 struct reiserfs_transaction_handle th;
472 /* change file system state to current state if it was mounted with read-write permissions */
473 if (!(s->s_flags & MS_RDONLY)) {
474 if (!journal_begin(&th, s, 10)) {
475 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
477 set_sb_umount_state(SB_DISK_SUPER_BLOCK(s),
478 REISERFS_SB(s)->s_mount_state);
479 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
483 /* note, journal_release checks for readonly mount, and can decide not
484 ** to do a journal_end
486 journal_release(&th, s);
488 reiserfs_free_bitmap_cache(s);
490 brelse(SB_BUFFER_WITH_SB(s));
494 if (REISERFS_SB(s)->reserved_blocks != 0) {
496 "green-2005: reiserfs_put_super: reserved blocks left %d",
497 REISERFS_SB(s)->reserved_blocks);
500 reiserfs_proc_info_done(s);
508 static struct kmem_cache *reiserfs_inode_cachep;
510 static struct inode *reiserfs_alloc_inode(struct super_block *sb)
512 struct reiserfs_inode_info *ei;
513 ei = (struct reiserfs_inode_info *)
514 kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
517 return &ei->vfs_inode;
520 static void reiserfs_destroy_inode(struct inode *inode)
522 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
525 static void init_once(void *foo)
527 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
529 INIT_LIST_HEAD(&ei->i_prealloc_list);
530 inode_init_once(&ei->vfs_inode);
531 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
532 ei->i_acl_access = NULL;
533 ei->i_acl_default = NULL;
537 static int init_inodecache(void)
539 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
541 reiserfs_inode_info),
542 0, (SLAB_RECLAIM_ACCOUNT|
545 if (reiserfs_inode_cachep == NULL)
550 static void destroy_inodecache(void)
552 kmem_cache_destroy(reiserfs_inode_cachep);
555 /* we don't mark inodes dirty, we just log them */
556 static void reiserfs_dirty_inode(struct inode *inode)
558 struct reiserfs_transaction_handle th;
561 if (inode->i_sb->s_flags & MS_RDONLY) {
562 reiserfs_warning(inode->i_sb,
563 "clm-6006: writing inode %lu on readonly FS",
567 reiserfs_write_lock(inode->i_sb);
569 /* this is really only used for atime updates, so they don't have
570 ** to be included in O_SYNC or fsync
572 err = journal_begin(&th, inode->i_sb, 1);
574 reiserfs_write_unlock(inode->i_sb);
577 reiserfs_update_sd(&th, inode);
578 journal_end(&th, inode->i_sb, 1);
579 reiserfs_write_unlock(inode->i_sb);
582 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
583 static void reiserfs_clear_inode(struct inode *inode)
585 struct posix_acl *acl;
587 acl = REISERFS_I(inode)->i_acl_access;
588 if (acl && !IS_ERR(acl))
589 posix_acl_release(acl);
590 REISERFS_I(inode)->i_acl_access = NULL;
592 acl = REISERFS_I(inode)->i_acl_default;
593 if (acl && !IS_ERR(acl))
594 posix_acl_release(acl);
595 REISERFS_I(inode)->i_acl_default = NULL;
598 #define reiserfs_clear_inode NULL
602 static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,
604 static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,
608 static const struct super_operations reiserfs_sops = {
609 .alloc_inode = reiserfs_alloc_inode,
610 .destroy_inode = reiserfs_destroy_inode,
611 .write_inode = reiserfs_write_inode,
612 .dirty_inode = reiserfs_dirty_inode,
613 .delete_inode = reiserfs_delete_inode,
614 .clear_inode = reiserfs_clear_inode,
615 .put_super = reiserfs_put_super,
616 .write_super = reiserfs_write_super,
617 .sync_fs = reiserfs_sync_fs,
618 .freeze_fs = reiserfs_freeze,
619 .unfreeze_fs = reiserfs_unfreeze,
620 .statfs = reiserfs_statfs,
621 .remount_fs = reiserfs_remount,
622 .show_options = generic_show_options,
624 .quota_read = reiserfs_quota_read,
625 .quota_write = reiserfs_quota_write,
630 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
632 static int reiserfs_dquot_initialize(struct inode *, int);
633 static int reiserfs_dquot_drop(struct inode *);
634 static int reiserfs_write_dquot(struct dquot *);
635 static int reiserfs_acquire_dquot(struct dquot *);
636 static int reiserfs_release_dquot(struct dquot *);
637 static int reiserfs_mark_dquot_dirty(struct dquot *);
638 static int reiserfs_write_info(struct super_block *, int);
639 static int reiserfs_quota_on(struct super_block *, int, int, char *, int);
641 static struct dquot_operations reiserfs_quota_operations = {
642 .initialize = reiserfs_dquot_initialize,
643 .drop = reiserfs_dquot_drop,
644 .alloc_space = dquot_alloc_space,
645 .alloc_inode = dquot_alloc_inode,
646 .free_space = dquot_free_space,
647 .free_inode = dquot_free_inode,
648 .transfer = dquot_transfer,
649 .write_dquot = reiserfs_write_dquot,
650 .acquire_dquot = reiserfs_acquire_dquot,
651 .release_dquot = reiserfs_release_dquot,
652 .mark_dirty = reiserfs_mark_dquot_dirty,
653 .write_info = reiserfs_write_info,
654 .alloc_dquot = dquot_alloc,
655 .destroy_dquot = dquot_destroy,
658 static struct quotactl_ops reiserfs_qctl_operations = {
659 .quota_on = reiserfs_quota_on,
660 .quota_off = vfs_quota_off,
661 .quota_sync = vfs_quota_sync,
662 .get_info = vfs_get_dqinfo,
663 .set_info = vfs_set_dqinfo,
664 .get_dqblk = vfs_get_dqblk,
665 .set_dqblk = vfs_set_dqblk,
669 static const struct export_operations reiserfs_export_ops = {
670 .encode_fh = reiserfs_encode_fh,
671 .fh_to_dentry = reiserfs_fh_to_dentry,
672 .fh_to_parent = reiserfs_fh_to_parent,
673 .get_parent = reiserfs_get_parent,
676 /* this struct is used in reiserfs_getopt () for containing the value for those
677 mount options that have values rather than being toggles. */
680 int setmask; /* bitmask which is to set on mount_options bitmask when this
681 value is found, 0 is no bits are to be changed. */
682 int clrmask; /* bitmask which is to clear on mount_options bitmask when this
683 value is found, 0 is no bits are to be changed. This is
684 applied BEFORE setmask */
687 /* Set this bit in arg_required to allow empty arguments */
688 #define REISERFS_OPT_ALLOWEMPTY 31
690 /* this struct is used in reiserfs_getopt() for describing the set of reiserfs
694 int arg_required; /* 0 if argument is not required, not 0 otherwise */
695 const arg_desc_t *values; /* list of values accepted by an option */
696 int setmask; /* bitmask which is to set on mount_options bitmask when this
697 value is found, 0 is no bits are to be changed. */
698 int clrmask; /* bitmask which is to clear on mount_options bitmask when this
699 value is found, 0 is no bits are to be changed. This is
700 applied BEFORE setmask */
703 /* possible values for -o data= */
704 static const arg_desc_t logging_mode[] = {
705 {"ordered", 1 << REISERFS_DATA_ORDERED,
706 (1 << REISERFS_DATA_LOG | 1 << REISERFS_DATA_WRITEBACK)},
707 {"journal", 1 << REISERFS_DATA_LOG,
708 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},
709 {"writeback", 1 << REISERFS_DATA_WRITEBACK,
710 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},
714 /* possible values for -o barrier= */
715 static const arg_desc_t barrier_mode[] = {
716 {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
717 {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
721 /* possible values for "-o block-allocator=" and bits which are to be set in
722 s_mount_opt of reiserfs specific part of in-core super block */
723 static const arg_desc_t balloc[] = {
724 {"noborder", 1 << REISERFS_NO_BORDER, 0},
725 {"border", 0, 1 << REISERFS_NO_BORDER},
726 {"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION, 0},
727 {"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION, 0},
728 {"test4", 1 << REISERFS_TEST4, 0},
729 {"notest4", 0, 1 << REISERFS_TEST4},
733 static const arg_desc_t tails[] = {
734 {"on", 1 << REISERFS_LARGETAIL, 1 << REISERFS_SMALLTAIL},
735 {"off", 0, (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
736 {"small", 1 << REISERFS_SMALLTAIL, 1 << REISERFS_LARGETAIL},
740 static const arg_desc_t error_actions[] = {
741 {"panic", 1 << REISERFS_ERROR_PANIC,
742 (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)},
743 {"ro-remount", 1 << REISERFS_ERROR_RO,
744 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)},
745 #ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
746 {"continue", 1 << REISERFS_ERROR_CONTINUE,
747 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
752 /* proceed only one option from a list *cur - string containing of mount options
753 opts - array of options which are accepted
754 opt_arg - if option is found and requires an argument and if it is specifed
755 in the input - pointer to the argument is stored here
756 bit_flags - if option requires to set a certain bit - it is set here
757 return -1 if unknown option is found, opt->arg_required otherwise */
758 static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
759 char **opt_arg, unsigned long *bit_flags)
768 const opt_desc_t *opt;
769 const arg_desc_t *arg;
773 /* assume argument cannot contain commas */
774 *cur = strchr(p, ',');
780 if (!strncmp(p, "alloc=", 6)) {
781 /* Ugly special case, probably we should redo options parser so that
782 it can understand several arguments for some options, also so that
783 it can fill several bitfields with option values. */
784 if (reiserfs_parse_alloc_options(s, p + 6)) {
791 /* for every option in the list */
792 for (opt = opts; opt->option_name; opt++) {
793 if (!strncmp(p, opt->option_name, strlen(opt->option_name))) {
796 (1 << REISERFS_UNSUPPORTED_OPT))
797 reiserfs_warning(s, "%s not supported.",
800 *bit_flags &= ~opt->clrmask;
802 (1 << REISERFS_UNSUPPORTED_OPT))
803 reiserfs_warning(s, "%s not supported.",
806 *bit_flags |= opt->setmask;
811 if (!opt->option_name) {
812 reiserfs_warning(s, "unknown mount option \"%s\"", p);
816 p += strlen(opt->option_name);
819 if (!opt->arg_required) {
821 "the option \"%s\" does not require an argument",
828 if (opt->arg_required) {
830 "the option \"%s\" requires an argument",
836 reiserfs_warning(s, "head of option \"%s\" is only correct",
841 /* move to the argument, or to next option if argument is not required */
844 if (opt->arg_required
845 && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
847 /* this catches "option=," if not allowed */
848 reiserfs_warning(s, "empty argument for \"%s\"",
854 /* *=NULLopt_arg contains pointer to argument */
856 return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);
859 /* values possible for this option are listed in opt->values */
860 for (arg = opt->values; arg->value; arg++) {
861 if (!strcmp(p, arg->value)) {
863 *bit_flags &= ~arg->clrmask;
864 *bit_flags |= arg->setmask;
866 return opt->arg_required;
870 reiserfs_warning(s, "bad value \"%s\" for option \"%s\"", p,
875 /* returns 0 if something is wrong in option string, 1 - otherwise */
876 static int reiserfs_parse_options(struct super_block *s, char *options, /* string given via mount's -o */
877 unsigned long *mount_options,
878 /* after the parsing phase, contains the
879 collection of bitflags defining what
880 mount options were selected. */
881 unsigned long *blocks, /* strtol-ed from NNN of resize=NNN */
883 unsigned int *commit_max_age,
890 opt_desc_t opts[] = {
891 /* Compatibility stuff, so that -o notail for old setups still work */
892 {"tails",.arg_required = 't',.values = tails},
894 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
895 {"conv",.setmask = 1 << REISERFS_CONVERT},
896 {"attrs",.setmask = 1 << REISERFS_ATTRS},
897 {"noattrs",.clrmask = 1 << REISERFS_ATTRS},
898 #ifdef CONFIG_REISERFS_FS_XATTR
899 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
900 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
902 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
903 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
905 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
906 {"acl",.setmask = 1 << REISERFS_POSIXACL},
907 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
909 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
910 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
912 {.option_name = "nolog"},
913 {"replayonly",.setmask = 1 << REPLAYONLY},
914 {"block-allocator",.arg_required = 'a',.values = balloc},
915 {"data",.arg_required = 'd',.values = logging_mode},
916 {"barrier",.arg_required = 'b',.values = barrier_mode},
917 {"resize",.arg_required = 'r',.values = NULL},
918 {"jdev",.arg_required = 'j',.values = NULL},
919 {"nolargeio",.arg_required = 'w',.values = NULL},
920 {"commit",.arg_required = 'c',.values = NULL},
921 {"usrquota",.setmask = 1 << REISERFS_QUOTA},
922 {"grpquota",.setmask = 1 << REISERFS_QUOTA},
923 {"noquota",.clrmask = 1 << REISERFS_QUOTA},
924 {"errors",.arg_required = 'e',.values = error_actions},
925 {"usrjquota",.arg_required =
926 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
927 {"grpjquota",.arg_required =
928 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
929 {"jqfmt",.arg_required = 'f',.values = NULL},
930 {.option_name = NULL}
934 if (!options || !*options)
935 /* use default configuration: create tails, journaling on, no
936 conversion to newest format */
939 for (pos = options; pos;) {
940 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
942 /* wrong option is given */
949 /* "resize=NNN" or "resize=auto" */
951 if (!strcmp(arg, "auto")) {
952 /* From JFS code, to auto-get the size. */
954 s->s_bdev->bd_inode->i_size >> s->
957 *blocks = simple_strtoul(arg, &p, 0);
959 /* NNN does not look like a number */
961 "reiserfs_parse_options: bad value %s",
970 unsigned long val = simple_strtoul(arg, &p, 0);
971 /* commit=NNN (time in seconds) */
972 if (*p != '\0' || val >= (unsigned int)-1) {
974 "reiserfs_parse_options: bad value %s",
978 *commit_max_age = (unsigned int)val;
982 reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported");
987 if (arg && *arg && jdev_name) {
988 if (*jdev_name) { //Hm, already assigned?
990 "reiserfs_parse_options: journal device was already specified to be %s",
998 if (c == 'u' || c == 'g') {
999 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
1001 if (sb_any_quota_loaded(s) &&
1002 (!*arg != !REISERFS_SB(s)->s_qf_names[qtype])) {
1004 "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
1007 if (*arg) { /* Some filename specified? */
1008 if (REISERFS_SB(s)->s_qf_names[qtype]
1009 && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1012 "reiserfs_parse_options: %s quota file already specified.",
1016 if (strchr(arg, '/')) {
1018 "reiserfs_parse_options: quotafile must be on filesystem root.");
1022 kmalloc(strlen(arg) + 1, GFP_KERNEL);
1023 if (!qf_names[qtype]) {
1025 "reiserfs_parse_options: not enough memory for storing quotafile name.");
1028 strcpy(qf_names[qtype], arg);
1029 *mount_options |= 1 << REISERFS_QUOTA;
1031 if (qf_names[qtype] !=
1032 REISERFS_SB(s)->s_qf_names[qtype])
1033 kfree(qf_names[qtype]);
1034 qf_names[qtype] = NULL;
1038 if (!strcmp(arg, "vfsold"))
1039 *qfmt = QFMT_VFS_OLD;
1040 else if (!strcmp(arg, "vfsv0"))
1041 *qfmt = QFMT_VFS_V0;
1044 "reiserfs_parse_options: unknown quota format specified.");
1047 if (sb_any_quota_loaded(s) &&
1048 *qfmt != REISERFS_SB(s)->s_jquota_fmt) {
1050 "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
1055 if (c == 'u' || c == 'g' || c == 'f') {
1057 "reiserfs_parse_options: journaled quota options not supported.");
1064 if (!REISERFS_SB(s)->s_jquota_fmt && !*qfmt
1065 && (qf_names[USRQUOTA] || qf_names[GRPQUOTA])) {
1067 "reiserfs_parse_options: journaled quota format not specified.");
1070 /* This checking is not precise wrt the quota type but for our purposes it is sufficient */
1071 if (!(*mount_options & (1 << REISERFS_QUOTA))
1072 && sb_any_quota_loaded(s)) {
1074 "reiserfs_parse_options: quota options must be present when quota is turned on.");
1082 static void switch_data_mode(struct super_block *s, unsigned long mode)
1084 REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1085 (1 << REISERFS_DATA_ORDERED) |
1086 (1 << REISERFS_DATA_WRITEBACK));
1087 REISERFS_SB(s)->s_mount_opt |= (1 << mode);
1090 static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1092 if (mount_options & (1 << REISERFS_DATA_LOG)) {
1093 if (!reiserfs_data_log(s)) {
1094 switch_data_mode(s, REISERFS_DATA_LOG);
1095 reiserfs_info(s, "switching to journaled data mode\n");
1097 } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1098 if (!reiserfs_data_ordered(s)) {
1099 switch_data_mode(s, REISERFS_DATA_ORDERED);
1100 reiserfs_info(s, "switching to ordered data mode\n");
1102 } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1103 if (!reiserfs_data_writeback(s)) {
1104 switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1105 reiserfs_info(s, "switching to writeback data mode\n");
1110 static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1112 int flush = (1 << REISERFS_BARRIER_FLUSH);
1113 int none = (1 << REISERFS_BARRIER_NONE);
1114 int all_barrier = flush | none;
1116 if (bits & all_barrier) {
1117 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1119 REISERFS_SB(s)->s_mount_opt |= flush;
1120 printk("reiserfs: enabling write barrier flush mode\n");
1121 } else if (bits & none) {
1122 REISERFS_SB(s)->s_mount_opt |= none;
1123 printk("reiserfs: write barriers turned off\n");
1128 static void handle_attrs(struct super_block *s)
1130 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1132 if (reiserfs_attrs(s)) {
1133 if (old_format_only(s)) {
1135 "reiserfs: cannot support attributes on 3.5.x disk format");
1136 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1139 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1141 "reiserfs: cannot support attributes until flag is set in super-block");
1142 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1148 static void handle_quota_files(struct super_block *s, char **qf_names,
1153 for (i = 0; i < MAXQUOTAS; i++) {
1154 if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1155 kfree(REISERFS_SB(s)->s_qf_names[i]);
1156 REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
1158 REISERFS_SB(s)->s_jquota_fmt = *qfmt;
1162 static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
1164 struct reiserfs_super_block *rs;
1165 struct reiserfs_transaction_handle th;
1166 unsigned long blocks;
1167 unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1168 unsigned long safe_mask = 0;
1169 unsigned int commit_max_age = (unsigned int)-1;
1170 struct reiserfs_journal *journal = SB_JOURNAL(s);
1171 char *new_opts = kstrdup(arg, GFP_KERNEL);
1173 char *qf_names[MAXQUOTAS];
1174 unsigned int qfmt = 0;
1178 memcpy(qf_names, REISERFS_SB(s)->s_qf_names, sizeof(qf_names));
1181 rs = SB_DISK_SUPER_BLOCK(s);
1183 if (!reiserfs_parse_options
1184 (s, arg, &mount_options, &blocks, NULL, &commit_max_age,
1187 for (i = 0; i < MAXQUOTAS; i++)
1188 if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1195 handle_quota_files(s, qf_names, &qfmt);
1200 /* Add options that are safe here */
1201 safe_mask |= 1 << REISERFS_SMALLTAIL;
1202 safe_mask |= 1 << REISERFS_LARGETAIL;
1203 safe_mask |= 1 << REISERFS_NO_BORDER;
1204 safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1205 safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1206 safe_mask |= 1 << REISERFS_TEST4;
1207 safe_mask |= 1 << REISERFS_ATTRS;
1208 safe_mask |= 1 << REISERFS_XATTRS_USER;
1209 safe_mask |= 1 << REISERFS_POSIXACL;
1210 safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1211 safe_mask |= 1 << REISERFS_BARRIER_NONE;
1212 safe_mask |= 1 << REISERFS_ERROR_RO;
1213 safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1214 safe_mask |= 1 << REISERFS_ERROR_PANIC;
1215 safe_mask |= 1 << REISERFS_QUOTA;
1217 /* Update the bitmask, taking care to keep
1218 * the bits we're not allowed to change here */
1219 REISERFS_SB(s)->s_mount_opt =
1221 s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
1223 if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1224 journal->j_max_commit_age = commit_max_age;
1225 journal->j_max_trans_age = commit_max_age;
1226 } else if (commit_max_age == 0) {
1227 /* 0 means restore defaults. */
1228 journal->j_max_commit_age = journal->j_default_max_commit_age;
1229 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1233 err = reiserfs_resize(s, blocks);
1238 if (*mount_flags & MS_RDONLY) {
1239 reiserfs_xattr_init(s, *mount_flags);
1240 /* remount read-only */
1241 if (s->s_flags & MS_RDONLY)
1242 /* it is read-only already */
1244 /* try to remount file system with read-only permissions */
1245 if (sb_umount_state(rs) == REISERFS_VALID_FS
1246 || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
1250 err = journal_begin(&th, s, 10);
1254 /* Mounting a rw partition read-only. */
1255 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1256 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1257 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1259 /* remount read-write */
1260 if (!(s->s_flags & MS_RDONLY)) {
1261 reiserfs_xattr_init(s, *mount_flags);
1262 goto out_ok; /* We are read-write already */
1265 if (reiserfs_is_journal_aborted(journal)) {
1266 err = journal->j_errno;
1270 handle_data_mode(s, mount_options);
1271 handle_barrier_mode(s, mount_options);
1272 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1273 s->s_flags &= ~MS_RDONLY; /* now it is safe to call journal_begin */
1274 err = journal_begin(&th, s, 10);
1278 /* Mount a partition which is read-only, read-write */
1279 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1280 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1281 s->s_flags &= ~MS_RDONLY;
1282 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1283 if (!old_format_only(s))
1284 set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1285 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1286 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1287 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1289 /* this will force a full flush of all journal lists */
1290 SB_JOURNAL(s)->j_must_wait = 1;
1291 err = journal_end(&th, s, 10);
1296 if (!(*mount_flags & MS_RDONLY)) {
1297 finish_unfinished(s);
1298 reiserfs_xattr_init(s, *mount_flags);
1302 kfree(s->s_options);
1303 s->s_options = new_opts;
1311 static int read_super_block(struct super_block *s, int offset)
1313 struct buffer_head *bh;
1314 struct reiserfs_super_block *rs;
1317 bh = sb_bread(s, offset / s->s_blocksize);
1319 reiserfs_warning(s, "sh-2006: read_super_block: "
1320 "bread failed (dev %s, block %lu, size %lu)",
1321 reiserfs_bdevname(s), offset / s->s_blocksize,
1326 rs = (struct reiserfs_super_block *)bh->b_data;
1327 if (!is_any_reiserfs_magic_string(rs)) {
1332 // ok, reiserfs signature (old or new) found in at the given offset
1334 fs_blocksize = sb_blocksize(rs);
1336 sb_set_blocksize(s, fs_blocksize);
1338 bh = sb_bread(s, offset / s->s_blocksize);
1340 reiserfs_warning(s, "sh-2007: read_super_block: "
1341 "bread failed (dev %s, block %lu, size %lu)\n",
1342 reiserfs_bdevname(s), offset / s->s_blocksize,
1347 rs = (struct reiserfs_super_block *)bh->b_data;
1348 if (sb_blocksize(rs) != s->s_blocksize) {
1349 reiserfs_warning(s, "sh-2011: read_super_block: "
1350 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1351 reiserfs_bdevname(s),
1352 (unsigned long long)bh->b_blocknr,
1358 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1361 "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1362 "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1363 "get newer reiserfsprogs package");
1367 SB_BUFFER_WITH_SB(s) = bh;
1368 SB_DISK_SUPER_BLOCK(s) = rs;
1370 if (is_reiserfs_jr(rs)) {
1371 /* magic is of non-standard journal filesystem, look at s_version to
1372 find which format is in use */
1373 if (sb_version(rs) == REISERFS_VERSION_2)
1375 "read_super_block: found reiserfs format \"3.6\""
1376 " with non-standard journal");
1377 else if (sb_version(rs) == REISERFS_VERSION_1)
1379 "read_super_block: found reiserfs format \"3.5\""
1380 " with non-standard journal");
1383 "sh-2012: read_super_block: found unknown "
1384 "format \"%u\" of reiserfs with non-standard magic",
1389 /* s_version of standard format may contain incorrect information,
1390 so we just look at the magic string */
1392 "found reiserfs format \"%s\" with standard journal\n",
1393 is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1395 s->s_op = &reiserfs_sops;
1396 s->s_export_op = &reiserfs_export_ops;
1398 s->s_qcop = &reiserfs_qctl_operations;
1399 s->dq_op = &reiserfs_quota_operations;
1402 /* new format is limited by the 32 bit wide i_blocks field, want to
1403 ** be one full block below that.
1405 s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1409 /* after journal replay, reread all bitmap and super blocks */
1410 static int reread_meta_blocks(struct super_block *s)
1412 ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
1413 wait_on_buffer(SB_BUFFER_WITH_SB(s));
1414 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1416 "reread_meta_blocks, error reading the super");
1423 /////////////////////////////////////////////////////
1424 // hash detection stuff
1426 // if root directory is empty - we set default - Yura's - hash and
1428 // FIXME: we look for only one name in a directory. If tea and yura
1429 // bith have the same value - we ask user to send report to the
1431 static __u32 find_hash_out(struct super_block *s)
1434 struct inode *inode;
1436 INITIALIZE_PATH(path);
1437 struct reiserfs_dir_entry de;
1438 __u32 hash = DEFAULT_HASH;
1440 inode = s->s_root->d_inode;
1442 do { // Some serious "goto"-hater was there ;)
1443 u32 teahash, r5hash, yurahash;
1445 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1446 retval = search_by_entry_key(s, &key, &path, &de);
1447 if (retval == IO_ERROR) {
1451 if (retval == NAME_NOT_FOUND)
1453 set_de_name_and_namelen(&de);
1454 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
1455 /* allow override in this case */
1456 if (reiserfs_rupasov_hash(s)) {
1459 reiserfs_warning(s, "FS seems to be empty, autodetect "
1460 "is using the default hash");
1463 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1464 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1465 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1466 if (((teahash == r5hash)
1468 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1469 == r5hash)) || ((teahash == yurahash)
1471 GET_HASH_VALUE(deh_offset
1476 || ((r5hash == yurahash)
1478 GET_HASH_VALUE(deh_offset
1479 (&(de.de_deh[de.de_entry_num])))))) {
1481 "Unable to automatically detect hash function. "
1482 "Please mount with -o hash={tea,rupasov,r5}",
1483 reiserfs_bdevname(s));
1487 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1490 else if (GET_HASH_VALUE
1491 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1493 else if (GET_HASH_VALUE
1494 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1497 reiserfs_warning(s, "Unrecognised hash function");
1506 // finds out which hash names are sorted with
1507 static int what_hash(struct super_block *s)
1511 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1513 /* reiserfs_hash_detect() == true if any of the hash mount options
1514 ** were used. We must check them to make sure the user isn't
1515 ** using a bad hash value
1517 if (code == UNSET_HASH || reiserfs_hash_detect(s))
1518 code = find_hash_out(s);
1520 if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1521 /* detection has found the hash, and we must check against the
1524 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1525 reiserfs_warning(s, "Error, %s hash detected, "
1526 "unable to force rupasov hash",
1527 reiserfs_hashname(code));
1529 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1530 reiserfs_warning(s, "Error, %s hash detected, "
1531 "unable to force tea hash",
1532 reiserfs_hashname(code));
1534 } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1535 reiserfs_warning(s, "Error, %s hash detected, "
1536 "unable to force r5 hash",
1537 reiserfs_hashname(code));
1541 /* find_hash_out was not called or could not determine the hash */
1542 if (reiserfs_rupasov_hash(s)) {
1544 } else if (reiserfs_tea_hash(s)) {
1546 } else if (reiserfs_r5_hash(s)) {
1551 /* if we are mounted RW, and we have a new valid hash code, update
1554 if (code != UNSET_HASH &&
1555 !(s->s_flags & MS_RDONLY) &&
1556 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1557 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1562 // return pointer to appropriate function
1563 static hashf_t hash_function(struct super_block *s)
1565 switch (what_hash(s)) {
1567 reiserfs_info(s, "Using tea hash to sort names\n");
1570 reiserfs_info(s, "Using rupasov hash to sort names\n");
1573 reiserfs_info(s, "Using r5 hash to sort names\n");
1579 // this is used to set up correct value for old partitions
1580 static int function2code(hashf_t func)
1582 if (func == keyed_hash)
1584 if (func == yura_hash)
1586 if (func == r5_hash)
1589 BUG(); // should never happen
1594 #define SWARN(silent, s, ...) \
1596 reiserfs_warning (s, __VA_ARGS__)
1598 static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1600 struct inode *root_inode;
1601 struct reiserfs_transaction_handle th;
1603 unsigned long blocks;
1604 unsigned int commit_max_age = 0;
1606 struct reiserfs_iget_args args;
1607 struct reiserfs_super_block *rs;
1609 struct reiserfs_sb_info *sbi;
1610 int errval = -EINVAL;
1611 char *qf_names[MAXQUOTAS] = {};
1612 unsigned int qfmt = 0;
1614 save_mount_options(s, data);
1616 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1622 /* Set default values for options: non-aggressive tails, RO on errors */
1623 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1624 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1625 /* no preallocation minimum, be smart in
1626 reiserfs_file_write instead */
1627 REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1628 /* Preallocate by 16 blocks (17-1) at once */
1629 REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1630 #ifdef CONFIG_REISERFS_FS_XATTR
1631 /* Initialize the rwsem for xattr dir */
1632 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
1634 /* setup default block allocator options */
1635 reiserfs_init_alloc_options(s);
1638 if (reiserfs_parse_options
1639 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
1640 &commit_max_age, qf_names, &qfmt) == 0) {
1644 handle_quota_files(s, qf_names, &qfmt);
1648 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1649 "for remount only");
1653 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1654 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1656 /* try new format (64-th 1k block), which can contain reiserfs super block */
1657 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1659 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",
1660 reiserfs_bdevname(s));
1664 rs = SB_DISK_SUPER_BLOCK(s);
1665 /* Let's do basic sanity check to verify that underlying device is not
1666 smaller than the filesystem. If the check fails then abort and scream,
1667 because bad stuff will happen otherwise. */
1668 if (s->s_bdev && s->s_bdev->bd_inode
1669 && i_size_read(s->s_bdev->bd_inode) <
1670 sb_block_count(rs) * sb_blocksize(rs)) {
1672 "Filesystem on %s cannot be mounted because it is bigger than the device",
1673 reiserfs_bdevname(s));
1675 "You may need to run fsck or increase size of your LVM partition");
1677 "Or may be you forgot to reboot after fdisk when it told you to");
1681 sbi->s_mount_state = SB_REISERFS_STATE(s);
1682 sbi->s_mount_state = REISERFS_VALID_FS;
1684 if ((errval = reiserfs_init_bitmap_cache(s))) {
1686 "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1690 #ifdef CONFIG_REISERFS_CHECK
1691 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");
1692 SWARN(silent, s, "- it is slow mode for debugging.");
1695 /* make data=ordered the default */
1696 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1697 !reiserfs_data_writeback(s)) {
1698 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1701 if (reiserfs_data_log(s)) {
1702 reiserfs_info(s, "using journaled data mode\n");
1703 } else if (reiserfs_data_ordered(s)) {
1704 reiserfs_info(s, "using ordered data mode\n");
1706 reiserfs_info(s, "using writeback data mode\n");
1708 if (reiserfs_barrier_flush(s)) {
1709 printk("reiserfs: using flush barriers\n");
1711 // set_device_ro(s->s_dev, 1) ;
1712 if (journal_init(s, jdev_name, old_format, commit_max_age)) {
1714 "sh-2022: reiserfs_fill_super: unable to initialize journal space");
1717 jinit_done = 1; /* once this is set, journal_release must be called
1718 ** if we error out of the mount
1721 if (reread_meta_blocks(s)) {
1723 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");
1730 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1732 "clm-7000: Detected readonly device, marking FS readonly");
1733 s->s_flags |= MS_RDONLY;
1735 args.objectid = REISERFS_ROOT_OBJECTID;
1736 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1738 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1739 reiserfs_init_locked_inode, (void *)(&args));
1742 "jmacd-10: reiserfs_fill_super: get root inode failed");
1746 if (root_inode->i_state & I_NEW) {
1747 reiserfs_read_locked_inode(root_inode, &args);
1748 unlock_new_inode(root_inode);
1751 s->s_root = d_alloc_root(root_inode);
1756 // define and initialize hash function
1757 sbi->s_hash_function = hash_function(s);
1758 if (sbi->s_hash_function == NULL) {
1764 if (is_reiserfs_3_5(rs)
1765 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
1766 set_bit(REISERFS_3_5, &(sbi->s_properties));
1767 else if (old_format)
1768 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
1770 set_bit(REISERFS_3_6, &(sbi->s_properties));
1772 if (!(s->s_flags & MS_RDONLY)) {
1774 errval = journal_begin(&th, s, 1);
1780 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1782 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1783 set_sb_fs_state(rs, 0);
1785 /* Clear out s_bmap_nr if it would wrap. We can handle this
1786 * case, but older revisions can't. This will cause the
1787 * file system to fail mount on those older implementations,
1788 * avoiding corruption. -jeffm */
1789 if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
1790 sb_bmap_nr(rs) != 0) {
1791 reiserfs_warning(s, "super-2030: This file system "
1792 "claims to use %u bitmap blocks in "
1793 "its super block, but requires %u. "
1794 "Clearing to zero.", sb_bmap_nr(rs),
1795 reiserfs_bmap_count(s));
1797 set_sb_bmap_nr(rs, 0);
1800 if (old_format_only(s)) {
1801 /* filesystem of format 3.5 either with standard or non-standard
1803 if (convert_reiserfs(s)) {
1804 /* and -o conv is given */
1807 "converting 3.5 filesystem to the 3.6 format");
1809 if (is_reiserfs_3_5(rs))
1810 /* put magic string of 3.6 format. 2.2 will not be able to
1811 mount this filesystem anymore */
1812 memcpy(rs->s_v1.s_magic,
1813 reiserfs_3_6_magic_string,
1815 (reiserfs_3_6_magic_string));
1817 set_sb_version(rs, REISERFS_VERSION_2);
1818 reiserfs_convert_objectid_map_v1(s);
1819 set_bit(REISERFS_3_6, &(sbi->s_properties));
1820 clear_bit(REISERFS_3_5, &(sbi->s_properties));
1821 } else if (!silent) {
1822 reiserfs_info(s, "using 3.5.x disk format\n");
1825 set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1828 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1829 errval = journal_end(&th, s, 1);
1836 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1842 /* look for files which were to be removed in previous session */
1843 finish_unfinished(s);
1845 if (old_format_only(s) && !silent) {
1846 reiserfs_info(s, "using 3.5.x disk format\n");
1849 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1855 // mark hash in super block: it could be unset. overwrite should be ok
1856 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1860 reiserfs_proc_info_init(s);
1862 init_waitqueue_head(&(sbi->s_wait));
1863 spin_lock_init(&sbi->bitmap_lock);
1868 if (jinit_done) { /* kill the commit thread, free journal ram */
1869 journal_release_error(NULL, s);
1872 reiserfs_free_bitmap_cache(s);
1873 if (SB_BUFFER_WITH_SB(s))
1874 brelse(SB_BUFFER_WITH_SB(s));
1878 for (j = 0; j < MAXQUOTAS; j++)
1884 s->s_fs_info = NULL;
1888 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1890 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
1892 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1893 buf->f_bfree = sb_free_blocks(rs);
1894 buf->f_bavail = buf->f_bfree;
1895 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1896 buf->f_bsize = dentry->d_sb->s_blocksize;
1897 /* changed to accommodate gcc folks. */
1898 buf->f_type = REISERFS_SUPER_MAGIC;
1903 static int reiserfs_dquot_initialize(struct inode *inode, int type)
1905 struct reiserfs_transaction_handle th;
1908 /* We may create quota structure so we need to reserve enough blocks */
1909 reiserfs_write_lock(inode->i_sb);
1911 journal_begin(&th, inode->i_sb,
1912 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1915 ret = dquot_initialize(inode, type);
1917 journal_end(&th, inode->i_sb,
1918 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1922 reiserfs_write_unlock(inode->i_sb);
1926 static int reiserfs_dquot_drop(struct inode *inode)
1928 struct reiserfs_transaction_handle th;
1931 /* We may delete quota structure so we need to reserve enough blocks */
1932 reiserfs_write_lock(inode->i_sb);
1934 journal_begin(&th, inode->i_sb,
1935 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1938 * We call dquot_drop() anyway to at least release references
1939 * to quota structures so that umount does not hang.
1944 ret = dquot_drop(inode);
1946 journal_end(&th, inode->i_sb,
1947 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1951 reiserfs_write_unlock(inode->i_sb);
1955 static int reiserfs_write_dquot(struct dquot *dquot)
1957 struct reiserfs_transaction_handle th;
1960 reiserfs_write_lock(dquot->dq_sb);
1962 journal_begin(&th, dquot->dq_sb,
1963 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1966 ret = dquot_commit(dquot);
1968 journal_end(&th, dquot->dq_sb,
1969 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1973 reiserfs_write_unlock(dquot->dq_sb);
1977 static int reiserfs_acquire_dquot(struct dquot *dquot)
1979 struct reiserfs_transaction_handle th;
1982 reiserfs_write_lock(dquot->dq_sb);
1984 journal_begin(&th, dquot->dq_sb,
1985 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1988 ret = dquot_acquire(dquot);
1990 journal_end(&th, dquot->dq_sb,
1991 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1995 reiserfs_write_unlock(dquot->dq_sb);
1999 static int reiserfs_release_dquot(struct dquot *dquot)
2001 struct reiserfs_transaction_handle th;
2004 reiserfs_write_lock(dquot->dq_sb);
2006 journal_begin(&th, dquot->dq_sb,
2007 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2009 /* Release dquot anyway to avoid endless cycle in dqput() */
2010 dquot_release(dquot);
2013 ret = dquot_release(dquot);
2015 journal_end(&th, dquot->dq_sb,
2016 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2020 reiserfs_write_unlock(dquot->dq_sb);
2024 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2026 /* Are we journaling quotas? */
2027 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2028 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2029 dquot_mark_dquot_dirty(dquot);
2030 return reiserfs_write_dquot(dquot);
2032 return dquot_mark_dquot_dirty(dquot);
2035 static int reiserfs_write_info(struct super_block *sb, int type)
2037 struct reiserfs_transaction_handle th;
2040 /* Data block + inode block */
2041 reiserfs_write_lock(sb);
2042 ret = journal_begin(&th, sb, 2);
2045 ret = dquot_commit_info(sb, type);
2046 err = journal_end(&th, sb, 2);
2050 reiserfs_write_unlock(sb);
2055 * Turn on quotas during mount time - we need to find the quota file and such...
2057 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2059 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2060 REISERFS_SB(sb)->s_jquota_fmt, type);
2064 * Standard function to be called on quota_on
2066 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2067 char *name, int remount)
2071 struct inode *inode;
2072 struct reiserfs_transaction_handle th;
2074 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2076 /* No more checks needed? Path and format_id are bogus anyway... */
2078 return vfs_quota_on(sb, type, format_id, name, 1);
2079 err = kern_path(name, LOOKUP_FOLLOW, &path);
2082 /* Quotafile not on the same filesystem? */
2083 if (path.mnt->mnt_sb != sb) {
2087 inode = path.dentry->d_inode;
2088 /* We must not pack tails for quota files on reiserfs for quota IO to work */
2089 if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2090 err = reiserfs_unpack(inode, NULL);
2092 reiserfs_warning(sb,
2093 "reiserfs: Unpacking tail of quota file failed"
2094 " (%d). Cannot turn on quotas.", err);
2098 mark_inode_dirty(inode);
2100 /* Journaling quota? */
2101 if (REISERFS_SB(sb)->s_qf_names[type]) {
2102 /* Quotafile not of fs root? */
2103 if (path.dentry->d_parent != sb->s_root)
2104 reiserfs_warning(sb,
2105 "reiserfs: Quota file not on filesystem root. "
2106 "Journalled quota will not work.");
2110 * When we journal data on quota file, we have to flush journal to see
2111 * all updates to the file when we bypass pagecache...
2113 if (reiserfs_file_data_log(inode)) {
2114 /* Just start temporary transaction and finish it */
2115 err = journal_begin(&th, sb, 1);
2118 err = journal_end_sync(&th, sb, 1);
2122 err = vfs_quota_on_path(sb, type, format_id, &path);
2128 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2129 * acquiring the locks... As quota files are never truncated and quota code
2130 * itself serializes the operations (and noone else should touch the files)
2131 * we don't have to be afraid of races */
2132 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2133 size_t len, loff_t off)
2135 struct inode *inode = sb_dqopt(sb)->files[type];
2136 unsigned long blk = off >> sb->s_blocksize_bits;
2137 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2139 struct buffer_head tmp_bh, *bh;
2140 loff_t i_size = i_size_read(inode);
2144 if (off + len > i_size)
2147 while (toread > 0) {
2149 sb->s_blocksize - offset <
2150 toread ? sb->s_blocksize - offset : toread;
2152 /* Quota files are without tails so we can safely use this function */
2153 reiserfs_write_lock(sb);
2154 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2155 reiserfs_write_unlock(sb);
2158 if (!buffer_mapped(&tmp_bh)) /* A hole? */
2159 memset(data, 0, tocopy);
2161 bh = sb_bread(sb, tmp_bh.b_blocknr);
2164 memcpy(data, bh->b_data + offset, tocopy);
2175 /* Write to quotafile (we know the transaction is already started and has
2176 * enough credits) */
2177 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2178 const char *data, size_t len, loff_t off)
2180 struct inode *inode = sb_dqopt(sb)->files[type];
2181 unsigned long blk = off >> sb->s_blocksize_bits;
2182 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2183 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2184 size_t towrite = len;
2185 struct buffer_head tmp_bh, *bh;
2187 if (!current->journal_info) {
2188 printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2189 " cancelled because transaction is not started.\n",
2190 (unsigned long long)off, (unsigned long long)len);
2193 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2194 while (towrite > 0) {
2195 tocopy = sb->s_blocksize - offset < towrite ?
2196 sb->s_blocksize - offset : towrite;
2198 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2201 if (offset || tocopy != sb->s_blocksize)
2202 bh = sb_bread(sb, tmp_bh.b_blocknr);
2204 bh = sb_getblk(sb, tmp_bh.b_blocknr);
2210 memcpy(bh->b_data + offset, data, tocopy);
2211 flush_dcache_page(bh->b_page);
2212 set_buffer_uptodate(bh);
2214 reiserfs_prepare_for_journal(sb, bh, 1);
2215 journal_mark_dirty(current->journal_info, sb, bh);
2217 reiserfs_add_ordered_list(inode, bh);
2225 if (len == towrite) {
2226 mutex_unlock(&inode->i_mutex);
2229 if (inode->i_size < off + len - towrite)
2230 i_size_write(inode, off + len - towrite);
2232 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2233 mark_inode_dirty(inode);
2234 mutex_unlock(&inode->i_mutex);
2235 return len - towrite;
2240 static int get_super_block(struct file_system_type *fs_type,
2241 int flags, const char *dev_name,
2242 void *data, struct vfsmount *mnt)
2244 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2248 static int __init init_reiserfs_fs(void)
2252 if ((ret = init_inodecache())) {
2256 if ((ret = reiserfs_xattr_register_handlers()))
2257 goto failed_reiserfs_xattr_register_handlers;
2259 reiserfs_proc_info_global_init();
2260 reiserfs_proc_register_global("version",
2261 reiserfs_global_version_in_proc);
2263 ret = register_filesystem(&reiserfs_fs_type);
2269 reiserfs_xattr_unregister_handlers();
2271 failed_reiserfs_xattr_register_handlers:
2272 reiserfs_proc_unregister_global("version");
2273 reiserfs_proc_info_global_done();
2274 destroy_inodecache();
2279 static void __exit exit_reiserfs_fs(void)
2281 reiserfs_xattr_unregister_handlers();
2282 reiserfs_proc_unregister_global("version");
2283 reiserfs_proc_info_global_done();
2284 unregister_filesystem(&reiserfs_fs_type);
2285 destroy_inodecache();
2288 struct file_system_type reiserfs_fs_type = {
2289 .owner = THIS_MODULE,
2291 .get_sb = get_super_block,
2292 .kill_sb = reiserfs_kill_sb,
2293 .fs_flags = FS_REQUIRES_DEV,
2296 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2297 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2298 MODULE_LICENSE("GPL");
2300 module_init(init_reiserfs_fs);
2301 module_exit(exit_reiserfs_fs);