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/slab.h>
16 #include <linux/vmalloc.h>
17 #include <linux/time.h>
18 #include <asm/uaccess.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>
33 struct file_system_type reiserfs_fs_type;
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;
39 int is_reiserfs_3_5(struct reiserfs_super_block *rs)
41 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
42 strlen(reiserfs_3_5_magic_string));
45 int is_reiserfs_3_6(struct reiserfs_super_block *rs)
47 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
48 strlen(reiserfs_3_6_magic_string));
51 int is_reiserfs_jr(struct reiserfs_super_block *rs)
53 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
54 strlen(reiserfs_jr_magic_string));
57 static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
59 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
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);
67 static int reiserfs_sync_fs(struct super_block *s, int wait)
69 struct reiserfs_transaction_handle th;
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);
79 static void flush_old_commits(struct work_struct *work)
81 struct reiserfs_sb_info *sbi;
82 struct super_block *s;
84 sbi = container_of(work, struct reiserfs_sb_info, old_work.work);
85 s = sbi->s_journal->j_work_sb;
87 spin_lock(&sbi->old_work_lock);
89 spin_unlock(&sbi->old_work_lock);
91 reiserfs_sync_fs(s, 1);
94 void reiserfs_schedule_old_flush(struct super_block *s)
96 struct reiserfs_sb_info *sbi = REISERFS_SB(s);
99 if (s->s_flags & MS_RDONLY)
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;
108 spin_unlock(&sbi->old_work_lock);
111 static void cancel_old_flush(struct super_block *s)
113 struct reiserfs_sb_info *sbi = REISERFS_SB(s);
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);
121 static int reiserfs_freeze(struct super_block *s)
123 struct reiserfs_transaction_handle th;
127 reiserfs_write_lock(s);
128 if (!(s->s_flags & MS_RDONLY)) {
129 int err = journal_begin(&th, s, 1);
131 reiserfs_block_writes(&th);
133 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
135 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
136 reiserfs_block_writes(&th);
137 journal_end_sync(&th, s, 1);
140 reiserfs_write_unlock(s);
144 static int reiserfs_unfreeze(struct super_block *s)
146 reiserfs_allow_writes(s);
150 extern const struct in_core_key MAX_IN_CORE_KEY;
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
159 static int remove_save_link_only(struct super_block *s,
160 struct reiserfs_key *key, int oid_free)
162 struct reiserfs_transaction_handle th;
165 /* we are going to do one balancing */
166 err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);
170 reiserfs_delete_solid_item(&th, NULL, key);
172 /* removals are protected by direct items */
173 reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid));
175 return journal_end(&th, s, JOURNAL_PER_BALANCE_CNT);
179 static int reiserfs_quota_on_mount(struct super_block *, int);
182 /* look for uncompleted unlinks and truncates and complete them */
183 static int finish_unfinished(struct super_block *s)
185 INITIALIZE_PATH(path);
186 struct cpu_key max_cpu_key, obj_key;
187 struct reiserfs_key save_link_key, last_inode_key;
189 struct item_head *ih;
190 struct buffer_head *bh;
199 int quota_enabled[MAXQUOTAS];
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;
209 memset(&last_inode_key, 0, sizeof(last_inode_key));
212 /* Needed for iput() to work correctly and not trash data */
213 if (s->s_flags & MS_ACTIVE) {
217 s->s_flags |= MS_ACTIVE;
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]) {
225 if (sb_has_quota_active(s, i)) {
226 quota_enabled[i] = 0;
229 ret = reiserfs_quota_on_mount(s, i);
231 reiserfs_warning(s, "reiserfs-2500",
232 "cannot turn on journaled "
233 "quota: error %d", ret);
239 REISERFS_SB(s)->s_is_unlinked_ok = 1;
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);
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");
256 ih = B_N_PITEM_HEAD(bh, item_pos);
258 if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
259 /* there are no "save" links anymore */
262 save_link_key = ih->ih_key;
263 if (is_indirect_le_ih(ih))
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;
278 inode = reiserfs_iget(s, &obj_key);
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",
284 retval = remove_save_link_only(s, &save_link_key, 1);
288 if (!truncate && inode->i_nlink) {
289 /* file is not unlinked */
290 reiserfs_warning(s, "vs-2185",
291 "file %K is not unlinked",
293 retval = remove_save_link_only(s, &save_link_key, 0);
296 dquot_initialize(inode);
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
303 reiserfs_warning(s, "green-2101",
304 "impossible truncate on a "
305 "directory %k. Please report",
307 retval = remove_save_link_only(s, &save_link_key, 0);
314 REISERFS_I(inode)->i_flags |=
315 i_link_saved_truncate_mask;
316 /* not completed truncate found. New size was committed together
318 reiserfs_info(s, "Truncating %k to %Ld ..",
319 INODE_PKEY(inode), inode->i_size);
320 reiserfs_truncate_file(inode,
322 /*don't update modification time */
324 retval = remove_save_link(inode, truncate);
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 */
335 reiserfs_warning(s, "super-2189", "Dead loop "
336 "in finish_unfinished "
337 "detected, just remove "
339 retval = remove_save_link_only(s,
348 REISERFS_SB(s)->s_is_unlinked_ok = 0;
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);
357 /* Restore the flag back */
358 s->s_flags &= ~MS_ACTIVE;
362 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
363 "Completed\n", done);
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)
374 INITIALIZE_PATH(path);
380 BUG_ON(!th->t_trans_id);
382 /* file can only get one "save link" of each kind */
384 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask),
385 "saved link already exists for truncated inode %lx",
388 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask),
389 "saved link already exists for unlinked inode %lx",
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;
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);
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 */ );
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",
412 set_cpu_key_k_offset(&key, 1);
413 set_cpu_key_k_type(&key, TYPE_INDIRECT);
415 /* item head of "safe" link */
416 make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT,
417 4 /*length */ , 0 /*free space */ );
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,
432 /* body of "save" link */
433 link = INODE_PKEY(inode)->k_dir_id;
435 /* put "save" link into tree, don't charge quota to anyone */
437 reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
439 if (retval != -ENOSPC)
440 reiserfs_error(inode->i_sb, "vs-2120",
441 "insert_item returned %d", retval);
444 REISERFS_I(inode)->i_flags |=
445 i_link_saved_truncate_mask;
447 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
451 /* this opens transaction unlike add_save_link */
452 int remove_save_link(struct inode *inode, int truncate)
454 struct reiserfs_transaction_handle th;
455 struct reiserfs_key key;
458 /* we are going to do one balancing only */
459 err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
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;
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);
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);
478 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||
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);
484 reiserfs_release_objectid(&th, inode->i_ino);
485 REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;
487 REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;
489 return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
492 static void reiserfs_kill_sb(struct super_block *s)
494 if (REISERFS_SB(s)) {
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.
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;
514 static void reiserfs_put_super(struct super_block *s)
516 struct reiserfs_transaction_handle th;
519 dquot_disable(s, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
521 reiserfs_write_lock(s);
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),
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));
534 /* note, journal_release checks for readonly mount, and can decide not
535 ** to do a journal_end
537 journal_release(&th, s);
539 reiserfs_free_bitmap_cache(s);
541 brelse(SB_BUFFER_WITH_SB(s));
545 if (REISERFS_SB(s)->reserved_blocks != 0) {
546 reiserfs_warning(s, "green-2005", "reserved blocks left %d",
547 REISERFS_SB(s)->reserved_blocks);
550 reiserfs_proc_info_done(s);
552 reiserfs_write_unlock(s);
553 mutex_destroy(&REISERFS_SB(s)->lock);
558 static struct kmem_cache *reiserfs_inode_cachep;
560 static struct inode *reiserfs_alloc_inode(struct super_block *sb)
562 struct reiserfs_inode_info *ei;
563 ei = (struct reiserfs_inode_info *)
564 kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
567 atomic_set(&ei->openers, 0);
568 mutex_init(&ei->tailpack);
569 return &ei->vfs_inode;
572 static void reiserfs_i_callback(struct rcu_head *head)
574 struct inode *inode = container_of(head, struct inode, i_rcu);
575 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
578 static void reiserfs_destroy_inode(struct inode *inode)
580 call_rcu(&inode->i_rcu, reiserfs_i_callback);
583 static void init_once(void *foo)
585 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
587 INIT_LIST_HEAD(&ei->i_prealloc_list);
588 inode_init_once(&ei->vfs_inode);
591 static int init_inodecache(void)
593 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
595 reiserfs_inode_info),
596 0, (SLAB_RECLAIM_ACCOUNT|
599 if (reiserfs_inode_cachep == NULL)
604 static void destroy_inodecache(void)
606 kmem_cache_destroy(reiserfs_inode_cachep);
609 /* we don't mark inodes dirty, we just log them */
610 static void reiserfs_dirty_inode(struct inode *inode, int flags)
612 struct reiserfs_transaction_handle th;
617 if (inode->i_sb->s_flags & MS_RDONLY) {
618 reiserfs_warning(inode->i_sb, "clm-6006",
619 "writing inode %lu on readonly FS",
623 lock_depth = reiserfs_write_lock_once(inode->i_sb);
625 /* this is really only used for atime updates, so they don't have
626 ** to be included in O_SYNC or fsync
628 err = journal_begin(&th, inode->i_sb, 1);
632 reiserfs_update_sd(&th, inode);
633 journal_end(&th, inode->i_sb, 1);
636 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
639 static int reiserfs_show_options(struct seq_file *seq, struct dentry *root)
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;
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 */
651 if (!(opts & (1 << REISERFS_BARRIER_FLUSH)))
652 seq_puts(seq, ",barrier=none");
653 /* barrier=flush is default so we don't show it */
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 */
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 */
667 if (opts & (1 << REISERFS_ATTRS))
668 seq_puts(seq, ",attrs");
670 if (opts & (1 << REISERFS_XATTRS_USER))
671 seq_puts(seq, ",user_xattr");
673 if (opts & (1 << REISERFS_EXPOSE_PRIVROOT))
674 seq_puts(seq, ",expose_privroot");
676 if (opts & (1 << REISERFS_POSIXACL))
677 seq_puts(seq, ",acl");
679 if (REISERFS_SB(s)->s_jdev)
680 seq_printf(seq, ",jdev=%s", REISERFS_SB(s)->s_jdev);
682 if (journal->j_max_commit_age != journal->j_default_max_commit_age)
683 seq_printf(seq, ",commit=%d", journal->j_max_commit_age);
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");
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);
716 static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,
718 static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,
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,
736 .quota_read = reiserfs_quota_read,
737 .quota_write = reiserfs_quota_write,
742 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
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 *);
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,
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,
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,
779 /* this struct is used in reiserfs_getopt () for containing the value for those
780 mount options that have values rather than being toggles. */
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 */
790 /* Set this bit in arg_required to allow empty arguments */
791 #define REISERFS_OPT_ALLOWEMPTY 31
793 /* this struct is used in reiserfs_getopt() for describing the set of reiserfs
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 */
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)},
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},
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},
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},
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)},
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)
871 const opt_desc_t *opt;
872 const arg_desc_t *arg;
876 /* assume argument cannot contain commas */
877 *cur = strchr(p, ',');
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)) {
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))) {
899 (1 << REISERFS_UNSUPPORTED_OPT))
900 reiserfs_warning(s, "super-6500",
901 "%s not supported.\n",
904 *bit_flags &= ~opt->clrmask;
906 (1 << REISERFS_UNSUPPORTED_OPT))
907 reiserfs_warning(s, "super-6501",
908 "%s not supported.\n",
911 *bit_flags |= opt->setmask;
916 if (!opt->option_name) {
917 reiserfs_warning(s, "super-6502",
918 "unknown mount option \"%s\"", p);
922 p += strlen(opt->option_name);
925 if (!opt->arg_required) {
926 reiserfs_warning(s, "super-6503",
927 "the option \"%s\" does not "
928 "require an argument\n",
935 if (opt->arg_required) {
936 reiserfs_warning(s, "super-6504",
937 "the option \"%s\" requires an "
938 "argument\n", opt->option_name);
943 reiserfs_warning(s, "super-6505",
944 "head of option \"%s\" is only correct\n",
949 /* move to the argument, or to next option if argument is not required */
952 if (opt->arg_required
953 && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
955 /* this catches "option=," if not allowed */
956 reiserfs_warning(s, "super-6506",
957 "empty argument for \"%s\"\n",
963 /* *=NULLopt_arg contains pointer to argument */
965 return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);
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)) {
972 *bit_flags &= ~arg->clrmask;
973 *bit_flags |= arg->setmask;
975 return opt->arg_required;
979 reiserfs_warning(s, "super-6506",
980 "bad value \"%s\" for option \"%s\"\n", p,
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 */
993 unsigned int *commit_max_age,
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},
1013 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
1014 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
1016 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1017 {"acl",.setmask = 1 << REISERFS_POSIXACL},
1018 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
1020 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
1021 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
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}
1045 if (!options || !*options)
1046 /* use default configuration: create tails, journaling on, no
1047 conversion to newest format */
1050 for (pos = options; pos;) {
1051 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
1053 /* wrong option is given */
1060 /* "resize=NNN" or "resize=auto" */
1062 if (!strcmp(arg, "auto")) {
1063 /* From JFS code, to auto-get the size. */
1065 s->s_bdev->bd_inode->i_size >> s->
1068 *blocks = simple_strtoul(arg, &p, 0);
1070 /* NNN does not look like a number */
1071 reiserfs_warning(s, "super-6507",
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",
1089 *commit_max_age = (unsigned int)val;
1093 reiserfs_warning(s, "super-6509", "nolargeio option "
1094 "is no longer supported");
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);
1111 if (c == 'u' || c == 'g') {
1112 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
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 "
1122 if (*arg) { /* Some filename specified? */
1123 if (REISERFS_SB(s)->s_qf_names[qtype]
1124 && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1126 reiserfs_warning(s, "super-6512",
1128 "already specified.",
1132 if (strchr(arg, '/')) {
1133 reiserfs_warning(s, "super-6513",
1134 "quotafile must be "
1135 "on filesystem root.");
1139 kmalloc(strlen(arg) + 1, GFP_KERNEL);
1140 if (!qf_names[qtype]) {
1141 reiserfs_warning(s, "reiserfs-2502",
1142 "not enough memory "
1147 strcpy(qf_names[qtype], arg);
1148 if (qtype == USRQUOTA)
1149 *mount_options |= 1 << REISERFS_USRQUOTA;
1151 *mount_options |= 1 << REISERFS_GRPQUOTA;
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);
1160 *mount_options &= ~(1 << REISERFS_GRPQUOTA);
1164 if (!strcmp(arg, "vfsold"))
1165 *qfmt = QFMT_VFS_OLD;
1166 else if (!strcmp(arg, "vfsv0"))
1167 *qfmt = QFMT_VFS_V0;
1169 reiserfs_warning(s, "super-6514",
1170 "unknown quota format "
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 "
1184 if (c == 'u' || c == 'g' || c == 'f') {
1185 reiserfs_warning(s, "reiserfs-2503", "journaled "
1186 "quota options not supported.");
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.");
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.");
1212 static void switch_data_mode(struct super_block *s, unsigned long mode)
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);
1220 static void handle_data_mode(struct super_block *s, unsigned long mount_options)
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");
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");
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");
1240 static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1242 int flush = (1 << REISERFS_BARRIER_FLUSH);
1243 int none = (1 << REISERFS_BARRIER_NONE);
1244 int all_barrier = flush | none;
1246 if (bits & all_barrier) {
1247 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
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");
1258 static void handle_attrs(struct super_block *s)
1260 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
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);
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 "
1273 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1279 static void handle_quota_files(struct super_block *s, char **qf_names,
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];
1290 REISERFS_SB(s)->s_jquota_fmt = *qfmt;
1294 static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
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);
1305 char *qf_names[MAXQUOTAS];
1306 unsigned int qfmt = 0;
1311 reiserfs_write_lock(s);
1314 memcpy(qf_names, REISERFS_SB(s)->s_qf_names, sizeof(qf_names));
1317 rs = SB_DISK_SUPER_BLOCK(s);
1319 if (!reiserfs_parse_options
1320 (s, arg, &mount_options, &blocks, NULL, &commit_max_age,
1323 for (i = 0; i < MAXQUOTAS; i++)
1324 if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1331 handle_quota_files(s, qf_names, &qfmt);
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;
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 =
1358 s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
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;
1370 err = reiserfs_resize(s, blocks);
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 */
1382 err = dquot_suspend(s, -1);
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) {
1392 err = journal_begin(&th, s, 10);
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));
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 */
1407 if (reiserfs_is_journal_aborted(journal)) {
1408 err = journal->j_errno;
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);
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;
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);
1437 if (!(*mount_flags & MS_RDONLY)) {
1438 dquot_resume(s, -1);
1439 finish_unfinished(s);
1440 reiserfs_xattr_init(s, *mount_flags);
1444 replace_mount_options(s, new_opts);
1445 reiserfs_write_unlock(s);
1450 reiserfs_write_unlock(s);
1454 static int read_super_block(struct super_block *s, int offset)
1456 struct buffer_head *bh;
1457 struct reiserfs_super_block *rs;
1460 bh = sb_bread(s, offset / s->s_blocksize);
1462 reiserfs_warning(s, "sh-2006",
1463 "bread failed (dev %s, block %lu, size %lu)",
1464 reiserfs_bdevname(s), offset / s->s_blocksize,
1469 rs = (struct reiserfs_super_block *)bh->b_data;
1470 if (!is_any_reiserfs_magic_string(rs)) {
1475 // ok, reiserfs signature (old or new) found in at the given offset
1477 fs_blocksize = sb_blocksize(rs);
1479 sb_set_blocksize(s, fs_blocksize);
1481 bh = sb_bread(s, offset / s->s_blocksize);
1483 reiserfs_warning(s, "sh-2007",
1484 "bread failed (dev %s, block %lu, size %lu)",
1485 reiserfs_bdevname(s), offset / s->s_blocksize,
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,
1501 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
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");
1511 SB_BUFFER_WITH_SB(s) = bh;
1512 SB_DISK_SUPER_BLOCK(s) = rs;
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");
1524 reiserfs_warning(s, "sh-2012", "found unknown "
1525 "format \"%u\" of reiserfs with "
1526 "non-standard magic", sb_version(rs));
1530 /* s_version of standard format may contain incorrect information,
1531 so we just look at the magic string */
1533 "found reiserfs format \"%s\" with standard journal\n",
1534 is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1536 s->s_op = &reiserfs_sops;
1537 s->s_export_op = &reiserfs_export_ops;
1539 s->s_qcop = &reiserfs_qctl_operations;
1540 s->dq_op = &reiserfs_quota_operations;
1543 /* new format is limited by the 32 bit wide i_blocks field, want to
1544 ** be one full block below that.
1546 s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1550 /* after journal replay, reread all bitmap and super blocks */
1551 static int reread_meta_blocks(struct super_block *s)
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");
1563 /////////////////////////////////////////////////////
1564 // hash detection stuff
1566 // if root directory is empty - we set default - Yura's - hash and
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
1571 static __u32 find_hash_out(struct super_block *s)
1574 struct inode *inode;
1576 INITIALIZE_PATH(path);
1577 struct reiserfs_dir_entry de;
1578 __u32 hash = DEFAULT_HASH;
1580 inode = s->s_root->d_inode;
1582 do { // Some serious "goto"-hater was there ;)
1583 u32 teahash, r5hash, yurahash;
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) {
1591 if (retval == NAME_NOT_FOUND)
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)) {
1599 reiserfs_info(s, "FS seems to be empty, autodetect "
1600 "is using the default hash\n");
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)
1608 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1609 == r5hash)) || ((teahash == yurahash)
1611 GET_HASH_VALUE(deh_offset
1616 || ((r5hash == 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}");
1627 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1630 else if (GET_HASH_VALUE
1631 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1633 else if (GET_HASH_VALUE
1634 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1637 reiserfs_warning(s, "reiserfs-2506",
1638 "Unrecognised hash function");
1647 // finds out which hash names are sorted with
1648 static int what_hash(struct super_block *s)
1652 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
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
1658 if (code == UNSET_HASH || reiserfs_hash_detect(s))
1659 code = find_hash_out(s);
1661 if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1662 /* detection has found the hash, and we must check against the
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));
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));
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));
1685 /* find_hash_out was not called or could not determine the hash */
1686 if (reiserfs_rupasov_hash(s)) {
1688 } else if (reiserfs_tea_hash(s)) {
1690 } else if (reiserfs_r5_hash(s)) {
1695 /* if we are mounted RW, and we have a new valid hash code, update
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);
1706 // return pointer to appropriate function
1707 static hashf_t hash_function(struct super_block *s)
1709 switch (what_hash(s)) {
1711 reiserfs_info(s, "Using tea hash to sort names\n");
1714 reiserfs_info(s, "Using rupasov hash to sort names\n");
1717 reiserfs_info(s, "Using r5 hash to sort names\n");
1723 // this is used to set up correct value for old partitions
1724 static int function2code(hashf_t func)
1726 if (func == keyed_hash)
1728 if (func == yura_hash)
1730 if (func == r5_hash)
1733 BUG(); // should never happen
1738 #define SWARN(silent, s, id, ...) \
1740 reiserfs_warning(s, id, __VA_ARGS__)
1742 static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1744 struct inode *root_inode;
1745 struct reiserfs_transaction_handle th;
1747 unsigned long blocks;
1748 unsigned int commit_max_age = 0;
1750 struct reiserfs_iget_args args;
1751 struct reiserfs_super_block *rs;
1753 struct reiserfs_sb_info *sbi;
1754 int errval = -EINVAL;
1755 char *qf_names[MAXQUOTAS] = {};
1756 unsigned int qfmt = 0;
1758 save_mount_options(s, data);
1760 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
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);
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;
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;
1787 if (jdev_name && jdev_name[0]) {
1788 sbi->s_jdev = kstrdup(jdev_name, GFP_KERNEL);
1790 SWARN(silent, s, "", "Cannot allocate memory for "
1791 "journal device name");
1796 handle_quota_files(s, qf_names, &qfmt);
1800 SWARN(silent, s, "jmacd-7", "resize option for remount only");
1801 goto error_unlocked;
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))
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;
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;
1830 sbi->s_mount_state = SB_REISERFS_STATE(s);
1831 sbi->s_mount_state = REISERFS_VALID_FS;
1833 if ((errval = reiserfs_init_bitmap_cache(s))) {
1834 SWARN(silent, s, "jmacd-8", "unable to read bitmap");
1835 goto error_unlocked;
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.");
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);
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");
1855 reiserfs_info(s, "using writeback data mode\n");
1857 if (reiserfs_barrier_flush(s)) {
1858 printk("reiserfs: using flush barriers\n");
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;
1867 jinit_done = 1; /* once this is set, journal_release must be called
1868 ** if we error out of the mount
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;
1879 goto error_unlocked;
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;
1886 args.objectid = REISERFS_ROOT_OBJECTID;
1887 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1889 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1890 reiserfs_init_locked_inode, (void *)(&args));
1892 SWARN(silent, s, "jmacd-10", "get root inode failed");
1893 goto error_unlocked;
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.
1904 reiserfs_write_lock(s);
1906 if (root_inode->i_state & I_NEW) {
1907 reiserfs_read_locked_inode(root_inode, &args);
1908 unlock_new_inode(root_inode);
1911 s->s_root = d_make_root(root_inode);
1914 // define and initialize hash function
1915 sbi->s_hash_function = hash_function(s);
1916 if (sbi->s_hash_function == NULL) {
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));
1928 set_bit(REISERFS_3_6, &(sbi->s_properties));
1930 if (!(s->s_flags & MS_RDONLY)) {
1932 errval = journal_begin(&th, s, 1);
1938 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1940 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1941 set_sb_fs_state(rs, 0);
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));
1955 set_sb_bmap_nr(rs, 0);
1958 if (old_format_only(s)) {
1959 /* filesystem of format 3.5 either with standard or non-standard
1961 if (convert_reiserfs(s)) {
1962 /* and -o conv is given */
1965 "converting 3.5 filesystem to the 3.6 format");
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,
1973 (reiserfs_3_6_magic_string));
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");
1983 set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1986 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1987 errval = journal_end(&th, s, 1);
1994 if ((errval = reiserfs_lookup_privroot(s)) ||
1995 (errval = reiserfs_xattr_init(s, s->s_flags))) {
2001 /* look for files which were to be removed in previous session */
2002 finish_unfinished(s);
2004 if (old_format_only(s) && !silent) {
2005 reiserfs_info(s, "using 3.5.x disk format\n");
2008 if ((errval = reiserfs_lookup_privroot(s)) ||
2009 (errval = reiserfs_xattr_init(s, s->s_flags))) {
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));
2020 reiserfs_proc_info_init(s);
2022 init_waitqueue_head(&(sbi->s_wait));
2023 spin_lock_init(&sbi->bitmap_lock);
2025 reiserfs_write_unlock(s);
2030 reiserfs_write_unlock(s);
2033 /* kill the commit thread, free journal ram */
2035 reiserfs_write_lock(s);
2036 journal_release_error(NULL, s);
2037 reiserfs_write_unlock(s);
2040 cancel_delayed_work_sync(&REISERFS_SB(s)->old_work);
2042 reiserfs_free_bitmap_cache(s);
2043 if (SB_BUFFER_WITH_SB(s))
2044 brelse(SB_BUFFER_WITH_SB(s));
2048 for (j = 0; j < MAXQUOTAS; j++)
2054 s->s_fs_info = NULL;
2058 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
2060 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
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);
2077 static int reiserfs_write_dquot(struct dquot *dquot)
2079 struct reiserfs_transaction_handle th;
2082 reiserfs_write_lock(dquot->dq_sb);
2084 journal_begin(&th, dquot->dq_sb,
2085 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2088 ret = dquot_commit(dquot);
2090 journal_end(&th, dquot->dq_sb,
2091 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2095 reiserfs_write_unlock(dquot->dq_sb);
2099 static int reiserfs_acquire_dquot(struct dquot *dquot)
2101 struct reiserfs_transaction_handle th;
2104 reiserfs_write_lock(dquot->dq_sb);
2106 journal_begin(&th, dquot->dq_sb,
2107 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2110 ret = dquot_acquire(dquot);
2112 journal_end(&th, dquot->dq_sb,
2113 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2117 reiserfs_write_unlock(dquot->dq_sb);
2121 static int reiserfs_release_dquot(struct dquot *dquot)
2123 struct reiserfs_transaction_handle th;
2126 reiserfs_write_lock(dquot->dq_sb);
2128 journal_begin(&th, dquot->dq_sb,
2129 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2131 /* Release dquot anyway to avoid endless cycle in dqput() */
2132 dquot_release(dquot);
2135 ret = dquot_release(dquot);
2137 journal_end(&th, dquot->dq_sb,
2138 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2142 reiserfs_write_unlock(dquot->dq_sb);
2146 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
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);
2154 return dquot_mark_dquot_dirty(dquot);
2157 static int reiserfs_write_info(struct super_block *sb, int type)
2159 struct reiserfs_transaction_handle th;
2162 /* Data block + inode block */
2163 reiserfs_write_lock(sb);
2164 ret = journal_begin(&th, sb, 2);
2167 ret = dquot_commit_info(sb, type);
2168 err = journal_end(&th, sb, 2);
2172 reiserfs_write_unlock(sb);
2177 * Turn on quotas during mount time - we need to find the quota file and such...
2179 static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2181 return dquot_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2182 REISERFS_SB(sb)->s_jquota_fmt, type);
2186 * Standard function to be called on quota_on
2188 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2192 struct inode *inode;
2193 struct reiserfs_transaction_handle th;
2194 int opt = type == USRQUOTA ? REISERFS_USRQUOTA : REISERFS_GRPQUOTA;
2196 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << opt)))
2199 /* Quotafile not on the same filesystem? */
2200 if (path->dentry->d_sb != sb) {
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);
2209 reiserfs_warning(sb, "super-6520",
2210 "Unpacking tail of quota file failed"
2211 " (%d). Cannot turn on quotas.", err);
2215 mark_inode_dirty(inode);
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.");
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...
2230 if (reiserfs_file_data_log(inode)) {
2231 /* Just start temporary transaction and finish it */
2232 err = journal_begin(&th, sb, 1);
2235 err = journal_end_sync(&th, sb, 1);
2239 err = dquot_quota_on(sb, type, format_id, path);
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)
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;
2255 struct buffer_head tmp_bh, *bh;
2256 loff_t i_size = i_size_read(inode);
2260 if (off + len > i_size)
2263 while (toread > 0) {
2265 sb->s_blocksize - offset <
2266 toread ? sb->s_blocksize - offset : toread;
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);
2274 if (!buffer_mapped(&tmp_bh)) /* A hole? */
2275 memset(data, 0, tocopy);
2277 bh = sb_bread(sb, tmp_bh.b_blocknr);
2280 memcpy(data, bh->b_data + offset, tocopy);
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)
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;
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);
2309 while (towrite > 0) {
2310 tocopy = sb->s_blocksize - offset < towrite ?
2311 sb->s_blocksize - offset : towrite;
2313 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2316 if (offset || tocopy != sb->s_blocksize)
2317 bh = sb_bread(sb, tmp_bh.b_blocknr);
2319 bh = sb_getblk(sb, tmp_bh.b_blocknr);
2325 memcpy(bh->b_data + offset, data, tocopy);
2326 flush_dcache_page(bh->b_page);
2327 set_buffer_uptodate(bh);
2329 reiserfs_prepare_for_journal(sb, bh, 1);
2330 journal_mark_dirty(current->journal_info, sb, bh);
2332 reiserfs_add_ordered_list(inode, bh);
2342 if (inode->i_size < off + len - towrite)
2343 i_size_write(inode, off + len - towrite);
2345 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2346 mark_inode_dirty(inode);
2347 return len - towrite;
2352 static struct dentry *get_super_block(struct file_system_type *fs_type,
2353 int flags, const char *dev_name,
2356 return mount_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
2359 static int __init init_reiserfs_fs(void)
2363 if ((ret = init_inodecache())) {
2367 reiserfs_proc_info_global_init();
2369 ret = register_filesystem(&reiserfs_fs_type);
2375 reiserfs_proc_info_global_done();
2376 destroy_inodecache();
2381 static void __exit exit_reiserfs_fs(void)
2383 reiserfs_proc_info_global_done();
2384 unregister_filesystem(&reiserfs_fs_type);
2385 destroy_inodecache();
2388 struct file_system_type reiserfs_fs_type = {
2389 .owner = THIS_MODULE,
2391 .mount = get_super_block,
2392 .kill_sb = reiserfs_kill_sb,
2393 .fs_flags = FS_REQUIRES_DEV,
2396 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2397 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2398 MODULE_LICENSE("GPL");
2400 module_init(init_reiserfs_fs);
2401 module_exit(exit_reiserfs_fs);