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 <linux/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
);
66 static int reiserfs_sync_fs(struct super_block
*s
, int wait
)
68 struct reiserfs_transaction_handle th
;
71 * Writeback quota in non-journalled quota case - journalled quota has
74 dquot_writeback_dquots(s
, -1);
75 reiserfs_write_lock(s
);
76 if (!journal_begin(&th
, s
, 1))
77 if (!journal_end_sync(&th
))
78 reiserfs_flush_old_commits(s
);
79 reiserfs_write_unlock(s
);
83 static void flush_old_commits(struct work_struct
*work
)
85 struct reiserfs_sb_info
*sbi
;
86 struct super_block
*s
;
88 sbi
= container_of(work
, struct reiserfs_sb_info
, old_work
.work
);
89 s
= sbi
->s_journal
->j_work_sb
;
91 spin_lock(&sbi
->old_work_lock
);
93 spin_unlock(&sbi
->old_work_lock
);
95 reiserfs_sync_fs(s
, 1);
98 void reiserfs_schedule_old_flush(struct super_block
*s
)
100 struct reiserfs_sb_info
*sbi
= REISERFS_SB(s
);
104 * Avoid scheduling flush when sb is being shut down. It can race
105 * with journal shutdown and free still queued delayed work.
107 if (s
->s_flags
& MS_RDONLY
|| !(s
->s_flags
& MS_ACTIVE
))
110 spin_lock(&sbi
->old_work_lock
);
111 if (!sbi
->work_queued
) {
112 delay
= msecs_to_jiffies(dirty_writeback_interval
* 10);
113 queue_delayed_work(system_long_wq
, &sbi
->old_work
, delay
);
114 sbi
->work_queued
= 1;
116 spin_unlock(&sbi
->old_work_lock
);
119 static void cancel_old_flush(struct super_block
*s
)
121 struct reiserfs_sb_info
*sbi
= REISERFS_SB(s
);
123 cancel_delayed_work_sync(&REISERFS_SB(s
)->old_work
);
124 spin_lock(&sbi
->old_work_lock
);
125 sbi
->work_queued
= 0;
126 spin_unlock(&sbi
->old_work_lock
);
129 static int reiserfs_freeze(struct super_block
*s
)
131 struct reiserfs_transaction_handle th
;
135 reiserfs_write_lock(s
);
136 if (!(s
->s_flags
& MS_RDONLY
)) {
137 int err
= journal_begin(&th
, s
, 1);
139 reiserfs_block_writes(&th
);
141 reiserfs_prepare_for_journal(s
, SB_BUFFER_WITH_SB(s
),
143 journal_mark_dirty(&th
, SB_BUFFER_WITH_SB(s
));
144 reiserfs_block_writes(&th
);
145 journal_end_sync(&th
);
148 reiserfs_write_unlock(s
);
152 static int reiserfs_unfreeze(struct super_block
*s
)
154 reiserfs_allow_writes(s
);
158 extern const struct in_core_key MAX_IN_CORE_KEY
;
161 * this is used to delete "save link" when there are no items of a
162 * file it points to. It can either happen if unlink is completed but
163 * "save unlink" removal, or if file has both unlink and truncate
164 * pending and as unlink completes first (because key of "save link"
165 * protecting unlink is bigger that a key lf "save link" which
166 * protects truncate), so there left no items to make truncate
169 static int remove_save_link_only(struct super_block
*s
,
170 struct reiserfs_key
*key
, int oid_free
)
172 struct reiserfs_transaction_handle th
;
175 /* we are going to do one balancing */
176 err
= journal_begin(&th
, s
, JOURNAL_PER_BALANCE_CNT
);
180 reiserfs_delete_solid_item(&th
, NULL
, key
);
182 /* removals are protected by direct items */
183 reiserfs_release_objectid(&th
, le32_to_cpu(key
->k_objectid
));
185 return journal_end(&th
);
189 static int reiserfs_quota_on_mount(struct super_block
*, int);
192 /* look for uncompleted unlinks and truncates and complete them */
193 static int finish_unfinished(struct super_block
*s
)
195 INITIALIZE_PATH(path
);
196 struct cpu_key max_cpu_key
, obj_key
;
197 struct reiserfs_key save_link_key
, last_inode_key
;
199 struct item_head
*ih
;
200 struct buffer_head
*bh
;
209 int quota_enabled
[MAXQUOTAS
];
212 /* compose key to look for "save" links */
213 max_cpu_key
.version
= KEY_FORMAT_3_5
;
214 max_cpu_key
.on_disk_key
.k_dir_id
= ~0U;
215 max_cpu_key
.on_disk_key
.k_objectid
= ~0U;
216 set_cpu_key_k_offset(&max_cpu_key
, ~0U);
217 max_cpu_key
.key_length
= 3;
219 memset(&last_inode_key
, 0, sizeof(last_inode_key
));
222 /* Needed for iput() to work correctly and not trash data */
223 if (s
->s_flags
& MS_ACTIVE
) {
227 s
->s_flags
|= MS_ACTIVE
;
229 /* Turn on quotas so that they are updated correctly */
230 for (i
= 0; i
< MAXQUOTAS
; i
++) {
231 quota_enabled
[i
] = 1;
232 if (REISERFS_SB(s
)->s_qf_names
[i
]) {
235 if (sb_has_quota_active(s
, i
)) {
236 quota_enabled
[i
] = 0;
239 ret
= reiserfs_quota_on_mount(s
, i
);
241 reiserfs_warning(s
, "reiserfs-2500",
242 "cannot turn on journaled "
243 "quota: error %d", ret
);
249 REISERFS_SB(s
)->s_is_unlinked_ok
= 1;
252 retval
= search_item(s
, &max_cpu_key
, &path
);
253 if (retval
!= ITEM_NOT_FOUND
) {
254 reiserfs_error(s
, "vs-2140",
255 "search_by_key returned %d", retval
);
259 bh
= get_last_bh(&path
);
260 item_pos
= get_item_pos(&path
);
261 if (item_pos
!= B_NR_ITEMS(bh
)) {
262 reiserfs_warning(s
, "vs-2060",
263 "wrong position found");
267 ih
= item_head(bh
, item_pos
);
269 if (le32_to_cpu(ih
->ih_key
.k_dir_id
) != MAX_KEY_OBJECTID
)
270 /* there are no "save" links anymore */
273 save_link_key
= ih
->ih_key
;
274 if (is_indirect_le_ih(ih
))
279 /* reiserfs_iget needs k_dirid and k_objectid only */
280 item
= ih_item_body(bh
, ih
);
281 obj_key
.on_disk_key
.k_dir_id
= le32_to_cpu(*(__le32
*) item
);
282 obj_key
.on_disk_key
.k_objectid
=
283 le32_to_cpu(ih
->ih_key
.k_objectid
);
284 obj_key
.on_disk_key
.k_offset
= 0;
285 obj_key
.on_disk_key
.k_type
= 0;
289 inode
= reiserfs_iget(s
, &obj_key
);
292 * the unlink almost completed, it just did not
293 * manage to remove "save" link and release objectid
295 reiserfs_warning(s
, "vs-2180", "iget failed for %K",
297 retval
= remove_save_link_only(s
, &save_link_key
, 1);
301 if (!truncate
&& inode
->i_nlink
) {
302 /* file is not unlinked */
303 reiserfs_warning(s
, "vs-2185",
304 "file %K is not unlinked",
306 retval
= remove_save_link_only(s
, &save_link_key
, 0);
309 depth
= reiserfs_write_unlock_nested(inode
->i_sb
);
310 dquot_initialize(inode
);
311 reiserfs_write_lock_nested(inode
->i_sb
, depth
);
313 if (truncate
&& S_ISDIR(inode
->i_mode
)) {
315 * We got a truncate request for a dir which
316 * is impossible. The only imaginable way is to
317 * execute unfinished truncate request then boot
318 * into old kernel, remove the file and create dir
321 reiserfs_warning(s
, "green-2101",
322 "impossible truncate on a "
323 "directory %k. Please report",
325 retval
= remove_save_link_only(s
, &save_link_key
, 0);
332 REISERFS_I(inode
)->i_flags
|=
333 i_link_saved_truncate_mask
;
335 * not completed truncate found. New size was
336 * committed together with "save" link
338 reiserfs_info(s
, "Truncating %k to %lld ..",
339 INODE_PKEY(inode
), inode
->i_size
);
341 /* don't update modification time */
342 reiserfs_truncate_file(inode
, 0);
344 retval
= remove_save_link(inode
, truncate
);
346 REISERFS_I(inode
)->i_flags
|= i_link_saved_unlink_mask
;
347 /* not completed unlink (rmdir) found */
348 reiserfs_info(s
, "Removing %k..", INODE_PKEY(inode
));
349 if (memcmp(&last_inode_key
, INODE_PKEY(inode
),
350 sizeof(last_inode_key
))){
351 last_inode_key
= *INODE_PKEY(inode
);
352 /* removal gets completed in iput */
355 reiserfs_warning(s
, "super-2189", "Dead loop "
356 "in finish_unfinished "
357 "detected, just remove "
359 retval
= remove_save_link_only(s
,
368 REISERFS_SB(s
)->s_is_unlinked_ok
= 0;
371 /* Turn quotas off */
372 reiserfs_write_unlock(s
);
373 for (i
= 0; i
< MAXQUOTAS
; i
++) {
374 if (sb_dqopt(s
)->files
[i
] && quota_enabled
[i
])
375 dquot_quota_off(s
, i
);
377 reiserfs_write_lock(s
);
379 /* Restore the flag back */
380 s
->s_flags
&= ~MS_ACTIVE
;
384 reiserfs_info(s
, "There were %d uncompleted unlinks/truncates. "
385 "Completed\n", done
);
390 * to protect file being unlinked from getting lost we "safe" link files
391 * being unlinked. This link will be deleted in the same transaction with last
392 * item of file. mounting the filesystem we scan all these links and remove
393 * files which almost got lost
395 void add_save_link(struct reiserfs_transaction_handle
*th
,
396 struct inode
*inode
, int truncate
)
398 INITIALIZE_PATH(path
);
404 BUG_ON(!th
->t_trans_id
);
406 /* file can only get one "save link" of each kind */
408 (REISERFS_I(inode
)->i_flags
& i_link_saved_truncate_mask
),
409 "saved link already exists for truncated inode %lx",
412 (REISERFS_I(inode
)->i_flags
& i_link_saved_unlink_mask
),
413 "saved link already exists for unlinked inode %lx",
416 /* setup key of "save" link */
417 key
.version
= KEY_FORMAT_3_5
;
418 key
.on_disk_key
.k_dir_id
= MAX_KEY_OBJECTID
;
419 key
.on_disk_key
.k_objectid
= inode
->i_ino
;
421 /* unlink, rmdir, rename */
422 set_cpu_key_k_offset(&key
, 1 + inode
->i_sb
->s_blocksize
);
423 set_cpu_key_k_type(&key
, TYPE_DIRECT
);
425 /* item head of "safe" link */
426 make_le_item_head(&ih
, &key
, key
.version
,
427 1 + inode
->i_sb
->s_blocksize
, TYPE_DIRECT
,
428 4 /*length */ , 0xffff /*free space */ );
431 if (S_ISDIR(inode
->i_mode
))
432 reiserfs_warning(inode
->i_sb
, "green-2102",
433 "Adding a truncate savelink for "
434 "a directory %k! Please report",
436 set_cpu_key_k_offset(&key
, 1);
437 set_cpu_key_k_type(&key
, TYPE_INDIRECT
);
439 /* item head of "safe" link */
440 make_le_item_head(&ih
, &key
, key
.version
, 1, TYPE_INDIRECT
,
441 4 /*length */ , 0 /*free space */ );
445 /* look for its place in the tree */
446 retval
= search_item(inode
->i_sb
, &key
, &path
);
447 if (retval
!= ITEM_NOT_FOUND
) {
448 if (retval
!= -ENOSPC
)
449 reiserfs_error(inode
->i_sb
, "vs-2100",
450 "search_by_key (%K) returned %d", &key
,
456 /* body of "save" link */
457 link
= INODE_PKEY(inode
)->k_dir_id
;
459 /* put "save" link into tree, don't charge quota to anyone */
461 reiserfs_insert_item(th
, &path
, &key
, &ih
, NULL
, (char *)&link
);
463 if (retval
!= -ENOSPC
)
464 reiserfs_error(inode
->i_sb
, "vs-2120",
465 "insert_item returned %d", retval
);
468 REISERFS_I(inode
)->i_flags
|=
469 i_link_saved_truncate_mask
;
471 REISERFS_I(inode
)->i_flags
|= i_link_saved_unlink_mask
;
475 /* this opens transaction unlike add_save_link */
476 int remove_save_link(struct inode
*inode
, int truncate
)
478 struct reiserfs_transaction_handle th
;
479 struct reiserfs_key key
;
482 /* we are going to do one balancing only */
483 err
= journal_begin(&th
, inode
->i_sb
, JOURNAL_PER_BALANCE_CNT
);
487 /* setup key of "save" link */
488 key
.k_dir_id
= cpu_to_le32(MAX_KEY_OBJECTID
);
489 key
.k_objectid
= INODE_PKEY(inode
)->k_objectid
;
491 /* unlink, rmdir, rename */
492 set_le_key_k_offset(KEY_FORMAT_3_5
, &key
,
493 1 + inode
->i_sb
->s_blocksize
);
494 set_le_key_k_type(KEY_FORMAT_3_5
, &key
, TYPE_DIRECT
);
497 set_le_key_k_offset(KEY_FORMAT_3_5
, &key
, 1);
498 set_le_key_k_type(KEY_FORMAT_3_5
, &key
, TYPE_INDIRECT
);
502 (REISERFS_I(inode
)->i_flags
& i_link_saved_truncate_mask
)) ||
504 (REISERFS_I(inode
)->i_flags
& i_link_saved_unlink_mask
)))
505 /* don't take quota bytes from anywhere */
506 reiserfs_delete_solid_item(&th
, NULL
, &key
);
508 reiserfs_release_objectid(&th
, inode
->i_ino
);
509 REISERFS_I(inode
)->i_flags
&= ~i_link_saved_unlink_mask
;
511 REISERFS_I(inode
)->i_flags
&= ~i_link_saved_truncate_mask
;
513 return journal_end(&th
);
516 static void reiserfs_kill_sb(struct super_block
*s
)
518 if (REISERFS_SB(s
)) {
519 reiserfs_proc_info_done(s
);
521 * Force any pending inode evictions to occur now. Any
522 * inodes to be removed that have extended attributes
523 * associated with them need to clean them up before
524 * we can release the extended attribute root dentries.
525 * shrink_dcache_for_umount will BUG if we don't release
526 * those before it's called so ->put_super is too late.
530 dput(REISERFS_SB(s
)->xattr_root
);
531 REISERFS_SB(s
)->xattr_root
= NULL
;
532 dput(REISERFS_SB(s
)->priv_root
);
533 REISERFS_SB(s
)->priv_root
= NULL
;
539 static void reiserfs_put_super(struct super_block
*s
)
541 struct reiserfs_transaction_handle th
;
544 dquot_disable(s
, -1, DQUOT_USAGE_ENABLED
| DQUOT_LIMITS_ENABLED
);
546 reiserfs_write_lock(s
);
549 * change file system state to current state if it was mounted
550 * with read-write permissions
552 if (!(s
->s_flags
& MS_RDONLY
)) {
553 if (!journal_begin(&th
, s
, 10)) {
554 reiserfs_prepare_for_journal(s
, SB_BUFFER_WITH_SB(s
),
556 set_sb_umount_state(SB_DISK_SUPER_BLOCK(s
),
557 REISERFS_SB(s
)->s_mount_state
);
558 journal_mark_dirty(&th
, SB_BUFFER_WITH_SB(s
));
563 * note, journal_release checks for readonly mount, and can
564 * decide not to do a journal_end
566 journal_release(&th
, s
);
568 reiserfs_free_bitmap_cache(s
);
570 brelse(SB_BUFFER_WITH_SB(s
));
574 if (REISERFS_SB(s
)->reserved_blocks
!= 0) {
575 reiserfs_warning(s
, "green-2005", "reserved blocks left %d",
576 REISERFS_SB(s
)->reserved_blocks
);
579 reiserfs_write_unlock(s
);
580 mutex_destroy(&REISERFS_SB(s
)->lock
);
581 destroy_workqueue(REISERFS_SB(s
)->commit_wq
);
586 static struct kmem_cache
*reiserfs_inode_cachep
;
588 static struct inode
*reiserfs_alloc_inode(struct super_block
*sb
)
590 struct reiserfs_inode_info
*ei
;
591 ei
= (struct reiserfs_inode_info
*)
592 kmem_cache_alloc(reiserfs_inode_cachep
, GFP_KERNEL
);
595 atomic_set(&ei
->openers
, 0);
596 mutex_init(&ei
->tailpack
);
597 return &ei
->vfs_inode
;
600 static void reiserfs_i_callback(struct rcu_head
*head
)
602 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
603 kmem_cache_free(reiserfs_inode_cachep
, REISERFS_I(inode
));
606 static void reiserfs_destroy_inode(struct inode
*inode
)
608 call_rcu(&inode
->i_rcu
, reiserfs_i_callback
);
611 static void init_once(void *foo
)
613 struct reiserfs_inode_info
*ei
= (struct reiserfs_inode_info
*)foo
;
615 INIT_LIST_HEAD(&ei
->i_prealloc_list
);
616 inode_init_once(&ei
->vfs_inode
);
619 static int __init
init_inodecache(void)
621 reiserfs_inode_cachep
= kmem_cache_create("reiser_inode_cache",
623 reiserfs_inode_info
),
624 0, (SLAB_RECLAIM_ACCOUNT
|
627 if (reiserfs_inode_cachep
== NULL
)
632 static void destroy_inodecache(void)
635 * Make sure all delayed rcu free inodes are flushed before we
639 kmem_cache_destroy(reiserfs_inode_cachep
);
642 /* we don't mark inodes dirty, we just log them */
643 static void reiserfs_dirty_inode(struct inode
*inode
, int flags
)
645 struct reiserfs_transaction_handle th
;
649 if (inode
->i_sb
->s_flags
& MS_RDONLY
) {
650 reiserfs_warning(inode
->i_sb
, "clm-6006",
651 "writing inode %lu on readonly FS",
655 reiserfs_write_lock(inode
->i_sb
);
658 * this is really only used for atime updates, so they don't have
659 * to be included in O_SYNC or fsync
661 err
= journal_begin(&th
, inode
->i_sb
, 1);
665 reiserfs_update_sd(&th
, inode
);
669 reiserfs_write_unlock(inode
->i_sb
);
672 static int reiserfs_show_options(struct seq_file
*seq
, struct dentry
*root
)
674 struct super_block
*s
= root
->d_sb
;
675 struct reiserfs_journal
*journal
= SB_JOURNAL(s
);
676 long opts
= REISERFS_SB(s
)->s_mount_opt
;
678 if (opts
& (1 << REISERFS_LARGETAIL
))
679 seq_puts(seq
, ",tails=on");
680 else if (!(opts
& (1 << REISERFS_SMALLTAIL
)))
681 seq_puts(seq
, ",notail");
682 /* tails=small is default so we don't show it */
684 if (!(opts
& (1 << REISERFS_BARRIER_FLUSH
)))
685 seq_puts(seq
, ",barrier=none");
686 /* barrier=flush is default so we don't show it */
688 if (opts
& (1 << REISERFS_ERROR_CONTINUE
))
689 seq_puts(seq
, ",errors=continue");
690 else if (opts
& (1 << REISERFS_ERROR_PANIC
))
691 seq_puts(seq
, ",errors=panic");
692 /* errors=ro is default so we don't show it */
694 if (opts
& (1 << REISERFS_DATA_LOG
))
695 seq_puts(seq
, ",data=journal");
696 else if (opts
& (1 << REISERFS_DATA_WRITEBACK
))
697 seq_puts(seq
, ",data=writeback");
698 /* data=ordered is default so we don't show it */
700 if (opts
& (1 << REISERFS_ATTRS
))
701 seq_puts(seq
, ",attrs");
703 if (opts
& (1 << REISERFS_XATTRS_USER
))
704 seq_puts(seq
, ",user_xattr");
706 if (opts
& (1 << REISERFS_EXPOSE_PRIVROOT
))
707 seq_puts(seq
, ",expose_privroot");
709 if (opts
& (1 << REISERFS_POSIXACL
))
710 seq_puts(seq
, ",acl");
712 if (REISERFS_SB(s
)->s_jdev
)
713 seq_printf(seq
, ",jdev=%s", REISERFS_SB(s
)->s_jdev
);
715 if (journal
->j_max_commit_age
!= journal
->j_default_max_commit_age
)
716 seq_printf(seq
, ",commit=%d", journal
->j_max_commit_age
);
719 if (REISERFS_SB(s
)->s_qf_names
[USRQUOTA
])
720 seq_printf(seq
, ",usrjquota=%s", REISERFS_SB(s
)->s_qf_names
[USRQUOTA
]);
721 else if (opts
& (1 << REISERFS_USRQUOTA
))
722 seq_puts(seq
, ",usrquota");
723 if (REISERFS_SB(s
)->s_qf_names
[GRPQUOTA
])
724 seq_printf(seq
, ",grpjquota=%s", REISERFS_SB(s
)->s_qf_names
[GRPQUOTA
]);
725 else if (opts
& (1 << REISERFS_GRPQUOTA
))
726 seq_puts(seq
, ",grpquota");
727 if (REISERFS_SB(s
)->s_jquota_fmt
) {
728 if (REISERFS_SB(s
)->s_jquota_fmt
== QFMT_VFS_OLD
)
729 seq_puts(seq
, ",jqfmt=vfsold");
730 else if (REISERFS_SB(s
)->s_jquota_fmt
== QFMT_VFS_V0
)
731 seq_puts(seq
, ",jqfmt=vfsv0");
735 /* Block allocator options */
736 if (opts
& (1 << REISERFS_NO_BORDER
))
737 seq_puts(seq
, ",block-allocator=noborder");
738 if (opts
& (1 << REISERFS_NO_UNHASHED_RELOCATION
))
739 seq_puts(seq
, ",block-allocator=no_unhashed_relocation");
740 if (opts
& (1 << REISERFS_HASHED_RELOCATION
))
741 seq_puts(seq
, ",block-allocator=hashed_relocation");
742 if (opts
& (1 << REISERFS_TEST4
))
743 seq_puts(seq
, ",block-allocator=test4");
744 show_alloc_options(seq
, s
);
749 static ssize_t
reiserfs_quota_write(struct super_block
*, int, const char *,
751 static ssize_t
reiserfs_quota_read(struct super_block
*, int, char *, size_t,
755 static const struct super_operations reiserfs_sops
= {
756 .alloc_inode
= reiserfs_alloc_inode
,
757 .destroy_inode
= reiserfs_destroy_inode
,
758 .write_inode
= reiserfs_write_inode
,
759 .dirty_inode
= reiserfs_dirty_inode
,
760 .evict_inode
= reiserfs_evict_inode
,
761 .put_super
= reiserfs_put_super
,
762 .sync_fs
= reiserfs_sync_fs
,
763 .freeze_fs
= reiserfs_freeze
,
764 .unfreeze_fs
= reiserfs_unfreeze
,
765 .statfs
= reiserfs_statfs
,
766 .remount_fs
= reiserfs_remount
,
767 .show_options
= reiserfs_show_options
,
769 .quota_read
= reiserfs_quota_read
,
770 .quota_write
= reiserfs_quota_write
,
775 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
777 static int reiserfs_write_dquot(struct dquot
*);
778 static int reiserfs_acquire_dquot(struct dquot
*);
779 static int reiserfs_release_dquot(struct dquot
*);
780 static int reiserfs_mark_dquot_dirty(struct dquot
*);
781 static int reiserfs_write_info(struct super_block
*, int);
782 static int reiserfs_quota_on(struct super_block
*, int, int, struct path
*);
784 static const struct dquot_operations reiserfs_quota_operations
= {
785 .write_dquot
= reiserfs_write_dquot
,
786 .acquire_dquot
= reiserfs_acquire_dquot
,
787 .release_dquot
= reiserfs_release_dquot
,
788 .mark_dirty
= reiserfs_mark_dquot_dirty
,
789 .write_info
= reiserfs_write_info
,
790 .alloc_dquot
= dquot_alloc
,
791 .destroy_dquot
= dquot_destroy
,
794 static const struct quotactl_ops reiserfs_qctl_operations
= {
795 .quota_on
= reiserfs_quota_on
,
796 .quota_off
= dquot_quota_off
,
797 .quota_sync
= dquot_quota_sync
,
798 .get_info
= dquot_get_dqinfo
,
799 .set_info
= dquot_set_dqinfo
,
800 .get_dqblk
= dquot_get_dqblk
,
801 .set_dqblk
= dquot_set_dqblk
,
805 static const struct export_operations reiserfs_export_ops
= {
806 .encode_fh
= reiserfs_encode_fh
,
807 .fh_to_dentry
= reiserfs_fh_to_dentry
,
808 .fh_to_parent
= reiserfs_fh_to_parent
,
809 .get_parent
= reiserfs_get_parent
,
813 * this struct is used in reiserfs_getopt () for containing the value for
814 * those mount options that have values rather than being toggles.
819 * bitmask which is to set on mount_options bitmask
820 * when this value is found, 0 is no bits are to be changed.
824 * bitmask which is to clear on mount_options bitmask
825 * when this value is found, 0 is no bits are to be changed.
826 * This is applied BEFORE setmask
831 /* Set this bit in arg_required to allow empty arguments */
832 #define REISERFS_OPT_ALLOWEMPTY 31
835 * this struct is used in reiserfs_getopt() for describing the
836 * set of reiserfs mount options
841 /* 0 if argument is not required, not 0 otherwise */
844 /* list of values accepted by an option */
845 const arg_desc_t
*values
;
848 * bitmask which is to set on mount_options bitmask
849 * when this value is found, 0 is no bits are to be changed.
854 * bitmask which is to clear on mount_options bitmask
855 * when this value is found, 0 is no bits are to be changed.
856 * This is applied BEFORE setmask
861 /* possible values for -o data= */
862 static const arg_desc_t logging_mode
[] = {
863 {"ordered", 1 << REISERFS_DATA_ORDERED
,
864 (1 << REISERFS_DATA_LOG
| 1 << REISERFS_DATA_WRITEBACK
)},
865 {"journal", 1 << REISERFS_DATA_LOG
,
866 (1 << REISERFS_DATA_ORDERED
| 1 << REISERFS_DATA_WRITEBACK
)},
867 {"writeback", 1 << REISERFS_DATA_WRITEBACK
,
868 (1 << REISERFS_DATA_ORDERED
| 1 << REISERFS_DATA_LOG
)},
872 /* possible values for -o barrier= */
873 static const arg_desc_t barrier_mode
[] = {
874 {"none", 1 << REISERFS_BARRIER_NONE
, 1 << REISERFS_BARRIER_FLUSH
},
875 {"flush", 1 << REISERFS_BARRIER_FLUSH
, 1 << REISERFS_BARRIER_NONE
},
880 * possible values for "-o block-allocator=" and bits which are to be set in
881 * s_mount_opt of reiserfs specific part of in-core super block
883 static const arg_desc_t balloc
[] = {
884 {"noborder", 1 << REISERFS_NO_BORDER
, 0},
885 {"border", 0, 1 << REISERFS_NO_BORDER
},
886 {"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION
, 0},
887 {"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION
, 0},
888 {"test4", 1 << REISERFS_TEST4
, 0},
889 {"notest4", 0, 1 << REISERFS_TEST4
},
893 static const arg_desc_t tails
[] = {
894 {"on", 1 << REISERFS_LARGETAIL
, 1 << REISERFS_SMALLTAIL
},
895 {"off", 0, (1 << REISERFS_LARGETAIL
) | (1 << REISERFS_SMALLTAIL
)},
896 {"small", 1 << REISERFS_SMALLTAIL
, 1 << REISERFS_LARGETAIL
},
900 static const arg_desc_t error_actions
[] = {
901 {"panic", 1 << REISERFS_ERROR_PANIC
,
902 (1 << REISERFS_ERROR_RO
| 1 << REISERFS_ERROR_CONTINUE
)},
903 {"ro-remount", 1 << REISERFS_ERROR_RO
,
904 (1 << REISERFS_ERROR_PANIC
| 1 << REISERFS_ERROR_CONTINUE
)},
905 #ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
906 {"continue", 1 << REISERFS_ERROR_CONTINUE
,
907 (1 << REISERFS_ERROR_PANIC
| 1 << REISERFS_ERROR_RO
)},
913 * proceed only one option from a list *cur - string containing of mount
915 * opts - array of options which are accepted
916 * opt_arg - if option is found and requires an argument and if it is specifed
917 * in the input - pointer to the argument is stored here
918 * bit_flags - if option requires to set a certain bit - it is set here
919 * return -1 if unknown option is found, opt->arg_required otherwise
921 static int reiserfs_getopt(struct super_block
*s
, char **cur
, opt_desc_t
* opts
,
922 char **opt_arg
, unsigned long *bit_flags
)
932 const opt_desc_t
*opt
;
933 const arg_desc_t
*arg
;
937 /* assume argument cannot contain commas */
938 *cur
= strchr(p
, ',');
944 if (!strncmp(p
, "alloc=", 6)) {
946 * Ugly special case, probably we should redo options
947 * parser so that it can understand several arguments for
948 * some options, also so that it can fill several bitfields
949 * with option values.
951 if (reiserfs_parse_alloc_options(s
, p
+ 6)) {
958 /* for every option in the list */
959 for (opt
= opts
; opt
->option_name
; opt
++) {
960 if (!strncmp(p
, opt
->option_name
, strlen(opt
->option_name
))) {
963 (1 << REISERFS_UNSUPPORTED_OPT
))
964 reiserfs_warning(s
, "super-6500",
965 "%s not supported.\n",
968 *bit_flags
&= ~opt
->clrmask
;
970 (1 << REISERFS_UNSUPPORTED_OPT
))
971 reiserfs_warning(s
, "super-6501",
972 "%s not supported.\n",
975 *bit_flags
|= opt
->setmask
;
980 if (!opt
->option_name
) {
981 reiserfs_warning(s
, "super-6502",
982 "unknown mount option \"%s\"", p
);
986 p
+= strlen(opt
->option_name
);
989 if (!opt
->arg_required
) {
990 reiserfs_warning(s
, "super-6503",
991 "the option \"%s\" does not "
992 "require an argument\n",
999 if (opt
->arg_required
) {
1000 reiserfs_warning(s
, "super-6504",
1001 "the option \"%s\" requires an "
1002 "argument\n", opt
->option_name
);
1007 reiserfs_warning(s
, "super-6505",
1008 "head of option \"%s\" is only correct\n",
1014 * move to the argument, or to next option if argument is not
1019 if (opt
->arg_required
1020 && !(opt
->arg_required
& (1 << REISERFS_OPT_ALLOWEMPTY
))
1022 /* this catches "option=," if not allowed */
1023 reiserfs_warning(s
, "super-6506",
1024 "empty argument for \"%s\"\n",
1030 /* *=NULLopt_arg contains pointer to argument */
1032 return opt
->arg_required
& ~(1 << REISERFS_OPT_ALLOWEMPTY
);
1035 /* values possible for this option are listed in opt->values */
1036 for (arg
= opt
->values
; arg
->value
; arg
++) {
1037 if (!strcmp(p
, arg
->value
)) {
1039 *bit_flags
&= ~arg
->clrmask
;
1040 *bit_flags
|= arg
->setmask
;
1042 return opt
->arg_required
;
1046 reiserfs_warning(s
, "super-6506",
1047 "bad value \"%s\" for option \"%s\"\n", p
,
1052 /* returns 0 if something is wrong in option string, 1 - otherwise */
1053 static int reiserfs_parse_options(struct super_block
*s
,
1055 /* string given via mount's -o */
1059 * after the parsing phase, contains the
1060 * collection of bitflags defining what
1061 * mount options were selected.
1063 unsigned long *mount_options
,
1065 /* strtol-ed from NNN of resize=NNN */
1066 unsigned long *blocks
,
1068 unsigned int *commit_max_age
,
1075 opt_desc_t opts
[] = {
1077 * Compatibility stuff, so that -o notail for old
1080 {"tails",.arg_required
= 't',.values
= tails
},
1081 {"notail",.clrmask
=
1082 (1 << REISERFS_LARGETAIL
) | (1 << REISERFS_SMALLTAIL
)},
1083 {"conv",.setmask
= 1 << REISERFS_CONVERT
},
1084 {"attrs",.setmask
= 1 << REISERFS_ATTRS
},
1085 {"noattrs",.clrmask
= 1 << REISERFS_ATTRS
},
1086 {"expose_privroot", .setmask
= 1 << REISERFS_EXPOSE_PRIVROOT
},
1087 #ifdef CONFIG_REISERFS_FS_XATTR
1088 {"user_xattr",.setmask
= 1 << REISERFS_XATTRS_USER
},
1089 {"nouser_xattr",.clrmask
= 1 << REISERFS_XATTRS_USER
},
1091 {"user_xattr",.setmask
= 1 << REISERFS_UNSUPPORTED_OPT
},
1092 {"nouser_xattr",.clrmask
= 1 << REISERFS_UNSUPPORTED_OPT
},
1094 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1095 {"acl",.setmask
= 1 << REISERFS_POSIXACL
},
1096 {"noacl",.clrmask
= 1 << REISERFS_POSIXACL
},
1098 {"acl",.setmask
= 1 << REISERFS_UNSUPPORTED_OPT
},
1099 {"noacl",.clrmask
= 1 << REISERFS_UNSUPPORTED_OPT
},
1101 {.option_name
= "nolog"},
1102 {"replayonly",.setmask
= 1 << REPLAYONLY
},
1103 {"block-allocator",.arg_required
= 'a',.values
= balloc
},
1104 {"data",.arg_required
= 'd',.values
= logging_mode
},
1105 {"barrier",.arg_required
= 'b',.values
= barrier_mode
},
1106 {"resize",.arg_required
= 'r',.values
= NULL
},
1107 {"jdev",.arg_required
= 'j',.values
= NULL
},
1108 {"nolargeio",.arg_required
= 'w',.values
= NULL
},
1109 {"commit",.arg_required
= 'c',.values
= NULL
},
1110 {"usrquota",.setmask
= 1 << REISERFS_USRQUOTA
},
1111 {"grpquota",.setmask
= 1 << REISERFS_GRPQUOTA
},
1112 {"noquota",.clrmask
= 1 << REISERFS_USRQUOTA
| 1 << REISERFS_GRPQUOTA
},
1113 {"errors",.arg_required
= 'e',.values
= error_actions
},
1114 {"usrjquota",.arg_required
=
1115 'u' | (1 << REISERFS_OPT_ALLOWEMPTY
),.values
= NULL
},
1116 {"grpjquota",.arg_required
=
1117 'g' | (1 << REISERFS_OPT_ALLOWEMPTY
),.values
= NULL
},
1118 {"jqfmt",.arg_required
= 'f',.values
= NULL
},
1119 {.option_name
= NULL
}
1123 if (!options
|| !*options
)
1125 * use default configuration: create tails, journaling on, no
1126 * conversion to newest format
1130 for (pos
= options
; pos
;) {
1131 c
= reiserfs_getopt(s
, &pos
, opts
, &arg
, mount_options
);
1133 /* wrong option is given */
1140 /* "resize=NNN" or "resize=auto" */
1142 if (!strcmp(arg
, "auto")) {
1143 /* From JFS code, to auto-get the size. */
1145 s
->s_bdev
->bd_inode
->i_size
>> s
->
1148 *blocks
= simple_strtoul(arg
, &p
, 0);
1150 /* NNN does not look like a number */
1151 reiserfs_warning(s
, "super-6507",
1161 unsigned long val
= simple_strtoul(arg
, &p
, 0);
1162 /* commit=NNN (time in seconds) */
1163 if (*p
!= '\0' || val
>= (unsigned int)-1) {
1164 reiserfs_warning(s
, "super-6508",
1165 "bad value %s for -ocommit\n",
1169 *commit_max_age
= (unsigned int)val
;
1173 reiserfs_warning(s
, "super-6509", "nolargeio option "
1174 "is no longer supported");
1179 if (arg
&& *arg
&& jdev_name
) {
1180 /* Hm, already assigned? */
1182 reiserfs_warning(s
, "super-6510",
1183 "journal device was "
1184 "already specified to "
1185 "be %s", *jdev_name
);
1192 if (c
== 'u' || c
== 'g') {
1193 int qtype
= c
== 'u' ? USRQUOTA
: GRPQUOTA
;
1195 if (sb_any_quota_loaded(s
) &&
1196 (!*arg
!= !REISERFS_SB(s
)->s_qf_names
[qtype
])) {
1197 reiserfs_warning(s
, "super-6511",
1198 "cannot change journaled "
1199 "quota options when quota "
1203 if (*arg
) { /* Some filename specified? */
1204 if (REISERFS_SB(s
)->s_qf_names
[qtype
]
1205 && strcmp(REISERFS_SB(s
)->s_qf_names
[qtype
],
1207 reiserfs_warning(s
, "super-6512",
1209 "already specified.",
1213 if (strchr(arg
, '/')) {
1214 reiserfs_warning(s
, "super-6513",
1215 "quotafile must be "
1216 "on filesystem root.");
1219 qf_names
[qtype
] = kstrdup(arg
, GFP_KERNEL
);
1220 if (!qf_names
[qtype
]) {
1221 reiserfs_warning(s
, "reiserfs-2502",
1222 "not enough memory "
1227 if (qtype
== USRQUOTA
)
1228 *mount_options
|= 1 << REISERFS_USRQUOTA
;
1230 *mount_options
|= 1 << REISERFS_GRPQUOTA
;
1232 if (qf_names
[qtype
] !=
1233 REISERFS_SB(s
)->s_qf_names
[qtype
])
1234 kfree(qf_names
[qtype
]);
1235 qf_names
[qtype
] = NULL
;
1236 if (qtype
== USRQUOTA
)
1237 *mount_options
&= ~(1 << REISERFS_USRQUOTA
);
1239 *mount_options
&= ~(1 << REISERFS_GRPQUOTA
);
1243 if (!strcmp(arg
, "vfsold"))
1244 *qfmt
= QFMT_VFS_OLD
;
1245 else if (!strcmp(arg
, "vfsv0"))
1246 *qfmt
= QFMT_VFS_V0
;
1248 reiserfs_warning(s
, "super-6514",
1249 "unknown quota format "
1253 if (sb_any_quota_loaded(s
) &&
1254 *qfmt
!= REISERFS_SB(s
)->s_jquota_fmt
) {
1255 reiserfs_warning(s
, "super-6515",
1256 "cannot change journaled "
1257 "quota options when quota "
1263 if (c
== 'u' || c
== 'g' || c
== 'f') {
1264 reiserfs_warning(s
, "reiserfs-2503", "journaled "
1265 "quota options not supported.");
1272 if (!REISERFS_SB(s
)->s_jquota_fmt
&& !*qfmt
1273 && (qf_names
[USRQUOTA
] || qf_names
[GRPQUOTA
])) {
1274 reiserfs_warning(s
, "super-6515",
1275 "journaled quota format not specified.");
1278 if ((!(*mount_options
& (1 << REISERFS_USRQUOTA
)) &&
1279 sb_has_quota_loaded(s
, USRQUOTA
)) ||
1280 (!(*mount_options
& (1 << REISERFS_GRPQUOTA
)) &&
1281 sb_has_quota_loaded(s
, GRPQUOTA
))) {
1282 reiserfs_warning(s
, "super-6516", "quota options must "
1283 "be present when quota is turned on.");
1291 static void switch_data_mode(struct super_block
*s
, unsigned long mode
)
1293 REISERFS_SB(s
)->s_mount_opt
&= ~((1 << REISERFS_DATA_LOG
) |
1294 (1 << REISERFS_DATA_ORDERED
) |
1295 (1 << REISERFS_DATA_WRITEBACK
));
1296 REISERFS_SB(s
)->s_mount_opt
|= (1 << mode
);
1299 static void handle_data_mode(struct super_block
*s
, unsigned long mount_options
)
1301 if (mount_options
& (1 << REISERFS_DATA_LOG
)) {
1302 if (!reiserfs_data_log(s
)) {
1303 switch_data_mode(s
, REISERFS_DATA_LOG
);
1304 reiserfs_info(s
, "switching to journaled data mode\n");
1306 } else if (mount_options
& (1 << REISERFS_DATA_ORDERED
)) {
1307 if (!reiserfs_data_ordered(s
)) {
1308 switch_data_mode(s
, REISERFS_DATA_ORDERED
);
1309 reiserfs_info(s
, "switching to ordered data mode\n");
1311 } else if (mount_options
& (1 << REISERFS_DATA_WRITEBACK
)) {
1312 if (!reiserfs_data_writeback(s
)) {
1313 switch_data_mode(s
, REISERFS_DATA_WRITEBACK
);
1314 reiserfs_info(s
, "switching to writeback data mode\n");
1319 static void handle_barrier_mode(struct super_block
*s
, unsigned long bits
)
1321 int flush
= (1 << REISERFS_BARRIER_FLUSH
);
1322 int none
= (1 << REISERFS_BARRIER_NONE
);
1323 int all_barrier
= flush
| none
;
1325 if (bits
& all_barrier
) {
1326 REISERFS_SB(s
)->s_mount_opt
&= ~all_barrier
;
1328 REISERFS_SB(s
)->s_mount_opt
|= flush
;
1329 printk("reiserfs: enabling write barrier flush mode\n");
1330 } else if (bits
& none
) {
1331 REISERFS_SB(s
)->s_mount_opt
|= none
;
1332 printk("reiserfs: write barriers turned off\n");
1337 static void handle_attrs(struct super_block
*s
)
1339 struct reiserfs_super_block
*rs
= SB_DISK_SUPER_BLOCK(s
);
1341 if (reiserfs_attrs(s
)) {
1342 if (old_format_only(s
)) {
1343 reiserfs_warning(s
, "super-6517", "cannot support "
1344 "attributes on 3.5.x disk format");
1345 REISERFS_SB(s
)->s_mount_opt
&= ~(1 << REISERFS_ATTRS
);
1348 if (!(le32_to_cpu(rs
->s_flags
) & reiserfs_attrs_cleared
)) {
1349 reiserfs_warning(s
, "super-6518", "cannot support "
1350 "attributes until flag is set in "
1352 REISERFS_SB(s
)->s_mount_opt
&= ~(1 << REISERFS_ATTRS
);
1358 static void handle_quota_files(struct super_block
*s
, char **qf_names
,
1363 for (i
= 0; i
< MAXQUOTAS
; i
++) {
1364 if (qf_names
[i
] != REISERFS_SB(s
)->s_qf_names
[i
])
1365 kfree(REISERFS_SB(s
)->s_qf_names
[i
]);
1366 REISERFS_SB(s
)->s_qf_names
[i
] = qf_names
[i
];
1369 REISERFS_SB(s
)->s_jquota_fmt
= *qfmt
;
1373 static int reiserfs_remount(struct super_block
*s
, int *mount_flags
, char *arg
)
1375 struct reiserfs_super_block
*rs
;
1376 struct reiserfs_transaction_handle th
;
1377 unsigned long blocks
;
1378 unsigned long mount_options
= REISERFS_SB(s
)->s_mount_opt
;
1379 unsigned long safe_mask
= 0;
1380 unsigned int commit_max_age
= (unsigned int)-1;
1381 struct reiserfs_journal
*journal
= SB_JOURNAL(s
);
1382 char *new_opts
= kstrdup(arg
, GFP_KERNEL
);
1384 char *qf_names
[MAXQUOTAS
];
1385 unsigned int qfmt
= 0;
1391 reiserfs_write_lock(s
);
1394 memcpy(qf_names
, REISERFS_SB(s
)->s_qf_names
, sizeof(qf_names
));
1397 rs
= SB_DISK_SUPER_BLOCK(s
);
1399 if (!reiserfs_parse_options
1400 (s
, arg
, &mount_options
, &blocks
, NULL
, &commit_max_age
,
1403 for (i
= 0; i
< MAXQUOTAS
; i
++)
1404 if (qf_names
[i
] != REISERFS_SB(s
)->s_qf_names
[i
])
1408 goto out_err_unlock
;
1411 handle_quota_files(s
, qf_names
, &qfmt
);
1416 /* Add options that are safe here */
1417 safe_mask
|= 1 << REISERFS_SMALLTAIL
;
1418 safe_mask
|= 1 << REISERFS_LARGETAIL
;
1419 safe_mask
|= 1 << REISERFS_NO_BORDER
;
1420 safe_mask
|= 1 << REISERFS_NO_UNHASHED_RELOCATION
;
1421 safe_mask
|= 1 << REISERFS_HASHED_RELOCATION
;
1422 safe_mask
|= 1 << REISERFS_TEST4
;
1423 safe_mask
|= 1 << REISERFS_ATTRS
;
1424 safe_mask
|= 1 << REISERFS_XATTRS_USER
;
1425 safe_mask
|= 1 << REISERFS_POSIXACL
;
1426 safe_mask
|= 1 << REISERFS_BARRIER_FLUSH
;
1427 safe_mask
|= 1 << REISERFS_BARRIER_NONE
;
1428 safe_mask
|= 1 << REISERFS_ERROR_RO
;
1429 safe_mask
|= 1 << REISERFS_ERROR_CONTINUE
;
1430 safe_mask
|= 1 << REISERFS_ERROR_PANIC
;
1431 safe_mask
|= 1 << REISERFS_USRQUOTA
;
1432 safe_mask
|= 1 << REISERFS_GRPQUOTA
;
1435 * Update the bitmask, taking care to keep
1436 * the bits we're not allowed to change here
1438 REISERFS_SB(s
)->s_mount_opt
=
1440 s_mount_opt
& ~safe_mask
) | (mount_options
& safe_mask
);
1442 if (commit_max_age
!= 0 && commit_max_age
!= (unsigned int)-1) {
1443 journal
->j_max_commit_age
= commit_max_age
;
1444 journal
->j_max_trans_age
= commit_max_age
;
1445 } else if (commit_max_age
== 0) {
1446 /* 0 means restore defaults. */
1447 journal
->j_max_commit_age
= journal
->j_default_max_commit_age
;
1448 journal
->j_max_trans_age
= JOURNAL_MAX_TRANS_AGE
;
1452 err
= reiserfs_resize(s
, blocks
);
1454 goto out_err_unlock
;
1457 if (*mount_flags
& MS_RDONLY
) {
1458 reiserfs_write_unlock(s
);
1459 reiserfs_xattr_init(s
, *mount_flags
);
1460 /* remount read-only */
1461 if (s
->s_flags
& MS_RDONLY
)
1462 /* it is read-only already */
1463 goto out_ok_unlocked
;
1465 err
= dquot_suspend(s
, -1);
1469 /* try to remount file system with read-only permissions */
1470 if (sb_umount_state(rs
) == REISERFS_VALID_FS
1471 || REISERFS_SB(s
)->s_mount_state
!= REISERFS_VALID_FS
) {
1472 goto out_ok_unlocked
;
1475 reiserfs_write_lock(s
);
1477 err
= journal_begin(&th
, s
, 10);
1479 goto out_err_unlock
;
1481 /* Mounting a rw partition read-only. */
1482 reiserfs_prepare_for_journal(s
, SB_BUFFER_WITH_SB(s
), 1);
1483 set_sb_umount_state(rs
, REISERFS_SB(s
)->s_mount_state
);
1484 journal_mark_dirty(&th
, SB_BUFFER_WITH_SB(s
));
1486 /* remount read-write */
1487 if (!(s
->s_flags
& MS_RDONLY
)) {
1488 reiserfs_write_unlock(s
);
1489 reiserfs_xattr_init(s
, *mount_flags
);
1490 goto out_ok_unlocked
; /* We are read-write already */
1493 if (reiserfs_is_journal_aborted(journal
)) {
1494 err
= journal
->j_errno
;
1495 goto out_err_unlock
;
1498 handle_data_mode(s
, mount_options
);
1499 handle_barrier_mode(s
, mount_options
);
1500 REISERFS_SB(s
)->s_mount_state
= sb_umount_state(rs
);
1502 /* now it is safe to call journal_begin */
1503 s
->s_flags
&= ~MS_RDONLY
;
1504 err
= journal_begin(&th
, s
, 10);
1506 goto out_err_unlock
;
1508 /* Mount a partition which is read-only, read-write */
1509 reiserfs_prepare_for_journal(s
, SB_BUFFER_WITH_SB(s
), 1);
1510 REISERFS_SB(s
)->s_mount_state
= sb_umount_state(rs
);
1511 s
->s_flags
&= ~MS_RDONLY
;
1512 set_sb_umount_state(rs
, REISERFS_ERROR_FS
);
1513 if (!old_format_only(s
))
1514 set_sb_mnt_count(rs
, sb_mnt_count(rs
) + 1);
1515 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1516 journal_mark_dirty(&th
, SB_BUFFER_WITH_SB(s
));
1517 REISERFS_SB(s
)->s_mount_state
= REISERFS_VALID_FS
;
1519 /* this will force a full flush of all journal lists */
1520 SB_JOURNAL(s
)->j_must_wait
= 1;
1521 err
= journal_end(&th
);
1523 goto out_err_unlock
;
1525 reiserfs_write_unlock(s
);
1526 if (!(*mount_flags
& MS_RDONLY
)) {
1527 dquot_resume(s
, -1);
1528 reiserfs_write_lock(s
);
1529 finish_unfinished(s
);
1530 reiserfs_write_unlock(s
);
1531 reiserfs_xattr_init(s
, *mount_flags
);
1535 replace_mount_options(s
, new_opts
);
1539 reiserfs_write_unlock(s
);
1545 static int read_super_block(struct super_block
*s
, int offset
)
1547 struct buffer_head
*bh
;
1548 struct reiserfs_super_block
*rs
;
1551 bh
= sb_bread(s
, offset
/ s
->s_blocksize
);
1553 reiserfs_warning(s
, "sh-2006",
1554 "bread failed (dev %s, block %lu, size %lu)",
1555 s
->s_id
, offset
/ s
->s_blocksize
,
1560 rs
= (struct reiserfs_super_block
*)bh
->b_data
;
1561 if (!is_any_reiserfs_magic_string(rs
)) {
1566 * ok, reiserfs signature (old or new) found in at the given offset
1568 fs_blocksize
= sb_blocksize(rs
);
1570 sb_set_blocksize(s
, fs_blocksize
);
1572 bh
= sb_bread(s
, offset
/ s
->s_blocksize
);
1574 reiserfs_warning(s
, "sh-2007",
1575 "bread failed (dev %s, block %lu, size %lu)",
1576 s
->s_id
, offset
/ s
->s_blocksize
,
1581 rs
= (struct reiserfs_super_block
*)bh
->b_data
;
1582 if (sb_blocksize(rs
) != s
->s_blocksize
) {
1583 reiserfs_warning(s
, "sh-2011", "can't find a reiserfs "
1584 "filesystem on (dev %s, block %llu, size %lu)",
1586 (unsigned long long)bh
->b_blocknr
,
1592 if (rs
->s_v1
.s_root_block
== cpu_to_le32(-1)) {
1594 reiserfs_warning(s
, "super-6519", "Unfinished reiserfsck "
1595 "--rebuild-tree run detected. Please run\n"
1596 "reiserfsck --rebuild-tree and wait for a "
1597 "completion. If that fails\n"
1598 "get newer reiserfsprogs package");
1602 SB_BUFFER_WITH_SB(s
) = bh
;
1603 SB_DISK_SUPER_BLOCK(s
) = rs
;
1606 * magic is of non-standard journal filesystem, look at s_version to
1607 * find which format is in use
1609 if (is_reiserfs_jr(rs
)) {
1610 if (sb_version(rs
) == REISERFS_VERSION_2
)
1611 reiserfs_info(s
, "found reiserfs format \"3.6\""
1612 " with non-standard journal\n");
1613 else if (sb_version(rs
) == REISERFS_VERSION_1
)
1614 reiserfs_info(s
, "found reiserfs format \"3.5\""
1615 " with non-standard journal\n");
1617 reiserfs_warning(s
, "sh-2012", "found unknown "
1618 "format \"%u\" of reiserfs with "
1619 "non-standard magic", sb_version(rs
));
1624 * s_version of standard format may contain incorrect
1625 * information, so we just look at the magic string
1628 "found reiserfs format \"%s\" with standard journal\n",
1629 is_reiserfs_3_5(rs
) ? "3.5" : "3.6");
1631 s
->s_op
= &reiserfs_sops
;
1632 s
->s_export_op
= &reiserfs_export_ops
;
1634 s
->s_qcop
= &reiserfs_qctl_operations
;
1635 s
->dq_op
= &reiserfs_quota_operations
;
1639 * new format is limited by the 32 bit wide i_blocks field, want to
1640 * be one full block below that.
1642 s
->s_maxbytes
= (512LL << 32) - s
->s_blocksize
;
1646 /* after journal replay, reread all bitmap and super blocks */
1647 static int reread_meta_blocks(struct super_block
*s
)
1649 ll_rw_block(READ
, 1, &SB_BUFFER_WITH_SB(s
));
1650 wait_on_buffer(SB_BUFFER_WITH_SB(s
));
1651 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s
))) {
1652 reiserfs_warning(s
, "reiserfs-2504", "error reading the super");
1659 /* hash detection stuff */
1662 * if root directory is empty - we set default - Yura's - hash and
1664 * FIXME: we look for only one name in a directory. If tea and yura
1665 * both have the same value - we ask user to send report to the
1668 static __u32
find_hash_out(struct super_block
*s
)
1671 struct inode
*inode
;
1673 INITIALIZE_PATH(path
);
1674 struct reiserfs_dir_entry de
;
1675 struct reiserfs_de_head
*deh
;
1676 __u32 hash
= DEFAULT_HASH
;
1677 __u32 deh_hashval
, teahash
, r5hash
, yurahash
;
1679 inode
= s
->s_root
->d_inode
;
1681 make_cpu_key(&key
, inode
, ~0, TYPE_DIRENTRY
, 3);
1682 retval
= search_by_entry_key(s
, &key
, &path
, &de
);
1683 if (retval
== IO_ERROR
) {
1687 if (retval
== NAME_NOT_FOUND
)
1690 set_de_name_and_namelen(&de
);
1691 deh
= de
.de_deh
+ de
.de_entry_num
;
1693 if (deh_offset(deh
) == DOT_DOT_OFFSET
) {
1694 /* allow override in this case */
1695 if (reiserfs_rupasov_hash(s
))
1697 reiserfs_info(s
, "FS seems to be empty, autodetect is using the default hash\n");
1701 deh_hashval
= GET_HASH_VALUE(deh_offset(deh
));
1702 r5hash
= GET_HASH_VALUE(r5_hash(de
.de_name
, de
.de_namelen
));
1703 teahash
= GET_HASH_VALUE(keyed_hash(de
.de_name
, de
.de_namelen
));
1704 yurahash
= GET_HASH_VALUE(yura_hash(de
.de_name
, de
.de_namelen
));
1706 if ((teahash
== r5hash
&& deh_hashval
== r5hash
) ||
1707 (teahash
== yurahash
&& deh_hashval
== yurahash
) ||
1708 (r5hash
== yurahash
&& deh_hashval
== yurahash
)) {
1709 reiserfs_warning(s
, "reiserfs-2506",
1710 "Unable to automatically detect hash "
1711 "function. Please mount with -o "
1712 "hash={tea,rupasov,r5}");
1717 if (deh_hashval
== yurahash
)
1719 else if (deh_hashval
== teahash
)
1721 else if (deh_hashval
== r5hash
)
1724 reiserfs_warning(s
, "reiserfs-2506",
1725 "Unrecognised hash function");
1733 /* finds out which hash names are sorted with */
1734 static int what_hash(struct super_block
*s
)
1738 code
= sb_hash_function_code(SB_DISK_SUPER_BLOCK(s
));
1741 * reiserfs_hash_detect() == true if any of the hash mount options
1742 * were used. We must check them to make sure the user isn't
1743 * using a bad hash value
1745 if (code
== UNSET_HASH
|| reiserfs_hash_detect(s
))
1746 code
= find_hash_out(s
);
1748 if (code
!= UNSET_HASH
&& reiserfs_hash_detect(s
)) {
1750 * detection has found the hash, and we must check against the
1753 if (reiserfs_rupasov_hash(s
) && code
!= YURA_HASH
) {
1754 reiserfs_warning(s
, "reiserfs-2507",
1755 "Error, %s hash detected, "
1756 "unable to force rupasov hash",
1757 reiserfs_hashname(code
));
1759 } else if (reiserfs_tea_hash(s
) && code
!= TEA_HASH
) {
1760 reiserfs_warning(s
, "reiserfs-2508",
1761 "Error, %s hash detected, "
1762 "unable to force tea hash",
1763 reiserfs_hashname(code
));
1765 } else if (reiserfs_r5_hash(s
) && code
!= R5_HASH
) {
1766 reiserfs_warning(s
, "reiserfs-2509",
1767 "Error, %s hash detected, "
1768 "unable to force r5 hash",
1769 reiserfs_hashname(code
));
1774 * find_hash_out was not called or
1775 * could not determine the hash
1777 if (reiserfs_rupasov_hash(s
)) {
1779 } else if (reiserfs_tea_hash(s
)) {
1781 } else if (reiserfs_r5_hash(s
)) {
1787 * if we are mounted RW, and we have a new valid hash code, update
1790 if (code
!= UNSET_HASH
&&
1791 !(s
->s_flags
& MS_RDONLY
) &&
1792 code
!= sb_hash_function_code(SB_DISK_SUPER_BLOCK(s
))) {
1793 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s
), code
);
1798 /* return pointer to appropriate function */
1799 static hashf_t
hash_function(struct super_block
*s
)
1801 switch (what_hash(s
)) {
1803 reiserfs_info(s
, "Using tea hash to sort names\n");
1806 reiserfs_info(s
, "Using rupasov hash to sort names\n");
1809 reiserfs_info(s
, "Using r5 hash to sort names\n");
1815 /* this is used to set up correct value for old partitions */
1816 static int function2code(hashf_t func
)
1818 if (func
== keyed_hash
)
1820 if (func
== yura_hash
)
1822 if (func
== r5_hash
)
1825 BUG(); /* should never happen */
1830 #define SWARN(silent, s, id, ...) \
1832 reiserfs_warning(s, id, __VA_ARGS__)
1834 static int reiserfs_fill_super(struct super_block
*s
, void *data
, int silent
)
1836 struct inode
*root_inode
;
1837 struct reiserfs_transaction_handle th
;
1839 unsigned long blocks
;
1840 unsigned int commit_max_age
= 0;
1842 struct reiserfs_iget_args args
;
1843 struct reiserfs_super_block
*rs
;
1845 struct reiserfs_sb_info
*sbi
;
1846 int errval
= -EINVAL
;
1847 char *qf_names
[MAXQUOTAS
] = {};
1848 unsigned int qfmt
= 0;
1850 save_mount_options(s
, data
);
1852 sbi
= kzalloc(sizeof(struct reiserfs_sb_info
), GFP_KERNEL
);
1856 /* Set default values for options: non-aggressive tails, RO on errors */
1857 sbi
->s_mount_opt
|= (1 << REISERFS_SMALLTAIL
);
1858 sbi
->s_mount_opt
|= (1 << REISERFS_ERROR_RO
);
1859 sbi
->s_mount_opt
|= (1 << REISERFS_BARRIER_FLUSH
);
1860 /* no preallocation minimum, be smart in reiserfs_file_write instead */
1861 sbi
->s_alloc_options
.preallocmin
= 0;
1862 /* Preallocate by 16 blocks (17-1) at once */
1863 sbi
->s_alloc_options
.preallocsize
= 17;
1864 /* setup default block allocator options */
1865 reiserfs_init_alloc_options(s
);
1867 spin_lock_init(&sbi
->old_work_lock
);
1868 INIT_DELAYED_WORK(&sbi
->old_work
, flush_old_commits
);
1869 mutex_init(&sbi
->lock
);
1870 sbi
->lock_depth
= -1;
1872 sbi
->commit_wq
= alloc_workqueue("reiserfs/%s", WQ_MEM_RECLAIM
, 0,
1874 if (!sbi
->commit_wq
) {
1875 SWARN(silent
, s
, "", "Cannot allocate commit workqueue");
1877 goto error_unlocked
;
1881 if (reiserfs_parse_options
1882 (s
, (char *)data
, &sbi
->s_mount_opt
, &blocks
, &jdev_name
,
1883 &commit_max_age
, qf_names
, &qfmt
) == 0) {
1884 goto error_unlocked
;
1886 if (jdev_name
&& jdev_name
[0]) {
1887 sbi
->s_jdev
= kstrdup(jdev_name
, GFP_KERNEL
);
1889 SWARN(silent
, s
, "", "Cannot allocate memory for "
1890 "journal device name");
1895 handle_quota_files(s
, qf_names
, &qfmt
);
1899 SWARN(silent
, s
, "jmacd-7", "resize option for remount only");
1900 goto error_unlocked
;
1904 * try old format (undistributed bitmap, super block in 8-th 1k
1905 * block of a device)
1907 if (!read_super_block(s
, REISERFS_OLD_DISK_OFFSET_IN_BYTES
))
1911 * try new format (64-th 1k block), which can contain reiserfs
1914 else if (read_super_block(s
, REISERFS_DISK_OFFSET_IN_BYTES
)) {
1915 SWARN(silent
, s
, "sh-2021", "can not find reiserfs on %s",
1917 goto error_unlocked
;
1920 rs
= SB_DISK_SUPER_BLOCK(s
);
1922 * Let's do basic sanity check to verify that underlying device is not
1923 * smaller than the filesystem. If the check fails then abort and
1924 * scream, because bad stuff will happen otherwise.
1926 if (s
->s_bdev
&& s
->s_bdev
->bd_inode
1927 && i_size_read(s
->s_bdev
->bd_inode
) <
1928 sb_block_count(rs
) * sb_blocksize(rs
)) {
1929 SWARN(silent
, s
, "", "Filesystem cannot be "
1930 "mounted because it is bigger than the device");
1931 SWARN(silent
, s
, "", "You may need to run fsck "
1932 "or increase size of your LVM partition");
1933 SWARN(silent
, s
, "", "Or may be you forgot to "
1934 "reboot after fdisk when it told you to");
1935 goto error_unlocked
;
1938 sbi
->s_mount_state
= SB_REISERFS_STATE(s
);
1939 sbi
->s_mount_state
= REISERFS_VALID_FS
;
1941 if ((errval
= reiserfs_init_bitmap_cache(s
))) {
1942 SWARN(silent
, s
, "jmacd-8", "unable to read bitmap");
1943 goto error_unlocked
;
1947 #ifdef CONFIG_REISERFS_CHECK
1948 SWARN(silent
, s
, "", "CONFIG_REISERFS_CHECK is set ON");
1949 SWARN(silent
, s
, "", "- it is slow mode for debugging.");
1952 /* make data=ordered the default */
1953 if (!reiserfs_data_log(s
) && !reiserfs_data_ordered(s
) &&
1954 !reiserfs_data_writeback(s
)) {
1955 sbi
->s_mount_opt
|= (1 << REISERFS_DATA_ORDERED
);
1958 if (reiserfs_data_log(s
)) {
1959 reiserfs_info(s
, "using journaled data mode\n");
1960 } else if (reiserfs_data_ordered(s
)) {
1961 reiserfs_info(s
, "using ordered data mode\n");
1963 reiserfs_info(s
, "using writeback data mode\n");
1965 if (reiserfs_barrier_flush(s
)) {
1966 printk("reiserfs: using flush barriers\n");
1969 if (journal_init(s
, jdev_name
, old_format
, commit_max_age
)) {
1970 SWARN(silent
, s
, "sh-2022",
1971 "unable to initialize journal space");
1972 goto error_unlocked
;
1975 * once this is set, journal_release must be called
1976 * if we error out of the mount
1981 if (reread_meta_blocks(s
)) {
1982 SWARN(silent
, s
, "jmacd-9",
1983 "unable to reread meta blocks after journal init");
1984 goto error_unlocked
;
1988 goto error_unlocked
;
1990 if (bdev_read_only(s
->s_bdev
) && !(s
->s_flags
& MS_RDONLY
)) {
1991 SWARN(silent
, s
, "clm-7000",
1992 "Detected readonly device, marking FS readonly");
1993 s
->s_flags
|= MS_RDONLY
;
1995 args
.objectid
= REISERFS_ROOT_OBJECTID
;
1996 args
.dirid
= REISERFS_ROOT_PARENT_OBJECTID
;
1998 iget5_locked(s
, REISERFS_ROOT_OBJECTID
, reiserfs_find_actor
,
1999 reiserfs_init_locked_inode
, (void *)&args
);
2001 SWARN(silent
, s
, "jmacd-10", "get root inode failed");
2002 goto error_unlocked
;
2006 * This path assumed to be called with the BKL in the old times.
2007 * Now we have inherited the big reiserfs lock from it and many
2008 * reiserfs helpers called in the mount path and elsewhere require
2009 * this lock to be held even if it's not always necessary. Let's be
2010 * conservative and hold it early. The window can be reduced after
2011 * careful review of the code.
2013 reiserfs_write_lock(s
);
2015 if (root_inode
->i_state
& I_NEW
) {
2016 reiserfs_read_locked_inode(root_inode
, &args
);
2017 unlock_new_inode(root_inode
);
2020 s
->s_root
= d_make_root(root_inode
);
2023 /* define and initialize hash function */
2024 sbi
->s_hash_function
= hash_function(s
);
2025 if (sbi
->s_hash_function
== NULL
) {
2031 if (is_reiserfs_3_5(rs
)
2032 || (is_reiserfs_jr(rs
) && SB_VERSION(s
) == REISERFS_VERSION_1
))
2033 set_bit(REISERFS_3_5
, &sbi
->s_properties
);
2034 else if (old_format
)
2035 set_bit(REISERFS_OLD_FORMAT
, &sbi
->s_properties
);
2037 set_bit(REISERFS_3_6
, &sbi
->s_properties
);
2039 if (!(s
->s_flags
& MS_RDONLY
)) {
2041 errval
= journal_begin(&th
, s
, 1);
2047 reiserfs_prepare_for_journal(s
, SB_BUFFER_WITH_SB(s
), 1);
2049 set_sb_umount_state(rs
, REISERFS_ERROR_FS
);
2050 set_sb_fs_state(rs
, 0);
2053 * Clear out s_bmap_nr if it would wrap. We can handle this
2054 * case, but older revisions can't. This will cause the
2055 * file system to fail mount on those older implementations,
2056 * avoiding corruption. -jeffm
2058 if (bmap_would_wrap(reiserfs_bmap_count(s
)) &&
2059 sb_bmap_nr(rs
) != 0) {
2060 reiserfs_warning(s
, "super-2030", "This file system "
2061 "claims to use %u bitmap blocks in "
2062 "its super block, but requires %u. "
2063 "Clearing to zero.", sb_bmap_nr(rs
),
2064 reiserfs_bmap_count(s
));
2066 set_sb_bmap_nr(rs
, 0);
2069 if (old_format_only(s
)) {
2071 * filesystem of format 3.5 either with standard
2072 * or non-standard journal
2074 if (convert_reiserfs(s
)) {
2075 /* and -o conv is given */
2078 "converting 3.5 filesystem to the 3.6 format");
2080 if (is_reiserfs_3_5(rs
))
2082 * put magic string of 3.6 format.
2083 * 2.2 will not be able to
2084 * mount this filesystem anymore
2086 memcpy(rs
->s_v1
.s_magic
,
2087 reiserfs_3_6_magic_string
,
2089 (reiserfs_3_6_magic_string
));
2091 set_sb_version(rs
, REISERFS_VERSION_2
);
2092 reiserfs_convert_objectid_map_v1(s
);
2093 set_bit(REISERFS_3_6
, &sbi
->s_properties
);
2094 clear_bit(REISERFS_3_5
, &sbi
->s_properties
);
2095 } else if (!silent
) {
2096 reiserfs_info(s
, "using 3.5.x disk format\n");
2099 set_sb_mnt_count(rs
, sb_mnt_count(rs
) + 1);
2102 journal_mark_dirty(&th
, SB_BUFFER_WITH_SB(s
));
2103 errval
= journal_end(&th
);
2110 reiserfs_write_unlock(s
);
2111 if ((errval
= reiserfs_lookup_privroot(s
)) ||
2112 (errval
= reiserfs_xattr_init(s
, s
->s_flags
))) {
2115 goto error_unlocked
;
2117 reiserfs_write_lock(s
);
2120 * look for files which were to be removed in previous session
2122 finish_unfinished(s
);
2124 if (old_format_only(s
) && !silent
) {
2125 reiserfs_info(s
, "using 3.5.x disk format\n");
2128 reiserfs_write_unlock(s
);
2129 if ((errval
= reiserfs_lookup_privroot(s
)) ||
2130 (errval
= reiserfs_xattr_init(s
, s
->s_flags
))) {
2133 goto error_unlocked
;
2135 reiserfs_write_lock(s
);
2138 * mark hash in super block: it could be unset. overwrite should be ok
2140 set_sb_hash_function_code(rs
, function2code(sbi
->s_hash_function
));
2144 reiserfs_proc_info_init(s
);
2146 init_waitqueue_head(&(sbi
->s_wait
));
2147 spin_lock_init(&sbi
->bitmap_lock
);
2149 reiserfs_write_unlock(s
);
2154 reiserfs_write_unlock(s
);
2157 /* kill the commit thread, free journal ram */
2159 reiserfs_write_lock(s
);
2160 journal_release_error(NULL
, s
);
2161 reiserfs_write_unlock(s
);
2164 cancel_delayed_work_sync(&REISERFS_SB(s
)->old_work
);
2166 reiserfs_free_bitmap_cache(s
);
2167 if (SB_BUFFER_WITH_SB(s
))
2168 brelse(SB_BUFFER_WITH_SB(s
));
2172 for (j
= 0; j
< MAXQUOTAS
; j
++)
2178 s
->s_fs_info
= NULL
;
2182 static int reiserfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
2184 struct reiserfs_super_block
*rs
= SB_DISK_SUPER_BLOCK(dentry
->d_sb
);
2186 buf
->f_namelen
= (REISERFS_MAX_NAME(s
->s_blocksize
));
2187 buf
->f_bfree
= sb_free_blocks(rs
);
2188 buf
->f_bavail
= buf
->f_bfree
;
2189 buf
->f_blocks
= sb_block_count(rs
) - sb_bmap_nr(rs
) - 1;
2190 buf
->f_bsize
= dentry
->d_sb
->s_blocksize
;
2191 /* changed to accommodate gcc folks. */
2192 buf
->f_type
= REISERFS_SUPER_MAGIC
;
2193 buf
->f_fsid
.val
[0] = (u32
)crc32_le(0, rs
->s_uuid
, sizeof(rs
->s_uuid
)/2);
2194 buf
->f_fsid
.val
[1] = (u32
)crc32_le(0, rs
->s_uuid
+ sizeof(rs
->s_uuid
)/2,
2195 sizeof(rs
->s_uuid
)/2);
2201 static int reiserfs_write_dquot(struct dquot
*dquot
)
2203 struct reiserfs_transaction_handle th
;
2207 reiserfs_write_lock(dquot
->dq_sb
);
2209 journal_begin(&th
, dquot
->dq_sb
,
2210 REISERFS_QUOTA_TRANS_BLOCKS(dquot
->dq_sb
));
2213 depth
= reiserfs_write_unlock_nested(dquot
->dq_sb
);
2214 ret
= dquot_commit(dquot
);
2215 reiserfs_write_lock_nested(dquot
->dq_sb
, depth
);
2216 err
= journal_end(&th
);
2220 reiserfs_write_unlock(dquot
->dq_sb
);
2224 static int reiserfs_acquire_dquot(struct dquot
*dquot
)
2226 struct reiserfs_transaction_handle th
;
2230 reiserfs_write_lock(dquot
->dq_sb
);
2232 journal_begin(&th
, dquot
->dq_sb
,
2233 REISERFS_QUOTA_INIT_BLOCKS(dquot
->dq_sb
));
2236 depth
= reiserfs_write_unlock_nested(dquot
->dq_sb
);
2237 ret
= dquot_acquire(dquot
);
2238 reiserfs_write_lock_nested(dquot
->dq_sb
, depth
);
2239 err
= journal_end(&th
);
2243 reiserfs_write_unlock(dquot
->dq_sb
);
2247 static int reiserfs_release_dquot(struct dquot
*dquot
)
2249 struct reiserfs_transaction_handle th
;
2252 reiserfs_write_lock(dquot
->dq_sb
);
2254 journal_begin(&th
, dquot
->dq_sb
,
2255 REISERFS_QUOTA_DEL_BLOCKS(dquot
->dq_sb
));
2256 reiserfs_write_unlock(dquot
->dq_sb
);
2258 /* Release dquot anyway to avoid endless cycle in dqput() */
2259 dquot_release(dquot
);
2262 ret
= dquot_release(dquot
);
2263 reiserfs_write_lock(dquot
->dq_sb
);
2264 err
= journal_end(&th
);
2267 reiserfs_write_unlock(dquot
->dq_sb
);
2272 static int reiserfs_mark_dquot_dirty(struct dquot
*dquot
)
2274 /* Are we journaling quotas? */
2275 if (REISERFS_SB(dquot
->dq_sb
)->s_qf_names
[USRQUOTA
] ||
2276 REISERFS_SB(dquot
->dq_sb
)->s_qf_names
[GRPQUOTA
]) {
2277 dquot_mark_dquot_dirty(dquot
);
2278 return reiserfs_write_dquot(dquot
);
2280 return dquot_mark_dquot_dirty(dquot
);
2283 static int reiserfs_write_info(struct super_block
*sb
, int type
)
2285 struct reiserfs_transaction_handle th
;
2289 /* Data block + inode block */
2290 reiserfs_write_lock(sb
);
2291 ret
= journal_begin(&th
, sb
, 2);
2294 depth
= reiserfs_write_unlock_nested(sb
);
2295 ret
= dquot_commit_info(sb
, type
);
2296 reiserfs_write_lock_nested(sb
, depth
);
2297 err
= journal_end(&th
);
2301 reiserfs_write_unlock(sb
);
2306 * Turn on quotas during mount time - we need to find the quota file and such...
2308 static int reiserfs_quota_on_mount(struct super_block
*sb
, int type
)
2310 return dquot_quota_on_mount(sb
, REISERFS_SB(sb
)->s_qf_names
[type
],
2311 REISERFS_SB(sb
)->s_jquota_fmt
, type
);
2315 * Standard function to be called on quota_on
2317 static int reiserfs_quota_on(struct super_block
*sb
, int type
, int format_id
,
2321 struct inode
*inode
;
2322 struct reiserfs_transaction_handle th
;
2323 int opt
= type
== USRQUOTA
? REISERFS_USRQUOTA
: REISERFS_GRPQUOTA
;
2325 reiserfs_write_lock(sb
);
2326 if (!(REISERFS_SB(sb
)->s_mount_opt
& (1 << opt
))) {
2331 /* Quotafile not on the same filesystem? */
2332 if (path
->dentry
->d_sb
!= sb
) {
2336 inode
= path
->dentry
->d_inode
;
2338 * We must not pack tails for quota files on reiserfs for quota
2341 if (!(REISERFS_I(inode
)->i_flags
& i_nopack_mask
)) {
2342 err
= reiserfs_unpack(inode
, NULL
);
2344 reiserfs_warning(sb
, "super-6520",
2345 "Unpacking tail of quota file failed"
2346 " (%d). Cannot turn on quotas.", err
);
2350 mark_inode_dirty(inode
);
2352 /* Journaling quota? */
2353 if (REISERFS_SB(sb
)->s_qf_names
[type
]) {
2354 /* Quotafile not of fs root? */
2355 if (path
->dentry
->d_parent
!= sb
->s_root
)
2356 reiserfs_warning(sb
, "super-6521",
2357 "Quota file not on filesystem root. "
2358 "Journalled quota will not work.");
2362 * When we journal data on quota file, we have to flush journal to see
2363 * all updates to the file when we bypass pagecache...
2365 if (reiserfs_file_data_log(inode
)) {
2366 /* Just start temporary transaction and finish it */
2367 err
= journal_begin(&th
, sb
, 1);
2370 err
= journal_end_sync(&th
);
2374 reiserfs_write_unlock(sb
);
2375 return dquot_quota_on(sb
, type
, format_id
, path
);
2377 reiserfs_write_unlock(sb
);
2382 * Read data from quotafile - avoid pagecache and such because we cannot afford
2383 * acquiring the locks... As quota files are never truncated and quota code
2384 * itself serializes the operations (and no one else should touch the files)
2385 * we don't have to be afraid of races
2387 static ssize_t
reiserfs_quota_read(struct super_block
*sb
, int type
, char *data
,
2388 size_t len
, loff_t off
)
2390 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
2391 unsigned long blk
= off
>> sb
->s_blocksize_bits
;
2392 int err
= 0, offset
= off
& (sb
->s_blocksize
- 1), tocopy
;
2394 struct buffer_head tmp_bh
, *bh
;
2395 loff_t i_size
= i_size_read(inode
);
2399 if (off
+ len
> i_size
)
2402 while (toread
> 0) {
2404 sb
->s_blocksize
- offset
<
2405 toread
? sb
->s_blocksize
- offset
: toread
;
2408 * Quota files are without tails so we can safely
2411 reiserfs_write_lock(sb
);
2412 err
= reiserfs_get_block(inode
, blk
, &tmp_bh
, 0);
2413 reiserfs_write_unlock(sb
);
2416 if (!buffer_mapped(&tmp_bh
)) /* A hole? */
2417 memset(data
, 0, tocopy
);
2419 bh
= sb_bread(sb
, tmp_bh
.b_blocknr
);
2422 memcpy(data
, bh
->b_data
+ offset
, tocopy
);
2434 * Write to quotafile (we know the transaction is already started and has
2437 static ssize_t
reiserfs_quota_write(struct super_block
*sb
, int type
,
2438 const char *data
, size_t len
, loff_t off
)
2440 struct inode
*inode
= sb_dqopt(sb
)->files
[type
];
2441 unsigned long blk
= off
>> sb
->s_blocksize_bits
;
2442 int err
= 0, offset
= off
& (sb
->s_blocksize
- 1), tocopy
;
2443 int journal_quota
= REISERFS_SB(sb
)->s_qf_names
[type
] != NULL
;
2444 size_t towrite
= len
;
2445 struct buffer_head tmp_bh
, *bh
;
2447 if (!current
->journal_info
) {
2448 printk(KERN_WARNING
"reiserfs: Quota write (off=%llu, len=%llu) cancelled because transaction is not started.\n",
2449 (unsigned long long)off
, (unsigned long long)len
);
2452 while (towrite
> 0) {
2453 tocopy
= sb
->s_blocksize
- offset
< towrite
?
2454 sb
->s_blocksize
- offset
: towrite
;
2456 reiserfs_write_lock(sb
);
2457 err
= reiserfs_get_block(inode
, blk
, &tmp_bh
, GET_BLOCK_CREATE
);
2458 reiserfs_write_unlock(sb
);
2461 if (offset
|| tocopy
!= sb
->s_blocksize
)
2462 bh
= sb_bread(sb
, tmp_bh
.b_blocknr
);
2464 bh
= sb_getblk(sb
, tmp_bh
.b_blocknr
);
2470 memcpy(bh
->b_data
+ offset
, data
, tocopy
);
2471 flush_dcache_page(bh
->b_page
);
2472 set_buffer_uptodate(bh
);
2474 reiserfs_write_lock(sb
);
2475 reiserfs_prepare_for_journal(sb
, bh
, 1);
2476 journal_mark_dirty(current
->journal_info
, bh
);
2478 reiserfs_add_ordered_list(inode
, bh
);
2479 reiserfs_write_unlock(sb
);
2489 if (inode
->i_size
< off
+ len
- towrite
)
2490 i_size_write(inode
, off
+ len
- towrite
);
2492 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
2493 mark_inode_dirty(inode
);
2494 return len
- towrite
;
2499 static struct dentry
*get_super_block(struct file_system_type
*fs_type
,
2500 int flags
, const char *dev_name
,
2503 return mount_bdev(fs_type
, flags
, dev_name
, data
, reiserfs_fill_super
);
2506 static int __init
init_reiserfs_fs(void)
2510 ret
= init_inodecache();
2514 reiserfs_proc_info_global_init();
2516 ret
= register_filesystem(&reiserfs_fs_type
);
2522 reiserfs_proc_info_global_done();
2523 destroy_inodecache();
2528 static void __exit
exit_reiserfs_fs(void)
2530 reiserfs_proc_info_global_done();
2531 unregister_filesystem(&reiserfs_fs_type
);
2532 destroy_inodecache();
2535 struct file_system_type reiserfs_fs_type
= {
2536 .owner
= THIS_MODULE
,
2538 .mount
= get_super_block
,
2539 .kill_sb
= reiserfs_kill_sb
,
2540 .fs_flags
= FS_REQUIRES_DEV
,
2542 MODULE_ALIAS_FS("reiserfs");
2544 MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2545 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2546 MODULE_LICENSE("GPL");
2548 module_init(init_reiserfs_fs
);
2549 module_exit(exit_reiserfs_fs
);