projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ext4: add missing unlock to an error path in ext4_quota_write()
[linux-2.6-block.git] / fs / reiserfs / super.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 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>
1da177e4
LT		 21#include <linux/init.h>
22#include <linux/blkdev.h>
23#include <linux/buffer_head.h>
a5694255 24#include <linux/exportfs.h>
1da177e4 25#include <linux/vfs.h>
6b3286ed 26#include <linux/mnt_namespace.h>
1da177e4
LT		 27#include <linux/mount.h>
28#include <linux/namei.h>
29#include <linux/quotaops.h>
30
31struct file_system_type reiserfs_fs_type;
32
33static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;
34static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;
35static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;
36
bd4c625c 37int is_reiserfs_3_5(struct reiserfs_super_block *rs)
1da177e4 38{
bd4c625c
LT		 39 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
40 strlen(reiserfs_3_5_magic_string));
1da177e4
LT		 41}
42
bd4c625c 43int is_reiserfs_3_6(struct reiserfs_super_block *rs)
1da177e4 44{
bd4c625c
LT		 45 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
46 strlen(reiserfs_3_6_magic_string));
1da177e4
LT		 47}
48
bd4c625c 49int is_reiserfs_jr(struct reiserfs_super_block *rs)
1da177e4 50{
bd4c625c
LT		 51 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
52 strlen(reiserfs_jr_magic_string));
1da177e4
LT		 53}
54
bd4c625c 55static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
1da177e4 56{
bd4c625c
LT		 57 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
58 is_reiserfs_jr(rs));
1da177e4
LT		 59}
60
bd4c625c 61static int reiserfs_remount(struct super_block *s, int *flags, char *data);
726c3342 62static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
1da177e4 63
bd4c625c 64static int reiserfs_sync_fs(struct super_block *s, int wait)
1da177e4 65{
bd4c625c
LT		 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;
1da177e4
LT		 79}
80
81static void reiserfs_write_super(struct super_block *s)
82{
bd4c625c 83 reiserfs_sync_fs(s, 1);
1da177e4
LT		 84}
85
bd4c625c 86static void reiserfs_write_super_lockfs(struct super_block *s)
1da177e4 87{
bd4c625c
LT		 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);
1da177e4
LT		 104}
105
bd4c625c
LT		 106static void reiserfs_unlockfs(struct super_block *s)
107{
108 reiserfs_allow_writes(s);
1da177e4
LT		 109}
110
bd4c625c 111extern const struct in_core_key MAX_IN_CORE_KEY;
1da177e4
LT		 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 */
bd4c625c
LT		 120static int remove_save_link_only(struct super_block *s,
121 struct reiserfs_key *key, int oid_free)
1da177e4 122{
bd4c625c
LT		 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);
1da177e4 137}
bd4c625c 138
1da177e4
LT		 139#ifdef CONFIG_QUOTA
140static int reiserfs_quota_on_mount(struct super_block *, int);
141#endif
bd4c625c 142
1da177e4 143/* look for uncompleted unlinks and truncates and complete them */
bd4c625c 144static int finish_unfinished(struct super_block *s)
1da177e4 145{
bd4c625c
LT		 146 INITIALIZE_PATH(path);
147 struct cpu_key max_cpu_key, obj_key;
fb46f341 148 struct reiserfs_key save_link_key, last_inode_key;
bd4c625c
LT		 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;
1da177e4 157#ifdef CONFIG_QUOTA
bd4c625c
LT		 158 int i;
159 int ms_active_set;
1da177e4 160#endif
bd4c625c
LT		 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;
1da177e4 168
fb46f341
LW		 169 memset(&last_inode_key, 0, sizeof(last_inode_key));
170
1da177e4 171#ifdef CONFIG_QUOTA
bd4c625c
LT		 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 journalled quota: error %d",
186 ret);
187 }
188 }
1da177e4 189#endif
bd4c625c
LT		 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));
fb46f341
LW		 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 }
bd4c625c
LT		 295 }
296
297 iput(inode);
298 printk("done\n");
299 done++;
300 }
301 REISERFS_SB(s)->s_is_unlinked_ok = 0;
302
1da177e4 303#ifdef CONFIG_QUOTA
bd4c625c
LT		 304 /* Turn quotas off */
305 for (i = 0; i < MAXQUOTAS; i++) {
306 if (sb_dqopt(s)->files[i])
1b445a9c 307 vfs_quota_off(s, i, 0);
bd4c625c
LT		 308 }
309 if (ms_active_set)
310 /* Restore the flag back */
311 s->s_flags &= ~MS_ACTIVE;
1da177e4 312#endif
bd4c625c
LT		 313 pathrelse(&path);
314 if (done)
315 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
316 "Completed\n", done);
317 return retval;
1da177e4 318}
bd4c625c 319
1da177e4
LT		 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
3a4fa0a2 322 item of file. mounting the filesystem we scan all these links and remove
1da177e4 323 files which almost got lost */
bd4c625c
LT		 324void add_save_link(struct reiserfs_transaction_handle *th,
325 struct inode *inode, int truncate)
1da177e4 326{
bd4c625c
LT		 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 }
1da177e4 383
bd4c625c
LT		 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}
1da177e4
LT		 403
404/* this opens transaction unlike add_save_link */
bd4c625c 405int remove_save_link(struct inode *inode, int truncate)
1da177e4 406{
bd4c625c
LT		 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 }
1da177e4 429
bd4c625c
LT		 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}
1da177e4 444
edc666e2 445static void reiserfs_kill_sb(struct super_block *s)
1da177e4 446{
edc666e2 447 if (REISERFS_SB(s)) {
fe08a9d4 448#ifdef CONFIG_REISERFS_FS_XATTR
edc666e2
DH		 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 }
fe08a9d4 454#endif
edc666e2
DH		 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 }
bd4c625c
LT		 460 }
461
edc666e2
DH		 462 kill_block_super(s);
463}
464
465static void reiserfs_put_super(struct super_block *s)
466{
467 struct reiserfs_transaction_handle th;
468 th.t_trans_id = 0;
bd4c625c
LT		 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
5065227b 486 reiserfs_free_bitmap_cache(s);
bd4c625c
LT		 487
488 brelse(SB_BUFFER_WITH_SB(s));
489
490 print_statistics(s);
491
bd4c625c
LT		 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;
1da177e4
LT		 504}
505
e18b890b 506static struct kmem_cache *reiserfs_inode_cachep;
1da177e4
LT		 507
508static struct inode *reiserfs_alloc_inode(struct super_block *sb)
509{
510 struct reiserfs_inode_info *ei;
bd4c625c 511 ei = (struct reiserfs_inode_info *)
e94b1766 512 kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
1da177e4
LT		 513 if (!ei)
514 return NULL;
515 return &ei->vfs_inode;
516}
517
518static void reiserfs_destroy_inode(struct inode *inode)
519{
520 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
521}
522
4ba9b9d0 523static void init_once(struct kmem_cache * cachep, void *foo)
1da177e4 524{
bd4c625c 525 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
1da177e4 526
a35afb83
CL		 527 INIT_LIST_HEAD(&ei->i_prealloc_list);
528 inode_init_once(&ei->vfs_inode);
cfe14677 529#ifdef CONFIG_REISERFS_FS_POSIX_ACL
a35afb83
CL		 530 ei->i_acl_access = NULL;
531 ei->i_acl_default = NULL;
cfe14677 532#endif
1da177e4 533}
bd4c625c 534
1da177e4
LT		 535static int init_inodecache(void)
536{
537 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
bd4c625c
LT		 538 sizeof(struct
539 reiserfs_inode_info),
fffb60f9
PJ		 540 0, (SLAB_RECLAIM_ACCOUNT|
541 SLAB_MEM_SPREAD),
20c2df83 542 init_once);
1da177e4
LT		 543 if (reiserfs_inode_cachep == NULL)
544 return -ENOMEM;
545 return 0;
546}
547
548static void destroy_inodecache(void)
549{
1a1d92c1 550 kmem_cache_destroy(reiserfs_inode_cachep);
1da177e4
LT		 551}
552
553/* we don't mark inodes dirty, we just log them */
bd4c625c
LT		 554static 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);
1da177e4
LT		 578}
579
cfe14677 580#ifdef CONFIG_REISERFS_FS_POSIX_ACL
bd4c625c 581static void reiserfs_clear_inode(struct inode *inode)
1da177e4 582{
bd4c625c 583 struct posix_acl *acl;
1da177e4 584
bd4c625c
LT		 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;
1da177e4 589
bd4c625c
LT		 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;
1da177e4 594}
cfe14677
AD		 595#else
596#define reiserfs_clear_inode NULL
597#endif
1da177e4
LT		 598
599#ifdef CONFIG_QUOTA
bd4c625c
LT		 600static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,
601 size_t, loff_t);
602static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,
603 loff_t);
1da177e4
LT		 604#endif
605
ee9b6d61 606static const struct super_operations reiserfs_sops = {
bd4c625c
LT		 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,
cdf6ccc8 620 .show_options = generic_show_options,
1da177e4 621#ifdef CONFIG_QUOTA
bd4c625c
LT		 622 .quota_read = reiserfs_quota_read,
623 .quota_write = reiserfs_quota_write,
1da177e4
LT		 624#endif
625};
626
627#ifdef CONFIG_QUOTA
628#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
629
630static int reiserfs_dquot_initialize(struct inode *, int);
631static int reiserfs_dquot_drop(struct inode *);
632static int reiserfs_write_dquot(struct dquot *);
633static int reiserfs_acquire_dquot(struct dquot *);
634static int reiserfs_release_dquot(struct dquot *);
635static int reiserfs_mark_dquot_dirty(struct dquot *);
636static int reiserfs_write_info(struct super_block *, int);
1b445a9c 637static int reiserfs_quota_on(struct super_block *, int, int, char *, int);
1da177e4 638
bd4c625c
LT		 639static 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,
1da177e4
LT		 652};
653
bd4c625c
LT		 654static 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,
1da177e4
LT		 662};
663#endif
664
39655164 665static const struct export_operations reiserfs_export_ops = {
bd4c625c 666 .encode_fh = reiserfs_encode_fh,
be55caf1
CH		 667 .fh_to_dentry = reiserfs_fh_to_dentry,
668 .fh_to_parent = reiserfs_fh_to_parent,
bd4c625c 669 .get_parent = reiserfs_get_parent,
bd4c625c 670};
1da177e4
LT		 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. */
674typedef struct {
bd4c625c
LT		 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 */
1da177e4
LT		 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 */
688typedef struct {
bd4c625c
LT		 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 */
1da177e4
LT		 697} opt_desc_t;
698
699/* possible values for -o data= */
700static const arg_desc_t logging_mode[] = {
bd4c625c
LT		 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)},
cd02b966 707 {.value = NULL}
1da177e4
LT		 708};
709
710/* possible values for -o barrier= */
711static const arg_desc_t barrier_mode[] = {
bd4c625c
LT		 712 {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
713 {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
cd02b966 714 {.value = NULL}
1da177e4
LT		 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 */
719static const arg_desc_t balloc[] = {
bd4c625c
LT		 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}
1da177e4
LT		 727};
728
729static const arg_desc_t tails[] = {
bd4c625c
LT		 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}
1da177e4
LT		 734};
735
736static const arg_desc_t error_actions[] = {
bd4c625c
LT		 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)},
1da177e4 741#ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
bd4c625c
LT		 742 {"continue", 1 << REISERFS_ERROR_CONTINUE,
743 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
1da177e4 744#endif
bd4c625c 745 {NULL, 0, 0},
1da177e4
LT		 746};
747
1da177e4
LT		 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 */
bd4c625c
LT		 754static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
755 char **opt_arg, unsigned long *bit_flags)
1da177e4 756{
bd4c625c
LT		 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);
1da177e4 868 return -1;
1da177e4
LT		 869}
870
871/* returns 0 if something is wrong in option string, 1 - otherwise */
bd4c625c
LT		 872static 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)
1da177e4 880{
bd4c625c
LT		 881 int c;
882 char *arg = NULL;
883 char *pos;
884 opt_desc_t opts[] = {
885 /* Compatibility stuff, so that -o notail for old setups still work */
886 {"tails",.arg_required = 't',.values = tails},
887 {"notail",.clrmask =
888 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
889 {"conv",.setmask = 1 << REISERFS_CONVERT},
890 {"attrs",.setmask = 1 << REISERFS_ATTRS},
891 {"noattrs",.clrmask = 1 << REISERFS_ATTRS},
1da177e4 892#ifdef CONFIG_REISERFS_FS_XATTR
bd4c625c
LT		 893 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
894 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
1da177e4 895#else
bd4c625c
LT		 896 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
897 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
1da177e4
LT		 898#endif
899#ifdef CONFIG_REISERFS_FS_POSIX_ACL
bd4c625c
LT		 900 {"acl",.setmask = 1 << REISERFS_POSIXACL},
901 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
1da177e4 902#else
bd4c625c
LT		 903 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
904 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
1da177e4 905#endif
cd02b966 906 {.option_name = "nolog"},
bd4c625c
LT		 907 {"replayonly",.setmask = 1 << REPLAYONLY},
908 {"block-allocator",.arg_required = 'a',.values = balloc},
909 {"data",.arg_required = 'd',.values = logging_mode},
910 {"barrier",.arg_required = 'b',.values = barrier_mode},
911 {"resize",.arg_required = 'r',.values = NULL},
912 {"jdev",.arg_required = 'j',.values = NULL},
913 {"nolargeio",.arg_required = 'w',.values = NULL},
914 {"commit",.arg_required = 'c',.values = NULL},
915 {"usrquota",.setmask = 1 << REISERFS_QUOTA},
916 {"grpquota",.setmask = 1 << REISERFS_QUOTA},
917 {"noquota",.clrmask = 1 << REISERFS_QUOTA},
918 {"errors",.arg_required = 'e',.values = error_actions},
919 {"usrjquota",.arg_required =
920 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
921 {"grpjquota",.arg_required =
922 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
923 {"jqfmt",.arg_required = 'f',.values = NULL},
cd02b966 924 {.option_name = NULL}
bd4c625c
LT		 925 };
926
927 *blocks = 0;
928 if (!options || !*options)
929 /* use default configuration: create tails, journaling on, no
930 conversion to newest format */
931 return 1;
932
933 for (pos = options; pos;) {
934 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
935 if (c == -1)
936 /* wrong option is given */
9a3bb301 937 return 0;
1da177e4 938
bd4c625c
LT		 939 if (c == 'r') {
940 char *p;
941
942 p = NULL;
943 /* "resize=NNN" or "resize=auto" */
944
945 if (!strcmp(arg, "auto")) {
946 /* From JFS code, to auto-get the size. */
947 *blocks =
948 s->s_bdev->bd_inode->i_size >> s->
949 s_blocksize_bits;
950 } else {
951 *blocks = simple_strtoul(arg, &p, 0);
952 if (*p != '\0') {
953 /* NNN does not look like a number */
954 reiserfs_warning(s,
955 "reiserfs_parse_options: bad value %s",
956 arg);
957 return 0;
958 }
959 }
1da177e4 960 }
1da177e4 961
bd4c625c
LT		 962 if (c == 'c') {
963 char *p = NULL;
964 unsigned long val = simple_strtoul(arg, &p, 0);
965 /* commit=NNN (time in seconds) */
966 if (*p != '\0' || val >= (unsigned int)-1) {
967 reiserfs_warning(s,
968 "reiserfs_parse_options: bad value %s",
969 arg);
970 return 0;
971 }
972 *commit_max_age = (unsigned int)val;
1da177e4 973 }
1da177e4 974
bd4c625c 975 if (c == 'w') {
36b756f2
AB		 976 reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported");
977 return 0;
1da177e4 978 }
1da177e4 979
bd4c625c
LT		 980 if (c == 'j') {
981 if (arg && *arg && jdev_name) {
982 if (*jdev_name) { //Hm, already assigned?
983 reiserfs_warning(s,
984 "reiserfs_parse_options: journal device was already specified to be %s",
985 *jdev_name);
986 return 0;
987 }
988 *jdev_name = arg;
989 }
1da177e4 990 }
bd4c625c
LT		 991#ifdef CONFIG_QUOTA
992 if (c == 'u' || c == 'g') {
993 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
994
995 if (sb_any_quota_enabled(s)) {
996 reiserfs_warning(s,
997 "reiserfs_parse_options: cannot change journalled quota options when quota turned on.");
998 return 0;
999 }
1000 if (*arg) { /* Some filename specified? */
1001 if (REISERFS_SB(s)->s_qf_names[qtype]
1002 && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1003 arg)) {
1004 reiserfs_warning(s,
1005 "reiserfs_parse_options: %s quota file already specified.",
1006 QTYPE2NAME(qtype));
1007 return 0;
1008 }
1009 if (strchr(arg, '/')) {
1010 reiserfs_warning(s,
1011 "reiserfs_parse_options: quotafile must be on filesystem root.");
1012 return 0;
1013 }
1014 REISERFS_SB(s)->s_qf_names[qtype] =
1015 kmalloc(strlen(arg) + 1, GFP_KERNEL);
1016 if (!REISERFS_SB(s)->s_qf_names[qtype]) {
1017 reiserfs_warning(s,
1018 "reiserfs_parse_options: not enough memory for storing quotafile name.");
1019 return 0;
1020 }
1021 strcpy(REISERFS_SB(s)->s_qf_names[qtype], arg);
1022 *mount_options |= 1 << REISERFS_QUOTA;
1023 } else {
833d304b
JL		 1024 kfree(REISERFS_SB(s)->s_qf_names[qtype]);
1025 REISERFS_SB(s)->s_qf_names[qtype] = NULL;
bd4c625c 1026 }
1da177e4 1027 }
bd4c625c
LT		 1028 if (c == 'f') {
1029 if (!strcmp(arg, "vfsold"))
1030 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_OLD;
1031 else if (!strcmp(arg, "vfsv0"))
1032 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V0;
1033 else {
1034 reiserfs_warning(s,
1035 "reiserfs_parse_options: unknown quota format specified.");
1036 return 0;
1037 }
1da177e4 1038 }
bd4c625c
LT		 1039#else
1040 if (c == 'u' || c == 'g' || c == 'f') {
1041 reiserfs_warning(s,
1042 "reiserfs_parse_options: journalled quota options not supported.");
1043 return 0;
1da177e4 1044 }
bd4c625c
LT		 1045#endif
1046 }
1047
1048#ifdef CONFIG_QUOTA
1049 if (!REISERFS_SB(s)->s_jquota_fmt
1050 && (REISERFS_SB(s)->s_qf_names[USRQUOTA]
1051 || REISERFS_SB(s)->s_qf_names[GRPQUOTA])) {
1052 reiserfs_warning(s,
1053 "reiserfs_parse_options: journalled quota format not specified.");
1da177e4 1054 return 0;
1da177e4 1055 }
bd4c625c
LT		 1056 /* This checking is not precise wrt the quota type but for our purposes it is sufficient */
1057 if (!(*mount_options & (1 << REISERFS_QUOTA))
1058 && sb_any_quota_enabled(s)) {
1059 reiserfs_warning(s,
1060 "reiserfs_parse_options: quota options must be present when quota is turned on.");
1061 return 0;
1da177e4
LT		 1062 }
1063#endif
556a2a45 1064
bd4c625c 1065 return 1;
1da177e4
LT		 1066}
1067
bd4c625c
LT		 1068static void switch_data_mode(struct super_block *s, unsigned long mode)
1069{
1070 REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1071 (1 << REISERFS_DATA_ORDERED) |
1072 (1 << REISERFS_DATA_WRITEBACK));
1073 REISERFS_SB(s)->s_mount_opt |= (1 << mode);
1da177e4
LT		 1074}
1075
1076static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1077{
bd4c625c
LT		 1078 if (mount_options & (1 << REISERFS_DATA_LOG)) {
1079 if (!reiserfs_data_log(s)) {
1080 switch_data_mode(s, REISERFS_DATA_LOG);
1081 reiserfs_info(s, "switching to journaled data mode\n");
1082 }
1083 } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1084 if (!reiserfs_data_ordered(s)) {
1085 switch_data_mode(s, REISERFS_DATA_ORDERED);
1086 reiserfs_info(s, "switching to ordered data mode\n");
1087 }
1088 } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1089 if (!reiserfs_data_writeback(s)) {
1090 switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1091 reiserfs_info(s, "switching to writeback data mode\n");
1092 }
1093 }
1da177e4
LT		 1094}
1095
bd4c625c
LT		 1096static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1097{
1098 int flush = (1 << REISERFS_BARRIER_FLUSH);
1099 int none = (1 << REISERFS_BARRIER_NONE);
1100 int all_barrier = flush | none;
1101
1102 if (bits & all_barrier) {
1103 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1104 if (bits & flush) {
1105 REISERFS_SB(s)->s_mount_opt |= flush;
1106 printk("reiserfs: enabling write barrier flush mode\n");
1107 } else if (bits & none) {
1108 REISERFS_SB(s)->s_mount_opt |= none;
1109 printk("reiserfs: write barriers turned off\n");
1110 }
1111 }
1da177e4
LT		 1112}
1113
bd4c625c 1114static void handle_attrs(struct super_block *s)
1da177e4 1115{
bd4c625c 1116 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1da177e4 1117
bd4c625c
LT		 1118 if (reiserfs_attrs(s)) {
1119 if (old_format_only(s)) {
1120 reiserfs_warning(s,
1121 "reiserfs: cannot support attributes on 3.5.x disk format");
1122 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1da177e4
LT		 1123 return;
1124 }
bd4c625c
LT		 1125 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1126 reiserfs_warning(s,
1127 "reiserfs: cannot support attributes until flag is set in super-block");
1128 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1da177e4
LT		 1129 }
1130 }
1131}
1132
bd4c625c 1133static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
1da177e4 1134{
bd4c625c
LT		 1135 struct reiserfs_super_block *rs;
1136 struct reiserfs_transaction_handle th;
1137 unsigned long blocks;
1138 unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1139 unsigned long safe_mask = 0;
1140 unsigned int commit_max_age = (unsigned int)-1;
1141 struct reiserfs_journal *journal = SB_JOURNAL(s);
cdf6ccc8 1142 char *new_opts = kstrdup(arg, GFP_KERNEL);
bd4c625c 1143 int err;
1da177e4 1144#ifdef CONFIG_QUOTA
bd4c625c 1145 int i;
1da177e4
LT		 1146#endif
1147
bd4c625c 1148 rs = SB_DISK_SUPER_BLOCK(s);
1da177e4 1149
bd4c625c
LT		 1150 if (!reiserfs_parse_options
1151 (s, arg, &mount_options, &blocks, NULL, &commit_max_age)) {
1da177e4 1152#ifdef CONFIG_QUOTA
833d304b
JL		 1153 for (i = 0; i < MAXQUOTAS; i++) {
1154 kfree(REISERFS_SB(s)->s_qf_names[i]);
1155 REISERFS_SB(s)->s_qf_names[i] = NULL;
1156 }
1da177e4 1157#endif
cdf6ccc8
MS		 1158 err = -EINVAL;
1159 goto out_err;
bd4c625c
LT		 1160 }
1161
1162 handle_attrs(s);
1163
1164 /* Add options that are safe here */
1165 safe_mask |= 1 << REISERFS_SMALLTAIL;
1166 safe_mask |= 1 << REISERFS_LARGETAIL;
1167 safe_mask |= 1 << REISERFS_NO_BORDER;
1168 safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1169 safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1170 safe_mask |= 1 << REISERFS_TEST4;
1171 safe_mask |= 1 << REISERFS_ATTRS;
1172 safe_mask |= 1 << REISERFS_XATTRS_USER;
1173 safe_mask |= 1 << REISERFS_POSIXACL;
1174 safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1175 safe_mask |= 1 << REISERFS_BARRIER_NONE;
1176 safe_mask |= 1 << REISERFS_ERROR_RO;
1177 safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1178 safe_mask |= 1 << REISERFS_ERROR_PANIC;
1179 safe_mask |= 1 << REISERFS_QUOTA;
1180
1181 /* Update the bitmask, taking care to keep
1182 * the bits we're not allowed to change here */
1183 REISERFS_SB(s)->s_mount_opt =
1184 (REISERFS_SB(s)->
1185 s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
1186
1187 if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1188 journal->j_max_commit_age = commit_max_age;
1189 journal->j_max_trans_age = commit_max_age;
1190 } else if (commit_max_age == 0) {
1191 /* 0 means restore defaults. */
1192 journal->j_max_commit_age = journal->j_default_max_commit_age;
1193 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1194 }
1195
1196 if (blocks) {
cdf6ccc8
MS		 1197 err = reiserfs_resize(s, blocks);
1198 if (err != 0)
1199 goto out_err;
bd4c625c
LT		 1200 }
1201
1202 if (*mount_flags & MS_RDONLY) {
1203 reiserfs_xattr_init(s, *mount_flags);
1204 /* remount read-only */
1205 if (s->s_flags & MS_RDONLY)
1206 /* it is read-only already */
cdf6ccc8 1207 goto out_ok;
bd4c625c
LT		 1208 /* try to remount file system with read-only permissions */
1209 if (sb_umount_state(rs) == REISERFS_VALID_FS
1210 || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
cdf6ccc8 1211 goto out_ok;
bd4c625c
LT		 1212 }
1213
1214 err = journal_begin(&th, s, 10);
1215 if (err)
cdf6ccc8 1216 goto out_err;
bd4c625c
LT		 1217
1218 /* Mounting a rw partition read-only. */
1219 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1220 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1221 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1222 } else {
1223 /* remount read-write */
1224 if (!(s->s_flags & MS_RDONLY)) {
1225 reiserfs_xattr_init(s, *mount_flags);
cdf6ccc8 1226 goto out_ok; /* We are read-write already */
bd4c625c
LT		 1227 }
1228
cdf6ccc8
MS		 1229 if (reiserfs_is_journal_aborted(journal)) {
1230 err = journal->j_errno;
1231 goto out_err;
1232 }
bd4c625c
LT		 1233
1234 handle_data_mode(s, mount_options);
1235 handle_barrier_mode(s, mount_options);
1236 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1237 s->s_flags &= ~MS_RDONLY; /* now it is safe to call journal_begin */
1238 err = journal_begin(&th, s, 10);
1239 if (err)
cdf6ccc8 1240 goto out_err;
bd4c625c
LT		 1241
1242 /* Mount a partition which is read-only, read-write */
1243 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1244 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1245 s->s_flags &= ~MS_RDONLY;
1246 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1247 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1248 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1249 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1250 }
1251 /* this will force a full flush of all journal lists */
1252 SB_JOURNAL(s)->j_must_wait = 1;
1253 err = journal_end(&th, s, 10);
1254 if (err)
cdf6ccc8 1255 goto out_err;
bd4c625c
LT		 1256 s->s_dirt = 0;
1257
1258 if (!(*mount_flags & MS_RDONLY)) {
1259 finish_unfinished(s);
1260 reiserfs_xattr_init(s, *mount_flags);
1261 }
1262
cdf6ccc8
MS		 1263out_ok:
1264 kfree(s->s_options);
1265 s->s_options = new_opts;
bd4c625c 1266 return 0;
cdf6ccc8
MS		 1267
1268out_err:
1269 kfree(new_opts);
1270 return err;
1da177e4
LT		 1271}
1272
bd4c625c 1273static int read_super_block(struct super_block *s, int offset)
1da177e4 1274{
bd4c625c
LT		 1275 struct buffer_head *bh;
1276 struct reiserfs_super_block *rs;
1277 int fs_blocksize;
1da177e4 1278
bd4c625c
LT		 1279 bh = sb_bread(s, offset / s->s_blocksize);
1280 if (!bh) {
1281 reiserfs_warning(s, "sh-2006: read_super_block: "
1282 "bread failed (dev %s, block %lu, size %lu)",
1283 reiserfs_bdevname(s), offset / s->s_blocksize,
1284 s->s_blocksize);
1285 return 1;
1286 }
1da177e4 1287
bd4c625c
LT		 1288 rs = (struct reiserfs_super_block *)bh->b_data;
1289 if (!is_any_reiserfs_magic_string(rs)) {
1290 brelse(bh);
1291 return 1;
1292 }
1293 //
1294 // ok, reiserfs signature (old or new) found in at the given offset
1295 //
1296 fs_blocksize = sb_blocksize(rs);
1297 brelse(bh);
1298 sb_set_blocksize(s, fs_blocksize);
1da177e4 1299
bd4c625c
LT		 1300 bh = sb_bread(s, offset / s->s_blocksize);
1301 if (!bh) {
1302 reiserfs_warning(s, "sh-2007: read_super_block: "
1303 "bread failed (dev %s, block %lu, size %lu)\n",
1304 reiserfs_bdevname(s), offset / s->s_blocksize,
1305 s->s_blocksize);
1306 return 1;
1307 }
1da177e4 1308
bd4c625c
LT		 1309 rs = (struct reiserfs_super_block *)bh->b_data;
1310 if (sb_blocksize(rs) != s->s_blocksize) {
1311 reiserfs_warning(s, "sh-2011: read_super_block: "
1312 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1313 reiserfs_bdevname(s),
1314 (unsigned long long)bh->b_blocknr,
1315 s->s_blocksize);
1316 brelse(bh);
1317 return 1;
1318 }
1da177e4 1319
bd4c625c
LT		 1320 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1321 brelse(bh);
1322 reiserfs_warning(s,
1323 "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1324 "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1325 "get newer reiserfsprogs package");
1326 return 1;
1da177e4 1327 }
1da177e4 1328
bd4c625c
LT		 1329 SB_BUFFER_WITH_SB(s) = bh;
1330 SB_DISK_SUPER_BLOCK(s) = rs;
1331
1332 if (is_reiserfs_jr(rs)) {
1333 /* magic is of non-standard journal filesystem, look at s_version to
1334 find which format is in use */
1335 if (sb_version(rs) == REISERFS_VERSION_2)
1336 reiserfs_warning(s,
1337 "read_super_block: found reiserfs format \"3.6\""
1338 " with non-standard journal");
1339 else if (sb_version(rs) == REISERFS_VERSION_1)
1340 reiserfs_warning(s,
1341 "read_super_block: found reiserfs format \"3.5\""
1342 " with non-standard journal");
1343 else {
1344 reiserfs_warning(s,
1345 "sh-2012: read_super_block: found unknown "
1346 "format \"%u\" of reiserfs with non-standard magic",
1347 sb_version(rs));
1348 return 1;
1349 }
1350 } else
1351 /* s_version of standard format may contain incorrect information,
1352 so we just look at the magic string */
1353 reiserfs_info(s,
1354 "found reiserfs format \"%s\" with standard journal\n",
1355 is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1356
1357 s->s_op = &reiserfs_sops;
1358 s->s_export_op = &reiserfs_export_ops;
1da177e4 1359#ifdef CONFIG_QUOTA
bd4c625c
LT		 1360 s->s_qcop = &reiserfs_qctl_operations;
1361 s->dq_op = &reiserfs_quota_operations;
1da177e4
LT		 1362#endif
1363
bd4c625c
LT		 1364 /* new format is limited by the 32 bit wide i_blocks field, want to
1365 ** be one full block below that.
1366 */
1367 s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1368 return 0;
1da177e4
LT		 1369}
1370
1da177e4 1371/* after journal replay, reread all bitmap and super blocks */
bd4c625c
LT		 1372static int reread_meta_blocks(struct super_block *s)
1373{
bd4c625c
LT		 1374 ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
1375 wait_on_buffer(SB_BUFFER_WITH_SB(s));
1376 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1377 reiserfs_warning(s,
1378 "reread_meta_blocks, error reading the super");
1379 return 1;
1380 }
1da177e4 1381
bd4c625c 1382 return 0;
bd4c625c 1383}
1da177e4
LT		 1384
1385/////////////////////////////////////////////////////
1386// hash detection stuff
1387
1da177e4
LT		 1388// if root directory is empty - we set default - Yura's - hash and
1389// warn about it
1390// FIXME: we look for only one name in a directory. If tea and yura
1391// bith have the same value - we ask user to send report to the
1392// mailing list
bd4c625c 1393static __u32 find_hash_out(struct super_block *s)
1da177e4 1394{
bd4c625c
LT		 1395 int retval;
1396 struct inode *inode;
1397 struct cpu_key key;
1398 INITIALIZE_PATH(path);
1399 struct reiserfs_dir_entry de;
1400 __u32 hash = DEFAULT_HASH;
1401
1402 inode = s->s_root->d_inode;
1403
1404 do { // Some serious "goto"-hater was there ;)
1405 u32 teahash, r5hash, yurahash;
1406
1407 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1408 retval = search_by_entry_key(s, &key, &path, &de);
1409 if (retval == IO_ERROR) {
1410 pathrelse(&path);
1411 return UNSET_HASH;
1412 }
1413 if (retval == NAME_NOT_FOUND)
1414 de.de_entry_num--;
1415 set_de_name_and_namelen(&de);
1416 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
1417 /* allow override in this case */
1418 if (reiserfs_rupasov_hash(s)) {
1419 hash = YURA_HASH;
1420 }
1421 reiserfs_warning(s, "FS seems to be empty, autodetect "
1422 "is using the default hash");
1423 break;
1424 }
1425 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1426 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1427 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1428 if (((teahash == r5hash)
1429 &&
1430 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1431 == r5hash)) || ((teahash == yurahash)
1432 && (yurahash ==
1433 GET_HASH_VALUE(deh_offset
1434 (&
1435 (de.
1436 de_deh[de.
1437 de_entry_num])))))
1438 || ((r5hash == yurahash)
1439 && (yurahash ==
1440 GET_HASH_VALUE(deh_offset
1441 (&(de.de_deh[de.de_entry_num])))))) {
1442 reiserfs_warning(s,
1443 "Unable to automatically detect hash function. "
1444 "Please mount with -o hash={tea,rupasov,r5}",
1445 reiserfs_bdevname(s));
1446 hash = UNSET_HASH;
1447 break;
1448 }
1449 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1450 yurahash)
1451 hash = YURA_HASH;
1452 else if (GET_HASH_VALUE
1453 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1454 hash = TEA_HASH;
1455 else if (GET_HASH_VALUE
1456 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1457 hash = R5_HASH;
1458 else {
1459 reiserfs_warning(s, "Unrecognised hash function");
1460 hash = UNSET_HASH;
1461 }
1462 } while (0);
1463
1464 pathrelse(&path);
1465 return hash;
1da177e4
LT		 1466}
1467
1468// finds out which hash names are sorted with
bd4c625c 1469static int what_hash(struct super_block *s)
1da177e4 1470{
bd4c625c
LT		 1471 __u32 code;
1472
1473 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1474
1475 /* reiserfs_hash_detect() == true if any of the hash mount options
1476 ** were used. We must check them to make sure the user isn't
1477 ** using a bad hash value
1478 */
1479 if (code == UNSET_HASH || reiserfs_hash_detect(s))
1480 code = find_hash_out(s);
1481
1482 if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1483 /* detection has found the hash, and we must check against the
1484 ** mount options
1485 */
1486 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1487 reiserfs_warning(s, "Error, %s hash detected, "
1488 "unable to force rupasov hash",
1489 reiserfs_hashname(code));
1490 code = UNSET_HASH;
1491 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1492 reiserfs_warning(s, "Error, %s hash detected, "
1493 "unable to force tea hash",
1494 reiserfs_hashname(code));
1495 code = UNSET_HASH;
1496 } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1497 reiserfs_warning(s, "Error, %s hash detected, "
1498 "unable to force r5 hash",
1499 reiserfs_hashname(code));
1500 code = UNSET_HASH;
1501 }
1502 } else {
1503 /* find_hash_out was not called or could not determine the hash */
1504 if (reiserfs_rupasov_hash(s)) {
1505 code = YURA_HASH;
1506 } else if (reiserfs_tea_hash(s)) {
1507 code = TEA_HASH;
1508 } else if (reiserfs_r5_hash(s)) {
1509 code = R5_HASH;
1510 }
1511 }
1512
1513 /* if we are mounted RW, and we have a new valid hash code, update
1514 ** the super
1515 */
1516 if (code != UNSET_HASH &&
1517 !(s->s_flags & MS_RDONLY) &&
1518 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1519 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1520 }
1521 return code;
1da177e4
LT		 1522}
1523
1524// return pointer to appropriate function
bd4c625c 1525static hashf_t hash_function(struct super_block *s)
1da177e4 1526{
bd4c625c
LT		 1527 switch (what_hash(s)) {
1528 case TEA_HASH:
1529 reiserfs_info(s, "Using tea hash to sort names\n");
1530 return keyed_hash;
1531 case YURA_HASH:
1532 reiserfs_info(s, "Using rupasov hash to sort names\n");
1533 return yura_hash;
1534 case R5_HASH:
1535 reiserfs_info(s, "Using r5 hash to sort names\n");
1536 return r5_hash;
1537 }
1538 return NULL;
1da177e4
LT		 1539}
1540
1541// this is used to set up correct value for old partitions
bd4c625c 1542static int function2code(hashf_t func)
1da177e4 1543{
bd4c625c
LT		 1544 if (func == keyed_hash)
1545 return TEA_HASH;
1546 if (func == yura_hash)
1547 return YURA_HASH;
1548 if (func == r5_hash)
1549 return R5_HASH;
1da177e4 1550
bd4c625c 1551 BUG(); // should never happen
1da177e4 1552
bd4c625c 1553 return 0;
1da177e4
LT		 1554}
1555
1556#define SWARN(silent, s, ...) \
1557 if (!(silent)) \
1558 reiserfs_warning (s, __VA_ARGS__)
1559
bd4c625c 1560static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1da177e4 1561{
bd4c625c 1562 struct inode *root_inode;
bd4c625c
LT		 1563 struct reiserfs_transaction_handle th;
1564 int old_format = 0;
1565 unsigned long blocks;
1566 unsigned int commit_max_age = 0;
1567 int jinit_done = 0;
1568 struct reiserfs_iget_args args;
1569 struct reiserfs_super_block *rs;
1570 char *jdev_name;
1571 struct reiserfs_sb_info *sbi;
1572 int errval = -EINVAL;
1573
cdf6ccc8
MS		 1574 save_mount_options(s, data);
1575
01afb213 1576 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
bd4c625c
LT		 1577 if (!sbi) {
1578 errval = -ENOMEM;
1579 goto error;
1580 }
1581 s->s_fs_info = sbi;
bd4c625c
LT		 1582 /* Set default values for options: non-aggressive tails, RO on errors */
1583 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1584 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1585 /* no preallocation minimum, be smart in
1586 reiserfs_file_write instead */
1587 REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1588 /* Preallocate by 16 blocks (17-1) at once */
1589 REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
fe08a9d4 1590#ifdef CONFIG_REISERFS_FS_XATTR
bd4c625c
LT		 1591 /* Initialize the rwsem for xattr dir */
1592 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
fe08a9d4 1593#endif
bd4c625c
LT		 1594 /* setup default block allocator options */
1595 reiserfs_init_alloc_options(s);
1596
1597 jdev_name = NULL;
1598 if (reiserfs_parse_options
1599 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
1600 &commit_max_age) == 0) {
1601 goto error;
1602 }
1603
1604 if (blocks) {
1605 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1606 "for remount only");
1607 goto error;
1608 }
1609
1610 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1611 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1612 old_format = 1;
1613 /* try new format (64-th 1k block), which can contain reiserfs super block */
1614 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1615 SWARN(silent, s,
1616 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",
1617 reiserfs_bdevname(s));
1618 goto error;
1619 }
1620
1621 rs = SB_DISK_SUPER_BLOCK(s);
1622 /* Let's do basic sanity check to verify that underlying device is not
1623 smaller than the filesystem. If the check fails then abort and scream,
1624 because bad stuff will happen otherwise. */
1625 if (s->s_bdev && s->s_bdev->bd_inode
1626 && i_size_read(s->s_bdev->bd_inode) <
1627 sb_block_count(rs) * sb_blocksize(rs)) {
1628 SWARN(silent, s,
1629 "Filesystem on %s cannot be mounted because it is bigger than the device",
1630 reiserfs_bdevname(s));
1631 SWARN(silent, s,
1632 "You may need to run fsck or increase size of your LVM partition");
1633 SWARN(silent, s,
1634 "Or may be you forgot to reboot after fdisk when it told you to");
1635 goto error;
1636 }
1637
1638 sbi->s_mount_state = SB_REISERFS_STATE(s);
1639 sbi->s_mount_state = REISERFS_VALID_FS;
1640
6f01046b 1641 if ((errval = reiserfs_init_bitmap_cache(s))) {
bd4c625c
LT		 1642 SWARN(silent, s,
1643 "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1644 goto error;
1645 }
d2c89a42 1646 errval = -EINVAL;
1da177e4 1647#ifdef CONFIG_REISERFS_CHECK
bd4c625c
LT		 1648 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");
1649 SWARN(silent, s, "- it is slow mode for debugging.");
1da177e4
LT		 1650#endif
1651
bd4c625c
LT		 1652 /* make data=ordered the default */
1653 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1654 !reiserfs_data_writeback(s)) {
1655 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1656 }
1657
1658 if (reiserfs_data_log(s)) {
1659 reiserfs_info(s, "using journaled data mode\n");
1660 } else if (reiserfs_data_ordered(s)) {
1661 reiserfs_info(s, "using ordered data mode\n");
1662 } else {
1663 reiserfs_info(s, "using writeback data mode\n");
1664 }
1665 if (reiserfs_barrier_flush(s)) {
1666 printk("reiserfs: using flush barriers\n");
1667 }
1668 // set_device_ro(s->s_dev, 1) ;
1669 if (journal_init(s, jdev_name, old_format, commit_max_age)) {
1670 SWARN(silent, s,
1671 "sh-2022: reiserfs_fill_super: unable to initialize journal space");
1672 goto error;
1673 } else {
1674 jinit_done = 1; /* once this is set, journal_release must be called
1675 ** if we error out of the mount
1676 */
1677 }
1678 if (reread_meta_blocks(s)) {
1679 SWARN(silent, s,
1680 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");
1681 goto error;
1682 }
1683
1684 if (replay_only(s))
1685 goto error;
1686
1687 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1688 SWARN(silent, s,
1689 "clm-7000: Detected readonly device, marking FS readonly");
1690 s->s_flags |= MS_RDONLY;
1691 }
1692 args.objectid = REISERFS_ROOT_OBJECTID;
1693 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1694 root_inode =
1695 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1696 reiserfs_init_locked_inode, (void *)(&args));
1697 if (!root_inode) {
1698 SWARN(silent, s,
1699 "jmacd-10: reiserfs_fill_super: get root inode failed");
1700 goto error;
1701 }
1702
1703 if (root_inode->i_state & I_NEW) {
1704 reiserfs_read_locked_inode(root_inode, &args);
1705 unlock_new_inode(root_inode);
1706 }
1707
1708 s->s_root = d_alloc_root(root_inode);
1709 if (!s->s_root) {
1710 iput(root_inode);
1711 goto error;
1712 }
1713 // define and initialize hash function
1714 sbi->s_hash_function = hash_function(s);
1715 if (sbi->s_hash_function == NULL) {
1716 dput(s->s_root);
1717 s->s_root = NULL;
1718 goto error;
1719 }
1720
1721 if (is_reiserfs_3_5(rs)
1722 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
1723 set_bit(REISERFS_3_5, &(sbi->s_properties));
e1fabd3c
JM		 1724 else if (old_format)
1725 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
bd4c625c
LT		 1726 else
1727 set_bit(REISERFS_3_6, &(sbi->s_properties));
1728
1729 if (!(s->s_flags & MS_RDONLY)) {
1730
1731 errval = journal_begin(&th, s, 1);
1732 if (errval) {
1733 dput(s->s_root);
1734 s->s_root = NULL;
1735 goto error;
1736 }
1737 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1738
1739 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1740 set_sb_fs_state(rs, 0);
1741
cb680c1b
JM		 1742 /* Clear out s_bmap_nr if it would wrap. We can handle this
1743 * case, but older revisions can't. This will cause the
1744 * file system to fail mount on those older implementations,
1745 * avoiding corruption. -jeffm */
1746 if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
1747 sb_bmap_nr(rs) != 0) {
1748 reiserfs_warning(s, "super-2030: This file system "
1749 "claims to use %u bitmap blocks in "
1750 "its super block, but requires %u. "
1751 "Clearing to zero.", sb_bmap_nr(rs),
1752 reiserfs_bmap_count(s));
1753
1754 set_sb_bmap_nr(rs, 0);
1755 }
1756
bd4c625c
LT		 1757 if (old_format_only(s)) {
1758 /* filesystem of format 3.5 either with standard or non-standard
1759 journal */
1760 if (convert_reiserfs(s)) {
1761 /* and -o conv is given */
1762 if (!silent)
1763 reiserfs_info(s,
1764 "converting 3.5 filesystem to the 3.6 format");
1765
1766 if (is_reiserfs_3_5(rs))
1767 /* put magic string of 3.6 format. 2.2 will not be able to
1768 mount this filesystem anymore */
1769 memcpy(rs->s_v1.s_magic,
1770 reiserfs_3_6_magic_string,
1771 sizeof
1772 (reiserfs_3_6_magic_string));
1773
1774 set_sb_version(rs, REISERFS_VERSION_2);
1775 reiserfs_convert_objectid_map_v1(s);
1776 set_bit(REISERFS_3_6, &(sbi->s_properties));
1777 clear_bit(REISERFS_3_5, &(sbi->s_properties));
1778 } else if (!silent) {
1779 reiserfs_info(s, "using 3.5.x disk format\n");
1780 }
1781 }
1782
1783 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1784 errval = journal_end(&th, s, 1);
1785 if (errval) {
1786 dput(s->s_root);
1787 s->s_root = NULL;
1788 goto error;
1789 }
1790
1791 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1792 dput(s->s_root);
1793 s->s_root = NULL;
1794 goto error;
1795 }
1796
1797 /* look for files which were to be removed in previous session */
1798 finish_unfinished(s);
1799 } else {
1800 if (old_format_only(s) && !silent) {
1801 reiserfs_info(s, "using 3.5.x disk format\n");
1802 }
1803
1804 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1805 dput(s->s_root);
1806 s->s_root = NULL;
1807 goto error;
1808 }
1809 }
1810 // mark hash in super block: it could be unset. overwrite should be ok
1811 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1812
1813 handle_attrs(s);
1814
1815 reiserfs_proc_info_init(s);
1816
1817 init_waitqueue_head(&(sbi->s_wait));
1818 spin_lock_init(&sbi->bitmap_lock);
1819
1820 return (0);
1821
1822 error:
1823 if (jinit_done) { /* kill the commit thread, free journal ram */
1824 journal_release_error(NULL, s);
1825 }
5065227b
JM		 1826
1827 reiserfs_free_bitmap_cache(s);
bd4c625c
LT		 1828 if (SB_BUFFER_WITH_SB(s))
1829 brelse(SB_BUFFER_WITH_SB(s));
1da177e4 1830#ifdef CONFIG_QUOTA
5065227b
JM		 1831 {
1832 int j;
1833 for (j = 0; j < MAXQUOTAS; j++) {
1834 kfree(sbi->s_qf_names[j]);
1835 sbi->s_qf_names[j] = NULL;
1836 }
bd4c625c 1837 }
1da177e4 1838#endif
833d304b 1839 kfree(sbi);
1da177e4 1840
bd4c625c
LT		 1841 s->s_fs_info = NULL;
1842 return errval;
1da177e4
LT		 1843}
1844
726c3342 1845static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4 1846{
726c3342 1847 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
bd4c625c
LT		 1848
1849 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1850 buf->f_bfree = sb_free_blocks(rs);
1851 buf->f_bavail = buf->f_bfree;
1852 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
726c3342 1853 buf->f_bsize = dentry->d_sb->s_blocksize;
bd4c625c
LT		 1854 /* changed to accommodate gcc folks. */
1855 buf->f_type = REISERFS_SUPER_MAGIC;
1856 return 0;
1da177e4
LT		 1857}
1858
1859#ifdef CONFIG_QUOTA
1860static int reiserfs_dquot_initialize(struct inode *inode, int type)
1861{
bd4c625c
LT		 1862 struct reiserfs_transaction_handle th;
1863 int ret, err;
1864
1865 /* We may create quota structure so we need to reserve enough blocks */
1866 reiserfs_write_lock(inode->i_sb);
1867 ret =
1868 journal_begin(&th, inode->i_sb,
1869 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1870 if (ret)
1871 goto out;
1872 ret = dquot_initialize(inode, type);
1873 err =
1874 journal_end(&th, inode->i_sb,
1875 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1876 if (!ret && err)
1877 ret = err;
1878 out:
1879 reiserfs_write_unlock(inode->i_sb);
1880 return ret;
1da177e4
LT		 1881}
1882
1883static int reiserfs_dquot_drop(struct inode *inode)
1884{
bd4c625c
LT		 1885 struct reiserfs_transaction_handle th;
1886 int ret, err;
1887
1888 /* We may delete quota structure so we need to reserve enough blocks */
1889 reiserfs_write_lock(inode->i_sb);
1890 ret =
1891 journal_begin(&th, inode->i_sb,
1892 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
a2fe594f
JK		 1893 if (ret) {
1894 /*
1895 * We call dquot_drop() anyway to at least release references
1896 * to quota structures so that umount does not hang.
1897 */
1898 dquot_drop(inode);
bd4c625c 1899 goto out;
a2fe594f 1900 }
bd4c625c
LT		 1901 ret = dquot_drop(inode);
1902 err =
1903 journal_end(&th, inode->i_sb,
1904 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1905 if (!ret && err)
1906 ret = err;
1907 out:
1908 reiserfs_write_unlock(inode->i_sb);
1909 return ret;
1da177e4
LT		 1910}
1911
1912static int reiserfs_write_dquot(struct dquot *dquot)
1913{
bd4c625c
LT		 1914 struct reiserfs_transaction_handle th;
1915 int ret, err;
1916
1917 reiserfs_write_lock(dquot->dq_sb);
1918 ret =
1919 journal_begin(&th, dquot->dq_sb,
1920 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1921 if (ret)
1922 goto out;
1923 ret = dquot_commit(dquot);
1924 err =
1925 journal_end(&th, dquot->dq_sb,
1926 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1927 if (!ret && err)
1928 ret = err;
1929 out:
1930 reiserfs_write_unlock(dquot->dq_sb);
1931 return ret;
1da177e4
LT		 1932}
1933
1934static int reiserfs_acquire_dquot(struct dquot *dquot)
1935{
bd4c625c
LT		 1936 struct reiserfs_transaction_handle th;
1937 int ret, err;
1938
1939 reiserfs_write_lock(dquot->dq_sb);
1940 ret =
1941 journal_begin(&th, dquot->dq_sb,
1942 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1943 if (ret)
1944 goto out;
1945 ret = dquot_acquire(dquot);
1946 err =
1947 journal_end(&th, dquot->dq_sb,
1948 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1949 if (!ret && err)
1950 ret = err;
1951 out:
1952 reiserfs_write_unlock(dquot->dq_sb);
1953 return ret;
1da177e4
LT		 1954}
1955
1956static int reiserfs_release_dquot(struct dquot *dquot)
1957{
bd4c625c
LT		 1958 struct reiserfs_transaction_handle th;
1959 int ret, err;
1960
1961 reiserfs_write_lock(dquot->dq_sb);
1962 ret =
1963 journal_begin(&th, dquot->dq_sb,
1964 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
9c3013e9
JK		 1965 if (ret) {
1966 /* Release dquot anyway to avoid endless cycle in dqput() */
1967 dquot_release(dquot);
bd4c625c 1968 goto out;
9c3013e9 1969 }
bd4c625c
LT		 1970 ret = dquot_release(dquot);
1971 err =
1972 journal_end(&th, dquot->dq_sb,
1973 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1974 if (!ret && err)
1975 ret = err;
1976 out:
1977 reiserfs_write_unlock(dquot->dq_sb);
1978 return ret;
1da177e4
LT		 1979}
1980
1981static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
1982{
bd4c625c
LT		 1983 /* Are we journalling quotas? */
1984 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
1985 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
1986 dquot_mark_dquot_dirty(dquot);
1987 return reiserfs_write_dquot(dquot);
1988 } else
1989 return dquot_mark_dquot_dirty(dquot);
1da177e4
LT		 1990}
1991
1992static int reiserfs_write_info(struct super_block *sb, int type)
1993{
bd4c625c
LT		 1994 struct reiserfs_transaction_handle th;
1995 int ret, err;
1996
1997 /* Data block + inode block */
1998 reiserfs_write_lock(sb);
1999 ret = journal_begin(&th, sb, 2);
2000 if (ret)
2001 goto out;
2002 ret = dquot_commit_info(sb, type);
2003 err = journal_end(&th, sb, 2);
2004 if (!ret && err)
2005 ret = err;
2006 out:
2007 reiserfs_write_unlock(sb);
2008 return ret;
1da177e4
LT		 2009}
2010
2011/*
84de856e 2012 * Turn on quotas during mount time - we need to find the quota file and such...
1da177e4
LT		 2013 */
2014static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2015{
84de856e 2016 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
bd4c625c 2017 REISERFS_SB(sb)->s_jquota_fmt, type);
1da177e4
LT		 2018}
2019
2020/*
2021 * Standard function to be called on quota_on
2022 */
bd4c625c 2023static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
1b445a9c 2024 char *path, int remount)
1da177e4 2025{
bd4c625c
LT		 2026 int err;
2027 struct nameidata nd;
d5dee5c3 2028 struct inode *inode;
bd4c625c
LT		 2029
2030 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2031 return -EINVAL;
1b445a9c
JK		 2032 /* No more checks needed? Path and format_id are bogus anyway... */
2033 if (remount)
2034 return vfs_quota_on(sb, type, format_id, path, 1);
bd4c625c
LT		 2035 err = path_lookup(path, LOOKUP_FOLLOW, &nd);
2036 if (err)
2037 return err;
2038 /* Quotafile not on the same filesystem? */
4ac91378 2039 if (nd.path.mnt->mnt_sb != sb) {
1d957f9b 2040 path_put(&nd.path);
bd4c625c
LT		 2041 return -EXDEV;
2042 }
d5dee5c3 2043 inode = nd.path.dentry->d_inode;
bd4c625c 2044 /* We must not pack tails for quota files on reiserfs for quota IO to work */
d5dee5c3
JK		 2045 if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2046 err = reiserfs_unpack(inode, NULL);
2047 if (err) {
2048 reiserfs_warning(sb,
2049 "reiserfs: Unpacking tail of quota file failed"
2050 " (%d). Cannot turn on quotas.", err);
2051 path_put(&nd.path);
2052 return -EINVAL;
2053 }
2054 mark_inode_dirty(inode);
bd4c625c
LT		 2055 }
2056 /* Not journalling quota? No more tests needed... */
2057 if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] &&
2058 !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) {
1d957f9b 2059 path_put(&nd.path);
1b445a9c 2060 return vfs_quota_on(sb, type, format_id, path, 0);
bd4c625c
LT		 2061 }
2062 /* Quotafile not of fs root? */
4ac91378 2063 if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)
bd4c625c
LT		 2064 reiserfs_warning(sb,
2065 "reiserfs: Quota file not on filesystem root. "
2066 "Journalled quota will not work.");
1d957f9b 2067 path_put(&nd.path);
1b445a9c 2068 return vfs_quota_on(sb, type, format_id, path, 0);
1da177e4
LT		 2069}
2070
2071/* Read data from quotafile - avoid pagecache and such because we cannot afford
2072 * acquiring the locks... As quota files are never truncated and quota code
2073 * itself serializes the operations (and noone else should touch the files)
2074 * we don't have to be afraid of races */
2075static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2076 size_t len, loff_t off)
2077{
bd4c625c
LT		 2078 struct inode *inode = sb_dqopt(sb)->files[type];
2079 unsigned long blk = off >> sb->s_blocksize_bits;
2080 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2081 size_t toread;
2082 struct buffer_head tmp_bh, *bh;
2083 loff_t i_size = i_size_read(inode);
2084
2085 if (off > i_size)
2086 return 0;
2087 if (off + len > i_size)
2088 len = i_size - off;
2089 toread = len;
2090 while (toread > 0) {
2091 tocopy =
2092 sb->s_blocksize - offset <
2093 toread ? sb->s_blocksize - offset : toread;
2094 tmp_bh.b_state = 0;
2095 /* Quota files are without tails so we can safely use this function */
2096 reiserfs_write_lock(sb);
2097 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2098 reiserfs_write_unlock(sb);
2099 if (err)
2100 return err;
2101 if (!buffer_mapped(&tmp_bh)) /* A hole? */
2102 memset(data, 0, tocopy);
2103 else {
2104 bh = sb_bread(sb, tmp_bh.b_blocknr);
2105 if (!bh)
2106 return -EIO;
2107 memcpy(data, bh->b_data + offset, tocopy);
2108 brelse(bh);
2109 }
2110 offset = 0;
2111 toread -= tocopy;
2112 data += tocopy;
2113 blk++;
2114 }
2115 return len;
1da177e4
LT		 2116}
2117
2118/* Write to quotafile (we know the transaction is already started and has
2119 * enough credits) */
2120static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2121 const char *data, size_t len, loff_t off)
2122{
bd4c625c
LT		 2123 struct inode *inode = sb_dqopt(sb)->files[type];
2124 unsigned long blk = off >> sb->s_blocksize_bits;
2125 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2126 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2127 size_t towrite = len;
2128 struct buffer_head tmp_bh, *bh;
2129
9c3013e9
JK		 2130 if (!current->journal_info) {
2131 printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2132 " cancelled because transaction is not started.\n",
2133 (unsigned long long)off, (unsigned long long)len);
2134 return -EIO;
2135 }
5c81a419 2136 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
bd4c625c
LT		 2137 while (towrite > 0) {
2138 tocopy = sb->s_blocksize - offset < towrite ?
2139 sb->s_blocksize - offset : towrite;
2140 tmp_bh.b_state = 0;
2141 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2142 if (err)
2143 goto out;
2144 if (offset || tocopy != sb->s_blocksize)
2145 bh = sb_bread(sb, tmp_bh.b_blocknr);
2146 else
2147 bh = sb_getblk(sb, tmp_bh.b_blocknr);
2148 if (!bh) {
2149 err = -EIO;
2150 goto out;
2151 }
2152 lock_buffer(bh);
2153 memcpy(bh->b_data + offset, data, tocopy);
2154 flush_dcache_page(bh->b_page);
2155 set_buffer_uptodate(bh);
2156 unlock_buffer(bh);
2157 reiserfs_prepare_for_journal(sb, bh, 1);
2158 journal_mark_dirty(current->journal_info, sb, bh);
2159 if (!journal_quota)
2160 reiserfs_add_ordered_list(inode, bh);
2161 brelse(bh);
2162 offset = 0;
2163 towrite -= tocopy;
2164 data += tocopy;
2165 blk++;
2166 }
9c3013e9 2167out:
bd4c625c
LT		 2168 if (len == towrite)
2169 return err;
2170 if (inode->i_size < off + len - towrite)
2171 i_size_write(inode, off + len - towrite);
2172 inode->i_version++;
2173 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2174 mark_inode_dirty(inode);
1b1dcc1b 2175 mutex_unlock(&inode->i_mutex);
bd4c625c 2176 return len - towrite;
1da177e4
LT		 2177}
2178
2179#endif
2180
454e2398
DH		 2181static int get_super_block(struct file_system_type *fs_type,
2182 int flags, const char *dev_name,
2183 void *data, struct vfsmount *mnt)
1da177e4 2184{
454e2398
DH		 2185 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2186 mnt);
1da177e4
LT		 2187}
2188
bd4c625c 2189static int __init init_reiserfs_fs(void)
1da177e4
LT		 2190{
2191 int ret;
2192
bd4c625c 2193 if ((ret = init_inodecache())) {
1da177e4
LT		 2194 return ret;
2195 }
2196
bd4c625c
LT		 2197 if ((ret = reiserfs_xattr_register_handlers()))
2198 goto failed_reiserfs_xattr_register_handlers;
1da177e4 2199
bd4c625c
LT		 2200 reiserfs_proc_info_global_init();
2201 reiserfs_proc_register_global("version",
2202 reiserfs_global_version_in_proc);
1da177e4 2203
bd4c625c 2204 ret = register_filesystem(&reiserfs_fs_type);
1da177e4
LT		 2205
2206 if (ret == 0) {
2207 return 0;
2208 }
2209
bd4c625c 2210 reiserfs_xattr_unregister_handlers();
1da177e4 2211
bd4c625c
LT		 2212 failed_reiserfs_xattr_register_handlers:
2213 reiserfs_proc_unregister_global("version");
2214 reiserfs_proc_info_global_done();
2215 destroy_inodecache();
1da177e4
LT		 2216
2217 return ret;
2218}
2219
bd4c625c 2220static void __exit exit_reiserfs_fs(void)
1da177e4 2221{
bd4c625c
LT		 2222 reiserfs_xattr_unregister_handlers();
2223 reiserfs_proc_unregister_global("version");
2224 reiserfs_proc_info_global_done();
2225 unregister_filesystem(&reiserfs_fs_type);
2226 destroy_inodecache();
1da177e4
LT		 2227}
2228
2229struct file_system_type reiserfs_fs_type = {
bd4c625c
LT		 2230 .owner = THIS_MODULE,
2231 .name = "reiserfs",
2232 .get_sb = get_super_block,
edc666e2 2233 .kill_sb = reiserfs_kill_sb,
bd4c625c 2234 .fs_flags = FS_REQUIRES_DEV,
1da177e4
LT		 2235};
2236
bd4c625c
LT		 2237MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2238MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2239MODULE_LICENSE("GPL");
1da177e4 2240
bd4c625c
LT		 2241module_init(init_reiserfs_fs);
2242module_exit(exit_reiserfs_fs);
Linux 6.x block layer and io_uring tree(s)