5 * Inode name handling routines for the OSTA-UDF(tm) filesystem.
8 * E-mail regarding any portion of the Linux UDF file system should be
9 * directed to the development team mailing list (run by majordomo):
10 * linux_udf@hpesjro.fc.hp.com
13 * This file is distributed under the terms of the GNU General Public
14 * License (GPL). Copies of the GPL can be obtained from:
15 * ftp://prep.ai.mit.edu/pub/gnu/GPL
16 * Each contributing author retains all rights to their own work.
18 * (C) 1998-2001 Ben Fennema
19 * (C) 1999-2000 Stelias Computing Inc
23 * 12/12/98 blf Created. Split out the lookup code from dir.c
24 * 04/19/99 blf link, mknod, symlink support
31 #include <linux/string.h>
32 #include <linux/errno.h>
34 #include <linux/slab.h>
35 #include <linux/quotaops.h>
36 #include <linux/locks.h>
37 #include <linux/smp_lock.h>
39 static inline int udf_match(int len, const char * const name, struct qstr *qs)
43 return !memcmp(name, qs->name, len);
46 int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
47 struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh,
48 uint8_t *impuse, uint8_t *fileident)
50 uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
55 uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
56 uint8_t lfi = cfi->lengthFileIdent;
57 int padlen = fibh->eoffset - fibh->soffset - liu - lfi -
58 sizeof(struct fileIdentDesc);
60 offset = fibh->soffset + sizeof(struct fileIdentDesc);
65 memcpy((uint8_t *)sfi->impUse, impuse, liu);
67 memcpy(fibh->ebh->b_data + offset, impuse, liu);
70 memcpy((uint8_t *)sfi->impUse, impuse, -offset);
71 memcpy(fibh->ebh->b_data, impuse - offset, liu + offset);
80 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi);
82 memcpy(fibh->ebh->b_data + offset, fileident, lfi);
85 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset);
86 memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset);
92 if (offset + padlen < 0)
93 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen);
95 memset(fibh->ebh->b_data + offset, 0x00, padlen);
98 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);
99 memset(fibh->ebh->b_data, 0x00, padlen + offset);
102 crc = udf_crc((uint8_t *)cfi + sizeof(tag), sizeof(struct fileIdentDesc) -
105 if (fibh->sbh == fibh->ebh)
106 crc = udf_crc((uint8_t *)sfi->impUse,
107 crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
108 else if (sizeof(struct fileIdentDesc) >= -fibh->soffset)
109 crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset,
110 crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
113 crc = udf_crc((uint8_t *)sfi->impUse,
114 -fibh->soffset - sizeof(struct fileIdentDesc), crc);
115 crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
118 cfi->descTag.descCRC = cpu_to_le32(crc);
119 cfi->descTag.descCRCLength = cpu_to_le16(crclen);
123 checksum += ((uint8_t *)&cfi->descTag)[i];
125 cfi->descTag.tagChecksum = checksum;
126 if (sizeof(struct fileIdentDesc) <= -fibh->soffset)
127 memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc));
130 memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
131 memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,
132 sizeof(struct fileIdentDesc) + fibh->soffset);
135 if (fibh->sbh != fibh->ebh)
136 mark_buffer_dirty_inode(fibh->ebh, inode);
137 mark_buffer_dirty_inode(fibh->sbh, inode);
141 static struct fileIdentDesc *
142 udf_find_entry(struct inode *dir, struct dentry *dentry,
143 struct udf_fileident_bh *fibh,
144 struct fileIdentDesc *cfi)
146 struct fileIdentDesc *fi=NULL;
153 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
155 uint32_t extoffset, elen, offset;
156 struct buffer_head *bh = NULL;
161 f_pos = (udf_ext0_offset(dir) >> 2);
163 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
164 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
165 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
167 offset >>= dir->i_sb->s_blocksize_bits;
168 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
169 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
171 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
172 extoffset -= sizeof(short_ad);
173 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
174 extoffset -= sizeof(long_ad);
181 udf_release_data(bh);
185 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
187 udf_release_data(bh);
191 while ( (f_pos < size) )
193 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
197 if (fibh->sbh != fibh->ebh)
198 udf_release_data(fibh->ebh);
199 udf_release_data(fibh->sbh);
200 udf_release_data(bh);
204 liu = le16_to_cpu(cfi->lengthOfImpUse);
205 lfi = cfi->lengthFileIdent;
207 if (fibh->sbh == fibh->ebh)
209 nameptr = fi->fileIdent + liu;
213 int poffset; /* Unpaded ending offset */
215 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
218 nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi);
222 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
223 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
227 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 )
229 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) )
233 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 )
235 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) )
242 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)))
244 if (udf_match(flen, fname, &(dentry->d_name)))
246 udf_release_data(bh);
251 if (fibh->sbh != fibh->ebh)
252 udf_release_data(fibh->ebh);
253 udf_release_data(fibh->sbh);
254 udf_release_data(bh);
262 * Look-up the inode for a given name.
265 * Required - lookup_dentry() will return -ENOTDIR if this routine is not
266 * available for a directory. The filesystem is useless if this routine is
267 * not available for at least the filesystem's root directory.
269 * This routine is passed an incomplete dentry - it must be completed by
270 * calling d_add(dentry, inode). If the name does not exist, then the
271 * specified inode must be set to null. An error should only be returned
272 * when the lookup fails for a reason other than the name not existing.
273 * Note that the directory inode semaphore is held during the call.
275 * Refer to lookup_dentry() in fs/namei.c
276 * lookup_dentry() -> lookup() -> real_lookup() -> .
279 * dir Pointer to inode of parent directory.
280 * dentry Pointer to dentry to complete.
283 * <return> Zero on success.
286 * July 1, 1997 - Andrew E. Mileski
287 * Written, tested, and released.
290 static struct dentry *
291 udf_lookup(struct inode *dir, struct dentry *dentry)
293 struct inode *inode = NULL;
294 struct fileIdentDesc cfi, *fi;
295 struct udf_fileident_bh fibh;
297 if (dentry->d_name.len > UDF_NAME_LEN)
298 return ERR_PTR(-ENAMETOOLONG);
301 /* temporary shorthand for specifying files by inode number */
302 if (!strncmp(dentry->d_name.name, ".B=", 3) )
304 lb_addr lb = { 0, simple_strtoul(dentry->d_name.name+3, NULL, 0) };
305 inode = udf_iget(dir->i_sb, lb);
307 return ERR_PTR(-EACCES);
310 #endif /* UDF_RECOVERY */
312 if ((fi = udf_find_entry(dir, dentry, &fibh, &cfi)))
314 if (fibh.sbh != fibh.ebh)
315 udf_release_data(fibh.ebh);
316 udf_release_data(fibh.sbh);
318 inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
320 return ERR_PTR(-EACCES);
322 d_add(dentry, inode);
326 static struct fileIdentDesc *
327 udf_add_entry(struct inode *dir, struct dentry *dentry,
328 struct udf_fileident_bh *fibh,
329 struct fileIdentDesc *cfi, int *err)
331 struct super_block *sb;
332 struct fileIdentDesc *fi=NULL;
333 struct ustr unifilename;
334 char name[UDF_NAME_LEN], fname[UDF_NAME_LEN];
339 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
345 uint32_t extoffset, elen, offset;
346 struct buffer_head *bh = NULL;
352 if (!dentry->d_name.len)
358 if ( !(udf_char_to_ustr(&unifilename, dentry->d_name.name, dentry->d_name.len)) )
360 *err = -ENAMETOOLONG;
364 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
366 if ( !(namelen = udf_UTF8toCS0(name, &unifilename, UDF_NAME_LEN)) )
368 *err = -ENAMETOOLONG;
372 else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
374 if ( !(namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, name, &unifilename, UDF_NAME_LEN)) )
376 *err = -ENAMETOOLONG;
386 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
388 f_pos = (udf_ext0_offset(dir) >> 2);
390 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
391 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
392 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
394 offset >>= dir->i_sb->s_blocksize_bits;
395 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
396 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
398 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
399 extoffset -= sizeof(short_ad);
400 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
401 extoffset -= sizeof(long_ad);
406 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
408 udf_release_data(bh);
413 block = UDF_I_LOCATION(dir).logicalBlockNum;
415 while ( (f_pos < size) )
417 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
421 if (fibh->sbh != fibh->ebh)
422 udf_release_data(fibh->ebh);
423 udf_release_data(fibh->sbh);
424 udf_release_data(bh);
429 liu = le16_to_cpu(cfi->lengthOfImpUse);
430 lfi = cfi->lengthFileIdent;
432 if (fibh->sbh == fibh->ebh)
433 nameptr = fi->fileIdent + liu;
436 int poffset; /* Unpaded ending offset */
438 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
441 nameptr = (char *)(fibh->ebh->b_data + poffset - lfi);
445 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
446 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
450 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 )
452 if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen)
454 udf_release_data(bh);
455 cfi->descTag.tagSerialNum = cpu_to_le16(1);
456 cfi->fileVersionNum = cpu_to_le16(1);
457 cfi->fileCharacteristics = 0;
458 cfi->lengthFileIdent = namelen;
459 cfi->lengthOfImpUse = cpu_to_le16(0);
460 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name))
473 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) &&
474 udf_match(flen, fname, &(dentry->d_name)))
476 if (fibh->sbh != fibh->ebh)
477 udf_release_data(fibh->ebh);
478 udf_release_data(fibh->sbh);
479 udf_release_data(bh);
487 block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0);
488 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
490 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
491 fibh->soffset = fibh->eoffset = udf_file_entry_alloc_offset(dir);
495 fibh->sbh = fibh->ebh = NULL;
496 fibh->soffset = fibh->eoffset = sb->s_blocksize;
502 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
503 sb->s_blocksize - fibh->eoffset < nfidlen)
505 udf_release_data(bh);
507 fibh->soffset -= udf_ext0_offset(dir);
508 fibh->eoffset -= udf_ext0_offset(dir);
509 f_pos -= (udf_ext0_offset(dir) >> 2);
510 if (fibh->sbh != fibh->ebh)
511 udf_release_data(fibh->ebh);
512 udf_release_data(fibh->sbh);
513 if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
515 bloc = UDF_I_LOCATION(dir);
516 eloc.logicalBlockNum = block;
517 eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
518 elen = dir->i_sb->s_blocksize;
519 extoffset = udf_file_entry_alloc_offset(dir);
520 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
521 extoffset += sizeof(short_ad);
522 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
523 extoffset += sizeof(long_ad);
526 if (sb->s_blocksize - fibh->eoffset >= nfidlen)
528 fibh->soffset = fibh->eoffset;
529 fibh->eoffset += nfidlen;
530 if (fibh->sbh != fibh->ebh)
532 udf_release_data(fibh->sbh);
533 fibh->sbh = fibh->ebh;
536 if (UDF_I_ALLOCTYPE(dir) != ICBTAG_FLAG_AD_IN_ICB)
537 block = eloc.logicalBlockNum + ((elen - 1) >>
538 dir->i_sb->s_blocksize_bits);
540 block = UDF_I_LOCATION(dir).logicalBlockNum;
542 fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset);
546 fibh->soffset = fibh->eoffset - sb->s_blocksize;
547 fibh->eoffset += nfidlen - sb->s_blocksize;
548 if (fibh->sbh != fibh->ebh)
550 udf_release_data(fibh->sbh);
551 fibh->sbh = fibh->ebh;
554 block = eloc.logicalBlockNum + ((elen - 1) >>
555 dir->i_sb->s_blocksize_bits);
557 if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err)))
559 udf_release_data(bh);
560 udf_release_data(fibh->sbh);
564 if (!(fibh->soffset))
566 if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) ==
567 (EXT_RECORDED_ALLOCATED >> 30))
569 block = eloc.logicalBlockNum + ((elen - 1) >>
570 dir->i_sb->s_blocksize_bits);
575 udf_release_data(fibh->sbh);
576 fibh->sbh = fibh->ebh;
577 fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
581 fi = (struct fileIdentDesc *)
582 (fibh->sbh->b_data + sb->s_blocksize + fibh->soffset);
586 memset(cfi, 0, sizeof(struct fileIdentDesc));
587 if (UDF_SB_UDFREV(sb) >= 0x0200)
588 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
590 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
591 cfi->fileVersionNum = cpu_to_le16(1);
592 cfi->lengthFileIdent = namelen;
593 cfi->lengthOfImpUse = cpu_to_le16(0);
594 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name))
596 udf_release_data(bh);
597 dir->i_size += nfidlen;
598 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
599 UDF_I_LENALLOC(dir) += nfidlen;
600 dir->i_version = ++event;
601 mark_inode_dirty(dir);
606 udf_release_data(bh);
607 if (fibh->sbh != fibh->ebh)
608 udf_release_data(fibh->ebh);
609 udf_release_data(fibh->sbh);
615 static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
616 struct udf_fileident_bh *fibh, struct fileIdentDesc *cfi)
618 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
619 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
620 memset(&(cfi->icb), 0x00, sizeof(long_ad));
621 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
624 static int udf_create(struct inode *dir, struct dentry *dentry, int mode)
626 struct udf_fileident_bh fibh;
628 struct fileIdentDesc cfi, *fi;
631 inode = udf_new_inode(dir, mode, &err);
635 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
636 inode->i_data.a_ops = &udf_adinicb_aops;
638 inode->i_data.a_ops = &udf_aops;
639 inode->i_op = &udf_file_inode_operations;
640 inode->i_fop = &udf_file_operations;
641 inode->i_mode = mode;
642 mark_inode_dirty(inode);
644 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
647 mark_inode_dirty(inode);
651 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
652 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
653 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
654 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
655 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
656 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
658 mark_inode_dirty(dir);
659 dir->i_version = ++event;
661 if (fibh.sbh != fibh.ebh)
662 udf_release_data(fibh.ebh);
663 udf_release_data(fibh.sbh);
664 d_instantiate(dentry, inode);
668 static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, int rdev)
670 struct inode * inode;
671 struct udf_fileident_bh fibh;
673 struct fileIdentDesc cfi, *fi;
676 inode = udf_new_inode(dir, mode, &err);
680 inode->i_uid = current->fsuid;
681 init_special_inode(inode, mode, rdev);
682 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
685 mark_inode_dirty(inode);
689 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
690 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
691 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
692 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
693 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
694 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
696 mark_inode_dirty(dir);
697 dir->i_version = ++event;
699 mark_inode_dirty(inode);
701 if (fibh.sbh != fibh.ebh)
702 udf_release_data(fibh.ebh);
703 udf_release_data(fibh.sbh);
704 d_instantiate(dentry, inode);
710 static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
712 struct inode * inode;
713 struct udf_fileident_bh fibh;
715 struct fileIdentDesc cfi, *fi;
718 if (dir->i_nlink >= (256<<sizeof(dir->i_nlink))-1)
722 inode = udf_new_inode(dir, S_IFDIR, &err);
726 inode->i_op = &udf_dir_inode_operations;
727 inode->i_fop = &udf_dir_operations;
728 if (!(fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err)))
731 mark_inode_dirty(inode);
736 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
737 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
738 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
739 cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
740 cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
741 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
742 udf_release_data(fibh.sbh);
743 inode->i_mode = S_IFDIR | mode;
744 if (dir->i_mode & S_ISGID)
745 inode->i_mode |= S_ISGID;
746 mark_inode_dirty(inode);
748 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
751 mark_inode_dirty(inode);
755 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
756 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
757 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
758 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
759 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
760 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
761 dir->i_version = ++event;
763 mark_inode_dirty(dir);
764 d_instantiate(dentry, inode);
765 if (fibh.sbh != fibh.ebh)
766 udf_release_data(fibh.ebh);
767 udf_release_data(fibh.sbh);
773 static int empty_dir(struct inode *dir)
775 struct fileIdentDesc *fi, cfi;
776 struct udf_fileident_bh fibh;
778 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
781 uint32_t extoffset, elen, offset;
782 struct buffer_head *bh = NULL;
784 f_pos = (udf_ext0_offset(dir) >> 2);
786 fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
787 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
788 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
790 offset >>= dir->i_sb->s_blocksize_bits;
791 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
792 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
794 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
795 extoffset -= sizeof(short_ad);
796 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
797 extoffset -= sizeof(long_ad);
804 udf_release_data(bh);
808 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
811 while ( (f_pos < size) )
813 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
817 if (fibh.sbh != fibh.ebh)
818 udf_release_data(fibh.ebh);
819 udf_release_data(fibh.sbh);
820 udf_release_data(bh);
824 if (cfi.lengthFileIdent && (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0)
826 udf_release_data(bh);
830 if (fibh.sbh != fibh.ebh)
831 udf_release_data(fibh.ebh);
832 udf_release_data(fibh.sbh);
833 udf_release_data(bh);
837 static int udf_rmdir(struct inode * dir, struct dentry * dentry)
840 struct inode * inode = dentry->d_inode;
841 struct udf_fileident_bh fibh;
842 struct fileIdentDesc *fi, cfi;
845 fi = udf_find_entry(dir, dentry, &fibh, &cfi);
850 if (udf_get_lb_pblock(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation), 0) != inode->i_ino)
853 if (!empty_dir(inode))
855 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
856 dir->i_version = ++event;
859 if (inode->i_nlink != 2)
860 udf_warning(inode->i_sb, "udf_rmdir",
861 "empty directory has nlink != 2 (%d)",
863 inode->i_version = ++event;
866 mark_inode_dirty(inode);
868 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
869 UDF_I_UCTIME(inode) = UDF_I_UCTIME(dir) = UDF_I_UMTIME(dir) = CURRENT_UTIME;
870 mark_inode_dirty(dir);
873 if (fibh.sbh != fibh.ebh)
874 udf_release_data(fibh.ebh);
875 udf_release_data(fibh.sbh);
880 static int udf_unlink(struct inode * dir, struct dentry * dentry)
883 struct inode * inode = dentry->d_inode;
884 struct udf_fileident_bh fibh;
885 struct fileIdentDesc *fi;
886 struct fileIdentDesc cfi;
889 fi = udf_find_entry(dir, dentry, &fibh, &cfi);
895 if (udf_get_lb_pblock(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation), 0) !=
903 udf_debug("Deleting nonexistent file (%lu), %d\n",
904 inode->i_ino, inode->i_nlink);
907 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
910 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
911 UDF_I_UCTIME(dir) = UDF_I_UMTIME(dir) = CURRENT_UTIME;
912 mark_inode_dirty(dir);
914 mark_inode_dirty(inode);
915 inode->i_ctime = dir->i_ctime;
919 if (fibh.sbh != fibh.ebh)
920 udf_release_data(fibh.ebh);
921 udf_release_data(fibh.sbh);
926 static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * symname)
928 struct inode * inode;
929 struct pathComponent *pc;
931 struct udf_fileident_bh fibh;
932 struct buffer_head *bh = NULL;
933 int eoffset, elen = 0;
934 struct fileIdentDesc *fi;
935 struct fileIdentDesc cfi;
940 if (!(inode = udf_new_inode(dir, S_IFLNK, &err)))
943 inode->i_mode = S_IFLNK | S_IRWXUGO;
944 inode->i_data.a_ops = &udf_symlink_aops;
945 inode->i_op = &page_symlink_inode_operations;
947 if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB)
949 struct buffer_head *bh = NULL;
951 uint32_t elen, extoffset;
953 block = udf_new_block(inode->i_sb, inode,
954 UDF_I_LOCATION(inode).partitionReferenceNum,
955 UDF_I_LOCATION(inode).logicalBlockNum, &err);
958 bloc = UDF_I_LOCATION(inode);
959 eloc.logicalBlockNum = block;
960 eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
961 elen = inode->i_sb->s_blocksize;
962 UDF_I_LENEXTENTS(inode) = elen;
963 extoffset = udf_file_entry_alloc_offset(inode);
964 udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 0);
965 udf_release_data(bh);
967 block = udf_get_pblock(inode->i_sb, block,
968 UDF_I_LOCATION(inode).partitionReferenceNum, 0);
969 bh = udf_tread(inode->i_sb, block);
971 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
972 mark_buffer_uptodate(bh, 1);
974 mark_buffer_dirty_inode(bh, inode);
978 block = udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0);
979 bh = udf_tread(inode->i_sb, block);
981 ea = bh->b_data + udf_ext0_offset(inode);
983 eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
984 pc = (struct pathComponent *)ea;
991 } while (*symname == '/');
993 pc->componentType = 1;
994 pc->lengthComponentIdent = 0;
995 pc->componentFileVersionNum = 0;
996 pc += sizeof(struct pathComponent);
997 elen += sizeof(struct pathComponent);
1000 err = -ENAMETOOLONG;
1004 if (elen + sizeof(struct pathComponent) > eoffset)
1007 pc = (struct pathComponent *)(ea + elen);
1009 compstart = (char *)symname;
1014 } while (*symname && *symname != '/');
1016 pc->componentType = 5;
1017 pc->lengthComponentIdent = 0;
1018 pc->componentFileVersionNum = 0;
1019 if (pc->componentIdent[0] == '.')
1021 if (pc->lengthComponentIdent == 1)
1022 pc->componentType = 4;
1023 else if (pc->lengthComponentIdent == 2 && pc->componentIdent[1] == '.')
1024 pc->componentType = 3;
1027 if (pc->componentType == 5)
1029 if (elen + sizeof(struct pathComponent) + symname - compstart > eoffset)
1032 pc->lengthComponentIdent = symname - compstart;
1034 memcpy(pc->componentIdent, compstart, pc->lengthComponentIdent);
1037 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
1044 } while (*symname == '/');
1048 udf_release_data(bh);
1049 inode->i_size = elen;
1050 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1051 UDF_I_LENALLOC(inode) = inode->i_size;
1052 mark_inode_dirty(inode);
1054 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
1056 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
1057 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
1058 if (UDF_SB_LVIDBH(inode->i_sb))
1060 struct logicalVolHeaderDesc *lvhd;
1062 lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
1063 uniqueID = le64_to_cpu(lvhd->uniqueID);
1064 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
1065 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
1066 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1068 lvhd->uniqueID = cpu_to_le64(uniqueID);
1069 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
1071 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
1072 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
1074 mark_inode_dirty(dir);
1075 dir->i_version = ++event;
1077 if (fibh.sbh != fibh.ebh)
1078 udf_release_data(fibh.ebh);
1079 udf_release_data(fibh.sbh);
1080 d_instantiate(dentry, inode);
1088 mark_inode_dirty(inode);
1093 static int udf_link(struct dentry * old_dentry, struct inode * dir,
1094 struct dentry *dentry)
1096 struct inode *inode = old_dentry->d_inode;
1097 struct udf_fileident_bh fibh;
1099 struct fileIdentDesc cfi, *fi;
1101 if (S_ISDIR(inode->i_mode))
1104 if (inode->i_nlink >= (256<<sizeof(inode->i_nlink))-1)
1107 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
1109 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
1110 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
1111 if (UDF_SB_LVIDBH(inode->i_sb))
1113 struct logicalVolHeaderDesc *lvhd;
1115 lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
1116 uniqueID = le64_to_cpu(lvhd->uniqueID);
1117 *(uint32_t *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
1118 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
1119 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1121 lvhd->uniqueID = cpu_to_le64(uniqueID);
1122 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
1124 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
1125 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
1127 mark_inode_dirty(dir);
1128 dir->i_version = ++event;
1130 if (fibh.sbh != fibh.ebh)
1131 udf_release_data(fibh.ebh);
1132 udf_release_data(fibh.sbh);
1134 inode->i_ctime = CURRENT_TIME;
1135 UDF_I_UCTIME(inode) = CURRENT_UTIME;
1136 mark_inode_dirty(inode);
1137 atomic_inc(&inode->i_count);
1138 d_instantiate(dentry, inode);
1142 /* Anybody can rename anything with this: the permission checks are left to the
1143 * higher-level routines.
1145 static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
1146 struct inode * new_dir, struct dentry * new_dentry)
1148 struct inode * old_inode = old_dentry->d_inode;
1149 struct inode * new_inode = new_dentry->d_inode;
1150 struct udf_fileident_bh ofibh, nfibh;
1151 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi;
1152 struct buffer_head *dir_bh = NULL;
1153 int retval = -ENOENT;
1155 if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi)))
1157 if (ofibh.sbh != ofibh.ebh)
1158 udf_release_data(ofibh.ebh);
1159 udf_release_data(ofibh.sbh);
1161 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, lelb_to_cpu(ocfi.icb.extLocation), 0) !=
1167 nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi);
1172 if (nfibh.sbh != nfibh.ebh)
1173 udf_release_data(nfibh.ebh);
1174 udf_release_data(nfibh.sbh);
1178 if (S_ISDIR(old_inode->i_mode))
1180 uint32_t offset = udf_ext0_offset(old_inode);
1184 retval = -ENOTEMPTY;
1185 if (!empty_dir(new_inode))
1189 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1192 dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset);
1195 if (udf_get_lb_pblock(old_inode->i_sb, cpu_to_lelb(dir_fi->icb.extLocation), 0) !=
1201 if (!new_inode && new_dir->i_nlink >= (256<<sizeof(new_dir->i_nlink))-1)
1206 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
1210 new_dir->i_version = ++event;
1213 * Like most other Unix systems, set the ctime for inodes on a
1216 old_inode->i_ctime = CURRENT_TIME;
1217 UDF_I_UCTIME(old_inode) = CURRENT_UTIME;
1218 mark_inode_dirty(old_inode);
1223 ncfi.fileVersionNum = ocfi.fileVersionNum;
1224 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
1225 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(long_ad));
1226 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
1228 /* The old fid may have moved - find it again */
1229 ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
1230 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
1232 old_dir->i_version = ++event;
1235 new_inode->i_nlink--;
1236 new_inode->i_ctime = CURRENT_TIME;
1237 UDF_I_UCTIME(new_inode) = CURRENT_UTIME;
1238 mark_inode_dirty(new_inode);
1240 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1241 UDF_I_UCTIME(old_dir) = UDF_I_UMTIME(old_dir) = CURRENT_UTIME;
1242 mark_inode_dirty(old_dir);
1246 dir_fi->icb.extLocation = lelb_to_cpu(UDF_I_LOCATION(new_dir));
1247 udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) +
1248 cpu_to_le16(dir_fi->lengthOfImpUse) + 3) & ~3);
1249 if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB)
1251 old_inode->i_version = ++event;
1252 mark_inode_dirty(old_inode);
1255 mark_buffer_dirty_inode(dir_bh, old_inode);
1256 old_dir->i_nlink --;
1257 mark_inode_dirty(old_dir);
1260 new_inode->i_nlink --;
1261 mark_inode_dirty(new_inode);
1265 new_dir->i_nlink ++;
1266 mark_inode_dirty(new_dir);
1272 if (ofibh.sbh != ofibh.ebh)
1273 udf_release_data(ofibh.ebh);
1274 udf_release_data(ofibh.sbh);
1280 udf_release_data(dir_bh);
1283 if (nfibh.sbh != nfibh.ebh)
1284 udf_release_data(nfibh.ebh);
1285 udf_release_data(nfibh.sbh);
1290 struct inode_operations udf_dir_inode_operations = {
1295 symlink: udf_symlink,