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