5 * Inode handling routines for the OSTA-UDF(tm) filesystem.
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.
13 * (C) 1998 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
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
24 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
25 * block boundaries (which is not actually allowed)
26 * 12/20/98 added support for strategy 4096
27 * 03/07/99 rewrote udf_block_map (again)
28 * New funcs, inode_bmap, udf_next_aext
29 * 04/19/99 Support for writing device EA's for major/minor #
34 #include <linux/smp_lock.h>
35 #include <linux/module.h>
36 #include <linux/pagemap.h>
37 #include <linux/buffer_head.h>
38 #include <linux/writeback.h>
39 #include <linux/slab.h>
40 #include <linux/crc-itu-t.h>
45 MODULE_AUTHOR("Ben Fennema");
46 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
47 MODULE_LICENSE("GPL");
49 #define EXTENT_MERGE_SIZE 5
51 static mode_t
udf_convert_permissions(struct fileEntry
*);
52 static int udf_update_inode(struct inode
*, int);
53 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
54 static int udf_sync_inode(struct inode
*inode
);
55 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
56 static struct buffer_head
*inode_getblk(struct inode
*, sector_t
, int *,
58 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
59 struct kernel_lb_addr
, uint32_t);
60 static void udf_split_extents(struct inode
*, int *, int, int,
61 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
62 static void udf_prealloc_extents(struct inode
*, int, int,
63 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
64 static void udf_merge_extents(struct inode
*,
65 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
66 static void udf_update_extents(struct inode
*,
67 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int, int,
68 struct extent_position
*);
69 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
72 void udf_evict_inode(struct inode
*inode
)
74 struct udf_inode_info
*iinfo
= UDF_I(inode
);
77 truncate_inode_pages(&inode
->i_data
, 0);
79 if (!inode
->i_nlink
&& !is_bad_inode(inode
)) {
83 udf_update_inode(inode
, IS_SYNC(inode
));
85 invalidate_inode_buffers(inode
);
87 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
&&
88 inode
->i_size
!= iinfo
->i_lenExtents
) {
89 printk(KERN_WARNING
"UDF-fs (%s): Inode %lu (mode %o) has "
90 "inode size %llu different from extent length %llu. "
91 "Filesystem need not be standards compliant.\n",
92 inode
->i_sb
->s_id
, inode
->i_ino
, inode
->i_mode
,
93 (unsigned long long)inode
->i_size
,
94 (unsigned long long)iinfo
->i_lenExtents
);
96 kfree(iinfo
->i_ext
.i_data
);
97 iinfo
->i_ext
.i_data
= NULL
;
100 udf_free_inode(inode
);
105 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
107 return block_write_full_page(page
, udf_get_block
, wbc
);
110 static int udf_readpage(struct file
*file
, struct page
*page
)
112 return block_read_full_page(page
, udf_get_block
);
115 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
116 loff_t pos
, unsigned len
, unsigned flags
,
117 struct page
**pagep
, void **fsdata
)
121 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
123 loff_t isize
= mapping
->host
->i_size
;
124 if (pos
+ len
> isize
)
125 vmtruncate(mapping
->host
, isize
);
131 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
133 return generic_block_bmap(mapping
, block
, udf_get_block
);
136 const struct address_space_operations udf_aops
= {
137 .readpage
= udf_readpage
,
138 .writepage
= udf_writepage
,
139 .sync_page
= block_sync_page
,
140 .write_begin
= udf_write_begin
,
141 .write_end
= generic_write_end
,
145 void udf_expand_file_adinicb(struct inode
*inode
, int newsize
, int *err
)
149 struct udf_inode_info
*iinfo
= UDF_I(inode
);
150 struct writeback_control udf_wbc
= {
151 .sync_mode
= WB_SYNC_NONE
,
155 /* from now on we have normal address_space methods */
156 inode
->i_data
.a_ops
= &udf_aops
;
158 if (!iinfo
->i_lenAlloc
) {
159 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
160 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
162 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
163 mark_inode_dirty(inode
);
167 page
= grab_cache_page(inode
->i_mapping
, 0);
168 BUG_ON(!PageLocked(page
));
170 if (!PageUptodate(page
)) {
172 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
173 PAGE_CACHE_SIZE
- iinfo
->i_lenAlloc
);
174 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
176 flush_dcache_page(page
);
177 SetPageUptodate(page
);
180 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
182 iinfo
->i_lenAlloc
= 0;
183 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
184 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
186 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
188 inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
189 page_cache_release(page
);
191 mark_inode_dirty(inode
);
194 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
198 struct buffer_head
*dbh
= NULL
;
199 struct kernel_lb_addr eloc
;
201 struct extent_position epos
;
203 struct udf_fileident_bh sfibh
, dfibh
;
204 loff_t f_pos
= udf_ext0_offset(inode
);
205 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
206 struct fileIdentDesc cfi
, *sfi
, *dfi
;
207 struct udf_inode_info
*iinfo
= UDF_I(inode
);
209 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
210 alloctype
= ICBTAG_FLAG_AD_SHORT
;
212 alloctype
= ICBTAG_FLAG_AD_LONG
;
214 if (!inode
->i_size
) {
215 iinfo
->i_alloc_type
= alloctype
;
216 mark_inode_dirty(inode
);
220 /* alloc block, and copy data to it */
221 *block
= udf_new_block(inode
->i_sb
, inode
,
222 iinfo
->i_location
.partitionReferenceNum
,
223 iinfo
->i_location
.logicalBlockNum
, err
);
226 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
227 iinfo
->i_location
.partitionReferenceNum
,
231 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
235 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
236 set_buffer_uptodate(dbh
);
238 mark_buffer_dirty_inode(dbh
, inode
);
240 sfibh
.soffset
= sfibh
.eoffset
=
241 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
242 sfibh
.sbh
= sfibh
.ebh
= NULL
;
243 dfibh
.soffset
= dfibh
.eoffset
= 0;
244 dfibh
.sbh
= dfibh
.ebh
= dbh
;
245 while (f_pos
< size
) {
246 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
247 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
253 iinfo
->i_alloc_type
= 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
,
260 le16_to_cpu(sfi
->lengthOfImpUse
))) {
261 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
266 mark_buffer_dirty_inode(dbh
, inode
);
268 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
270 iinfo
->i_lenAlloc
= 0;
271 eloc
.logicalBlockNum
= *block
;
272 eloc
.partitionReferenceNum
=
273 iinfo
->i_location
.partitionReferenceNum
;
274 iinfo
->i_lenExtents
= inode
->i_size
;
276 epos
.block
= iinfo
->i_location
;
277 epos
.offset
= udf_file_entry_alloc_offset(inode
);
278 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
282 mark_inode_dirty(inode
);
286 static int udf_get_block(struct inode
*inode
, sector_t block
,
287 struct buffer_head
*bh_result
, int create
)
290 struct buffer_head
*bh
;
292 struct udf_inode_info
*iinfo
;
295 phys
= udf_block_map(inode
, block
);
297 map_bh(bh_result
, inode
->i_sb
, phys
);
307 iinfo
= UDF_I(inode
);
308 if (block
== iinfo
->i_next_alloc_block
+ 1) {
309 iinfo
->i_next_alloc_block
++;
310 iinfo
->i_next_alloc_goal
++;
315 bh
= inode_getblk(inode
, block
, &err
, &phys
, &new);
322 set_buffer_new(bh_result
);
323 map_bh(bh_result
, inode
->i_sb
, phys
);
330 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
331 int create
, int *err
)
333 struct buffer_head
*bh
;
334 struct buffer_head dummy
;
337 dummy
.b_blocknr
= -1000;
338 *err
= udf_get_block(inode
, block
, &dummy
, create
);
339 if (!*err
&& buffer_mapped(&dummy
)) {
340 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
341 if (buffer_new(&dummy
)) {
343 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
344 set_buffer_uptodate(bh
);
346 mark_buffer_dirty_inode(bh
, inode
);
354 /* Extend the file by 'blocks' blocks, return the number of extents added */
355 int udf_extend_file(struct inode
*inode
, struct extent_position
*last_pos
,
356 struct kernel_long_ad
*last_ext
, sector_t blocks
)
359 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
360 struct super_block
*sb
= inode
->i_sb
;
361 struct kernel_lb_addr prealloc_loc
= {};
362 int prealloc_len
= 0;
363 struct udf_inode_info
*iinfo
;
365 /* The previous extent is fake and we should not extend by anything
366 * - there's nothing to do... */
370 iinfo
= UDF_I(inode
);
371 /* Round the last extent up to a multiple of block size */
372 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
373 last_ext
->extLength
=
374 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
375 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
376 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
377 iinfo
->i_lenExtents
=
378 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
379 ~(sb
->s_blocksize
- 1);
382 /* Last extent are just preallocated blocks? */
383 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
384 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;
395 /* Can we merge with the previous extent? */
396 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
397 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
398 add
= ((1 << 30) - sb
->s_blocksize
-
399 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
400 sb
->s_blocksize_bits
;
404 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
408 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
409 last_ext
->extLength
, 1);
412 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
413 last_ext
->extLength
, 1);
415 /* Managed to do everything necessary? */
419 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
420 last_ext
->extLocation
.logicalBlockNum
= 0;
421 last_ext
->extLocation
.partitionReferenceNum
= 0;
422 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
423 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
424 (add
<< sb
->s_blocksize_bits
);
426 /* Create enough extents to cover the whole hole */
427 while (blocks
> add
) {
429 if (udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
430 last_ext
->extLength
, 1) == -1)
435 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
436 (blocks
<< sb
->s_blocksize_bits
);
437 if (udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
438 last_ext
->extLength
, 1) == -1)
444 /* Do we have some preallocated blocks saved? */
446 if (udf_add_aext(inode
, last_pos
, &prealloc_loc
,
447 prealloc_len
, 1) == -1)
449 last_ext
->extLocation
= prealloc_loc
;
450 last_ext
->extLength
= prealloc_len
;
454 /* last_pos should point to the last written extent... */
455 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
456 last_pos
->offset
-= sizeof(struct short_ad
);
457 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
458 last_pos
->offset
-= sizeof(struct long_ad
);
465 static struct buffer_head
*inode_getblk(struct inode
*inode
, sector_t block
,
466 int *err
, sector_t
*phys
, int *new)
468 static sector_t last_block
;
469 struct buffer_head
*result
= NULL
;
470 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
471 struct extent_position prev_epos
, cur_epos
, next_epos
;
472 int count
= 0, startnum
= 0, endnum
= 0;
473 uint32_t elen
= 0, tmpelen
;
474 struct kernel_lb_addr eloc
, tmpeloc
;
476 loff_t lbcount
= 0, b_off
= 0;
477 uint32_t newblocknum
, newblock
;
480 struct udf_inode_info
*iinfo
= UDF_I(inode
);
481 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
484 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
485 prev_epos
.block
= iinfo
->i_location
;
487 cur_epos
= next_epos
= prev_epos
;
488 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
490 /* find the extent which contains the block we are looking for.
491 alternate between laarr[0] and laarr[1] for locations of the
492 current extent, and the previous extent */
494 if (prev_epos
.bh
!= cur_epos
.bh
) {
495 brelse(prev_epos
.bh
);
497 prev_epos
.bh
= cur_epos
.bh
;
499 if (cur_epos
.bh
!= next_epos
.bh
) {
501 get_bh(next_epos
.bh
);
502 cur_epos
.bh
= next_epos
.bh
;
507 prev_epos
.block
= cur_epos
.block
;
508 cur_epos
.block
= next_epos
.block
;
510 prev_epos
.offset
= cur_epos
.offset
;
511 cur_epos
.offset
= next_epos
.offset
;
513 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
519 laarr
[c
].extLength
= (etype
<< 30) | elen
;
520 laarr
[c
].extLocation
= eloc
;
522 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
523 pgoal
= eloc
.logicalBlockNum
+
524 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
525 inode
->i_sb
->s_blocksize_bits
);
528 } while (lbcount
+ elen
<= b_off
);
531 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
533 * Move prev_epos and cur_epos into indirect extent if we are at
536 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
537 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
539 /* if the extent is allocated and recorded, return the block
540 if the extent is not a multiple of the blocksize, round up */
542 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
543 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
544 elen
= EXT_RECORDED_ALLOCATED
|
545 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
546 ~(inode
->i_sb
->s_blocksize
- 1));
547 etype
= udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
549 brelse(prev_epos
.bh
);
551 brelse(next_epos
.bh
);
552 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
558 /* Are we beyond EOF? */
567 /* Create a fake extent when there's not one */
568 memset(&laarr
[0].extLocation
, 0x00,
569 sizeof(struct kernel_lb_addr
));
570 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
571 /* Will udf_extend_file() create real extent from
573 startnum
= (offset
> 0);
575 /* Create extents for the hole between EOF and offset */
576 ret
= udf_extend_file(inode
, &prev_epos
, laarr
, offset
);
578 brelse(prev_epos
.bh
);
580 brelse(next_epos
.bh
);
581 /* We don't really know the error here so we just make
589 /* We are not covered by a preallocated extent? */
590 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
591 EXT_NOT_RECORDED_ALLOCATED
) {
592 /* Is there any real extent? - otherwise we overwrite
596 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
597 inode
->i_sb
->s_blocksize
;
598 memset(&laarr
[c
].extLocation
, 0x00,
599 sizeof(struct kernel_lb_addr
));
606 endnum
= startnum
= ((count
> 2) ? 2 : count
);
608 /* if the current extent is in position 0,
609 swap it with the previous */
610 if (!c
&& count
!= 1) {
617 /* if the current block is located in an extent,
618 read the next extent */
619 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
621 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
622 laarr
[c
+ 1].extLocation
= eloc
;
630 /* if the current extent is not recorded but allocated, get the
631 * block in the extent corresponding to the requested block */
632 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
633 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
634 else { /* otherwise, allocate a new block */
635 if (iinfo
->i_next_alloc_block
== block
)
636 goal
= iinfo
->i_next_alloc_goal
;
639 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
640 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
643 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
644 iinfo
->i_location
.partitionReferenceNum
,
647 brelse(prev_epos
.bh
);
651 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
654 /* if the extent the requsted block is located in contains multiple
655 * blocks, split the extent into at most three extents. blocks prior
656 * to requested block, requested block, and blocks after requested
658 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
660 #ifdef UDF_PREALLOCATE
661 /* We preallocate blocks only for regular files. It also makes sense
662 * for directories but there's a problem when to drop the
663 * preallocation. We might use some delayed work for that but I feel
664 * it's overengineering for a filesystem like UDF. */
665 if (S_ISREG(inode
->i_mode
))
666 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
669 /* merge any continuous blocks in laarr */
670 udf_merge_extents(inode
, laarr
, &endnum
);
672 /* write back the new extents, inserting new extents if the new number
673 * of extents is greater than the old number, and deleting extents if
674 * the new number of extents is less than the old number */
675 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
677 brelse(prev_epos
.bh
);
679 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
680 iinfo
->i_location
.partitionReferenceNum
, 0);
686 iinfo
->i_next_alloc_block
= block
;
687 iinfo
->i_next_alloc_goal
= newblocknum
;
688 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
691 udf_sync_inode(inode
);
693 mark_inode_dirty(inode
);
698 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
700 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
703 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
704 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
706 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
707 (laarr
[*c
].extLength
>> 30) ==
708 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
710 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
711 blocksize
- 1) >> blocksize_bits
;
712 int8_t etype
= (laarr
[curr
].extLength
>> 30);
716 else if (!offset
|| blen
== offset
+ 1) {
717 laarr
[curr
+ 2] = laarr
[curr
+ 1];
718 laarr
[curr
+ 1] = laarr
[curr
];
720 laarr
[curr
+ 3] = laarr
[curr
+ 1];
721 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
725 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
726 udf_free_blocks(inode
->i_sb
, inode
,
727 &laarr
[curr
].extLocation
,
729 laarr
[curr
].extLength
=
730 EXT_NOT_RECORDED_NOT_ALLOCATED
|
731 (offset
<< blocksize_bits
);
732 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
733 laarr
[curr
].extLocation
.
734 partitionReferenceNum
= 0;
736 laarr
[curr
].extLength
= (etype
<< 30) |
737 (offset
<< blocksize_bits
);
743 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
744 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
745 laarr
[curr
].extLocation
.partitionReferenceNum
=
746 UDF_I(inode
)->i_location
.partitionReferenceNum
;
747 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
751 if (blen
!= offset
+ 1) {
752 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
753 laarr
[curr
].extLocation
.logicalBlockNum
+=
755 laarr
[curr
].extLength
= (etype
<< 30) |
756 ((blen
- (offset
+ 1)) << blocksize_bits
);
763 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
764 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
767 int start
, length
= 0, currlength
= 0, i
;
769 if (*endnum
>= (c
+ 1)) {
775 if ((laarr
[c
+ 1].extLength
>> 30) ==
776 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
778 length
= currlength
=
779 (((laarr
[c
+ 1].extLength
&
780 UDF_EXTENT_LENGTH_MASK
) +
781 inode
->i_sb
->s_blocksize
- 1) >>
782 inode
->i_sb
->s_blocksize_bits
);
787 for (i
= start
+ 1; i
<= *endnum
; i
++) {
790 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
791 } else if ((laarr
[i
].extLength
>> 30) ==
792 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
793 length
+= (((laarr
[i
].extLength
&
794 UDF_EXTENT_LENGTH_MASK
) +
795 inode
->i_sb
->s_blocksize
- 1) >>
796 inode
->i_sb
->s_blocksize_bits
);
802 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
803 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
804 inode
->i_sb
->s_blocksize
- 1) >>
805 inode
->i_sb
->s_blocksize_bits
);
806 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
807 laarr
[start
].extLocation
.partitionReferenceNum
,
808 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
809 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
812 if (start
== (c
+ 1))
813 laarr
[start
].extLength
+=
815 inode
->i_sb
->s_blocksize_bits
);
817 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
818 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
820 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
821 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
822 laarr
[c
].extLocation
.
823 partitionReferenceNum
;
824 laarr
[c
+ 1].extLength
=
825 EXT_NOT_RECORDED_ALLOCATED
|
827 inode
->i_sb
->s_blocksize_bits
);
831 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
832 int elen
= ((laarr
[i
].extLength
&
833 UDF_EXTENT_LENGTH_MASK
) +
834 inode
->i_sb
->s_blocksize
- 1) >>
835 inode
->i_sb
->s_blocksize_bits
;
837 if (elen
> numalloc
) {
838 laarr
[i
].extLength
-=
840 inode
->i_sb
->s_blocksize_bits
);
844 if (*endnum
> (i
+ 1))
847 sizeof(struct long_ad
) *
848 (*endnum
- (i
+ 1)));
853 UDF_I(inode
)->i_lenExtents
+=
854 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
859 static void udf_merge_extents(struct inode
*inode
,
860 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
864 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
865 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
867 for (i
= 0; i
< (*endnum
- 1); i
++) {
868 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
869 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
871 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
872 (((li
->extLength
>> 30) ==
873 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
874 ((lip1
->extLocation
.logicalBlockNum
-
875 li
->extLocation
.logicalBlockNum
) ==
876 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
877 blocksize
- 1) >> blocksize_bits
)))) {
879 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
880 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
881 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
882 lip1
->extLength
= (lip1
->extLength
-
884 UDF_EXTENT_LENGTH_MASK
) +
885 UDF_EXTENT_LENGTH_MASK
) &
887 li
->extLength
= (li
->extLength
&
888 UDF_EXTENT_FLAG_MASK
) +
889 (UDF_EXTENT_LENGTH_MASK
+ 1) -
891 lip1
->extLocation
.logicalBlockNum
=
892 li
->extLocation
.logicalBlockNum
+
894 UDF_EXTENT_LENGTH_MASK
) >>
897 li
->extLength
= lip1
->extLength
+
899 UDF_EXTENT_LENGTH_MASK
) +
900 blocksize
- 1) & ~(blocksize
- 1));
901 if (*endnum
> (i
+ 2))
902 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
903 sizeof(struct long_ad
) *
904 (*endnum
- (i
+ 2)));
908 } else if (((li
->extLength
>> 30) ==
909 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
910 ((lip1
->extLength
>> 30) ==
911 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
912 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
914 UDF_EXTENT_LENGTH_MASK
) +
915 blocksize
- 1) >> blocksize_bits
);
916 li
->extLocation
.logicalBlockNum
= 0;
917 li
->extLocation
.partitionReferenceNum
= 0;
919 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
920 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
921 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
922 lip1
->extLength
= (lip1
->extLength
-
924 UDF_EXTENT_LENGTH_MASK
) +
925 UDF_EXTENT_LENGTH_MASK
) &
927 li
->extLength
= (li
->extLength
&
928 UDF_EXTENT_FLAG_MASK
) +
929 (UDF_EXTENT_LENGTH_MASK
+ 1) -
932 li
->extLength
= lip1
->extLength
+
934 UDF_EXTENT_LENGTH_MASK
) +
935 blocksize
- 1) & ~(blocksize
- 1));
936 if (*endnum
> (i
+ 2))
937 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
938 sizeof(struct long_ad
) *
939 (*endnum
- (i
+ 2)));
943 } else if ((li
->extLength
>> 30) ==
944 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
945 udf_free_blocks(inode
->i_sb
, inode
,
948 UDF_EXTENT_LENGTH_MASK
) +
949 blocksize
- 1) >> blocksize_bits
);
950 li
->extLocation
.logicalBlockNum
= 0;
951 li
->extLocation
.partitionReferenceNum
= 0;
952 li
->extLength
= (li
->extLength
&
953 UDF_EXTENT_LENGTH_MASK
) |
954 EXT_NOT_RECORDED_NOT_ALLOCATED
;
959 static void udf_update_extents(struct inode
*inode
,
960 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
961 int startnum
, int endnum
,
962 struct extent_position
*epos
)
965 struct kernel_lb_addr tmploc
;
968 if (startnum
> endnum
) {
969 for (i
= 0; i
< (startnum
- endnum
); i
++)
970 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
972 } else if (startnum
< endnum
) {
973 for (i
= 0; i
< (endnum
- startnum
); i
++) {
974 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
976 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
977 &laarr
[i
].extLength
, 1);
982 for (i
= start
; i
< endnum
; i
++) {
983 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
984 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
985 laarr
[i
].extLength
, 1);
989 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
990 int create
, int *err
)
992 struct buffer_head
*bh
= NULL
;
994 bh
= udf_getblk(inode
, block
, create
, err
);
998 if (buffer_uptodate(bh
))
1001 ll_rw_block(READ
, 1, &bh
);
1004 if (buffer_uptodate(bh
))
1012 void udf_truncate(struct inode
*inode
)
1016 struct udf_inode_info
*iinfo
;
1018 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1019 S_ISLNK(inode
->i_mode
)))
1021 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1025 iinfo
= UDF_I(inode
);
1026 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1027 if (inode
->i_sb
->s_blocksize
<
1028 (udf_file_entry_alloc_offset(inode
) +
1030 udf_expand_file_adinicb(inode
, inode
->i_size
, &err
);
1031 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1032 inode
->i_size
= iinfo
->i_lenAlloc
;
1036 udf_truncate_extents(inode
);
1038 offset
= inode
->i_size
& (inode
->i_sb
->s_blocksize
- 1);
1039 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ offset
,
1040 0x00, inode
->i_sb
->s_blocksize
-
1041 offset
- udf_file_entry_alloc_offset(inode
));
1042 iinfo
->i_lenAlloc
= inode
->i_size
;
1045 block_truncate_page(inode
->i_mapping
, inode
->i_size
,
1047 udf_truncate_extents(inode
);
1050 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1052 udf_sync_inode(inode
);
1054 mark_inode_dirty(inode
);
1058 static void __udf_read_inode(struct inode
*inode
)
1060 struct buffer_head
*bh
= NULL
;
1061 struct fileEntry
*fe
;
1063 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1066 * Set defaults, but the inode is still incomplete!
1067 * Note: get_new_inode() sets the following on a new inode:
1070 * i_flags = sb->s_flags
1072 * clean_inode(): zero fills and sets
1077 bh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 0, &ident
);
1079 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) failed !bh\n",
1081 make_bad_inode(inode
);
1085 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1086 ident
!= TAG_IDENT_USE
) {
1087 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) "
1088 "failed ident=%d\n", inode
->i_ino
, ident
);
1090 make_bad_inode(inode
);
1094 fe
= (struct fileEntry
*)bh
->b_data
;
1096 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1097 struct buffer_head
*ibh
;
1099 ibh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 1,
1101 if (ident
== TAG_IDENT_IE
&& ibh
) {
1102 struct buffer_head
*nbh
= NULL
;
1103 struct kernel_lb_addr loc
;
1104 struct indirectEntry
*ie
;
1106 ie
= (struct indirectEntry
*)ibh
->b_data
;
1107 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1109 if (ie
->indirectICB
.extLength
&&
1110 (nbh
= udf_read_ptagged(inode
->i_sb
, &loc
, 0,
1112 if (ident
== TAG_IDENT_FE
||
1113 ident
== TAG_IDENT_EFE
) {
1114 memcpy(&iinfo
->i_location
,
1116 sizeof(struct kernel_lb_addr
));
1120 __udf_read_inode(inode
);
1127 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1128 printk(KERN_ERR
"udf: unsupported strategy type: %d\n",
1129 le16_to_cpu(fe
->icbTag
.strategyType
));
1131 make_bad_inode(inode
);
1134 udf_fill_inode(inode
, bh
);
1139 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1141 struct fileEntry
*fe
;
1142 struct extendedFileEntry
*efe
;
1144 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1145 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1147 fe
= (struct fileEntry
*)bh
->b_data
;
1148 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1150 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1151 iinfo
->i_strat4096
= 0;
1152 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1153 iinfo
->i_strat4096
= 1;
1155 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1156 ICBTAG_FLAG_AD_MASK
;
1157 iinfo
->i_unique
= 0;
1158 iinfo
->i_lenEAttr
= 0;
1159 iinfo
->i_lenExtents
= 0;
1160 iinfo
->i_lenAlloc
= 0;
1161 iinfo
->i_next_alloc_block
= 0;
1162 iinfo
->i_next_alloc_goal
= 0;
1163 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1166 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1167 sizeof(struct extendedFileEntry
))) {
1168 make_bad_inode(inode
);
1171 memcpy(iinfo
->i_ext
.i_data
,
1172 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1173 inode
->i_sb
->s_blocksize
-
1174 sizeof(struct extendedFileEntry
));
1175 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1178 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1179 sizeof(struct fileEntry
))) {
1180 make_bad_inode(inode
);
1183 memcpy(iinfo
->i_ext
.i_data
,
1184 bh
->b_data
+ sizeof(struct fileEntry
),
1185 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1186 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1189 iinfo
->i_lenAlloc
= le32_to_cpu(
1190 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1192 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1193 sizeof(struct unallocSpaceEntry
))) {
1194 make_bad_inode(inode
);
1197 memcpy(iinfo
->i_ext
.i_data
,
1198 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1199 inode
->i_sb
->s_blocksize
-
1200 sizeof(struct unallocSpaceEntry
));
1204 read_lock(&sbi
->s_cred_lock
);
1205 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1206 if (inode
->i_uid
== -1 ||
1207 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1208 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1209 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1211 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1212 if (inode
->i_gid
== -1 ||
1213 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1214 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1215 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1217 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1218 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1219 inode
->i_mode
= sbi
->s_fmode
;
1220 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1221 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1222 inode
->i_mode
= sbi
->s_dmode
;
1224 inode
->i_mode
= udf_convert_permissions(fe
);
1225 inode
->i_mode
&= ~sbi
->s_umask
;
1226 read_unlock(&sbi
->s_cred_lock
);
1228 inode
->i_nlink
= le16_to_cpu(fe
->fileLinkCount
);
1229 if (!inode
->i_nlink
)
1232 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1233 iinfo
->i_lenExtents
= inode
->i_size
;
1235 if (iinfo
->i_efe
== 0) {
1236 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1237 (inode
->i_sb
->s_blocksize_bits
- 9);
1239 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1240 inode
->i_atime
= sbi
->s_record_time
;
1242 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1243 fe
->modificationTime
))
1244 inode
->i_mtime
= sbi
->s_record_time
;
1246 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1247 inode
->i_ctime
= sbi
->s_record_time
;
1249 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1250 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1251 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1252 offset
= sizeof(struct fileEntry
) + iinfo
->i_lenEAttr
;
1254 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1255 (inode
->i_sb
->s_blocksize_bits
- 9);
1257 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1258 inode
->i_atime
= sbi
->s_record_time
;
1260 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1261 efe
->modificationTime
))
1262 inode
->i_mtime
= sbi
->s_record_time
;
1264 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1265 iinfo
->i_crtime
= sbi
->s_record_time
;
1267 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1268 inode
->i_ctime
= sbi
->s_record_time
;
1270 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1271 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1272 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1273 offset
= sizeof(struct extendedFileEntry
) +
1277 switch (fe
->icbTag
.fileType
) {
1278 case ICBTAG_FILE_TYPE_DIRECTORY
:
1279 inode
->i_op
= &udf_dir_inode_operations
;
1280 inode
->i_fop
= &udf_dir_operations
;
1281 inode
->i_mode
|= S_IFDIR
;
1284 case ICBTAG_FILE_TYPE_REALTIME
:
1285 case ICBTAG_FILE_TYPE_REGULAR
:
1286 case ICBTAG_FILE_TYPE_UNDEF
:
1287 case ICBTAG_FILE_TYPE_VAT20
:
1288 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1289 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1291 inode
->i_data
.a_ops
= &udf_aops
;
1292 inode
->i_op
= &udf_file_inode_operations
;
1293 inode
->i_fop
= &udf_file_operations
;
1294 inode
->i_mode
|= S_IFREG
;
1296 case ICBTAG_FILE_TYPE_BLOCK
:
1297 inode
->i_mode
|= S_IFBLK
;
1299 case ICBTAG_FILE_TYPE_CHAR
:
1300 inode
->i_mode
|= S_IFCHR
;
1302 case ICBTAG_FILE_TYPE_FIFO
:
1303 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1305 case ICBTAG_FILE_TYPE_SOCKET
:
1306 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1308 case ICBTAG_FILE_TYPE_SYMLINK
:
1309 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1310 inode
->i_op
= &udf_symlink_inode_operations
;
1311 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1313 case ICBTAG_FILE_TYPE_MAIN
:
1314 udf_debug("METADATA FILE-----\n");
1316 case ICBTAG_FILE_TYPE_MIRROR
:
1317 udf_debug("METADATA MIRROR FILE-----\n");
1319 case ICBTAG_FILE_TYPE_BITMAP
:
1320 udf_debug("METADATA BITMAP FILE-----\n");
1323 printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown "
1324 "file type=%d\n", inode
->i_ino
,
1325 fe
->icbTag
.fileType
);
1326 make_bad_inode(inode
);
1329 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1330 struct deviceSpec
*dsea
=
1331 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1333 init_special_inode(inode
, inode
->i_mode
,
1334 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1335 le32_to_cpu(dsea
->minorDeviceIdent
)));
1336 /* Developer ID ??? */
1338 make_bad_inode(inode
);
1342 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1344 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1345 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1347 if (!iinfo
->i_ext
.i_data
) {
1348 printk(KERN_ERR
"udf:udf_alloc_i_data (ino %ld) "
1349 "no free memory\n", inode
->i_ino
);
1356 static mode_t
udf_convert_permissions(struct fileEntry
*fe
)
1359 uint32_t permissions
;
1362 permissions
= le32_to_cpu(fe
->permissions
);
1363 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1365 mode
= ((permissions
) & S_IRWXO
) |
1366 ((permissions
>> 2) & S_IRWXG
) |
1367 ((permissions
>> 4) & S_IRWXU
) |
1368 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1369 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1370 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1375 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1377 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1380 static int udf_sync_inode(struct inode
*inode
)
1382 return udf_update_inode(inode
, 1);
1385 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1387 struct buffer_head
*bh
= NULL
;
1388 struct fileEntry
*fe
;
1389 struct extendedFileEntry
*efe
;
1394 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1395 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1396 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1398 bh
= udf_tgetblk(inode
->i_sb
,
1399 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1401 udf_debug("getblk failure\n");
1406 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1407 fe
= (struct fileEntry
*)bh
->b_data
;
1408 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1411 struct unallocSpaceEntry
*use
=
1412 (struct unallocSpaceEntry
*)bh
->b_data
;
1414 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1415 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1416 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1417 sizeof(struct unallocSpaceEntry
));
1418 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1419 use
->descTag
.tagLocation
=
1420 cpu_to_le32(iinfo
->i_location
.logicalBlockNum
);
1421 crclen
= sizeof(struct unallocSpaceEntry
) +
1422 iinfo
->i_lenAlloc
- sizeof(struct tag
);
1423 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1424 use
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)use
+
1427 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1432 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1433 fe
->uid
= cpu_to_le32(-1);
1435 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1437 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1438 fe
->gid
= cpu_to_le32(-1);
1440 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1442 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1443 ((inode
->i_mode
& S_IRWXG
) << 2) |
1444 ((inode
->i_mode
& S_IRWXU
) << 4);
1446 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1447 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1448 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1449 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1450 fe
->permissions
= cpu_to_le32(udfperms
);
1452 if (S_ISDIR(inode
->i_mode
))
1453 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1455 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1457 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1459 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1461 struct deviceSpec
*dsea
=
1462 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1464 dsea
= (struct deviceSpec
*)
1465 udf_add_extendedattr(inode
,
1466 sizeof(struct deviceSpec
) +
1467 sizeof(struct regid
), 12, 0x3);
1468 dsea
->attrType
= cpu_to_le32(12);
1469 dsea
->attrSubtype
= 1;
1470 dsea
->attrLength
= cpu_to_le32(
1471 sizeof(struct deviceSpec
) +
1472 sizeof(struct regid
));
1473 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1475 eid
= (struct regid
*)dsea
->impUse
;
1476 memset(eid
, 0, sizeof(struct regid
));
1477 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1478 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1479 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1480 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1481 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1484 if (iinfo
->i_efe
== 0) {
1485 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1486 iinfo
->i_ext
.i_data
,
1487 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1488 fe
->logicalBlocksRecorded
= cpu_to_le64(
1489 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1490 (blocksize_bits
- 9));
1492 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1493 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1494 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1495 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1496 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1497 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1498 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1499 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1500 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1501 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1502 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1503 crclen
= sizeof(struct fileEntry
);
1505 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1506 iinfo
->i_ext
.i_data
,
1507 inode
->i_sb
->s_blocksize
-
1508 sizeof(struct extendedFileEntry
));
1509 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1510 efe
->logicalBlocksRecorded
= cpu_to_le64(
1511 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1512 (blocksize_bits
- 9));
1514 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1515 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1516 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1517 iinfo
->i_crtime
= inode
->i_atime
;
1519 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1520 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1521 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1522 iinfo
->i_crtime
= inode
->i_mtime
;
1524 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1525 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1526 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1527 iinfo
->i_crtime
= inode
->i_ctime
;
1529 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1530 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1531 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1532 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1534 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1535 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1536 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1537 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1538 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1539 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1540 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1541 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1542 crclen
= sizeof(struct extendedFileEntry
);
1544 if (iinfo
->i_strat4096
) {
1545 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1546 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1547 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1549 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1550 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1553 if (S_ISDIR(inode
->i_mode
))
1554 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1555 else if (S_ISREG(inode
->i_mode
))
1556 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1557 else if (S_ISLNK(inode
->i_mode
))
1558 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1559 else if (S_ISBLK(inode
->i_mode
))
1560 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1561 else if (S_ISCHR(inode
->i_mode
))
1562 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1563 else if (S_ISFIFO(inode
->i_mode
))
1564 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1565 else if (S_ISSOCK(inode
->i_mode
))
1566 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1568 icbflags
= iinfo
->i_alloc_type
|
1569 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1570 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1571 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1572 (le16_to_cpu(fe
->icbTag
.flags
) &
1573 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1574 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1576 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1577 if (sbi
->s_udfrev
>= 0x0200)
1578 fe
->descTag
.descVersion
= cpu_to_le16(3);
1580 fe
->descTag
.descVersion
= cpu_to_le16(2);
1581 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1582 fe
->descTag
.tagLocation
= cpu_to_le32(
1583 iinfo
->i_location
.logicalBlockNum
);
1584 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1585 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1586 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1588 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1591 set_buffer_uptodate(bh
);
1594 /* write the data blocks */
1595 mark_buffer_dirty(bh
);
1597 sync_dirty_buffer(bh
);
1598 if (buffer_write_io_error(bh
)) {
1599 printk(KERN_WARNING
"IO error syncing udf inode "
1600 "[%s:%08lx]\n", inode
->i_sb
->s_id
,
1610 struct inode
*udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
)
1612 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1613 struct inode
*inode
= iget_locked(sb
, block
);
1618 if (inode
->i_state
& I_NEW
) {
1619 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1620 __udf_read_inode(inode
);
1621 unlock_new_inode(inode
);
1624 if (is_bad_inode(inode
))
1627 if (ino
->logicalBlockNum
>= UDF_SB(sb
)->
1628 s_partmaps
[ino
->partitionReferenceNum
].s_partition_len
) {
1629 udf_debug("block=%d, partition=%d out of range\n",
1630 ino
->logicalBlockNum
, ino
->partitionReferenceNum
);
1631 make_bad_inode(inode
);
1642 int8_t udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1643 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1646 struct short_ad
*sad
= NULL
;
1647 struct long_ad
*lad
= NULL
;
1648 struct allocExtDesc
*aed
;
1651 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1654 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1655 udf_file_entry_alloc_offset(inode
) +
1658 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1660 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1661 adsize
= sizeof(struct short_ad
);
1662 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1663 adsize
= sizeof(struct long_ad
);
1667 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1668 unsigned char *sptr
, *dptr
;
1669 struct buffer_head
*nbh
;
1671 struct kernel_lb_addr obloc
= epos
->block
;
1673 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1674 obloc
.partitionReferenceNum
,
1675 obloc
.logicalBlockNum
, &err
);
1676 if (!epos
->block
.logicalBlockNum
)
1678 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1684 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1685 set_buffer_uptodate(nbh
);
1687 mark_buffer_dirty_inode(nbh
, inode
);
1689 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1690 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1691 aed
->previousAllocExtLocation
=
1692 cpu_to_le32(obloc
.logicalBlockNum
);
1693 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1694 loffset
= epos
->offset
;
1695 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1696 sptr
= ptr
- adsize
;
1697 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1698 memcpy(dptr
, sptr
, adsize
);
1699 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1701 loffset
= epos
->offset
+ adsize
;
1702 aed
->lengthAllocDescs
= cpu_to_le32(0);
1704 epos
->offset
= sizeof(struct allocExtDesc
);
1707 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1708 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1710 iinfo
->i_lenAlloc
+= adsize
;
1711 mark_inode_dirty(inode
);
1714 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1715 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1716 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1718 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1719 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1720 switch (iinfo
->i_alloc_type
) {
1721 case ICBTAG_FLAG_AD_SHORT
:
1722 sad
= (struct short_ad
*)sptr
;
1723 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1724 inode
->i_sb
->s_blocksize
);
1726 cpu_to_le32(epos
->block
.logicalBlockNum
);
1728 case ICBTAG_FLAG_AD_LONG
:
1729 lad
= (struct long_ad
*)sptr
;
1730 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1731 inode
->i_sb
->s_blocksize
);
1732 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1733 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1737 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1738 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1739 udf_update_tag(epos
->bh
->b_data
, loffset
);
1741 udf_update_tag(epos
->bh
->b_data
,
1742 sizeof(struct allocExtDesc
));
1743 mark_buffer_dirty_inode(epos
->bh
, inode
);
1746 mark_inode_dirty(inode
);
1751 etype
= udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1754 iinfo
->i_lenAlloc
+= adsize
;
1755 mark_inode_dirty(inode
);
1757 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1758 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1759 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1760 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1761 udf_update_tag(epos
->bh
->b_data
,
1762 epos
->offset
+ (inc
? 0 : adsize
));
1764 udf_update_tag(epos
->bh
->b_data
,
1765 sizeof(struct allocExtDesc
));
1766 mark_buffer_dirty_inode(epos
->bh
, inode
);
1772 int8_t udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1773 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1777 struct short_ad
*sad
;
1778 struct long_ad
*lad
;
1779 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1782 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1783 udf_file_entry_alloc_offset(inode
) +
1786 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1788 switch (iinfo
->i_alloc_type
) {
1789 case ICBTAG_FLAG_AD_SHORT
:
1790 sad
= (struct short_ad
*)ptr
;
1791 sad
->extLength
= cpu_to_le32(elen
);
1792 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
1793 adsize
= sizeof(struct short_ad
);
1795 case ICBTAG_FLAG_AD_LONG
:
1796 lad
= (struct long_ad
*)ptr
;
1797 lad
->extLength
= cpu_to_le32(elen
);
1798 lad
->extLocation
= cpu_to_lelb(*eloc
);
1799 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1800 adsize
= sizeof(struct long_ad
);
1807 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1808 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1809 struct allocExtDesc
*aed
=
1810 (struct allocExtDesc
*)epos
->bh
->b_data
;
1811 udf_update_tag(epos
->bh
->b_data
,
1812 le32_to_cpu(aed
->lengthAllocDescs
) +
1813 sizeof(struct allocExtDesc
));
1815 mark_buffer_dirty_inode(epos
->bh
, inode
);
1817 mark_inode_dirty(inode
);
1821 epos
->offset
+= adsize
;
1823 return (elen
>> 30);
1826 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1827 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1831 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1832 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1834 epos
->block
= *eloc
;
1835 epos
->offset
= sizeof(struct allocExtDesc
);
1837 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
1838 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1840 udf_debug("reading block %d failed!\n", block
);
1848 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1849 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1854 struct short_ad
*sad
;
1855 struct long_ad
*lad
;
1856 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1860 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1861 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1862 udf_file_entry_alloc_offset(inode
) +
1864 alen
= udf_file_entry_alloc_offset(inode
) +
1868 epos
->offset
= sizeof(struct allocExtDesc
);
1869 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1870 alen
= sizeof(struct allocExtDesc
) +
1871 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1875 switch (iinfo
->i_alloc_type
) {
1876 case ICBTAG_FLAG_AD_SHORT
:
1877 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1880 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1881 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1882 eloc
->partitionReferenceNum
=
1883 iinfo
->i_location
.partitionReferenceNum
;
1884 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1886 case ICBTAG_FLAG_AD_LONG
:
1887 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
1890 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1891 *eloc
= lelb_to_cpu(lad
->extLocation
);
1892 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1895 udf_debug("alloc_type = %d unsupported\n",
1896 iinfo
->i_alloc_type
);
1903 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
1904 struct kernel_lb_addr neloc
, uint32_t nelen
)
1906 struct kernel_lb_addr oeloc
;
1913 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
1914 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
1916 nelen
= (etype
<< 30) | oelen
;
1918 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
1921 return (nelen
>> 30);
1924 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
1925 struct kernel_lb_addr eloc
, uint32_t elen
)
1927 struct extent_position oepos
;
1930 struct allocExtDesc
*aed
;
1931 struct udf_inode_info
*iinfo
;
1938 iinfo
= UDF_I(inode
);
1939 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1940 adsize
= sizeof(struct short_ad
);
1941 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1942 adsize
= sizeof(struct long_ad
);
1947 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
1950 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
1951 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
1952 if (oepos
.bh
!= epos
.bh
) {
1953 oepos
.block
= epos
.block
;
1957 oepos
.offset
= epos
.offset
- adsize
;
1960 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
1963 if (epos
.bh
!= oepos
.bh
) {
1964 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
1965 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
1966 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
1968 iinfo
->i_lenAlloc
-= (adsize
* 2);
1969 mark_inode_dirty(inode
);
1971 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1972 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
1973 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1974 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1975 udf_update_tag(oepos
.bh
->b_data
,
1976 oepos
.offset
- (2 * adsize
));
1978 udf_update_tag(oepos
.bh
->b_data
,
1979 sizeof(struct allocExtDesc
));
1980 mark_buffer_dirty_inode(oepos
.bh
, inode
);
1983 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
1985 iinfo
->i_lenAlloc
-= adsize
;
1986 mark_inode_dirty(inode
);
1988 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1989 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
1990 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1991 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1992 udf_update_tag(oepos
.bh
->b_data
,
1993 epos
.offset
- adsize
);
1995 udf_update_tag(oepos
.bh
->b_data
,
1996 sizeof(struct allocExtDesc
));
1997 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2004 return (elen
>> 30);
2007 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2008 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2009 uint32_t *elen
, sector_t
*offset
)
2011 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2012 loff_t lbcount
= 0, bcount
=
2013 (loff_t
) block
<< blocksize_bits
;
2015 struct udf_inode_info
*iinfo
;
2017 iinfo
= UDF_I(inode
);
2019 pos
->block
= iinfo
->i_location
;
2024 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2026 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2027 iinfo
->i_lenExtents
= lbcount
;
2031 } while (lbcount
<= bcount
);
2033 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2038 long udf_block_map(struct inode
*inode
, sector_t block
)
2040 struct kernel_lb_addr eloc
;
2043 struct extent_position epos
= {};
2048 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2049 (EXT_RECORDED_ALLOCATED
>> 30))
2050 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2057 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2058 return udf_fixed_to_variable(ret
);