projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
udf: support files larger than 1G
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / udf / inode.c
CommitLineData
1da177e4
LT		 1/*
2 * inode.c
3 *
4 * PURPOSE
5 * Inode handling routines for the OSTA-UDF(tm) filesystem.
6 *
1da177e4
LT		 7 * COPYRIGHT
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
12 *
13 * (C) 1998 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
16 *
17 * HISTORY
18 *
19 * 10/04/98 dgb Added rudimentary directory functions
20 * 10/07/98 Fully working udf_block_map! It works!
21 * 11/25/98 bmap altered to better support extents
22 * 12/06/98 blf partition support in udf_iget, udf_block_map and udf_read_inode
23 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
24 * block boundaries (which is not actually allowed)
25 * 12/20/98 added support for strategy 4096
26 * 03/07/99 rewrote udf_block_map (again)
27 * New funcs, inode_bmap, udf_next_aext
28 * 04/19/99 Support for writing device EA's for major/minor #
29 */
30
31#include "udfdecl.h"
32#include <linux/mm.h>
33#include <linux/smp_lock.h>
34#include <linux/module.h>
35#include <linux/pagemap.h>
36#include <linux/buffer_head.h>
37#include <linux/writeback.h>
38#include <linux/slab.h>
39
40#include "udf_i.h"
41#include "udf_sb.h"
42
43MODULE_AUTHOR("Ben Fennema");
44MODULE_DESCRIPTION("Universal Disk Format Filesystem");
45MODULE_LICENSE("GPL");
46
47#define EXTENT_MERGE_SIZE 5
48
49static mode_t udf_convert_permissions(struct fileEntry *);
50static int udf_update_inode(struct inode *, int);
51static void udf_fill_inode(struct inode *, struct buffer_head *);
60448b1d 52static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
1da177e4 53 long *, int *);
ff116fc8
JK		 54static int8_t udf_insert_aext(struct inode *, struct extent_position,
55 kernel_lb_addr, uint32_t);
1da177e4
LT		 56static void udf_split_extents(struct inode *, int *, int, int,
57 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
58static void udf_prealloc_extents(struct inode *, int, int,
59 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
60static void udf_merge_extents(struct inode *,
61 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
62static void udf_update_extents(struct inode *,
63 kernel_long_ad [EXTENT_MERGE_SIZE], int, int,
ff116fc8 64 struct extent_position *);
1da177e4
LT		 65static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
66
67/*
68 * udf_delete_inode
69 *
70 * PURPOSE
71 * Clean-up before the specified inode is destroyed.
72 *
73 * DESCRIPTION
74 * This routine is called when the kernel destroys an inode structure
75 * ie. when iput() finds i_count == 0.
76 *
77 * HISTORY
78 * July 1, 1997 - Andrew E. Mileski
79 * Written, tested, and released.
80 *
81 * Called at the last iput() if i_nlink is zero.
82 */
83void udf_delete_inode(struct inode * inode)
84{
fef26658
MF		 85 truncate_inode_pages(&inode->i_data, 0);
86
1da177e4
LT		 87 if (is_bad_inode(inode))
88 goto no_delete;
89
90 inode->i_size = 0;
91 udf_truncate(inode);
92 lock_kernel();
93
94 udf_update_inode(inode, IS_SYNC(inode));
95 udf_free_inode(inode);
96
97 unlock_kernel();
98 return;
99no_delete:
100 clear_inode(inode);
101}
102
103void udf_clear_inode(struct inode *inode)
104{
105 if (!(inode->i_sb->s_flags & MS_RDONLY)) {
106 lock_kernel();
107 udf_discard_prealloc(inode);
108 unlock_kernel();
109 }
110
111 kfree(UDF_I_DATA(inode));
112 UDF_I_DATA(inode) = NULL;
113}
114
115static int udf_writepage(struct page *page, struct writeback_control *wbc)
116{
117 return block_write_full_page(page, udf_get_block, wbc);
118}
119
120static int udf_readpage(struct file *file, struct page *page)
121{
122 return block_read_full_page(page, udf_get_block);
123}
124
125static int udf_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
126{
127 return block_prepare_write(page, from, to, udf_get_block);
128}
129
130static sector_t udf_bmap(struct address_space *mapping, sector_t block)
131{
132 return generic_block_bmap(mapping,block,udf_get_block);
133}
134
f5e54d6e 135const struct address_space_operations udf_aops = {
1da177e4
LT		 136 .readpage = udf_readpage,
137 .writepage = udf_writepage,
138 .sync_page = block_sync_page,
139 .prepare_write = udf_prepare_write,
140 .commit_write = generic_commit_write,
141 .bmap = udf_bmap,
142};
143
144void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
145{
146 struct page *page;
147 char *kaddr;
148 struct writeback_control udf_wbc = {
149 .sync_mode = WB_SYNC_NONE,
150 .nr_to_write = 1,
151 };
152
153 /* from now on we have normal address_space methods */
154 inode->i_data.a_ops = &udf_aops;
155
156 if (!UDF_I_LENALLOC(inode))
157 {
158 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
159 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
160 else
161 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
162 mark_inode_dirty(inode);
163 return;
164 }
165
166 page = grab_cache_page(inode->i_mapping, 0);
cd7619d6
MM		 167 BUG_ON(!PageLocked(page));
168
1da177e4
LT		 169 if (!PageUptodate(page))
170 {
171 kaddr = kmap(page);
172 memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
173 PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
174 memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode),
175 UDF_I_LENALLOC(inode));
176 flush_dcache_page(page);
177 SetPageUptodate(page);
178 kunmap(page);
179 }
180 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0x00,
181 UDF_I_LENALLOC(inode));
182 UDF_I_LENALLOC(inode) = 0;
183 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
184 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
185 else
186 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
187
188 inode->i_data.a_ops->writepage(page, &udf_wbc);
189 page_cache_release(page);
190
191 mark_inode_dirty(inode);
192}
193
194struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err)
195{
196 int newblock;
ff116fc8
JK		 197 struct buffer_head *dbh = NULL;
198 kernel_lb_addr eloc;
199 uint32_t elen;
1da177e4 200 uint8_t alloctype;
ff116fc8 201 struct extent_position epos;
1da177e4
LT		 202
203 struct udf_fileident_bh sfibh, dfibh;
204 loff_t f_pos = udf_ext0_offset(inode) >> 2;
205 int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
206 struct fileIdentDesc cfi, *sfi, *dfi;
207
208 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
209 alloctype = ICBTAG_FLAG_AD_SHORT;
210 else
211 alloctype = ICBTAG_FLAG_AD_LONG;
212
213 if (!inode->i_size)
214 {
215 UDF_I_ALLOCTYPE(inode) = alloctype;
216 mark_inode_dirty(inode);
217 return NULL;
218 }
219
220 /* alloc block, and copy data to it */
221 *block = udf_new_block(inode->i_sb, inode,
222 UDF_I_LOCATION(inode).partitionReferenceNum,
223 UDF_I_LOCATION(inode).logicalBlockNum, err);
224
225 if (!(*block))
226 return NULL;
227 newblock = udf_get_pblock(inode->i_sb, *block,
228 UDF_I_LOCATION(inode).partitionReferenceNum, 0);
229 if (!newblock)
230 return NULL;
231 dbh = udf_tgetblk(inode->i_sb, newblock);
232 if (!dbh)
233 return NULL;
234 lock_buffer(dbh);
235 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
236 set_buffer_uptodate(dbh);
237 unlock_buffer(dbh);
238 mark_buffer_dirty_inode(dbh, inode);
239
240 sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
ff116fc8 241 sfibh.sbh = sfibh.ebh = NULL;
1da177e4
LT		 242 dfibh.soffset = dfibh.eoffset = 0;
243 dfibh.sbh = dfibh.ebh = dbh;
244 while ( (f_pos < size) )
245 {
246 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
ff116fc8 247 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
1da177e4
LT		 248 if (!sfi)
249 {
3bf25cb4 250 brelse(dbh);
1da177e4
LT		 251 return NULL;
252 }
253 UDF_I_ALLOCTYPE(inode) = alloctype;
254 sfi->descTag.tagLocation = cpu_to_le32(*block);
255 dfibh.soffset = dfibh.eoffset;
256 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
257 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
258 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
259 sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse)))
260 {
261 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
3bf25cb4 262 brelse(dbh);
1da177e4
LT		 263 return NULL;
264 }
265 }
266 mark_buffer_dirty_inode(dbh, inode);
267
268 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
269 UDF_I_LENALLOC(inode) = 0;
1da177e4
LT		 270 eloc.logicalBlockNum = *block;
271 eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
272 elen = inode->i_size;
273 UDF_I_LENEXTENTS(inode) = elen;
ff116fc8
JK		 274 epos.bh = NULL;
275 epos.block = UDF_I_LOCATION(inode);
276 epos.offset = udf_file_entry_alloc_offset(inode);
277 udf_add_aext(inode, &epos, eloc, elen, 0);
1da177e4
LT		 278 /* UniqueID stuff */
279
3bf25cb4 280 brelse(epos.bh);
1da177e4
LT		 281 mark_inode_dirty(inode);
282 return dbh;
283}
284
285static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create)
286{
287 int err, new;
288 struct buffer_head *bh;
289 unsigned long phys;
290
291 if (!create)
292 {
293 phys = udf_block_map(inode, block);
294 if (phys)
295 map_bh(bh_result, inode->i_sb, phys);
296 return 0;
297 }
298
299 err = -EIO;
300 new = 0;
301 bh = NULL;
302
303 lock_kernel();
304
305 if (block < 0)
306 goto abort_negative;
307
308 if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1)
309 {
310 UDF_I_NEXT_ALLOC_BLOCK(inode) ++;
311 UDF_I_NEXT_ALLOC_GOAL(inode) ++;
312 }
313
314 err = 0;
315
316 bh = inode_getblk(inode, block, &err, &phys, &new);
2c2111c2 317 BUG_ON(bh);
1da177e4
LT		 318 if (err)
319 goto abort;
2c2111c2 320 BUG_ON(!phys);
1da177e4
LT		 321
322 if (new)
323 set_buffer_new(bh_result);
324 map_bh(bh_result, inode->i_sb, phys);
325abort:
326 unlock_kernel();
327 return err;
328
329abort_negative:
330 udf_warning(inode->i_sb, "udf_get_block", "block < 0");
331 goto abort;
332}
333
334static struct buffer_head *
335udf_getblk(struct inode *inode, long block, int create, int *err)
336{
337 struct buffer_head dummy;
338
339 dummy.b_state = 0;
340 dummy.b_blocknr = -1000;
341 *err = udf_get_block(inode, block, &dummy, create);
342 if (!*err && buffer_mapped(&dummy))
343 {
344 struct buffer_head *bh;
345 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
346 if (buffer_new(&dummy))
347 {
348 lock_buffer(bh);
349 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
350 set_buffer_uptodate(bh);
351 unlock_buffer(bh);
352 mark_buffer_dirty_inode(bh, inode);
353 }
354 return bh;
355 }
356 return NULL;
357}
358
31170b6a
JK		 359/* Extend the file by 'blocks' blocks, return the number of extents added */
360int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
361 kernel_long_ad *last_ext, sector_t blocks)
362{
363 sector_t add;
364 int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
365 struct super_block *sb = inode->i_sb;
366 kernel_lb_addr prealloc_loc = {0, 0};
367 int prealloc_len = 0;
368
369 /* The previous extent is fake and we should not extend by anything
370 * - there's nothing to do... */
371 if (!blocks && fake)
372 return 0;
373 /* Round the last extent up to a multiple of block size */
374 if (last_ext->extLength & (sb->s_blocksize - 1)) {
375 last_ext->extLength =
376 (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
377 (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
378 sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
379 UDF_I_LENEXTENTS(inode) =
380 (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
381 ~(sb->s_blocksize - 1);
382 }
383 /* Last extent are just preallocated blocks? */
384 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) {
385 /* Save the extent so that we can reattach it to the end */
386 prealloc_loc = last_ext->extLocation;
387 prealloc_len = last_ext->extLength;
388 /* Mark the extent as a hole */
389 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
390 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
391 last_ext->extLocation.logicalBlockNum = 0;
392 last_ext->extLocation.partitionReferenceNum = 0;
393 }
394 /* Can we merge with the previous extent? */
395 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) {
396 add = ((1<<30) - sb->s_blocksize - (last_ext->extLength &
397 UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits;
398 if (add > blocks)
399 add = blocks;
400 blocks -= add;
401 last_ext->extLength += add << sb->s_blocksize_bits;
402 }
403
404 if (fake) {
405 udf_add_aext(inode, last_pos, last_ext->extLocation,
406 last_ext->extLength, 1);
407 count++;
408 }
409 else
410 udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1);
411 /* Managed to do everything necessary? */
412 if (!blocks)
413 goto out;
414
415 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
416 last_ext->extLocation.logicalBlockNum = 0;
417 last_ext->extLocation.partitionReferenceNum = 0;
418 add = (1 << (30-sb->s_blocksize_bits)) - 1;
419 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
420 /* Create enough extents to cover the whole hole */
421 while (blocks > add) {
422 blocks -= add;
423 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
424 last_ext->extLength, 1) == -1)
425 return -1;
426 count++;
427 }
428 if (blocks) {
429 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
430 (blocks << sb->s_blocksize_bits);
431 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
432 last_ext->extLength, 1) == -1)
433 return -1;
434 count++;
435 }
436out:
437 /* Do we have some preallocated blocks saved? */
438 if (prealloc_len) {
439 if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1)
440 return -1;
441 last_ext->extLocation = prealloc_loc;
442 last_ext->extLength = prealloc_len;
443 count++;
444 }
445 /* last_pos should point to the last written extent... */
446 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
447 last_pos->offset -= sizeof(short_ad);
448 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
449 last_pos->offset -= sizeof(long_ad);
450 else
451 return -1;
452 return count;
453}
454
60448b1d 455static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
1da177e4
LT		 456 int *err, long *phys, int *new)
457{
31170b6a 458 static sector_t last_block;
ff116fc8 459 struct buffer_head *result = NULL;
1da177e4 460 kernel_long_ad laarr[EXTENT_MERGE_SIZE];
ff116fc8 461 struct extent_position prev_epos, cur_epos, next_epos;
1da177e4
LT		 462 int count = 0, startnum = 0, endnum = 0;
463 uint32_t elen = 0;
ff116fc8 464 kernel_lb_addr eloc;
1da177e4 465 int c = 1;
60448b1d
JK		 466 loff_t lbcount = 0, b_off = 0;
467 uint32_t newblocknum, newblock;
468 sector_t offset = 0;
1da177e4
LT		 469 int8_t etype;
470 int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
31170b6a 471 int lastblock = 0;
1da177e4 472
ff116fc8
JK		 473 prev_epos.offset = udf_file_entry_alloc_offset(inode);
474 prev_epos.block = UDF_I_LOCATION(inode);
475 prev_epos.bh = NULL;
476 cur_epos = next_epos = prev_epos;
60448b1d 477 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
1da177e4
LT		 478
479 /* find the extent which contains the block we are looking for.
480 alternate between laarr[0] and laarr[1] for locations of the
481 current extent, and the previous extent */
482 do
483 {
ff116fc8 484 if (prev_epos.bh != cur_epos.bh)
1da177e4 485 {
3bf25cb4
JK		 486 brelse(prev_epos.bh);
487 get_bh(cur_epos.bh);
ff116fc8 488 prev_epos.bh = cur_epos.bh;
1da177e4 489 }
ff116fc8 490 if (cur_epos.bh != next_epos.bh)
1da177e4 491 {
3bf25cb4
JK		 492 brelse(cur_epos.bh);
493 get_bh(next_epos.bh);
ff116fc8 494 cur_epos.bh = next_epos.bh;
1da177e4
LT		 495 }
496
497 lbcount += elen;
498
ff116fc8
JK		 499 prev_epos.block = cur_epos.block;
500 cur_epos.block = next_epos.block;
1da177e4 501
ff116fc8
JK		 502 prev_epos.offset = cur_epos.offset;
503 cur_epos.offset = next_epos.offset;
1da177e4 504
ff116fc8 505 if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
1da177e4
LT		 506 break;
507
508 c = !c;
509
510 laarr[c].extLength = (etype << 30) | elen;
511 laarr[c].extLocation = eloc;
512
513 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
514 pgoal = eloc.logicalBlockNum +
515 ((elen + inode->i_sb->s_blocksize - 1) >>
516 inode->i_sb->s_blocksize_bits);
517
518 count ++;
519 } while (lbcount + elen <= b_off);
520
521 b_off -= lbcount;
522 offset = b_off >> inode->i_sb->s_blocksize_bits;
31170b6a
JK		 523 /* Move into indirect extent if we are at a pointer to it */
524 udf_next_aext(inode, &prev_epos, &eloc, &elen, 0);
1da177e4
LT		 525
526 /* if the extent is allocated and recorded, return the block
527 if the extent is not a multiple of the blocksize, round up */
528
529 if (etype == (EXT_RECORDED_ALLOCATED >> 30))
530 {
531 if (elen & (inode->i_sb->s_blocksize - 1))
532 {
533 elen = EXT_RECORDED_ALLOCATED |
534 ((elen + inode->i_sb->s_blocksize - 1) &
535 ~(inode->i_sb->s_blocksize - 1));
ff116fc8 536 etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
1da177e4 537 }
3bf25cb4
JK		 538 brelse(prev_epos.bh);
539 brelse(cur_epos.bh);
540 brelse(next_epos.bh);
1da177e4
LT		 541 newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
542 *phys = newblock;
543 return NULL;
544 }
545
31170b6a
JK		 546 last_block = block;
547 /* Are we beyond EOF? */
1da177e4
LT		 548 if (etype == -1)
549 {
31170b6a
JK		 550 int ret;
551
552 if (count) {
553 if (c)
554 laarr[0] = laarr[1];
555 startnum = 1;
1da177e4 556 }
31170b6a
JK		 557 else {
558 /* Create a fake extent when there's not one */
559 memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
560 laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
561 /* Will udf_extend_file() create real extent from a fake one? */
562 startnum = (offset > 0);
563 }
564 /* Create extents for the hole between EOF and offset */
565 ret = udf_extend_file(inode, &prev_epos, laarr, offset);
566 if (ret == -1) {
567 brelse(prev_epos.bh);
568 brelse(cur_epos.bh);
569 brelse(next_epos.bh);
570 /* We don't really know the error here so we just make
571 * something up */
572 *err = -ENOSPC;
573 return NULL;
574 }
575 c = 0;
576 offset = 0;
577 count += ret;
578 /* We are not covered by a preallocated extent? */
579 if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
580 /* Is there any real extent? - otherwise we overwrite
581 * the fake one... */
582 if (count)
583 c = !c;
584 laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
585 inode->i_sb->s_blocksize;
586 memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
587 count ++;
588 endnum ++;
589 }
590 endnum = c+1;
1da177e4
LT		 591 lastblock = 1;
592 }
31170b6a 593 else {
1da177e4
LT		 594 endnum = startnum = ((count > 2) ? 2 : count);
595
31170b6a
JK		 596 /* if the current extent is in position 0, swap it with the previous */
597 if (!c && count != 1)
598 {
599 laarr[2] = laarr[0];
600 laarr[0] = laarr[1];
601 laarr[1] = laarr[2];
602 c = 1;
603 }
1da177e4 604
31170b6a 605 /* if the current block is located in an extent, read the next extent */
ff116fc8 606 if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1)
1da177e4
LT		 607 {
608 laarr[c+1].extLength = (etype << 30) | elen;
609 laarr[c+1].extLocation = eloc;
610 count ++;
611 startnum ++;
612 endnum ++;
613 }
31170b6a 614 else {
1da177e4 615 lastblock = 1;
31170b6a 616 }
1da177e4 617 }
1da177e4
LT		 618
619 /* if the current extent is not recorded but allocated, get the
620 block in the extent corresponding to the requested block */
621 if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
622 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
623 else /* otherwise, allocate a new block */
624 {
625 if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
626 goal = UDF_I_NEXT_ALLOC_GOAL(inode);
627
628 if (!goal)
629 {
630 if (!(goal = pgoal))
631 goal = UDF_I_LOCATION(inode).logicalBlockNum + 1;
632 }
633
634 if (!(newblocknum = udf_new_block(inode->i_sb, inode,
635 UDF_I_LOCATION(inode).partitionReferenceNum, goal, err)))
636 {
3bf25cb4 637 brelse(prev_epos.bh);
1da177e4
LT		 638 *err = -ENOSPC;
639 return NULL;
640 }
641 UDF_I_LENEXTENTS(inode) += inode->i_sb->s_blocksize;
642 }
643
644 /* if the extent the requsted block is located in contains multiple blocks,
645 split the extent into at most three extents. blocks prior to requested
646 block, requested block, and blocks after requested block */
647 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
648
649#ifdef UDF_PREALLOCATE
650 /* preallocate blocks */
651 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
652#endif
653
654 /* merge any continuous blocks in laarr */
655 udf_merge_extents(inode, laarr, &endnum);
656
657 /* write back the new extents, inserting new extents if the new number
31170b6a
JK		 658 of extents is greater than the old number, and deleting extents if
659 the new number of extents is less than the old number */
ff116fc8 660 udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
1da177e4 661
3bf25cb4 662 brelse(prev_epos.bh);
1da177e4
LT		 663
664 if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
665 UDF_I_LOCATION(inode).partitionReferenceNum, 0)))
666 {
667 return NULL;
668 }
669 *phys = newblock;
670 *err = 0;
671 *new = 1;
672 UDF_I_NEXT_ALLOC_BLOCK(inode) = block;
673 UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum;
674 inode->i_ctime = current_fs_time(inode->i_sb);
675
676 if (IS_SYNC(inode))
677 udf_sync_inode(inode);
678 else
679 mark_inode_dirty(inode);
680 return result;
681}
682
683static void udf_split_extents(struct inode *inode, int *c, int offset, int newblocknum,
684 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
685{
686 if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
687 (laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
688 {
689 int curr = *c;
690 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
691 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
692 int8_t etype = (laarr[curr].extLength >> 30);
693
694 if (blen == 1)
695 ;
696 else if (!offset || blen == offset + 1)
697 {
698 laarr[curr+2] = laarr[curr+1];
699 laarr[curr+1] = laarr[curr];
700 }
701 else
702 {
703 laarr[curr+3] = laarr[curr+1];
704 laarr[curr+2] = laarr[curr+1] = laarr[curr];
705 }
706
707 if (offset)
708 {
709 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
710 {
711 udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset);
712 laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
713 (offset << inode->i_sb->s_blocksize_bits);
714 laarr[curr].extLocation.logicalBlockNum = 0;
715 laarr[curr].extLocation.partitionReferenceNum = 0;
716 }
717 else
718 laarr[curr].extLength = (etype << 30) |
719 (offset << inode->i_sb->s_blocksize_bits);
720 curr ++;
721 (*c) ++;
722 (*endnum) ++;
723 }
724
725 laarr[curr].extLocation.logicalBlockNum = newblocknum;
726 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
727 laarr[curr].extLocation.partitionReferenceNum =
728 UDF_I_LOCATION(inode).partitionReferenceNum;
729 laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
730 inode->i_sb->s_blocksize;
731 curr ++;
732
733 if (blen != offset + 1)
734 {
735 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
736 laarr[curr].extLocation.logicalBlockNum += (offset + 1);
737 laarr[curr].extLength = (etype << 30) |
738 ((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits);
739 curr ++;
740 (*endnum) ++;
741 }
742 }
743}
744
745static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
746 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
747{
748 int start, length = 0, currlength = 0, i;
749
750 if (*endnum >= (c+1))
751 {
752 if (!lastblock)
753 return;
754 else
755 start = c;
756 }
757 else
758 {
759 if ((laarr[c+1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
760 {
761 start = c+1;
762 length = currlength = (((laarr[c+1].extLength & UDF_EXTENT_LENGTH_MASK) +
763 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
764 }
765 else
766 start = c;
767 }
768
769 for (i=start+1; i<=*endnum; i++)
770 {
771 if (i == *endnum)
772 {
773 if (lastblock)
774 length += UDF_DEFAULT_PREALLOC_BLOCKS;
775 }
776 else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
777 length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
778 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
779 else
780 break;
781 }
782
783 if (length)
784 {
785 int next = laarr[start].extLocation.logicalBlockNum +
786 (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
787 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
788 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
789 laarr[start].extLocation.partitionReferenceNum,
790 next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length :
791 UDF_DEFAULT_PREALLOC_BLOCKS) - currlength);
792
793 if (numalloc)
794 {
795 if (start == (c+1))
796 laarr[start].extLength +=
797 (numalloc << inode->i_sb->s_blocksize_bits);
798 else
799 {
800 memmove(&laarr[c+2], &laarr[c+1],
801 sizeof(long_ad) * (*endnum - (c+1)));
802 (*endnum) ++;
803 laarr[c+1].extLocation.logicalBlockNum = next;
804 laarr[c+1].extLocation.partitionReferenceNum =
805 laarr[c].extLocation.partitionReferenceNum;
806 laarr[c+1].extLength = EXT_NOT_RECORDED_ALLOCATED |
807 (numalloc << inode->i_sb->s_blocksize_bits);
808 start = c+1;
809 }
810
811 for (i=start+1; numalloc && i<*endnum; i++)
812 {
813 int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
814 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
815
816 if (elen > numalloc)
817 {
818 laarr[i].extLength -=
819 (numalloc << inode->i_sb->s_blocksize_bits);
820 numalloc = 0;
821 }
822 else
823 {
824 numalloc -= elen;
825 if (*endnum > (i+1))
826 memmove(&laarr[i], &laarr[i+1],
827 sizeof(long_ad) * (*endnum - (i+1)));
828 i --;
829 (*endnum) --;
830 }
831 }
832 UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits;
833 }
834 }
835}
836
837static void udf_merge_extents(struct inode *inode,
838 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
839{
840 int i;
841
842 for (i=0; i<(*endnum-1); i++)
843 {
844 if ((laarr[i].extLength >> 30) == (laarr[i+1].extLength >> 30))
845 {
846 if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
847 ((laarr[i+1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) ==
848 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
849 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits)))
850 {
851 if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
852 (laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) +
853 inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK)
854 {
855 laarr[i+1].extLength = (laarr[i+1].extLength -
856 (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
857 UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1);
858 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
859 (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
860 laarr[i+1].extLocation.logicalBlockNum =
861 laarr[i].extLocation.logicalBlockNum +
862 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >>
863 inode->i_sb->s_blocksize_bits);
864 }
865 else
866 {
867 laarr[i].extLength = laarr[i+1].extLength +
868 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
869 inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1));
870 if (*endnum > (i+2))
871 memmove(&laarr[i+1], &laarr[i+2],
872 sizeof(long_ad) * (*endnum - (i+2)));
873 i --;
874 (*endnum) --;
875 }
876 }
877 }
878 else if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
879 ((laarr[i+1].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)))
880 {
881 udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
882 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
883 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
884 laarr[i].extLocation.logicalBlockNum = 0;
885 laarr[i].extLocation.partitionReferenceNum = 0;
886
887 if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
888 (laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) +
889 inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK)
890 {
891 laarr[i+1].extLength = (laarr[i+1].extLength -
892 (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
893 UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1);
894 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
895 (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
896 }
897 else
898 {
899 laarr[i].extLength = laarr[i+1].extLength +
900 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
901 inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1));
902 if (*endnum > (i+2))
903 memmove(&laarr[i+1], &laarr[i+2],
904 sizeof(long_ad) * (*endnum - (i+2)));
905 i --;
906 (*endnum) --;
907 }
908 }
909 else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
910 {
911 udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
912 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
913 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
914 laarr[i].extLocation.logicalBlockNum = 0;
915 laarr[i].extLocation.partitionReferenceNum = 0;
916 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) |
917 EXT_NOT_RECORDED_NOT_ALLOCATED;
918 }
919 }
920}
921
922static void udf_update_extents(struct inode *inode,
923 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum,
ff116fc8 924 struct extent_position *epos)
1da177e4
LT		 925{
926 int start = 0, i;
927 kernel_lb_addr tmploc;
928 uint32_t tmplen;
929
930 if (startnum > endnum)
931 {
932 for (i=0; i<(startnum-endnum); i++)
ff116fc8
JK		 933 udf_delete_aext(inode, *epos, laarr[i].extLocation,
934 laarr[i].extLength);
1da177e4
LT		 935 }
936 else if (startnum < endnum)
937 {
938 for (i=0; i<(endnum-startnum); i++)
939 {
ff116fc8
JK		 940 udf_insert_aext(inode, *epos, laarr[i].extLocation,
941 laarr[i].extLength);
942 udf_next_aext(inode, epos, &laarr[i].extLocation,
943 &laarr[i].extLength, 1);
1da177e4
LT		 944 start ++;
945 }
946 }
947
948 for (i=start; i<endnum; i++)
949 {
ff116fc8
JK		 950 udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
951 udf_write_aext(inode, epos, laarr[i].extLocation,
952 laarr[i].extLength, 1);
1da177e4
LT		 953 }
954}
955
956struct buffer_head * udf_bread(struct inode * inode, int block,
957 int create, int * err)
958{
959 struct buffer_head * bh = NULL;
960
961 bh = udf_getblk(inode, block, create, err);
962 if (!bh)
963 return NULL;
964
965 if (buffer_uptodate(bh))
966 return bh;
967 ll_rw_block(READ, 1, &bh);
968 wait_on_buffer(bh);
969 if (buffer_uptodate(bh))
970 return bh;
971 brelse(bh);
972 *err = -EIO;
973 return NULL;
974}
975
976void udf_truncate(struct inode * inode)
977{
978 int offset;
979 int err;
980
981 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
982 S_ISLNK(inode->i_mode)))
983 return;
984 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
985 return;
986
987 lock_kernel();
988 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
989 {
990 if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
991 inode->i_size))
992 {
993 udf_expand_file_adinicb(inode, inode->i_size, &err);
994 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
995 {
996 inode->i_size = UDF_I_LENALLOC(inode);
997 unlock_kernel();
998 return;
999 }
1000 else
1001 udf_truncate_extents(inode);
1002 }
1003 else
1004 {
1005 offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
1006 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset, 0x00, inode->i_sb->s_blocksize - offset - udf_file_entry_alloc_offset(inode));
1007 UDF_I_LENALLOC(inode) = inode->i_size;
1008 }
1009 }
1010 else
1011 {
1012 block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
1013 udf_truncate_extents(inode);
1014 }
1015
1016 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
1017 if (IS_SYNC(inode))
1018 udf_sync_inode (inode);
1019 else
1020 mark_inode_dirty(inode);
1021 unlock_kernel();
1022}
1023
1024static void
1025__udf_read_inode(struct inode *inode)
1026{
1027 struct buffer_head *bh = NULL;
1028 struct fileEntry *fe;
1029 uint16_t ident;
1030
1031 /*
1032 * Set defaults, but the inode is still incomplete!
1033 * Note: get_new_inode() sets the following on a new inode:
1034 * i_sb = sb
1035 * i_no = ino
1036 * i_flags = sb->s_flags
1037 * i_state = 0
1038 * clean_inode(): zero fills and sets
1039 * i_count = 1
1040 * i_nlink = 1
1041 * i_op = NULL;
1042 */
1da177e4
LT		 1043 bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
1044
1045 if (!bh)
1046 {
1047 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
1048 inode->i_ino);
1049 make_bad_inode(inode);
1050 return;
1051 }
1052
1053 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1054 ident != TAG_IDENT_USE)
1055 {
1056 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
1057 inode->i_ino, ident);
3bf25cb4 1058 brelse(bh);
1da177e4
LT		 1059 make_bad_inode(inode);
1060 return;
1061 }
1062
1063 fe = (struct fileEntry *)bh->b_data;
1064
1065 if (le16_to_cpu(fe->icbTag.strategyType) == 4096)
1066 {
1067 struct buffer_head *ibh = NULL, *nbh = NULL;
1068 struct indirectEntry *ie;
1069
1070 ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
1071 if (ident == TAG_IDENT_IE)
1072 {
1073 if (ibh)
1074 {
1075 kernel_lb_addr loc;
1076 ie = (struct indirectEntry *)ibh->b_data;
1077
1078 loc = lelb_to_cpu(ie->indirectICB.extLocation);
1079
1080 if (ie->indirectICB.extLength &&
1081 (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident)))
1082 {
1083 if (ident == TAG_IDENT_FE ||
1084 ident == TAG_IDENT_EFE)
1085 {
1086 memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr));
3bf25cb4
JK		 1087 brelse(bh);
1088 brelse(ibh);
1089 brelse(nbh);
1da177e4
LT		 1090 __udf_read_inode(inode);
1091 return;
1092 }
1093 else
1094 {
3bf25cb4
JK		 1095 brelse(nbh);
1096 brelse(ibh);
1da177e4
LT		 1097 }
1098 }
1099 else
3bf25cb4 1100 brelse(ibh);
1da177e4
LT		 1101 }
1102 }
1103 else
3bf25cb4 1104 brelse(ibh);
1da177e4
LT		 1105 }
1106 else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
1107 {
1108 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
1109 le16_to_cpu(fe->icbTag.strategyType));
3bf25cb4 1110 brelse(bh);
1da177e4
LT		 1111 make_bad_inode(inode);
1112 return;
1113 }
1114 udf_fill_inode(inode, bh);
31170b6a 1115
3bf25cb4 1116 brelse(bh);
1da177e4
LT		 1117}
1118
1119static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
1120{
1121 struct fileEntry *fe;
1122 struct extendedFileEntry *efe;
1123 time_t convtime;
1124 long convtime_usec;
1125 int offset;
1126
1127 fe = (struct fileEntry *)bh->b_data;
1128 efe = (struct extendedFileEntry *)bh->b_data;
1129
1130 if (le16_to_cpu(fe->icbTag.strategyType) == 4)
1131 UDF_I_STRAT4096(inode) = 0;
1132 else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
1133 UDF_I_STRAT4096(inode) = 1;
1134
1135 UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
1136 UDF_I_UNIQUE(inode) = 0;
1137 UDF_I_LENEATTR(inode) = 0;
1138 UDF_I_LENEXTENTS(inode) = 0;
1139 UDF_I_LENALLOC(inode) = 0;
1140 UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
1141 UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
1142 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE)
1143 {
1144 UDF_I_EFE(inode) = 1;
1145 UDF_I_USE(inode) = 0;
1146 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
1147 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1148 }
1149 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE)
1150 {
1151 UDF_I_EFE(inode) = 0;
1152 UDF_I_USE(inode) = 0;
1153 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
1154 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1155 }
1156 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1157 {
1158 UDF_I_EFE(inode) = 0;
1159 UDF_I_USE(inode) = 1;
1160 UDF_I_LENALLOC(inode) =
1161 le32_to_cpu(
1162 ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
1163 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry), GFP_KERNEL);
1164 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1165 return;
1166 }
1167
1168 inode->i_uid = le32_to_cpu(fe->uid);
4d6660eb
PS		 1169 if (inode->i_uid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1170 UDF_FLAG_UID_IGNORE))
1171 inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
1da177e4
LT		 1172
1173 inode->i_gid = le32_to_cpu(fe->gid);
4d6660eb
PS		 1174 if (inode->i_gid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1175 UDF_FLAG_GID_IGNORE))
1176 inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
1da177e4
LT		 1177
1178 inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
1179 if (!inode->i_nlink)
1180 inode->i_nlink = 1;
1181
1182 inode->i_size = le64_to_cpu(fe->informationLength);
1183 UDF_I_LENEXTENTS(inode) = inode->i_size;
1184
1185 inode->i_mode = udf_convert_permissions(fe);
1186 inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
1187
1188 if (UDF_I_EFE(inode) == 0)
1189 {
1190 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1191 (inode->i_sb->s_blocksize_bits - 9);
1192
1193 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1194 lets_to_cpu(fe->accessTime)) )
1195 {
1196 inode->i_atime.tv_sec = convtime;
1197 inode->i_atime.tv_nsec = convtime_usec * 1000;
1198 }
1199 else
1200 {
1201 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1202 }
1203
1204 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1205 lets_to_cpu(fe->modificationTime)) )
1206 {
1207 inode->i_mtime.tv_sec = convtime;
1208 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1209 }
1210 else
1211 {
1212 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1213 }
1214
1215 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1216 lets_to_cpu(fe->attrTime)) )
1217 {
1218 inode->i_ctime.tv_sec = convtime;
1219 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1220 }
1221 else
1222 {
1223 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1224 }
1225
1226 UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
1227 UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
1228 UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
1229 offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
1230 }
1231 else
1232 {
1233 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1234 (inode->i_sb->s_blocksize_bits - 9);
1235
1236 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1237 lets_to_cpu(efe->accessTime)) )
1238 {
1239 inode->i_atime.tv_sec = convtime;
1240 inode->i_atime.tv_nsec = convtime_usec * 1000;
1241 }
1242 else
1243 {
1244 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1245 }
1246
1247 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1248 lets_to_cpu(efe->modificationTime)) )
1249 {
1250 inode->i_mtime.tv_sec = convtime;
1251 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1252 }
1253 else
1254 {
1255 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1256 }
1257
1258 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1259 lets_to_cpu(efe->createTime)) )
1260 {
1261 UDF_I_CRTIME(inode).tv_sec = convtime;
1262 UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
1263 }
1264 else
1265 {
1266 UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
1267 }
1268
1269 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1270 lets_to_cpu(efe->attrTime)) )
1271 {
1272 inode->i_ctime.tv_sec = convtime;
1273 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1274 }
1275 else
1276 {
1277 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1278 }
1279
1280 UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
1281 UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
1282 UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
1283 offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
1284 }
1285
1286 switch (fe->icbTag.fileType)
1287 {
1288 case ICBTAG_FILE_TYPE_DIRECTORY:
1289 {
1290 inode->i_op = &udf_dir_inode_operations;
1291 inode->i_fop = &udf_dir_operations;
1292 inode->i_mode |= S_IFDIR;
d8c76e6f 1293 inc_nlink(inode);
1da177e4
LT		 1294 break;
1295 }
1296 case ICBTAG_FILE_TYPE_REALTIME:
1297 case ICBTAG_FILE_TYPE_REGULAR:
1298 case ICBTAG_FILE_TYPE_UNDEF:
1299 {
1300 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1301 inode->i_data.a_ops = &udf_adinicb_aops;
1302 else
1303 inode->i_data.a_ops = &udf_aops;
1304 inode->i_op = &udf_file_inode_operations;
1305 inode->i_fop = &udf_file_operations;
1306 inode->i_mode |= S_IFREG;
1307 break;
1308 }
1309 case ICBTAG_FILE_TYPE_BLOCK:
1310 {
1311 inode->i_mode |= S_IFBLK;
1312 break;
1313 }
1314 case ICBTAG_FILE_TYPE_CHAR:
1315 {
1316 inode->i_mode |= S_IFCHR;
1317 break;
1318 }
1319 case ICBTAG_FILE_TYPE_FIFO:
1320 {
1321 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1322 break;
1323 }
1324 case ICBTAG_FILE_TYPE_SOCKET:
1325 {
1326 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1327 break;
1328 }
1329 case ICBTAG_FILE_TYPE_SYMLINK:
1330 {
1331 inode->i_data.a_ops = &udf_symlink_aops;
1332 inode->i_op = &page_symlink_inode_operations;
1333 inode->i_mode = S_IFLNK|S_IRWXUGO;
1334 break;
1335 }
1336 default:
1337 {
1338 printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
1339 inode->i_ino, fe->icbTag.fileType);
1340 make_bad_inode(inode);
1341 return;
1342 }
1343 }
1344 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1345 {
1346 struct deviceSpec *dsea =
1347 (struct deviceSpec *)
1348 udf_get_extendedattr(inode, 12, 1);
1349
1350 if (dsea)
1351 {
1352 init_special_inode(inode, inode->i_mode, MKDEV(
1353 le32_to_cpu(dsea->majorDeviceIdent),
1354 le32_to_cpu(dsea->minorDeviceIdent)));
1355 /* Developer ID ??? */
1356 }
1357 else
1358 {
1359 make_bad_inode(inode);
1360 }
1361 }
1362}
1363
1364static mode_t
1365udf_convert_permissions(struct fileEntry *fe)
1366{
1367 mode_t mode;
1368 uint32_t permissions;
1369 uint32_t flags;
1370
1371 permissions = le32_to_cpu(fe->permissions);
1372 flags = le16_to_cpu(fe->icbTag.flags);
1373
1374 mode = (( permissions ) & S_IRWXO) |
1375 (( permissions >> 2 ) & S_IRWXG) |
1376 (( permissions >> 4 ) & S_IRWXU) |
1377 (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
1378 (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
1379 (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
1380
1381 return mode;
1382}
1383
1384/*
1385 * udf_write_inode
1386 *
1387 * PURPOSE
1388 * Write out the specified inode.
1389 *
1390 * DESCRIPTION
1391 * This routine is called whenever an inode is synced.
1392 * Currently this routine is just a placeholder.
1393 *
1394 * HISTORY
1395 * July 1, 1997 - Andrew E. Mileski
1396 * Written, tested, and released.
1397 */
1398
1399int udf_write_inode(struct inode * inode, int sync)
1400{
1401 int ret;
1402 lock_kernel();
1403 ret = udf_update_inode(inode, sync);
1404 unlock_kernel();
1405 return ret;
1406}
1407
1408int udf_sync_inode(struct inode * inode)
1409{
1410 return udf_update_inode(inode, 1);
1411}
1412
1413static int
1414udf_update_inode(struct inode *inode, int do_sync)
1415{
1416 struct buffer_head *bh = NULL;
1417 struct fileEntry *fe;
1418 struct extendedFileEntry *efe;
1419 uint32_t udfperms;
1420 uint16_t icbflags;
1421 uint16_t crclen;
1422 int i;
1423 kernel_timestamp cpu_time;
1424 int err = 0;
1425
1426 bh = udf_tread(inode->i_sb,
1427 udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
1428
1429 if (!bh)
1430 {
1431 udf_debug("bread failure\n");
1432 return -EIO;
1433 }
1434
1435 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
1436
1437 fe = (struct fileEntry *)bh->b_data;
1438 efe = (struct extendedFileEntry *)bh->b_data;
1439
1440 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1441 {
1442 struct unallocSpaceEntry *use =
1443 (struct unallocSpaceEntry *)bh->b_data;
1444
1445 use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1446 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1447 crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
1448 sizeof(tag);
1449 use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1450 use->descTag.descCRCLength = cpu_to_le16(crclen);
1451 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
1452
1453 use->descTag.tagChecksum = 0;
1454 for (i=0; i<16; i++)
1455 if (i != 4)
1456 use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
1457
1458 mark_buffer_dirty(bh);
3bf25cb4 1459 brelse(bh);
1da177e4
LT		 1460 return err;
1461 }
1462
4d6660eb
PS		 1463 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1464 fe->uid = cpu_to_le32(-1);
0e6b3e5e 1465 else fe->uid = cpu_to_le32(inode->i_uid);
1da177e4 1466
4d6660eb
PS		 1467 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1468 fe->gid = cpu_to_le32(-1);
0e6b3e5e 1469 else fe->gid = cpu_to_le32(inode->i_gid);
1da177e4
LT		 1470
1471 udfperms = ((inode->i_mode & S_IRWXO) ) |
1472 ((inode->i_mode & S_IRWXG) << 2) |
1473 ((inode->i_mode & S_IRWXU) << 4);
1474
1475 udfperms |= (le32_to_cpu(fe->permissions) &
1476 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
1477 FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
1478 FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
1479 fe->permissions = cpu_to_le32(udfperms);
1480
1481 if (S_ISDIR(inode->i_mode))
1482 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1483 else
1484 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1485
1486 fe->informationLength = cpu_to_le64(inode->i_size);
1487
1488 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1489 {
1490 regid *eid;
1491 struct deviceSpec *dsea =
1492 (struct deviceSpec *)
1493 udf_get_extendedattr(inode, 12, 1);
1494
1495 if (!dsea)
1496 {
1497 dsea = (struct deviceSpec *)
1498 udf_add_extendedattr(inode,
1499 sizeof(struct deviceSpec) +
1500 sizeof(regid), 12, 0x3);
1501 dsea->attrType = cpu_to_le32(12);
1502 dsea->attrSubtype = 1;
1503 dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) +
1504 sizeof(regid));
1505 dsea->impUseLength = cpu_to_le32(sizeof(regid));
1506 }
1507 eid = (regid *)dsea->impUse;
1508 memset(eid, 0, sizeof(regid));
1509 strcpy(eid->ident, UDF_ID_DEVELOPER);
1510 eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
1511 eid->identSuffix[1] = UDF_OS_ID_LINUX;
1512 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1513 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1514 }
1515
1516 if (UDF_I_EFE(inode) == 0)
1517 {
1518 memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1519 fe->logicalBlocksRecorded = cpu_to_le64(
1520 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1521 (inode->i_sb->s_blocksize_bits - 9));
1522
1523 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1524 fe->accessTime = cpu_to_lets(cpu_time);
1525 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1526 fe->modificationTime = cpu_to_lets(cpu_time);
1527 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1528 fe->attrTime = cpu_to_lets(cpu_time);
1529 memset(&(fe->impIdent), 0, sizeof(regid));
1530 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
1531 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1532 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1533 fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1534 fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1535 fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1536 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
1537 crclen = sizeof(struct fileEntry);
1538 }
1539 else
1540 {
1541 memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1542 efe->objectSize = cpu_to_le64(inode->i_size);
1543 efe->logicalBlocksRecorded = cpu_to_le64(
1544 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1545 (inode->i_sb->s_blocksize_bits - 9));
1546
1547 if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
1548 (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
1549 UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec))
1550 {
1551 UDF_I_CRTIME(inode) = inode->i_atime;
1552 }
1553 if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
1554 (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
1555 UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec))
1556 {
1557 UDF_I_CRTIME(inode) = inode->i_mtime;
1558 }
1559 if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
1560 (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
1561 UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec))
1562 {
1563 UDF_I_CRTIME(inode) = inode->i_ctime;
1564 }
1565
1566 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1567 efe->accessTime = cpu_to_lets(cpu_time);
1568 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1569 efe->modificationTime = cpu_to_lets(cpu_time);
1570 if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode)))
1571 efe->createTime = cpu_to_lets(cpu_time);
1572 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1573 efe->attrTime = cpu_to_lets(cpu_time);
1574
1575 memset(&(efe->impIdent), 0, sizeof(regid));
1576 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
1577 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1578 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1579 efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1580 efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1581 efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1582 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
1583 crclen = sizeof(struct extendedFileEntry);
1584 }
1585 if (UDF_I_STRAT4096(inode))
1586 {
1587 fe->icbTag.strategyType = cpu_to_le16(4096);
1588 fe->icbTag.strategyParameter = cpu_to_le16(1);
1589 fe->icbTag.numEntries = cpu_to_le16(2);
1590 }
1591 else
1592 {
1593 fe->icbTag.strategyType = cpu_to_le16(4);
1594 fe->icbTag.numEntries = cpu_to_le16(1);
1595 }
1596
1597 if (S_ISDIR(inode->i_mode))
1598 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
1599 else if (S_ISREG(inode->i_mode))
1600 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
1601 else if (S_ISLNK(inode->i_mode))
1602 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
1603 else if (S_ISBLK(inode->i_mode))
1604 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
1605 else if (S_ISCHR(inode->i_mode))
1606 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
1607 else if (S_ISFIFO(inode->i_mode))
1608 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
1609 else if (S_ISSOCK(inode->i_mode))
1610 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
1611
1612 icbflags = UDF_I_ALLOCTYPE(inode) |
1613 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1614 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1615 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1616 (le16_to_cpu(fe->icbTag.flags) &
1617 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
1618 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
1619
1620 fe->icbTag.flags = cpu_to_le16(icbflags);
1621 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1622 fe->descTag.descVersion = cpu_to_le16(3);
1623 else
1624 fe->descTag.descVersion = cpu_to_le16(2);
1625 fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
1626 fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1627 crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
1628 fe->descTag.descCRCLength = cpu_to_le16(crclen);
1629 fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
1630
1631 fe->descTag.tagChecksum = 0;
1632 for (i=0; i<16; i++)
1633 if (i != 4)
1634 fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
1635
1636 /* write the data blocks */
1637 mark_buffer_dirty(bh);
1638 if (do_sync)
1639 {
1640 sync_dirty_buffer(bh);
1641 if (buffer_req(bh) && !buffer_uptodate(bh))
1642 {
1643 printk("IO error syncing udf inode [%s:%08lx]\n",
1644 inode->i_sb->s_id, inode->i_ino);
1645 err = -EIO;
1646 }
1647 }
3bf25cb4 1648 brelse(bh);
1da177e4
LT		 1649 return err;
1650}
1651
1652struct inode *
1653udf_iget(struct super_block *sb, kernel_lb_addr ino)
1654{
1655 unsigned long block = udf_get_lb_pblock(sb, ino, 0);
1656 struct inode *inode = iget_locked(sb, block);
1657
1658 if (!inode)
1659 return NULL;
1660
1661 if (inode->i_state & I_NEW) {
1662 memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr));
1663 __udf_read_inode(inode);
1664 unlock_new_inode(inode);
1665 }
1666
1667 if (is_bad_inode(inode))
1668 goto out_iput;
1669
1670 if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
1671 udf_debug("block=%d, partition=%d out of range\n",
1672 ino.logicalBlockNum, ino.partitionReferenceNum);
1673 make_bad_inode(inode);
1674 goto out_iput;
1675 }
1676
1677 return inode;
1678
1679 out_iput:
1680 iput(inode);
1681 return NULL;
1682}
1683
ff116fc8
JK		 1684int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
1685 kernel_lb_addr eloc, uint32_t elen, int inc)
1da177e4
LT		 1686{
1687 int adsize;
1688 short_ad *sad = NULL;
1689 long_ad *lad = NULL;
1690 struct allocExtDesc *aed;
1691 int8_t etype;
1692 uint8_t *ptr;
1693
ff116fc8
JK		 1694 if (!epos->bh)
1695 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1da177e4 1696 else
ff116fc8 1697 ptr = epos->bh->b_data + epos->offset;
1da177e4
LT		 1698
1699 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
1700 adsize = sizeof(short_ad);
1701 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
1702 adsize = sizeof(long_ad);
1703 else
1704 return -1;
1705
ff116fc8 1706 if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize)
1da177e4
LT		 1707 {
1708 char *sptr, *dptr;
1709 struct buffer_head *nbh;
1710 int err, loffset;
ff116fc8 1711 kernel_lb_addr obloc = epos->block;
1da177e4 1712
ff116fc8 1713 if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
1da177e4
LT		 1714 obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
1715 {
1716 return -1;
1717 }
1718 if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
ff116fc8 1719 epos->block, 0))))
1da177e4
LT		 1720 {
1721 return -1;
1722 }
1723 lock_buffer(nbh);
1724 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
1725 set_buffer_uptodate(nbh);
1726 unlock_buffer(nbh);
1727 mark_buffer_dirty_inode(nbh, inode);
1728
1729 aed = (struct allocExtDesc *)(nbh->b_data);
1730 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
1731 aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
ff116fc8 1732 if (epos->offset + adsize > inode->i_sb->s_blocksize)
1da177e4 1733 {
ff116fc8 1734 loffset = epos->offset;
1da177e4
LT		 1735 aed->lengthAllocDescs = cpu_to_le32(adsize);
1736 sptr = ptr - adsize;
1737 dptr = nbh->b_data + sizeof(struct allocExtDesc);
1738 memcpy(dptr, sptr, adsize);
ff116fc8 1739 epos->offset = sizeof(struct allocExtDesc) + adsize;
1da177e4
LT		 1740 }
1741 else
1742 {
ff116fc8 1743 loffset = epos->offset + adsize;
1da177e4
LT		 1744 aed->lengthAllocDescs = cpu_to_le32(0);
1745 sptr = ptr;
ff116fc8 1746 epos->offset = sizeof(struct allocExtDesc);
1da177e4 1747
ff116fc8 1748 if (epos->bh)
1da177e4 1749 {
ff116fc8 1750 aed = (struct allocExtDesc *)epos->bh->b_data;
1da177e4
LT		 1751 aed->lengthAllocDescs =
1752 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1753 }
1754 else
1755 {
1756 UDF_I_LENALLOC(inode) += adsize;
1757 mark_inode_dirty(inode);
1758 }
1759 }
1760 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1761 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
ff116fc8 1762 epos->block.logicalBlockNum, sizeof(tag));
1da177e4
LT		 1763 else
1764 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
ff116fc8 1765 epos->block.logicalBlockNum, sizeof(tag));
1da177e4
LT		 1766 switch (UDF_I_ALLOCTYPE(inode))
1767 {
1768 case ICBTAG_FLAG_AD_SHORT:
1769 {
1770 sad = (short_ad *)sptr;
1771 sad->extLength = cpu_to_le32(
1772 EXT_NEXT_EXTENT_ALLOCDECS |
1773 inode->i_sb->s_blocksize);
ff116fc8 1774 sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
1da177e4
LT		 1775 break;
1776 }
1777 case ICBTAG_FLAG_AD_LONG:
1778 {
1779 lad = (long_ad *)sptr;
1780 lad->extLength = cpu_to_le32(
1781 EXT_NEXT_EXTENT_ALLOCDECS |
1782 inode->i_sb->s_blocksize);
ff116fc8 1783 lad->extLocation = cpu_to_lelb(epos->block);
1da177e4
LT		 1784 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1785 break;
1786 }
1787 }
ff116fc8 1788 if (epos->bh)
1da177e4
LT		 1789 {
1790 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
ff116fc8 1791 udf_update_tag(epos->bh->b_data, loffset);
1da177e4 1792 else
ff116fc8
JK		 1793 udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
1794 mark_buffer_dirty_inode(epos->bh, inode);
3bf25cb4 1795 brelse(epos->bh);
1da177e4
LT		 1796 }
1797 else
1798 mark_inode_dirty(inode);
ff116fc8 1799 epos->bh = nbh;
1da177e4
LT		 1800 }
1801
ff116fc8 1802 etype = udf_write_aext(inode, epos, eloc, elen, inc);
1da177e4 1803
ff116fc8 1804 if (!epos->bh)
1da177e4
LT		 1805 {
1806 UDF_I_LENALLOC(inode) += adsize;
1807 mark_inode_dirty(inode);
1808 }
1809 else
1810 {
ff116fc8 1811 aed = (struct allocExtDesc *)epos->bh->b_data;
1da177e4
LT		 1812 aed->lengthAllocDescs =
1813 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1814 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
ff116fc8 1815 udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
1da177e4 1816 else
ff116fc8
JK		 1817 udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
1818 mark_buffer_dirty_inode(epos->bh, inode);
1da177e4
LT		 1819 }
1820
1821 return etype;
1822}
1823
ff116fc8
JK		 1824int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
1825 kernel_lb_addr eloc, uint32_t elen, int inc)
1da177e4
LT		 1826{
1827 int adsize;
1828 uint8_t *ptr;
1829
ff116fc8
JK		 1830 if (!epos->bh)
1831 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1da177e4 1832 else
ff116fc8 1833 ptr = epos->bh->b_data + epos->offset;
1da177e4
LT		 1834
1835 switch (UDF_I_ALLOCTYPE(inode))
1836 {
1837 case ICBTAG_FLAG_AD_SHORT:
1838 {
1839 short_ad *sad = (short_ad *)ptr;
1840 sad->extLength = cpu_to_le32(elen);
1841 sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
1842 adsize = sizeof(short_ad);
1843 break;
1844 }
1845 case ICBTAG_FLAG_AD_LONG:
1846 {
1847 long_ad *lad = (long_ad *)ptr;
1848 lad->extLength = cpu_to_le32(elen);
1849 lad->extLocation = cpu_to_lelb(eloc);
1850 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1851 adsize = sizeof(long_ad);
1852 break;
1853 }
1854 default:
1855 return -1;
1856 }
1857
ff116fc8 1858 if (epos->bh)
1da177e4
LT		 1859 {
1860 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1861 {
ff116fc8
JK		 1862 struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
1863 udf_update_tag(epos->bh->b_data,
1da177e4
LT		 1864 le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
1865 }
ff116fc8 1866 mark_buffer_dirty_inode(epos->bh, inode);
1da177e4
LT		 1867 }
1868 else
1869 mark_inode_dirty(inode);
1870
1871 if (inc)
ff116fc8 1872 epos->offset += adsize;
1da177e4
LT		 1873 return (elen >> 30);
1874}
1875
ff116fc8
JK		 1876int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
1877 kernel_lb_addr *eloc, uint32_t *elen, int inc)
1da177e4
LT		 1878{
1879 int8_t etype;
1880
ff116fc8 1881 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
1da177e4
LT		 1882 (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
1883 {
ff116fc8
JK		 1884 epos->block = *eloc;
1885 epos->offset = sizeof(struct allocExtDesc);
3bf25cb4 1886 brelse(epos->bh);
ff116fc8 1887 if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0))))
1da177e4
LT		 1888 {
1889 udf_debug("reading block %d failed!\n",
ff116fc8 1890 udf_get_lb_pblock(inode->i_sb, epos->block, 0));
1da177e4
LT		 1891 return -1;
1892 }
1893 }
1894
1895 return etype;
1896}
1897
ff116fc8
JK		 1898int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
1899 kernel_lb_addr *eloc, uint32_t *elen, int inc)
1da177e4
LT		 1900{
1901 int alen;
1902 int8_t etype;
1903 uint8_t *ptr;
1904
ff116fc8 1905 if (!epos->bh)
1da177e4 1906 {
ff116fc8
JK		 1907 if (!epos->offset)
1908 epos->offset = udf_file_entry_alloc_offset(inode);
1909 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1da177e4
LT		 1910 alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
1911 }
1912 else
1913 {
ff116fc8
JK		 1914 if (!epos->offset)
1915 epos->offset = sizeof(struct allocExtDesc);
1916 ptr = epos->bh->b_data + epos->offset;
1917 alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
1da177e4
LT		 1918 }
1919
1920 switch (UDF_I_ALLOCTYPE(inode))
1921 {
1922 case ICBTAG_FLAG_AD_SHORT:
1923 {
1924 short_ad *sad;
1925
ff116fc8 1926 if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
1da177e4
LT		 1927 return -1;
1928
1929 etype = le32_to_cpu(sad->extLength) >> 30;
1930 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
1931 eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
1932 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
1933 break;
1934 }
1935 case ICBTAG_FLAG_AD_LONG:
1936 {
1937 long_ad *lad;
1938
ff116fc8 1939 if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
1da177e4
LT		 1940 return -1;
1941
1942 etype = le32_to_cpu(lad->extLength) >> 30;
1943 *eloc = lelb_to_cpu(lad->extLocation);
1944 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
1945 break;
1946 }
1947 default:
1948 {
1949 udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode));
1950 return -1;
1951 }
1952 }
1953
1954 return etype;
1955}
1956
1957static int8_t
ff116fc8
JK		 1958udf_insert_aext(struct inode *inode, struct extent_position epos,
1959 kernel_lb_addr neloc, uint32_t nelen)
1da177e4
LT		 1960{
1961 kernel_lb_addr oeloc;
1962 uint32_t oelen;
1963 int8_t etype;
1964
ff116fc8 1965 if (epos.bh)
3bf25cb4 1966 get_bh(epos.bh);
1da177e4 1967
ff116fc8 1968 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1)
1da177e4 1969 {
ff116fc8 1970 udf_write_aext(inode, &epos, neloc, nelen, 1);
1da177e4
LT		 1971
1972 neloc = oeloc;
1973 nelen = (etype << 30) | oelen;
1974 }
ff116fc8 1975 udf_add_aext(inode, &epos, neloc, nelen, 1);
3bf25cb4 1976 brelse(epos.bh);
1da177e4
LT		 1977 return (nelen >> 30);
1978}
1979
ff116fc8
JK		 1980int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
1981 kernel_lb_addr eloc, uint32_t elen)
1da177e4 1982{
ff116fc8
JK		 1983 struct extent_position oepos;
1984 int adsize;
1da177e4
LT		 1985 int8_t etype;
1986 struct allocExtDesc *aed;
1987
ff116fc8 1988 if (epos.bh)
1da177e4 1989 {
3bf25cb4
JK		 1990 get_bh(epos.bh);
1991 get_bh(epos.bh);
1da177e4
LT		 1992 }
1993
1994 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
1995 adsize = sizeof(short_ad);
1996 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
1997 adsize = sizeof(long_ad);
1998 else
1999 adsize = 0;
2000
ff116fc8
JK		 2001 oepos = epos;
2002 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
1da177e4
LT		 2003 return -1;
2004
ff116fc8 2005 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
1da177e4 2006 {
ff116fc8
JK		 2007 udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
2008 if (oepos.bh != epos.bh)
1da177e4 2009 {
ff116fc8 2010 oepos.block = epos.block;
3bf25cb4
JK		 2011 brelse(oepos.bh);
2012 get_bh(epos.bh);
ff116fc8
JK		 2013 oepos.bh = epos.bh;
2014 oepos.offset = epos.offset - adsize;
1da177e4
LT		 2015 }
2016 }
2017 memset(&eloc, 0x00, sizeof(kernel_lb_addr));
2018 elen = 0;
2019
ff116fc8 2020 if (epos.bh != oepos.bh)
1da177e4 2021 {
ff116fc8
JK		 2022 udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
2023 udf_write_aext(inode, &oepos, eloc, elen, 1);
2024 udf_write_aext(inode, &oepos, eloc, elen, 1);
2025 if (!oepos.bh)
1da177e4
LT		 2026 {
2027 UDF_I_LENALLOC(inode) -= (adsize * 2);
2028 mark_inode_dirty(inode);
2029 }
2030 else
2031 {
ff116fc8 2032 aed = (struct allocExtDesc *)oepos.bh->b_data;
1da177e4
LT		 2033 aed->lengthAllocDescs =
2034 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize));
2035 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
ff116fc8 2036 udf_update_tag(oepos.bh->b_data, oepos.offset - (2*adsize));
1da177e4 2037 else
ff116fc8
JK		 2038 udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
2039 mark_buffer_dirty_inode(oepos.bh, inode);
1da177e4
LT		 2040 }
2041 }
2042 else
2043 {
ff116fc8
JK		 2044 udf_write_aext(inode, &oepos, eloc, elen, 1);
2045 if (!oepos.bh)
1da177e4
LT		 2046 {
2047 UDF_I_LENALLOC(inode) -= adsize;
2048 mark_inode_dirty(inode);
2049 }
2050 else
2051 {
ff116fc8 2052 aed = (struct allocExtDesc *)oepos.bh->b_data;
1da177e4
LT		 2053 aed->lengthAllocDescs =
2054 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
2055 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
ff116fc8 2056 udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
1da177e4 2057 else
ff116fc8
JK		 2058 udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
2059 mark_buffer_dirty_inode(oepos.bh, inode);
1da177e4
LT		 2060 }
2061 }
2062
3bf25cb4
JK		 2063 brelse(epos.bh);
2064 brelse(oepos.bh);
1da177e4
LT		 2065 return (elen >> 30);
2066}
2067
ff116fc8
JK		 2068int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *pos,
2069 kernel_lb_addr *eloc, uint32_t *elen, sector_t *offset)
1da177e4 2070{
60448b1d 2071 loff_t lbcount = 0, bcount = (loff_t)block << inode->i_sb->s_blocksize_bits;
1da177e4
LT		 2072 int8_t etype;
2073
2074 if (block < 0)
2075 {
2076 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
2077 return -1;
2078 }
1da177e4 2079
ff116fc8
JK		 2080 pos->offset = 0;
2081 pos->block = UDF_I_LOCATION(inode);
2082 pos->bh = NULL;
1da177e4 2083 *elen = 0;
1da177e4
LT		 2084
2085 do
2086 {
ff116fc8 2087 if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1)
1da177e4 2088 {
60448b1d 2089 *offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
1da177e4
LT		 2090 UDF_I_LENEXTENTS(inode) = lbcount;
2091 return -1;
2092 }
2093 lbcount += *elen;
2094 } while (lbcount <= bcount);
2095
60448b1d 2096 *offset = (bcount + *elen - lbcount) >> inode->i_sb->s_blocksize_bits;
1da177e4
LT		 2097
2098 return etype;
2099}
2100
60448b1d 2101long udf_block_map(struct inode *inode, sector_t block)
1da177e4 2102{
ff116fc8
JK		 2103 kernel_lb_addr eloc;
2104 uint32_t elen;
60448b1d 2105 sector_t offset;
ff116fc8 2106 struct extent_position epos = { NULL, 0, { 0, 0}};
1da177e4
LT		 2107 int ret;
2108
2109 lock_kernel();
2110
ff116fc8 2111 if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
60448b1d 2112 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
1da177e4
LT		 2113 else
2114 ret = 0;
2115
2116 unlock_kernel();
3bf25cb4 2117 brelse(epos.bh);
1da177e4
LT		 2118
2119 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
2120 return udf_fixed_to_variable(ret);
2121 else
2122 return ret;
2123}
kernel source for telekom puls (alcatel/mediatek)