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/module.h>
35 #include <linux/pagemap.h>
36 #include <linux/writeback.h>
37 #include <linux/slab.h>
38 #include <linux/crc-itu-t.h>
39 #include <linux/mpage.h>
40 #include <linux/uio.h>
41 #include <linux/bio.h>
46 #define EXTENT_MERGE_SIZE 5
48 static umode_t
udf_convert_permissions(struct fileEntry
*);
49 static int udf_update_inode(struct inode
*, int);
50 static int udf_sync_inode(struct inode
*inode
);
51 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
52 static sector_t
inode_getblk(struct inode
*, sector_t
, int *, int *);
53 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
54 struct kernel_lb_addr
, uint32_t);
55 static void udf_split_extents(struct inode
*, int *, int, int,
56 struct kernel_long_ad
*, int *);
57 static void udf_prealloc_extents(struct inode
*, int, int,
58 struct kernel_long_ad
*, int *);
59 static void udf_merge_extents(struct inode
*, struct kernel_long_ad
*, int *);
60 static void udf_update_extents(struct inode
*, struct kernel_long_ad
*, int,
61 int, struct extent_position
*);
62 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
64 static void __udf_clear_extent_cache(struct inode
*inode
)
66 struct udf_inode_info
*iinfo
= UDF_I(inode
);
68 if (iinfo
->cached_extent
.lstart
!= -1) {
69 brelse(iinfo
->cached_extent
.epos
.bh
);
70 iinfo
->cached_extent
.lstart
= -1;
74 /* Invalidate extent cache */
75 static void udf_clear_extent_cache(struct inode
*inode
)
77 struct udf_inode_info
*iinfo
= UDF_I(inode
);
79 spin_lock(&iinfo
->i_extent_cache_lock
);
80 __udf_clear_extent_cache(inode
);
81 spin_unlock(&iinfo
->i_extent_cache_lock
);
84 /* Return contents of extent cache */
85 static int udf_read_extent_cache(struct inode
*inode
, loff_t bcount
,
86 loff_t
*lbcount
, struct extent_position
*pos
)
88 struct udf_inode_info
*iinfo
= UDF_I(inode
);
91 spin_lock(&iinfo
->i_extent_cache_lock
);
92 if ((iinfo
->cached_extent
.lstart
<= bcount
) &&
93 (iinfo
->cached_extent
.lstart
!= -1)) {
95 *lbcount
= iinfo
->cached_extent
.lstart
;
96 memcpy(pos
, &iinfo
->cached_extent
.epos
,
97 sizeof(struct extent_position
));
102 spin_unlock(&iinfo
->i_extent_cache_lock
);
106 /* Add extent to extent cache */
107 static void udf_update_extent_cache(struct inode
*inode
, loff_t estart
,
108 struct extent_position
*pos
)
110 struct udf_inode_info
*iinfo
= UDF_I(inode
);
112 spin_lock(&iinfo
->i_extent_cache_lock
);
113 /* Invalidate previously cached extent */
114 __udf_clear_extent_cache(inode
);
117 memcpy(&iinfo
->cached_extent
.epos
, pos
, sizeof(struct extent_position
));
118 iinfo
->cached_extent
.lstart
= estart
;
119 switch (iinfo
->i_alloc_type
) {
120 case ICBTAG_FLAG_AD_SHORT
:
121 iinfo
->cached_extent
.epos
.offset
-= sizeof(struct short_ad
);
123 case ICBTAG_FLAG_AD_LONG
:
124 iinfo
->cached_extent
.epos
.offset
-= sizeof(struct long_ad
);
127 spin_unlock(&iinfo
->i_extent_cache_lock
);
130 void udf_evict_inode(struct inode
*inode
)
132 struct udf_inode_info
*iinfo
= UDF_I(inode
);
135 if (!inode
->i_nlink
&& !is_bad_inode(inode
)) {
137 udf_setsize(inode
, 0);
138 udf_update_inode(inode
, IS_SYNC(inode
));
140 truncate_inode_pages_final(&inode
->i_data
);
141 invalidate_inode_buffers(inode
);
143 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
&&
144 inode
->i_size
!= iinfo
->i_lenExtents
) {
145 udf_warn(inode
->i_sb
, "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
146 inode
->i_ino
, inode
->i_mode
,
147 (unsigned long long)inode
->i_size
,
148 (unsigned long long)iinfo
->i_lenExtents
);
150 kfree(iinfo
->i_ext
.i_data
);
151 iinfo
->i_ext
.i_data
= NULL
;
152 udf_clear_extent_cache(inode
);
154 udf_free_inode(inode
);
158 static void udf_write_failed(struct address_space
*mapping
, loff_t to
)
160 struct inode
*inode
= mapping
->host
;
161 struct udf_inode_info
*iinfo
= UDF_I(inode
);
162 loff_t isize
= inode
->i_size
;
165 truncate_pagecache(inode
, isize
);
166 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
167 down_write(&iinfo
->i_data_sem
);
168 udf_clear_extent_cache(inode
);
169 udf_truncate_extents(inode
);
170 up_write(&iinfo
->i_data_sem
);
175 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
177 return block_write_full_page(page
, udf_get_block
, wbc
);
180 static int udf_writepages(struct address_space
*mapping
,
181 struct writeback_control
*wbc
)
183 return mpage_writepages(mapping
, wbc
, udf_get_block
);
186 static int udf_readpage(struct file
*file
, struct page
*page
)
188 return mpage_readpage(page
, udf_get_block
);
191 static int udf_readpages(struct file
*file
, struct address_space
*mapping
,
192 struct list_head
*pages
, unsigned nr_pages
)
194 return mpage_readpages(mapping
, pages
, nr_pages
, udf_get_block
);
197 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
198 loff_t pos
, unsigned len
, unsigned flags
,
199 struct page
**pagep
, void **fsdata
)
203 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
205 udf_write_failed(mapping
, pos
+ len
);
209 static ssize_t
udf_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
211 struct file
*file
= iocb
->ki_filp
;
212 struct address_space
*mapping
= file
->f_mapping
;
213 struct inode
*inode
= mapping
->host
;
214 size_t count
= iov_iter_count(iter
);
217 ret
= blockdev_direct_IO(iocb
, inode
, iter
, udf_get_block
);
218 if (unlikely(ret
< 0 && iov_iter_rw(iter
) == WRITE
))
219 udf_write_failed(mapping
, iocb
->ki_pos
+ count
);
223 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
225 return generic_block_bmap(mapping
, block
, udf_get_block
);
228 const struct address_space_operations udf_aops
= {
229 .readpage
= udf_readpage
,
230 .readpages
= udf_readpages
,
231 .writepage
= udf_writepage
,
232 .writepages
= udf_writepages
,
233 .write_begin
= udf_write_begin
,
234 .write_end
= generic_write_end
,
235 .direct_IO
= udf_direct_IO
,
240 * Expand file stored in ICB to a normal one-block-file
242 * This function requires i_data_sem for writing and releases it.
243 * This function requires i_mutex held
245 int udf_expand_file_adinicb(struct inode
*inode
)
249 struct udf_inode_info
*iinfo
= UDF_I(inode
);
251 struct writeback_control udf_wbc
= {
252 .sync_mode
= WB_SYNC_NONE
,
256 WARN_ON_ONCE(!inode_is_locked(inode
));
257 if (!iinfo
->i_lenAlloc
) {
258 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
259 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
261 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
262 /* from now on we have normal address_space methods */
263 inode
->i_data
.a_ops
= &udf_aops
;
264 up_write(&iinfo
->i_data_sem
);
265 mark_inode_dirty(inode
);
269 * Release i_data_sem so that we can lock a page - page lock ranks
270 * above i_data_sem. i_mutex still protects us against file changes.
272 up_write(&iinfo
->i_data_sem
);
274 page
= find_or_create_page(inode
->i_mapping
, 0, GFP_NOFS
);
278 if (!PageUptodate(page
)) {
279 kaddr
= kmap_atomic(page
);
280 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
281 PAGE_SIZE
- iinfo
->i_lenAlloc
);
282 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
284 flush_dcache_page(page
);
285 SetPageUptodate(page
);
286 kunmap_atomic(kaddr
);
288 down_write(&iinfo
->i_data_sem
);
289 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
291 iinfo
->i_lenAlloc
= 0;
292 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
293 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
295 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
296 /* from now on we have normal address_space methods */
297 inode
->i_data
.a_ops
= &udf_aops
;
298 up_write(&iinfo
->i_data_sem
);
299 err
= inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
301 /* Restore everything back so that we don't lose data... */
303 down_write(&iinfo
->i_data_sem
);
304 kaddr
= kmap_atomic(page
);
305 memcpy(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, kaddr
,
307 kunmap_atomic(kaddr
);
309 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
310 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
311 up_write(&iinfo
->i_data_sem
);
314 mark_inode_dirty(inode
);
319 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
323 struct buffer_head
*dbh
= NULL
;
324 struct kernel_lb_addr eloc
;
326 struct extent_position epos
;
328 struct udf_fileident_bh sfibh
, dfibh
;
329 loff_t f_pos
= udf_ext0_offset(inode
);
330 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
331 struct fileIdentDesc cfi
, *sfi
, *dfi
;
332 struct udf_inode_info
*iinfo
= UDF_I(inode
);
334 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
335 alloctype
= ICBTAG_FLAG_AD_SHORT
;
337 alloctype
= ICBTAG_FLAG_AD_LONG
;
339 if (!inode
->i_size
) {
340 iinfo
->i_alloc_type
= alloctype
;
341 mark_inode_dirty(inode
);
345 /* alloc block, and copy data to it */
346 *block
= udf_new_block(inode
->i_sb
, inode
,
347 iinfo
->i_location
.partitionReferenceNum
,
348 iinfo
->i_location
.logicalBlockNum
, err
);
351 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
352 iinfo
->i_location
.partitionReferenceNum
,
356 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
360 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
361 set_buffer_uptodate(dbh
);
363 mark_buffer_dirty_inode(dbh
, inode
);
365 sfibh
.soffset
= sfibh
.eoffset
=
366 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
367 sfibh
.sbh
= sfibh
.ebh
= NULL
;
368 dfibh
.soffset
= dfibh
.eoffset
= 0;
369 dfibh
.sbh
= dfibh
.ebh
= dbh
;
370 while (f_pos
< size
) {
371 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
372 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
378 iinfo
->i_alloc_type
= alloctype
;
379 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
380 dfibh
.soffset
= dfibh
.eoffset
;
381 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
382 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
383 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
385 le16_to_cpu(sfi
->lengthOfImpUse
))) {
386 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
391 mark_buffer_dirty_inode(dbh
, inode
);
393 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
395 iinfo
->i_lenAlloc
= 0;
396 eloc
.logicalBlockNum
= *block
;
397 eloc
.partitionReferenceNum
=
398 iinfo
->i_location
.partitionReferenceNum
;
399 iinfo
->i_lenExtents
= inode
->i_size
;
401 epos
.block
= iinfo
->i_location
;
402 epos
.offset
= udf_file_entry_alloc_offset(inode
);
403 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
407 mark_inode_dirty(inode
);
411 static int udf_get_block(struct inode
*inode
, sector_t block
,
412 struct buffer_head
*bh_result
, int create
)
416 struct udf_inode_info
*iinfo
;
419 phys
= udf_block_map(inode
, block
);
421 map_bh(bh_result
, inode
->i_sb
, phys
);
427 iinfo
= UDF_I(inode
);
429 down_write(&iinfo
->i_data_sem
);
430 if (block
== iinfo
->i_next_alloc_block
+ 1) {
431 iinfo
->i_next_alloc_block
++;
432 iinfo
->i_next_alloc_goal
++;
435 udf_clear_extent_cache(inode
);
436 phys
= inode_getblk(inode
, block
, &err
, &new);
441 set_buffer_new(bh_result
);
442 map_bh(bh_result
, inode
->i_sb
, phys
);
445 up_write(&iinfo
->i_data_sem
);
449 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
450 int create
, int *err
)
452 struct buffer_head
*bh
;
453 struct buffer_head dummy
;
456 dummy
.b_blocknr
= -1000;
457 *err
= udf_get_block(inode
, block
, &dummy
, create
);
458 if (!*err
&& buffer_mapped(&dummy
)) {
459 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
460 if (buffer_new(&dummy
)) {
462 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
463 set_buffer_uptodate(bh
);
465 mark_buffer_dirty_inode(bh
, inode
);
473 /* Extend the file by 'blocks' blocks, return the number of extents added */
474 static int udf_do_extend_file(struct inode
*inode
,
475 struct extent_position
*last_pos
,
476 struct kernel_long_ad
*last_ext
,
480 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
481 struct super_block
*sb
= inode
->i_sb
;
482 struct kernel_lb_addr prealloc_loc
= {};
483 int prealloc_len
= 0;
484 struct udf_inode_info
*iinfo
;
487 /* The previous extent is fake and we should not extend by anything
488 * - there's nothing to do... */
492 iinfo
= UDF_I(inode
);
493 /* Round the last extent up to a multiple of block size */
494 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
495 last_ext
->extLength
=
496 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
497 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
498 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
499 iinfo
->i_lenExtents
=
500 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
501 ~(sb
->s_blocksize
- 1);
504 /* Last extent are just preallocated blocks? */
505 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
506 EXT_NOT_RECORDED_ALLOCATED
) {
507 /* Save the extent so that we can reattach it to the end */
508 prealloc_loc
= last_ext
->extLocation
;
509 prealloc_len
= last_ext
->extLength
;
510 /* Mark the extent as a hole */
511 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
512 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
513 last_ext
->extLocation
.logicalBlockNum
= 0;
514 last_ext
->extLocation
.partitionReferenceNum
= 0;
517 /* Can we merge with the previous extent? */
518 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
519 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
520 add
= ((1 << 30) - sb
->s_blocksize
-
521 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
522 sb
->s_blocksize_bits
;
526 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
530 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
531 last_ext
->extLength
, 1);
534 struct kernel_lb_addr tmploc
;
537 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
538 last_ext
->extLength
, 1);
540 * We've rewritten the last extent but there may be empty
541 * indirect extent after it - enter it.
543 udf_next_aext(inode
, last_pos
, &tmploc
, &tmplen
, 0);
546 /* Managed to do everything necessary? */
550 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
551 last_ext
->extLocation
.logicalBlockNum
= 0;
552 last_ext
->extLocation
.partitionReferenceNum
= 0;
553 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
554 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
555 (add
<< sb
->s_blocksize_bits
);
557 /* Create enough extents to cover the whole hole */
558 while (blocks
> add
) {
560 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
561 last_ext
->extLength
, 1);
567 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
568 (blocks
<< sb
->s_blocksize_bits
);
569 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
570 last_ext
->extLength
, 1);
577 /* Do we have some preallocated blocks saved? */
579 err
= udf_add_aext(inode
, last_pos
, &prealloc_loc
,
583 last_ext
->extLocation
= prealloc_loc
;
584 last_ext
->extLength
= prealloc_len
;
588 /* last_pos should point to the last written extent... */
589 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
590 last_pos
->offset
-= sizeof(struct short_ad
);
591 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
592 last_pos
->offset
-= sizeof(struct long_ad
);
599 static int udf_extend_file(struct inode
*inode
, loff_t newsize
)
602 struct extent_position epos
;
603 struct kernel_lb_addr eloc
;
606 struct super_block
*sb
= inode
->i_sb
;
607 sector_t first_block
= newsize
>> sb
->s_blocksize_bits
, offset
;
609 struct udf_inode_info
*iinfo
= UDF_I(inode
);
610 struct kernel_long_ad extent
;
613 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
614 adsize
= sizeof(struct short_ad
);
615 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
616 adsize
= sizeof(struct long_ad
);
620 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
622 /* File has extent covering the new size (could happen when extending
623 * inside a block)? */
626 if (newsize
& (sb
->s_blocksize
- 1))
628 /* Extended file just to the boundary of the last file block? */
632 /* Truncate is extending the file by 'offset' blocks */
633 if ((!epos
.bh
&& epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
634 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
635 /* File has no extents at all or has empty last
636 * indirect extent! Create a fake extent... */
637 extent
.extLocation
.logicalBlockNum
= 0;
638 extent
.extLocation
.partitionReferenceNum
= 0;
639 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
641 epos
.offset
-= adsize
;
642 etype
= udf_next_aext(inode
, &epos
, &extent
.extLocation
,
643 &extent
.extLength
, 0);
644 extent
.extLength
|= etype
<< 30;
646 err
= udf_do_extend_file(inode
, &epos
, &extent
, offset
);
650 iinfo
->i_lenExtents
= newsize
;
656 static sector_t
inode_getblk(struct inode
*inode
, sector_t block
,
659 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
660 struct extent_position prev_epos
, cur_epos
, next_epos
;
661 int count
= 0, startnum
= 0, endnum
= 0;
662 uint32_t elen
= 0, tmpelen
;
663 struct kernel_lb_addr eloc
, tmpeloc
;
665 loff_t lbcount
= 0, b_off
= 0;
666 uint32_t newblocknum
, newblock
;
669 struct udf_inode_info
*iinfo
= UDF_I(inode
);
670 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
676 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
677 prev_epos
.block
= iinfo
->i_location
;
679 cur_epos
= next_epos
= prev_epos
;
680 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
682 /* find the extent which contains the block we are looking for.
683 alternate between laarr[0] and laarr[1] for locations of the
684 current extent, and the previous extent */
686 if (prev_epos
.bh
!= cur_epos
.bh
) {
687 brelse(prev_epos
.bh
);
689 prev_epos
.bh
= cur_epos
.bh
;
691 if (cur_epos
.bh
!= next_epos
.bh
) {
693 get_bh(next_epos
.bh
);
694 cur_epos
.bh
= next_epos
.bh
;
699 prev_epos
.block
= cur_epos
.block
;
700 cur_epos
.block
= next_epos
.block
;
702 prev_epos
.offset
= cur_epos
.offset
;
703 cur_epos
.offset
= next_epos
.offset
;
705 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
711 laarr
[c
].extLength
= (etype
<< 30) | elen
;
712 laarr
[c
].extLocation
= eloc
;
714 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
715 pgoal
= eloc
.logicalBlockNum
+
716 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
717 inode
->i_sb
->s_blocksize_bits
);
720 } while (lbcount
+ elen
<= b_off
);
723 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
725 * Move prev_epos and cur_epos into indirect extent if we are at
728 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
729 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
731 /* if the extent is allocated and recorded, return the block
732 if the extent is not a multiple of the blocksize, round up */
734 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
735 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
736 elen
= EXT_RECORDED_ALLOCATED
|
737 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
738 ~(inode
->i_sb
->s_blocksize
- 1));
739 udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
741 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
745 /* Are we beyond EOF? */
754 /* Create a fake extent when there's not one */
755 memset(&laarr
[0].extLocation
, 0x00,
756 sizeof(struct kernel_lb_addr
));
757 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
758 /* Will udf_do_extend_file() create real extent from
760 startnum
= (offset
> 0);
762 /* Create extents for the hole between EOF and offset */
763 ret
= udf_do_extend_file(inode
, &prev_epos
, laarr
, offset
);
772 /* We are not covered by a preallocated extent? */
773 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
774 EXT_NOT_RECORDED_ALLOCATED
) {
775 /* Is there any real extent? - otherwise we overwrite
779 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
780 inode
->i_sb
->s_blocksize
;
781 memset(&laarr
[c
].extLocation
, 0x00,
782 sizeof(struct kernel_lb_addr
));
789 endnum
= startnum
= ((count
> 2) ? 2 : count
);
791 /* if the current extent is in position 0,
792 swap it with the previous */
793 if (!c
&& count
!= 1) {
800 /* if the current block is located in an extent,
801 read the next extent */
802 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
804 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
805 laarr
[c
+ 1].extLocation
= eloc
;
813 /* if the current extent is not recorded but allocated, get the
814 * block in the extent corresponding to the requested block */
815 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
816 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
817 else { /* otherwise, allocate a new block */
818 if (iinfo
->i_next_alloc_block
== block
)
819 goal
= iinfo
->i_next_alloc_goal
;
822 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
823 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
826 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
827 iinfo
->i_location
.partitionReferenceNum
,
835 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
838 /* if the extent the requsted block is located in contains multiple
839 * blocks, split the extent into at most three extents. blocks prior
840 * to requested block, requested block, and blocks after requested
842 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
844 /* We preallocate blocks only for regular files. It also makes sense
845 * for directories but there's a problem when to drop the
846 * preallocation. We might use some delayed work for that but I feel
847 * it's overengineering for a filesystem like UDF. */
848 if (S_ISREG(inode
->i_mode
))
849 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
851 /* merge any continuous blocks in laarr */
852 udf_merge_extents(inode
, laarr
, &endnum
);
854 /* write back the new extents, inserting new extents if the new number
855 * of extents is greater than the old number, and deleting extents if
856 * the new number of extents is less than the old number */
857 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
859 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
860 iinfo
->i_location
.partitionReferenceNum
, 0);
866 iinfo
->i_next_alloc_block
= block
;
867 iinfo
->i_next_alloc_goal
= newblocknum
;
868 inode
->i_ctime
= current_time(inode
);
871 udf_sync_inode(inode
);
873 mark_inode_dirty(inode
);
875 brelse(prev_epos
.bh
);
877 brelse(next_epos
.bh
);
881 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
882 int newblocknum
, struct kernel_long_ad
*laarr
,
885 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
886 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
888 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
889 (laarr
[*c
].extLength
>> 30) ==
890 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
892 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
893 blocksize
- 1) >> blocksize_bits
;
894 int8_t etype
= (laarr
[curr
].extLength
>> 30);
898 else if (!offset
|| blen
== offset
+ 1) {
899 laarr
[curr
+ 2] = laarr
[curr
+ 1];
900 laarr
[curr
+ 1] = laarr
[curr
];
902 laarr
[curr
+ 3] = laarr
[curr
+ 1];
903 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
907 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
908 udf_free_blocks(inode
->i_sb
, inode
,
909 &laarr
[curr
].extLocation
,
911 laarr
[curr
].extLength
=
912 EXT_NOT_RECORDED_NOT_ALLOCATED
|
913 (offset
<< blocksize_bits
);
914 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
915 laarr
[curr
].extLocation
.
916 partitionReferenceNum
= 0;
918 laarr
[curr
].extLength
= (etype
<< 30) |
919 (offset
<< blocksize_bits
);
925 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
926 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
927 laarr
[curr
].extLocation
.partitionReferenceNum
=
928 UDF_I(inode
)->i_location
.partitionReferenceNum
;
929 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
933 if (blen
!= offset
+ 1) {
934 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
935 laarr
[curr
].extLocation
.logicalBlockNum
+=
937 laarr
[curr
].extLength
= (etype
<< 30) |
938 ((blen
- (offset
+ 1)) << blocksize_bits
);
945 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
946 struct kernel_long_ad
*laarr
,
949 int start
, length
= 0, currlength
= 0, i
;
951 if (*endnum
>= (c
+ 1)) {
957 if ((laarr
[c
+ 1].extLength
>> 30) ==
958 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
960 length
= currlength
=
961 (((laarr
[c
+ 1].extLength
&
962 UDF_EXTENT_LENGTH_MASK
) +
963 inode
->i_sb
->s_blocksize
- 1) >>
964 inode
->i_sb
->s_blocksize_bits
);
969 for (i
= start
+ 1; i
<= *endnum
; i
++) {
972 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
973 } else if ((laarr
[i
].extLength
>> 30) ==
974 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
975 length
+= (((laarr
[i
].extLength
&
976 UDF_EXTENT_LENGTH_MASK
) +
977 inode
->i_sb
->s_blocksize
- 1) >>
978 inode
->i_sb
->s_blocksize_bits
);
984 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
985 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
986 inode
->i_sb
->s_blocksize
- 1) >>
987 inode
->i_sb
->s_blocksize_bits
);
988 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
989 laarr
[start
].extLocation
.partitionReferenceNum
,
990 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
991 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
994 if (start
== (c
+ 1))
995 laarr
[start
].extLength
+=
997 inode
->i_sb
->s_blocksize_bits
);
999 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
1000 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
1002 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
1003 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
1004 laarr
[c
].extLocation
.
1005 partitionReferenceNum
;
1006 laarr
[c
+ 1].extLength
=
1007 EXT_NOT_RECORDED_ALLOCATED
|
1009 inode
->i_sb
->s_blocksize_bits
);
1013 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
1014 int elen
= ((laarr
[i
].extLength
&
1015 UDF_EXTENT_LENGTH_MASK
) +
1016 inode
->i_sb
->s_blocksize
- 1) >>
1017 inode
->i_sb
->s_blocksize_bits
;
1019 if (elen
> numalloc
) {
1020 laarr
[i
].extLength
-=
1022 inode
->i_sb
->s_blocksize_bits
);
1026 if (*endnum
> (i
+ 1))
1029 sizeof(struct long_ad
) *
1030 (*endnum
- (i
+ 1)));
1035 UDF_I(inode
)->i_lenExtents
+=
1036 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
1041 static void udf_merge_extents(struct inode
*inode
, struct kernel_long_ad
*laarr
,
1045 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
1046 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1048 for (i
= 0; i
< (*endnum
- 1); i
++) {
1049 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
1050 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
1052 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
1053 (((li
->extLength
>> 30) ==
1054 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
1055 ((lip1
->extLocation
.logicalBlockNum
-
1056 li
->extLocation
.logicalBlockNum
) ==
1057 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1058 blocksize
- 1) >> blocksize_bits
)))) {
1060 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1061 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1062 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1063 lip1
->extLength
= (lip1
->extLength
-
1065 UDF_EXTENT_LENGTH_MASK
) +
1066 UDF_EXTENT_LENGTH_MASK
) &
1068 li
->extLength
= (li
->extLength
&
1069 UDF_EXTENT_FLAG_MASK
) +
1070 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1072 lip1
->extLocation
.logicalBlockNum
=
1073 li
->extLocation
.logicalBlockNum
+
1075 UDF_EXTENT_LENGTH_MASK
) >>
1078 li
->extLength
= lip1
->extLength
+
1080 UDF_EXTENT_LENGTH_MASK
) +
1081 blocksize
- 1) & ~(blocksize
- 1));
1082 if (*endnum
> (i
+ 2))
1083 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1084 sizeof(struct long_ad
) *
1085 (*endnum
- (i
+ 2)));
1089 } else if (((li
->extLength
>> 30) ==
1090 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
1091 ((lip1
->extLength
>> 30) ==
1092 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
1093 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
1095 UDF_EXTENT_LENGTH_MASK
) +
1096 blocksize
- 1) >> blocksize_bits
);
1097 li
->extLocation
.logicalBlockNum
= 0;
1098 li
->extLocation
.partitionReferenceNum
= 0;
1100 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1101 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1102 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1103 lip1
->extLength
= (lip1
->extLength
-
1105 UDF_EXTENT_LENGTH_MASK
) +
1106 UDF_EXTENT_LENGTH_MASK
) &
1108 li
->extLength
= (li
->extLength
&
1109 UDF_EXTENT_FLAG_MASK
) +
1110 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1113 li
->extLength
= lip1
->extLength
+
1115 UDF_EXTENT_LENGTH_MASK
) +
1116 blocksize
- 1) & ~(blocksize
- 1));
1117 if (*endnum
> (i
+ 2))
1118 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1119 sizeof(struct long_ad
) *
1120 (*endnum
- (i
+ 2)));
1124 } else if ((li
->extLength
>> 30) ==
1125 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
1126 udf_free_blocks(inode
->i_sb
, inode
,
1127 &li
->extLocation
, 0,
1129 UDF_EXTENT_LENGTH_MASK
) +
1130 blocksize
- 1) >> blocksize_bits
);
1131 li
->extLocation
.logicalBlockNum
= 0;
1132 li
->extLocation
.partitionReferenceNum
= 0;
1133 li
->extLength
= (li
->extLength
&
1134 UDF_EXTENT_LENGTH_MASK
) |
1135 EXT_NOT_RECORDED_NOT_ALLOCATED
;
1140 static void udf_update_extents(struct inode
*inode
, struct kernel_long_ad
*laarr
,
1141 int startnum
, int endnum
,
1142 struct extent_position
*epos
)
1145 struct kernel_lb_addr tmploc
;
1148 if (startnum
> endnum
) {
1149 for (i
= 0; i
< (startnum
- endnum
); i
++)
1150 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
1151 laarr
[i
].extLength
);
1152 } else if (startnum
< endnum
) {
1153 for (i
= 0; i
< (endnum
- startnum
); i
++) {
1154 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
1155 laarr
[i
].extLength
);
1156 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
1157 &laarr
[i
].extLength
, 1);
1162 for (i
= start
; i
< endnum
; i
++) {
1163 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
1164 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
1165 laarr
[i
].extLength
, 1);
1169 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
1170 int create
, int *err
)
1172 struct buffer_head
*bh
= NULL
;
1174 bh
= udf_getblk(inode
, block
, create
, err
);
1178 if (buffer_uptodate(bh
))
1181 ll_rw_block(REQ_OP_READ
, 0, 1, &bh
);
1184 if (buffer_uptodate(bh
))
1192 int udf_setsize(struct inode
*inode
, loff_t newsize
)
1195 struct udf_inode_info
*iinfo
;
1196 int bsize
= i_blocksize(inode
);
1198 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1199 S_ISLNK(inode
->i_mode
)))
1201 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1204 iinfo
= UDF_I(inode
);
1205 if (newsize
> inode
->i_size
) {
1206 down_write(&iinfo
->i_data_sem
);
1207 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1209 (udf_file_entry_alloc_offset(inode
) + newsize
)) {
1210 err
= udf_expand_file_adinicb(inode
);
1213 down_write(&iinfo
->i_data_sem
);
1215 iinfo
->i_lenAlloc
= newsize
;
1219 err
= udf_extend_file(inode
, newsize
);
1221 up_write(&iinfo
->i_data_sem
);
1225 truncate_setsize(inode
, newsize
);
1226 up_write(&iinfo
->i_data_sem
);
1228 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1229 down_write(&iinfo
->i_data_sem
);
1230 udf_clear_extent_cache(inode
);
1231 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1232 0x00, bsize
- newsize
-
1233 udf_file_entry_alloc_offset(inode
));
1234 iinfo
->i_lenAlloc
= newsize
;
1235 truncate_setsize(inode
, newsize
);
1236 up_write(&iinfo
->i_data_sem
);
1239 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1243 down_write(&iinfo
->i_data_sem
);
1244 udf_clear_extent_cache(inode
);
1245 truncate_setsize(inode
, newsize
);
1246 udf_truncate_extents(inode
);
1247 up_write(&iinfo
->i_data_sem
);
1250 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1252 udf_sync_inode(inode
);
1254 mark_inode_dirty(inode
);
1259 * Maximum length of linked list formed by ICB hierarchy. The chosen number is
1260 * arbitrary - just that we hopefully don't limit any real use of rewritten
1261 * inode on write-once media but avoid looping for too long on corrupted media.
1263 #define UDF_MAX_ICB_NESTING 1024
1265 static int udf_read_inode(struct inode
*inode
, bool hidden_inode
)
1267 struct buffer_head
*bh
= NULL
;
1268 struct fileEntry
*fe
;
1269 struct extendedFileEntry
*efe
;
1271 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1272 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1273 struct kernel_lb_addr
*iloc
= &iinfo
->i_location
;
1274 unsigned int link_count
;
1275 unsigned int indirections
= 0;
1276 int bs
= inode
->i_sb
->s_blocksize
;
1280 if (iloc
->partitionReferenceNum
>= sbi
->s_partitions
) {
1281 udf_debug("partition reference: %d > logical volume partitions: %d\n",
1282 iloc
->partitionReferenceNum
, sbi
->s_partitions
);
1286 if (iloc
->logicalBlockNum
>=
1287 sbi
->s_partmaps
[iloc
->partitionReferenceNum
].s_partition_len
) {
1288 udf_debug("block=%d, partition=%d out of range\n",
1289 iloc
->logicalBlockNum
, iloc
->partitionReferenceNum
);
1294 * Set defaults, but the inode is still incomplete!
1295 * Note: get_new_inode() sets the following on a new inode:
1298 * i_flags = sb->s_flags
1300 * clean_inode(): zero fills and sets
1305 bh
= udf_read_ptagged(inode
->i_sb
, iloc
, 0, &ident
);
1307 udf_err(inode
->i_sb
, "(ino %ld) failed !bh\n", inode
->i_ino
);
1311 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1312 ident
!= TAG_IDENT_USE
) {
1313 udf_err(inode
->i_sb
, "(ino %ld) failed ident=%d\n",
1314 inode
->i_ino
, ident
);
1318 fe
= (struct fileEntry
*)bh
->b_data
;
1319 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1321 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1322 struct buffer_head
*ibh
;
1324 ibh
= udf_read_ptagged(inode
->i_sb
, iloc
, 1, &ident
);
1325 if (ident
== TAG_IDENT_IE
&& ibh
) {
1326 struct kernel_lb_addr loc
;
1327 struct indirectEntry
*ie
;
1329 ie
= (struct indirectEntry
*)ibh
->b_data
;
1330 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1332 if (ie
->indirectICB
.extLength
) {
1334 memcpy(&iinfo
->i_location
, &loc
,
1335 sizeof(struct kernel_lb_addr
));
1336 if (++indirections
> UDF_MAX_ICB_NESTING
) {
1337 udf_err(inode
->i_sb
,
1338 "too many ICBs in ICB hierarchy"
1339 " (max %d supported)\n",
1340 UDF_MAX_ICB_NESTING
);
1348 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1349 udf_err(inode
->i_sb
, "unsupported strategy type: %d\n",
1350 le16_to_cpu(fe
->icbTag
.strategyType
));
1353 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1354 iinfo
->i_strat4096
= 0;
1355 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1356 iinfo
->i_strat4096
= 1;
1358 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1359 ICBTAG_FLAG_AD_MASK
;
1360 iinfo
->i_unique
= 0;
1361 iinfo
->i_lenEAttr
= 0;
1362 iinfo
->i_lenExtents
= 0;
1363 iinfo
->i_lenAlloc
= 0;
1364 iinfo
->i_next_alloc_block
= 0;
1365 iinfo
->i_next_alloc_goal
= 0;
1366 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1369 ret
= udf_alloc_i_data(inode
, bs
-
1370 sizeof(struct extendedFileEntry
));
1373 memcpy(iinfo
->i_ext
.i_data
,
1374 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1375 bs
- sizeof(struct extendedFileEntry
));
1376 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1379 ret
= udf_alloc_i_data(inode
, bs
- sizeof(struct fileEntry
));
1382 memcpy(iinfo
->i_ext
.i_data
,
1383 bh
->b_data
+ sizeof(struct fileEntry
),
1384 bs
- sizeof(struct fileEntry
));
1385 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1388 iinfo
->i_lenAlloc
= le32_to_cpu(
1389 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1391 ret
= udf_alloc_i_data(inode
, bs
-
1392 sizeof(struct unallocSpaceEntry
));
1395 memcpy(iinfo
->i_ext
.i_data
,
1396 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1397 bs
- sizeof(struct unallocSpaceEntry
));
1402 read_lock(&sbi
->s_cred_lock
);
1403 i_uid_write(inode
, le32_to_cpu(fe
->uid
));
1404 if (!uid_valid(inode
->i_uid
) ||
1405 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1406 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1407 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1409 i_gid_write(inode
, le32_to_cpu(fe
->gid
));
1410 if (!gid_valid(inode
->i_gid
) ||
1411 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1412 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1413 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1415 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1416 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1417 inode
->i_mode
= sbi
->s_fmode
;
1418 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1419 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1420 inode
->i_mode
= sbi
->s_dmode
;
1422 inode
->i_mode
= udf_convert_permissions(fe
);
1423 inode
->i_mode
&= ~sbi
->s_umask
;
1424 read_unlock(&sbi
->s_cred_lock
);
1426 link_count
= le16_to_cpu(fe
->fileLinkCount
);
1428 if (!hidden_inode
) {
1434 set_nlink(inode
, link_count
);
1436 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1437 iinfo
->i_lenExtents
= inode
->i_size
;
1439 if (iinfo
->i_efe
== 0) {
1440 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1441 (inode
->i_sb
->s_blocksize_bits
- 9);
1443 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1444 inode
->i_atime
= sbi
->s_record_time
;
1446 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1447 fe
->modificationTime
))
1448 inode
->i_mtime
= sbi
->s_record_time
;
1450 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1451 inode
->i_ctime
= sbi
->s_record_time
;
1453 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1454 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1455 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1456 iinfo
->i_checkpoint
= le32_to_cpu(fe
->checkpoint
);
1458 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1459 (inode
->i_sb
->s_blocksize_bits
- 9);
1461 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1462 inode
->i_atime
= sbi
->s_record_time
;
1464 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1465 efe
->modificationTime
))
1466 inode
->i_mtime
= sbi
->s_record_time
;
1468 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1469 iinfo
->i_crtime
= sbi
->s_record_time
;
1471 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1472 inode
->i_ctime
= sbi
->s_record_time
;
1474 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1475 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1476 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1477 iinfo
->i_checkpoint
= le32_to_cpu(efe
->checkpoint
);
1479 inode
->i_generation
= iinfo
->i_unique
;
1482 * Sanity check length of allocation descriptors and extended attrs to
1483 * avoid integer overflows
1485 if (iinfo
->i_lenEAttr
> bs
|| iinfo
->i_lenAlloc
> bs
)
1487 /* Now do exact checks */
1488 if (udf_file_entry_alloc_offset(inode
) + iinfo
->i_lenAlloc
> bs
)
1490 /* Sanity checks for files in ICB so that we don't get confused later */
1491 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1493 * For file in ICB data is stored in allocation descriptor
1494 * so sizes should match
1496 if (iinfo
->i_lenAlloc
!= inode
->i_size
)
1498 /* File in ICB has to fit in there... */
1499 if (inode
->i_size
> bs
- udf_file_entry_alloc_offset(inode
))
1503 switch (fe
->icbTag
.fileType
) {
1504 case ICBTAG_FILE_TYPE_DIRECTORY
:
1505 inode
->i_op
= &udf_dir_inode_operations
;
1506 inode
->i_fop
= &udf_dir_operations
;
1507 inode
->i_mode
|= S_IFDIR
;
1510 case ICBTAG_FILE_TYPE_REALTIME
:
1511 case ICBTAG_FILE_TYPE_REGULAR
:
1512 case ICBTAG_FILE_TYPE_UNDEF
:
1513 case ICBTAG_FILE_TYPE_VAT20
:
1514 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1515 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1517 inode
->i_data
.a_ops
= &udf_aops
;
1518 inode
->i_op
= &udf_file_inode_operations
;
1519 inode
->i_fop
= &udf_file_operations
;
1520 inode
->i_mode
|= S_IFREG
;
1522 case ICBTAG_FILE_TYPE_BLOCK
:
1523 inode
->i_mode
|= S_IFBLK
;
1525 case ICBTAG_FILE_TYPE_CHAR
:
1526 inode
->i_mode
|= S_IFCHR
;
1528 case ICBTAG_FILE_TYPE_FIFO
:
1529 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1531 case ICBTAG_FILE_TYPE_SOCKET
:
1532 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1534 case ICBTAG_FILE_TYPE_SYMLINK
:
1535 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1536 inode
->i_op
= &udf_symlink_inode_operations
;
1537 inode_nohighmem(inode
);
1538 inode
->i_mode
= S_IFLNK
| 0777;
1540 case ICBTAG_FILE_TYPE_MAIN
:
1541 udf_debug("METADATA FILE-----\n");
1543 case ICBTAG_FILE_TYPE_MIRROR
:
1544 udf_debug("METADATA MIRROR FILE-----\n");
1546 case ICBTAG_FILE_TYPE_BITMAP
:
1547 udf_debug("METADATA BITMAP FILE-----\n");
1550 udf_err(inode
->i_sb
, "(ino %ld) failed unknown file type=%d\n",
1551 inode
->i_ino
, fe
->icbTag
.fileType
);
1554 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1555 struct deviceSpec
*dsea
=
1556 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1558 init_special_inode(inode
, inode
->i_mode
,
1559 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1560 le32_to_cpu(dsea
->minorDeviceIdent
)));
1561 /* Developer ID ??? */
1571 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1573 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1574 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1576 if (!iinfo
->i_ext
.i_data
) {
1577 udf_err(inode
->i_sb
, "(ino %ld) no free memory\n",
1585 static umode_t
udf_convert_permissions(struct fileEntry
*fe
)
1588 uint32_t permissions
;
1591 permissions
= le32_to_cpu(fe
->permissions
);
1592 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1594 mode
= ((permissions
) & 0007) |
1595 ((permissions
>> 2) & 0070) |
1596 ((permissions
>> 4) & 0700) |
1597 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1598 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1599 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1604 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1606 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1609 static int udf_sync_inode(struct inode
*inode
)
1611 return udf_update_inode(inode
, 1);
1614 static void udf_adjust_time(struct udf_inode_info
*iinfo
, struct timespec time
)
1616 if (iinfo
->i_crtime
.tv_sec
> time
.tv_sec
||
1617 (iinfo
->i_crtime
.tv_sec
== time
.tv_sec
&&
1618 iinfo
->i_crtime
.tv_nsec
> time
.tv_nsec
))
1619 iinfo
->i_crtime
= time
;
1622 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1624 struct buffer_head
*bh
= NULL
;
1625 struct fileEntry
*fe
;
1626 struct extendedFileEntry
*efe
;
1627 uint64_t lb_recorded
;
1632 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1633 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1634 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1636 bh
= udf_tgetblk(inode
->i_sb
,
1637 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1639 udf_debug("getblk failure\n");
1644 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1645 fe
= (struct fileEntry
*)bh
->b_data
;
1646 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1649 struct unallocSpaceEntry
*use
=
1650 (struct unallocSpaceEntry
*)bh
->b_data
;
1652 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1653 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1654 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1655 sizeof(struct unallocSpaceEntry
));
1656 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1657 crclen
= sizeof(struct unallocSpaceEntry
);
1662 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1663 fe
->uid
= cpu_to_le32(-1);
1665 fe
->uid
= cpu_to_le32(i_uid_read(inode
));
1667 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1668 fe
->gid
= cpu_to_le32(-1);
1670 fe
->gid
= cpu_to_le32(i_gid_read(inode
));
1672 udfperms
= ((inode
->i_mode
& 0007)) |
1673 ((inode
->i_mode
& 0070) << 2) |
1674 ((inode
->i_mode
& 0700) << 4);
1676 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1677 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1678 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1679 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1680 fe
->permissions
= cpu_to_le32(udfperms
);
1682 if (S_ISDIR(inode
->i_mode
) && inode
->i_nlink
> 0)
1683 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1685 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1687 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1689 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1691 struct deviceSpec
*dsea
=
1692 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1694 dsea
= (struct deviceSpec
*)
1695 udf_add_extendedattr(inode
,
1696 sizeof(struct deviceSpec
) +
1697 sizeof(struct regid
), 12, 0x3);
1698 dsea
->attrType
= cpu_to_le32(12);
1699 dsea
->attrSubtype
= 1;
1700 dsea
->attrLength
= cpu_to_le32(
1701 sizeof(struct deviceSpec
) +
1702 sizeof(struct regid
));
1703 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1705 eid
= (struct regid
*)dsea
->impUse
;
1706 memset(eid
, 0, sizeof(struct regid
));
1707 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1708 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1709 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1710 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1711 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1714 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1715 lb_recorded
= 0; /* No extents => no blocks! */
1718 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1719 (blocksize_bits
- 9);
1721 if (iinfo
->i_efe
== 0) {
1722 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1723 iinfo
->i_ext
.i_data
,
1724 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1725 fe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1727 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1728 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1729 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1730 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1731 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1732 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1733 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1734 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1735 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1736 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1737 fe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1738 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1739 crclen
= sizeof(struct fileEntry
);
1741 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1742 iinfo
->i_ext
.i_data
,
1743 inode
->i_sb
->s_blocksize
-
1744 sizeof(struct extendedFileEntry
));
1745 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1746 efe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1748 udf_adjust_time(iinfo
, inode
->i_atime
);
1749 udf_adjust_time(iinfo
, inode
->i_mtime
);
1750 udf_adjust_time(iinfo
, inode
->i_ctime
);
1752 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1753 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1754 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1755 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1757 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1758 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1759 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1760 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1761 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1762 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1763 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1764 efe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1765 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1766 crclen
= sizeof(struct extendedFileEntry
);
1770 if (iinfo
->i_strat4096
) {
1771 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1772 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1773 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1775 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1776 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1780 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_USE
;
1781 else if (S_ISDIR(inode
->i_mode
))
1782 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1783 else if (S_ISREG(inode
->i_mode
))
1784 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1785 else if (S_ISLNK(inode
->i_mode
))
1786 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1787 else if (S_ISBLK(inode
->i_mode
))
1788 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1789 else if (S_ISCHR(inode
->i_mode
))
1790 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1791 else if (S_ISFIFO(inode
->i_mode
))
1792 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1793 else if (S_ISSOCK(inode
->i_mode
))
1794 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1796 icbflags
= iinfo
->i_alloc_type
|
1797 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1798 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1799 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1800 (le16_to_cpu(fe
->icbTag
.flags
) &
1801 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1802 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1804 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1805 if (sbi
->s_udfrev
>= 0x0200)
1806 fe
->descTag
.descVersion
= cpu_to_le16(3);
1808 fe
->descTag
.descVersion
= cpu_to_le16(2);
1809 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1810 fe
->descTag
.tagLocation
= cpu_to_le32(
1811 iinfo
->i_location
.logicalBlockNum
);
1812 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1813 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1814 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1816 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1818 set_buffer_uptodate(bh
);
1821 /* write the data blocks */
1822 mark_buffer_dirty(bh
);
1824 sync_dirty_buffer(bh
);
1825 if (buffer_write_io_error(bh
)) {
1826 udf_warn(inode
->i_sb
, "IO error syncing udf inode [%08lx]\n",
1836 struct inode
*__udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
,
1839 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1840 struct inode
*inode
= iget_locked(sb
, block
);
1844 return ERR_PTR(-ENOMEM
);
1846 if (!(inode
->i_state
& I_NEW
))
1849 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1850 err
= udf_read_inode(inode
, hidden_inode
);
1853 return ERR_PTR(err
);
1855 unlock_new_inode(inode
);
1860 int udf_setup_indirect_aext(struct inode
*inode
, int block
,
1861 struct extent_position
*epos
)
1863 struct super_block
*sb
= inode
->i_sb
;
1864 struct buffer_head
*bh
;
1865 struct allocExtDesc
*aed
;
1866 struct extent_position nepos
;
1867 struct kernel_lb_addr neloc
;
1870 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1871 adsize
= sizeof(struct short_ad
);
1872 else if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1873 adsize
= sizeof(struct long_ad
);
1877 neloc
.logicalBlockNum
= block
;
1878 neloc
.partitionReferenceNum
= epos
->block
.partitionReferenceNum
;
1880 bh
= udf_tgetblk(sb
, udf_get_lb_pblock(sb
, &neloc
, 0));
1884 memset(bh
->b_data
, 0x00, sb
->s_blocksize
);
1885 set_buffer_uptodate(bh
);
1887 mark_buffer_dirty_inode(bh
, inode
);
1889 aed
= (struct allocExtDesc
*)(bh
->b_data
);
1890 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_STRICT
)) {
1891 aed
->previousAllocExtLocation
=
1892 cpu_to_le32(epos
->block
.logicalBlockNum
);
1894 aed
->lengthAllocDescs
= cpu_to_le32(0);
1895 if (UDF_SB(sb
)->s_udfrev
>= 0x0200)
1899 udf_new_tag(bh
->b_data
, TAG_IDENT_AED
, ver
, 1, block
,
1900 sizeof(struct tag
));
1902 nepos
.block
= neloc
;
1903 nepos
.offset
= sizeof(struct allocExtDesc
);
1907 * Do we have to copy current last extent to make space for indirect
1910 if (epos
->offset
+ adsize
> sb
->s_blocksize
) {
1911 struct kernel_lb_addr cp_loc
;
1915 epos
->offset
-= adsize
;
1916 cp_type
= udf_current_aext(inode
, epos
, &cp_loc
, &cp_len
, 0);
1917 cp_len
|= ((uint32_t)cp_type
) << 30;
1919 __udf_add_aext(inode
, &nepos
, &cp_loc
, cp_len
, 1);
1920 udf_write_aext(inode
, epos
, &nepos
.block
,
1921 sb
->s_blocksize
| EXT_NEXT_EXTENT_ALLOCDECS
, 0);
1923 __udf_add_aext(inode
, epos
, &nepos
.block
,
1924 sb
->s_blocksize
| EXT_NEXT_EXTENT_ALLOCDECS
, 0);
1934 * Append extent at the given position - should be the first free one in inode
1935 * / indirect extent. This function assumes there is enough space in the inode
1936 * or indirect extent. Use udf_add_aext() if you didn't check for this before.
1938 int __udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1939 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1941 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1942 struct allocExtDesc
*aed
;
1945 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1946 adsize
= sizeof(struct short_ad
);
1947 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1948 adsize
= sizeof(struct long_ad
);
1953 WARN_ON(iinfo
->i_lenAlloc
!=
1954 epos
->offset
- udf_file_entry_alloc_offset(inode
));
1956 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1957 WARN_ON(le32_to_cpu(aed
->lengthAllocDescs
) !=
1958 epos
->offset
- sizeof(struct allocExtDesc
));
1959 WARN_ON(epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
);
1962 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1965 iinfo
->i_lenAlloc
+= adsize
;
1966 mark_inode_dirty(inode
);
1968 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1969 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1970 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1971 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1972 udf_update_tag(epos
->bh
->b_data
,
1973 epos
->offset
+ (inc
? 0 : adsize
));
1975 udf_update_tag(epos
->bh
->b_data
,
1976 sizeof(struct allocExtDesc
));
1977 mark_buffer_dirty_inode(epos
->bh
, inode
);
1984 * Append extent at given position - should be the first free one in inode
1985 * / indirect extent. Takes care of allocating and linking indirect blocks.
1987 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1988 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1991 struct super_block
*sb
= inode
->i_sb
;
1993 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1994 adsize
= sizeof(struct short_ad
);
1995 else if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1996 adsize
= sizeof(struct long_ad
);
2000 if (epos
->offset
+ (2 * adsize
) > sb
->s_blocksize
) {
2004 new_block
= udf_new_block(sb
, NULL
,
2005 epos
->block
.partitionReferenceNum
,
2006 epos
->block
.logicalBlockNum
, &err
);
2010 err
= udf_setup_indirect_aext(inode
, new_block
, epos
);
2015 return __udf_add_aext(inode
, epos
, eloc
, elen
, inc
);
2018 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
2019 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
2023 struct short_ad
*sad
;
2024 struct long_ad
*lad
;
2025 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2028 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
2029 udf_file_entry_alloc_offset(inode
) +
2032 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2034 switch (iinfo
->i_alloc_type
) {
2035 case ICBTAG_FLAG_AD_SHORT
:
2036 sad
= (struct short_ad
*)ptr
;
2037 sad
->extLength
= cpu_to_le32(elen
);
2038 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
2039 adsize
= sizeof(struct short_ad
);
2041 case ICBTAG_FLAG_AD_LONG
:
2042 lad
= (struct long_ad
*)ptr
;
2043 lad
->extLength
= cpu_to_le32(elen
);
2044 lad
->extLocation
= cpu_to_lelb(*eloc
);
2045 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
2046 adsize
= sizeof(struct long_ad
);
2053 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2054 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
2055 struct allocExtDesc
*aed
=
2056 (struct allocExtDesc
*)epos
->bh
->b_data
;
2057 udf_update_tag(epos
->bh
->b_data
,
2058 le32_to_cpu(aed
->lengthAllocDescs
) +
2059 sizeof(struct allocExtDesc
));
2061 mark_buffer_dirty_inode(epos
->bh
, inode
);
2063 mark_inode_dirty(inode
);
2067 epos
->offset
+= adsize
;
2071 * Only 1 indirect extent in a row really makes sense but allow upto 16 in case
2072 * someone does some weird stuff.
2074 #define UDF_MAX_INDIR_EXTS 16
2076 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
2077 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2080 unsigned int indirections
= 0;
2082 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
2083 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
2086 if (++indirections
> UDF_MAX_INDIR_EXTS
) {
2087 udf_err(inode
->i_sb
,
2088 "too many indirect extents in inode %lu\n",
2093 epos
->block
= *eloc
;
2094 epos
->offset
= sizeof(struct allocExtDesc
);
2096 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
2097 epos
->bh
= udf_tread(inode
->i_sb
, block
);
2099 udf_debug("reading block %d failed!\n", block
);
2107 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
2108 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2113 struct short_ad
*sad
;
2114 struct long_ad
*lad
;
2115 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2119 epos
->offset
= udf_file_entry_alloc_offset(inode
);
2120 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
2121 udf_file_entry_alloc_offset(inode
) +
2123 alen
= udf_file_entry_alloc_offset(inode
) +
2127 epos
->offset
= sizeof(struct allocExtDesc
);
2128 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2129 alen
= sizeof(struct allocExtDesc
) +
2130 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
2134 switch (iinfo
->i_alloc_type
) {
2135 case ICBTAG_FLAG_AD_SHORT
:
2136 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
2139 etype
= le32_to_cpu(sad
->extLength
) >> 30;
2140 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
2141 eloc
->partitionReferenceNum
=
2142 iinfo
->i_location
.partitionReferenceNum
;
2143 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2145 case ICBTAG_FLAG_AD_LONG
:
2146 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
2149 etype
= le32_to_cpu(lad
->extLength
) >> 30;
2150 *eloc
= lelb_to_cpu(lad
->extLocation
);
2151 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2154 udf_debug("alloc_type = %d unsupported\n", iinfo
->i_alloc_type
);
2161 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
2162 struct kernel_lb_addr neloc
, uint32_t nelen
)
2164 struct kernel_lb_addr oeloc
;
2171 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2172 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2174 nelen
= (etype
<< 30) | oelen
;
2176 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2179 return (nelen
>> 30);
2182 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
2183 struct kernel_lb_addr eloc
, uint32_t elen
)
2185 struct extent_position oepos
;
2188 struct allocExtDesc
*aed
;
2189 struct udf_inode_info
*iinfo
;
2196 iinfo
= UDF_I(inode
);
2197 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2198 adsize
= sizeof(struct short_ad
);
2199 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2200 adsize
= sizeof(struct long_ad
);
2205 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2208 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2209 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2210 if (oepos
.bh
!= epos
.bh
) {
2211 oepos
.block
= epos
.block
;
2215 oepos
.offset
= epos
.offset
- adsize
;
2218 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2221 if (epos
.bh
!= oepos
.bh
) {
2222 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2223 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2224 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2226 iinfo
->i_lenAlloc
-= (adsize
* 2);
2227 mark_inode_dirty(inode
);
2229 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2230 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2231 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2232 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2233 udf_update_tag(oepos
.bh
->b_data
,
2234 oepos
.offset
- (2 * adsize
));
2236 udf_update_tag(oepos
.bh
->b_data
,
2237 sizeof(struct allocExtDesc
));
2238 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2241 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2243 iinfo
->i_lenAlloc
-= adsize
;
2244 mark_inode_dirty(inode
);
2246 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2247 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2248 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2249 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2250 udf_update_tag(oepos
.bh
->b_data
,
2251 epos
.offset
- adsize
);
2253 udf_update_tag(oepos
.bh
->b_data
,
2254 sizeof(struct allocExtDesc
));
2255 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2262 return (elen
>> 30);
2265 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2266 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2267 uint32_t *elen
, sector_t
*offset
)
2269 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2270 loff_t lbcount
= 0, bcount
= (loff_t
) block
<< blocksize_bits
;
2272 struct udf_inode_info
*iinfo
;
2274 iinfo
= UDF_I(inode
);
2275 if (!udf_read_extent_cache(inode
, bcount
, &lbcount
, pos
)) {
2277 pos
->block
= iinfo
->i_location
;
2282 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2284 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2285 iinfo
->i_lenExtents
= lbcount
;
2289 } while (lbcount
<= bcount
);
2290 /* update extent cache */
2291 udf_update_extent_cache(inode
, lbcount
- *elen
, pos
);
2292 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2297 long udf_block_map(struct inode
*inode
, sector_t block
)
2299 struct kernel_lb_addr eloc
;
2302 struct extent_position epos
= {};
2305 down_read(&UDF_I(inode
)->i_data_sem
);
2307 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2308 (EXT_RECORDED_ALLOCATED
>> 30))
2309 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2313 up_read(&UDF_I(inode
)->i_data_sem
);
2316 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2317 return udf_fixed_to_variable(ret
);