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