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