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 and udf_read_inode
23 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
24 * block boundaries (which is not actually allowed)
25 * 12/20/98 added support for strategy 4096
26 * 03/07/99 rewrote udf_block_map (again)
27 * New funcs, inode_bmap, udf_next_aext
28 * 04/19/99 Support for writing device EA's for major/minor #
33 #include <linux/smp_lock.h>
34 #include <linux/module.h>
35 #include <linux/pagemap.h>
36 #include <linux/buffer_head.h>
37 #include <linux/writeback.h>
38 #include <linux/slab.h>
43 MODULE_AUTHOR("Ben Fennema");
44 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
45 MODULE_LICENSE("GPL");
47 #define EXTENT_MERGE_SIZE 5
49 static mode_t
udf_convert_permissions(struct fileEntry
*);
50 static int udf_update_inode(struct inode
*, int);
51 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
52 static struct buffer_head
*inode_getblk(struct inode
*, sector_t
, int *,
54 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
55 kernel_lb_addr
, uint32_t);
56 static void udf_split_extents(struct inode
*, int *, int, int,
57 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
58 static void udf_prealloc_extents(struct inode
*, int, int,
59 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
60 static void udf_merge_extents(struct inode
*,
61 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
62 static void udf_update_extents(struct inode
*,
63 kernel_long_ad
[EXTENT_MERGE_SIZE
], int, int,
64 struct extent_position
*);
65 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
71 * Clean-up before the specified inode is destroyed.
74 * This routine is called when the kernel destroys an inode structure
75 * ie. when iput() finds i_count == 0.
78 * July 1, 1997 - Andrew E. Mileski
79 * Written, tested, and released.
81 * Called at the last iput() if i_nlink is zero.
83 void udf_delete_inode(struct inode
* inode
)
85 truncate_inode_pages(&inode
->i_data
, 0);
87 if (is_bad_inode(inode
))
94 udf_update_inode(inode
, IS_SYNC(inode
));
95 udf_free_inode(inode
);
103 void udf_clear_inode(struct inode
*inode
)
105 if (!(inode
->i_sb
->s_flags
& MS_RDONLY
)) {
107 udf_discard_prealloc(inode
);
111 kfree(UDF_I_DATA(inode
));
112 UDF_I_DATA(inode
) = NULL
;
115 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
117 return block_write_full_page(page
, udf_get_block
, wbc
);
120 static int udf_readpage(struct file
*file
, struct page
*page
)
122 return block_read_full_page(page
, udf_get_block
);
125 static int udf_prepare_write(struct file
*file
, struct page
*page
, unsigned from
, unsigned to
)
127 return block_prepare_write(page
, from
, to
, udf_get_block
);
130 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
132 return generic_block_bmap(mapping
,block
,udf_get_block
);
135 const struct address_space_operations udf_aops
= {
136 .readpage
= udf_readpage
,
137 .writepage
= udf_writepage
,
138 .sync_page
= block_sync_page
,
139 .prepare_write
= udf_prepare_write
,
140 .commit_write
= generic_commit_write
,
144 void udf_expand_file_adinicb(struct inode
* inode
, int newsize
, int * err
)
148 struct writeback_control udf_wbc
= {
149 .sync_mode
= WB_SYNC_NONE
,
153 /* from now on we have normal address_space methods */
154 inode
->i_data
.a_ops
= &udf_aops
;
156 if (!UDF_I_LENALLOC(inode
))
158 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
159 UDF_I_ALLOCTYPE(inode
) = ICBTAG_FLAG_AD_SHORT
;
161 UDF_I_ALLOCTYPE(inode
) = ICBTAG_FLAG_AD_LONG
;
162 mark_inode_dirty(inode
);
166 page
= grab_cache_page(inode
->i_mapping
, 0);
167 BUG_ON(!PageLocked(page
));
169 if (!PageUptodate(page
))
172 memset(kaddr
+ UDF_I_LENALLOC(inode
), 0x00,
173 PAGE_CACHE_SIZE
- UDF_I_LENALLOC(inode
));
174 memcpy(kaddr
, UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
),
175 UDF_I_LENALLOC(inode
));
176 flush_dcache_page(page
);
177 SetPageUptodate(page
);
180 memset(UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
), 0x00,
181 UDF_I_LENALLOC(inode
));
182 UDF_I_LENALLOC(inode
) = 0;
183 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
184 UDF_I_ALLOCTYPE(inode
) = ICBTAG_FLAG_AD_SHORT
;
186 UDF_I_ALLOCTYPE(inode
) = 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
, int *err
)
197 struct buffer_head
*dbh
= NULL
;
201 struct extent_position epos
;
203 struct udf_fileident_bh sfibh
, dfibh
;
204 loff_t f_pos
= udf_ext0_offset(inode
) >> 2;
205 int size
= (udf_ext0_offset(inode
) + inode
->i_size
) >> 2;
206 struct fileIdentDesc cfi
, *sfi
, *dfi
;
208 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
209 alloctype
= ICBTAG_FLAG_AD_SHORT
;
211 alloctype
= ICBTAG_FLAG_AD_LONG
;
215 UDF_I_ALLOCTYPE(inode
) = alloctype
;
216 mark_inode_dirty(inode
);
220 /* alloc block, and copy data to it */
221 *block
= udf_new_block(inode
->i_sb
, inode
,
222 UDF_I_LOCATION(inode
).partitionReferenceNum
,
223 UDF_I_LOCATION(inode
).logicalBlockNum
, err
);
227 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
228 UDF_I_LOCATION(inode
).partitionReferenceNum
, 0);
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
= (f_pos
& ((inode
->i_sb
->s_blocksize
- 1) >> 2)) << 2;
241 sfibh
.sbh
= sfibh
.ebh
= NULL
;
242 dfibh
.soffset
= dfibh
.eoffset
= 0;
243 dfibh
.sbh
= dfibh
.ebh
= dbh
;
244 while ( (f_pos
< size
) )
246 UDF_I_ALLOCTYPE(inode
) = ICBTAG_FLAG_AD_IN_ICB
;
247 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
, NULL
, NULL
, NULL
);
253 UDF_I_ALLOCTYPE(inode
) = alloctype
;
254 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
255 dfibh
.soffset
= dfibh
.eoffset
;
256 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
257 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
258 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
259 sfi
->fileIdent
+ le16_to_cpu(sfi
->lengthOfImpUse
)))
261 UDF_I_ALLOCTYPE(inode
) = ICBTAG_FLAG_AD_IN_ICB
;
266 mark_buffer_dirty_inode(dbh
, inode
);
268 memset(UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
), 0, UDF_I_LENALLOC(inode
));
269 UDF_I_LENALLOC(inode
) = 0;
270 eloc
.logicalBlockNum
= *block
;
271 eloc
.partitionReferenceNum
= UDF_I_LOCATION(inode
).partitionReferenceNum
;
272 elen
= inode
->i_size
;
273 UDF_I_LENEXTENTS(inode
) = elen
;
275 epos
.block
= UDF_I_LOCATION(inode
);
276 epos
.offset
= udf_file_entry_alloc_offset(inode
);
277 udf_add_aext(inode
, &epos
, eloc
, elen
, 0);
281 mark_inode_dirty(inode
);
285 static int udf_get_block(struct inode
*inode
, sector_t block
, struct buffer_head
*bh_result
, int create
)
288 struct buffer_head
*bh
;
293 phys
= udf_block_map(inode
, block
);
295 map_bh(bh_result
, inode
->i_sb
, phys
);
308 if (block
== UDF_I_NEXT_ALLOC_BLOCK(inode
) + 1)
310 UDF_I_NEXT_ALLOC_BLOCK(inode
) ++;
311 UDF_I_NEXT_ALLOC_GOAL(inode
) ++;
316 bh
= inode_getblk(inode
, block
, &err
, &phys
, &new);
323 set_buffer_new(bh_result
);
324 map_bh(bh_result
, inode
->i_sb
, phys
);
330 udf_warning(inode
->i_sb
, "udf_get_block", "block < 0");
334 static struct buffer_head
*
335 udf_getblk(struct inode
*inode
, long block
, int create
, int *err
)
337 struct buffer_head dummy
;
340 dummy
.b_blocknr
= -1000;
341 *err
= udf_get_block(inode
, block
, &dummy
, create
);
342 if (!*err
&& buffer_mapped(&dummy
))
344 struct buffer_head
*bh
;
345 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
346 if (buffer_new(&dummy
))
349 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
350 set_buffer_uptodate(bh
);
352 mark_buffer_dirty_inode(bh
, inode
);
359 static struct buffer_head
* inode_getblk(struct inode
* inode
, sector_t block
,
360 int *err
, long *phys
, int *new)
362 struct buffer_head
*result
= NULL
;
363 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
364 struct extent_position prev_epos
, cur_epos
, next_epos
;
365 int count
= 0, startnum
= 0, endnum
= 0;
369 loff_t lbcount
= 0, b_off
= 0;
370 uint32_t newblocknum
, newblock
;
373 int goal
= 0, pgoal
= UDF_I_LOCATION(inode
).logicalBlockNum
;
376 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
377 prev_epos
.block
= UDF_I_LOCATION(inode
);
379 cur_epos
= next_epos
= prev_epos
;
380 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
382 /* find the extent which contains the block we are looking for.
383 alternate between laarr[0] and laarr[1] for locations of the
384 current extent, and the previous extent */
387 if (prev_epos
.bh
!= cur_epos
.bh
)
389 brelse(prev_epos
.bh
);
391 prev_epos
.bh
= cur_epos
.bh
;
393 if (cur_epos
.bh
!= next_epos
.bh
)
396 get_bh(next_epos
.bh
);
397 cur_epos
.bh
= next_epos
.bh
;
402 prev_epos
.block
= cur_epos
.block
;
403 cur_epos
.block
= next_epos
.block
;
405 prev_epos
.offset
= cur_epos
.offset
;
406 cur_epos
.offset
= next_epos
.offset
;
408 if ((etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1)) == -1)
413 laarr
[c
].extLength
= (etype
<< 30) | elen
;
414 laarr
[c
].extLocation
= eloc
;
416 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
417 pgoal
= eloc
.logicalBlockNum
+
418 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
419 inode
->i_sb
->s_blocksize_bits
);
422 } while (lbcount
+ elen
<= b_off
);
425 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
427 /* if the extent is allocated and recorded, return the block
428 if the extent is not a multiple of the blocksize, round up */
430 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30))
432 if (elen
& (inode
->i_sb
->s_blocksize
- 1))
434 elen
= EXT_RECORDED_ALLOCATED
|
435 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
436 ~(inode
->i_sb
->s_blocksize
- 1));
437 etype
= udf_write_aext(inode
, &cur_epos
, eloc
, elen
, 1);
439 brelse(prev_epos
.bh
);
441 brelse(next_epos
.bh
);
442 newblock
= udf_get_lb_pblock(inode
->i_sb
, eloc
, offset
);
449 endnum
= startnum
= ((count
> 1) ? 1 : count
);
450 if (laarr
[c
].extLength
& (inode
->i_sb
->s_blocksize
- 1))
453 (laarr
[c
].extLength
& UDF_EXTENT_FLAG_MASK
) |
454 (((laarr
[c
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
455 inode
->i_sb
->s_blocksize
- 1) &
456 ~(inode
->i_sb
->s_blocksize
- 1));
457 UDF_I_LENEXTENTS(inode
) =
458 (UDF_I_LENEXTENTS(inode
) + inode
->i_sb
->s_blocksize
- 1) &
459 ~(inode
->i_sb
->s_blocksize
- 1);
462 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
463 ((offset
+ 1) << inode
->i_sb
->s_blocksize_bits
);
464 memset(&laarr
[c
].extLocation
, 0x00, sizeof(kernel_lb_addr
));
470 endnum
= startnum
= ((count
> 2) ? 2 : count
);
472 /* if the current extent is in position 0, swap it with the previous */
473 if (!c
&& count
!= 1)
481 /* if the current block is located in a extent, read the next extent */
484 if ((etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0)) != -1)
486 laarr
[c
+1].extLength
= (etype
<< 30) | elen
;
487 laarr
[c
+1].extLocation
= eloc
;
496 brelse(next_epos
.bh
);
498 /* if the current extent is not recorded but allocated, get the
499 block in the extent corresponding to the requested block */
500 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
501 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
502 else /* otherwise, allocate a new block */
504 if (UDF_I_NEXT_ALLOC_BLOCK(inode
) == block
)
505 goal
= UDF_I_NEXT_ALLOC_GOAL(inode
);
510 goal
= UDF_I_LOCATION(inode
).logicalBlockNum
+ 1;
513 if (!(newblocknum
= udf_new_block(inode
->i_sb
, inode
,
514 UDF_I_LOCATION(inode
).partitionReferenceNum
, goal
, err
)))
516 brelse(prev_epos
.bh
);
520 UDF_I_LENEXTENTS(inode
) += inode
->i_sb
->s_blocksize
;
523 /* if the extent the requsted block is located in contains multiple blocks,
524 split the extent into at most three extents. blocks prior to requested
525 block, requested block, and blocks after requested block */
526 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
528 #ifdef UDF_PREALLOCATE
529 /* preallocate blocks */
530 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
533 /* merge any continuous blocks in laarr */
534 udf_merge_extents(inode
, laarr
, &endnum
);
536 /* write back the new extents, inserting new extents if the new number
537 of extents is greater than the old number, and deleting extents if
538 the new number of extents is less than the old number */
539 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
541 brelse(prev_epos
.bh
);
543 if (!(newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
544 UDF_I_LOCATION(inode
).partitionReferenceNum
, 0)))
551 UDF_I_NEXT_ALLOC_BLOCK(inode
) = block
;
552 UDF_I_NEXT_ALLOC_GOAL(inode
) = newblocknum
;
553 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
556 udf_sync_inode(inode
);
558 mark_inode_dirty(inode
);
562 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
, int newblocknum
,
563 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
], int *endnum
)
565 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
566 (laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
569 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
570 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
;
571 int8_t etype
= (laarr
[curr
].extLength
>> 30);
575 else if (!offset
|| blen
== offset
+ 1)
577 laarr
[curr
+2] = laarr
[curr
+1];
578 laarr
[curr
+1] = laarr
[curr
];
582 laarr
[curr
+3] = laarr
[curr
+1];
583 laarr
[curr
+2] = laarr
[curr
+1] = laarr
[curr
];
588 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
590 udf_free_blocks(inode
->i_sb
, inode
, laarr
[curr
].extLocation
, 0, offset
);
591 laarr
[curr
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
592 (offset
<< inode
->i_sb
->s_blocksize_bits
);
593 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
594 laarr
[curr
].extLocation
.partitionReferenceNum
= 0;
597 laarr
[curr
].extLength
= (etype
<< 30) |
598 (offset
<< inode
->i_sb
->s_blocksize_bits
);
604 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
605 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
606 laarr
[curr
].extLocation
.partitionReferenceNum
=
607 UDF_I_LOCATION(inode
).partitionReferenceNum
;
608 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
609 inode
->i_sb
->s_blocksize
;
612 if (blen
!= offset
+ 1)
614 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
615 laarr
[curr
].extLocation
.logicalBlockNum
+= (offset
+ 1);
616 laarr
[curr
].extLength
= (etype
<< 30) |
617 ((blen
- (offset
+ 1)) << inode
->i_sb
->s_blocksize_bits
);
624 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
625 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
], int *endnum
)
627 int start
, length
= 0, currlength
= 0, i
;
629 if (*endnum
>= (c
+1))
638 if ((laarr
[c
+1].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
641 length
= currlength
= (((laarr
[c
+1].extLength
& UDF_EXTENT_LENGTH_MASK
) +
642 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
);
648 for (i
=start
+1; i
<=*endnum
; i
++)
653 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
655 else if ((laarr
[i
].extLength
>> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
656 length
+= (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
657 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
);
664 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
665 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
666 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
);
667 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
668 laarr
[start
].extLocation
.partitionReferenceNum
,
669 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
? length
:
670 UDF_DEFAULT_PREALLOC_BLOCKS
) - currlength
);
675 laarr
[start
].extLength
+=
676 (numalloc
<< inode
->i_sb
->s_blocksize_bits
);
679 memmove(&laarr
[c
+2], &laarr
[c
+1],
680 sizeof(long_ad
) * (*endnum
- (c
+1)));
682 laarr
[c
+1].extLocation
.logicalBlockNum
= next
;
683 laarr
[c
+1].extLocation
.partitionReferenceNum
=
684 laarr
[c
].extLocation
.partitionReferenceNum
;
685 laarr
[c
+1].extLength
= EXT_NOT_RECORDED_ALLOCATED
|
686 (numalloc
<< inode
->i_sb
->s_blocksize_bits
);
690 for (i
=start
+1; numalloc
&& i
<*endnum
; i
++)
692 int elen
= ((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
693 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
;
697 laarr
[i
].extLength
-=
698 (numalloc
<< inode
->i_sb
->s_blocksize_bits
);
705 memmove(&laarr
[i
], &laarr
[i
+1],
706 sizeof(long_ad
) * (*endnum
- (i
+1)));
711 UDF_I_LENEXTENTS(inode
) += numalloc
<< inode
->i_sb
->s_blocksize_bits
;
716 static void udf_merge_extents(struct inode
*inode
,
717 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
], int *endnum
)
721 for (i
=0; i
<(*endnum
-1); i
++)
723 if ((laarr
[i
].extLength
>> 30) == (laarr
[i
+1].extLength
>> 30))
725 if (((laarr
[i
].extLength
>> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
726 ((laarr
[i
+1].extLocation
.logicalBlockNum
- laarr
[i
].extLocation
.logicalBlockNum
) ==
727 (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
728 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
)))
730 if (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
731 (laarr
[i
+1].extLength
& UDF_EXTENT_LENGTH_MASK
) +
732 inode
->i_sb
->s_blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
)
734 laarr
[i
+1].extLength
= (laarr
[i
+1].extLength
-
735 (laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
736 UDF_EXTENT_LENGTH_MASK
) & ~(inode
->i_sb
->s_blocksize
-1);
737 laarr
[i
].extLength
= (laarr
[i
].extLength
& UDF_EXTENT_FLAG_MASK
) +
738 (UDF_EXTENT_LENGTH_MASK
+ 1) - inode
->i_sb
->s_blocksize
;
739 laarr
[i
+1].extLocation
.logicalBlockNum
=
740 laarr
[i
].extLocation
.logicalBlockNum
+
741 ((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) >>
742 inode
->i_sb
->s_blocksize_bits
);
746 laarr
[i
].extLength
= laarr
[i
+1].extLength
+
747 (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
748 inode
->i_sb
->s_blocksize
- 1) & ~(inode
->i_sb
->s_blocksize
-1));
750 memmove(&laarr
[i
+1], &laarr
[i
+2],
751 sizeof(long_ad
) * (*endnum
- (i
+2)));
757 else if (((laarr
[i
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
758 ((laarr
[i
+1].extLength
>> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)))
760 udf_free_blocks(inode
->i_sb
, inode
, laarr
[i
].extLocation
, 0,
761 ((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
762 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
);
763 laarr
[i
].extLocation
.logicalBlockNum
= 0;
764 laarr
[i
].extLocation
.partitionReferenceNum
= 0;
766 if (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
767 (laarr
[i
+1].extLength
& UDF_EXTENT_LENGTH_MASK
) +
768 inode
->i_sb
->s_blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
)
770 laarr
[i
+1].extLength
= (laarr
[i
+1].extLength
-
771 (laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
772 UDF_EXTENT_LENGTH_MASK
) & ~(inode
->i_sb
->s_blocksize
-1);
773 laarr
[i
].extLength
= (laarr
[i
].extLength
& UDF_EXTENT_FLAG_MASK
) +
774 (UDF_EXTENT_LENGTH_MASK
+ 1) - inode
->i_sb
->s_blocksize
;
778 laarr
[i
].extLength
= laarr
[i
+1].extLength
+
779 (((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
780 inode
->i_sb
->s_blocksize
- 1) & ~(inode
->i_sb
->s_blocksize
-1));
782 memmove(&laarr
[i
+1], &laarr
[i
+2],
783 sizeof(long_ad
) * (*endnum
- (i
+2)));
788 else if ((laarr
[i
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
790 udf_free_blocks(inode
->i_sb
, inode
, laarr
[i
].extLocation
, 0,
791 ((laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
792 inode
->i_sb
->s_blocksize
- 1) >> inode
->i_sb
->s_blocksize_bits
);
793 laarr
[i
].extLocation
.logicalBlockNum
= 0;
794 laarr
[i
].extLocation
.partitionReferenceNum
= 0;
795 laarr
[i
].extLength
= (laarr
[i
].extLength
& UDF_EXTENT_LENGTH_MASK
) |
796 EXT_NOT_RECORDED_NOT_ALLOCATED
;
801 static void udf_update_extents(struct inode
*inode
,
802 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
], int startnum
, int endnum
,
803 struct extent_position
*epos
)
806 kernel_lb_addr tmploc
;
809 if (startnum
> endnum
)
811 for (i
=0; i
<(startnum
-endnum
); i
++)
812 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
815 else if (startnum
< endnum
)
817 for (i
=0; i
<(endnum
-startnum
); i
++)
819 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
821 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
822 &laarr
[i
].extLength
, 1);
827 for (i
=start
; i
<endnum
; i
++)
829 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
830 udf_write_aext(inode
, epos
, laarr
[i
].extLocation
,
831 laarr
[i
].extLength
, 1);
835 struct buffer_head
* udf_bread(struct inode
* inode
, int block
,
836 int create
, int * err
)
838 struct buffer_head
* bh
= NULL
;
840 bh
= udf_getblk(inode
, block
, create
, err
);
844 if (buffer_uptodate(bh
))
846 ll_rw_block(READ
, 1, &bh
);
848 if (buffer_uptodate(bh
))
855 void udf_truncate(struct inode
* inode
)
860 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
861 S_ISLNK(inode
->i_mode
)))
863 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
867 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
)
869 if (inode
->i_sb
->s_blocksize
< (udf_file_entry_alloc_offset(inode
) +
872 udf_expand_file_adinicb(inode
, inode
->i_size
, &err
);
873 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
)
875 inode
->i_size
= UDF_I_LENALLOC(inode
);
880 udf_truncate_extents(inode
);
884 offset
= inode
->i_size
& (inode
->i_sb
->s_blocksize
- 1);
885 memset(UDF_I_DATA(inode
) + UDF_I_LENEATTR(inode
) + offset
, 0x00, inode
->i_sb
->s_blocksize
- offset
- udf_file_entry_alloc_offset(inode
));
886 UDF_I_LENALLOC(inode
) = inode
->i_size
;
891 block_truncate_page(inode
->i_mapping
, inode
->i_size
, udf_get_block
);
892 udf_truncate_extents(inode
);
895 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
897 udf_sync_inode (inode
);
899 mark_inode_dirty(inode
);
904 __udf_read_inode(struct inode
*inode
)
906 struct buffer_head
*bh
= NULL
;
907 struct fileEntry
*fe
;
911 * Set defaults, but the inode is still incomplete!
912 * Note: get_new_inode() sets the following on a new inode:
915 * i_flags = sb->s_flags
917 * clean_inode(): zero fills and sets
922 bh
= udf_read_ptagged(inode
->i_sb
, UDF_I_LOCATION(inode
), 0, &ident
);
926 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) failed !bh\n",
928 make_bad_inode(inode
);
932 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
933 ident
!= TAG_IDENT_USE
)
935 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) failed ident=%d\n",
936 inode
->i_ino
, ident
);
938 make_bad_inode(inode
);
942 fe
= (struct fileEntry
*)bh
->b_data
;
944 if (le16_to_cpu(fe
->icbTag
.strategyType
) == 4096)
946 struct buffer_head
*ibh
= NULL
, *nbh
= NULL
;
947 struct indirectEntry
*ie
;
949 ibh
= udf_read_ptagged(inode
->i_sb
, UDF_I_LOCATION(inode
), 1, &ident
);
950 if (ident
== TAG_IDENT_IE
)
955 ie
= (struct indirectEntry
*)ibh
->b_data
;
957 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
959 if (ie
->indirectICB
.extLength
&&
960 (nbh
= udf_read_ptagged(inode
->i_sb
, loc
, 0, &ident
)))
962 if (ident
== TAG_IDENT_FE
||
963 ident
== TAG_IDENT_EFE
)
965 memcpy(&UDF_I_LOCATION(inode
), &loc
, sizeof(kernel_lb_addr
));
969 __udf_read_inode(inode
);
985 else if (le16_to_cpu(fe
->icbTag
.strategyType
) != 4)
987 printk(KERN_ERR
"udf: unsupported strategy type: %d\n",
988 le16_to_cpu(fe
->icbTag
.strategyType
));
990 make_bad_inode(inode
);
993 udf_fill_inode(inode
, bh
);
997 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
999 struct fileEntry
*fe
;
1000 struct extendedFileEntry
*efe
;
1005 fe
= (struct fileEntry
*)bh
->b_data
;
1006 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1008 if (le16_to_cpu(fe
->icbTag
.strategyType
) == 4)
1009 UDF_I_STRAT4096(inode
) = 0;
1010 else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
1011 UDF_I_STRAT4096(inode
) = 1;
1013 UDF_I_ALLOCTYPE(inode
) = le16_to_cpu(fe
->icbTag
.flags
) & ICBTAG_FLAG_AD_MASK
;
1014 UDF_I_UNIQUE(inode
) = 0;
1015 UDF_I_LENEATTR(inode
) = 0;
1016 UDF_I_LENEXTENTS(inode
) = 0;
1017 UDF_I_LENALLOC(inode
) = 0;
1018 UDF_I_NEXT_ALLOC_BLOCK(inode
) = 0;
1019 UDF_I_NEXT_ALLOC_GOAL(inode
) = 0;
1020 if (le16_to_cpu(fe
->descTag
.tagIdent
) == TAG_IDENT_EFE
)
1022 UDF_I_EFE(inode
) = 1;
1023 UDF_I_USE(inode
) = 0;
1024 UDF_I_DATA(inode
) = kmalloc(inode
->i_sb
->s_blocksize
- sizeof(struct extendedFileEntry
), GFP_KERNEL
);
1025 memcpy(UDF_I_DATA(inode
), bh
->b_data
+ sizeof(struct extendedFileEntry
), inode
->i_sb
->s_blocksize
- sizeof(struct extendedFileEntry
));
1027 else if (le16_to_cpu(fe
->descTag
.tagIdent
) == TAG_IDENT_FE
)
1029 UDF_I_EFE(inode
) = 0;
1030 UDF_I_USE(inode
) = 0;
1031 UDF_I_DATA(inode
) = kmalloc(inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
), GFP_KERNEL
);
1032 memcpy(UDF_I_DATA(inode
), bh
->b_data
+ sizeof(struct fileEntry
), inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1034 else if (le16_to_cpu(fe
->descTag
.tagIdent
) == TAG_IDENT_USE
)
1036 UDF_I_EFE(inode
) = 0;
1037 UDF_I_USE(inode
) = 1;
1038 UDF_I_LENALLOC(inode
) =
1040 ((struct unallocSpaceEntry
*)bh
->b_data
)->lengthAllocDescs
);
1041 UDF_I_DATA(inode
) = kmalloc(inode
->i_sb
->s_blocksize
- sizeof(struct unallocSpaceEntry
), GFP_KERNEL
);
1042 memcpy(UDF_I_DATA(inode
), bh
->b_data
+ sizeof(struct unallocSpaceEntry
), inode
->i_sb
->s_blocksize
- sizeof(struct unallocSpaceEntry
));
1046 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1047 if (inode
->i_uid
== -1 || UDF_QUERY_FLAG(inode
->i_sb
,
1048 UDF_FLAG_UID_IGNORE
))
1049 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1051 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1052 if (inode
->i_gid
== -1 || UDF_QUERY_FLAG(inode
->i_sb
,
1053 UDF_FLAG_GID_IGNORE
))
1054 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1056 inode
->i_nlink
= le16_to_cpu(fe
->fileLinkCount
);
1057 if (!inode
->i_nlink
)
1060 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1061 UDF_I_LENEXTENTS(inode
) = inode
->i_size
;
1063 inode
->i_mode
= udf_convert_permissions(fe
);
1064 inode
->i_mode
&= ~UDF_SB(inode
->i_sb
)->s_umask
;
1066 if (UDF_I_EFE(inode
) == 0)
1068 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1069 (inode
->i_sb
->s_blocksize_bits
- 9);
1071 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1072 lets_to_cpu(fe
->accessTime
)) )
1074 inode
->i_atime
.tv_sec
= convtime
;
1075 inode
->i_atime
.tv_nsec
= convtime_usec
* 1000;
1079 inode
->i_atime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1082 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1083 lets_to_cpu(fe
->modificationTime
)) )
1085 inode
->i_mtime
.tv_sec
= convtime
;
1086 inode
->i_mtime
.tv_nsec
= convtime_usec
* 1000;
1090 inode
->i_mtime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1093 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1094 lets_to_cpu(fe
->attrTime
)) )
1096 inode
->i_ctime
.tv_sec
= convtime
;
1097 inode
->i_ctime
.tv_nsec
= convtime_usec
* 1000;
1101 inode
->i_ctime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1104 UDF_I_UNIQUE(inode
) = le64_to_cpu(fe
->uniqueID
);
1105 UDF_I_LENEATTR(inode
) = le32_to_cpu(fe
->lengthExtendedAttr
);
1106 UDF_I_LENALLOC(inode
) = le32_to_cpu(fe
->lengthAllocDescs
);
1107 offset
= sizeof(struct fileEntry
) + UDF_I_LENEATTR(inode
);
1111 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1112 (inode
->i_sb
->s_blocksize_bits
- 9);
1114 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1115 lets_to_cpu(efe
->accessTime
)) )
1117 inode
->i_atime
.tv_sec
= convtime
;
1118 inode
->i_atime
.tv_nsec
= convtime_usec
* 1000;
1122 inode
->i_atime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1125 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1126 lets_to_cpu(efe
->modificationTime
)) )
1128 inode
->i_mtime
.tv_sec
= convtime
;
1129 inode
->i_mtime
.tv_nsec
= convtime_usec
* 1000;
1133 inode
->i_mtime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1136 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1137 lets_to_cpu(efe
->createTime
)) )
1139 UDF_I_CRTIME(inode
).tv_sec
= convtime
;
1140 UDF_I_CRTIME(inode
).tv_nsec
= convtime_usec
* 1000;
1144 UDF_I_CRTIME(inode
) = UDF_SB_RECORDTIME(inode
->i_sb
);
1147 if ( udf_stamp_to_time(&convtime
, &convtime_usec
,
1148 lets_to_cpu(efe
->attrTime
)) )
1150 inode
->i_ctime
.tv_sec
= convtime
;
1151 inode
->i_ctime
.tv_nsec
= convtime_usec
* 1000;
1155 inode
->i_ctime
= UDF_SB_RECORDTIME(inode
->i_sb
);
1158 UDF_I_UNIQUE(inode
) = le64_to_cpu(efe
->uniqueID
);
1159 UDF_I_LENEATTR(inode
) = le32_to_cpu(efe
->lengthExtendedAttr
);
1160 UDF_I_LENALLOC(inode
) = le32_to_cpu(efe
->lengthAllocDescs
);
1161 offset
= sizeof(struct extendedFileEntry
) + UDF_I_LENEATTR(inode
);
1164 switch (fe
->icbTag
.fileType
)
1166 case ICBTAG_FILE_TYPE_DIRECTORY
:
1168 inode
->i_op
= &udf_dir_inode_operations
;
1169 inode
->i_fop
= &udf_dir_operations
;
1170 inode
->i_mode
|= S_IFDIR
;
1174 case ICBTAG_FILE_TYPE_REALTIME
:
1175 case ICBTAG_FILE_TYPE_REGULAR
:
1176 case ICBTAG_FILE_TYPE_UNDEF
:
1178 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
)
1179 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1181 inode
->i_data
.a_ops
= &udf_aops
;
1182 inode
->i_op
= &udf_file_inode_operations
;
1183 inode
->i_fop
= &udf_file_operations
;
1184 inode
->i_mode
|= S_IFREG
;
1187 case ICBTAG_FILE_TYPE_BLOCK
:
1189 inode
->i_mode
|= S_IFBLK
;
1192 case ICBTAG_FILE_TYPE_CHAR
:
1194 inode
->i_mode
|= S_IFCHR
;
1197 case ICBTAG_FILE_TYPE_FIFO
:
1199 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1202 case ICBTAG_FILE_TYPE_SOCKET
:
1204 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1207 case ICBTAG_FILE_TYPE_SYMLINK
:
1209 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1210 inode
->i_op
= &page_symlink_inode_operations
;
1211 inode
->i_mode
= S_IFLNK
|S_IRWXUGO
;
1216 printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
1217 inode
->i_ino
, fe
->icbTag
.fileType
);
1218 make_bad_inode(inode
);
1222 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
1224 struct deviceSpec
*dsea
=
1225 (struct deviceSpec
*)
1226 udf_get_extendedattr(inode
, 12, 1);
1230 init_special_inode(inode
, inode
->i_mode
, MKDEV(
1231 le32_to_cpu(dsea
->majorDeviceIdent
),
1232 le32_to_cpu(dsea
->minorDeviceIdent
)));
1233 /* Developer ID ??? */
1237 make_bad_inode(inode
);
1243 udf_convert_permissions(struct fileEntry
*fe
)
1246 uint32_t permissions
;
1249 permissions
= le32_to_cpu(fe
->permissions
);
1250 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1252 mode
= (( permissions
) & S_IRWXO
) |
1253 (( permissions
>> 2 ) & S_IRWXG
) |
1254 (( permissions
>> 4 ) & S_IRWXU
) |
1255 (( flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1256 (( flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1257 (( flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1266 * Write out the specified inode.
1269 * This routine is called whenever an inode is synced.
1270 * Currently this routine is just a placeholder.
1273 * July 1, 1997 - Andrew E. Mileski
1274 * Written, tested, and released.
1277 int udf_write_inode(struct inode
* inode
, int sync
)
1281 ret
= udf_update_inode(inode
, sync
);
1286 int udf_sync_inode(struct inode
* inode
)
1288 return udf_update_inode(inode
, 1);
1292 udf_update_inode(struct inode
*inode
, int do_sync
)
1294 struct buffer_head
*bh
= NULL
;
1295 struct fileEntry
*fe
;
1296 struct extendedFileEntry
*efe
;
1301 kernel_timestamp cpu_time
;
1304 bh
= udf_tread(inode
->i_sb
,
1305 udf_get_lb_pblock(inode
->i_sb
, UDF_I_LOCATION(inode
), 0));
1309 udf_debug("bread failure\n");
1313 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1315 fe
= (struct fileEntry
*)bh
->b_data
;
1316 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1318 if (le16_to_cpu(fe
->descTag
.tagIdent
) == TAG_IDENT_USE
)
1320 struct unallocSpaceEntry
*use
=
1321 (struct unallocSpaceEntry
*)bh
->b_data
;
1323 use
->lengthAllocDescs
= cpu_to_le32(UDF_I_LENALLOC(inode
));
1324 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
), UDF_I_DATA(inode
), inode
->i_sb
->s_blocksize
- sizeof(struct unallocSpaceEntry
));
1325 crclen
= sizeof(struct unallocSpaceEntry
) + UDF_I_LENALLOC(inode
) -
1327 use
->descTag
.tagLocation
= cpu_to_le32(UDF_I_LOCATION(inode
).logicalBlockNum
);
1328 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1329 use
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)use
+ sizeof(tag
), crclen
, 0));
1331 use
->descTag
.tagChecksum
= 0;
1332 for (i
=0; i
<16; i
++)
1334 use
->descTag
.tagChecksum
+= ((uint8_t *)&(use
->descTag
))[i
];
1336 mark_buffer_dirty(bh
);
1341 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1342 fe
->uid
= cpu_to_le32(-1);
1343 else fe
->uid
= cpu_to_le32(inode
->i_uid
);
1345 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1346 fe
->gid
= cpu_to_le32(-1);
1347 else fe
->gid
= cpu_to_le32(inode
->i_gid
);
1349 udfperms
= ((inode
->i_mode
& S_IRWXO
) ) |
1350 ((inode
->i_mode
& S_IRWXG
) << 2) |
1351 ((inode
->i_mode
& S_IRWXU
) << 4);
1353 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1354 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1355 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1356 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1357 fe
->permissions
= cpu_to_le32(udfperms
);
1359 if (S_ISDIR(inode
->i_mode
))
1360 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1362 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1364 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1366 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
1369 struct deviceSpec
*dsea
=
1370 (struct deviceSpec
*)
1371 udf_get_extendedattr(inode
, 12, 1);
1375 dsea
= (struct deviceSpec
*)
1376 udf_add_extendedattr(inode
,
1377 sizeof(struct deviceSpec
) +
1378 sizeof(regid
), 12, 0x3);
1379 dsea
->attrType
= cpu_to_le32(12);
1380 dsea
->attrSubtype
= 1;
1381 dsea
->attrLength
= cpu_to_le32(sizeof(struct deviceSpec
) +
1383 dsea
->impUseLength
= cpu_to_le32(sizeof(regid
));
1385 eid
= (regid
*)dsea
->impUse
;
1386 memset(eid
, 0, sizeof(regid
));
1387 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1388 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1389 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1390 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1391 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1394 if (UDF_I_EFE(inode
) == 0)
1396 memcpy(bh
->b_data
+ sizeof(struct fileEntry
), UDF_I_DATA(inode
), inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1397 fe
->logicalBlocksRecorded
= cpu_to_le64(
1398 (inode
->i_blocks
+ (1 << (inode
->i_sb
->s_blocksize_bits
- 9)) - 1) >>
1399 (inode
->i_sb
->s_blocksize_bits
- 9));
1401 if (udf_time_to_stamp(&cpu_time
, inode
->i_atime
))
1402 fe
->accessTime
= cpu_to_lets(cpu_time
);
1403 if (udf_time_to_stamp(&cpu_time
, inode
->i_mtime
))
1404 fe
->modificationTime
= cpu_to_lets(cpu_time
);
1405 if (udf_time_to_stamp(&cpu_time
, inode
->i_ctime
))
1406 fe
->attrTime
= cpu_to_lets(cpu_time
);
1407 memset(&(fe
->impIdent
), 0, sizeof(regid
));
1408 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1409 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1410 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1411 fe
->uniqueID
= cpu_to_le64(UDF_I_UNIQUE(inode
));
1412 fe
->lengthExtendedAttr
= cpu_to_le32(UDF_I_LENEATTR(inode
));
1413 fe
->lengthAllocDescs
= cpu_to_le32(UDF_I_LENALLOC(inode
));
1414 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1415 crclen
= sizeof(struct fileEntry
);
1419 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
), UDF_I_DATA(inode
), inode
->i_sb
->s_blocksize
- sizeof(struct extendedFileEntry
));
1420 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1421 efe
->logicalBlocksRecorded
= cpu_to_le64(
1422 (inode
->i_blocks
+ (1 << (inode
->i_sb
->s_blocksize_bits
- 9)) - 1) >>
1423 (inode
->i_sb
->s_blocksize_bits
- 9));
1425 if (UDF_I_CRTIME(inode
).tv_sec
> inode
->i_atime
.tv_sec
||
1426 (UDF_I_CRTIME(inode
).tv_sec
== inode
->i_atime
.tv_sec
&&
1427 UDF_I_CRTIME(inode
).tv_nsec
> inode
->i_atime
.tv_nsec
))
1429 UDF_I_CRTIME(inode
) = inode
->i_atime
;
1431 if (UDF_I_CRTIME(inode
).tv_sec
> inode
->i_mtime
.tv_sec
||
1432 (UDF_I_CRTIME(inode
).tv_sec
== inode
->i_mtime
.tv_sec
&&
1433 UDF_I_CRTIME(inode
).tv_nsec
> inode
->i_mtime
.tv_nsec
))
1435 UDF_I_CRTIME(inode
) = inode
->i_mtime
;
1437 if (UDF_I_CRTIME(inode
).tv_sec
> inode
->i_ctime
.tv_sec
||
1438 (UDF_I_CRTIME(inode
).tv_sec
== inode
->i_ctime
.tv_sec
&&
1439 UDF_I_CRTIME(inode
).tv_nsec
> inode
->i_ctime
.tv_nsec
))
1441 UDF_I_CRTIME(inode
) = inode
->i_ctime
;
1444 if (udf_time_to_stamp(&cpu_time
, inode
->i_atime
))
1445 efe
->accessTime
= cpu_to_lets(cpu_time
);
1446 if (udf_time_to_stamp(&cpu_time
, inode
->i_mtime
))
1447 efe
->modificationTime
= cpu_to_lets(cpu_time
);
1448 if (udf_time_to_stamp(&cpu_time
, UDF_I_CRTIME(inode
)))
1449 efe
->createTime
= cpu_to_lets(cpu_time
);
1450 if (udf_time_to_stamp(&cpu_time
, inode
->i_ctime
))
1451 efe
->attrTime
= cpu_to_lets(cpu_time
);
1453 memset(&(efe
->impIdent
), 0, sizeof(regid
));
1454 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1455 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1456 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1457 efe
->uniqueID
= cpu_to_le64(UDF_I_UNIQUE(inode
));
1458 efe
->lengthExtendedAttr
= cpu_to_le32(UDF_I_LENEATTR(inode
));
1459 efe
->lengthAllocDescs
= cpu_to_le32(UDF_I_LENALLOC(inode
));
1460 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1461 crclen
= sizeof(struct extendedFileEntry
);
1463 if (UDF_I_STRAT4096(inode
))
1465 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1466 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1467 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1471 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1472 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1475 if (S_ISDIR(inode
->i_mode
))
1476 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1477 else if (S_ISREG(inode
->i_mode
))
1478 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1479 else if (S_ISLNK(inode
->i_mode
))
1480 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1481 else if (S_ISBLK(inode
->i_mode
))
1482 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1483 else if (S_ISCHR(inode
->i_mode
))
1484 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1485 else if (S_ISFIFO(inode
->i_mode
))
1486 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1487 else if (S_ISSOCK(inode
->i_mode
))
1488 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1490 icbflags
= UDF_I_ALLOCTYPE(inode
) |
1491 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1492 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1493 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1494 (le16_to_cpu(fe
->icbTag
.flags
) &
1495 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1496 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1498 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1499 if (UDF_SB_UDFREV(inode
->i_sb
) >= 0x0200)
1500 fe
->descTag
.descVersion
= cpu_to_le16(3);
1502 fe
->descTag
.descVersion
= cpu_to_le16(2);
1503 fe
->descTag
.tagSerialNum
= cpu_to_le16(UDF_SB_SERIALNUM(inode
->i_sb
));
1504 fe
->descTag
.tagLocation
= cpu_to_le32(UDF_I_LOCATION(inode
).logicalBlockNum
);
1505 crclen
+= UDF_I_LENEATTR(inode
) + UDF_I_LENALLOC(inode
) - sizeof(tag
);
1506 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1507 fe
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)fe
+ sizeof(tag
), crclen
, 0));
1509 fe
->descTag
.tagChecksum
= 0;
1510 for (i
=0; i
<16; i
++)
1512 fe
->descTag
.tagChecksum
+= ((uint8_t *)&(fe
->descTag
))[i
];
1514 /* write the data blocks */
1515 mark_buffer_dirty(bh
);
1518 sync_dirty_buffer(bh
);
1519 if (buffer_req(bh
) && !buffer_uptodate(bh
))
1521 printk("IO error syncing udf inode [%s:%08lx]\n",
1522 inode
->i_sb
->s_id
, inode
->i_ino
);
1531 udf_iget(struct super_block
*sb
, kernel_lb_addr ino
)
1533 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1534 struct inode
*inode
= iget_locked(sb
, block
);
1539 if (inode
->i_state
& I_NEW
) {
1540 memcpy(&UDF_I_LOCATION(inode
), &ino
, sizeof(kernel_lb_addr
));
1541 __udf_read_inode(inode
);
1542 unlock_new_inode(inode
);
1545 if (is_bad_inode(inode
))
1548 if (ino
.logicalBlockNum
>= UDF_SB_PARTLEN(sb
, ino
.partitionReferenceNum
)) {
1549 udf_debug("block=%d, partition=%d out of range\n",
1550 ino
.logicalBlockNum
, ino
.partitionReferenceNum
);
1551 make_bad_inode(inode
);
1562 int8_t udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1563 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1566 short_ad
*sad
= NULL
;
1567 long_ad
*lad
= NULL
;
1568 struct allocExtDesc
*aed
;
1573 ptr
= UDF_I_DATA(inode
) + epos
->offset
- udf_file_entry_alloc_offset(inode
) + UDF_I_LENEATTR(inode
);
1575 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1577 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
1578 adsize
= sizeof(short_ad
);
1579 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
1580 adsize
= sizeof(long_ad
);
1584 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
)
1587 struct buffer_head
*nbh
;
1589 kernel_lb_addr obloc
= epos
->block
;
1591 if (!(epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1592 obloc
.partitionReferenceNum
, obloc
.logicalBlockNum
, &err
)))
1596 if (!(nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1602 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1603 set_buffer_uptodate(nbh
);
1605 mark_buffer_dirty_inode(nbh
, inode
);
1607 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1608 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1609 aed
->previousAllocExtLocation
= cpu_to_le32(obloc
.logicalBlockNum
);
1610 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
)
1612 loffset
= epos
->offset
;
1613 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1614 sptr
= ptr
- adsize
;
1615 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1616 memcpy(dptr
, sptr
, adsize
);
1617 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1621 loffset
= epos
->offset
+ adsize
;
1622 aed
->lengthAllocDescs
= cpu_to_le32(0);
1624 epos
->offset
= sizeof(struct allocExtDesc
);
1628 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1629 aed
->lengthAllocDescs
=
1630 cpu_to_le32(le32_to_cpu(aed
->lengthAllocDescs
) + adsize
);
1634 UDF_I_LENALLOC(inode
) += adsize
;
1635 mark_inode_dirty(inode
);
1638 if (UDF_SB_UDFREV(inode
->i_sb
) >= 0x0200)
1639 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1640 epos
->block
.logicalBlockNum
, sizeof(tag
));
1642 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1643 epos
->block
.logicalBlockNum
, sizeof(tag
));
1644 switch (UDF_I_ALLOCTYPE(inode
))
1646 case ICBTAG_FLAG_AD_SHORT
:
1648 sad
= (short_ad
*)sptr
;
1649 sad
->extLength
= cpu_to_le32(
1650 EXT_NEXT_EXTENT_ALLOCDECS
|
1651 inode
->i_sb
->s_blocksize
);
1652 sad
->extPosition
= cpu_to_le32(epos
->block
.logicalBlockNum
);
1655 case ICBTAG_FLAG_AD_LONG
:
1657 lad
= (long_ad
*)sptr
;
1658 lad
->extLength
= cpu_to_le32(
1659 EXT_NEXT_EXTENT_ALLOCDECS
|
1660 inode
->i_sb
->s_blocksize
);
1661 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1662 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1668 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) || UDF_SB_UDFREV(inode
->i_sb
) >= 0x0201)
1669 udf_update_tag(epos
->bh
->b_data
, loffset
);
1671 udf_update_tag(epos
->bh
->b_data
, sizeof(struct allocExtDesc
));
1672 mark_buffer_dirty_inode(epos
->bh
, inode
);
1676 mark_inode_dirty(inode
);
1680 etype
= udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1684 UDF_I_LENALLOC(inode
) += adsize
;
1685 mark_inode_dirty(inode
);
1689 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1690 aed
->lengthAllocDescs
=
1691 cpu_to_le32(le32_to_cpu(aed
->lengthAllocDescs
) + adsize
);
1692 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) || UDF_SB_UDFREV(inode
->i_sb
) >= 0x0201)
1693 udf_update_tag(epos
->bh
->b_data
, epos
->offset
+ (inc
? 0 : adsize
));
1695 udf_update_tag(epos
->bh
->b_data
, sizeof(struct allocExtDesc
));
1696 mark_buffer_dirty_inode(epos
->bh
, inode
);
1702 int8_t udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1703 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1709 ptr
= UDF_I_DATA(inode
) + epos
->offset
- udf_file_entry_alloc_offset(inode
) + UDF_I_LENEATTR(inode
);
1711 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1713 switch (UDF_I_ALLOCTYPE(inode
))
1715 case ICBTAG_FLAG_AD_SHORT
:
1717 short_ad
*sad
= (short_ad
*)ptr
;
1718 sad
->extLength
= cpu_to_le32(elen
);
1719 sad
->extPosition
= cpu_to_le32(eloc
.logicalBlockNum
);
1720 adsize
= sizeof(short_ad
);
1723 case ICBTAG_FLAG_AD_LONG
:
1725 long_ad
*lad
= (long_ad
*)ptr
;
1726 lad
->extLength
= cpu_to_le32(elen
);
1727 lad
->extLocation
= cpu_to_lelb(eloc
);
1728 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1729 adsize
= sizeof(long_ad
);
1738 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) || UDF_SB_UDFREV(inode
->i_sb
) >= 0x0201)
1740 struct allocExtDesc
*aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1741 udf_update_tag(epos
->bh
->b_data
,
1742 le32_to_cpu(aed
->lengthAllocDescs
) + sizeof(struct allocExtDesc
));
1744 mark_buffer_dirty_inode(epos
->bh
, inode
);
1747 mark_inode_dirty(inode
);
1750 epos
->offset
+= adsize
;
1751 return (elen
>> 30);
1754 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1755 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1759 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1760 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30))
1762 epos
->block
= *eloc
;
1763 epos
->offset
= sizeof(struct allocExtDesc
);
1765 if (!(epos
->bh
= udf_tread(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
, epos
->block
, 0))))
1767 udf_debug("reading block %d failed!\n",
1768 udf_get_lb_pblock(inode
->i_sb
, epos
->block
, 0));
1776 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1777 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1786 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1787 ptr
= UDF_I_DATA(inode
) + epos
->offset
- udf_file_entry_alloc_offset(inode
) + UDF_I_LENEATTR(inode
);
1788 alen
= udf_file_entry_alloc_offset(inode
) + UDF_I_LENALLOC(inode
);
1793 epos
->offset
= sizeof(struct allocExtDesc
);
1794 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1795 alen
= sizeof(struct allocExtDesc
) + le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->lengthAllocDescs
);
1798 switch (UDF_I_ALLOCTYPE(inode
))
1800 case ICBTAG_FLAG_AD_SHORT
:
1804 if (!(sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
)))
1807 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1808 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1809 eloc
->partitionReferenceNum
= UDF_I_LOCATION(inode
).partitionReferenceNum
;
1810 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1813 case ICBTAG_FLAG_AD_LONG
:
1817 if (!(lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
)))
1820 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1821 *eloc
= lelb_to_cpu(lad
->extLocation
);
1822 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1827 udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode
));
1836 udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
1837 kernel_lb_addr neloc
, uint32_t nelen
)
1839 kernel_lb_addr oeloc
;
1846 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1)
1848 udf_write_aext(inode
, &epos
, neloc
, nelen
, 1);
1851 nelen
= (etype
<< 30) | oelen
;
1853 udf_add_aext(inode
, &epos
, neloc
, nelen
, 1);
1855 return (nelen
>> 30);
1858 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
1859 kernel_lb_addr eloc
, uint32_t elen
)
1861 struct extent_position oepos
;
1864 struct allocExtDesc
*aed
;
1872 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
1873 adsize
= sizeof(short_ad
);
1874 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
1875 adsize
= sizeof(long_ad
);
1880 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
1883 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1)
1885 udf_write_aext(inode
, &oepos
, eloc
, (etype
<< 30) | elen
, 1);
1886 if (oepos
.bh
!= epos
.bh
)
1888 oepos
.block
= epos
.block
;
1892 oepos
.offset
= epos
.offset
- adsize
;
1895 memset(&eloc
, 0x00, sizeof(kernel_lb_addr
));
1898 if (epos
.bh
!= oepos
.bh
)
1900 udf_free_blocks(inode
->i_sb
, inode
, epos
.block
, 0, 1);
1901 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1902 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1905 UDF_I_LENALLOC(inode
) -= (adsize
* 2);
1906 mark_inode_dirty(inode
);
1910 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1911 aed
->lengthAllocDescs
=
1912 cpu_to_le32(le32_to_cpu(aed
->lengthAllocDescs
) - (2*adsize
));
1913 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) || UDF_SB_UDFREV(inode
->i_sb
) >= 0x0201)
1914 udf_update_tag(oepos
.bh
->b_data
, oepos
.offset
- (2*adsize
));
1916 udf_update_tag(oepos
.bh
->b_data
, sizeof(struct allocExtDesc
));
1917 mark_buffer_dirty_inode(oepos
.bh
, inode
);
1922 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1925 UDF_I_LENALLOC(inode
) -= adsize
;
1926 mark_inode_dirty(inode
);
1930 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1931 aed
->lengthAllocDescs
=
1932 cpu_to_le32(le32_to_cpu(aed
->lengthAllocDescs
) - adsize
);
1933 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) || UDF_SB_UDFREV(inode
->i_sb
) >= 0x0201)
1934 udf_update_tag(oepos
.bh
->b_data
, epos
.offset
- adsize
);
1936 udf_update_tag(oepos
.bh
->b_data
, sizeof(struct allocExtDesc
));
1937 mark_buffer_dirty_inode(oepos
.bh
, inode
);
1943 return (elen
>> 30);
1946 int8_t inode_bmap(struct inode
*inode
, sector_t block
, struct extent_position
*pos
,
1947 kernel_lb_addr
*eloc
, uint32_t *elen
, sector_t
*offset
)
1949 loff_t lbcount
= 0, bcount
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
1954 printk(KERN_ERR
"udf: inode_bmap: block < 0\n");
1959 pos
->block
= UDF_I_LOCATION(inode
);
1965 if ((etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1)) == -1)
1967 *offset
= (bcount
- lbcount
) >> inode
->i_sb
->s_blocksize_bits
;
1968 UDF_I_LENEXTENTS(inode
) = lbcount
;
1972 } while (lbcount
<= bcount
);
1974 *offset
= (bcount
+ *elen
- lbcount
) >> inode
->i_sb
->s_blocksize_bits
;
1979 long udf_block_map(struct inode
*inode
, sector_t block
)
1981 kernel_lb_addr eloc
;
1984 struct extent_position epos
= { NULL
, 0, { 0, 0}};
1989 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) == (EXT_RECORDED_ALLOCATED
>> 30))
1990 ret
= udf_get_lb_pblock(inode
->i_sb
, eloc
, offset
);
1997 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
1998 return udf_fixed_to_variable(ret
);