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