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