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