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