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