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