5 * Inode name 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-2004 Ben Fennema
14 * (C) 1999-2000 Stelias Computing Inc
18 * 12/12/98 blf Created. Split out the lookup code from dir.c
19 * 04/19/99 blf link, mknod, symlink support
26 #include <linux/string.h>
27 #include <linux/errno.h>
29 #include <linux/slab.h>
30 #include <linux/buffer_head.h>
31 #include <linux/sched.h>
32 #include <linux/crc-itu-t.h>
33 #include <linux/exportfs.h>
35 static inline int udf_match(int len1
, const unsigned char *name1
, int len2
,
36 const unsigned char *name2
)
41 return !memcmp(name1
, name2
, len1
);
44 int udf_write_fi(struct inode
*inode
, struct fileIdentDesc
*cfi
,
45 struct fileIdentDesc
*sfi
, struct udf_fileident_bh
*fibh
,
46 uint8_t *impuse
, uint8_t *fileident
)
48 uint16_t crclen
= fibh
->eoffset
- fibh
->soffset
- sizeof(struct tag
);
51 uint16_t liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
52 uint8_t lfi
= cfi
->lengthFileIdent
;
53 int padlen
= fibh
->eoffset
- fibh
->soffset
- liu
- lfi
-
54 sizeof(struct fileIdentDesc
);
57 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
60 offset
= fibh
->soffset
+ sizeof(struct fileIdentDesc
);
63 if (adinicb
|| (offset
+ liu
< 0)) {
64 memcpy((uint8_t *)sfi
->impUse
, impuse
, liu
);
65 } else if (offset
>= 0) {
66 memcpy(fibh
->ebh
->b_data
+ offset
, impuse
, liu
);
68 memcpy((uint8_t *)sfi
->impUse
, impuse
, -offset
);
69 memcpy(fibh
->ebh
->b_data
, impuse
- offset
,
77 if (adinicb
|| (offset
+ lfi
< 0)) {
78 memcpy((uint8_t *)sfi
->fileIdent
+ liu
, fileident
, lfi
);
79 } else if (offset
>= 0) {
80 memcpy(fibh
->ebh
->b_data
+ offset
, fileident
, lfi
);
82 memcpy((uint8_t *)sfi
->fileIdent
+ liu
, fileident
,
84 memcpy(fibh
->ebh
->b_data
, fileident
- offset
,
91 if (adinicb
|| (offset
+ padlen
< 0)) {
92 memset((uint8_t *)sfi
->padding
+ liu
+ lfi
, 0x00, padlen
);
93 } else if (offset
>= 0) {
94 memset(fibh
->ebh
->b_data
+ offset
, 0x00, padlen
);
96 memset((uint8_t *)sfi
->padding
+ liu
+ lfi
, 0x00, -offset
);
97 memset(fibh
->ebh
->b_data
, 0x00, padlen
+ offset
);
100 crc
= crc_itu_t(0, (uint8_t *)cfi
+ sizeof(struct tag
),
101 sizeof(struct fileIdentDesc
) - sizeof(struct tag
));
103 if (fibh
->sbh
== fibh
->ebh
) {
104 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
105 crclen
+ sizeof(struct tag
) -
106 sizeof(struct fileIdentDesc
));
107 } else if (sizeof(struct fileIdentDesc
) >= -fibh
->soffset
) {
108 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
+
109 sizeof(struct fileIdentDesc
) +
111 crclen
+ sizeof(struct tag
) -
112 sizeof(struct fileIdentDesc
));
114 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
115 -fibh
->soffset
- sizeof(struct fileIdentDesc
));
116 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
, fibh
->eoffset
);
119 cfi
->descTag
.descCRC
= cpu_to_le16(crc
);
120 cfi
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
121 cfi
->descTag
.tagChecksum
= udf_tag_checksum(&cfi
->descTag
);
123 if (adinicb
|| (sizeof(struct fileIdentDesc
) <= -fibh
->soffset
)) {
124 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
,
125 sizeof(struct fileIdentDesc
));
127 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
, -fibh
->soffset
);
128 memcpy(fibh
->ebh
->b_data
, (uint8_t *)cfi
- fibh
->soffset
,
129 sizeof(struct fileIdentDesc
) + fibh
->soffset
);
133 mark_inode_dirty(inode
);
135 if (fibh
->sbh
!= fibh
->ebh
)
136 mark_buffer_dirty_inode(fibh
->ebh
, inode
);
137 mark_buffer_dirty_inode(fibh
->sbh
, inode
);
142 static struct fileIdentDesc
*udf_find_entry(struct inode
*dir
,
143 const struct qstr
*child
,
144 struct udf_fileident_bh
*fibh
,
145 struct fileIdentDesc
*cfi
)
147 struct fileIdentDesc
*fi
= NULL
;
150 unsigned char *fname
= NULL
;
151 unsigned char *nameptr
;
155 struct kernel_lb_addr eloc
;
158 struct extent_position epos
= {};
159 struct udf_inode_info
*dinfo
= UDF_I(dir
);
160 int isdotdot
= child
->len
== 2 &&
161 child
->name
[0] == '.' && child
->name
[1] == '.';
163 size
= udf_ext0_offset(dir
) + dir
->i_size
;
164 f_pos
= udf_ext0_offset(dir
);
166 fibh
->sbh
= fibh
->ebh
= NULL
;
167 fibh
->soffset
= fibh
->eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
168 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
169 if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
, &epos
,
170 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30))
172 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
173 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
174 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
175 epos
.offset
-= sizeof(struct short_ad
);
176 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
177 epos
.offset
-= sizeof(struct long_ad
);
181 fibh
->sbh
= fibh
->ebh
= udf_tread(dir
->i_sb
, block
);
186 fname
= kmalloc(UDF_NAME_LEN
, GFP_NOFS
);
190 while (f_pos
< size
) {
191 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
196 liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
197 lfi
= cfi
->lengthFileIdent
;
199 if (fibh
->sbh
== fibh
->ebh
) {
200 nameptr
= fi
->fileIdent
+ liu
;
202 int poffset
; /* Unpaded ending offset */
204 poffset
= fibh
->soffset
+ sizeof(struct fileIdentDesc
) +
208 nameptr
= (uint8_t *)(fibh
->ebh
->b_data
+
212 memcpy(nameptr
, fi
->fileIdent
+ liu
,
214 memcpy(nameptr
+ lfi
- poffset
,
215 fibh
->ebh
->b_data
, poffset
);
219 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
220 if (!UDF_QUERY_FLAG(dir
->i_sb
, UDF_FLAG_UNDELETE
))
224 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_HIDDEN
) != 0) {
225 if (!UDF_QUERY_FLAG(dir
->i_sb
, UDF_FLAG_UNHIDE
))
229 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_PARENT
) &&
236 flen
= udf_get_filename(dir
->i_sb
, nameptr
, fname
, lfi
);
237 if (flen
&& udf_match(flen
, fname
, child
->len
, child
->name
))
243 if (fibh
->sbh
!= fibh
->ebh
)
253 static struct dentry
*udf_lookup(struct inode
*dir
, struct dentry
*dentry
,
256 struct inode
*inode
= NULL
;
257 struct fileIdentDesc cfi
;
258 struct udf_fileident_bh fibh
;
260 if (dentry
->d_name
.len
> UDF_NAME_LEN
- 2)
261 return ERR_PTR(-ENAMETOOLONG
);
264 /* temporary shorthand for specifying files by inode number */
265 if (!strncmp(dentry
->d_name
.name
, ".B=", 3)) {
266 struct kernel_lb_addr lb
= {
267 .logicalBlockNum
= 0,
268 .partitionReferenceNum
=
269 simple_strtoul(dentry
->d_name
.name
+ 3,
272 inode
= udf_iget(dir
->i_sb
, lb
);
276 #endif /* UDF_RECOVERY */
278 if (udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
)) {
279 struct kernel_lb_addr loc
;
281 if (fibh
.sbh
!= fibh
.ebh
)
285 loc
= lelb_to_cpu(cfi
.icb
.extLocation
);
286 inode
= udf_iget(dir
->i_sb
, &loc
);
288 return ERR_CAST(inode
);
291 return d_splice_alias(inode
, dentry
);
294 static struct fileIdentDesc
*udf_add_entry(struct inode
*dir
,
295 struct dentry
*dentry
,
296 struct udf_fileident_bh
*fibh
,
297 struct fileIdentDesc
*cfi
, int *err
)
299 struct super_block
*sb
= dir
->i_sb
;
300 struct fileIdentDesc
*fi
= NULL
;
301 unsigned char *name
= NULL
;
304 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
309 struct kernel_lb_addr eloc
;
312 struct extent_position epos
= {};
313 struct udf_inode_info
*dinfo
;
315 fibh
->sbh
= fibh
->ebh
= NULL
;
316 name
= kmalloc(UDF_NAME_LEN
, GFP_NOFS
);
323 if (!dentry
->d_name
.len
) {
327 namelen
= udf_put_filename(sb
, dentry
->d_name
.name
, name
,
330 *err
= -ENAMETOOLONG
;
337 nfidlen
= (sizeof(struct fileIdentDesc
) + namelen
+ 3) & ~3;
339 f_pos
= udf_ext0_offset(dir
);
341 fibh
->soffset
= fibh
->eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
343 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
344 if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
, &epos
,
345 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30)) {
346 block
= udf_get_lb_pblock(dir
->i_sb
,
347 &dinfo
->i_location
, 0);
348 fibh
->soffset
= fibh
->eoffset
= sb
->s_blocksize
;
351 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
352 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
353 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
354 epos
.offset
-= sizeof(struct short_ad
);
355 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
356 epos
.offset
-= sizeof(struct long_ad
);
360 fibh
->sbh
= fibh
->ebh
= udf_tread(dir
->i_sb
, block
);
366 block
= dinfo
->i_location
.logicalBlockNum
;
369 while (f_pos
< size
) {
370 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
378 liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
379 lfi
= cfi
->lengthFileIdent
;
381 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
382 if (((sizeof(struct fileIdentDesc
) +
383 liu
+ lfi
+ 3) & ~3) == nfidlen
) {
384 cfi
->descTag
.tagSerialNum
= cpu_to_le16(1);
385 cfi
->fileVersionNum
= cpu_to_le16(1);
386 cfi
->fileCharacteristics
= 0;
387 cfi
->lengthFileIdent
= namelen
;
388 cfi
->lengthOfImpUse
= cpu_to_le16(0);
389 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
,
403 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
&&
404 sb
->s_blocksize
- fibh
->eoffset
< nfidlen
) {
407 fibh
->soffset
-= udf_ext0_offset(dir
);
408 fibh
->eoffset
-= udf_ext0_offset(dir
);
409 f_pos
-= udf_ext0_offset(dir
);
410 if (fibh
->sbh
!= fibh
->ebh
)
413 fibh
->sbh
= fibh
->ebh
=
414 udf_expand_dir_adinicb(dir
, &block
, err
);
417 epos
.block
= dinfo
->i_location
;
418 epos
.offset
= udf_file_entry_alloc_offset(dir
);
419 /* Load extent udf_expand_dir_adinicb() has created */
420 udf_current_aext(dir
, &epos
, &eloc
, &elen
, 1);
423 /* Entry fits into current block? */
424 if (sb
->s_blocksize
- fibh
->eoffset
>= nfidlen
) {
425 fibh
->soffset
= fibh
->eoffset
;
426 fibh
->eoffset
+= nfidlen
;
427 if (fibh
->sbh
!= fibh
->ebh
) {
429 fibh
->sbh
= fibh
->ebh
;
432 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
433 block
= dinfo
->i_location
.logicalBlockNum
;
434 fi
= (struct fileIdentDesc
*)
435 (dinfo
->i_ext
.i_data
+
437 udf_ext0_offset(dir
) +
440 block
= eloc
.logicalBlockNum
+
442 dir
->i_sb
->s_blocksize_bits
);
443 fi
= (struct fileIdentDesc
*)
444 (fibh
->sbh
->b_data
+ fibh
->soffset
);
447 /* Round up last extent in the file */
448 elen
= (elen
+ sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1);
449 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
450 epos
.offset
-= sizeof(struct short_ad
);
451 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
452 epos
.offset
-= sizeof(struct long_ad
);
453 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
454 dinfo
->i_lenExtents
= (dinfo
->i_lenExtents
+ sb
->s_blocksize
455 - 1) & ~(sb
->s_blocksize
- 1);
457 fibh
->soffset
= fibh
->eoffset
- sb
->s_blocksize
;
458 fibh
->eoffset
+= nfidlen
- sb
->s_blocksize
;
459 if (fibh
->sbh
!= fibh
->ebh
) {
461 fibh
->sbh
= fibh
->ebh
;
464 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
465 dir
->i_sb
->s_blocksize_bits
);
466 fibh
->ebh
= udf_bread(dir
,
467 f_pos
>> dir
->i_sb
->s_blocksize_bits
, 1, err
);
470 /* Extents could have been merged, invalidate our position */
473 epos
.block
= dinfo
->i_location
;
474 epos
.offset
= udf_file_entry_alloc_offset(dir
);
476 if (!fibh
->soffset
) {
477 /* Find the freshly allocated block */
478 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
479 (EXT_RECORDED_ALLOCATED
>> 30))
481 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
482 dir
->i_sb
->s_blocksize_bits
);
484 fibh
->sbh
= fibh
->ebh
;
485 fi
= (struct fileIdentDesc
*)(fibh
->sbh
->b_data
);
487 fi
= (struct fileIdentDesc
*)
488 (fibh
->sbh
->b_data
+ sb
->s_blocksize
+
493 memset(cfi
, 0, sizeof(struct fileIdentDesc
));
494 if (UDF_SB(sb
)->s_udfrev
>= 0x0200)
495 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 3, 1, block
,
498 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 2, 1, block
,
500 cfi
->fileVersionNum
= cpu_to_le16(1);
501 cfi
->lengthFileIdent
= namelen
;
502 cfi
->lengthOfImpUse
= cpu_to_le16(0);
503 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
, name
)) {
504 dir
->i_size
+= nfidlen
;
505 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
506 dinfo
->i_lenAlloc
+= nfidlen
;
508 /* Find the last extent and truncate it to proper size */
509 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
510 (EXT_RECORDED_ALLOCATED
>> 30))
512 elen
-= dinfo
->i_lenExtents
- dir
->i_size
;
513 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
514 epos
.offset
-= sizeof(struct short_ad
);
515 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
516 epos
.offset
-= sizeof(struct long_ad
);
517 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
518 dinfo
->i_lenExtents
= dir
->i_size
;
521 mark_inode_dirty(dir
);
530 if (fibh
->sbh
!= fibh
->ebh
)
539 static int udf_delete_entry(struct inode
*inode
, struct fileIdentDesc
*fi
,
540 struct udf_fileident_bh
*fibh
,
541 struct fileIdentDesc
*cfi
)
543 cfi
->fileCharacteristics
|= FID_FILE_CHAR_DELETED
;
545 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
546 memset(&(cfi
->icb
), 0x00, sizeof(struct long_ad
));
548 return udf_write_fi(inode
, cfi
, fi
, fibh
, NULL
, NULL
);
551 static int udf_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
554 struct udf_fileident_bh fibh
;
556 struct fileIdentDesc cfi
, *fi
;
558 struct udf_inode_info
*iinfo
;
560 inode
= udf_new_inode(dir
, mode
, &err
);
565 iinfo
= UDF_I(inode
);
566 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
567 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
569 inode
->i_data
.a_ops
= &udf_aops
;
570 inode
->i_op
= &udf_file_inode_operations
;
571 inode
->i_fop
= &udf_file_operations
;
572 mark_inode_dirty(inode
);
574 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
576 inode_dec_link_count(inode
);
580 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
581 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
582 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
583 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
584 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
585 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
586 mark_inode_dirty(dir
);
587 if (fibh
.sbh
!= fibh
.ebh
)
590 d_instantiate(dentry
, inode
);
595 static int udf_tmpfile(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
598 struct udf_inode_info
*iinfo
;
601 inode
= udf_new_inode(dir
, mode
, &err
);
605 iinfo
= UDF_I(inode
);
606 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
607 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
609 inode
->i_data
.a_ops
= &udf_aops
;
610 inode
->i_op
= &udf_file_inode_operations
;
611 inode
->i_fop
= &udf_file_operations
;
612 mark_inode_dirty(inode
);
614 d_tmpfile(dentry
, inode
);
618 static int udf_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
622 struct udf_fileident_bh fibh
;
623 struct fileIdentDesc cfi
, *fi
;
625 struct udf_inode_info
*iinfo
;
627 if (!old_valid_dev(rdev
))
631 inode
= udf_new_inode(dir
, mode
, &err
);
635 iinfo
= UDF_I(inode
);
636 init_special_inode(inode
, mode
, rdev
);
637 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
639 inode_dec_link_count(inode
);
643 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
644 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
645 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
646 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
647 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
648 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
649 mark_inode_dirty(dir
);
650 mark_inode_dirty(inode
);
652 if (fibh
.sbh
!= fibh
.ebh
)
655 d_instantiate(dentry
, inode
);
662 static int udf_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
665 struct udf_fileident_bh fibh
;
666 struct fileIdentDesc cfi
, *fi
;
668 struct udf_inode_info
*dinfo
= UDF_I(dir
);
669 struct udf_inode_info
*iinfo
;
672 inode
= udf_new_inode(dir
, S_IFDIR
| mode
, &err
);
676 iinfo
= UDF_I(inode
);
677 inode
->i_op
= &udf_dir_inode_operations
;
678 inode
->i_fop
= &udf_dir_operations
;
679 fi
= udf_add_entry(inode
, NULL
, &fibh
, &cfi
, &err
);
681 inode_dec_link_count(inode
);
686 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
687 cfi
.icb
.extLocation
= cpu_to_lelb(dinfo
->i_location
);
688 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
689 cpu_to_le32(dinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
690 cfi
.fileCharacteristics
=
691 FID_FILE_CHAR_DIRECTORY
| FID_FILE_CHAR_PARENT
;
692 udf_write_fi(inode
, &cfi
, fi
, &fibh
, NULL
, NULL
);
694 mark_inode_dirty(inode
);
696 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
699 mark_inode_dirty(inode
);
703 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
704 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
705 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
706 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
707 cfi
.fileCharacteristics
|= FID_FILE_CHAR_DIRECTORY
;
708 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
710 mark_inode_dirty(dir
);
711 d_instantiate(dentry
, inode
);
712 if (fibh
.sbh
!= fibh
.ebh
)
721 static int empty_dir(struct inode
*dir
)
723 struct fileIdentDesc
*fi
, cfi
;
724 struct udf_fileident_bh fibh
;
726 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
728 struct kernel_lb_addr eloc
;
731 struct extent_position epos
= {};
732 struct udf_inode_info
*dinfo
= UDF_I(dir
);
734 f_pos
= udf_ext0_offset(dir
);
735 fibh
.soffset
= fibh
.eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
737 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
738 fibh
.sbh
= fibh
.ebh
= NULL
;
739 else if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
,
740 &epos
, &eloc
, &elen
, &offset
) ==
741 (EXT_RECORDED_ALLOCATED
>> 30)) {
742 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
743 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
744 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
745 epos
.offset
-= sizeof(struct short_ad
);
746 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
747 epos
.offset
-= sizeof(struct long_ad
);
751 fibh
.sbh
= fibh
.ebh
= udf_tread(dir
->i_sb
, block
);
761 while (f_pos
< size
) {
762 fi
= udf_fileident_read(dir
, &f_pos
, &fibh
, &cfi
, &epos
, &eloc
,
765 if (fibh
.sbh
!= fibh
.ebh
)
772 if (cfi
.lengthFileIdent
&&
773 (cfi
.fileCharacteristics
& FID_FILE_CHAR_DELETED
) == 0) {
774 if (fibh
.sbh
!= fibh
.ebh
)
782 if (fibh
.sbh
!= fibh
.ebh
)
790 static int udf_rmdir(struct inode
*dir
, struct dentry
*dentry
)
793 struct inode
*inode
= dentry
->d_inode
;
794 struct udf_fileident_bh fibh
;
795 struct fileIdentDesc
*fi
, cfi
;
796 struct kernel_lb_addr tloc
;
799 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
804 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
805 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
808 if (!empty_dir(inode
))
810 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
813 if (inode
->i_nlink
!= 2)
814 udf_warn(inode
->i_sb
, "empty directory has nlink != 2 (%d)\n",
818 inode_dec_link_count(dir
);
819 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
=
820 current_fs_time(dir
->i_sb
);
821 mark_inode_dirty(dir
);
824 if (fibh
.sbh
!= fibh
.ebh
)
832 static int udf_unlink(struct inode
*dir
, struct dentry
*dentry
)
835 struct inode
*inode
= dentry
->d_inode
;
836 struct udf_fileident_bh fibh
;
837 struct fileIdentDesc
*fi
;
838 struct fileIdentDesc cfi
;
839 struct kernel_lb_addr tloc
;
842 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
847 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
848 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
851 if (!inode
->i_nlink
) {
852 udf_debug("Deleting nonexistent file (%lu), %d\n",
853 inode
->i_ino
, inode
->i_nlink
);
856 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
859 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(dir
->i_sb
);
860 mark_inode_dirty(dir
);
861 inode_dec_link_count(inode
);
862 inode
->i_ctime
= dir
->i_ctime
;
866 if (fibh
.sbh
!= fibh
.ebh
)
874 static int udf_symlink(struct inode
*dir
, struct dentry
*dentry
,
878 struct pathComponent
*pc
;
879 const char *compstart
;
880 struct udf_fileident_bh fibh
;
881 struct extent_position epos
= {};
882 int eoffset
, elen
= 0;
883 struct fileIdentDesc
*fi
;
884 struct fileIdentDesc cfi
;
888 unsigned char *name
= NULL
;
890 struct udf_inode_info
*iinfo
;
891 struct super_block
*sb
= dir
->i_sb
;
893 inode
= udf_new_inode(dir
, S_IFLNK
| S_IRWXUGO
, &err
);
897 iinfo
= UDF_I(inode
);
898 down_write(&iinfo
->i_data_sem
);
899 name
= kmalloc(UDF_NAME_LEN
, GFP_NOFS
);
905 inode
->i_data
.a_ops
= &udf_symlink_aops
;
906 inode
->i_op
= &udf_symlink_inode_operations
;
908 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
909 struct kernel_lb_addr eloc
;
912 block
= udf_new_block(sb
, inode
,
913 iinfo
->i_location
.partitionReferenceNum
,
914 iinfo
->i_location
.logicalBlockNum
, &err
);
917 epos
.block
= iinfo
->i_location
;
918 epos
.offset
= udf_file_entry_alloc_offset(inode
);
920 eloc
.logicalBlockNum
= block
;
921 eloc
.partitionReferenceNum
=
922 iinfo
->i_location
.partitionReferenceNum
;
923 bsize
= sb
->s_blocksize
;
924 iinfo
->i_lenExtents
= bsize
;
925 udf_add_aext(inode
, &epos
, &eloc
, bsize
, 0);
928 block
= udf_get_pblock(sb
, block
,
929 iinfo
->i_location
.partitionReferenceNum
,
931 epos
.bh
= udf_tgetblk(sb
, block
);
932 lock_buffer(epos
.bh
);
933 memset(epos
.bh
->b_data
, 0x00, bsize
);
934 set_buffer_uptodate(epos
.bh
);
935 unlock_buffer(epos
.bh
);
936 mark_buffer_dirty_inode(epos
.bh
, inode
);
937 ea
= epos
.bh
->b_data
+ udf_ext0_offset(inode
);
939 ea
= iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
;
941 eoffset
= sb
->s_blocksize
- udf_ext0_offset(inode
);
942 pc
= (struct pathComponent
*)ea
;
944 if (*symname
== '/') {
947 } while (*symname
== '/');
949 pc
->componentType
= 1;
950 pc
->lengthComponentIdent
= 0;
951 pc
->componentFileVersionNum
= 0;
952 elen
+= sizeof(struct pathComponent
);
958 if (elen
+ sizeof(struct pathComponent
) > eoffset
)
961 pc
= (struct pathComponent
*)(ea
+ elen
);
967 } while (*symname
&& *symname
!= '/');
969 pc
->componentType
= 5;
970 pc
->lengthComponentIdent
= 0;
971 pc
->componentFileVersionNum
= 0;
972 if (compstart
[0] == '.') {
973 if ((symname
- compstart
) == 1)
974 pc
->componentType
= 4;
975 else if ((symname
- compstart
) == 2 &&
977 pc
->componentType
= 3;
980 if (pc
->componentType
== 5) {
981 namelen
= udf_put_filename(sb
, compstart
, name
,
982 symname
- compstart
);
986 if (elen
+ sizeof(struct pathComponent
) + namelen
>
990 pc
->lengthComponentIdent
= namelen
;
992 memcpy(pc
->componentIdent
, name
, namelen
);
995 elen
+= sizeof(struct pathComponent
) + pc
->lengthComponentIdent
;
1000 } while (*symname
== '/');
1005 inode
->i_size
= elen
;
1006 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1007 iinfo
->i_lenAlloc
= inode
->i_size
;
1009 udf_truncate_tail_extent(inode
);
1010 mark_inode_dirty(inode
);
1011 up_write(&iinfo
->i_data_sem
);
1013 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
1016 cfi
.icb
.extLength
= cpu_to_le32(sb
->s_blocksize
);
1017 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
1018 if (UDF_SB(inode
->i_sb
)->s_lvid_bh
) {
1019 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
1020 cpu_to_le32(lvid_get_unique_id(sb
));
1022 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
1023 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1024 mark_inode_dirty(dir
);
1025 if (fibh
.sbh
!= fibh
.ebh
)
1028 d_instantiate(dentry
, inode
);
1036 up_write(&iinfo
->i_data_sem
);
1038 inode_dec_link_count(inode
);
1043 static int udf_link(struct dentry
*old_dentry
, struct inode
*dir
,
1044 struct dentry
*dentry
)
1046 struct inode
*inode
= old_dentry
->d_inode
;
1047 struct udf_fileident_bh fibh
;
1048 struct fileIdentDesc cfi
, *fi
;
1051 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
1055 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
1056 cfi
.icb
.extLocation
= cpu_to_lelb(UDF_I(inode
)->i_location
);
1057 if (UDF_SB(inode
->i_sb
)->s_lvid_bh
) {
1058 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
1059 cpu_to_le32(lvid_get_unique_id(inode
->i_sb
));
1061 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
1062 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1063 mark_inode_dirty(dir
);
1065 if (fibh
.sbh
!= fibh
.ebh
)
1069 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1070 mark_inode_dirty(inode
);
1072 d_instantiate(dentry
, inode
);
1077 /* Anybody can rename anything with this: the permission checks are left to the
1078 * higher-level routines.
1080 static int udf_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1081 struct inode
*new_dir
, struct dentry
*new_dentry
)
1083 struct inode
*old_inode
= old_dentry
->d_inode
;
1084 struct inode
*new_inode
= new_dentry
->d_inode
;
1085 struct udf_fileident_bh ofibh
, nfibh
;
1086 struct fileIdentDesc
*ofi
= NULL
, *nfi
= NULL
, *dir_fi
= NULL
;
1087 struct fileIdentDesc ocfi
, ncfi
;
1088 struct buffer_head
*dir_bh
= NULL
;
1089 int retval
= -ENOENT
;
1090 struct kernel_lb_addr tloc
;
1091 struct udf_inode_info
*old_iinfo
= UDF_I(old_inode
);
1093 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1095 if (ofibh
.sbh
!= ofibh
.ebh
)
1099 tloc
= lelb_to_cpu(ocfi
.icb
.extLocation
);
1100 if (!ofi
|| udf_get_lb_pblock(old_dir
->i_sb
, &tloc
, 0)
1101 != old_inode
->i_ino
)
1104 nfi
= udf_find_entry(new_dir
, &new_dentry
->d_name
, &nfibh
, &ncfi
);
1107 if (nfibh
.sbh
!= nfibh
.ebh
)
1113 if (S_ISDIR(old_inode
->i_mode
)) {
1114 int offset
= udf_ext0_offset(old_inode
);
1117 retval
= -ENOTEMPTY
;
1118 if (!empty_dir(new_inode
))
1122 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1123 dir_fi
= udf_get_fileident(
1124 old_iinfo
->i_ext
.i_data
-
1126 sizeof(struct extendedFileEntry
) :
1127 sizeof(struct fileEntry
)),
1128 old_inode
->i_sb
->s_blocksize
, &offset
);
1130 dir_bh
= udf_bread(old_inode
, 0, 0, &retval
);
1133 dir_fi
= udf_get_fileident(dir_bh
->b_data
,
1134 old_inode
->i_sb
->s_blocksize
, &offset
);
1138 tloc
= lelb_to_cpu(dir_fi
->icb
.extLocation
);
1139 if (udf_get_lb_pblock(old_inode
->i_sb
, &tloc
, 0) !=
1144 nfi
= udf_add_entry(new_dir
, new_dentry
, &nfibh
, &ncfi
,
1151 * Like most other Unix systems, set the ctime for inodes on a
1154 old_inode
->i_ctime
= current_fs_time(old_inode
->i_sb
);
1155 mark_inode_dirty(old_inode
);
1160 ncfi
.fileVersionNum
= ocfi
.fileVersionNum
;
1161 ncfi
.fileCharacteristics
= ocfi
.fileCharacteristics
;
1162 memcpy(&(ncfi
.icb
), &(ocfi
.icb
), sizeof(struct long_ad
));
1163 udf_write_fi(new_dir
, &ncfi
, nfi
, &nfibh
, NULL
, NULL
);
1165 /* The old fid may have moved - find it again */
1166 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1167 udf_delete_entry(old_dir
, ofi
, &ofibh
, &ocfi
);
1170 new_inode
->i_ctime
= current_fs_time(new_inode
->i_sb
);
1171 inode_dec_link_count(new_inode
);
1173 old_dir
->i_ctime
= old_dir
->i_mtime
= current_fs_time(old_dir
->i_sb
);
1174 mark_inode_dirty(old_dir
);
1177 dir_fi
->icb
.extLocation
= cpu_to_lelb(UDF_I(new_dir
)->i_location
);
1178 udf_update_tag((char *)dir_fi
,
1179 (sizeof(struct fileIdentDesc
) +
1180 le16_to_cpu(dir_fi
->lengthOfImpUse
) + 3) & ~3);
1181 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1182 mark_inode_dirty(old_inode
);
1184 mark_buffer_dirty_inode(dir_bh
, old_inode
);
1186 inode_dec_link_count(old_dir
);
1188 inode_dec_link_count(new_inode
);
1191 mark_inode_dirty(new_dir
);
1196 if (ofibh
.sbh
!= ofibh
.ebh
)
1206 if (nfibh
.sbh
!= nfibh
.ebh
)
1214 static struct dentry
*udf_get_parent(struct dentry
*child
)
1216 struct kernel_lb_addr tloc
;
1217 struct inode
*inode
= NULL
;
1218 struct qstr dotdot
= QSTR_INIT("..", 2);
1219 struct fileIdentDesc cfi
;
1220 struct udf_fileident_bh fibh
;
1222 if (!udf_find_entry(child
->d_inode
, &dotdot
, &fibh
, &cfi
))
1223 return ERR_PTR(-EACCES
);
1225 if (fibh
.sbh
!= fibh
.ebh
)
1229 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
1230 inode
= udf_iget(child
->d_inode
->i_sb
, &tloc
);
1232 return ERR_CAST(inode
);
1234 return d_obtain_alias(inode
);
1238 static struct dentry
*udf_nfs_get_inode(struct super_block
*sb
, u32 block
,
1239 u16 partref
, __u32 generation
)
1241 struct inode
*inode
;
1242 struct kernel_lb_addr loc
;
1245 return ERR_PTR(-ESTALE
);
1247 loc
.logicalBlockNum
= block
;
1248 loc
.partitionReferenceNum
= partref
;
1249 inode
= udf_iget(sb
, &loc
);
1252 return ERR_CAST(inode
);
1254 if (generation
&& inode
->i_generation
!= generation
) {
1256 return ERR_PTR(-ESTALE
);
1258 return d_obtain_alias(inode
);
1261 static struct dentry
*udf_fh_to_dentry(struct super_block
*sb
,
1262 struct fid
*fid
, int fh_len
, int fh_type
)
1264 if ((fh_len
!= 3 && fh_len
!= 5) ||
1265 (fh_type
!= FILEID_UDF_WITH_PARENT
&&
1266 fh_type
!= FILEID_UDF_WITHOUT_PARENT
))
1269 return udf_nfs_get_inode(sb
, fid
->udf
.block
, fid
->udf
.partref
,
1270 fid
->udf
.generation
);
1273 static struct dentry
*udf_fh_to_parent(struct super_block
*sb
,
1274 struct fid
*fid
, int fh_len
, int fh_type
)
1276 if (fh_len
!= 5 || fh_type
!= FILEID_UDF_WITH_PARENT
)
1279 return udf_nfs_get_inode(sb
, fid
->udf
.parent_block
,
1280 fid
->udf
.parent_partref
,
1281 fid
->udf
.parent_generation
);
1283 static int udf_encode_fh(struct inode
*inode
, __u32
*fh
, int *lenp
,
1284 struct inode
*parent
)
1287 struct kernel_lb_addr location
= UDF_I(inode
)->i_location
;
1288 struct fid
*fid
= (struct fid
*)fh
;
1289 int type
= FILEID_UDF_WITHOUT_PARENT
;
1291 if (parent
&& (len
< 5)) {
1293 return FILEID_INVALID
;
1294 } else if (len
< 3) {
1296 return FILEID_INVALID
;
1300 fid
->udf
.block
= location
.logicalBlockNum
;
1301 fid
->udf
.partref
= location
.partitionReferenceNum
;
1302 fid
->udf
.parent_partref
= 0;
1303 fid
->udf
.generation
= inode
->i_generation
;
1306 location
= UDF_I(parent
)->i_location
;
1307 fid
->udf
.parent_block
= location
.logicalBlockNum
;
1308 fid
->udf
.parent_partref
= location
.partitionReferenceNum
;
1309 fid
->udf
.parent_generation
= inode
->i_generation
;
1311 type
= FILEID_UDF_WITH_PARENT
;
1317 const struct export_operations udf_export_ops
= {
1318 .encode_fh
= udf_encode_fh
,
1319 .fh_to_dentry
= udf_fh_to_dentry
,
1320 .fh_to_parent
= udf_fh_to_parent
,
1321 .get_parent
= udf_get_parent
,
1324 const struct inode_operations udf_dir_inode_operations
= {
1325 .lookup
= udf_lookup
,
1326 .create
= udf_create
,
1328 .unlink
= udf_unlink
,
1329 .symlink
= udf_symlink
,
1333 .rename
= udf_rename
,
1334 .tmpfile
= udf_tmpfile
,
1336 const struct inode_operations udf_symlink_inode_operations
= {
1337 .readlink
= generic_readlink
,
1338 .follow_link
= page_follow_link_light
,
1339 .put_link
= page_put_link
,