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