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