blob: 663a91f5dce8a33d4f12c85658122a62da216bc8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/init.h>
22#include <linux/blkdev.h>
23#include <linux/buffer_head.h>
Christoph Hellwiga5694252007-07-17 04:04:28 -070024#include <linux/exportfs.h>
Jan Kara74abb982008-07-25 01:46:51 -070025#include <linux/quotaops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/vfs.h>
Kirill Korotaev6b3286e2006-12-08 02:37:56 -080027#include <linux/mnt_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/mount.h>
29#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
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
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070037int is_reiserfs_3_5(struct reiserfs_super_block *rs)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070039 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
40 strlen(reiserfs_3_5_magic_string));
Linus Torvalds1da177e2005-04-16 15:20:36 -070041}
42
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070043int is_reiserfs_3_6(struct reiserfs_super_block *rs)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070045 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
46 strlen(reiserfs_3_6_magic_string));
Linus Torvalds1da177e2005-04-16 15:20:36 -070047}
48
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070049int is_reiserfs_jr(struct reiserfs_super_block *rs)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070051 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
52 strlen(reiserfs_jr_magic_string));
Linus Torvalds1da177e2005-04-16 15:20:36 -070053}
54
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070055static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070057 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
58 is_reiserfs_jr(rs));
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070061static int reiserfs_remount(struct super_block *s, int *flags, char *data);
David Howells726c3342006-06-23 02:02:58 -070062static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070064static int reiserfs_sync_fs(struct super_block *s, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070066 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
81static void reiserfs_write_super(struct super_block *s)
82{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070083 reiserfs_sync_fs(s, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070086static void reiserfs_write_super_lockfs(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070088 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700106static void reiserfs_unlockfs(struct super_block *s)
107{
108 reiserfs_allow_writes(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
110
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700111extern const struct in_core_key MAX_IN_CORE_KEY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
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 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700120static int remove_save_link_only(struct super_block *s,
121 struct reiserfs_key *key, int oid_free)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700123 struct reiserfs_transaction_handle th;
124 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700126 /* we are going to do one balancing */
127 err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);
128 if (err)
129 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700131 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139#ifdef CONFIG_QUOTA
140static int reiserfs_quota_on_mount(struct super_block *, int);
141#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/* look for uncompleted unlinks and truncates and complete them */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700144static int finish_unfinished(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700146 INITIALIZE_PATH(path);
147 struct cpu_key max_cpu_key, obj_key;
Lepton Wufb46f342007-10-16 23:30:04 -0700148 struct reiserfs_key save_link_key, last_inode_key;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700149 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700158 int i;
159 int ms_active_set;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700161
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Lepton Wufb46f342007-10-16 23:30:04 -0700169 memset(&last_inode_key, 0, sizeof(last_inode_key));
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700172 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700179 /* 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,
Jan Kara45065672008-07-25 01:46:37 -0700185 "reiserfs: cannot turn on journaled quota: error %d",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700186 ret);
187 }
188 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700191 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700202 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));
Lepton Wufb46f342007-10-16 23:30:04 -0700283 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 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700295 }
296
297 iput(inode);
298 printk("done\n");
299 done++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700301 REISERFS_SB(s)->s_is_unlinked_ok = 0;
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700304 /* Turn quotas off */
305 for (i = 0; i < MAXQUOTAS; i++) {
306 if (sb_dqopt(s)->files[i])
Jan Kara1b445a92008-04-28 02:14:35 -0700307 vfs_quota_off(s, i, 0);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700308 }
309 if (ms_active_set)
310 /* Restore the flag back */
311 s->s_flags &= ~MS_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700313 pathrelse(&path);
314 if (done)
315 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
316 "Completed\n", done);
317 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320/* 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
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200322 item of file. mounting the filesystem we scan all these links and remove
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 files which almost got lost */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700324void add_save_link(struct reiserfs_transaction_handle *th,
325 struct inode *inode, int truncate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700327 INITIALIZE_PATH(path);
328 int retval;
329 struct cpu_key key;
330 struct item_head ih;
331 __le32 link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700333 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700335 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700345 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700354 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700367 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700373 /* 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700384 /* body of "save" link */
385 link = INODE_PKEY(inode)->k_dir_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700387 /* 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402}
403
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404/* this opens transaction unlike add_save_link */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700405int remove_save_link(struct inode *inode, int truncate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700407 struct reiserfs_transaction_handle th;
408 struct reiserfs_key key;
409 int err;
410
411 /* we are going to do one balancing only */
412 err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
413 if (err)
414 return err;
415
416 /* setup key of "save" link */
417 key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID);
418 key.k_objectid = INODE_PKEY(inode)->k_objectid;
419 if (!truncate) {
420 /* unlink, rmdir, rename */
421 set_le_key_k_offset(KEY_FORMAT_3_5, &key,
422 1 + inode->i_sb->s_blocksize);
423 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);
424 } else {
425 /* truncate */
426 set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1);
427 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
428 }
429
430 if ((truncate &&
431 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||
432 (!truncate &&
433 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask)))
434 /* don't take quota bytes from anywhere */
435 reiserfs_delete_solid_item(&th, NULL, &key);
436 if (!truncate) {
437 reiserfs_release_objectid(&th, inode->i_ino);
438 REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;
439 } else
440 REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;
441
442 return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443}
444
David Howellsedc666e2006-10-11 01:22:14 -0700445static void reiserfs_kill_sb(struct super_block *s)
446{
447 if (REISERFS_SB(s)) {
Alexey Dobriyanfe08a9d2007-05-08 00:24:55 -0700448#ifdef CONFIG_REISERFS_FS_XATTR
David Howellsedc666e2006-10-11 01:22:14 -0700449 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 }
Alexey Dobriyanfe08a9d2007-05-08 00:24:55 -0700454#endif
David Howellsedc666e2006-10-11 01:22:14 -0700455 if (REISERFS_SB(s)->priv_root) {
456 d_invalidate(REISERFS_SB(s)->priv_root);
457 dput(REISERFS_SB(s)->priv_root);
458 REISERFS_SB(s)->priv_root = NULL;
459 }
460 }
461
462 kill_block_super(s);
463}
464
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700465static void reiserfs_put_super(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700467 struct reiserfs_transaction_handle th;
468 th.t_trans_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700470 /* 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700481 /* note, journal_release checks for readonly mount, and can decide not
482 ** to do a journal_end
483 */
484 journal_release(&th, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Jeff Mahoney50652272006-09-30 23:28:44 -0700486 reiserfs_free_bitmap_cache(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700488 brelse(SB_BUFFER_WITH_SB(s));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700490 print_statistics(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700492 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700498 reiserfs_proc_info_done(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700500 kfree(s->s_fs_info);
501 s->s_fs_info = NULL;
502
503 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504}
505
Christoph Lametere18b8902006-12-06 20:33:20 -0800506static struct kmem_cache *reiserfs_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
508static struct inode *reiserfs_alloc_inode(struct super_block *sb)
509{
510 struct reiserfs_inode_info *ei;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700511 ei = (struct reiserfs_inode_info *)
Christoph Lametere94b1762006-12-06 20:33:17 -0800512 kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 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
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700523static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700525 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Christoph Lametera35afb82007-05-16 22:10:57 -0700527 INIT_LIST_HEAD(&ei->i_prealloc_list);
528 inode_init_once(&ei->vfs_inode);
Alexey Dobriyancfe14672006-09-29 02:00:00 -0700529#ifdef CONFIG_REISERFS_FS_POSIX_ACL
Christoph Lametera35afb82007-05-16 22:10:57 -0700530 ei->i_acl_access = NULL;
531 ei->i_acl_default = NULL;
Alexey Dobriyancfe14672006-09-29 02:00:00 -0700532#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535static int init_inodecache(void)
536{
537 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700538 sizeof(struct
539 reiserfs_inode_info),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800540 0, (SLAB_RECLAIM_ACCOUNT|
541 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900542 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (reiserfs_inode_cachep == NULL)
544 return -ENOMEM;
545 return 0;
546}
547
548static void destroy_inodecache(void)
549{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700550 kmem_cache_destroy(reiserfs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551}
552
553/* we don't mark inodes dirty, we just log them */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700554static void reiserfs_dirty_inode(struct inode *inode)
555{
556 struct reiserfs_transaction_handle th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700558 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700567 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
Alexey Dobriyancfe14672006-09-29 02:00:00 -0700580#ifdef CONFIG_REISERFS_FS_POSIX_ACL
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700581static void reiserfs_clear_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700583 struct posix_acl *acl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700585 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700590 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
Alexey Dobriyancfe14672006-09-29 02:00:00 -0700595#else
596#define reiserfs_clear_inode NULL
597#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700600static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604#endif
605
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800606static const struct super_operations reiserfs_sops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700607 .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,
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -0800620 .show_options = generic_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700622 .quota_read = reiserfs_quota_read,
623 .quota_write = reiserfs_quota_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624#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);
Jan Kara1b445a92008-04-28 02:14:35 -0700637static int reiserfs_quota_on(struct super_block *, int, int, char *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700639static 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652};
653
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700654static 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662};
663#endif
664
Christoph Hellwig39655162007-10-21 16:42:17 -0700665static const struct export_operations reiserfs_export_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700666 .encode_fh = reiserfs_encode_fh,
Christoph Hellwigbe55caf2007-10-21 16:42:13 -0700667 .fh_to_dentry = reiserfs_fh_to_dentry,
668 .fh_to_parent = reiserfs_fh_to_parent,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700669 .get_parent = reiserfs_get_parent,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700670};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
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 {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700675 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681} 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 {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700689 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697} opt_desc_t;
698
699/* possible values for -o data= */
700static const arg_desc_t logging_mode[] = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700701 {"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)},
Vladimir V. Savelievcd02b962006-03-25 03:07:15 -0800707 {.value = NULL}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708};
709
710/* possible values for -o barrier= */
711static const arg_desc_t barrier_mode[] = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700712 {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
713 {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
Vladimir V. Savelievcd02b962006-03-25 03:07:15 -0800714 {.value = NULL}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715};
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[] = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700720 {"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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727};
728
729static const arg_desc_t tails[] = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700730 {"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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734};
735
736static const arg_desc_t error_actions[] = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700737 {"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)},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741#ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700742 {"continue", 1 << REISERFS_ERROR_CONTINUE,
743 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700745 {NULL, 0, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746};
747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748/* 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 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700754static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
755 char **opt_arg, unsigned long *bit_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700757 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700767 p = *cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700769 /* assume argument cannot contain commas */
770 *cur = strchr(p, ',');
771 if (*cur) {
772 *(*cur) = '\0';
773 (*cur)++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700776 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700786
787 /* for every option in the list */
788 for (opt = opts; opt->option_name; opt++) {
789 if (!strncmp(p, opt->option_name, strlen(opt->option_name))) {
790 if (bit_flags) {
791 if (opt->clrmask ==
792 (1 << REISERFS_UNSUPPORTED_OPT))
793 reiserfs_warning(s, "%s not supported.",
794 p);
795 else
796 *bit_flags &= ~opt->clrmask;
797 if (opt->setmask ==
798 (1 << REISERFS_UNSUPPORTED_OPT))
799 reiserfs_warning(s, "%s not supported.",
800 p);
801 else
802 *bit_flags |= opt->setmask;
803 }
804 break;
805 }
806 }
807 if (!opt->option_name) {
808 reiserfs_warning(s, "unknown mount option \"%s\"", p);
809 return -1;
810 }
811
812 p += strlen(opt->option_name);
813 switch (*p) {
814 case '=':
815 if (!opt->arg_required) {
816 reiserfs_warning(s,
817 "the option \"%s\" does not require an argument",
818 opt->option_name);
819 return -1;
820 }
821 break;
822
823 case 0:
824 if (opt->arg_required) {
825 reiserfs_warning(s,
826 "the option \"%s\" requires an argument",
827 opt->option_name);
828 return -1;
829 }
830 break;
831 default:
832 reiserfs_warning(s, "head of option \"%s\" is only correct",
833 opt->option_name);
834 return -1;
835 }
836
837 /* move to the argument, or to next option if argument is not required */
838 p++;
839
840 if (opt->arg_required
841 && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
842 && !strlen(p)) {
843 /* this catches "option=," if not allowed */
844 reiserfs_warning(s, "empty argument for \"%s\"",
845 opt->option_name);
846 return -1;
847 }
848
849 if (!opt->values) {
850 /* *=NULLopt_arg contains pointer to argument */
851 *opt_arg = p;
852 return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);
853 }
854
855 /* values possible for this option are listed in opt->values */
856 for (arg = opt->values; arg->value; arg++) {
857 if (!strcmp(p, arg->value)) {
858 if (bit_flags) {
859 *bit_flags &= ~arg->clrmask;
860 *bit_flags |= arg->setmask;
861 }
862 return opt->arg_required;
863 }
864 }
865
866 reiserfs_warning(s, "bad value \"%s\" for option \"%s\"", p,
867 opt->option_name);
868 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871/* returns 0 if something is wrong in option string, 1 - otherwise */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700872static 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,
Jan Kara00b44192008-07-25 01:46:38 -0700879 unsigned int *commit_max_age,
880 char **qf_names,
881 unsigned int *qfmt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700883 int c;
884 char *arg = NULL;
885 char *pos;
886 opt_desc_t opts[] = {
887 /* Compatibility stuff, so that -o notail for old setups still work */
888 {"tails",.arg_required = 't',.values = tails},
889 {"notail",.clrmask =
890 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
891 {"conv",.setmask = 1 << REISERFS_CONVERT},
892 {"attrs",.setmask = 1 << REISERFS_ATTRS},
893 {"noattrs",.clrmask = 1 << REISERFS_ATTRS},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894#ifdef CONFIG_REISERFS_FS_XATTR
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700895 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
896 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897#else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700898 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
899 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900#endif
901#ifdef CONFIG_REISERFS_FS_POSIX_ACL
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700902 {"acl",.setmask = 1 << REISERFS_POSIXACL},
903 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904#else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700905 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
906 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907#endif
Vladimir V. Savelievcd02b962006-03-25 03:07:15 -0800908 {.option_name = "nolog"},
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700909 {"replayonly",.setmask = 1 << REPLAYONLY},
910 {"block-allocator",.arg_required = 'a',.values = balloc},
911 {"data",.arg_required = 'd',.values = logging_mode},
912 {"barrier",.arg_required = 'b',.values = barrier_mode},
913 {"resize",.arg_required = 'r',.values = NULL},
914 {"jdev",.arg_required = 'j',.values = NULL},
915 {"nolargeio",.arg_required = 'w',.values = NULL},
916 {"commit",.arg_required = 'c',.values = NULL},
917 {"usrquota",.setmask = 1 << REISERFS_QUOTA},
918 {"grpquota",.setmask = 1 << REISERFS_QUOTA},
919 {"noquota",.clrmask = 1 << REISERFS_QUOTA},
920 {"errors",.arg_required = 'e',.values = error_actions},
921 {"usrjquota",.arg_required =
922 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
923 {"grpjquota",.arg_required =
924 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
925 {"jqfmt",.arg_required = 'f',.values = NULL},
Vladimir V. Savelievcd02b962006-03-25 03:07:15 -0800926 {.option_name = NULL}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700927 };
928
929 *blocks = 0;
930 if (!options || !*options)
931 /* use default configuration: create tails, journaling on, no
932 conversion to newest format */
933 return 1;
934
935 for (pos = options; pos;) {
936 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
937 if (c == -1)
938 /* wrong option is given */
939 return 0;
940
941 if (c == 'r') {
942 char *p;
943
944 p = NULL;
945 /* "resize=NNN" or "resize=auto" */
946
947 if (!strcmp(arg, "auto")) {
948 /* From JFS code, to auto-get the size. */
949 *blocks =
950 s->s_bdev->bd_inode->i_size >> s->
951 s_blocksize_bits;
952 } else {
953 *blocks = simple_strtoul(arg, &p, 0);
954 if (*p != '\0') {
955 /* NNN does not look like a number */
956 reiserfs_warning(s,
957 "reiserfs_parse_options: bad value %s",
958 arg);
959 return 0;
960 }
961 }
962 }
963
964 if (c == 'c') {
965 char *p = NULL;
966 unsigned long val = simple_strtoul(arg, &p, 0);
967 /* commit=NNN (time in seconds) */
968 if (*p != '\0' || val >= (unsigned int)-1) {
969 reiserfs_warning(s,
970 "reiserfs_parse_options: bad value %s",
971 arg);
972 return 0;
973 }
974 *commit_max_age = (unsigned int)val;
975 }
976
977 if (c == 'w') {
Adrian Bunk36b756f2006-09-27 01:50:50 -0700978 reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported");
979 return 0;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700980 }
981
982 if (c == 'j') {
983 if (arg && *arg && jdev_name) {
984 if (*jdev_name) { //Hm, already assigned?
985 reiserfs_warning(s,
986 "reiserfs_parse_options: journal device was already specified to be %s",
987 *jdev_name);
988 return 0;
989 }
990 *jdev_name = arg;
991 }
992 }
993#ifdef CONFIG_QUOTA
994 if (c == 'u' || c == 'g') {
995 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
996
Jan Kara00b44192008-07-25 01:46:38 -0700997 if ((sb_any_quota_enabled(s) ||
998 sb_any_quota_suspended(s)) &&
999 (!*arg != !REISERFS_SB(s)->s_qf_names[qtype])) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001000 reiserfs_warning(s,
Jan Kara45065672008-07-25 01:46:37 -07001001 "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001002 return 0;
1003 }
1004 if (*arg) { /* Some filename specified? */
1005 if (REISERFS_SB(s)->s_qf_names[qtype]
1006 && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1007 arg)) {
1008 reiserfs_warning(s,
1009 "reiserfs_parse_options: %s quota file already specified.",
1010 QTYPE2NAME(qtype));
1011 return 0;
1012 }
1013 if (strchr(arg, '/')) {
1014 reiserfs_warning(s,
1015 "reiserfs_parse_options: quotafile must be on filesystem root.");
1016 return 0;
1017 }
Jan Kara00b44192008-07-25 01:46:38 -07001018 qf_names[qtype] =
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001019 kmalloc(strlen(arg) + 1, GFP_KERNEL);
Jan Kara00b44192008-07-25 01:46:38 -07001020 if (!qf_names[qtype]) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001021 reiserfs_warning(s,
1022 "reiserfs_parse_options: not enough memory for storing quotafile name.");
1023 return 0;
1024 }
Jan Kara00b44192008-07-25 01:46:38 -07001025 strcpy(qf_names[qtype], arg);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001026 *mount_options |= 1 << REISERFS_QUOTA;
1027 } else {
Jan Kara00b44192008-07-25 01:46:38 -07001028 if (qf_names[qtype] !=
1029 REISERFS_SB(s)->s_qf_names[qtype])
1030 kfree(qf_names[qtype]);
1031 qf_names[qtype] = NULL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001032 }
1033 }
1034 if (c == 'f') {
1035 if (!strcmp(arg, "vfsold"))
Jan Kara00b44192008-07-25 01:46:38 -07001036 *qfmt = QFMT_VFS_OLD;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001037 else if (!strcmp(arg, "vfsv0"))
Jan Kara00b44192008-07-25 01:46:38 -07001038 *qfmt = QFMT_VFS_V0;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001039 else {
1040 reiserfs_warning(s,
1041 "reiserfs_parse_options: unknown quota format specified.");
1042 return 0;
1043 }
Jan Kara00b44192008-07-25 01:46:38 -07001044 if ((sb_any_quota_enabled(s) ||
1045 sb_any_quota_suspended(s)) &&
1046 *qfmt != REISERFS_SB(s)->s_jquota_fmt) {
1047 reiserfs_warning(s,
1048 "reiserfs_parse_options: cannot change journaled quota options when quota turned on.");
1049 return 0;
1050 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001051 }
1052#else
1053 if (c == 'u' || c == 'g' || c == 'f') {
1054 reiserfs_warning(s,
Jan Kara45065672008-07-25 01:46:37 -07001055 "reiserfs_parse_options: journaled quota options not supported.");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001056 return 0;
1057 }
1058#endif
1059 }
1060
1061#ifdef CONFIG_QUOTA
Jan Kara00b44192008-07-25 01:46:38 -07001062 if (!REISERFS_SB(s)->s_jquota_fmt && !*qfmt
1063 && (qf_names[USRQUOTA] || qf_names[GRPQUOTA])) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001064 reiserfs_warning(s,
Jan Kara45065672008-07-25 01:46:37 -07001065 "reiserfs_parse_options: journaled quota format not specified.");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001066 return 0;
1067 }
1068 /* This checking is not precise wrt the quota type but for our purposes it is sufficient */
1069 if (!(*mount_options & (1 << REISERFS_QUOTA))
1070 && sb_any_quota_enabled(s)) {
1071 reiserfs_warning(s,
1072 "reiserfs_parse_options: quota options must be present when quota is turned on.");
1073 return 0;
1074 }
1075#endif
1076
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078}
1079
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001080static void switch_data_mode(struct super_block *s, unsigned long mode)
1081{
1082 REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1083 (1 << REISERFS_DATA_ORDERED) |
1084 (1 << REISERFS_DATA_WRITEBACK));
1085 REISERFS_SB(s)->s_mount_opt |= (1 << mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086}
1087
1088static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1089{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001090 if (mount_options & (1 << REISERFS_DATA_LOG)) {
1091 if (!reiserfs_data_log(s)) {
1092 switch_data_mode(s, REISERFS_DATA_LOG);
1093 reiserfs_info(s, "switching to journaled data mode\n");
1094 }
1095 } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1096 if (!reiserfs_data_ordered(s)) {
1097 switch_data_mode(s, REISERFS_DATA_ORDERED);
1098 reiserfs_info(s, "switching to ordered data mode\n");
1099 }
1100 } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1101 if (!reiserfs_data_writeback(s)) {
1102 switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1103 reiserfs_info(s, "switching to writeback data mode\n");
1104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106}
1107
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001108static void handle_barrier_mode(struct super_block *s, unsigned long bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001110 int flush = (1 << REISERFS_BARRIER_FLUSH);
1111 int none = (1 << REISERFS_BARRIER_NONE);
1112 int all_barrier = flush | none;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001114 if (bits & all_barrier) {
1115 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1116 if (bits & flush) {
1117 REISERFS_SB(s)->s_mount_opt |= flush;
1118 printk("reiserfs: enabling write barrier flush mode\n");
1119 } else if (bits & none) {
1120 REISERFS_SB(s)->s_mount_opt |= none;
1121 printk("reiserfs: write barriers turned off\n");
1122 }
1123 }
1124}
1125
1126static void handle_attrs(struct super_block *s)
1127{
1128 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1129
1130 if (reiserfs_attrs(s)) {
1131 if (old_format_only(s)) {
1132 reiserfs_warning(s,
1133 "reiserfs: cannot support attributes on 3.5.x disk format");
1134 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 return;
1136 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001137 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1138 reiserfs_warning(s,
1139 "reiserfs: cannot support attributes until flag is set in super-block");
1140 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 }
1142 }
1143}
1144
Jan Kara00b44192008-07-25 01:46:38 -07001145#ifdef CONFIG_QUOTA
1146static void handle_quota_files(struct super_block *s, char **qf_names,
1147 unsigned int *qfmt)
1148{
1149 int i;
1150
1151 for (i = 0; i < MAXQUOTAS; i++) {
1152 if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1153 kfree(REISERFS_SB(s)->s_qf_names[i]);
1154 REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
1155 }
1156 REISERFS_SB(s)->s_jquota_fmt = *qfmt;
1157}
1158#endif
1159
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001160static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001162 struct reiserfs_super_block *rs;
1163 struct reiserfs_transaction_handle th;
1164 unsigned long blocks;
1165 unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1166 unsigned long safe_mask = 0;
1167 unsigned int commit_max_age = (unsigned int)-1;
1168 struct reiserfs_journal *journal = SB_JOURNAL(s);
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001169 char *new_opts = kstrdup(arg, GFP_KERNEL);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001170 int err;
Jan Kara00b44192008-07-25 01:46:38 -07001171 char *qf_names[MAXQUOTAS];
1172 unsigned int qfmt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001174 int i;
Jan Kara00b44192008-07-25 01:46:38 -07001175
1176 memcpy(qf_names, REISERFS_SB(s)->s_qf_names, sizeof(qf_names));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177#endif
1178
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001179 rs = SB_DISK_SUPER_BLOCK(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001181 if (!reiserfs_parse_options
Jan Kara00b44192008-07-25 01:46:38 -07001182 (s, arg, &mount_options, &blocks, NULL, &commit_max_age,
1183 qf_names, &qfmt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184#ifdef CONFIG_QUOTA
Jan Kara00b44192008-07-25 01:46:38 -07001185 for (i = 0; i < MAXQUOTAS; i++)
1186 if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1187 kfree(qf_names[i]);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001188#endif
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001189 err = -EINVAL;
1190 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 }
Jan Kara00b44192008-07-25 01:46:38 -07001192#ifdef CONFIG_QUOTA
1193 handle_quota_files(s, qf_names, &qfmt);
1194#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001196 handle_attrs(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001198 /* Add options that are safe here */
1199 safe_mask |= 1 << REISERFS_SMALLTAIL;
1200 safe_mask |= 1 << REISERFS_LARGETAIL;
1201 safe_mask |= 1 << REISERFS_NO_BORDER;
1202 safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1203 safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1204 safe_mask |= 1 << REISERFS_TEST4;
1205 safe_mask |= 1 << REISERFS_ATTRS;
1206 safe_mask |= 1 << REISERFS_XATTRS_USER;
1207 safe_mask |= 1 << REISERFS_POSIXACL;
1208 safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1209 safe_mask |= 1 << REISERFS_BARRIER_NONE;
1210 safe_mask |= 1 << REISERFS_ERROR_RO;
1211 safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1212 safe_mask |= 1 << REISERFS_ERROR_PANIC;
1213 safe_mask |= 1 << REISERFS_QUOTA;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001215 /* Update the bitmask, taking care to keep
1216 * the bits we're not allowed to change here */
1217 REISERFS_SB(s)->s_mount_opt =
1218 (REISERFS_SB(s)->
1219 s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001221 if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1222 journal->j_max_commit_age = commit_max_age;
1223 journal->j_max_trans_age = commit_max_age;
1224 } else if (commit_max_age == 0) {
1225 /* 0 means restore defaults. */
1226 journal->j_max_commit_age = journal->j_default_max_commit_age;
1227 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001230 if (blocks) {
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001231 err = reiserfs_resize(s, blocks);
1232 if (err != 0)
1233 goto out_err;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001236 if (*mount_flags & MS_RDONLY) {
1237 reiserfs_xattr_init(s, *mount_flags);
1238 /* remount read-only */
1239 if (s->s_flags & MS_RDONLY)
1240 /* it is read-only already */
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001241 goto out_ok;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001242 /* try to remount file system with read-only permissions */
1243 if (sb_umount_state(rs) == REISERFS_VALID_FS
1244 || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001245 goto out_ok;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001248 err = journal_begin(&th, s, 10);
1249 if (err)
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001250 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001252 /* Mounting a rw partition read-only. */
1253 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1254 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1255 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1256 } else {
1257 /* remount read-write */
1258 if (!(s->s_flags & MS_RDONLY)) {
1259 reiserfs_xattr_init(s, *mount_flags);
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001260 goto out_ok; /* We are read-write already */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001263 if (reiserfs_is_journal_aborted(journal)) {
1264 err = journal->j_errno;
1265 goto out_err;
1266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001268 handle_data_mode(s, mount_options);
1269 handle_barrier_mode(s, mount_options);
1270 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1271 s->s_flags &= ~MS_RDONLY; /* now it is safe to call journal_begin */
1272 err = journal_begin(&th, s, 10);
1273 if (err)
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001274 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001276 /* Mount a partition which is read-only, read-write */
1277 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1278 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1279 s->s_flags &= ~MS_RDONLY;
1280 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1281 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1282 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1283 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1284 }
1285 /* this will force a full flush of all journal lists */
1286 SB_JOURNAL(s)->j_must_wait = 1;
1287 err = journal_end(&th, s, 10);
1288 if (err)
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001289 goto out_err;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001290 s->s_dirt = 0;
1291
1292 if (!(*mount_flags & MS_RDONLY)) {
1293 finish_unfinished(s);
1294 reiserfs_xattr_init(s, *mount_flags);
1295 }
1296
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001297out_ok:
1298 kfree(s->s_options);
1299 s->s_options = new_opts;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001300 return 0;
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001301
1302out_err:
1303 kfree(new_opts);
1304 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305}
1306
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001307static int read_super_block(struct super_block *s, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001309 struct buffer_head *bh;
1310 struct reiserfs_super_block *rs;
1311 int fs_blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001313 bh = sb_bread(s, offset / s->s_blocksize);
1314 if (!bh) {
1315 reiserfs_warning(s, "sh-2006: read_super_block: "
1316 "bread failed (dev %s, block %lu, size %lu)",
1317 reiserfs_bdevname(s), offset / s->s_blocksize,
1318 s->s_blocksize);
1319 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001322 rs = (struct reiserfs_super_block *)bh->b_data;
1323 if (!is_any_reiserfs_magic_string(rs)) {
1324 brelse(bh);
1325 return 1;
1326 }
1327 //
1328 // ok, reiserfs signature (old or new) found in at the given offset
1329 //
1330 fs_blocksize = sb_blocksize(rs);
1331 brelse(bh);
1332 sb_set_blocksize(s, fs_blocksize);
1333
1334 bh = sb_bread(s, offset / s->s_blocksize);
1335 if (!bh) {
1336 reiserfs_warning(s, "sh-2007: read_super_block: "
1337 "bread failed (dev %s, block %lu, size %lu)\n",
1338 reiserfs_bdevname(s), offset / s->s_blocksize,
1339 s->s_blocksize);
1340 return 1;
1341 }
1342
1343 rs = (struct reiserfs_super_block *)bh->b_data;
1344 if (sb_blocksize(rs) != s->s_blocksize) {
1345 reiserfs_warning(s, "sh-2011: read_super_block: "
1346 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",
1347 reiserfs_bdevname(s),
1348 (unsigned long long)bh->b_blocknr,
1349 s->s_blocksize);
1350 brelse(bh);
1351 return 1;
1352 }
1353
1354 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1355 brelse(bh);
1356 reiserfs_warning(s,
1357 "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"
1358 "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"
1359 "get newer reiserfsprogs package");
1360 return 1;
1361 }
1362
1363 SB_BUFFER_WITH_SB(s) = bh;
1364 SB_DISK_SUPER_BLOCK(s) = rs;
1365
1366 if (is_reiserfs_jr(rs)) {
1367 /* magic is of non-standard journal filesystem, look at s_version to
1368 find which format is in use */
1369 if (sb_version(rs) == REISERFS_VERSION_2)
1370 reiserfs_warning(s,
1371 "read_super_block: found reiserfs format \"3.6\""
1372 " with non-standard journal");
1373 else if (sb_version(rs) == REISERFS_VERSION_1)
1374 reiserfs_warning(s,
1375 "read_super_block: found reiserfs format \"3.5\""
1376 " with non-standard journal");
1377 else {
1378 reiserfs_warning(s,
1379 "sh-2012: read_super_block: found unknown "
1380 "format \"%u\" of reiserfs with non-standard magic",
1381 sb_version(rs));
1382 return 1;
1383 }
1384 } else
1385 /* s_version of standard format may contain incorrect information,
1386 so we just look at the magic string */
1387 reiserfs_info(s,
1388 "found reiserfs format \"%s\" with standard journal\n",
1389 is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1390
1391 s->s_op = &reiserfs_sops;
1392 s->s_export_op = &reiserfs_export_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393#ifdef CONFIG_QUOTA
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001394 s->s_qcop = &reiserfs_qctl_operations;
1395 s->dq_op = &reiserfs_quota_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396#endif
1397
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001398 /* new format is limited by the 32 bit wide i_blocks field, want to
1399 ** be one full block below that.
1400 */
1401 s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1402 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403}
1404
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405/* after journal replay, reread all bitmap and super blocks */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001406static int reread_meta_blocks(struct super_block *s)
1407{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001408 ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
1409 wait_on_buffer(SB_BUFFER_WITH_SB(s));
1410 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1411 reiserfs_warning(s,
1412 "reread_meta_blocks, error reading the super");
1413 return 1;
1414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001416 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417}
1418
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419/////////////////////////////////////////////////////
1420// hash detection stuff
1421
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422// if root directory is empty - we set default - Yura's - hash and
1423// warn about it
1424// FIXME: we look for only one name in a directory. If tea and yura
1425// bith have the same value - we ask user to send report to the
1426// mailing list
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001427static __u32 find_hash_out(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001429 int retval;
1430 struct inode *inode;
1431 struct cpu_key key;
1432 INITIALIZE_PATH(path);
1433 struct reiserfs_dir_entry de;
1434 __u32 hash = DEFAULT_HASH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001436 inode = s->s_root->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001438 do { // Some serious "goto"-hater was there ;)
1439 u32 teahash, r5hash, yurahash;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001441 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1442 retval = search_by_entry_key(s, &key, &path, &de);
1443 if (retval == IO_ERROR) {
1444 pathrelse(&path);
1445 return UNSET_HASH;
1446 }
1447 if (retval == NAME_NOT_FOUND)
1448 de.de_entry_num--;
1449 set_de_name_and_namelen(&de);
1450 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
1451 /* allow override in this case */
1452 if (reiserfs_rupasov_hash(s)) {
1453 hash = YURA_HASH;
1454 }
1455 reiserfs_warning(s, "FS seems to be empty, autodetect "
1456 "is using the default hash");
1457 break;
1458 }
1459 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1460 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1461 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1462 if (((teahash == r5hash)
1463 &&
1464 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1465 == r5hash)) || ((teahash == yurahash)
1466 && (yurahash ==
1467 GET_HASH_VALUE(deh_offset
1468 (&
1469 (de.
1470 de_deh[de.
1471 de_entry_num])))))
1472 || ((r5hash == yurahash)
1473 && (yurahash ==
1474 GET_HASH_VALUE(deh_offset
1475 (&(de.de_deh[de.de_entry_num])))))) {
1476 reiserfs_warning(s,
1477 "Unable to automatically detect hash function. "
1478 "Please mount with -o hash={tea,rupasov,r5}",
1479 reiserfs_bdevname(s));
1480 hash = UNSET_HASH;
1481 break;
1482 }
1483 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1484 yurahash)
1485 hash = YURA_HASH;
1486 else if (GET_HASH_VALUE
1487 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1488 hash = TEA_HASH;
1489 else if (GET_HASH_VALUE
1490 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1491 hash = R5_HASH;
1492 else {
1493 reiserfs_warning(s, "Unrecognised hash function");
1494 hash = UNSET_HASH;
1495 }
1496 } while (0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001498 pathrelse(&path);
1499 return hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500}
1501
1502// finds out which hash names are sorted with
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001503static int what_hash(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001505 __u32 code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001507 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001509 /* reiserfs_hash_detect() == true if any of the hash mount options
1510 ** were used. We must check them to make sure the user isn't
1511 ** using a bad hash value
1512 */
1513 if (code == UNSET_HASH || reiserfs_hash_detect(s))
1514 code = find_hash_out(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001516 if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1517 /* detection has found the hash, and we must check against the
1518 ** mount options
1519 */
1520 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1521 reiserfs_warning(s, "Error, %s hash detected, "
1522 "unable to force rupasov hash",
1523 reiserfs_hashname(code));
1524 code = UNSET_HASH;
1525 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1526 reiserfs_warning(s, "Error, %s hash detected, "
1527 "unable to force tea hash",
1528 reiserfs_hashname(code));
1529 code = UNSET_HASH;
1530 } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1531 reiserfs_warning(s, "Error, %s hash detected, "
1532 "unable to force r5 hash",
1533 reiserfs_hashname(code));
1534 code = UNSET_HASH;
1535 }
1536 } else {
1537 /* find_hash_out was not called or could not determine the hash */
1538 if (reiserfs_rupasov_hash(s)) {
1539 code = YURA_HASH;
1540 } else if (reiserfs_tea_hash(s)) {
1541 code = TEA_HASH;
1542 } else if (reiserfs_r5_hash(s)) {
1543 code = R5_HASH;
1544 }
1545 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001547 /* if we are mounted RW, and we have a new valid hash code, update
1548 ** the super
1549 */
1550 if (code != UNSET_HASH &&
1551 !(s->s_flags & MS_RDONLY) &&
1552 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1553 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1554 }
1555 return code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556}
1557
1558// return pointer to appropriate function
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001559static hashf_t hash_function(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001561 switch (what_hash(s)) {
1562 case TEA_HASH:
1563 reiserfs_info(s, "Using tea hash to sort names\n");
1564 return keyed_hash;
1565 case YURA_HASH:
1566 reiserfs_info(s, "Using rupasov hash to sort names\n");
1567 return yura_hash;
1568 case R5_HASH:
1569 reiserfs_info(s, "Using r5 hash to sort names\n");
1570 return r5_hash;
1571 }
1572 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573}
1574
1575// this is used to set up correct value for old partitions
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001576static int function2code(hashf_t func)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001578 if (func == keyed_hash)
1579 return TEA_HASH;
1580 if (func == yura_hash)
1581 return YURA_HASH;
1582 if (func == r5_hash)
1583 return R5_HASH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001585 BUG(); // should never happen
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001587 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588}
1589
1590#define SWARN(silent, s, ...) \
1591 if (!(silent)) \
1592 reiserfs_warning (s, __VA_ARGS__)
1593
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001594static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001596 struct inode *root_inode;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001597 struct reiserfs_transaction_handle th;
1598 int old_format = 0;
1599 unsigned long blocks;
1600 unsigned int commit_max_age = 0;
1601 int jinit_done = 0;
1602 struct reiserfs_iget_args args;
1603 struct reiserfs_super_block *rs;
1604 char *jdev_name;
1605 struct reiserfs_sb_info *sbi;
1606 int errval = -EINVAL;
Jan Kara00b44192008-07-25 01:46:38 -07001607 char *qf_names[MAXQUOTAS] = {};
1608 unsigned int qfmt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Miklos Szeredicdf6ccc2008-02-08 04:21:47 -08001610 save_mount_options(s, data);
1611
Yan Burman01afb212006-12-06 20:39:01 -08001612 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001613 if (!sbi) {
1614 errval = -ENOMEM;
1615 goto error;
1616 }
1617 s->s_fs_info = sbi;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001618 /* Set default values for options: non-aggressive tails, RO on errors */
1619 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1620 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1621 /* no preallocation minimum, be smart in
1622 reiserfs_file_write instead */
1623 REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1624 /* Preallocate by 16 blocks (17-1) at once */
1625 REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
Alexey Dobriyanfe08a9d2007-05-08 00:24:55 -07001626#ifdef CONFIG_REISERFS_FS_XATTR
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001627 /* Initialize the rwsem for xattr dir */
1628 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
Alexey Dobriyanfe08a9d2007-05-08 00:24:55 -07001629#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001630 /* setup default block allocator options */
1631 reiserfs_init_alloc_options(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001633 jdev_name = NULL;
1634 if (reiserfs_parse_options
1635 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
Jan Kara00b44192008-07-25 01:46:38 -07001636 &commit_max_age, qf_names, &qfmt) == 0) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001637 goto error;
1638 }
Jan Kara00b44192008-07-25 01:46:38 -07001639#ifdef CONFIG_QUOTA
1640 handle_quota_files(s, qf_names, &qfmt);
1641#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001643 if (blocks) {
1644 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "
1645 "for remount only");
1646 goto error;
1647 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001649 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1650 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1651 old_format = 1;
1652 /* try new format (64-th 1k block), which can contain reiserfs super block */
1653 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1654 SWARN(silent, s,
1655 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",
1656 reiserfs_bdevname(s));
1657 goto error;
1658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001660 rs = SB_DISK_SUPER_BLOCK(s);
1661 /* Let's do basic sanity check to verify that underlying device is not
1662 smaller than the filesystem. If the check fails then abort and scream,
1663 because bad stuff will happen otherwise. */
1664 if (s->s_bdev && s->s_bdev->bd_inode
1665 && i_size_read(s->s_bdev->bd_inode) <
1666 sb_block_count(rs) * sb_blocksize(rs)) {
1667 SWARN(silent, s,
1668 "Filesystem on %s cannot be mounted because it is bigger than the device",
1669 reiserfs_bdevname(s));
1670 SWARN(silent, s,
1671 "You may need to run fsck or increase size of your LVM partition");
1672 SWARN(silent, s,
1673 "Or may be you forgot to reboot after fdisk when it told you to");
1674 goto error;
1675 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001677 sbi->s_mount_state = SB_REISERFS_STATE(s);
1678 sbi->s_mount_state = REISERFS_VALID_FS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Jeff Mahoney6f010462006-09-30 23:28:43 -07001680 if ((errval = reiserfs_init_bitmap_cache(s))) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001681 SWARN(silent, s,
1682 "jmacd-8: reiserfs_fill_super: unable to read bitmap");
1683 goto error;
1684 }
Jeff Mahoneyd2c89a42006-11-02 22:07:20 -08001685 errval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001687 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");
1688 SWARN(silent, s, "- it is slow mode for debugging.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689#endif
1690
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001691 /* make data=ordered the default */
1692 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1693 !reiserfs_data_writeback(s)) {
1694 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
1696
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001697 if (reiserfs_data_log(s)) {
1698 reiserfs_info(s, "using journaled data mode\n");
1699 } else if (reiserfs_data_ordered(s)) {
1700 reiserfs_info(s, "using ordered data mode\n");
1701 } else {
1702 reiserfs_info(s, "using writeback data mode\n");
1703 }
1704 if (reiserfs_barrier_flush(s)) {
1705 printk("reiserfs: using flush barriers\n");
1706 }
1707 // set_device_ro(s->s_dev, 1) ;
1708 if (journal_init(s, jdev_name, old_format, commit_max_age)) {
1709 SWARN(silent, s,
1710 "sh-2022: reiserfs_fill_super: unable to initialize journal space");
1711 goto error;
1712 } else {
1713 jinit_done = 1; /* once this is set, journal_release must be called
1714 ** if we error out of the mount
1715 */
1716 }
1717 if (reread_meta_blocks(s)) {
1718 SWARN(silent, s,
1719 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");
1720 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 }
1722
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001723 if (replay_only(s))
1724 goto error;
1725
1726 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1727 SWARN(silent, s,
1728 "clm-7000: Detected readonly device, marking FS readonly");
1729 s->s_flags |= MS_RDONLY;
1730 }
1731 args.objectid = REISERFS_ROOT_OBJECTID;
1732 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1733 root_inode =
1734 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1735 reiserfs_init_locked_inode, (void *)(&args));
1736 if (!root_inode) {
1737 SWARN(silent, s,
1738 "jmacd-10: reiserfs_fill_super: get root inode failed");
1739 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 }
1741
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001742 if (root_inode->i_state & I_NEW) {
1743 reiserfs_read_locked_inode(root_inode, &args);
1744 unlock_new_inode(root_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 }
1746
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001747 s->s_root = d_alloc_root(root_inode);
1748 if (!s->s_root) {
1749 iput(root_inode);
1750 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001752 // define and initialize hash function
1753 sbi->s_hash_function = hash_function(s);
1754 if (sbi->s_hash_function == NULL) {
1755 dput(s->s_root);
1756 s->s_root = NULL;
1757 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001759
1760 if (is_reiserfs_3_5(rs)
1761 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
1762 set_bit(REISERFS_3_5, &(sbi->s_properties));
Jeff Mahoneye1fabd32006-09-30 23:28:40 -07001763 else if (old_format)
1764 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001765 else
1766 set_bit(REISERFS_3_6, &(sbi->s_properties));
1767
1768 if (!(s->s_flags & MS_RDONLY)) {
1769
1770 errval = journal_begin(&th, s, 1);
1771 if (errval) {
1772 dput(s->s_root);
1773 s->s_root = NULL;
1774 goto error;
1775 }
1776 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1777
1778 set_sb_umount_state(rs, REISERFS_ERROR_FS);
1779 set_sb_fs_state(rs, 0);
1780
Jeff Mahoneycb680c12007-10-18 23:39:27 -07001781 /* Clear out s_bmap_nr if it would wrap. We can handle this
1782 * case, but older revisions can't. This will cause the
1783 * file system to fail mount on those older implementations,
1784 * avoiding corruption. -jeffm */
1785 if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
1786 sb_bmap_nr(rs) != 0) {
1787 reiserfs_warning(s, "super-2030: This file system "
1788 "claims to use %u bitmap blocks in "
1789 "its super block, but requires %u. "
1790 "Clearing to zero.", sb_bmap_nr(rs),
1791 reiserfs_bmap_count(s));
1792
1793 set_sb_bmap_nr(rs, 0);
1794 }
1795
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001796 if (old_format_only(s)) {
1797 /* filesystem of format 3.5 either with standard or non-standard
1798 journal */
1799 if (convert_reiserfs(s)) {
1800 /* and -o conv is given */
1801 if (!silent)
1802 reiserfs_info(s,
1803 "converting 3.5 filesystem to the 3.6 format");
1804
1805 if (is_reiserfs_3_5(rs))
1806 /* put magic string of 3.6 format. 2.2 will not be able to
1807 mount this filesystem anymore */
1808 memcpy(rs->s_v1.s_magic,
1809 reiserfs_3_6_magic_string,
1810 sizeof
1811 (reiserfs_3_6_magic_string));
1812
1813 set_sb_version(rs, REISERFS_VERSION_2);
1814 reiserfs_convert_objectid_map_v1(s);
1815 set_bit(REISERFS_3_6, &(sbi->s_properties));
1816 clear_bit(REISERFS_3_5, &(sbi->s_properties));
1817 } else if (!silent) {
1818 reiserfs_info(s, "using 3.5.x disk format\n");
1819 }
1820 }
1821
1822 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1823 errval = journal_end(&th, s, 1);
1824 if (errval) {
1825 dput(s->s_root);
1826 s->s_root = NULL;
1827 goto error;
1828 }
1829
1830 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1831 dput(s->s_root);
1832 s->s_root = NULL;
1833 goto error;
1834 }
1835
1836 /* look for files which were to be removed in previous session */
1837 finish_unfinished(s);
1838 } else {
1839 if (old_format_only(s) && !silent) {
1840 reiserfs_info(s, "using 3.5.x disk format\n");
1841 }
1842
1843 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {
1844 dput(s->s_root);
1845 s->s_root = NULL;
1846 goto error;
1847 }
1848 }
1849 // mark hash in super block: it could be unset. overwrite should be ok
1850 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1851
1852 handle_attrs(s);
1853
1854 reiserfs_proc_info_init(s);
1855
1856 init_waitqueue_head(&(sbi->s_wait));
1857 spin_lock_init(&sbi->bitmap_lock);
1858
1859 return (0);
1860
Jan Kara00b44192008-07-25 01:46:38 -07001861error:
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001862 if (jinit_done) { /* kill the commit thread, free journal ram */
1863 journal_release_error(NULL, s);
1864 }
Jeff Mahoney50652272006-09-30 23:28:44 -07001865
1866 reiserfs_free_bitmap_cache(s);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001867 if (SB_BUFFER_WITH_SB(s))
1868 brelse(SB_BUFFER_WITH_SB(s));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869#ifdef CONFIG_QUOTA
Jeff Mahoney50652272006-09-30 23:28:44 -07001870 {
1871 int j;
Jan Kara00b44192008-07-25 01:46:38 -07001872 for (j = 0; j < MAXQUOTAS; j++)
1873 kfree(qf_names[j]);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001874 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875#endif
James Lamanna833d3042005-10-30 15:00:16 -08001876 kfree(sbi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001878 s->s_fs_info = NULL;
1879 return errval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880}
1881
David Howells726c3342006-06-23 02:02:58 -07001882static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883{
David Howells726c3342006-06-23 02:02:58 -07001884 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001885
1886 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1887 buf->f_bfree = sb_free_blocks(rs);
1888 buf->f_bavail = buf->f_bfree;
1889 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
David Howells726c3342006-06-23 02:02:58 -07001890 buf->f_bsize = dentry->d_sb->s_blocksize;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001891 /* changed to accommodate gcc folks. */
1892 buf->f_type = REISERFS_SUPER_MAGIC;
1893 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
1896#ifdef CONFIG_QUOTA
1897static int reiserfs_dquot_initialize(struct inode *inode, int type)
1898{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001899 struct reiserfs_transaction_handle th;
1900 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001902 /* We may create quota structure so we need to reserve enough blocks */
1903 reiserfs_write_lock(inode->i_sb);
1904 ret =
1905 journal_begin(&th, inode->i_sb,
1906 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1907 if (ret)
1908 goto out;
1909 ret = dquot_initialize(inode, type);
1910 err =
1911 journal_end(&th, inode->i_sb,
1912 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1913 if (!ret && err)
1914 ret = err;
1915 out:
1916 reiserfs_write_unlock(inode->i_sb);
1917 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918}
1919
1920static int reiserfs_dquot_drop(struct inode *inode)
1921{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001922 struct reiserfs_transaction_handle th;
1923 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001925 /* We may delete quota structure so we need to reserve enough blocks */
1926 reiserfs_write_lock(inode->i_sb);
1927 ret =
1928 journal_begin(&th, inode->i_sb,
1929 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
Jan Karaa2fe5942008-04-28 02:16:23 -07001930 if (ret) {
1931 /*
1932 * We call dquot_drop() anyway to at least release references
1933 * to quota structures so that umount does not hang.
1934 */
1935 dquot_drop(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001936 goto out;
Jan Karaa2fe5942008-04-28 02:16:23 -07001937 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001938 ret = dquot_drop(inode);
1939 err =
1940 journal_end(&th, inode->i_sb,
1941 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1942 if (!ret && err)
1943 ret = err;
1944 out:
1945 reiserfs_write_unlock(inode->i_sb);
1946 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947}
1948
1949static int reiserfs_write_dquot(struct dquot *dquot)
1950{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001951 struct reiserfs_transaction_handle th;
1952 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001954 reiserfs_write_lock(dquot->dq_sb);
1955 ret =
1956 journal_begin(&th, dquot->dq_sb,
1957 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1958 if (ret)
1959 goto out;
1960 ret = dquot_commit(dquot);
1961 err =
1962 journal_end(&th, dquot->dq_sb,
1963 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1964 if (!ret && err)
1965 ret = err;
1966 out:
1967 reiserfs_write_unlock(dquot->dq_sb);
1968 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969}
1970
1971static int reiserfs_acquire_dquot(struct dquot *dquot)
1972{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001973 struct reiserfs_transaction_handle th;
1974 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001976 reiserfs_write_lock(dquot->dq_sb);
1977 ret =
1978 journal_begin(&th, dquot->dq_sb,
1979 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1980 if (ret)
1981 goto out;
1982 ret = dquot_acquire(dquot);
1983 err =
1984 journal_end(&th, dquot->dq_sb,
1985 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1986 if (!ret && err)
1987 ret = err;
1988 out:
1989 reiserfs_write_unlock(dquot->dq_sb);
1990 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991}
1992
1993static int reiserfs_release_dquot(struct dquot *dquot)
1994{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001995 struct reiserfs_transaction_handle th;
1996 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001998 reiserfs_write_lock(dquot->dq_sb);
1999 ret =
2000 journal_begin(&th, dquot->dq_sb,
2001 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
Jan Kara9c3013e2007-09-11 15:23:29 -07002002 if (ret) {
2003 /* Release dquot anyway to avoid endless cycle in dqput() */
2004 dquot_release(dquot);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002005 goto out;
Jan Kara9c3013e2007-09-11 15:23:29 -07002006 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002007 ret = dquot_release(dquot);
2008 err =
2009 journal_end(&th, dquot->dq_sb,
2010 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2011 if (!ret && err)
2012 ret = err;
2013 out:
2014 reiserfs_write_unlock(dquot->dq_sb);
2015 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016}
2017
2018static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2019{
Jan Kara45065672008-07-25 01:46:37 -07002020 /* Are we journaling quotas? */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002021 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2022 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2023 dquot_mark_dquot_dirty(dquot);
2024 return reiserfs_write_dquot(dquot);
2025 } else
2026 return dquot_mark_dquot_dirty(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027}
2028
2029static int reiserfs_write_info(struct super_block *sb, int type)
2030{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002031 struct reiserfs_transaction_handle th;
2032 int ret, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002034 /* Data block + inode block */
2035 reiserfs_write_lock(sb);
2036 ret = journal_begin(&th, sb, 2);
2037 if (ret)
2038 goto out;
2039 ret = dquot_commit_info(sb, type);
2040 err = journal_end(&th, sb, 2);
2041 if (!ret && err)
2042 ret = err;
2043 out:
2044 reiserfs_write_unlock(sb);
2045 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046}
2047
2048/*
Christoph Hellwig84de8562005-06-23 00:09:16 -07002049 * Turn on quotas during mount time - we need to find the quota file and such...
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 */
2051static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2052{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002053 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002054 REISERFS_SB(sb)->s_jquota_fmt, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055}
2056
2057/*
2058 * Standard function to be called on quota_on
2059 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002060static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
Al Viro82646132008-08-02 00:57:06 -04002061 char *name, int remount)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002063 int err;
Al Viro82646132008-08-02 00:57:06 -04002064 struct path path;
Jan Karad5dee5c2008-04-28 02:16:23 -07002065 struct inode *inode;
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002066 struct reiserfs_transaction_handle th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002068 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2069 return -EINVAL;
Jan Kara1b445a92008-04-28 02:14:35 -07002070 /* No more checks needed? Path and format_id are bogus anyway... */
2071 if (remount)
Al Viro82646132008-08-02 00:57:06 -04002072 return vfs_quota_on(sb, type, format_id, name, 1);
2073 err = kern_path(name, LOOKUP_FOLLOW, &path);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002074 if (err)
2075 return err;
2076 /* Quotafile not on the same filesystem? */
Al Viro82646132008-08-02 00:57:06 -04002077 if (path.mnt->mnt_sb != sb) {
Al Viro77e69da2008-08-01 04:29:18 -04002078 err = -EXDEV;
2079 goto out;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002080 }
Al Viro82646132008-08-02 00:57:06 -04002081 inode = path.dentry->d_inode;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002082 /* We must not pack tails for quota files on reiserfs for quota IO to work */
Jan Karad5dee5c2008-04-28 02:16:23 -07002083 if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2084 err = reiserfs_unpack(inode, NULL);
2085 if (err) {
2086 reiserfs_warning(sb,
2087 "reiserfs: Unpacking tail of quota file failed"
2088 " (%d). Cannot turn on quotas.", err);
Al Viro77e69da2008-08-01 04:29:18 -04002089 err = -EINVAL;
2090 goto out;
Jan Karad5dee5c2008-04-28 02:16:23 -07002091 }
2092 mark_inode_dirty(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002093 }
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002094 /* Journaling quota? */
2095 if (REISERFS_SB(sb)->s_qf_names[type]) {
2096 /* Quotafile not of fs root? */
Al Viro82646132008-08-02 00:57:06 -04002097 if (path.dentry->d_parent != sb->s_root)
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002098 reiserfs_warning(sb,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002099 "reiserfs: Quota file not on filesystem root. "
2100 "Journalled quota will not work.");
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002101 }
2102
2103 /*
2104 * When we journal data on quota file, we have to flush journal to see
2105 * all updates to the file when we bypass pagecache...
2106 */
2107 if (reiserfs_file_data_log(inode)) {
2108 /* Just start temporary transaction and finish it */
2109 err = journal_begin(&th, sb, 1);
2110 if (err)
Al Viro77e69da2008-08-01 04:29:18 -04002111 goto out;
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002112 err = journal_end_sync(&th, sb, 1);
2113 if (err)
Al Viro77e69da2008-08-01 04:29:18 -04002114 goto out;
Jan Kara5d4f7fd2008-07-25 01:46:36 -07002115 }
Al Viro82646132008-08-02 00:57:06 -04002116 err = vfs_quota_on_path(sb, type, format_id, &path);
Al Viro77e69da2008-08-01 04:29:18 -04002117out:
Al Viro82646132008-08-02 00:57:06 -04002118 path_put(&path);
Al Viro77e69da2008-08-01 04:29:18 -04002119 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120}
2121
2122/* Read data from quotafile - avoid pagecache and such because we cannot afford
2123 * acquiring the locks... As quota files are never truncated and quota code
2124 * itself serializes the operations (and noone else should touch the files)
2125 * we don't have to be afraid of races */
2126static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2127 size_t len, loff_t off)
2128{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002129 struct inode *inode = sb_dqopt(sb)->files[type];
2130 unsigned long blk = off >> sb->s_blocksize_bits;
2131 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2132 size_t toread;
2133 struct buffer_head tmp_bh, *bh;
2134 loff_t i_size = i_size_read(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002136 if (off > i_size)
2137 return 0;
2138 if (off + len > i_size)
2139 len = i_size - off;
2140 toread = len;
2141 while (toread > 0) {
2142 tocopy =
2143 sb->s_blocksize - offset <
2144 toread ? sb->s_blocksize - offset : toread;
2145 tmp_bh.b_state = 0;
2146 /* Quota files are without tails so we can safely use this function */
2147 reiserfs_write_lock(sb);
2148 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2149 reiserfs_write_unlock(sb);
2150 if (err)
2151 return err;
2152 if (!buffer_mapped(&tmp_bh)) /* A hole? */
2153 memset(data, 0, tocopy);
2154 else {
2155 bh = sb_bread(sb, tmp_bh.b_blocknr);
2156 if (!bh)
2157 return -EIO;
2158 memcpy(data, bh->b_data + offset, tocopy);
2159 brelse(bh);
2160 }
2161 offset = 0;
2162 toread -= tocopy;
2163 data += tocopy;
2164 blk++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002166 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167}
2168
2169/* Write to quotafile (we know the transaction is already started and has
2170 * enough credits) */
2171static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2172 const char *data, size_t len, loff_t off)
2173{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002174 struct inode *inode = sb_dqopt(sb)->files[type];
2175 unsigned long blk = off >> sb->s_blocksize_bits;
2176 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2177 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2178 size_t towrite = len;
2179 struct buffer_head tmp_bh, *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
Jan Kara9c3013e2007-09-11 15:23:29 -07002181 if (!current->journal_info) {
2182 printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2183 " cancelled because transaction is not started.\n",
2184 (unsigned long long)off, (unsigned long long)len);
2185 return -EIO;
2186 }
Arjan van de Ven5c81a412006-07-03 00:25:20 -07002187 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002188 while (towrite > 0) {
2189 tocopy = sb->s_blocksize - offset < towrite ?
2190 sb->s_blocksize - offset : towrite;
2191 tmp_bh.b_state = 0;
2192 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2193 if (err)
2194 goto out;
2195 if (offset || tocopy != sb->s_blocksize)
2196 bh = sb_bread(sb, tmp_bh.b_blocknr);
2197 else
2198 bh = sb_getblk(sb, tmp_bh.b_blocknr);
2199 if (!bh) {
2200 err = -EIO;
2201 goto out;
2202 }
2203 lock_buffer(bh);
2204 memcpy(bh->b_data + offset, data, tocopy);
2205 flush_dcache_page(bh->b_page);
2206 set_buffer_uptodate(bh);
2207 unlock_buffer(bh);
2208 reiserfs_prepare_for_journal(sb, bh, 1);
2209 journal_mark_dirty(current->journal_info, sb, bh);
2210 if (!journal_quota)
2211 reiserfs_add_ordered_list(inode, bh);
2212 brelse(bh);
2213 offset = 0;
2214 towrite -= tocopy;
2215 data += tocopy;
2216 blk++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 }
Jan Kara9c3013e2007-09-11 15:23:29 -07002218out:
Jan Kara10dd08d2008-07-04 09:59:34 -07002219 if (len == towrite) {
2220 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002221 return err;
Jan Kara10dd08d2008-07-04 09:59:34 -07002222 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002223 if (inode->i_size < off + len - towrite)
2224 i_size_write(inode, off + len - towrite);
2225 inode->i_version++;
2226 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2227 mark_inode_dirty(inode);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002228 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002229 return len - towrite;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230}
2231
2232#endif
2233
David Howells454e2392006-06-23 02:02:57 -07002234static int get_super_block(struct file_system_type *fs_type,
2235 int flags, const char *dev_name,
2236 void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237{
David Howells454e2392006-06-23 02:02:57 -07002238 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super,
2239 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240}
2241
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002242static int __init init_reiserfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243{
2244 int ret;
2245
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002246 if ((ret = init_inodecache())) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 return ret;
2248 }
2249
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002250 if ((ret = reiserfs_xattr_register_handlers()))
2251 goto failed_reiserfs_xattr_register_handlers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002253 reiserfs_proc_info_global_init();
2254 reiserfs_proc_register_global("version",
2255 reiserfs_global_version_in_proc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002257 ret = register_filesystem(&reiserfs_fs_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258
2259 if (ret == 0) {
2260 return 0;
2261 }
2262
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002263 reiserfs_xattr_unregister_handlers();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002265 failed_reiserfs_xattr_register_handlers:
2266 reiserfs_proc_unregister_global("version");
2267 reiserfs_proc_info_global_done();
2268 destroy_inodecache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269
2270 return ret;
2271}
2272
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002273static void __exit exit_reiserfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002275 reiserfs_xattr_unregister_handlers();
2276 reiserfs_proc_unregister_global("version");
2277 reiserfs_proc_info_global_done();
2278 unregister_filesystem(&reiserfs_fs_type);
2279 destroy_inodecache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280}
2281
2282struct file_system_type reiserfs_fs_type = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002283 .owner = THIS_MODULE,
2284 .name = "reiserfs",
2285 .get_sb = get_super_block,
David Howellsedc666e2006-10-11 01:22:14 -07002286 .kill_sb = reiserfs_kill_sb,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002287 .fs_flags = FS_REQUIRES_DEV,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288};
2289
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002290MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2291MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2292MODULE_LICENSE("GPL");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002294module_init(init_reiserfs_fs);
2295module_exit(exit_reiserfs_fs);