aboutsummaryrefslogtreecommitdiffstats
path: root/fs/reiserfs/inode.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/reiserfs/inode.c')
-rw-r--r--fs/reiserfs/inode.c4925
1 files changed, 2531 insertions, 2394 deletions
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 289d864fe731..d76ee6c4f9b8 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -18,107 +18,111 @@
18#include <linux/writeback.h> 18#include <linux/writeback.h>
19#include <linux/quotaops.h> 19#include <linux/quotaops.h>
20 20
21extern int reiserfs_default_io_size; /* default io size devuned in super.c */ 21extern int reiserfs_default_io_size; /* default io size devuned in super.c */
22 22
23static int reiserfs_commit_write(struct file *f, struct page *page, 23static int reiserfs_commit_write(struct file *f, struct page *page,
24 unsigned from, unsigned to); 24 unsigned from, unsigned to);
25static int reiserfs_prepare_write(struct file *f, struct page *page, 25static int reiserfs_prepare_write(struct file *f, struct page *page,
26 unsigned from, unsigned to); 26 unsigned from, unsigned to);
27 27
28void reiserfs_delete_inode (struct inode * inode) 28void reiserfs_delete_inode(struct inode *inode)
29{ 29{
30 /* We need blocks for transaction + (user+group) quota update (possibly delete) */ 30 /* We need blocks for transaction + (user+group) quota update (possibly delete) */
31 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb); 31 int jbegin_count =
32 struct reiserfs_transaction_handle th ; 32 JOURNAL_PER_BALANCE_CNT * 2 +
33 33 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
34 reiserfs_write_lock(inode->i_sb); 34 struct reiserfs_transaction_handle th;
35 35
36 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */ 36 truncate_inode_pages(&inode->i_data, 0);
37 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
38 down (&inode->i_sem);
39 37
40 reiserfs_delete_xattrs (inode); 38 reiserfs_write_lock(inode->i_sb);
41 39
42 if (journal_begin(&th, inode->i_sb, jbegin_count)) { 40 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
43 up (&inode->i_sem); 41 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
44 goto out; 42 down(&inode->i_sem);
45 }
46 reiserfs_update_inode_transaction(inode) ;
47 43
48 if (reiserfs_delete_object (&th, inode)) { 44 reiserfs_delete_xattrs(inode);
49 up (&inode->i_sem);
50 goto out;
51 }
52 45
53 /* Do quota update inside a transaction for journaled quotas. We must do that 46 if (journal_begin(&th, inode->i_sb, jbegin_count)) {
54 * after delete_object so that quota updates go into the same transaction as 47 up(&inode->i_sem);
55 * stat data deletion */ 48 goto out;
56 DQUOT_FREE_INODE(inode); 49 }
50 reiserfs_update_inode_transaction(inode);
57 51
58 if (journal_end(&th, inode->i_sb, jbegin_count)) { 52 if (reiserfs_delete_object(&th, inode)) {
59 up (&inode->i_sem); 53 up(&inode->i_sem);
60 goto out; 54 goto out;
61 } 55 }
56
57 /* Do quota update inside a transaction for journaled quotas. We must do that
58 * after delete_object so that quota updates go into the same transaction as
59 * stat data deletion */
60 DQUOT_FREE_INODE(inode);
61
62 if (journal_end(&th, inode->i_sb, jbegin_count)) {
63 up(&inode->i_sem);
64 goto out;
65 }
62 66
63 up (&inode->i_sem); 67 up(&inode->i_sem);
64 68
65 /* all items of file are deleted, so we can remove "save" link */ 69 /* all items of file are deleted, so we can remove "save" link */
66 remove_save_link (inode, 0/* not truncate */); /* we can't do anything 70 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
67 * about an error here */ 71 * about an error here */
68 } else { 72 } else {
69 /* no object items are in the tree */ 73 /* no object items are in the tree */
70 ; 74 ;
71 } 75 }
72out: 76 out:
73 clear_inode (inode); /* note this must go after the journal_end to prevent deadlock */ 77 clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */
74 inode->i_blocks = 0; 78 inode->i_blocks = 0;
75 reiserfs_write_unlock(inode->i_sb); 79 reiserfs_write_unlock(inode->i_sb);
76} 80}
77 81
78static void _make_cpu_key (struct cpu_key * key, int version, __u32 dirid, __u32 objectid, 82static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
79 loff_t offset, int type, int length ) 83 __u32 objectid, loff_t offset, int type, int length)
80{ 84{
81 key->version = version; 85 key->version = version;
82 86
83 key->on_disk_key.k_dir_id = dirid; 87 key->on_disk_key.k_dir_id = dirid;
84 key->on_disk_key.k_objectid = objectid; 88 key->on_disk_key.k_objectid = objectid;
85 set_cpu_key_k_offset (key, offset); 89 set_cpu_key_k_offset(key, offset);
86 set_cpu_key_k_type (key, type); 90 set_cpu_key_k_type(key, type);
87 key->key_length = length; 91 key->key_length = length;
88} 92}
89 93
90
91/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set 94/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
92 offset and type of key */ 95 offset and type of key */
93void make_cpu_key (struct cpu_key * key, struct inode * inode, loff_t offset, 96void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
94 int type, int length ) 97 int type, int length)
95{ 98{
96 _make_cpu_key (key, get_inode_item_key_version (inode), le32_to_cpu (INODE_PKEY (inode)->k_dir_id), 99 _make_cpu_key(key, get_inode_item_key_version(inode),
97 le32_to_cpu (INODE_PKEY (inode)->k_objectid), 100 le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
98 offset, type, length); 101 le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
102 length);
99} 103}
100 104
101
102// 105//
103// when key is 0, do not set version and short key 106// when key is 0, do not set version and short key
104// 107//
105inline void make_le_item_head (struct item_head * ih, const struct cpu_key * key, 108inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
106 int version, 109 int version,
107 loff_t offset, int type, int length, 110 loff_t offset, int type, int length,
108 int entry_count/*or ih_free_space*/) 111 int entry_count /*or ih_free_space */ )
109{ 112{
110 if (key) { 113 if (key) {
111 ih->ih_key.k_dir_id = cpu_to_le32 (key->on_disk_key.k_dir_id); 114 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
112 ih->ih_key.k_objectid = cpu_to_le32 (key->on_disk_key.k_objectid); 115 ih->ih_key.k_objectid =
113 } 116 cpu_to_le32(key->on_disk_key.k_objectid);
114 put_ih_version( ih, version ); 117 }
115 set_le_ih_k_offset (ih, offset); 118 put_ih_version(ih, version);
116 set_le_ih_k_type (ih, type); 119 set_le_ih_k_offset(ih, offset);
117 put_ih_item_len( ih, length ); 120 set_le_ih_k_type(ih, type);
118 /* set_ih_free_space (ih, 0);*/ 121 put_ih_item_len(ih, length);
119 // for directory items it is entry count, for directs and stat 122 /* set_ih_free_space (ih, 0); */
120 // datas - 0xffff, for indirects - 0 123 // for directory items it is entry count, for directs and stat
121 put_ih_entry_count( ih, entry_count ); 124 // datas - 0xffff, for indirects - 0
125 put_ih_entry_count(ih, entry_count);
122} 126}
123 127
124// 128//
@@ -153,84 +157,84 @@ inline void make_le_item_head (struct item_head * ih, const struct cpu_key * key
153** to be unmapped, so that block_prepare_write will correctly call 157** to be unmapped, so that block_prepare_write will correctly call
154** reiserfs_get_block to convert the tail into an unformatted node 158** reiserfs_get_block to convert the tail into an unformatted node
155*/ 159*/
156static inline void fix_tail_page_for_writing(struct page *page) { 160static inline void fix_tail_page_for_writing(struct page *page)
157 struct buffer_head *head, *next, *bh ; 161{
158 162 struct buffer_head *head, *next, *bh;
159 if (page && page_has_buffers(page)) { 163
160 head = page_buffers(page) ; 164 if (page && page_has_buffers(page)) {
161 bh = head ; 165 head = page_buffers(page);
162 do { 166 bh = head;
163 next = bh->b_this_page ; 167 do {
164 if (buffer_mapped(bh) && bh->b_blocknr == 0) { 168 next = bh->b_this_page;
165 reiserfs_unmap_buffer(bh) ; 169 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
166 } 170 reiserfs_unmap_buffer(bh);
167 bh = next ; 171 }
168 } while (bh != head) ; 172 bh = next;
169 } 173 } while (bh != head);
174 }
170} 175}
171 176
172/* reiserfs_get_block does not need to allocate a block only if it has been 177/* reiserfs_get_block does not need to allocate a block only if it has been
173 done already or non-hole position has been found in the indirect item */ 178 done already or non-hole position has been found in the indirect item */
174static inline int allocation_needed (int retval, b_blocknr_t allocated, 179static inline int allocation_needed(int retval, b_blocknr_t allocated,
175 struct item_head * ih, 180 struct item_head *ih,
176 __le32 * item, int pos_in_item) 181 __le32 * item, int pos_in_item)
177{ 182{
178 if (allocated) 183 if (allocated)
179 return 0; 184 return 0;
180 if (retval == POSITION_FOUND && is_indirect_le_ih (ih) && 185 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
181 get_block_num(item, pos_in_item)) 186 get_block_num(item, pos_in_item))
182 return 0; 187 return 0;
183 return 1; 188 return 1;
184} 189}
185 190
186static inline int indirect_item_found (int retval, struct item_head * ih) 191static inline int indirect_item_found(int retval, struct item_head *ih)
187{ 192{
188 return (retval == POSITION_FOUND) && is_indirect_le_ih (ih); 193 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
189} 194}
190 195
191 196static inline void set_block_dev_mapped(struct buffer_head *bh,
192static inline void set_block_dev_mapped (struct buffer_head * bh, 197 b_blocknr_t block, struct inode *inode)
193 b_blocknr_t block, struct inode * inode)
194{ 198{
195 map_bh(bh, inode->i_sb, block); 199 map_bh(bh, inode->i_sb, block);
196} 200}
197 201
198
199// 202//
200// files which were created in the earlier version can not be longer, 203// files which were created in the earlier version can not be longer,
201// than 2 gb 204// than 2 gb
202// 205//
203static int file_capable (struct inode * inode, long block) 206static int file_capable(struct inode *inode, long block)
204{ 207{
205 if (get_inode_item_key_version (inode) != KEY_FORMAT_3_5 || // it is new file. 208 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.
206 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb 209 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb
207 return 1; 210 return 1;
208 211
209 return 0; 212 return 0;
210} 213}
211 214
212/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th, 215/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
213 struct inode *inode, struct path *path) { 216 struct inode *inode, struct path *path)
214 struct super_block *s = th->t_super ; 217{
215 int len = th->t_blocks_allocated ; 218 struct super_block *s = th->t_super;
216 int err; 219 int len = th->t_blocks_allocated;
217 220 int err;
218 BUG_ON (!th->t_trans_id); 221
219 BUG_ON (!th->t_refcount); 222 BUG_ON(!th->t_trans_id);
220 223 BUG_ON(!th->t_refcount);
221 /* we cannot restart while nested */ 224
222 if (th->t_refcount > 1) { 225 /* we cannot restart while nested */
223 return 0 ; 226 if (th->t_refcount > 1) {
224 } 227 return 0;
225 pathrelse(path) ; 228 }
226 reiserfs_update_sd(th, inode) ; 229 pathrelse(path);
227 err = journal_end(th, s, len) ; 230 reiserfs_update_sd(th, inode);
228 if (!err) { 231 err = journal_end(th, s, len);
229 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6) ; 232 if (!err) {
230 if (!err) 233 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
231 reiserfs_update_inode_transaction(inode) ; 234 if (!err)
232 } 235 reiserfs_update_inode_transaction(inode);
233 return err; 236 }
237 return err;
234} 238}
235 239
236// it is called by get_block when create == 0. Returns block number 240// it is called by get_block when create == 0. Returns block number
@@ -241,190 +245,192 @@ static int file_capable (struct inode * inode, long block)
241// Please improve the english/clarity in the comment above, as it is 245// Please improve the english/clarity in the comment above, as it is
242// hard to understand. 246// hard to understand.
243 247
244static int _get_block_create_0 (struct inode * inode, long block, 248static int _get_block_create_0(struct inode *inode, long block,
245 struct buffer_head * bh_result, 249 struct buffer_head *bh_result, int args)
246 int args)
247{ 250{
248 INITIALIZE_PATH (path); 251 INITIALIZE_PATH(path);
249 struct cpu_key key; 252 struct cpu_key key;
250 struct buffer_head * bh; 253 struct buffer_head *bh;
251 struct item_head * ih, tmp_ih; 254 struct item_head *ih, tmp_ih;
252 int fs_gen ; 255 int fs_gen;
253 int blocknr; 256 int blocknr;
254 char * p = NULL; 257 char *p = NULL;
255 int chars; 258 int chars;
256 int ret ; 259 int ret;
257 int result ; 260 int result;
258 int done = 0 ; 261 int done = 0;
259 unsigned long offset ; 262 unsigned long offset;
260 263
261 // prepare the key to look for the 'block'-th block of file 264 // prepare the key to look for the 'block'-th block of file
262 make_cpu_key (&key, inode, 265 make_cpu_key(&key, inode,
263 (loff_t)block * inode->i_sb->s_blocksize + 1, TYPE_ANY, 3); 266 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
264 267 3);
265research: 268
266 result = search_for_position_by_key (inode->i_sb, &key, &path) ; 269 research:
267 if (result != POSITION_FOUND) { 270 result = search_for_position_by_key(inode->i_sb, &key, &path);
268 pathrelse (&path); 271 if (result != POSITION_FOUND) {
269 if (p) 272 pathrelse(&path);
270 kunmap(bh_result->b_page) ; 273 if (p)
271 if (result == IO_ERROR) 274 kunmap(bh_result->b_page);
272 return -EIO; 275 if (result == IO_ERROR)
273 // We do not return -ENOENT if there is a hole but page is uptodate, because it means 276 return -EIO;
274 // That there is some MMAPED data associated with it that is yet to be written to disk. 277 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
275 if ((args & GET_BLOCK_NO_HOLE) && !PageUptodate(bh_result->b_page) ) { 278 // That there is some MMAPED data associated with it that is yet to be written to disk.
276 return -ENOENT ; 279 if ((args & GET_BLOCK_NO_HOLE)
277 } 280 && !PageUptodate(bh_result->b_page)) {
278 return 0 ; 281 return -ENOENT;
279 } 282 }
280 283 return 0;
281 // 284 }
282 bh = get_last_bh (&path); 285 //
283 ih = get_ih (&path); 286 bh = get_last_bh(&path);
284 if (is_indirect_le_ih (ih)) { 287 ih = get_ih(&path);
285 __le32 * ind_item = (__le32 *)B_I_PITEM (bh, ih); 288 if (is_indirect_le_ih(ih)) {
286 289 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
287 /* FIXME: here we could cache indirect item or part of it in 290
288 the inode to avoid search_by_key in case of subsequent 291 /* FIXME: here we could cache indirect item or part of it in
289 access to file */ 292 the inode to avoid search_by_key in case of subsequent
290 blocknr = get_block_num(ind_item, path.pos_in_item) ; 293 access to file */
291 ret = 0 ; 294 blocknr = get_block_num(ind_item, path.pos_in_item);
292 if (blocknr) { 295 ret = 0;
293 map_bh(bh_result, inode->i_sb, blocknr); 296 if (blocknr) {
294 if (path.pos_in_item == ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) { 297 map_bh(bh_result, inode->i_sb, blocknr);
295 set_buffer_boundary(bh_result); 298 if (path.pos_in_item ==
296 } 299 ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
297 } else 300 set_buffer_boundary(bh_result);
298 // We do not return -ENOENT if there is a hole but page is uptodate, because it means 301 }
299 // That there is some MMAPED data associated with it that is yet to be written to disk. 302 } else
300 if ((args & GET_BLOCK_NO_HOLE) && !PageUptodate(bh_result->b_page) ) { 303 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
301 ret = -ENOENT ; 304 // That there is some MMAPED data associated with it that is yet to be written to disk.
302 } 305 if ((args & GET_BLOCK_NO_HOLE)
303 306 && !PageUptodate(bh_result->b_page)) {
304 pathrelse (&path); 307 ret = -ENOENT;
305 if (p) 308 }
306 kunmap(bh_result->b_page) ; 309
307 return ret ; 310 pathrelse(&path);
308 } 311 if (p)
309 312 kunmap(bh_result->b_page);
310 // requested data are in direct item(s) 313 return ret;
311 if (!(args & GET_BLOCK_READ_DIRECT)) { 314 }
312 // we are called by bmap. FIXME: we can not map block of file 315 // requested data are in direct item(s)
313 // when it is stored in direct item(s) 316 if (!(args & GET_BLOCK_READ_DIRECT)) {
314 pathrelse (&path); 317 // we are called by bmap. FIXME: we can not map block of file
315 if (p) 318 // when it is stored in direct item(s)
316 kunmap(bh_result->b_page) ; 319 pathrelse(&path);
317 return -ENOENT; 320 if (p)
318 } 321 kunmap(bh_result->b_page);
319 322 return -ENOENT;
320 /* if we've got a direct item, and the buffer or page was uptodate, 323 }
321 ** we don't want to pull data off disk again. skip to the 324
322 ** end, where we map the buffer and return 325 /* if we've got a direct item, and the buffer or page was uptodate,
323 */ 326 ** we don't want to pull data off disk again. skip to the
324 if (buffer_uptodate(bh_result)) { 327 ** end, where we map the buffer and return
325 goto finished ; 328 */
326 } else 329 if (buffer_uptodate(bh_result)) {
327 /* 330 goto finished;
328 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date 331 } else
329 ** pages without any buffers. If the page is up to date, we don't want 332 /*
330 ** read old data off disk. Set the up to date bit on the buffer instead 333 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
331 ** and jump to the end 334 ** pages without any buffers. If the page is up to date, we don't want
332 */ 335 ** read old data off disk. Set the up to date bit on the buffer instead
333 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) { 336 ** and jump to the end
337 */
338 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
334 set_buffer_uptodate(bh_result); 339 set_buffer_uptodate(bh_result);
335 goto finished ; 340 goto finished;
336 } 341 }
337 342 // read file tail into part of page
338 // read file tail into part of page 343 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
339 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1) ; 344 fs_gen = get_generation(inode->i_sb);
340 fs_gen = get_generation(inode->i_sb) ; 345 copy_item_head(&tmp_ih, ih);
341 copy_item_head (&tmp_ih, ih); 346
342 347 /* we only want to kmap if we are reading the tail into the page.
343 /* we only want to kmap if we are reading the tail into the page. 348 ** this is not the common case, so we don't kmap until we are
344 ** this is not the common case, so we don't kmap until we are 349 ** sure we need to. But, this means the item might move if
345 ** sure we need to. But, this means the item might move if 350 ** kmap schedules
346 ** kmap schedules 351 */
347 */ 352 if (!p) {
348 if (!p) { 353 p = (char *)kmap(bh_result->b_page);
349 p = (char *)kmap(bh_result->b_page) ; 354 if (fs_changed(fs_gen, inode->i_sb)
350 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) { 355 && item_moved(&tmp_ih, &path)) {
351 goto research; 356 goto research;
352 } 357 }
353 } 358 }
354 p += offset ; 359 p += offset;
355 memset (p, 0, inode->i_sb->s_blocksize); 360 memset(p, 0, inode->i_sb->s_blocksize);
356 do { 361 do {
357 if (!is_direct_le_ih (ih)) { 362 if (!is_direct_le_ih(ih)) {
358 BUG (); 363 BUG();
359 } 364 }
360 /* make sure we don't read more bytes than actually exist in 365 /* make sure we don't read more bytes than actually exist in
361 ** the file. This can happen in odd cases where i_size isn't 366 ** the file. This can happen in odd cases where i_size isn't
362 ** correct, and when direct item padding results in a few 367 ** correct, and when direct item padding results in a few
363 ** extra bytes at the end of the direct item 368 ** extra bytes at the end of the direct item
364 */ 369 */
365 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size) 370 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
366 break ; 371 break;
367 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) { 372 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
368 chars = inode->i_size - (le_ih_k_offset(ih) - 1) - path.pos_in_item; 373 chars =
369 done = 1 ; 374 inode->i_size - (le_ih_k_offset(ih) - 1) -
370 } else { 375 path.pos_in_item;
371 chars = ih_item_len(ih) - path.pos_in_item; 376 done = 1;
372 } 377 } else {
373 memcpy (p, B_I_PITEM (bh, ih) + path.pos_in_item, chars); 378 chars = ih_item_len(ih) - path.pos_in_item;
374 379 }
375 if (done) 380 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
376 break ;
377
378 p += chars;
379
380 if (PATH_LAST_POSITION (&path) != (B_NR_ITEMS (bh) - 1))
381 // we done, if read direct item is not the last item of
382 // node FIXME: we could try to check right delimiting key
383 // to see whether direct item continues in the right
384 // neighbor or rely on i_size
385 break;
386
387 // update key to look for the next piece
388 set_cpu_key_k_offset (&key, cpu_key_k_offset (&key) + chars);
389 result = search_for_position_by_key (inode->i_sb, &key, &path);
390 if (result != POSITION_FOUND)
391 // i/o error most likely
392 break;
393 bh = get_last_bh (&path);
394 ih = get_ih (&path);
395 } while (1);
396
397 flush_dcache_page(bh_result->b_page) ;
398 kunmap(bh_result->b_page) ;
399
400finished:
401 pathrelse (&path);
402
403 if (result == IO_ERROR)
404 return -EIO;
405
406 /* this buffer has valid data, but isn't valid for io. mapping it to
407 * block #0 tells the rest of reiserfs it just has a tail in it
408 */
409 map_bh(bh_result, inode->i_sb, 0);
410 set_buffer_uptodate (bh_result);
411 return 0;
412}
413 381
382 if (done)
383 break;
384
385 p += chars;
386
387 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
388 // we done, if read direct item is not the last item of
389 // node FIXME: we could try to check right delimiting key
390 // to see whether direct item continues in the right
391 // neighbor or rely on i_size
392 break;
393
394 // update key to look for the next piece
395 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
396 result = search_for_position_by_key(inode->i_sb, &key, &path);
397 if (result != POSITION_FOUND)
398 // i/o error most likely
399 break;
400 bh = get_last_bh(&path);
401 ih = get_ih(&path);
402 } while (1);
403
404 flush_dcache_page(bh_result->b_page);
405 kunmap(bh_result->b_page);
406
407 finished:
408 pathrelse(&path);
409
410 if (result == IO_ERROR)
411 return -EIO;
412
413 /* this buffer has valid data, but isn't valid for io. mapping it to
414 * block #0 tells the rest of reiserfs it just has a tail in it
415 */
416 map_bh(bh_result, inode->i_sb, 0);
417 set_buffer_uptodate(bh_result);
418 return 0;
419}
414 420
415// this is called to create file map. So, _get_block_create_0 will not 421// this is called to create file map. So, _get_block_create_0 will not
416// read direct item 422// read direct item
417static int reiserfs_bmap (struct inode * inode, sector_t block, 423static int reiserfs_bmap(struct inode *inode, sector_t block,
418 struct buffer_head * bh_result, int create) 424 struct buffer_head *bh_result, int create)
419{ 425{
420 if (!file_capable (inode, block)) 426 if (!file_capable(inode, block))
421 return -EFBIG; 427 return -EFBIG;
422 428
423 reiserfs_write_lock(inode->i_sb); 429 reiserfs_write_lock(inode->i_sb);
424 /* do not read the direct item */ 430 /* do not read the direct item */
425 _get_block_create_0 (inode, block, bh_result, 0) ; 431 _get_block_create_0(inode, block, bh_result, 0);
426 reiserfs_write_unlock(inode->i_sb); 432 reiserfs_write_unlock(inode->i_sb);
427 return 0; 433 return 0;
428} 434}
429 435
430/* special version of get_block that is only used by grab_tail_page right 436/* special version of get_block that is only used by grab_tail_page right
@@ -444,9 +450,11 @@ static int reiserfs_bmap (struct inode * inode, sector_t block,
444** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block, 450** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
445** don't use this function. 451** don't use this function.
446*/ 452*/
447static int reiserfs_get_block_create_0 (struct inode * inode, sector_t block, 453static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
448 struct buffer_head * bh_result, int create) { 454 struct buffer_head *bh_result,
449 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE) ; 455 int create)
456{
457 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
450} 458}
451 459
452/* This is special helper for reiserfs_get_block in case we are executing 460/* This is special helper for reiserfs_get_block in case we are executing
@@ -457,43 +465,42 @@ static int reiserfs_get_blocks_direct_io(struct inode *inode,
457 struct buffer_head *bh_result, 465 struct buffer_head *bh_result,
458 int create) 466 int create)
459{ 467{
460 int ret ; 468 int ret;
461
462 bh_result->b_page = NULL;
463
464 /* We set the b_size before reiserfs_get_block call since it is
465 referenced in convert_tail_for_hole() that may be called from
466 reiserfs_get_block() */
467 bh_result->b_size = (1 << inode->i_blkbits);
468
469 ret = reiserfs_get_block(inode, iblock, bh_result,
470 create | GET_BLOCK_NO_DANGLE) ;
471 if (ret)
472 goto out;
473
474 /* don't allow direct io onto tail pages */
475 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
476 /* make sure future calls to the direct io funcs for this offset
477 ** in the file fail by unmapping the buffer
478 */
479 clear_buffer_mapped(bh_result);
480 ret = -EINVAL ;
481 }
482 /* Possible unpacked tail. Flush the data before pages have
483 disappeared */
484 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
485 int err;
486 lock_kernel();
487 err = reiserfs_commit_for_inode(inode);
488 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
489 unlock_kernel();
490 if (err < 0)
491 ret = err;
492 }
493out:
494 return ret ;
495}
496 469
470 bh_result->b_page = NULL;
471
472 /* We set the b_size before reiserfs_get_block call since it is
473 referenced in convert_tail_for_hole() that may be called from
474 reiserfs_get_block() */
475 bh_result->b_size = (1 << inode->i_blkbits);
476
477 ret = reiserfs_get_block(inode, iblock, bh_result,
478 create | GET_BLOCK_NO_DANGLE);
479 if (ret)
480 goto out;
481
482 /* don't allow direct io onto tail pages */
483 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
484 /* make sure future calls to the direct io funcs for this offset
485 ** in the file fail by unmapping the buffer
486 */
487 clear_buffer_mapped(bh_result);
488 ret = -EINVAL;
489 }
490 /* Possible unpacked tail. Flush the data before pages have
491 disappeared */
492 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
493 int err;
494 lock_kernel();
495 err = reiserfs_commit_for_inode(inode);
496 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
497 unlock_kernel();
498 if (err < 0)
499 ret = err;
500 }
501 out:
502 return ret;
503}
497 504
498/* 505/*
499** helper function for when reiserfs_get_block is called for a hole 506** helper function for when reiserfs_get_block is called for a hole
@@ -505,490 +512,547 @@ out:
505** you should not be in a transaction, or have any paths held when you 512** you should not be in a transaction, or have any paths held when you
506** call this. 513** call this.
507*/ 514*/
508static int convert_tail_for_hole(struct inode *inode, 515static int convert_tail_for_hole(struct inode *inode,
509 struct buffer_head *bh_result, 516 struct buffer_head *bh_result,
510 loff_t tail_offset) { 517 loff_t tail_offset)
511 unsigned long index ; 518{
512 unsigned long tail_end ; 519 unsigned long index;
513 unsigned long tail_start ; 520 unsigned long tail_end;
514 struct page * tail_page ; 521 unsigned long tail_start;
515 struct page * hole_page = bh_result->b_page ; 522 struct page *tail_page;
516 int retval = 0 ; 523 struct page *hole_page = bh_result->b_page;
517 524 int retval = 0;
518 if ((tail_offset & (bh_result->b_size - 1)) != 1) 525
519 return -EIO ; 526 if ((tail_offset & (bh_result->b_size - 1)) != 1)
520 527 return -EIO;
521 /* always try to read until the end of the block */ 528
522 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1) ; 529 /* always try to read until the end of the block */
523 tail_end = (tail_start | (bh_result->b_size - 1)) + 1 ; 530 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
524 531 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
525 index = tail_offset >> PAGE_CACHE_SHIFT ; 532
526 /* hole_page can be zero in case of direct_io, we are sure 533 index = tail_offset >> PAGE_CACHE_SHIFT;
527 that we cannot get here if we write with O_DIRECT into 534 /* hole_page can be zero in case of direct_io, we are sure
528 tail page */ 535 that we cannot get here if we write with O_DIRECT into
529 if (!hole_page || index != hole_page->index) { 536 tail page */
530 tail_page = grab_cache_page(inode->i_mapping, index) ; 537 if (!hole_page || index != hole_page->index) {
531 retval = -ENOMEM; 538 tail_page = grab_cache_page(inode->i_mapping, index);
532 if (!tail_page) { 539 retval = -ENOMEM;
533 goto out ; 540 if (!tail_page) {
534 } 541 goto out;
535 } else { 542 }
536 tail_page = hole_page ; 543 } else {
537 } 544 tail_page = hole_page;
538 545 }
539 /* we don't have to make sure the conversion did not happen while 546
540 ** we were locking the page because anyone that could convert 547 /* we don't have to make sure the conversion did not happen while
541 ** must first take i_sem. 548 ** we were locking the page because anyone that could convert
542 ** 549 ** must first take i_sem.
543 ** We must fix the tail page for writing because it might have buffers 550 **
544 ** that are mapped, but have a block number of 0. This indicates tail 551 ** We must fix the tail page for writing because it might have buffers
545 ** data that has been read directly into the page, and block_prepare_write 552 ** that are mapped, but have a block number of 0. This indicates tail
546 ** won't trigger a get_block in this case. 553 ** data that has been read directly into the page, and block_prepare_write
547 */ 554 ** won't trigger a get_block in this case.
548 fix_tail_page_for_writing(tail_page) ; 555 */
549 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end); 556 fix_tail_page_for_writing(tail_page);
550 if (retval) 557 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
551 goto unlock ; 558 if (retval)
552 559 goto unlock;
553 /* tail conversion might change the data in the page */ 560
554 flush_dcache_page(tail_page) ; 561 /* tail conversion might change the data in the page */
555 562 flush_dcache_page(tail_page);
556 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end) ; 563
557 564 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
558unlock: 565
559 if (tail_page != hole_page) { 566 unlock:
560 unlock_page(tail_page) ; 567 if (tail_page != hole_page) {
561 page_cache_release(tail_page) ; 568 unlock_page(tail_page);
562 } 569 page_cache_release(tail_page);
563out: 570 }
564 return retval ; 571 out:
572 return retval;
565} 573}
566 574
567static inline int _allocate_block(struct reiserfs_transaction_handle *th, 575static inline int _allocate_block(struct reiserfs_transaction_handle *th,
568 long block, 576 long block,
569 struct inode *inode, 577 struct inode *inode,
570 b_blocknr_t *allocated_block_nr, 578 b_blocknr_t * allocated_block_nr,
571 struct path * path, 579 struct path *path, int flags)
572 int flags) { 580{
573 BUG_ON (!th->t_trans_id); 581 BUG_ON(!th->t_trans_id);
574 582
575#ifdef REISERFS_PREALLOCATE 583#ifdef REISERFS_PREALLOCATE
576 if (!(flags & GET_BLOCK_NO_ISEM)) { 584 if (!(flags & GET_BLOCK_NO_ISEM)) {
577 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr, path, block); 585 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
578 } 586 path, block);
587 }
579#endif 588#endif
580 return reiserfs_new_unf_blocknrs (th, inode, allocated_block_nr, path, block); 589 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
590 block);
581} 591}
582 592
583int reiserfs_get_block (struct inode * inode, sector_t block, 593int reiserfs_get_block(struct inode *inode, sector_t block,
584 struct buffer_head * bh_result, int create) 594 struct buffer_head *bh_result, int create)
585{ 595{
586 int repeat, retval = 0; 596 int repeat, retval = 0;
587 b_blocknr_t allocated_block_nr = 0;// b_blocknr_t is (unsigned) 32 bit int 597 b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int
588 INITIALIZE_PATH(path); 598 INITIALIZE_PATH(path);
589 int pos_in_item; 599 int pos_in_item;
590 struct cpu_key key; 600 struct cpu_key key;
591 struct buffer_head * bh, * unbh = NULL; 601 struct buffer_head *bh, *unbh = NULL;
592 struct item_head * ih, tmp_ih; 602 struct item_head *ih, tmp_ih;
593 __le32 * item; 603 __le32 *item;
594 int done; 604 int done;
595 int fs_gen; 605 int fs_gen;
596 struct reiserfs_transaction_handle *th = NULL; 606 struct reiserfs_transaction_handle *th = NULL;
597 /* space reserved in transaction batch: 607 /* space reserved in transaction batch:
598 . 3 balancings in direct->indirect conversion 608 . 3 balancings in direct->indirect conversion
599 . 1 block involved into reiserfs_update_sd() 609 . 1 block involved into reiserfs_update_sd()
600 XXX in practically impossible worst case direct2indirect() 610 XXX in practically impossible worst case direct2indirect()
601 can incur (much) more than 3 balancings. 611 can incur (much) more than 3 balancings.
602 quota update for user, group */ 612 quota update for user, group */
603 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 1 + 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); 613 int jbegin_count =
604 int version; 614 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
605 int dangle = 1; 615 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
606 loff_t new_offset = (((loff_t)block) << inode->i_sb->s_blocksize_bits) + 1 ; 616 int version;
607 617 int dangle = 1;
608 /* bad.... */ 618 loff_t new_offset =
609 reiserfs_write_lock(inode->i_sb); 619 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
610 version = get_inode_item_key_version (inode); 620
611 621 /* bad.... */
612 if (block < 0) { 622 reiserfs_write_lock(inode->i_sb);
613 reiserfs_write_unlock(inode->i_sb); 623 version = get_inode_item_key_version(inode);
614 return -EIO;
615 }
616 624
617 if (!file_capable (inode, block)) { 625 if (block < 0) {
618 reiserfs_write_unlock(inode->i_sb); 626 reiserfs_write_unlock(inode->i_sb);
619 return -EFBIG; 627 return -EIO;
620 } 628 }
621
622 /* if !create, we aren't changing the FS, so we don't need to
623 ** log anything, so we don't need to start a transaction
624 */
625 if (!(create & GET_BLOCK_CREATE)) {
626 int ret ;
627 /* find number of block-th logical block of the file */
628 ret = _get_block_create_0 (inode, block, bh_result,
629 create | GET_BLOCK_READ_DIRECT) ;
630 reiserfs_write_unlock(inode->i_sb);
631 return ret;
632 }
633 /*
634 * if we're already in a transaction, make sure to close
635 * any new transactions we start in this func
636 */
637 if ((create & GET_BLOCK_NO_DANGLE) ||
638 reiserfs_transaction_running(inode->i_sb))
639 dangle = 0;
640
641 /* If file is of such a size, that it might have a tail and tails are enabled
642 ** we should mark it as possibly needing tail packing on close
643 */
644 if ( (have_large_tails (inode->i_sb) && inode->i_size < i_block_size (inode)*4) ||
645 (have_small_tails (inode->i_sb) && inode->i_size < i_block_size(inode)) )
646 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask ;
647
648 /* set the key of the first byte in the 'block'-th block of file */
649 make_cpu_key (&key, inode, new_offset,
650 TYPE_ANY, 3/*key length*/);
651 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
652start_trans:
653 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
654 if (!th) {
655 retval = -ENOMEM;
656 goto failure;
657 }
658 reiserfs_update_inode_transaction(inode) ;
659 }
660 research:
661
662 retval = search_for_position_by_key (inode->i_sb, &key, &path);
663 if (retval == IO_ERROR) {
664 retval = -EIO;
665 goto failure;
666 }
667
668 bh = get_last_bh (&path);
669 ih = get_ih (&path);
670 item = get_item (&path);
671 pos_in_item = path.pos_in_item;
672
673 fs_gen = get_generation (inode->i_sb);
674 copy_item_head (&tmp_ih, ih);
675
676 if (allocation_needed (retval, allocated_block_nr, ih, item, pos_in_item)) {
677 /* we have to allocate block for the unformatted node */
678 if (!th) {
679 pathrelse(&path) ;
680 goto start_trans;
681 }
682
683 repeat = _allocate_block(th, block, inode, &allocated_block_nr, &path, create);
684
685 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
686 /* restart the transaction to give the journal a chance to free
687 ** some blocks. releases the path, so we have to go back to
688 ** research if we succeed on the second try
689 */
690 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
691 retval = restart_transaction(th, inode, &path) ;
692 if (retval)
693 goto failure;
694 repeat = _allocate_block(th, block, inode, &allocated_block_nr, NULL, create);
695
696 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
697 goto research ;
698 }
699 if (repeat == QUOTA_EXCEEDED)
700 retval = -EDQUOT;
701 else
702 retval = -ENOSPC;
703 goto failure;
704 }
705
706 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
707 goto research;
708 }
709 }
710
711 if (indirect_item_found (retval, ih)) {
712 b_blocknr_t unfm_ptr;
713 /* 'block'-th block is in the file already (there is
714 corresponding cell in some indirect item). But it may be
715 zero unformatted node pointer (hole) */
716 unfm_ptr = get_block_num (item, pos_in_item);
717 if (unfm_ptr == 0) {
718 /* use allocated block to plug the hole */
719 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ;
720 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
721 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
722 goto research;
723 }
724 set_buffer_new(bh_result);
725 if (buffer_dirty(bh_result) && reiserfs_data_ordered(inode->i_sb))
726 reiserfs_add_ordered_list(inode, bh_result);
727 put_block_num(item, pos_in_item, allocated_block_nr) ;
728 unfm_ptr = allocated_block_nr;
729 journal_mark_dirty (th, inode->i_sb, bh);
730 reiserfs_update_sd(th, inode) ;
731 }
732 set_block_dev_mapped(bh_result, unfm_ptr, inode);
733 pathrelse (&path);
734 retval = 0;
735 if (!dangle && th)
736 retval = reiserfs_end_persistent_transaction(th);
737 629
738 reiserfs_write_unlock(inode->i_sb); 630 if (!file_capable(inode, block)) {
739 631 reiserfs_write_unlock(inode->i_sb);
740 /* the item was found, so new blocks were not added to the file 632 return -EFBIG;
741 ** there is no need to make sure the inode is updated with this 633 }
742 ** transaction 634
743 */ 635 /* if !create, we aren't changing the FS, so we don't need to
744 return retval; 636 ** log anything, so we don't need to start a transaction
745 } 637 */
746 638 if (!(create & GET_BLOCK_CREATE)) {
747 if (!th) { 639 int ret;
748 pathrelse(&path) ; 640 /* find number of block-th logical block of the file */
749 goto start_trans; 641 ret = _get_block_create_0(inode, block, bh_result,
750 } 642 create | GET_BLOCK_READ_DIRECT);
751 643 reiserfs_write_unlock(inode->i_sb);
752 /* desired position is not found or is in the direct item. We have 644 return ret;
753 to append file with holes up to 'block'-th block converting 645 }
754 direct items to indirect one if necessary */ 646 /*
755 done = 0; 647 * if we're already in a transaction, make sure to close
756 do { 648 * any new transactions we start in this func
757 if (is_statdata_le_ih (ih)) { 649 */
758 __le32 unp = 0; 650 if ((create & GET_BLOCK_NO_DANGLE) ||
759 struct cpu_key tmp_key; 651 reiserfs_transaction_running(inode->i_sb))
760 652 dangle = 0;
761 /* indirect item has to be inserted */ 653
762 make_le_item_head (&tmp_ih, &key, version, 1, TYPE_INDIRECT, 654 /* If file is of such a size, that it might have a tail and tails are enabled
763 UNFM_P_SIZE, 0/* free_space */); 655 ** we should mark it as possibly needing tail packing on close
764 656 */
765 if (cpu_key_k_offset (&key) == 1) { 657 if ((have_large_tails(inode->i_sb)
766 /* we are going to add 'block'-th block to the file. Use 658 && inode->i_size < i_block_size(inode) * 4)
767 allocated block for that */ 659 || (have_small_tails(inode->i_sb)
768 unp = cpu_to_le32 (allocated_block_nr); 660 && inode->i_size < i_block_size(inode)))
769 set_block_dev_mapped (bh_result, allocated_block_nr, inode); 661 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
770 set_buffer_new(bh_result); 662
771 done = 1; 663 /* set the key of the first byte in the 'block'-th block of file */
772 } 664 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
773 tmp_key = key; // ;) 665 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
774 set_cpu_key_k_offset (&tmp_key, 1); 666 start_trans:
775 PATH_LAST_POSITION(&path) ++; 667 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
776 668 if (!th) {
777 retval = reiserfs_insert_item (th, &path, &tmp_key, &tmp_ih, inode, (char *)&unp); 669 retval = -ENOMEM;
778 if (retval) {
779 reiserfs_free_block (th, inode, allocated_block_nr, 1);
780 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
781 }
782 //mark_tail_converted (inode);
783 } else if (is_direct_le_ih (ih)) {
784 /* direct item has to be converted */
785 loff_t tail_offset;
786
787 tail_offset = ((le_ih_k_offset (ih) - 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
788 if (tail_offset == cpu_key_k_offset (&key)) {
789 /* direct item we just found fits into block we have
790 to map. Convert it into unformatted node: use
791 bh_result for the conversion */
792 set_block_dev_mapped (bh_result, allocated_block_nr, inode);
793 unbh = bh_result;
794 done = 1;
795 } else {
796 /* we have to padd file tail stored in direct item(s)
797 up to block size and convert it to unformatted
798 node. FIXME: this should also get into page cache */
799
800 pathrelse(&path) ;
801 /*
802 * ugly, but we can only end the transaction if
803 * we aren't nested
804 */
805 BUG_ON (!th->t_refcount);
806 if (th->t_refcount == 1) {
807 retval = reiserfs_end_persistent_transaction(th);
808 th = NULL;
809 if (retval)
810 goto failure; 670 goto failure;
811 } 671 }
672 reiserfs_update_inode_transaction(inode);
673 }
674 research:
812 675
813 retval = convert_tail_for_hole(inode, bh_result, tail_offset) ; 676 retval = search_for_position_by_key(inode->i_sb, &key, &path);
814 if (retval) {
815 if ( retval != -ENOSPC )
816 reiserfs_warning (inode->i_sb, "clm-6004: convert tail failed inode %lu, error %d", inode->i_ino, retval) ;
817 if (allocated_block_nr) {
818 /* the bitmap, the super, and the stat data == 3 */
819 if (!th)
820 th = reiserfs_persistent_transaction(inode->i_sb,3);
821 if (th)
822 reiserfs_free_block (th,inode,allocated_block_nr,1);
823 }
824 goto failure ;
825 }
826 goto research ;
827 }
828 retval = direct2indirect (th, inode, &path, unbh, tail_offset);
829 if (retval) {
830 reiserfs_unmap_buffer(unbh);
831 reiserfs_free_block (th, inode, allocated_block_nr, 1);
832 goto failure;
833 }
834 /* it is important the set_buffer_uptodate is done after
835 ** the direct2indirect. The buffer might contain valid
836 ** data newer than the data on disk (read by readpage, changed,
837 ** and then sent here by writepage). direct2indirect needs
838 ** to know if unbh was already up to date, so it can decide
839 ** if the data in unbh needs to be replaced with data from
840 ** the disk
841 */
842 set_buffer_uptodate (unbh);
843
844 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
845 buffer will disappear shortly, so it should not be added to
846 */
847 if ( unbh->b_page ) {
848 /* we've converted the tail, so we must
849 ** flush unbh before the transaction commits
850 */
851 reiserfs_add_tail_list(inode, unbh) ;
852
853 /* mark it dirty now to prevent commit_write from adding
854 ** this buffer to the inode's dirty buffer list
855 */
856 /*
857 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
858 * It's still atomic, but it sets the page dirty too,
859 * which makes it eligible for writeback at any time by the
860 * VM (which was also the case with __mark_buffer_dirty())
861 */
862 mark_buffer_dirty(unbh) ;
863 }
864 } else {
865 /* append indirect item with holes if needed, when appending
866 pointer to 'block'-th block use block, which is already
867 allocated */
868 struct cpu_key tmp_key;
869 unp_t unf_single=0; // We use this in case we need to allocate only
870 // one block which is a fastpath
871 unp_t *un;
872 __u64 max_to_insert=MAX_ITEM_LEN(inode->i_sb->s_blocksize)/UNFM_P_SIZE;
873 __u64 blocks_needed;
874
875 RFALSE( pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
876 "vs-804: invalid position for append");
877 /* indirect item has to be appended, set up key of that position */
878 make_cpu_key (&tmp_key, inode,
879 le_key_k_offset (version, &(ih->ih_key)) + op_bytes_number (ih, inode->i_sb->s_blocksize),
880 //pos_in_item * inode->i_sb->s_blocksize,
881 TYPE_INDIRECT, 3);// key type is unimportant
882
883 blocks_needed = 1 + ((cpu_key_k_offset (&key) - cpu_key_k_offset (&tmp_key)) >> inode->i_sb->s_blocksize_bits);
884 RFALSE( blocks_needed < 0, "green-805: invalid offset");
885
886 if ( blocks_needed == 1 ) {
887 un = &unf_single;
888 } else {
889 un=kmalloc( min(blocks_needed,max_to_insert)*UNFM_P_SIZE,
890 GFP_ATOMIC); // We need to avoid scheduling.
891 if ( !un) {
892 un = &unf_single;
893 blocks_needed = 1;
894 max_to_insert = 0;
895 } else
896 memset(un, 0, UNFM_P_SIZE * min(blocks_needed,max_to_insert));
897 }
898 if ( blocks_needed <= max_to_insert) {
899 /* we are going to add target block to the file. Use allocated
900 block for that */
901 un[blocks_needed-1] = cpu_to_le32 (allocated_block_nr);
902 set_block_dev_mapped (bh_result, allocated_block_nr, inode);
903 set_buffer_new(bh_result);
904 done = 1;
905 } else {
906 /* paste hole to the indirect item */
907 /* If kmalloc failed, max_to_insert becomes zero and it means we
908 only have space for one block */
909 blocks_needed=max_to_insert?max_to_insert:1;
910 }
911 retval = reiserfs_paste_into_item (th, &path, &tmp_key, inode, (char *)un, UNFM_P_SIZE * blocks_needed);
912
913 if (blocks_needed != 1)
914 kfree(un);
915
916 if (retval) {
917 reiserfs_free_block (th, inode, allocated_block_nr, 1);
918 goto failure;
919 }
920 if (!done) {
921 /* We need to mark new file size in case this function will be
922 interrupted/aborted later on. And we may do this only for
923 holes. */
924 inode->i_size += inode->i_sb->s_blocksize * blocks_needed;
925 }
926 }
927
928 if (done == 1)
929 break;
930
931 /* this loop could log more blocks than we had originally asked
932 ** for. So, we have to allow the transaction to end if it is
933 ** too big or too full. Update the inode so things are
934 ** consistent if we crash before the function returns
935 **
936 ** release the path so that anybody waiting on the path before
937 ** ending their transaction will be able to continue.
938 */
939 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
940 retval = restart_transaction(th, inode, &path) ;
941 if (retval)
942 goto failure;
943 }
944 /* inserting indirect pointers for a hole can take a
945 ** long time. reschedule if needed
946 */
947 cond_resched();
948
949 retval = search_for_position_by_key (inode->i_sb, &key, &path);
950 if (retval == IO_ERROR) { 677 if (retval == IO_ERROR) {
951 retval = -EIO; 678 retval = -EIO;
952 goto failure; 679 goto failure;
953 } 680 }
954 if (retval == POSITION_FOUND) { 681
955 reiserfs_warning (inode->i_sb, "vs-825: reiserfs_get_block: " 682 bh = get_last_bh(&path);
956 "%K should not be found", &key); 683 ih = get_ih(&path);
957 retval = -EEXIST; 684 item = get_item(&path);
958 if (allocated_block_nr)
959 reiserfs_free_block (th, inode, allocated_block_nr, 1);
960 pathrelse(&path) ;
961 goto failure;
962 }
963 bh = get_last_bh (&path);
964 ih = get_ih (&path);
965 item = get_item (&path);
966 pos_in_item = path.pos_in_item; 685 pos_in_item = path.pos_in_item;
967 } while (1);
968 686
687 fs_gen = get_generation(inode->i_sb);
688 copy_item_head(&tmp_ih, ih);
689
690 if (allocation_needed
691 (retval, allocated_block_nr, ih, item, pos_in_item)) {
692 /* we have to allocate block for the unformatted node */
693 if (!th) {
694 pathrelse(&path);
695 goto start_trans;
696 }
697
698 repeat =
699 _allocate_block(th, block, inode, &allocated_block_nr,
700 &path, create);
701
702 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
703 /* restart the transaction to give the journal a chance to free
704 ** some blocks. releases the path, so we have to go back to
705 ** research if we succeed on the second try
706 */
707 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
708 retval = restart_transaction(th, inode, &path);
709 if (retval)
710 goto failure;
711 repeat =
712 _allocate_block(th, block, inode,
713 &allocated_block_nr, NULL, create);
714
715 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
716 goto research;
717 }
718 if (repeat == QUOTA_EXCEEDED)
719 retval = -EDQUOT;
720 else
721 retval = -ENOSPC;
722 goto failure;
723 }
724
725 if (fs_changed(fs_gen, inode->i_sb)
726 && item_moved(&tmp_ih, &path)) {
727 goto research;
728 }
729 }
730
731 if (indirect_item_found(retval, ih)) {
732 b_blocknr_t unfm_ptr;
733 /* 'block'-th block is in the file already (there is
734 corresponding cell in some indirect item). But it may be
735 zero unformatted node pointer (hole) */
736 unfm_ptr = get_block_num(item, pos_in_item);
737 if (unfm_ptr == 0) {
738 /* use allocated block to plug the hole */
739 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
740 if (fs_changed(fs_gen, inode->i_sb)
741 && item_moved(&tmp_ih, &path)) {
742 reiserfs_restore_prepared_buffer(inode->i_sb,
743 bh);
744 goto research;
745 }
746 set_buffer_new(bh_result);
747 if (buffer_dirty(bh_result)
748 && reiserfs_data_ordered(inode->i_sb))
749 reiserfs_add_ordered_list(inode, bh_result);
750 put_block_num(item, pos_in_item, allocated_block_nr);
751 unfm_ptr = allocated_block_nr;
752 journal_mark_dirty(th, inode->i_sb, bh);
753 reiserfs_update_sd(th, inode);
754 }
755 set_block_dev_mapped(bh_result, unfm_ptr, inode);
756 pathrelse(&path);
757 retval = 0;
758 if (!dangle && th)
759 retval = reiserfs_end_persistent_transaction(th);
760
761 reiserfs_write_unlock(inode->i_sb);
762
763 /* the item was found, so new blocks were not added to the file
764 ** there is no need to make sure the inode is updated with this
765 ** transaction
766 */
767 return retval;
768 }
769
770 if (!th) {
771 pathrelse(&path);
772 goto start_trans;
773 }
774
775 /* desired position is not found or is in the direct item. We have
776 to append file with holes up to 'block'-th block converting
777 direct items to indirect one if necessary */
778 done = 0;
779 do {
780 if (is_statdata_le_ih(ih)) {
781 __le32 unp = 0;
782 struct cpu_key tmp_key;
783
784 /* indirect item has to be inserted */
785 make_le_item_head(&tmp_ih, &key, version, 1,
786 TYPE_INDIRECT, UNFM_P_SIZE,
787 0 /* free_space */ );
788
789 if (cpu_key_k_offset(&key) == 1) {
790 /* we are going to add 'block'-th block to the file. Use
791 allocated block for that */
792 unp = cpu_to_le32(allocated_block_nr);
793 set_block_dev_mapped(bh_result,
794 allocated_block_nr, inode);
795 set_buffer_new(bh_result);
796 done = 1;
797 }
798 tmp_key = key; // ;)
799 set_cpu_key_k_offset(&tmp_key, 1);
800 PATH_LAST_POSITION(&path)++;
801
802 retval =
803 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
804 inode, (char *)&unp);
805 if (retval) {
806 reiserfs_free_block(th, inode,
807 allocated_block_nr, 1);
808 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
809 }
810 //mark_tail_converted (inode);
811 } else if (is_direct_le_ih(ih)) {
812 /* direct item has to be converted */
813 loff_t tail_offset;
814
815 tail_offset =
816 ((le_ih_k_offset(ih) -
817 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
818 if (tail_offset == cpu_key_k_offset(&key)) {
819 /* direct item we just found fits into block we have
820 to map. Convert it into unformatted node: use
821 bh_result for the conversion */
822 set_block_dev_mapped(bh_result,
823 allocated_block_nr, inode);
824 unbh = bh_result;
825 done = 1;
826 } else {
827 /* we have to padd file tail stored in direct item(s)
828 up to block size and convert it to unformatted
829 node. FIXME: this should also get into page cache */
830
831 pathrelse(&path);
832 /*
833 * ugly, but we can only end the transaction if
834 * we aren't nested
835 */
836 BUG_ON(!th->t_refcount);
837 if (th->t_refcount == 1) {
838 retval =
839 reiserfs_end_persistent_transaction
840 (th);
841 th = NULL;
842 if (retval)
843 goto failure;
844 }
845
846 retval =
847 convert_tail_for_hole(inode, bh_result,
848 tail_offset);
849 if (retval) {
850 if (retval != -ENOSPC)
851 reiserfs_warning(inode->i_sb,
852 "clm-6004: convert tail failed inode %lu, error %d",
853 inode->i_ino,
854 retval);
855 if (allocated_block_nr) {
856 /* the bitmap, the super, and the stat data == 3 */
857 if (!th)
858 th = reiserfs_persistent_transaction(inode->i_sb, 3);
859 if (th)
860 reiserfs_free_block(th,
861 inode,
862 allocated_block_nr,
863 1);
864 }
865 goto failure;
866 }
867 goto research;
868 }
869 retval =
870 direct2indirect(th, inode, &path, unbh,
871 tail_offset);
872 if (retval) {
873 reiserfs_unmap_buffer(unbh);
874 reiserfs_free_block(th, inode,
875 allocated_block_nr, 1);
876 goto failure;
877 }
878 /* it is important the set_buffer_uptodate is done after
879 ** the direct2indirect. The buffer might contain valid
880 ** data newer than the data on disk (read by readpage, changed,
881 ** and then sent here by writepage). direct2indirect needs
882 ** to know if unbh was already up to date, so it can decide
883 ** if the data in unbh needs to be replaced with data from
884 ** the disk
885 */
886 set_buffer_uptodate(unbh);
887
888 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
889 buffer will disappear shortly, so it should not be added to
890 */
891 if (unbh->b_page) {
892 /* we've converted the tail, so we must
893 ** flush unbh before the transaction commits
894 */
895 reiserfs_add_tail_list(inode, unbh);
896
897 /* mark it dirty now to prevent commit_write from adding
898 ** this buffer to the inode's dirty buffer list
899 */
900 /*
901 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
902 * It's still atomic, but it sets the page dirty too,
903 * which makes it eligible for writeback at any time by the
904 * VM (which was also the case with __mark_buffer_dirty())
905 */
906 mark_buffer_dirty(unbh);
907 }
908 } else {
909 /* append indirect item with holes if needed, when appending
910 pointer to 'block'-th block use block, which is already
911 allocated */
912 struct cpu_key tmp_key;
913 unp_t unf_single = 0; // We use this in case we need to allocate only
914 // one block which is a fastpath
915 unp_t *un;
916 __u64 max_to_insert =
917 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
918 UNFM_P_SIZE;
919 __u64 blocks_needed;
920
921 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
922 "vs-804: invalid position for append");
923 /* indirect item has to be appended, set up key of that position */
924 make_cpu_key(&tmp_key, inode,
925 le_key_k_offset(version,
926 &(ih->ih_key)) +
927 op_bytes_number(ih,
928 inode->i_sb->s_blocksize),
929 //pos_in_item * inode->i_sb->s_blocksize,
930 TYPE_INDIRECT, 3); // key type is unimportant
931
932 blocks_needed =
933 1 +
934 ((cpu_key_k_offset(&key) -
935 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
936 s_blocksize_bits);
937 RFALSE(blocks_needed < 0, "green-805: invalid offset");
938
939 if (blocks_needed == 1) {
940 un = &unf_single;
941 } else {
942 un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.
943 if (!un) {
944 un = &unf_single;
945 blocks_needed = 1;
946 max_to_insert = 0;
947 } else
948 memset(un, 0,
949 UNFM_P_SIZE * min(blocks_needed,
950 max_to_insert));
951 }
952 if (blocks_needed <= max_to_insert) {
953 /* we are going to add target block to the file. Use allocated
954 block for that */
955 un[blocks_needed - 1] =
956 cpu_to_le32(allocated_block_nr);
957 set_block_dev_mapped(bh_result,
958 allocated_block_nr, inode);
959 set_buffer_new(bh_result);
960 done = 1;
961 } else {
962 /* paste hole to the indirect item */
963 /* If kmalloc failed, max_to_insert becomes zero and it means we
964 only have space for one block */
965 blocks_needed =
966 max_to_insert ? max_to_insert : 1;
967 }
968 retval =
969 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
970 (char *)un,
971 UNFM_P_SIZE *
972 blocks_needed);
973
974 if (blocks_needed != 1)
975 kfree(un);
976
977 if (retval) {
978 reiserfs_free_block(th, inode,
979 allocated_block_nr, 1);
980 goto failure;
981 }
982 if (!done) {
983 /* We need to mark new file size in case this function will be
984 interrupted/aborted later on. And we may do this only for
985 holes. */
986 inode->i_size +=
987 inode->i_sb->s_blocksize * blocks_needed;
988 }
989 }
969 990
970 retval = 0; 991 if (done == 1)
992 break;
971 993
972 failure: 994 /* this loop could log more blocks than we had originally asked
973 if (th && (!dangle || (retval && !th->t_trans_id))) { 995 ** for. So, we have to allow the transaction to end if it is
974 int err; 996 ** too big or too full. Update the inode so things are
975 if (th->t_trans_id) 997 ** consistent if we crash before the function returns
976 reiserfs_update_sd(th, inode); 998 **
977 err = reiserfs_end_persistent_transaction(th); 999 ** release the path so that anybody waiting on the path before
978 if (err) 1000 ** ending their transaction will be able to continue.
979 retval = err; 1001 */
980 } 1002 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1003 retval = restart_transaction(th, inode, &path);
1004 if (retval)
1005 goto failure;
1006 }
1007 /* inserting indirect pointers for a hole can take a
1008 ** long time. reschedule if needed
1009 */
1010 cond_resched();
981 1011
982 reiserfs_write_unlock(inode->i_sb); 1012 retval = search_for_position_by_key(inode->i_sb, &key, &path);
983 reiserfs_check_path(&path) ; 1013 if (retval == IO_ERROR) {
984 return retval; 1014 retval = -EIO;
1015 goto failure;
1016 }
1017 if (retval == POSITION_FOUND) {
1018 reiserfs_warning(inode->i_sb,
1019 "vs-825: reiserfs_get_block: "
1020 "%K should not be found", &key);
1021 retval = -EEXIST;
1022 if (allocated_block_nr)
1023 reiserfs_free_block(th, inode,
1024 allocated_block_nr, 1);
1025 pathrelse(&path);
1026 goto failure;
1027 }
1028 bh = get_last_bh(&path);
1029 ih = get_ih(&path);
1030 item = get_item(&path);
1031 pos_in_item = path.pos_in_item;
1032 } while (1);
1033
1034 retval = 0;
1035
1036 failure:
1037 if (th && (!dangle || (retval && !th->t_trans_id))) {
1038 int err;
1039 if (th->t_trans_id)
1040 reiserfs_update_sd(th, inode);
1041 err = reiserfs_end_persistent_transaction(th);
1042 if (err)
1043 retval = err;
1044 }
1045
1046 reiserfs_write_unlock(inode->i_sb);
1047 reiserfs_check_path(&path);
1048 return retval;
985} 1049}
986 1050
987static int 1051static int
988reiserfs_readpages(struct file *file, struct address_space *mapping, 1052reiserfs_readpages(struct file *file, struct address_space *mapping,
989 struct list_head *pages, unsigned nr_pages) 1053 struct list_head *pages, unsigned nr_pages)
990{ 1054{
991 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block); 1055 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
992} 1056}
993 1057
994/* Compute real number of used bytes by file 1058/* Compute real number of used bytes by file
@@ -996,51 +1060,56 @@ reiserfs_readpages(struct file *file, struct address_space *mapping,
996 */ 1060 */
997static int real_space_diff(struct inode *inode, int sd_size) 1061static int real_space_diff(struct inode *inode, int sd_size)
998{ 1062{
999 int bytes; 1063 int bytes;
1000 loff_t blocksize = inode->i_sb->s_blocksize ; 1064 loff_t blocksize = inode->i_sb->s_blocksize;
1001 1065
1002 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) 1066 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1003 return sd_size ; 1067 return sd_size;
1004 1068
1005 /* End of file is also in full block with indirect reference, so round 1069 /* End of file is also in full block with indirect reference, so round
1006 ** up to the next block. 1070 ** up to the next block.
1007 ** 1071 **
1008 ** there is just no way to know if the tail is actually packed 1072 ** there is just no way to know if the tail is actually packed
1009 ** on the file, so we have to assume it isn't. When we pack the 1073 ** on the file, so we have to assume it isn't. When we pack the
1010 ** tail, we add 4 bytes to pretend there really is an unformatted 1074 ** tail, we add 4 bytes to pretend there really is an unformatted
1011 ** node pointer 1075 ** node pointer
1012 */ 1076 */
1013 bytes = ((inode->i_size + (blocksize-1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE + sd_size; 1077 bytes =
1014 return bytes ; 1078 ((inode->i_size +
1079 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1080 sd_size;
1081 return bytes;
1015} 1082}
1016 1083
1017static inline loff_t to_real_used_space(struct inode *inode, ulong blocks, 1084static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
1018 int sd_size) 1085 int sd_size)
1019{ 1086{
1020 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) { 1087 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1021 return inode->i_size + (loff_t)(real_space_diff(inode, sd_size)) ; 1088 return inode->i_size +
1022 } 1089 (loff_t) (real_space_diff(inode, sd_size));
1023 return ((loff_t)real_space_diff(inode, sd_size)) + (((loff_t)blocks) << 9); 1090 }
1091 return ((loff_t) real_space_diff(inode, sd_size)) +
1092 (((loff_t) blocks) << 9);
1024} 1093}
1025 1094
1026/* Compute number of blocks used by file in ReiserFS counting */ 1095/* Compute number of blocks used by file in ReiserFS counting */
1027static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size) 1096static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1028{ 1097{
1029 loff_t bytes = inode_get_bytes(inode) ; 1098 loff_t bytes = inode_get_bytes(inode);
1030 loff_t real_space = real_space_diff(inode, sd_size) ; 1099 loff_t real_space = real_space_diff(inode, sd_size);
1031 1100
1032 /* keeps fsck and non-quota versions of reiserfs happy */ 1101 /* keeps fsck and non-quota versions of reiserfs happy */
1033 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) { 1102 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1034 bytes += (loff_t)511 ; 1103 bytes += (loff_t) 511;
1035 } 1104 }
1036 1105
1037 /* files from before the quota patch might i_blocks such that 1106 /* files from before the quota patch might i_blocks such that
1038 ** bytes < real_space. Deal with that here to prevent it from 1107 ** bytes < real_space. Deal with that here to prevent it from
1039 ** going negative. 1108 ** going negative.
1040 */ 1109 */
1041 if (bytes < real_space) 1110 if (bytes < real_space)
1042 return 0 ; 1111 return 0;
1043 return (bytes - real_space) >> 9; 1112 return (bytes - real_space) >> 9;
1044} 1113}
1045 1114
1046// 1115//
@@ -1051,263 +1120,269 @@ static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1051// 1120//
1052 1121
1053// called by read_locked_inode 1122// called by read_locked_inode
1054static void init_inode (struct inode * inode, struct path * path) 1123static void init_inode(struct inode *inode, struct path *path)
1055{ 1124{
1056 struct buffer_head * bh; 1125 struct buffer_head *bh;
1057 struct item_head * ih; 1126 struct item_head *ih;
1058 __u32 rdev; 1127 __u32 rdev;
1059 //int version = ITEM_VERSION_1; 1128 //int version = ITEM_VERSION_1;
1060 1129
1061 bh = PATH_PLAST_BUFFER (path); 1130 bh = PATH_PLAST_BUFFER(path);
1062 ih = PATH_PITEM_HEAD (path); 1131 ih = PATH_PITEM_HEAD(path);
1063 1132
1064 1133 copy_key(INODE_PKEY(inode), &(ih->ih_key));
1065 copy_key (INODE_PKEY (inode), &(ih->ih_key)); 1134 inode->i_blksize = reiserfs_default_io_size;
1066 inode->i_blksize = reiserfs_default_io_size; 1135
1067 1136 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1068 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list )); 1137 REISERFS_I(inode)->i_flags = 0;
1069 REISERFS_I(inode)->i_flags = 0; 1138 REISERFS_I(inode)->i_prealloc_block = 0;
1070 REISERFS_I(inode)->i_prealloc_block = 0; 1139 REISERFS_I(inode)->i_prealloc_count = 0;
1071 REISERFS_I(inode)->i_prealloc_count = 0; 1140 REISERFS_I(inode)->i_trans_id = 0;
1072 REISERFS_I(inode)->i_trans_id = 0; 1141 REISERFS_I(inode)->i_jl = NULL;
1073 REISERFS_I(inode)->i_jl = NULL; 1142 REISERFS_I(inode)->i_acl_access = NULL;
1074 REISERFS_I(inode)->i_acl_access = NULL; 1143 REISERFS_I(inode)->i_acl_default = NULL;
1075 REISERFS_I(inode)->i_acl_default = NULL; 1144 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1076 init_rwsem (&REISERFS_I(inode)->xattr_sem); 1145
1077 1146 if (stat_data_v1(ih)) {
1078 if (stat_data_v1 (ih)) { 1147 struct stat_data_v1 *sd =
1079 struct stat_data_v1 * sd = (struct stat_data_v1 *)B_I_PITEM (bh, ih); 1148 (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1080 unsigned long blocks; 1149 unsigned long blocks;
1081 1150
1082 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1151 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1083 set_inode_sd_version (inode, STAT_DATA_V1); 1152 set_inode_sd_version(inode, STAT_DATA_V1);
1084 inode->i_mode = sd_v1_mode(sd); 1153 inode->i_mode = sd_v1_mode(sd);
1085 inode->i_nlink = sd_v1_nlink(sd); 1154 inode->i_nlink = sd_v1_nlink(sd);
1086 inode->i_uid = sd_v1_uid(sd); 1155 inode->i_uid = sd_v1_uid(sd);
1087 inode->i_gid = sd_v1_gid(sd); 1156 inode->i_gid = sd_v1_gid(sd);
1088 inode->i_size = sd_v1_size(sd); 1157 inode->i_size = sd_v1_size(sd);
1089 inode->i_atime.tv_sec = sd_v1_atime(sd); 1158 inode->i_atime.tv_sec = sd_v1_atime(sd);
1090 inode->i_mtime.tv_sec = sd_v1_mtime(sd); 1159 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1091 inode->i_ctime.tv_sec = sd_v1_ctime(sd); 1160 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1092 inode->i_atime.tv_nsec = 0; 1161 inode->i_atime.tv_nsec = 0;
1093 inode->i_ctime.tv_nsec = 0; 1162 inode->i_ctime.tv_nsec = 0;
1094 inode->i_mtime.tv_nsec = 0; 1163 inode->i_mtime.tv_nsec = 0;
1095 1164
1096 inode->i_blocks = sd_v1_blocks(sd); 1165 inode->i_blocks = sd_v1_blocks(sd);
1097 inode->i_generation = le32_to_cpu (INODE_PKEY (inode)->k_dir_id); 1166 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1098 blocks = (inode->i_size + 511) >> 9; 1167 blocks = (inode->i_size + 511) >> 9;
1099 blocks = _ROUND_UP (blocks, inode->i_sb->s_blocksize >> 9); 1168 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1100 if (inode->i_blocks > blocks) { 1169 if (inode->i_blocks > blocks) {
1101 // there was a bug in <=3.5.23 when i_blocks could take negative 1170 // there was a bug in <=3.5.23 when i_blocks could take negative
1102 // values. Starting from 3.5.17 this value could even be stored in 1171 // values. Starting from 3.5.17 this value could even be stored in
1103 // stat data. For such files we set i_blocks based on file 1172 // stat data. For such files we set i_blocks based on file
1104 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be 1173 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1105 // only updated if file's inode will ever change 1174 // only updated if file's inode will ever change
1106 inode->i_blocks = blocks; 1175 inode->i_blocks = blocks;
1107 } 1176 }
1108
1109 rdev = sd_v1_rdev(sd);
1110 REISERFS_I(inode)->i_first_direct_byte = sd_v1_first_direct_byte(sd);
1111 /* an early bug in the quota code can give us an odd number for the
1112 ** block count. This is incorrect, fix it here.
1113 */
1114 if (inode->i_blocks & 1) {
1115 inode->i_blocks++ ;
1116 }
1117 inode_set_bytes(inode, to_real_used_space(inode, inode->i_blocks,
1118 SD_V1_SIZE));
1119 /* nopack is initially zero for v1 objects. For v2 objects,
1120 nopack is initialised from sd_attrs */
1121 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1122 } else {
1123 // new stat data found, but object may have old items
1124 // (directories and symlinks)
1125 struct stat_data * sd = (struct stat_data *)B_I_PITEM (bh, ih);
1126
1127 inode->i_mode = sd_v2_mode(sd);
1128 inode->i_nlink = sd_v2_nlink(sd);
1129 inode->i_uid = sd_v2_uid(sd);
1130 inode->i_size = sd_v2_size(sd);
1131 inode->i_gid = sd_v2_gid(sd);
1132 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1133 inode->i_atime.tv_sec = sd_v2_atime(sd);
1134 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1135 inode->i_ctime.tv_nsec = 0;
1136 inode->i_mtime.tv_nsec = 0;
1137 inode->i_atime.tv_nsec = 0;
1138 inode->i_blocks = sd_v2_blocks(sd);
1139 rdev = sd_v2_rdev(sd);
1140 if( S_ISCHR( inode -> i_mode ) || S_ISBLK( inode -> i_mode ) )
1141 inode->i_generation = le32_to_cpu (INODE_PKEY (inode)->k_dir_id);
1142 else
1143 inode->i_generation = sd_v2_generation(sd);
1144 1177
1145 if (S_ISDIR (inode->i_mode) || S_ISLNK (inode->i_mode)) 1178 rdev = sd_v1_rdev(sd);
1146 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1179 REISERFS_I(inode)->i_first_direct_byte =
1147 else 1180 sd_v1_first_direct_byte(sd);
1148 set_inode_item_key_version (inode, KEY_FORMAT_3_6); 1181 /* an early bug in the quota code can give us an odd number for the
1149 REISERFS_I(inode)->i_first_direct_byte = 0; 1182 ** block count. This is incorrect, fix it here.
1150 set_inode_sd_version (inode, STAT_DATA_V2); 1183 */
1151 inode_set_bytes(inode, to_real_used_space(inode, inode->i_blocks, 1184 if (inode->i_blocks & 1) {
1152 SD_V2_SIZE)); 1185 inode->i_blocks++;
1153 /* read persistent inode attributes from sd and initalise 1186 }
1154 generic inode flags from them */ 1187 inode_set_bytes(inode,
1155 REISERFS_I(inode)->i_attrs = sd_v2_attrs( sd ); 1188 to_real_used_space(inode, inode->i_blocks,
1156 sd_attrs_to_i_attrs( sd_v2_attrs( sd ), inode ); 1189 SD_V1_SIZE));
1157 } 1190 /* nopack is initially zero for v1 objects. For v2 objects,
1158 1191 nopack is initialised from sd_attrs */
1159 pathrelse (path); 1192 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1160 if (S_ISREG (inode->i_mode)) { 1193 } else {
1161 inode->i_op = &reiserfs_file_inode_operations; 1194 // new stat data found, but object may have old items
1162 inode->i_fop = &reiserfs_file_operations; 1195 // (directories and symlinks)
1163 inode->i_mapping->a_ops = &reiserfs_address_space_operations ; 1196 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1164 } else if (S_ISDIR (inode->i_mode)) { 1197
1165 inode->i_op = &reiserfs_dir_inode_operations; 1198 inode->i_mode = sd_v2_mode(sd);
1166 inode->i_fop = &reiserfs_dir_operations; 1199 inode->i_nlink = sd_v2_nlink(sd);
1167 } else if (S_ISLNK (inode->i_mode)) { 1200 inode->i_uid = sd_v2_uid(sd);
1168 inode->i_op = &reiserfs_symlink_inode_operations; 1201 inode->i_size = sd_v2_size(sd);
1169 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 1202 inode->i_gid = sd_v2_gid(sd);
1170 } else { 1203 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1171 inode->i_blocks = 0; 1204 inode->i_atime.tv_sec = sd_v2_atime(sd);
1172 inode->i_op = &reiserfs_special_inode_operations; 1205 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1173 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev)); 1206 inode->i_ctime.tv_nsec = 0;
1174 } 1207 inode->i_mtime.tv_nsec = 0;
1175} 1208 inode->i_atime.tv_nsec = 0;
1209 inode->i_blocks = sd_v2_blocks(sd);
1210 rdev = sd_v2_rdev(sd);
1211 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1212 inode->i_generation =
1213 le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1214 else
1215 inode->i_generation = sd_v2_generation(sd);
1176 1216
1217 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1218 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1219 else
1220 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1221 REISERFS_I(inode)->i_first_direct_byte = 0;
1222 set_inode_sd_version(inode, STAT_DATA_V2);
1223 inode_set_bytes(inode,
1224 to_real_used_space(inode, inode->i_blocks,
1225 SD_V2_SIZE));
1226 /* read persistent inode attributes from sd and initalise
1227 generic inode flags from them */
1228 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1229 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
1230 }
1231
1232 pathrelse(path);
1233 if (S_ISREG(inode->i_mode)) {
1234 inode->i_op = &reiserfs_file_inode_operations;
1235 inode->i_fop = &reiserfs_file_operations;
1236 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1237 } else if (S_ISDIR(inode->i_mode)) {
1238 inode->i_op = &reiserfs_dir_inode_operations;
1239 inode->i_fop = &reiserfs_dir_operations;
1240 } else if (S_ISLNK(inode->i_mode)) {
1241 inode->i_op = &reiserfs_symlink_inode_operations;
1242 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1243 } else {
1244 inode->i_blocks = 0;
1245 inode->i_op = &reiserfs_special_inode_operations;
1246 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
1247 }
1248}
1177 1249
1178// update new stat data with inode fields 1250// update new stat data with inode fields
1179static void inode2sd (void * sd, struct inode * inode, loff_t size) 1251static void inode2sd(void *sd, struct inode *inode, loff_t size)
1180{ 1252{
1181 struct stat_data * sd_v2 = (struct stat_data *)sd; 1253 struct stat_data *sd_v2 = (struct stat_data *)sd;
1182 __u16 flags; 1254 __u16 flags;
1183 1255
1184 set_sd_v2_mode(sd_v2, inode->i_mode ); 1256 set_sd_v2_mode(sd_v2, inode->i_mode);
1185 set_sd_v2_nlink(sd_v2, inode->i_nlink ); 1257 set_sd_v2_nlink(sd_v2, inode->i_nlink);
1186 set_sd_v2_uid(sd_v2, inode->i_uid ); 1258 set_sd_v2_uid(sd_v2, inode->i_uid);
1187 set_sd_v2_size(sd_v2, size ); 1259 set_sd_v2_size(sd_v2, size);
1188 set_sd_v2_gid(sd_v2, inode->i_gid ); 1260 set_sd_v2_gid(sd_v2, inode->i_gid);
1189 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec ); 1261 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1190 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec ); 1262 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1191 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec ); 1263 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1192 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE)); 1264 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1193 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1265 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1194 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev)); 1266 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1195 else 1267 else
1196 set_sd_v2_generation(sd_v2, inode->i_generation); 1268 set_sd_v2_generation(sd_v2, inode->i_generation);
1197 flags = REISERFS_I(inode)->i_attrs; 1269 flags = REISERFS_I(inode)->i_attrs;
1198 i_attrs_to_sd_attrs( inode, &flags ); 1270 i_attrs_to_sd_attrs(inode, &flags);
1199 set_sd_v2_attrs( sd_v2, flags ); 1271 set_sd_v2_attrs(sd_v2, flags);
1200} 1272}
1201 1273
1202
1203// used to copy inode's fields to old stat data 1274// used to copy inode's fields to old stat data
1204static void inode2sd_v1 (void * sd, struct inode * inode, loff_t size) 1275static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
1205{ 1276{
1206 struct stat_data_v1 * sd_v1 = (struct stat_data_v1 *)sd; 1277 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
1207 1278
1208 set_sd_v1_mode(sd_v1, inode->i_mode ); 1279 set_sd_v1_mode(sd_v1, inode->i_mode);
1209 set_sd_v1_uid(sd_v1, inode->i_uid ); 1280 set_sd_v1_uid(sd_v1, inode->i_uid);
1210 set_sd_v1_gid(sd_v1, inode->i_gid ); 1281 set_sd_v1_gid(sd_v1, inode->i_gid);
1211 set_sd_v1_nlink(sd_v1, inode->i_nlink ); 1282 set_sd_v1_nlink(sd_v1, inode->i_nlink);
1212 set_sd_v1_size(sd_v1, size ); 1283 set_sd_v1_size(sd_v1, size);
1213 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec ); 1284 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1214 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec ); 1285 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1215 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec ); 1286 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
1216 1287
1217 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1288 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1218 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev)); 1289 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1219 else 1290 else
1220 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE)); 1291 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
1221
1222 // Sigh. i_first_direct_byte is back
1223 set_sd_v1_first_direct_byte(sd_v1, REISERFS_I(inode)->i_first_direct_byte);
1224}
1225 1292
1293 // Sigh. i_first_direct_byte is back
1294 set_sd_v1_first_direct_byte(sd_v1,
1295 REISERFS_I(inode)->i_first_direct_byte);
1296}
1226 1297
1227/* NOTE, you must prepare the buffer head before sending it here, 1298/* NOTE, you must prepare the buffer head before sending it here,
1228** and then log it after the call 1299** and then log it after the call
1229*/ 1300*/
1230static void update_stat_data (struct path * path, struct inode * inode, 1301static void update_stat_data(struct path *path, struct inode *inode,
1231 loff_t size) 1302 loff_t size)
1232{ 1303{
1233 struct buffer_head * bh; 1304 struct buffer_head *bh;
1234 struct item_head * ih; 1305 struct item_head *ih;
1235 1306
1236 bh = PATH_PLAST_BUFFER (path); 1307 bh = PATH_PLAST_BUFFER(path);
1237 ih = PATH_PITEM_HEAD (path); 1308 ih = PATH_PITEM_HEAD(path);
1238
1239 if (!is_statdata_le_ih (ih))
1240 reiserfs_panic (inode->i_sb, "vs-13065: update_stat_data: key %k, found item %h",
1241 INODE_PKEY (inode), ih);
1242
1243 if (stat_data_v1 (ih)) {
1244 // path points to old stat data
1245 inode2sd_v1 (B_I_PITEM (bh, ih), inode, size);
1246 } else {
1247 inode2sd (B_I_PITEM (bh, ih), inode, size);
1248 }
1249
1250 return;
1251}
1252 1309
1310 if (!is_statdata_le_ih(ih))
1311 reiserfs_panic(inode->i_sb,
1312 "vs-13065: update_stat_data: key %k, found item %h",
1313 INODE_PKEY(inode), ih);
1253 1314
1254void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th, 1315 if (stat_data_v1(ih)) {
1255 struct inode * inode, loff_t size) 1316 // path points to old stat data
1317 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1318 } else {
1319 inode2sd(B_I_PITEM(bh, ih), inode, size);
1320 }
1321
1322 return;
1323}
1324
1325void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1326 struct inode *inode, loff_t size)
1256{ 1327{
1257 struct cpu_key key; 1328 struct cpu_key key;
1258 INITIALIZE_PATH(path); 1329 INITIALIZE_PATH(path);
1259 struct buffer_head *bh ; 1330 struct buffer_head *bh;
1260 int fs_gen ; 1331 int fs_gen;
1261 struct item_head *ih, tmp_ih ; 1332 struct item_head *ih, tmp_ih;
1262 int retval; 1333 int retval;
1263 1334
1264 BUG_ON (!th->t_trans_id); 1335 BUG_ON(!th->t_trans_id);
1265 1336
1266 make_cpu_key (&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3);//key type is unimportant 1337 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant
1267 1338
1268 for(;;) { 1339 for (;;) {
1269 int pos; 1340 int pos;
1270 /* look for the object's stat data */ 1341 /* look for the object's stat data */
1271 retval = search_item (inode->i_sb, &key, &path); 1342 retval = search_item(inode->i_sb, &key, &path);
1272 if (retval == IO_ERROR) { 1343 if (retval == IO_ERROR) {
1273 reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: " 1344 reiserfs_warning(inode->i_sb,
1274 "i/o failure occurred trying to update %K stat data", 1345 "vs-13050: reiserfs_update_sd: "
1275 &key); 1346 "i/o failure occurred trying to update %K stat data",
1276 return; 1347 &key);
1277 } 1348 return;
1278 if (retval == ITEM_NOT_FOUND) { 1349 }
1279 pos = PATH_LAST_POSITION (&path); 1350 if (retval == ITEM_NOT_FOUND) {
1280 pathrelse(&path) ; 1351 pos = PATH_LAST_POSITION(&path);
1281 if (inode->i_nlink == 0) { 1352 pathrelse(&path);
1282 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found");*/ 1353 if (inode->i_nlink == 0) {
1283 return; 1354 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1284 } 1355 return;
1285 reiserfs_warning (inode->i_sb, "vs-13060: reiserfs_update_sd: " 1356 }
1286 "stat data of object %k (nlink == %d) not found (pos %d)", 1357 reiserfs_warning(inode->i_sb,
1287 INODE_PKEY (inode), inode->i_nlink, pos); 1358 "vs-13060: reiserfs_update_sd: "
1288 reiserfs_check_path(&path) ; 1359 "stat data of object %k (nlink == %d) not found (pos %d)",
1289 return; 1360 INODE_PKEY(inode), inode->i_nlink,
1290 } 1361 pos);
1291 1362 reiserfs_check_path(&path);
1292 /* sigh, prepare_for_journal might schedule. When it schedules the 1363 return;
1293 ** FS might change. We have to detect that, and loop back to the 1364 }
1294 ** search if the stat data item has moved 1365
1295 */ 1366 /* sigh, prepare_for_journal might schedule. When it schedules the
1296 bh = get_last_bh(&path) ; 1367 ** FS might change. We have to detect that, and loop back to the
1297 ih = get_ih(&path) ; 1368 ** search if the stat data item has moved
1298 copy_item_head (&tmp_ih, ih); 1369 */
1299 fs_gen = get_generation (inode->i_sb); 1370 bh = get_last_bh(&path);
1300 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ; 1371 ih = get_ih(&path);
1301 if (fs_changed (fs_gen, inode->i_sb) && item_moved(&tmp_ih, &path)) { 1372 copy_item_head(&tmp_ih, ih);
1302 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ; 1373 fs_gen = get_generation(inode->i_sb);
1303 continue ; /* Stat_data item has been moved after scheduling. */ 1374 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1304 } 1375 if (fs_changed(fs_gen, inode->i_sb)
1305 break; 1376 && item_moved(&tmp_ih, &path)) {
1306 } 1377 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1307 update_stat_data (&path, inode, size); 1378 continue; /* Stat_data item has been moved after scheduling. */
1308 journal_mark_dirty(th, th->t_super, bh) ; 1379 }
1309 pathrelse (&path); 1380 break;
1310 return; 1381 }
1382 update_stat_data(&path, inode, size);
1383 journal_mark_dirty(th, th->t_super, bh);
1384 pathrelse(&path);
1385 return;
1311} 1386}
1312 1387
1313/* reiserfs_read_locked_inode is called to read the inode off disk, and it 1388/* reiserfs_read_locked_inode is called to read the inode off disk, and it
@@ -1316,9 +1391,10 @@ void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th,
1316** corresponding iput might try to delete whatever object the inode last 1391** corresponding iput might try to delete whatever object the inode last
1317** represented. 1392** represented.
1318*/ 1393*/
1319static void reiserfs_make_bad_inode(struct inode *inode) { 1394static void reiserfs_make_bad_inode(struct inode *inode)
1320 memset(INODE_PKEY(inode), 0, KEY_SIZE); 1395{
1321 make_bad_inode(inode); 1396 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1397 make_bad_inode(inode);
1322} 1398}
1323 1399
1324// 1400//
@@ -1326,77 +1402,79 @@ static void reiserfs_make_bad_inode(struct inode *inode) {
1326// evolved as the prototype did 1402// evolved as the prototype did
1327// 1403//
1328 1404
1329int reiserfs_init_locked_inode (struct inode * inode, void *p) 1405int reiserfs_init_locked_inode(struct inode *inode, void *p)
1330{ 1406{
1331 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p ; 1407 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1332 inode->i_ino = args->objectid; 1408 inode->i_ino = args->objectid;
1333 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid); 1409 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1334 return 0; 1410 return 0;
1335} 1411}
1336 1412
1337/* looks for stat data in the tree, and fills up the fields of in-core 1413/* looks for stat data in the tree, and fills up the fields of in-core
1338 inode stat data fields */ 1414 inode stat data fields */
1339void reiserfs_read_locked_inode (struct inode * inode, struct reiserfs_iget_args *args) 1415void reiserfs_read_locked_inode(struct inode *inode,
1416 struct reiserfs_iget_args *args)
1340{ 1417{
1341 INITIALIZE_PATH (path_to_sd); 1418 INITIALIZE_PATH(path_to_sd);
1342 struct cpu_key key; 1419 struct cpu_key key;
1343 unsigned long dirino; 1420 unsigned long dirino;
1344 int retval; 1421 int retval;
1345 1422
1346 dirino = args->dirid ; 1423 dirino = args->dirid;
1347 1424
1348 /* set version 1, version 2 could be used too, because stat data 1425 /* set version 1, version 2 could be used too, because stat data
1349 key is the same in both versions */ 1426 key is the same in both versions */
1350 key.version = KEY_FORMAT_3_5; 1427 key.version = KEY_FORMAT_3_5;
1351 key.on_disk_key.k_dir_id = dirino; 1428 key.on_disk_key.k_dir_id = dirino;
1352 key.on_disk_key.k_objectid = inode->i_ino; 1429 key.on_disk_key.k_objectid = inode->i_ino;
1353 key.on_disk_key.k_offset = 0; 1430 key.on_disk_key.k_offset = 0;
1354 key.on_disk_key.k_type = 0; 1431 key.on_disk_key.k_type = 0;
1355 1432
1356 /* look for the object's stat data */ 1433 /* look for the object's stat data */
1357 retval = search_item (inode->i_sb, &key, &path_to_sd); 1434 retval = search_item(inode->i_sb, &key, &path_to_sd);
1358 if (retval == IO_ERROR) { 1435 if (retval == IO_ERROR) {
1359 reiserfs_warning (inode->i_sb, "vs-13070: reiserfs_read_locked_inode: " 1436 reiserfs_warning(inode->i_sb,
1360 "i/o failure occurred trying to find stat data of %K", 1437 "vs-13070: reiserfs_read_locked_inode: "
1361 &key); 1438 "i/o failure occurred trying to find stat data of %K",
1362 reiserfs_make_bad_inode(inode) ; 1439 &key);
1363 return; 1440 reiserfs_make_bad_inode(inode);
1364 } 1441 return;
1365 if (retval != ITEM_FOUND) { 1442 }
1366 /* a stale NFS handle can trigger this without it being an error */ 1443 if (retval != ITEM_FOUND) {
1367 pathrelse (&path_to_sd); 1444 /* a stale NFS handle can trigger this without it being an error */
1368 reiserfs_make_bad_inode(inode) ; 1445 pathrelse(&path_to_sd);
1369 inode->i_nlink = 0; 1446 reiserfs_make_bad_inode(inode);
1370 return; 1447 inode->i_nlink = 0;
1371 } 1448 return;
1372 1449 }
1373 init_inode (inode, &path_to_sd); 1450
1374 1451 init_inode(inode, &path_to_sd);
1375 /* It is possible that knfsd is trying to access inode of a file 1452
1376 that is being removed from the disk by some other thread. As we 1453 /* It is possible that knfsd is trying to access inode of a file
1377 update sd on unlink all that is required is to check for nlink 1454 that is being removed from the disk by some other thread. As we
1378 here. This bug was first found by Sizif when debugging 1455 update sd on unlink all that is required is to check for nlink
1379 SquidNG/Butterfly, forgotten, and found again after Philippe 1456 here. This bug was first found by Sizif when debugging
1380 Gramoulle <philippe.gramoulle@mmania.com> reproduced it. 1457 SquidNG/Butterfly, forgotten, and found again after Philippe
1381 1458 Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1382 More logical fix would require changes in fs/inode.c:iput() to 1459
1383 remove inode from hash-table _after_ fs cleaned disk stuff up and 1460 More logical fix would require changes in fs/inode.c:iput() to
1384 in iget() to return NULL if I_FREEING inode is found in 1461 remove inode from hash-table _after_ fs cleaned disk stuff up and
1385 hash-table. */ 1462 in iget() to return NULL if I_FREEING inode is found in
1386 /* Currently there is one place where it's ok to meet inode with 1463 hash-table. */
1387 nlink==0: processing of open-unlinked and half-truncated files 1464 /* Currently there is one place where it's ok to meet inode with
1388 during mount (fs/reiserfs/super.c:finish_unfinished()). */ 1465 nlink==0: processing of open-unlinked and half-truncated files
1389 if( ( inode -> i_nlink == 0 ) && 1466 during mount (fs/reiserfs/super.c:finish_unfinished()). */
1390 ! REISERFS_SB(inode -> i_sb) -> s_is_unlinked_ok ) { 1467 if ((inode->i_nlink == 0) &&
1391 reiserfs_warning (inode->i_sb, 1468 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1392 "vs-13075: reiserfs_read_locked_inode: " 1469 reiserfs_warning(inode->i_sb,
1393 "dead inode read from disk %K. " 1470 "vs-13075: reiserfs_read_locked_inode: "
1394 "This is likely to be race with knfsd. Ignore", 1471 "dead inode read from disk %K. "
1395 &key ); 1472 "This is likely to be race with knfsd. Ignore",
1396 reiserfs_make_bad_inode( inode ); 1473 &key);
1397 } 1474 reiserfs_make_bad_inode(inode);
1398 1475 }
1399 reiserfs_check_path(&path_to_sd) ; /* init inode should be relsing */ 1476
1477 reiserfs_check_path(&path_to_sd); /* init inode should be relsing */
1400 1478
1401} 1479}
1402 1480
@@ -1412,140 +1490,148 @@ void reiserfs_read_locked_inode (struct inode * inode, struct reiserfs_iget_args
1412 * inode numbers (objectids) are distinguished by parent directory ids. 1490 * inode numbers (objectids) are distinguished by parent directory ids.
1413 * 1491 *
1414 */ 1492 */
1415int reiserfs_find_actor( struct inode *inode, void *opaque ) 1493int reiserfs_find_actor(struct inode *inode, void *opaque)
1416{ 1494{
1417 struct reiserfs_iget_args *args; 1495 struct reiserfs_iget_args *args;
1418 1496
1419 args = opaque; 1497 args = opaque;
1420 /* args is already in CPU order */ 1498 /* args is already in CPU order */
1421 return (inode->i_ino == args->objectid) && 1499 return (inode->i_ino == args->objectid) &&
1422 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid); 1500 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
1423} 1501}
1424 1502
1425struct inode * reiserfs_iget (struct super_block * s, const struct cpu_key * key) 1503struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
1426{ 1504{
1427 struct inode * inode; 1505 struct inode *inode;
1428 struct reiserfs_iget_args args ; 1506 struct reiserfs_iget_args args;
1429 1507
1430 args.objectid = key->on_disk_key.k_objectid ; 1508 args.objectid = key->on_disk_key.k_objectid;
1431 args.dirid = key->on_disk_key.k_dir_id ; 1509 args.dirid = key->on_disk_key.k_dir_id;
1432 inode = iget5_locked (s, key->on_disk_key.k_objectid, 1510 inode = iget5_locked(s, key->on_disk_key.k_objectid,
1433 reiserfs_find_actor, reiserfs_init_locked_inode, (void *)(&args)); 1511 reiserfs_find_actor, reiserfs_init_locked_inode,
1434 if (!inode) 1512 (void *)(&args));
1435 return ERR_PTR(-ENOMEM) ; 1513 if (!inode)
1436 1514 return ERR_PTR(-ENOMEM);
1437 if (inode->i_state & I_NEW) { 1515
1438 reiserfs_read_locked_inode(inode, &args); 1516 if (inode->i_state & I_NEW) {
1439 unlock_new_inode(inode); 1517 reiserfs_read_locked_inode(inode, &args);
1440 } 1518 unlock_new_inode(inode);
1441 1519 }
1442 if (comp_short_keys (INODE_PKEY (inode), key) || is_bad_inode (inode)) { 1520
1443 /* either due to i/o error or a stale NFS handle */ 1521 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1444 iput (inode); 1522 /* either due to i/o error or a stale NFS handle */
1445 inode = NULL; 1523 iput(inode);
1446 } 1524 inode = NULL;
1447 return inode; 1525 }
1526 return inode;
1448} 1527}
1449 1528
1450struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp) 1529struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)
1451{ 1530{
1452 __u32 *data = vobjp; 1531 __u32 *data = vobjp;
1453 struct cpu_key key ; 1532 struct cpu_key key;
1454 struct dentry *result; 1533 struct dentry *result;
1455 struct inode *inode; 1534 struct inode *inode;
1456 1535
1457 key.on_disk_key.k_objectid = data[0] ; 1536 key.on_disk_key.k_objectid = data[0];
1458 key.on_disk_key.k_dir_id = data[1] ; 1537 key.on_disk_key.k_dir_id = data[1];
1459 reiserfs_write_lock(sb); 1538 reiserfs_write_lock(sb);
1460 inode = reiserfs_iget(sb, &key) ; 1539 inode = reiserfs_iget(sb, &key);
1461 if (inode && !IS_ERR(inode) && data[2] != 0 && 1540 if (inode && !IS_ERR(inode) && data[2] != 0 &&
1462 data[2] != inode->i_generation) { 1541 data[2] != inode->i_generation) {
1463 iput(inode) ; 1542 iput(inode);
1464 inode = NULL ; 1543 inode = NULL;
1465 } 1544 }
1466 reiserfs_write_unlock(sb); 1545 reiserfs_write_unlock(sb);
1467 if (!inode) 1546 if (!inode)
1468 inode = ERR_PTR(-ESTALE); 1547 inode = ERR_PTR(-ESTALE);
1469 if (IS_ERR(inode)) 1548 if (IS_ERR(inode))
1470 return ERR_PTR(PTR_ERR(inode)); 1549 return ERR_PTR(PTR_ERR(inode));
1471 result = d_alloc_anon(inode); 1550 result = d_alloc_anon(inode);
1472 if (!result) { 1551 if (!result) {
1473 iput(inode); 1552 iput(inode);
1474 return ERR_PTR(-ENOMEM); 1553 return ERR_PTR(-ENOMEM);
1475 } 1554 }
1476 return result; 1555 return result;
1477} 1556}
1478 1557
1479struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 *data, 1558struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
1480 int len, int fhtype, 1559 int len, int fhtype,
1481 int (*acceptable)(void *contect, struct dentry *de), 1560 int (*acceptable) (void *contect,
1482 void *context) { 1561 struct dentry * de),
1483 __u32 obj[3], parent[3]; 1562 void *context)
1484 1563{
1485 /* fhtype happens to reflect the number of u32s encoded. 1564 __u32 obj[3], parent[3];
1486 * due to a bug in earlier code, fhtype might indicate there 1565
1487 * are more u32s then actually fitted. 1566 /* fhtype happens to reflect the number of u32s encoded.
1488 * so if fhtype seems to be more than len, reduce fhtype. 1567 * due to a bug in earlier code, fhtype might indicate there
1489 * Valid types are: 1568 * are more u32s then actually fitted.
1490 * 2 - objectid + dir_id - legacy support 1569 * so if fhtype seems to be more than len, reduce fhtype.
1491 * 3 - objectid + dir_id + generation 1570 * Valid types are:
1492 * 4 - objectid + dir_id + objectid and dirid of parent - legacy 1571 * 2 - objectid + dir_id - legacy support
1493 * 5 - objectid + dir_id + generation + objectid and dirid of parent 1572 * 3 - objectid + dir_id + generation
1494 * 6 - as above plus generation of directory 1573 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1495 * 6 does not fit in NFSv2 handles 1574 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1496 */ 1575 * 6 - as above plus generation of directory
1497 if (fhtype > len) { 1576 * 6 does not fit in NFSv2 handles
1498 if (fhtype != 6 || len != 5) 1577 */
1499 reiserfs_warning (sb, "nfsd/reiserfs, fhtype=%d, len=%d - odd", 1578 if (fhtype > len) {
1500 fhtype, len); 1579 if (fhtype != 6 || len != 5)
1501 fhtype = 5; 1580 reiserfs_warning(sb,
1502 } 1581 "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1503 1582 fhtype, len);
1504 obj[0] = data[0]; 1583 fhtype = 5;
1505 obj[1] = data[1]; 1584 }
1506 if (fhtype == 3 || fhtype >= 5) 1585
1507 obj[2] = data[2]; 1586 obj[0] = data[0];
1508 else obj[2] = 0; /* generation number */ 1587 obj[1] = data[1];
1509 1588 if (fhtype == 3 || fhtype >= 5)
1510 if (fhtype >= 4) { 1589 obj[2] = data[2];
1511 parent[0] = data[fhtype>=5?3:2] ; 1590 else
1512 parent[1] = data[fhtype>=5?4:3] ; 1591 obj[2] = 0; /* generation number */
1513 if (fhtype == 6)
1514 parent[2] = data[5];
1515 else parent[2] = 0;
1516 }
1517 return sb->s_export_op->find_exported_dentry(sb, obj, fhtype < 4 ? NULL : parent,
1518 acceptable, context);
1519}
1520 1592
1521int reiserfs_encode_fh(struct dentry *dentry, __u32 *data, int *lenp, int need_parent) { 1593 if (fhtype >= 4) {
1522 struct inode *inode = dentry->d_inode ; 1594 parent[0] = data[fhtype >= 5 ? 3 : 2];
1523 int maxlen = *lenp; 1595 parent[1] = data[fhtype >= 5 ? 4 : 3];
1524 1596 if (fhtype == 6)
1525 if (maxlen < 3) 1597 parent[2] = data[5];
1526 return 255 ; 1598 else
1527 1599 parent[2] = 0;
1528 data[0] = inode->i_ino ; 1600 }
1529 data[1] = le32_to_cpu(INODE_PKEY (inode)->k_dir_id) ; 1601 return sb->s_export_op->find_exported_dentry(sb, obj,
1530 data[2] = inode->i_generation ; 1602 fhtype < 4 ? NULL : parent,
1531 *lenp = 3 ; 1603 acceptable, context);
1532 /* no room for directory info? return what we've stored so far */
1533 if (maxlen < 5 || ! need_parent)
1534 return 3 ;
1535
1536 spin_lock(&dentry->d_lock);
1537 inode = dentry->d_parent->d_inode ;
1538 data[3] = inode->i_ino ;
1539 data[4] = le32_to_cpu(INODE_PKEY (inode)->k_dir_id) ;
1540 *lenp = 5 ;
1541 if (maxlen >= 6) {
1542 data[5] = inode->i_generation ;
1543 *lenp = 6 ;
1544 }
1545 spin_unlock(&dentry->d_lock);
1546 return *lenp ;
1547} 1604}
1548 1605
1606int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1607 int need_parent)
1608{
1609 struct inode *inode = dentry->d_inode;
1610 int maxlen = *lenp;
1611
1612 if (maxlen < 3)
1613 return 255;
1614
1615 data[0] = inode->i_ino;
1616 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1617 data[2] = inode->i_generation;
1618 *lenp = 3;
1619 /* no room for directory info? return what we've stored so far */
1620 if (maxlen < 5 || !need_parent)
1621 return 3;
1622
1623 spin_lock(&dentry->d_lock);
1624 inode = dentry->d_parent->d_inode;
1625 data[3] = inode->i_ino;
1626 data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1627 *lenp = 5;
1628 if (maxlen >= 6) {
1629 data[5] = inode->i_generation;
1630 *lenp = 6;
1631 }
1632 spin_unlock(&dentry->d_lock);
1633 return *lenp;
1634}
1549 1635
1550/* looks for stat data, then copies fields to it, marks the buffer 1636/* looks for stat data, then copies fields to it, marks the buffer
1551 containing stat data as dirty */ 1637 containing stat data as dirty */
@@ -1554,120 +1640,127 @@ int reiserfs_encode_fh(struct dentry *dentry, __u32 *data, int *lenp, int need_p
1554** to properly mark inodes for datasync and such, but only actually 1640** to properly mark inodes for datasync and such, but only actually
1555** does something when called for a synchronous update. 1641** does something when called for a synchronous update.
1556*/ 1642*/
1557int reiserfs_write_inode (struct inode * inode, int do_sync) { 1643int reiserfs_write_inode(struct inode *inode, int do_sync)
1558 struct reiserfs_transaction_handle th ; 1644{
1559 int jbegin_count = 1 ; 1645 struct reiserfs_transaction_handle th;
1560 1646 int jbegin_count = 1;
1561 if (inode->i_sb->s_flags & MS_RDONLY) 1647
1562 return -EROFS; 1648 if (inode->i_sb->s_flags & MS_RDONLY)
1563 /* memory pressure can sometimes initiate write_inode calls with sync == 1, 1649 return -EROFS;
1564 ** these cases are just when the system needs ram, not when the 1650 /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1565 ** inode needs to reach disk for safety, and they can safely be 1651 ** these cases are just when the system needs ram, not when the
1566 ** ignored because the altered inode has already been logged. 1652 ** inode needs to reach disk for safety, and they can safely be
1567 */ 1653 ** ignored because the altered inode has already been logged.
1568 if (do_sync && !(current->flags & PF_MEMALLOC)) { 1654 */
1569 reiserfs_write_lock(inode->i_sb); 1655 if (do_sync && !(current->flags & PF_MEMALLOC)) {
1570 if (!journal_begin(&th, inode->i_sb, jbegin_count)) { 1656 reiserfs_write_lock(inode->i_sb);
1571 reiserfs_update_sd (&th, inode); 1657 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1572 journal_end_sync(&th, inode->i_sb, jbegin_count) ; 1658 reiserfs_update_sd(&th, inode);
1573 } 1659 journal_end_sync(&th, inode->i_sb, jbegin_count);
1574 reiserfs_write_unlock(inode->i_sb); 1660 }
1575 } 1661 reiserfs_write_unlock(inode->i_sb);
1576 return 0; 1662 }
1663 return 0;
1577} 1664}
1578 1665
1579/* stat data of new object is inserted already, this inserts the item 1666/* stat data of new object is inserted already, this inserts the item
1580 containing "." and ".." entries */ 1667 containing "." and ".." entries */
1581static int reiserfs_new_directory (struct reiserfs_transaction_handle *th, 1668static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1582 struct inode *inode, 1669 struct inode *inode,
1583 struct item_head * ih, struct path * path, 1670 struct item_head *ih, struct path *path,
1584 struct inode * dir) 1671 struct inode *dir)
1585{ 1672{
1586 struct super_block * sb = th->t_super; 1673 struct super_block *sb = th->t_super;
1587 char empty_dir [EMPTY_DIR_SIZE]; 1674 char empty_dir[EMPTY_DIR_SIZE];
1588 char * body = empty_dir; 1675 char *body = empty_dir;
1589 struct cpu_key key; 1676 struct cpu_key key;
1590 int retval; 1677 int retval;
1591 1678
1592 BUG_ON (!th->t_trans_id); 1679 BUG_ON(!th->t_trans_id);
1593 1680
1594 _make_cpu_key (&key, KEY_FORMAT_3_5, le32_to_cpu (ih->ih_key.k_dir_id), 1681 _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1595 le32_to_cpu (ih->ih_key.k_objectid), DOT_OFFSET, TYPE_DIRENTRY, 3/*key length*/); 1682 le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1596 1683 TYPE_DIRENTRY, 3 /*key length */ );
1597 /* compose item head for new item. Directories consist of items of 1684
1598 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it 1685 /* compose item head for new item. Directories consist of items of
1599 is done by reiserfs_new_inode */ 1686 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1600 if (old_format_only (sb)) { 1687 is done by reiserfs_new_inode */
1601 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET, TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2); 1688 if (old_format_only(sb)) {
1602 1689 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1603 make_empty_dir_item_v1 (body, ih->ih_key.k_dir_id, ih->ih_key.k_objectid, 1690 TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1604 INODE_PKEY (dir)->k_dir_id, 1691
1605 INODE_PKEY (dir)->k_objectid ); 1692 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1606 } else { 1693 ih->ih_key.k_objectid,
1607 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET, TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2); 1694 INODE_PKEY(dir)->k_dir_id,
1608 1695 INODE_PKEY(dir)->k_objectid);
1609 make_empty_dir_item (body, ih->ih_key.k_dir_id, ih->ih_key.k_objectid, 1696 } else {
1610 INODE_PKEY (dir)->k_dir_id, 1697 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1611 INODE_PKEY (dir)->k_objectid ); 1698 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1612 } 1699
1613 1700 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1614 /* look for place in the tree for new item */ 1701 ih->ih_key.k_objectid,
1615 retval = search_item (sb, &key, path); 1702 INODE_PKEY(dir)->k_dir_id,
1616 if (retval == IO_ERROR) { 1703 INODE_PKEY(dir)->k_objectid);
1617 reiserfs_warning (sb, "vs-13080: reiserfs_new_directory: " 1704 }
1618 "i/o failure occurred creating new directory"); 1705
1619 return -EIO; 1706 /* look for place in the tree for new item */
1620 } 1707 retval = search_item(sb, &key, path);
1621 if (retval == ITEM_FOUND) { 1708 if (retval == IO_ERROR) {
1622 pathrelse (path); 1709 reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
1623 reiserfs_warning (sb, "vs-13070: reiserfs_new_directory: " 1710 "i/o failure occurred creating new directory");
1624 "object with this key exists (%k)", &(ih->ih_key)); 1711 return -EIO;
1625 return -EEXIST; 1712 }
1626 } 1713 if (retval == ITEM_FOUND) {
1627 1714 pathrelse(path);
1628 /* insert item, that is empty directory item */ 1715 reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
1629 return reiserfs_insert_item (th, path, &key, ih, inode, body); 1716 "object with this key exists (%k)",
1630} 1717 &(ih->ih_key));
1718 return -EEXIST;
1719 }
1631 1720
1721 /* insert item, that is empty directory item */
1722 return reiserfs_insert_item(th, path, &key, ih, inode, body);
1723}
1632 1724
1633/* stat data of object has been inserted, this inserts the item 1725/* stat data of object has been inserted, this inserts the item
1634 containing the body of symlink */ 1726 containing the body of symlink */
1635static int reiserfs_new_symlink (struct reiserfs_transaction_handle *th, 1727static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */
1636 struct inode *inode, /* Inode of symlink */ 1728 struct item_head *ih,
1637 struct item_head * ih, 1729 struct path *path, const char *symname,
1638 struct path * path, const char * symname, int item_len) 1730 int item_len)
1639{ 1731{
1640 struct super_block * sb = th->t_super; 1732 struct super_block *sb = th->t_super;
1641 struct cpu_key key; 1733 struct cpu_key key;
1642 int retval; 1734 int retval;
1643 1735
1644 BUG_ON (!th->t_trans_id); 1736 BUG_ON(!th->t_trans_id);
1645 1737
1646 _make_cpu_key (&key, KEY_FORMAT_3_5, 1738 _make_cpu_key(&key, KEY_FORMAT_3_5,
1647 le32_to_cpu (ih->ih_key.k_dir_id), 1739 le32_to_cpu(ih->ih_key.k_dir_id),
1648 le32_to_cpu (ih->ih_key.k_objectid), 1740 le32_to_cpu(ih->ih_key.k_objectid),
1649 1, TYPE_DIRECT, 3/*key length*/); 1741 1, TYPE_DIRECT, 3 /*key length */ );
1650 1742
1651 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len, 0/*free_space*/); 1743 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1652 1744 0 /*free_space */ );
1653 /* look for place in the tree for new item */
1654 retval = search_item (sb, &key, path);
1655 if (retval == IO_ERROR) {
1656 reiserfs_warning (sb, "vs-13080: reiserfs_new_symlinik: "
1657 "i/o failure occurred creating new symlink");
1658 return -EIO;
1659 }
1660 if (retval == ITEM_FOUND) {
1661 pathrelse (path);
1662 reiserfs_warning (sb, "vs-13080: reiserfs_new_symlink: "
1663 "object with this key exists (%k)", &(ih->ih_key));
1664 return -EEXIST;
1665 }
1666
1667 /* insert item, that is body of symlink */
1668 return reiserfs_insert_item (th, path, &key, ih, inode, symname);
1669}
1670 1745
1746 /* look for place in the tree for new item */
1747 retval = search_item(sb, &key, path);
1748 if (retval == IO_ERROR) {
1749 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
1750 "i/o failure occurred creating new symlink");
1751 return -EIO;
1752 }
1753 if (retval == ITEM_FOUND) {
1754 pathrelse(path);
1755 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
1756 "object with this key exists (%k)",
1757 &(ih->ih_key));
1758 return -EEXIST;
1759 }
1760
1761 /* insert item, that is body of symlink */
1762 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
1763}
1671 1764
1672/* inserts the stat data into the tree, and then calls 1765/* inserts the stat data into the tree, and then calls
1673 reiserfs_new_directory (to insert ".", ".." item if new object is 1766 reiserfs_new_directory (to insert ".", ".." item if new object is
@@ -1678,213 +1771,229 @@ static int reiserfs_new_symlink (struct reiserfs_transaction_handle *th,
1678 non-zero due to an error, we have to drop the quota previously allocated 1771 non-zero due to an error, we have to drop the quota previously allocated
1679 for the fresh inode. This can only be done outside a transaction, so 1772 for the fresh inode. This can only be done outside a transaction, so
1680 if we return non-zero, we also end the transaction. */ 1773 if we return non-zero, we also end the transaction. */
1681int reiserfs_new_inode (struct reiserfs_transaction_handle *th, 1774int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1682 struct inode * dir, int mode, 1775 struct inode *dir, int mode, const char *symname,
1683 const char * symname, 1776 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1684 /* 0 for regular, EMTRY_DIR_SIZE for dirs, 1777 strlen (symname) for symlinks) */
1685 strlen (symname) for symlinks)*/ 1778 loff_t i_size, struct dentry *dentry,
1686 loff_t i_size, struct dentry *dentry, 1779 struct inode *inode)
1687 struct inode *inode)
1688{ 1780{
1689 struct super_block * sb; 1781 struct super_block *sb;
1690 INITIALIZE_PATH (path_to_key); 1782 INITIALIZE_PATH(path_to_key);
1691 struct cpu_key key; 1783 struct cpu_key key;
1692 struct item_head ih; 1784 struct item_head ih;
1693 struct stat_data sd; 1785 struct stat_data sd;
1694 int retval; 1786 int retval;
1695 int err; 1787 int err;
1696 1788
1697 BUG_ON (!th->t_trans_id); 1789 BUG_ON(!th->t_trans_id);
1698 1790
1699 if (DQUOT_ALLOC_INODE(inode)) { 1791 if (DQUOT_ALLOC_INODE(inode)) {
1700 err = -EDQUOT; 1792 err = -EDQUOT;
1701 goto out_end_trans; 1793 goto out_end_trans;
1702 } 1794 }
1703 if (!dir || !dir->i_nlink) { 1795 if (!dir || !dir->i_nlink) {
1704 err = -EPERM; 1796 err = -EPERM;
1705 goto out_bad_inode; 1797 goto out_bad_inode;
1706 } 1798 }
1707 1799
1708 sb = dir->i_sb; 1800 sb = dir->i_sb;
1709 1801
1710 /* item head of new item */ 1802 /* item head of new item */
1711 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir); 1803 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1712 ih.ih_key.k_objectid = cpu_to_le32 (reiserfs_get_unused_objectid (th)); 1804 ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1713 if (!ih.ih_key.k_objectid) { 1805 if (!ih.ih_key.k_objectid) {
1714 err = -ENOMEM; 1806 err = -ENOMEM;
1715 goto out_bad_inode ; 1807 goto out_bad_inode;
1716 } 1808 }
1717 if (old_format_only (sb)) 1809 if (old_format_only(sb))
1718 /* not a perfect generation count, as object ids can be reused, but 1810 /* not a perfect generation count, as object ids can be reused, but
1719 ** this is as good as reiserfs can do right now. 1811 ** this is as good as reiserfs can do right now.
1720 ** note that the private part of inode isn't filled in yet, we have 1812 ** note that the private part of inode isn't filled in yet, we have
1721 ** to use the directory. 1813 ** to use the directory.
1722 */ 1814 */
1723 inode->i_generation = le32_to_cpu (INODE_PKEY (dir)->k_objectid); 1815 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1724 else 1816 else
1725#if defined( USE_INODE_GENERATION_COUNTER ) 1817#if defined( USE_INODE_GENERATION_COUNTER )
1726 inode->i_generation = le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation); 1818 inode->i_generation =
1819 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1727#else 1820#else
1728 inode->i_generation = ++event; 1821 inode->i_generation = ++event;
1729#endif 1822#endif
1730 1823
1731 /* fill stat data */ 1824 /* fill stat data */
1732 inode->i_nlink = (S_ISDIR (mode) ? 2 : 1); 1825 inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1733 1826
1734 /* uid and gid must already be set by the caller for quota init */ 1827 /* uid and gid must already be set by the caller for quota init */
1735 1828
1736 /* symlink cannot be immutable or append only, right? */ 1829 /* symlink cannot be immutable or append only, right? */
1737 if( S_ISLNK( inode -> i_mode ) ) 1830 if (S_ISLNK(inode->i_mode))
1738 inode -> i_flags &= ~ ( S_IMMUTABLE | S_APPEND ); 1831 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1739 1832
1740 inode->i_mtime = inode->i_atime = inode->i_ctime = 1833 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1741 CURRENT_TIME_SEC; 1834 inode->i_size = i_size;
1742 inode->i_size = i_size; 1835 inode->i_blocks = 0;
1743 inode->i_blocks = 0; 1836 inode->i_bytes = 0;
1744 inode->i_bytes = 0; 1837 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1745 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 : 1838 U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
1746 U32_MAX/*NO_BYTES_IN_DIRECT_ITEM*/; 1839
1747 1840 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1748 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list )); 1841 REISERFS_I(inode)->i_flags = 0;
1749 REISERFS_I(inode)->i_flags = 0; 1842 REISERFS_I(inode)->i_prealloc_block = 0;
1750 REISERFS_I(inode)->i_prealloc_block = 0; 1843 REISERFS_I(inode)->i_prealloc_count = 0;
1751 REISERFS_I(inode)->i_prealloc_count = 0; 1844 REISERFS_I(inode)->i_trans_id = 0;
1752 REISERFS_I(inode)->i_trans_id = 0; 1845 REISERFS_I(inode)->i_jl = NULL;
1753 REISERFS_I(inode)->i_jl = NULL; 1846 REISERFS_I(inode)->i_attrs =
1754 REISERFS_I(inode)->i_attrs = 1847 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1755 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK; 1848 sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1756 sd_attrs_to_i_attrs( REISERFS_I(inode) -> i_attrs, inode ); 1849 REISERFS_I(inode)->i_acl_access = NULL;
1757 REISERFS_I(inode)->i_acl_access = NULL; 1850 REISERFS_I(inode)->i_acl_default = NULL;
1758 REISERFS_I(inode)->i_acl_default = NULL; 1851 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1759 init_rwsem (&REISERFS_I(inode)->xattr_sem); 1852
1760 1853 if (old_format_only(sb))
1761 if (old_format_only (sb)) 1854 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1762 make_le_item_head (&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET, TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT); 1855 TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1763 else 1856 else
1764 make_le_item_head (&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET, TYPE_STAT_DATA, SD_SIZE, MAX_US_INT); 1857 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1765 1858 TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1766 /* key to search for correct place for new stat data */ 1859
1767 _make_cpu_key (&key, KEY_FORMAT_3_6, le32_to_cpu (ih.ih_key.k_dir_id), 1860 /* key to search for correct place for new stat data */
1768 le32_to_cpu (ih.ih_key.k_objectid), SD_OFFSET, TYPE_STAT_DATA, 3/*key length*/); 1861 _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1769 1862 le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1770 /* find proper place for inserting of stat data */ 1863 TYPE_STAT_DATA, 3 /*key length */ );
1771 retval = search_item (sb, &key, &path_to_key); 1864
1772 if (retval == IO_ERROR) { 1865 /* find proper place for inserting of stat data */
1773 err = -EIO; 1866 retval = search_item(sb, &key, &path_to_key);
1774 goto out_bad_inode; 1867 if (retval == IO_ERROR) {
1775 } 1868 err = -EIO;
1776 if (retval == ITEM_FOUND) { 1869 goto out_bad_inode;
1777 pathrelse (&path_to_key); 1870 }
1778 err = -EEXIST; 1871 if (retval == ITEM_FOUND) {
1779 goto out_bad_inode; 1872 pathrelse(&path_to_key);
1780 } 1873 err = -EEXIST;
1781 if (old_format_only (sb)) { 1874 goto out_bad_inode;
1782 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) { 1875 }
1783 pathrelse (&path_to_key); 1876 if (old_format_only(sb)) {
1784 /* i_uid or i_gid is too big to be stored in stat data v3.5 */ 1877 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1785 err = -EINVAL; 1878 pathrelse(&path_to_key);
1786 goto out_bad_inode; 1879 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1787 } 1880 err = -EINVAL;
1788 inode2sd_v1 (&sd, inode, inode->i_size); 1881 goto out_bad_inode;
1789 } else { 1882 }
1790 inode2sd (&sd, inode, inode->i_size); 1883 inode2sd_v1(&sd, inode, inode->i_size);
1791 } 1884 } else {
1792 // these do not go to on-disk stat data 1885 inode2sd(&sd, inode, inode->i_size);
1793 inode->i_ino = le32_to_cpu (ih.ih_key.k_objectid); 1886 }
1794 inode->i_blksize = reiserfs_default_io_size; 1887 // these do not go to on-disk stat data
1795 1888 inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1796 // store in in-core inode the key of stat data and version all 1889 inode->i_blksize = reiserfs_default_io_size;
1797 // object items will have (directory items will have old offset 1890
1798 // format, other new objects will consist of new items) 1891 // store in in-core inode the key of stat data and version all
1799 memcpy (INODE_PKEY (inode), &(ih.ih_key), KEY_SIZE); 1892 // object items will have (directory items will have old offset
1800 if (old_format_only (sb) || S_ISDIR(mode) || S_ISLNK(mode)) 1893 // format, other new objects will consist of new items)
1801 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1894 memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1802 else 1895 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1803 set_inode_item_key_version (inode, KEY_FORMAT_3_6); 1896 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1804 if (old_format_only (sb)) 1897 else
1805 set_inode_sd_version (inode, STAT_DATA_V1); 1898 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1806 else 1899 if (old_format_only(sb))
1807 set_inode_sd_version (inode, STAT_DATA_V2); 1900 set_inode_sd_version(inode, STAT_DATA_V1);
1808 1901 else
1809 /* insert the stat data into the tree */ 1902 set_inode_sd_version(inode, STAT_DATA_V2);
1903
1904 /* insert the stat data into the tree */
1810#ifdef DISPLACE_NEW_PACKING_LOCALITIES 1905#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1811 if (REISERFS_I(dir)->new_packing_locality) 1906 if (REISERFS_I(dir)->new_packing_locality)
1812 th->displace_new_blocks = 1; 1907 th->displace_new_blocks = 1;
1813#endif 1908#endif
1814 retval = reiserfs_insert_item (th, &path_to_key, &key, &ih, inode, (char *)(&sd)); 1909 retval =
1815 if (retval) { 1910 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1816 err = retval; 1911 (char *)(&sd));
1817 reiserfs_check_path(&path_to_key) ; 1912 if (retval) {
1818 goto out_bad_inode; 1913 err = retval;
1819 } 1914 reiserfs_check_path(&path_to_key);
1820 1915 goto out_bad_inode;
1916 }
1821#ifdef DISPLACE_NEW_PACKING_LOCALITIES 1917#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1822 if (!th->displace_new_blocks) 1918 if (!th->displace_new_blocks)
1823 REISERFS_I(dir)->new_packing_locality = 0; 1919 REISERFS_I(dir)->new_packing_locality = 0;
1824#endif 1920#endif
1825 if (S_ISDIR(mode)) { 1921 if (S_ISDIR(mode)) {
1826 /* insert item with "." and ".." */ 1922 /* insert item with "." and ".." */
1827 retval = reiserfs_new_directory (th, inode, &ih, &path_to_key, dir); 1923 retval =
1828 } 1924 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1829 1925 }
1830 if (S_ISLNK(mode)) { 1926
1831 /* insert body of symlink */ 1927 if (S_ISLNK(mode)) {
1832 if (!old_format_only (sb)) 1928 /* insert body of symlink */
1833 i_size = ROUND_UP(i_size); 1929 if (!old_format_only(sb))
1834 retval = reiserfs_new_symlink (th, inode, &ih, &path_to_key, symname, i_size); 1930 i_size = ROUND_UP(i_size);
1835 } 1931 retval =
1836 if (retval) { 1932 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1837 err = retval; 1933 i_size);
1838 reiserfs_check_path(&path_to_key) ; 1934 }
1839 journal_end(th, th->t_super, th->t_blocks_allocated); 1935 if (retval) {
1840 goto out_inserted_sd; 1936 err = retval;
1841 } 1937 reiserfs_check_path(&path_to_key);
1842 1938 journal_end(th, th->t_super, th->t_blocks_allocated);
1843 /* XXX CHECK THIS */ 1939 goto out_inserted_sd;
1844 if (reiserfs_posixacl (inode->i_sb)) { 1940 }
1845 retval = reiserfs_inherit_default_acl (dir, dentry, inode); 1941
1846 if (retval) { 1942 /* XXX CHECK THIS */
1847 err = retval; 1943 if (reiserfs_posixacl(inode->i_sb)) {
1848 reiserfs_check_path(&path_to_key) ; 1944 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1849 journal_end(th, th->t_super, th->t_blocks_allocated); 1945 if (retval) {
1850 goto out_inserted_sd; 1946 err = retval;
1851 } 1947 reiserfs_check_path(&path_to_key);
1852 } else if (inode->i_sb->s_flags & MS_POSIXACL) { 1948 journal_end(th, th->t_super, th->t_blocks_allocated);
1853 reiserfs_warning (inode->i_sb, "ACLs aren't enabled in the fs, " 1949 goto out_inserted_sd;
1854 "but vfs thinks they are!"); 1950 }
1855 } else if (is_reiserfs_priv_object (dir)) { 1951 } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1856 reiserfs_mark_inode_private (inode); 1952 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1857 } 1953 "but vfs thinks they are!");
1858 1954 } else if (is_reiserfs_priv_object(dir)) {
1859 insert_inode_hash (inode); 1955 reiserfs_mark_inode_private(inode);
1860 reiserfs_update_sd(th, inode); 1956 }
1861 reiserfs_check_path(&path_to_key) ; 1957
1862 1958 insert_inode_hash(inode);
1863 return 0; 1959 reiserfs_update_sd(th, inode);
1960 reiserfs_check_path(&path_to_key);
1961
1962 return 0;
1864 1963
1865/* it looks like you can easily compress these two goto targets into 1964/* it looks like you can easily compress these two goto targets into
1866 * one. Keeping it like this doesn't actually hurt anything, and they 1965 * one. Keeping it like this doesn't actually hurt anything, and they
1867 * are place holders for what the quota code actually needs. 1966 * are place holders for what the quota code actually needs.
1868 */ 1967 */
1869out_bad_inode: 1968 out_bad_inode:
1870 /* Invalidate the object, nothing was inserted yet */ 1969 /* Invalidate the object, nothing was inserted yet */
1871 INODE_PKEY(inode)->k_objectid = 0; 1970 INODE_PKEY(inode)->k_objectid = 0;
1872 1971
1873 /* Quota change must be inside a transaction for journaling */ 1972 /* Quota change must be inside a transaction for journaling */
1874 DQUOT_FREE_INODE(inode); 1973 DQUOT_FREE_INODE(inode);
1875 1974
1876out_end_trans: 1975 out_end_trans:
1877 journal_end(th, th->t_super, th->t_blocks_allocated) ; 1976 journal_end(th, th->t_super, th->t_blocks_allocated);
1878 /* Drop can be outside and it needs more credits so it's better to have it outside */ 1977 /* Drop can be outside and it needs more credits so it's better to have it outside */
1879 DQUOT_DROP(inode); 1978 DQUOT_DROP(inode);
1880 inode->i_flags |= S_NOQUOTA; 1979 inode->i_flags |= S_NOQUOTA;
1881 make_bad_inode(inode); 1980 make_bad_inode(inode);
1882 1981
1883out_inserted_sd: 1982 out_inserted_sd:
1884 inode->i_nlink = 0; 1983 inode->i_nlink = 0;
1885 th->t_trans_id = 0; /* so the caller can't use this handle later */ 1984 th->t_trans_id = 0; /* so the caller can't use this handle later */
1886 iput(inode); 1985
1887 return err; 1986 /* If we were inheriting an ACL, we need to release the lock so that
1987 * iput doesn't deadlock in reiserfs_delete_xattrs. The locking
1988 * code really needs to be reworked, but this will take care of it
1989 * for now. -jeffm */
1990 if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {
1991 reiserfs_write_unlock_xattrs(dir->i_sb);
1992 iput(inode);
1993 reiserfs_write_lock_xattrs(dir->i_sb);
1994 } else
1995 iput(inode);
1996 return err;
1888} 1997}
1889 1998
1890/* 1999/*
@@ -1900,77 +2009,78 @@ out_inserted_sd:
1900** 2009**
1901** on failure, nonzero is returned, page_result and bh_result are untouched. 2010** on failure, nonzero is returned, page_result and bh_result are untouched.
1902*/ 2011*/
1903static int grab_tail_page(struct inode *p_s_inode, 2012static int grab_tail_page(struct inode *p_s_inode,
1904 struct page **page_result, 2013 struct page **page_result,
1905 struct buffer_head **bh_result) { 2014 struct buffer_head **bh_result)
1906 2015{
1907 /* we want the page with the last byte in the file, 2016
1908 ** not the page that will hold the next byte for appending 2017 /* we want the page with the last byte in the file,
1909 */ 2018 ** not the page that will hold the next byte for appending
1910 unsigned long index = (p_s_inode->i_size-1) >> PAGE_CACHE_SHIFT ; 2019 */
1911 unsigned long pos = 0 ; 2020 unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
1912 unsigned long start = 0 ; 2021 unsigned long pos = 0;
1913 unsigned long blocksize = p_s_inode->i_sb->s_blocksize ; 2022 unsigned long start = 0;
1914 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1) ; 2023 unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
1915 struct buffer_head *bh ; 2024 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
1916 struct buffer_head *head ; 2025 struct buffer_head *bh;
1917 struct page * page ; 2026 struct buffer_head *head;
1918 int error ; 2027 struct page *page;
1919 2028 int error;
1920 /* we know that we are only called with inode->i_size > 0. 2029
1921 ** we also know that a file tail can never be as big as a block 2030 /* we know that we are only called with inode->i_size > 0.
1922 ** If i_size % blocksize == 0, our file is currently block aligned 2031 ** we also know that a file tail can never be as big as a block
1923 ** and it won't need converting or zeroing after a truncate. 2032 ** If i_size % blocksize == 0, our file is currently block aligned
1924 */ 2033 ** and it won't need converting or zeroing after a truncate.
1925 if ((offset & (blocksize - 1)) == 0) { 2034 */
1926 return -ENOENT ; 2035 if ((offset & (blocksize - 1)) == 0) {
1927 } 2036 return -ENOENT;
1928 page = grab_cache_page(p_s_inode->i_mapping, index) ; 2037 }
1929 error = -ENOMEM ; 2038 page = grab_cache_page(p_s_inode->i_mapping, index);
1930 if (!page) { 2039 error = -ENOMEM;
1931 goto out ; 2040 if (!page) {
1932 } 2041 goto out;
1933 /* start within the page of the last block in the file */ 2042 }
1934 start = (offset / blocksize) * blocksize ; 2043 /* start within the page of the last block in the file */
1935 2044 start = (offset / blocksize) * blocksize;
1936 error = block_prepare_write(page, start, offset, 2045
1937 reiserfs_get_block_create_0) ; 2046 error = block_prepare_write(page, start, offset,
1938 if (error) 2047 reiserfs_get_block_create_0);
1939 goto unlock ; 2048 if (error)
1940 2049 goto unlock;
1941 head = page_buffers(page) ; 2050
1942 bh = head; 2051 head = page_buffers(page);
1943 do { 2052 bh = head;
1944 if (pos >= start) { 2053 do {
1945 break ; 2054 if (pos >= start) {
1946 } 2055 break;
1947 bh = bh->b_this_page ; 2056 }
1948 pos += blocksize ; 2057 bh = bh->b_this_page;
1949 } while(bh != head) ; 2058 pos += blocksize;
1950 2059 } while (bh != head);
1951 if (!buffer_uptodate(bh)) { 2060
1952 /* note, this should never happen, prepare_write should 2061 if (!buffer_uptodate(bh)) {
1953 ** be taking care of this for us. If the buffer isn't up to date, 2062 /* note, this should never happen, prepare_write should
1954 ** I've screwed up the code to find the buffer, or the code to 2063 ** be taking care of this for us. If the buffer isn't up to date,
1955 ** call prepare_write 2064 ** I've screwed up the code to find the buffer, or the code to
1956 */ 2065 ** call prepare_write
1957 reiserfs_warning (p_s_inode->i_sb, 2066 */
1958 "clm-6000: error reading block %lu on dev %s", 2067 reiserfs_warning(p_s_inode->i_sb,
1959 bh->b_blocknr, 2068 "clm-6000: error reading block %lu on dev %s",
1960 reiserfs_bdevname (p_s_inode->i_sb)) ; 2069 bh->b_blocknr,
1961 error = -EIO ; 2070 reiserfs_bdevname(p_s_inode->i_sb));
1962 goto unlock ; 2071 error = -EIO;
1963 } 2072 goto unlock;
1964 *bh_result = bh ; 2073 }
1965 *page_result = page ; 2074 *bh_result = bh;
1966 2075 *page_result = page;
1967out: 2076
1968 return error ; 2077 out:
1969 2078 return error;
1970unlock: 2079
1971 unlock_page(page) ; 2080 unlock:
1972 page_cache_release(page) ; 2081 unlock_page(page);
1973 return error ; 2082 page_cache_release(page);
2083 return error;
1974} 2084}
1975 2085
1976/* 2086/*
@@ -1979,235 +2089,247 @@ unlock:
1979** 2089**
1980** some code taken from block_truncate_page 2090** some code taken from block_truncate_page
1981*/ 2091*/
1982int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps) { 2092int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
1983 struct reiserfs_transaction_handle th ; 2093{
1984 /* we want the offset for the first byte after the end of the file */ 2094 struct reiserfs_transaction_handle th;
1985 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1) ; 2095 /* we want the offset for the first byte after the end of the file */
1986 unsigned blocksize = p_s_inode->i_sb->s_blocksize ; 2096 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
1987 unsigned length ; 2097 unsigned blocksize = p_s_inode->i_sb->s_blocksize;
1988 struct page *page = NULL ; 2098 unsigned length;
1989 int error ; 2099 struct page *page = NULL;
1990 struct buffer_head *bh = NULL ; 2100 int error;
1991 2101 struct buffer_head *bh = NULL;
1992 reiserfs_write_lock(p_s_inode->i_sb); 2102
1993 2103 reiserfs_write_lock(p_s_inode->i_sb);
1994 if (p_s_inode->i_size > 0) { 2104
1995 if ((error = grab_tail_page(p_s_inode, &page, &bh))) { 2105 if (p_s_inode->i_size > 0) {
1996 // -ENOENT means we truncated past the end of the file, 2106 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
1997 // and get_block_create_0 could not find a block to read in, 2107 // -ENOENT means we truncated past the end of the file,
1998 // which is ok. 2108 // and get_block_create_0 could not find a block to read in,
1999 if (error != -ENOENT) 2109 // which is ok.
2000 reiserfs_warning (p_s_inode->i_sb, 2110 if (error != -ENOENT)
2001 "clm-6001: grab_tail_page failed %d", 2111 reiserfs_warning(p_s_inode->i_sb,
2002 error); 2112 "clm-6001: grab_tail_page failed %d",
2003 page = NULL ; 2113 error);
2004 bh = NULL ; 2114 page = NULL;
2005 } 2115 bh = NULL;
2006 } 2116 }
2007 2117 }
2008 /* so, if page != NULL, we have a buffer head for the offset at
2009 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2010 ** then we have an unformatted node. Otherwise, we have a direct item,
2011 ** and no zeroing is required on disk. We zero after the truncate,
2012 ** because the truncate might pack the item anyway
2013 ** (it will unmap bh if it packs).
2014 */
2015 /* it is enough to reserve space in transaction for 2 balancings:
2016 one for "save" link adding and another for the first
2017 cut_from_item. 1 is for update_sd */
2018 error = journal_begin (&th, p_s_inode->i_sb,
2019 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2020 if (error)
2021 goto out;
2022 reiserfs_update_inode_transaction(p_s_inode) ;
2023 if (update_timestamps)
2024 /* we are doing real truncate: if the system crashes before the last
2025 transaction of truncating gets committed - on reboot the file
2026 either appears truncated properly or not truncated at all */
2027 add_save_link (&th, p_s_inode, 1);
2028 error = reiserfs_do_truncate (&th, p_s_inode, page, update_timestamps) ;
2029 if (error)
2030 goto out;
2031 error = journal_end (&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2032 if (error)
2033 goto out;
2034
2035 if (update_timestamps) {
2036 error = remove_save_link (p_s_inode, 1/* truncate */);
2037 if (error)
2038 goto out;
2039 }
2040
2041 if (page) {
2042 length = offset & (blocksize - 1) ;
2043 /* if we are not on a block boundary */
2044 if (length) {
2045 char *kaddr;
2046
2047 length = blocksize - length ;
2048 kaddr = kmap_atomic(page, KM_USER0) ;
2049 memset(kaddr + offset, 0, length) ;
2050 flush_dcache_page(page) ;
2051 kunmap_atomic(kaddr, KM_USER0) ;
2052 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2053 mark_buffer_dirty(bh) ;
2054 }
2055 }
2056 unlock_page(page) ;
2057 page_cache_release(page) ;
2058 }
2059
2060 reiserfs_write_unlock(p_s_inode->i_sb);
2061 return 0;
2062out:
2063 if (page) {
2064 unlock_page (page);
2065 page_cache_release (page);
2066 }
2067 reiserfs_write_unlock(p_s_inode->i_sb);
2068 return error;
2069}
2070 2118
2071static int map_block_for_writepage(struct inode *inode, 2119 /* so, if page != NULL, we have a buffer head for the offset at
2072 struct buffer_head *bh_result, 2120 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2073 unsigned long block) { 2121 ** then we have an unformatted node. Otherwise, we have a direct item,
2074 struct reiserfs_transaction_handle th ; 2122 ** and no zeroing is required on disk. We zero after the truncate,
2075 int fs_gen ; 2123 ** because the truncate might pack the item anyway
2076 struct item_head tmp_ih ; 2124 ** (it will unmap bh if it packs).
2077 struct item_head *ih ;
2078 struct buffer_head *bh ;
2079 __le32 *item ;
2080 struct cpu_key key ;
2081 INITIALIZE_PATH(path) ;
2082 int pos_in_item ;
2083 int jbegin_count = JOURNAL_PER_BALANCE_CNT ;
2084 loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1 ;
2085 int retval ;
2086 int use_get_block = 0 ;
2087 int bytes_copied = 0 ;
2088 int copy_size ;
2089 int trans_running = 0;
2090
2091 /* catch places below that try to log something without starting a trans */
2092 th.t_trans_id = 0;
2093
2094 if (!buffer_uptodate(bh_result)) {
2095 return -EIO;
2096 }
2097
2098 kmap(bh_result->b_page) ;
2099start_over:
2100 reiserfs_write_lock(inode->i_sb);
2101 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3) ;
2102
2103research:
2104 retval = search_for_position_by_key(inode->i_sb, &key, &path) ;
2105 if (retval != POSITION_FOUND) {
2106 use_get_block = 1;
2107 goto out ;
2108 }
2109
2110 bh = get_last_bh(&path) ;
2111 ih = get_ih(&path) ;
2112 item = get_item(&path) ;
2113 pos_in_item = path.pos_in_item ;
2114
2115 /* we've found an unformatted node */
2116 if (indirect_item_found(retval, ih)) {
2117 if (bytes_copied > 0) {
2118 reiserfs_warning (inode->i_sb, "clm-6002: bytes_copied %d",
2119 bytes_copied) ;
2120 }
2121 if (!get_block_num(item, pos_in_item)) {
2122 /* crap, we are writing to a hole */
2123 use_get_block = 1;
2124 goto out ;
2125 }
2126 set_block_dev_mapped(bh_result, get_block_num(item,pos_in_item),inode);
2127 } else if (is_direct_le_ih(ih)) {
2128 char *p ;
2129 p = page_address(bh_result->b_page) ;
2130 p += (byte_offset -1) & (PAGE_CACHE_SIZE - 1) ;
2131 copy_size = ih_item_len(ih) - pos_in_item;
2132
2133 fs_gen = get_generation(inode->i_sb) ;
2134 copy_item_head(&tmp_ih, ih) ;
2135
2136 if (!trans_running) {
2137 /* vs-3050 is gone, no need to drop the path */
2138 retval = journal_begin(&th, inode->i_sb, jbegin_count) ;
2139 if (retval)
2140 goto out;
2141 reiserfs_update_inode_transaction(inode) ;
2142 trans_running = 1;
2143 if (fs_changed(fs_gen, inode->i_sb) && item_moved(&tmp_ih, &path)) {
2144 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
2145 goto research;
2146 }
2147 }
2148
2149 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ;
2150
2151 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
2152 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
2153 goto research;
2154 }
2155
2156 memcpy( B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied, copy_size) ;
2157
2158 journal_mark_dirty(&th, inode->i_sb, bh) ;
2159 bytes_copied += copy_size ;
2160 set_block_dev_mapped(bh_result, 0, inode);
2161
2162 /* are there still bytes left? */
2163 if (bytes_copied < bh_result->b_size &&
2164 (byte_offset + bytes_copied) < inode->i_size) {
2165 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + copy_size) ;
2166 goto research ;
2167 }
2168 } else {
2169 reiserfs_warning (inode->i_sb,
2170 "clm-6003: bad item inode %lu, device %s",
2171 inode->i_ino, reiserfs_bdevname (inode->i_sb)) ;
2172 retval = -EIO ;
2173 goto out ;
2174 }
2175 retval = 0 ;
2176
2177out:
2178 pathrelse(&path) ;
2179 if (trans_running) {
2180 int err = journal_end(&th, inode->i_sb, jbegin_count) ;
2181 if (err)
2182 retval = err;
2183 trans_running = 0;
2184 }
2185 reiserfs_write_unlock(inode->i_sb);
2186
2187 /* this is where we fill in holes in the file. */
2188 if (use_get_block) {
2189 retval = reiserfs_get_block(inode, block, bh_result,
2190 GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM |
2191 GET_BLOCK_NO_DANGLE);
2192 if (!retval) {
2193 if (!buffer_mapped(bh_result) || bh_result->b_blocknr == 0) {
2194 /* get_block failed to find a mapped unformatted node. */
2195 use_get_block = 0 ;
2196 goto start_over ;
2197 }
2198 }
2199 }
2200 kunmap(bh_result->b_page) ;
2201
2202 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2203 /* we've copied data from the page into the direct item, so the
2204 * buffer in the page is now clean, mark it to reflect that.
2205 */ 2125 */
2206 lock_buffer(bh_result); 2126 /* it is enough to reserve space in transaction for 2 balancings:
2207 clear_buffer_dirty(bh_result); 2127 one for "save" link adding and another for the first
2208 unlock_buffer(bh_result); 2128 cut_from_item. 1 is for update_sd */
2209 } 2129 error = journal_begin(&th, p_s_inode->i_sb,
2210 return retval ; 2130 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2131 if (error)
2132 goto out;
2133 reiserfs_update_inode_transaction(p_s_inode);
2134 if (update_timestamps)
2135 /* we are doing real truncate: if the system crashes before the last
2136 transaction of truncating gets committed - on reboot the file
2137 either appears truncated properly or not truncated at all */
2138 add_save_link(&th, p_s_inode, 1);
2139 error = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
2140 if (error)
2141 goto out;
2142 error =
2143 journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2144 if (error)
2145 goto out;
2146
2147 if (update_timestamps) {
2148 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2149 if (error)
2150 goto out;
2151 }
2152
2153 if (page) {
2154 length = offset & (blocksize - 1);
2155 /* if we are not on a block boundary */
2156 if (length) {
2157 char *kaddr;
2158
2159 length = blocksize - length;
2160 kaddr = kmap_atomic(page, KM_USER0);
2161 memset(kaddr + offset, 0, length);
2162 flush_dcache_page(page);
2163 kunmap_atomic(kaddr, KM_USER0);
2164 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2165 mark_buffer_dirty(bh);
2166 }
2167 }
2168 unlock_page(page);
2169 page_cache_release(page);
2170 }
2171
2172 reiserfs_write_unlock(p_s_inode->i_sb);
2173 return 0;
2174 out:
2175 if (page) {
2176 unlock_page(page);
2177 page_cache_release(page);
2178 }
2179 reiserfs_write_unlock(p_s_inode->i_sb);
2180 return error;
2181}
2182
2183static int map_block_for_writepage(struct inode *inode,
2184 struct buffer_head *bh_result,
2185 unsigned long block)
2186{
2187 struct reiserfs_transaction_handle th;
2188 int fs_gen;
2189 struct item_head tmp_ih;
2190 struct item_head *ih;
2191 struct buffer_head *bh;
2192 __le32 *item;
2193 struct cpu_key key;
2194 INITIALIZE_PATH(path);
2195 int pos_in_item;
2196 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2197 loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1;
2198 int retval;
2199 int use_get_block = 0;
2200 int bytes_copied = 0;
2201 int copy_size;
2202 int trans_running = 0;
2203
2204 /* catch places below that try to log something without starting a trans */
2205 th.t_trans_id = 0;
2206
2207 if (!buffer_uptodate(bh_result)) {
2208 return -EIO;
2209 }
2210
2211 kmap(bh_result->b_page);
2212 start_over:
2213 reiserfs_write_lock(inode->i_sb);
2214 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2215
2216 research:
2217 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2218 if (retval != POSITION_FOUND) {
2219 use_get_block = 1;
2220 goto out;
2221 }
2222
2223 bh = get_last_bh(&path);
2224 ih = get_ih(&path);
2225 item = get_item(&path);
2226 pos_in_item = path.pos_in_item;
2227
2228 /* we've found an unformatted node */
2229 if (indirect_item_found(retval, ih)) {
2230 if (bytes_copied > 0) {
2231 reiserfs_warning(inode->i_sb,
2232 "clm-6002: bytes_copied %d",
2233 bytes_copied);
2234 }
2235 if (!get_block_num(item, pos_in_item)) {
2236 /* crap, we are writing to a hole */
2237 use_get_block = 1;
2238 goto out;
2239 }
2240 set_block_dev_mapped(bh_result,
2241 get_block_num(item, pos_in_item), inode);
2242 } else if (is_direct_le_ih(ih)) {
2243 char *p;
2244 p = page_address(bh_result->b_page);
2245 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2246 copy_size = ih_item_len(ih) - pos_in_item;
2247
2248 fs_gen = get_generation(inode->i_sb);
2249 copy_item_head(&tmp_ih, ih);
2250
2251 if (!trans_running) {
2252 /* vs-3050 is gone, no need to drop the path */
2253 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2254 if (retval)
2255 goto out;
2256 reiserfs_update_inode_transaction(inode);
2257 trans_running = 1;
2258 if (fs_changed(fs_gen, inode->i_sb)
2259 && item_moved(&tmp_ih, &path)) {
2260 reiserfs_restore_prepared_buffer(inode->i_sb,
2261 bh);
2262 goto research;
2263 }
2264 }
2265
2266 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2267
2268 if (fs_changed(fs_gen, inode->i_sb)
2269 && item_moved(&tmp_ih, &path)) {
2270 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2271 goto research;
2272 }
2273
2274 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2275 copy_size);
2276
2277 journal_mark_dirty(&th, inode->i_sb, bh);
2278 bytes_copied += copy_size;
2279 set_block_dev_mapped(bh_result, 0, inode);
2280
2281 /* are there still bytes left? */
2282 if (bytes_copied < bh_result->b_size &&
2283 (byte_offset + bytes_copied) < inode->i_size) {
2284 set_cpu_key_k_offset(&key,
2285 cpu_key_k_offset(&key) +
2286 copy_size);
2287 goto research;
2288 }
2289 } else {
2290 reiserfs_warning(inode->i_sb,
2291 "clm-6003: bad item inode %lu, device %s",
2292 inode->i_ino, reiserfs_bdevname(inode->i_sb));
2293 retval = -EIO;
2294 goto out;
2295 }
2296 retval = 0;
2297
2298 out:
2299 pathrelse(&path);
2300 if (trans_running) {
2301 int err = journal_end(&th, inode->i_sb, jbegin_count);
2302 if (err)
2303 retval = err;
2304 trans_running = 0;
2305 }
2306 reiserfs_write_unlock(inode->i_sb);
2307
2308 /* this is where we fill in holes in the file. */
2309 if (use_get_block) {
2310 retval = reiserfs_get_block(inode, block, bh_result,
2311 GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM
2312 | GET_BLOCK_NO_DANGLE);
2313 if (!retval) {
2314 if (!buffer_mapped(bh_result)
2315 || bh_result->b_blocknr == 0) {
2316 /* get_block failed to find a mapped unformatted node. */
2317 use_get_block = 0;
2318 goto start_over;
2319 }
2320 }
2321 }
2322 kunmap(bh_result->b_page);
2323
2324 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2325 /* we've copied data from the page into the direct item, so the
2326 * buffer in the page is now clean, mark it to reflect that.
2327 */
2328 lock_buffer(bh_result);
2329 clear_buffer_dirty(bh_result);
2330 unlock_buffer(bh_result);
2331 }
2332 return retval;
2211} 2333}
2212 2334
2213/* 2335/*
@@ -2215,383 +2337,388 @@ out:
2215 * start/recovery path as __block_write_full_page, along with special 2337 * start/recovery path as __block_write_full_page, along with special
2216 * code to handle reiserfs tails. 2338 * code to handle reiserfs tails.
2217 */ 2339 */
2218static int reiserfs_write_full_page(struct page *page, struct writeback_control *wbc) { 2340static int reiserfs_write_full_page(struct page *page,
2219 struct inode *inode = page->mapping->host ; 2341 struct writeback_control *wbc)
2220 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT ; 2342{
2221 int error = 0; 2343 struct inode *inode = page->mapping->host;
2222 unsigned long block ; 2344 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2223 struct buffer_head *head, *bh; 2345 int error = 0;
2224 int partial = 0 ; 2346 unsigned long block;
2225 int nr = 0; 2347 struct buffer_head *head, *bh;
2226 int checked = PageChecked(page); 2348 int partial = 0;
2227 struct reiserfs_transaction_handle th; 2349 int nr = 0;
2228 struct super_block *s = inode->i_sb; 2350 int checked = PageChecked(page);
2229 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize; 2351 struct reiserfs_transaction_handle th;
2230 th.t_trans_id = 0; 2352 struct super_block *s = inode->i_sb;
2231 2353 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2232 /* The page dirty bit is cleared before writepage is called, which 2354 th.t_trans_id = 0;
2233 * means we have to tell create_empty_buffers to make dirty buffers 2355
2234 * The page really should be up to date at this point, so tossing 2356 /* The page dirty bit is cleared before writepage is called, which
2235 * in the BH_Uptodate is just a sanity check. 2357 * means we have to tell create_empty_buffers to make dirty buffers
2236 */ 2358 * The page really should be up to date at this point, so tossing
2237 if (!page_has_buffers(page)) { 2359 * in the BH_Uptodate is just a sanity check.
2238 create_empty_buffers(page, s->s_blocksize, 2360 */
2239 (1 << BH_Dirty) | (1 << BH_Uptodate)); 2361 if (!page_has_buffers(page)) {
2240 } 2362 create_empty_buffers(page, s->s_blocksize,
2241 head = page_buffers(page) ; 2363 (1 << BH_Dirty) | (1 << BH_Uptodate));
2242 2364 }
2243 /* last page in the file, zero out any contents past the 2365 head = page_buffers(page);
2244 ** last byte in the file
2245 */
2246 if (page->index >= end_index) {
2247 char *kaddr;
2248 unsigned last_offset;
2249
2250 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1) ;
2251 /* no file contents in this page */
2252 if (page->index >= end_index + 1 || !last_offset) {
2253 unlock_page(page);
2254 return 0;
2255 }
2256 kaddr = kmap_atomic(page, KM_USER0);
2257 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE-last_offset) ;
2258 flush_dcache_page(page) ;
2259 kunmap_atomic(kaddr, KM_USER0) ;
2260 }
2261 bh = head ;
2262 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits) ;
2263 /* first map all the buffers, logging any direct items we find */
2264 do {
2265 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2266 (buffer_mapped(bh) && bh->b_blocknr == 0))) {
2267 /* not mapped yet, or it points to a direct item, search
2268 * the btree for the mapping info, and log any direct
2269 * items found
2270 */
2271 if ((error = map_block_for_writepage(inode, bh, block))) {
2272 goto fail ;
2273 }
2274 }
2275 bh = bh->b_this_page;
2276 block++;
2277 } while(bh != head) ;
2278
2279 /*
2280 * we start the transaction after map_block_for_writepage,
2281 * because it can create holes in the file (an unbounded operation).
2282 * starting it here, we can make a reliable estimate for how many
2283 * blocks we're going to log
2284 */
2285 if (checked) {
2286 ClearPageChecked(page);
2287 reiserfs_write_lock(s);
2288 error = journal_begin(&th, s, bh_per_page + 1);
2289 if (error) {
2290 reiserfs_write_unlock(s);
2291 goto fail;
2292 }
2293 reiserfs_update_inode_transaction(inode);
2294 }
2295 /* now go through and lock any dirty buffers on the page */
2296 do {
2297 get_bh(bh);
2298 if (!buffer_mapped(bh))
2299 continue;
2300 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2301 continue;
2302 2366
2303 if (checked) { 2367 /* last page in the file, zero out any contents past the
2304 reiserfs_prepare_for_journal(s, bh, 1); 2368 ** last byte in the file
2305 journal_mark_dirty(&th, s, bh); 2369 */
2306 continue; 2370 if (page->index >= end_index) {
2371 char *kaddr;
2372 unsigned last_offset;
2373
2374 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2375 /* no file contents in this page */
2376 if (page->index >= end_index + 1 || !last_offset) {
2377 unlock_page(page);
2378 return 0;
2379 }
2380 kaddr = kmap_atomic(page, KM_USER0);
2381 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2382 flush_dcache_page(page);
2383 kunmap_atomic(kaddr, KM_USER0);
2307 } 2384 }
2308 /* from this point on, we know the buffer is mapped to a 2385 bh = head;
2309 * real block and not a direct item 2386 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2387 /* first map all the buffers, logging any direct items we find */
2388 do {
2389 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2390 (buffer_mapped(bh)
2391 && bh->b_blocknr ==
2392 0))) {
2393 /* not mapped yet, or it points to a direct item, search
2394 * the btree for the mapping info, and log any direct
2395 * items found
2396 */
2397 if ((error = map_block_for_writepage(inode, bh, block))) {
2398 goto fail;
2399 }
2400 }
2401 bh = bh->b_this_page;
2402 block++;
2403 } while (bh != head);
2404
2405 /*
2406 * we start the transaction after map_block_for_writepage,
2407 * because it can create holes in the file (an unbounded operation).
2408 * starting it here, we can make a reliable estimate for how many
2409 * blocks we're going to log
2310 */ 2410 */
2311 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) { 2411 if (checked) {
2312 lock_buffer(bh); 2412 ClearPageChecked(page);
2313 } else { 2413 reiserfs_write_lock(s);
2314 if (test_set_buffer_locked(bh)) { 2414 error = journal_begin(&th, s, bh_per_page + 1);
2315 redirty_page_for_writepage(wbc, page); 2415 if (error) {
2316 continue; 2416 reiserfs_write_unlock(s);
2317 } 2417 goto fail;
2418 }
2419 reiserfs_update_inode_transaction(inode);
2318 } 2420 }
2319 if (test_clear_buffer_dirty(bh)) { 2421 /* now go through and lock any dirty buffers on the page */
2320 mark_buffer_async_write(bh); 2422 do {
2321 } else { 2423 get_bh(bh);
2322 unlock_buffer(bh); 2424 if (!buffer_mapped(bh))
2425 continue;
2426 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2427 continue;
2428
2429 if (checked) {
2430 reiserfs_prepare_for_journal(s, bh, 1);
2431 journal_mark_dirty(&th, s, bh);
2432 continue;
2433 }
2434 /* from this point on, we know the buffer is mapped to a
2435 * real block and not a direct item
2436 */
2437 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2438 lock_buffer(bh);
2439 } else {
2440 if (test_set_buffer_locked(bh)) {
2441 redirty_page_for_writepage(wbc, page);
2442 continue;
2443 }
2444 }
2445 if (test_clear_buffer_dirty(bh)) {
2446 mark_buffer_async_write(bh);
2447 } else {
2448 unlock_buffer(bh);
2449 }
2450 } while ((bh = bh->b_this_page) != head);
2451
2452 if (checked) {
2453 error = journal_end(&th, s, bh_per_page + 1);
2454 reiserfs_write_unlock(s);
2455 if (error)
2456 goto fail;
2323 } 2457 }
2324 } while((bh = bh->b_this_page) != head); 2458 BUG_ON(PageWriteback(page));
2459 set_page_writeback(page);
2460 unlock_page(page);
2325 2461
2326 if (checked) { 2462 /*
2327 error = journal_end(&th, s, bh_per_page + 1); 2463 * since any buffer might be the only dirty buffer on the page,
2328 reiserfs_write_unlock(s); 2464 * the first submit_bh can bring the page out of writeback.
2329 if (error) 2465 * be careful with the buffers.
2330 goto fail;
2331 }
2332 BUG_ON(PageWriteback(page));
2333 set_page_writeback(page);
2334 unlock_page(page);
2335
2336 /*
2337 * since any buffer might be the only dirty buffer on the page,
2338 * the first submit_bh can bring the page out of writeback.
2339 * be careful with the buffers.
2340 */
2341 do {
2342 struct buffer_head *next = bh->b_this_page;
2343 if (buffer_async_write(bh)) {
2344 submit_bh(WRITE, bh);
2345 nr++;
2346 }
2347 put_bh(bh);
2348 bh = next;
2349 } while(bh != head);
2350
2351 error = 0;
2352done:
2353 if (nr == 0) {
2354 /*
2355 * if this page only had a direct item, it is very possible for
2356 * no io to be required without there being an error. Or,
2357 * someone else could have locked them and sent them down the
2358 * pipe without locking the page
2359 */ 2466 */
2360 bh = head ;
2361 do { 2467 do {
2362 if (!buffer_uptodate(bh)) { 2468 struct buffer_head *next = bh->b_this_page;
2363 partial = 1; 2469 if (buffer_async_write(bh)) {
2364 break; 2470 submit_bh(WRITE, bh);
2365 } 2471 nr++;
2366 bh = bh->b_this_page; 2472 }
2367 } while(bh != head); 2473 put_bh(bh);
2368 if (!partial) 2474 bh = next;
2369 SetPageUptodate(page); 2475 } while (bh != head);
2370 end_page_writeback(page);
2371 }
2372 return error;
2373
2374fail:
2375 /* catches various errors, we need to make sure any valid dirty blocks
2376 * get to the media. The page is currently locked and not marked for
2377 * writeback
2378 */
2379 ClearPageUptodate(page);
2380 bh = head;
2381 do {
2382 get_bh(bh);
2383 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2384 lock_buffer(bh);
2385 mark_buffer_async_write(bh);
2386 } else {
2387 /*
2388 * clear any dirty bits that might have come from getting
2389 * attached to a dirty page
2390 */
2391 clear_buffer_dirty(bh);
2392 }
2393 bh = bh->b_this_page;
2394 } while(bh != head);
2395 SetPageError(page);
2396 BUG_ON(PageWriteback(page));
2397 set_page_writeback(page);
2398 unlock_page(page);
2399 do {
2400 struct buffer_head *next = bh->b_this_page;
2401 if (buffer_async_write(bh)) {
2402 clear_buffer_dirty(bh);
2403 submit_bh(WRITE, bh);
2404 nr++;
2405 }
2406 put_bh(bh);
2407 bh = next;
2408 } while(bh != head);
2409 goto done;
2410}
2411 2476
2477 error = 0;
2478 done:
2479 if (nr == 0) {
2480 /*
2481 * if this page only had a direct item, it is very possible for
2482 * no io to be required without there being an error. Or,
2483 * someone else could have locked them and sent them down the
2484 * pipe without locking the page
2485 */
2486 bh = head;
2487 do {
2488 if (!buffer_uptodate(bh)) {
2489 partial = 1;
2490 break;
2491 }
2492 bh = bh->b_this_page;
2493 } while (bh != head);
2494 if (!partial)
2495 SetPageUptodate(page);
2496 end_page_writeback(page);
2497 }
2498 return error;
2412 2499
2413static int reiserfs_readpage (struct file *f, struct page * page) 2500 fail:
2414{ 2501 /* catches various errors, we need to make sure any valid dirty blocks
2415 return block_read_full_page (page, reiserfs_get_block); 2502 * get to the media. The page is currently locked and not marked for
2503 * writeback
2504 */
2505 ClearPageUptodate(page);
2506 bh = head;
2507 do {
2508 get_bh(bh);
2509 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2510 lock_buffer(bh);
2511 mark_buffer_async_write(bh);
2512 } else {
2513 /*
2514 * clear any dirty bits that might have come from getting
2515 * attached to a dirty page
2516 */
2517 clear_buffer_dirty(bh);
2518 }
2519 bh = bh->b_this_page;
2520 } while (bh != head);
2521 SetPageError(page);
2522 BUG_ON(PageWriteback(page));
2523 set_page_writeback(page);
2524 unlock_page(page);
2525 do {
2526 struct buffer_head *next = bh->b_this_page;
2527 if (buffer_async_write(bh)) {
2528 clear_buffer_dirty(bh);
2529 submit_bh(WRITE, bh);
2530 nr++;
2531 }
2532 put_bh(bh);
2533 bh = next;
2534 } while (bh != head);
2535 goto done;
2416} 2536}
2417 2537
2538static int reiserfs_readpage(struct file *f, struct page *page)
2539{
2540 return block_read_full_page(page, reiserfs_get_block);
2541}
2418 2542
2419static int reiserfs_writepage (struct page * page, struct writeback_control *wbc) 2543static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2420{ 2544{
2421 struct inode *inode = page->mapping->host ; 2545 struct inode *inode = page->mapping->host;
2422 reiserfs_wait_on_write_block(inode->i_sb) ; 2546 reiserfs_wait_on_write_block(inode->i_sb);
2423 return reiserfs_write_full_page(page, wbc) ; 2547 return reiserfs_write_full_page(page, wbc);
2424} 2548}
2425 2549
2426static int reiserfs_prepare_write(struct file *f, struct page *page, 2550static int reiserfs_prepare_write(struct file *f, struct page *page,
2427 unsigned from, unsigned to) { 2551 unsigned from, unsigned to)
2428 struct inode *inode = page->mapping->host ; 2552{
2429 int ret; 2553 struct inode *inode = page->mapping->host;
2430 int old_ref = 0; 2554 int ret;
2431 2555 int old_ref = 0;
2432 reiserfs_wait_on_write_block(inode->i_sb) ; 2556
2433 fix_tail_page_for_writing(page) ; 2557 reiserfs_wait_on_write_block(inode->i_sb);
2434 if (reiserfs_transaction_running(inode->i_sb)) { 2558 fix_tail_page_for_writing(page);
2435 struct reiserfs_transaction_handle *th; 2559 if (reiserfs_transaction_running(inode->i_sb)) {
2436 th = (struct reiserfs_transaction_handle *)current->journal_info; 2560 struct reiserfs_transaction_handle *th;
2437 BUG_ON (!th->t_refcount); 2561 th = (struct reiserfs_transaction_handle *)current->
2438 BUG_ON (!th->t_trans_id); 2562 journal_info;
2439 old_ref = th->t_refcount; 2563 BUG_ON(!th->t_refcount);
2440 th->t_refcount++; 2564 BUG_ON(!th->t_trans_id);
2441 } 2565 old_ref = th->t_refcount;
2442 2566 th->t_refcount++;
2443 ret = block_prepare_write(page, from, to, reiserfs_get_block) ;
2444 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2445 struct reiserfs_transaction_handle *th = current->journal_info;
2446 /* this gets a little ugly. If reiserfs_get_block returned an
2447 * error and left a transacstion running, we've got to close it,
2448 * and we've got to free handle if it was a persistent transaction.
2449 *
2450 * But, if we had nested into an existing transaction, we need
2451 * to just drop the ref count on the handle.
2452 *
2453 * If old_ref == 0, the transaction is from reiserfs_get_block,
2454 * and it was a persistent trans. Otherwise, it was nested above.
2455 */
2456 if (th->t_refcount > old_ref) {
2457 if (old_ref)
2458 th->t_refcount--;
2459 else {
2460 int err;
2461 reiserfs_write_lock(inode->i_sb);
2462 err = reiserfs_end_persistent_transaction(th);
2463 reiserfs_write_unlock(inode->i_sb);
2464 if (err)
2465 ret = err;
2466 }
2467 } 2567 }
2468 }
2469 return ret;
2470 2568
2471} 2569 ret = block_prepare_write(page, from, to, reiserfs_get_block);
2570 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2571 struct reiserfs_transaction_handle *th = current->journal_info;
2572 /* this gets a little ugly. If reiserfs_get_block returned an
2573 * error and left a transacstion running, we've got to close it,
2574 * and we've got to free handle if it was a persistent transaction.
2575 *
2576 * But, if we had nested into an existing transaction, we need
2577 * to just drop the ref count on the handle.
2578 *
2579 * If old_ref == 0, the transaction is from reiserfs_get_block,
2580 * and it was a persistent trans. Otherwise, it was nested above.
2581 */
2582 if (th->t_refcount > old_ref) {
2583 if (old_ref)
2584 th->t_refcount--;
2585 else {
2586 int err;
2587 reiserfs_write_lock(inode->i_sb);
2588 err = reiserfs_end_persistent_transaction(th);
2589 reiserfs_write_unlock(inode->i_sb);
2590 if (err)
2591 ret = err;
2592 }
2593 }
2594 }
2595 return ret;
2472 2596
2597}
2473 2598
2474static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block) { 2599static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2475 return generic_block_bmap(as, block, reiserfs_bmap) ; 2600{
2601 return generic_block_bmap(as, block, reiserfs_bmap);
2476} 2602}
2477 2603
2478static int reiserfs_commit_write(struct file *f, struct page *page, 2604static int reiserfs_commit_write(struct file *f, struct page *page,
2479 unsigned from, unsigned to) { 2605 unsigned from, unsigned to)
2480 struct inode *inode = page->mapping->host ; 2606{
2481 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 2607 struct inode *inode = page->mapping->host;
2482 int ret = 0; 2608 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2483 int update_sd = 0; 2609 int ret = 0;
2484 struct reiserfs_transaction_handle *th = NULL; 2610 int update_sd = 0;
2485 2611 struct reiserfs_transaction_handle *th = NULL;
2486 reiserfs_wait_on_write_block(inode->i_sb) ; 2612
2487 if (reiserfs_transaction_running(inode->i_sb)) { 2613 reiserfs_wait_on_write_block(inode->i_sb);
2488 th = current->journal_info; 2614 if (reiserfs_transaction_running(inode->i_sb)) {
2489 } 2615 th = current->journal_info;
2490 reiserfs_commit_page(inode, page, from, to); 2616 }
2491 2617 reiserfs_commit_page(inode, page, from, to);
2492 /* generic_commit_write does this for us, but does not update the
2493 ** transaction tracking stuff when the size changes. So, we have
2494 ** to do the i_size updates here.
2495 */
2496 if (pos > inode->i_size) {
2497 struct reiserfs_transaction_handle myth ;
2498 reiserfs_write_lock(inode->i_sb);
2499 /* If the file have grown beyond the border where it
2500 can have a tail, unmark it as needing a tail
2501 packing */
2502 if ( (have_large_tails (inode->i_sb) && inode->i_size > i_block_size (inode)*4) ||
2503 (have_small_tails (inode->i_sb) && inode->i_size > i_block_size(inode)) )
2504 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask ;
2505
2506 ret = journal_begin(&myth, inode->i_sb, 1) ;
2507 if (ret) {
2508 reiserfs_write_unlock(inode->i_sb);
2509 goto journal_error;
2510 }
2511 reiserfs_update_inode_transaction(inode) ;
2512 inode->i_size = pos ;
2513 reiserfs_update_sd(&myth, inode) ;
2514 update_sd = 1;
2515 ret = journal_end(&myth, inode->i_sb, 1) ;
2516 reiserfs_write_unlock(inode->i_sb);
2517 if (ret)
2518 goto journal_error;
2519 }
2520 if (th) {
2521 reiserfs_write_lock(inode->i_sb);
2522 if (!update_sd)
2523 reiserfs_update_sd(th, inode) ;
2524 ret = reiserfs_end_persistent_transaction(th);
2525 reiserfs_write_unlock(inode->i_sb);
2526 if (ret)
2527 goto out;
2528 }
2529
2530 /* we test for O_SYNC here so we can commit the transaction
2531 ** for any packed tails the file might have had
2532 */
2533 if (f && (f->f_flags & O_SYNC)) {
2534 reiserfs_write_lock(inode->i_sb);
2535 ret = reiserfs_commit_for_inode(inode) ;
2536 reiserfs_write_unlock(inode->i_sb);
2537 }
2538out:
2539 return ret ;
2540 2618
2541journal_error: 2619 /* generic_commit_write does this for us, but does not update the
2542 if (th) { 2620 ** transaction tracking stuff when the size changes. So, we have
2543 reiserfs_write_lock(inode->i_sb); 2621 ** to do the i_size updates here.
2544 if (!update_sd) 2622 */
2545 reiserfs_update_sd(th, inode) ; 2623 if (pos > inode->i_size) {
2546 ret = reiserfs_end_persistent_transaction(th); 2624 struct reiserfs_transaction_handle myth;
2547 reiserfs_write_unlock(inode->i_sb); 2625 reiserfs_write_lock(inode->i_sb);
2548 } 2626 /* If the file have grown beyond the border where it
2627 can have a tail, unmark it as needing a tail
2628 packing */
2629 if ((have_large_tails(inode->i_sb)
2630 && inode->i_size > i_block_size(inode) * 4)
2631 || (have_small_tails(inode->i_sb)
2632 && inode->i_size > i_block_size(inode)))
2633 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2634
2635 ret = journal_begin(&myth, inode->i_sb, 1);
2636 if (ret) {
2637 reiserfs_write_unlock(inode->i_sb);
2638 goto journal_error;
2639 }
2640 reiserfs_update_inode_transaction(inode);
2641 inode->i_size = pos;
2642 /*
2643 * this will just nest into our transaction. It's important
2644 * to use mark_inode_dirty so the inode gets pushed around on the
2645 * dirty lists, and so that O_SYNC works as expected
2646 */
2647 mark_inode_dirty(inode);
2648 reiserfs_update_sd(&myth, inode);
2649 update_sd = 1;
2650 ret = journal_end(&myth, inode->i_sb, 1);
2651 reiserfs_write_unlock(inode->i_sb);
2652 if (ret)
2653 goto journal_error;
2654 }
2655 if (th) {
2656 reiserfs_write_lock(inode->i_sb);
2657 if (!update_sd)
2658 mark_inode_dirty(inode);
2659 ret = reiserfs_end_persistent_transaction(th);
2660 reiserfs_write_unlock(inode->i_sb);
2661 if (ret)
2662 goto out;
2663 }
2664
2665 out:
2666 return ret;
2549 2667
2550 return ret; 2668 journal_error:
2669 if (th) {
2670 reiserfs_write_lock(inode->i_sb);
2671 if (!update_sd)
2672 reiserfs_update_sd(th, inode);
2673 ret = reiserfs_end_persistent_transaction(th);
2674 reiserfs_write_unlock(inode->i_sb);
2675 }
2676
2677 return ret;
2551} 2678}
2552 2679
2553void sd_attrs_to_i_attrs( __u16 sd_attrs, struct inode *inode ) 2680void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2554{ 2681{
2555 if( reiserfs_attrs( inode -> i_sb ) ) { 2682 if (reiserfs_attrs(inode->i_sb)) {
2556 if( sd_attrs & REISERFS_SYNC_FL ) 2683 if (sd_attrs & REISERFS_SYNC_FL)
2557 inode -> i_flags |= S_SYNC; 2684 inode->i_flags |= S_SYNC;
2558 else 2685 else
2559 inode -> i_flags &= ~S_SYNC; 2686 inode->i_flags &= ~S_SYNC;
2560 if( sd_attrs & REISERFS_IMMUTABLE_FL ) 2687 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2561 inode -> i_flags |= S_IMMUTABLE; 2688 inode->i_flags |= S_IMMUTABLE;
2562 else 2689 else
2563 inode -> i_flags &= ~S_IMMUTABLE; 2690 inode->i_flags &= ~S_IMMUTABLE;
2564 if( sd_attrs & REISERFS_APPEND_FL ) 2691 if (sd_attrs & REISERFS_APPEND_FL)
2565 inode -> i_flags |= S_APPEND; 2692 inode->i_flags |= S_APPEND;
2566 else 2693 else
2567 inode -> i_flags &= ~S_APPEND; 2694 inode->i_flags &= ~S_APPEND;
2568 if( sd_attrs & REISERFS_NOATIME_FL ) 2695 if (sd_attrs & REISERFS_NOATIME_FL)
2569 inode -> i_flags |= S_NOATIME; 2696 inode->i_flags |= S_NOATIME;
2570 else 2697 else
2571 inode -> i_flags &= ~S_NOATIME; 2698 inode->i_flags &= ~S_NOATIME;
2572 if( sd_attrs & REISERFS_NOTAIL_FL ) 2699 if (sd_attrs & REISERFS_NOTAIL_FL)
2573 REISERFS_I(inode)->i_flags |= i_nopack_mask; 2700 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2574 else 2701 else
2575 REISERFS_I(inode)->i_flags &= ~i_nopack_mask; 2702 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2576 } 2703 }
2577} 2704}
2578 2705
2579void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs ) 2706void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2580{ 2707{
2581 if( reiserfs_attrs( inode -> i_sb ) ) { 2708 if (reiserfs_attrs(inode->i_sb)) {
2582 if( inode -> i_flags & S_IMMUTABLE ) 2709 if (inode->i_flags & S_IMMUTABLE)
2583 *sd_attrs |= REISERFS_IMMUTABLE_FL; 2710 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2584 else 2711 else
2585 *sd_attrs &= ~REISERFS_IMMUTABLE_FL; 2712 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2586 if( inode -> i_flags & S_SYNC ) 2713 if (inode->i_flags & S_SYNC)
2587 *sd_attrs |= REISERFS_SYNC_FL; 2714 *sd_attrs |= REISERFS_SYNC_FL;
2588 else 2715 else
2589 *sd_attrs &= ~REISERFS_SYNC_FL; 2716 *sd_attrs &= ~REISERFS_SYNC_FL;
2590 if( inode -> i_flags & S_NOATIME ) 2717 if (inode->i_flags & S_NOATIME)
2591 *sd_attrs |= REISERFS_NOATIME_FL; 2718 *sd_attrs |= REISERFS_NOATIME_FL;
2592 else 2719 else
2593 *sd_attrs &= ~REISERFS_NOATIME_FL; 2720 *sd_attrs &= ~REISERFS_NOATIME_FL;
2594 if( REISERFS_I(inode)->i_flags & i_nopack_mask ) 2721 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2595 *sd_attrs |= REISERFS_NOTAIL_FL; 2722 *sd_attrs |= REISERFS_NOTAIL_FL;
2596 else 2723 else
2597 *sd_attrs &= ~REISERFS_NOTAIL_FL; 2724 *sd_attrs &= ~REISERFS_NOTAIL_FL;
@@ -2603,106 +2730,107 @@ void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs )
2603*/ 2730*/
2604static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh) 2731static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2605{ 2732{
2606 int ret = 1 ; 2733 int ret = 1;
2607 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb) ; 2734 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2608 2735
2609 spin_lock(&j->j_dirty_buffers_lock) ; 2736 spin_lock(&j->j_dirty_buffers_lock);
2610 if (!buffer_mapped(bh)) { 2737 if (!buffer_mapped(bh)) {
2611 goto free_jh; 2738 goto free_jh;
2612 } 2739 }
2613 /* the page is locked, and the only places that log a data buffer 2740 /* the page is locked, and the only places that log a data buffer
2614 * also lock the page. 2741 * also lock the page.
2615 */
2616 if (reiserfs_file_data_log(inode)) {
2617 /*
2618 * very conservative, leave the buffer pinned if
2619 * anyone might need it.
2620 */
2621 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2622 ret = 0 ;
2623 }
2624 } else
2625 if (buffer_dirty(bh) || buffer_locked(bh)) {
2626 struct reiserfs_journal_list *jl;
2627 struct reiserfs_jh *jh = bh->b_private;
2628
2629 /* why is this safe?
2630 * reiserfs_setattr updates i_size in the on disk
2631 * stat data before allowing vmtruncate to be called.
2632 *
2633 * If buffer was put onto the ordered list for this
2634 * transaction, we know for sure either this transaction
2635 * or an older one already has updated i_size on disk,
2636 * and this ordered data won't be referenced in the file
2637 * if we crash.
2638 *
2639 * if the buffer was put onto the ordered list for an older
2640 * transaction, we need to leave it around
2641 */ 2742 */
2642 if (jh && (jl = jh->jl) && jl != SB_JOURNAL(inode->i_sb)->j_current_jl) 2743 if (reiserfs_file_data_log(inode)) {
2643 ret = 0; 2744 /*
2644 } 2745 * very conservative, leave the buffer pinned if
2645free_jh: 2746 * anyone might need it.
2646 if (ret && bh->b_private) { 2747 */
2647 reiserfs_free_jh(bh); 2748 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2648 } 2749 ret = 0;
2649 spin_unlock(&j->j_dirty_buffers_lock) ; 2750 }
2650 return ret ; 2751 } else if (buffer_dirty(bh) || buffer_locked(bh)) {
2752 struct reiserfs_journal_list *jl;
2753 struct reiserfs_jh *jh = bh->b_private;
2754
2755 /* why is this safe?
2756 * reiserfs_setattr updates i_size in the on disk
2757 * stat data before allowing vmtruncate to be called.
2758 *
2759 * If buffer was put onto the ordered list for this
2760 * transaction, we know for sure either this transaction
2761 * or an older one already has updated i_size on disk,
2762 * and this ordered data won't be referenced in the file
2763 * if we crash.
2764 *
2765 * if the buffer was put onto the ordered list for an older
2766 * transaction, we need to leave it around
2767 */
2768 if (jh && (jl = jh->jl)
2769 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2770 ret = 0;
2771 }
2772 free_jh:
2773 if (ret && bh->b_private) {
2774 reiserfs_free_jh(bh);
2775 }
2776 spin_unlock(&j->j_dirty_buffers_lock);
2777 return ret;
2651} 2778}
2652 2779
2653/* clm -- taken from fs/buffer.c:block_invalidate_page */ 2780/* clm -- taken from fs/buffer.c:block_invalidate_page */
2654static int reiserfs_invalidatepage(struct page *page, unsigned long offset) 2781static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
2655{ 2782{
2656 struct buffer_head *head, *bh, *next; 2783 struct buffer_head *head, *bh, *next;
2657 struct inode *inode = page->mapping->host; 2784 struct inode *inode = page->mapping->host;
2658 unsigned int curr_off = 0; 2785 unsigned int curr_off = 0;
2659 int ret = 1; 2786 int ret = 1;
2660 2787
2661 BUG_ON(!PageLocked(page)); 2788 BUG_ON(!PageLocked(page));
2662 2789
2663 if (offset == 0) 2790 if (offset == 0)
2664 ClearPageChecked(page); 2791 ClearPageChecked(page);
2665 2792
2666 if (!page_has_buffers(page)) 2793 if (!page_has_buffers(page))
2667 goto out; 2794 goto out;
2795
2796 head = page_buffers(page);
2797 bh = head;
2798 do {
2799 unsigned int next_off = curr_off + bh->b_size;
2800 next = bh->b_this_page;
2668 2801
2669 head = page_buffers(page); 2802 /*
2670 bh = head; 2803 * is this block fully invalidated?
2671 do { 2804 */
2672 unsigned int next_off = curr_off + bh->b_size; 2805 if (offset <= curr_off) {
2673 next = bh->b_this_page; 2806 if (invalidatepage_can_drop(inode, bh))
2807 reiserfs_unmap_buffer(bh);
2808 else
2809 ret = 0;
2810 }
2811 curr_off = next_off;
2812 bh = next;
2813 } while (bh != head);
2674 2814
2675 /* 2815 /*
2676 * is this block fully invalidated? 2816 * We release buffers only if the entire page is being invalidated.
2817 * The get_block cached value has been unconditionally invalidated,
2818 * so real IO is not possible anymore.
2677 */ 2819 */
2678 if (offset <= curr_off) { 2820 if (!offset && ret)
2679 if (invalidatepage_can_drop(inode, bh)) 2821 ret = try_to_release_page(page, 0);
2680 reiserfs_unmap_buffer(bh); 2822 out:
2681 else 2823 return ret;
2682 ret = 0;
2683 }
2684 curr_off = next_off;
2685 bh = next;
2686 } while (bh != head);
2687
2688 /*
2689 * We release buffers only if the entire page is being invalidated.
2690 * The get_block cached value has been unconditionally invalidated,
2691 * so real IO is not possible anymore.
2692 */
2693 if (!offset && ret)
2694 ret = try_to_release_page(page, 0);
2695out:
2696 return ret;
2697} 2824}
2698 2825
2699static int reiserfs_set_page_dirty(struct page *page) { 2826static int reiserfs_set_page_dirty(struct page *page)
2700 struct inode *inode = page->mapping->host; 2827{
2701 if (reiserfs_file_data_log(inode)) { 2828 struct inode *inode = page->mapping->host;
2702 SetPageChecked(page); 2829 if (reiserfs_file_data_log(inode)) {
2703 return __set_page_dirty_nobuffers(page); 2830 SetPageChecked(page);
2704 } 2831 return __set_page_dirty_nobuffers(page);
2705 return __set_page_dirty_buffers(page); 2832 }
2833 return __set_page_dirty_buffers(page);
2706} 2834}
2707 2835
2708/* 2836/*
@@ -2716,143 +2844,152 @@ static int reiserfs_set_page_dirty(struct page *page) {
2716 */ 2844 */
2717static int reiserfs_releasepage(struct page *page, int unused_gfp_flags) 2845static int reiserfs_releasepage(struct page *page, int unused_gfp_flags)
2718{ 2846{
2719 struct inode *inode = page->mapping->host ; 2847 struct inode *inode = page->mapping->host;
2720 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb) ; 2848 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2721 struct buffer_head *head ; 2849 struct buffer_head *head;
2722 struct buffer_head *bh ; 2850 struct buffer_head *bh;
2723 int ret = 1 ; 2851 int ret = 1;
2724 2852
2725 WARN_ON(PageChecked(page)); 2853 WARN_ON(PageChecked(page));
2726 spin_lock(&j->j_dirty_buffers_lock) ; 2854 spin_lock(&j->j_dirty_buffers_lock);
2727 head = page_buffers(page) ; 2855 head = page_buffers(page);
2728 bh = head ; 2856 bh = head;
2729 do { 2857 do {
2730 if (bh->b_private) { 2858 if (bh->b_private) {
2731 if (!buffer_dirty(bh) && !buffer_locked(bh)) { 2859 if (!buffer_dirty(bh) && !buffer_locked(bh)) {
2732 reiserfs_free_jh(bh); 2860 reiserfs_free_jh(bh);
2733 } else { 2861 } else {
2734 ret = 0 ; 2862 ret = 0;
2735 break ; 2863 break;
2736 } 2864 }
2737 } 2865 }
2738 bh = bh->b_this_page ; 2866 bh = bh->b_this_page;
2739 } while (bh != head) ; 2867 } while (bh != head);
2740 if (ret) 2868 if (ret)
2741 ret = try_to_free_buffers(page) ; 2869 ret = try_to_free_buffers(page);
2742 spin_unlock(&j->j_dirty_buffers_lock) ; 2870 spin_unlock(&j->j_dirty_buffers_lock);
2743 return ret ; 2871 return ret;
2744} 2872}
2745 2873
2746/* We thank Mingming Cao for helping us understand in great detail what 2874/* We thank Mingming Cao for helping us understand in great detail what
2747 to do in this section of the code. */ 2875 to do in this section of the code. */
2748static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb, 2876static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
2749 const struct iovec *iov, loff_t offset, unsigned long nr_segs) 2877 const struct iovec *iov, loff_t offset,
2878 unsigned long nr_segs)
2750{ 2879{
2751 struct file *file = iocb->ki_filp; 2880 struct file *file = iocb->ki_filp;
2752 struct inode *inode = file->f_mapping->host; 2881 struct inode *inode = file->f_mapping->host;
2753 2882
2754 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 2883 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2755 offset, nr_segs, reiserfs_get_blocks_direct_io, NULL); 2884 offset, nr_segs,
2885 reiserfs_get_blocks_direct_io, NULL);
2756} 2886}
2757 2887
2758int reiserfs_setattr(struct dentry *dentry, struct iattr *attr) { 2888int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
2759 struct inode *inode = dentry->d_inode ; 2889{
2760 int error ; 2890 struct inode *inode = dentry->d_inode;
2761 unsigned int ia_valid = attr->ia_valid; 2891 int error;
2762 reiserfs_write_lock(inode->i_sb); 2892 unsigned int ia_valid = attr->ia_valid;
2763 if (attr->ia_valid & ATTR_SIZE) { 2893 reiserfs_write_lock(inode->i_sb);
2764 /* version 2 items will be caught by the s_maxbytes check 2894 if (attr->ia_valid & ATTR_SIZE) {
2765 ** done for us in vmtruncate 2895 /* version 2 items will be caught by the s_maxbytes check
2766 */ 2896 ** done for us in vmtruncate
2767 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 && 2897 */
2768 attr->ia_size > MAX_NON_LFS) { 2898 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
2769 error = -EFBIG ; 2899 attr->ia_size > MAX_NON_LFS) {
2770 goto out; 2900 error = -EFBIG;
2771 } 2901 goto out;
2772 /* fill in hole pointers in the expanding truncate case. */ 2902 }
2773 if (attr->ia_size > inode->i_size) { 2903 /* fill in hole pointers in the expanding truncate case. */
2774 error = generic_cont_expand(inode, attr->ia_size) ; 2904 if (attr->ia_size > inode->i_size) {
2775 if (REISERFS_I(inode)->i_prealloc_count > 0) { 2905 error = generic_cont_expand(inode, attr->ia_size);
2776 int err; 2906 if (REISERFS_I(inode)->i_prealloc_count > 0) {
2777 struct reiserfs_transaction_handle th ; 2907 int err;
2778 /* we're changing at most 2 bitmaps, inode + super */ 2908 struct reiserfs_transaction_handle th;
2779 err = journal_begin(&th, inode->i_sb, 4) ; 2909 /* we're changing at most 2 bitmaps, inode + super */
2780 if (!err) { 2910 err = journal_begin(&th, inode->i_sb, 4);
2781 reiserfs_discard_prealloc (&th, inode); 2911 if (!err) {
2782 err = journal_end(&th, inode->i_sb, 4) ; 2912 reiserfs_discard_prealloc(&th, inode);
2913 err = journal_end(&th, inode->i_sb, 4);
2914 }
2915 if (err)
2916 error = err;
2917 }
2918 if (error)
2919 goto out;
2783 } 2920 }
2784 if (err)
2785 error = err;
2786 }
2787 if (error)
2788 goto out;
2789 } 2921 }
2790 }
2791 2922
2792 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) || 2923 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
2793 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) && 2924 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
2794 (get_inode_sd_version (inode) == STAT_DATA_V1)) { 2925 (get_inode_sd_version(inode) == STAT_DATA_V1)) {
2795 /* stat data of format v3.5 has 16 bit uid and gid */ 2926 /* stat data of format v3.5 has 16 bit uid and gid */
2796 error = -EINVAL; 2927 error = -EINVAL;
2797 goto out; 2928 goto out;
2798 } 2929 }
2799
2800 error = inode_change_ok(inode, attr) ;
2801 if (!error) {
2802 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2803 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2804 error = reiserfs_chown_xattrs (inode, attr);
2805
2806 if (!error) {
2807 struct reiserfs_transaction_handle th;
2808 int jbegin_count = 2*(REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)+REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb))+2;
2809
2810 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2811 error = journal_begin(&th, inode->i_sb, jbegin_count);
2812 if (error)
2813 goto out;
2814 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2815 if (error) {
2816 journal_end(&th, inode->i_sb, jbegin_count);
2817 goto out;
2818 }
2819 /* Update corresponding info in inode so that everything is in
2820 * one transaction */
2821 if (attr->ia_valid & ATTR_UID)
2822 inode->i_uid = attr->ia_uid;
2823 if (attr->ia_valid & ATTR_GID)
2824 inode->i_gid = attr->ia_gid;
2825 mark_inode_dirty(inode);
2826 error = journal_end(&th, inode->i_sb, jbegin_count);
2827 }
2828 }
2829 if (!error)
2830 error = inode_setattr(inode, attr) ;
2831 }
2832 2930
2931 error = inode_change_ok(inode, attr);
2932 if (!error) {
2933 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2934 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2935 error = reiserfs_chown_xattrs(inode, attr);
2936
2937 if (!error) {
2938 struct reiserfs_transaction_handle th;
2939 int jbegin_count =
2940 2 *
2941 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
2942 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
2943 2;
2944
2945 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2946 error =
2947 journal_begin(&th, inode->i_sb,
2948 jbegin_count);
2949 if (error)
2950 goto out;
2951 error =
2952 DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2953 if (error) {
2954 journal_end(&th, inode->i_sb,
2955 jbegin_count);
2956 goto out;
2957 }
2958 /* Update corresponding info in inode so that everything is in
2959 * one transaction */
2960 if (attr->ia_valid & ATTR_UID)
2961 inode->i_uid = attr->ia_uid;
2962 if (attr->ia_valid & ATTR_GID)
2963 inode->i_gid = attr->ia_gid;
2964 mark_inode_dirty(inode);
2965 error =
2966 journal_end(&th, inode->i_sb, jbegin_count);
2967 }
2968 }
2969 if (!error)
2970 error = inode_setattr(inode, attr);
2971 }
2833 2972
2834 if (!error && reiserfs_posixacl (inode->i_sb)) { 2973 if (!error && reiserfs_posixacl(inode->i_sb)) {
2835 if (attr->ia_valid & ATTR_MODE) 2974 if (attr->ia_valid & ATTR_MODE)
2836 error = reiserfs_acl_chmod (inode); 2975 error = reiserfs_acl_chmod(inode);
2837 } 2976 }
2838 2977
2839out: 2978 out:
2840 reiserfs_write_unlock(inode->i_sb); 2979 reiserfs_write_unlock(inode->i_sb);
2841 return error ; 2980 return error;
2842} 2981}
2843 2982
2844
2845
2846struct address_space_operations reiserfs_address_space_operations = { 2983struct address_space_operations reiserfs_address_space_operations = {
2847 .writepage = reiserfs_writepage, 2984 .writepage = reiserfs_writepage,
2848 .readpage = reiserfs_readpage, 2985 .readpage = reiserfs_readpage,
2849 .readpages = reiserfs_readpages, 2986 .readpages = reiserfs_readpages,
2850 .releasepage = reiserfs_releasepage, 2987 .releasepage = reiserfs_releasepage,
2851 .invalidatepage = reiserfs_invalidatepage, 2988 .invalidatepage = reiserfs_invalidatepage,
2852 .sync_page = block_sync_page, 2989 .sync_page = block_sync_page,
2853 .prepare_write = reiserfs_prepare_write, 2990 .prepare_write = reiserfs_prepare_write,
2854 .commit_write = reiserfs_commit_write, 2991 .commit_write = reiserfs_commit_write,
2855 .bmap = reiserfs_aop_bmap, 2992 .bmap = reiserfs_aop_bmap,
2856 .direct_IO = reiserfs_direct_IO, 2993 .direct_IO = reiserfs_direct_IO,
2857 .set_page_dirty = reiserfs_set_page_dirty, 2994 .set_page_dirty = reiserfs_set_page_dirty,
2858} ; 2995};
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-05 04:23:24 -0500