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