1 /* 2 * namei.c 3 * 4 * PURPOSE 5 * Inode name handling routines for the OSTA-UDF(tm) filesystem. 6 * 7 * COPYRIGHT 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. 12 * 13 * (C) 1998-2004 Ben Fennema 14 * (C) 1999-2000 Stelias Computing Inc 15 * 16 * HISTORY 17 * 18 * 12/12/98 blf Created. Split out the lookup code from dir.c 19 * 04/19/99 blf link, mknod, symlink support 20 */ 21 22 #include "udfdecl.h" 23 24 #include "udf_i.h" 25 #include "udf_sb.h" 26 #include <linux/string.h> 27 #include <linux/errno.h> 28 #include <linux/mm.h> 29 #include <linux/slab.h> 30 #include <linux/quotaops.h> 31 #include <linux/smp_lock.h> 32 #include <linux/buffer_head.h> 33 34 static inline int udf_match(int len1, const char *name1, int len2, const char *name2) 35 { 36 if (len1 != len2) 37 return 0; 38 return !memcmp(name1, name2, len1); 39 } 40 41 int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, 42 struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh, 43 uint8_t *impuse, uint8_t *fileident) 44 { 45 uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag); 46 uint16_t crc; 47 uint8_t checksum = 0; 48 int i; 49 int offset; 50 uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse); 51 uint8_t lfi = cfi->lengthFileIdent; 52 int padlen = fibh->eoffset - fibh->soffset - liu - lfi - 53 sizeof(struct fileIdentDesc); 54 int adinicb = 0; 55 56 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) 57 adinicb = 1; 58 59 offset = fibh->soffset + sizeof(struct fileIdentDesc); 60 61 if (impuse) 62 { 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); 67 else 68 { 69 memcpy((uint8_t *)sfi->impUse, impuse, -offset); 70 memcpy(fibh->ebh->b_data, impuse - offset, liu + offset); 71 } 72 } 73 74 offset += liu; 75 76 if (fileident) 77 { 78 if (adinicb || (offset + lfi < 0)) 79 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi); 80 else if (offset >= 0) 81 memcpy(fibh->ebh->b_data + offset, fileident, lfi); 82 else 83 { 84 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset); 85 memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset); 86 } 87 } 88 89 offset += lfi; 90 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); 95 else 96 { 97 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset); 98 memset(fibh->ebh->b_data, 0x00, padlen + offset); 99 } 100 101 crc = udf_crc((uint8_t *)cfi + sizeof(tag), sizeof(struct fileIdentDesc) - 102 sizeof(tag), 0); 103 104 if (fibh->sbh == fibh->ebh) 105 crc = udf_crc((uint8_t *)sfi->impUse, 106 crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc); 107 else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) 108 crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset, 109 crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc); 110 else 111 { 112 crc = udf_crc((uint8_t *)sfi->impUse, 113 -fibh->soffset - sizeof(struct fileIdentDesc), crc); 114 crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc); 115 } 116 117 cfi->descTag.descCRC = cpu_to_le16(crc); 118 cfi->descTag.descCRCLength = cpu_to_le16(crclen); 119 120 for (i=0; i<16; i++) 121 if (i != 4) 122 checksum += ((uint8_t *)&cfi->descTag)[i]; 123 124 cfi->descTag.tagChecksum = checksum; 125 if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) 126 memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc)); 127 else 128 { 129 memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset); 130 memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset, 131 sizeof(struct fileIdentDesc) + fibh->soffset); 132 } 133 134 if (adinicb) 135 mark_inode_dirty(inode); 136 else 137 { 138 if (fibh->sbh != fibh->ebh) 139 mark_buffer_dirty_inode(fibh->ebh, inode); 140 mark_buffer_dirty_inode(fibh->sbh, inode); 141 } 142 return 0; 143 } 144 145 static struct fileIdentDesc * 146 udf_find_entry(struct inode *dir, struct dentry *dentry, 147 struct udf_fileident_bh *fibh, 148 struct fileIdentDesc *cfi) 149 { 150 struct fileIdentDesc *fi=NULL; 151 loff_t f_pos; 152 int block, flen; 153 char fname[UDF_NAME_LEN]; 154 char *nameptr; 155 uint8_t lfi; 156 uint16_t liu; 157 loff_t size; 158 kernel_lb_addr bloc, eloc; 159 uint32_t extoffset, elen, offset; 160 struct buffer_head *bh = NULL; 161 162 size = (udf_ext0_offset(dir) + dir->i_size) >> 2; 163 f_pos = (udf_ext0_offset(dir) >> 2); 164 165 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; 166 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 167 fibh->sbh = fibh->ebh = NULL; 168 else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 169 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30)) 170 { 171 offset >>= dir->i_sb->s_blocksize_bits; 172 block = udf_get_lb_pblock(dir->i_sb, eloc, offset); 173 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) 174 { 175 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 176 extoffset -= sizeof(short_ad); 177 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 178 extoffset -= sizeof(long_ad); 179 } 180 else 181 offset = 0; 182 183 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) 184 { 185 udf_release_data(bh); 186 return NULL; 187 } 188 } 189 else 190 { 191 udf_release_data(bh); 192 return NULL; 193 } 194 195 while ( (f_pos < size) ) 196 { 197 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh); 198 199 if (!fi) 200 { 201 if (fibh->sbh != fibh->ebh) 202 udf_release_data(fibh->ebh); 203 udf_release_data(fibh->sbh); 204 udf_release_data(bh); 205 return NULL; 206 } 207 208 liu = le16_to_cpu(cfi->lengthOfImpUse); 209 lfi = cfi->lengthFileIdent; 210 211 if (fibh->sbh == fibh->ebh) 212 { 213 nameptr = fi->fileIdent + liu; 214 } 215 else 216 { 217 int poffset; /* Unpaded ending offset */ 218 219 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi; 220 221 if (poffset >= lfi) 222 nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi); 223 else 224 { 225 nameptr = fname; 226 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); 227 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset); 228 } 229 } 230 231 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) 232 { 233 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) ) 234 continue; 235 } 236 237 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 ) 238 { 239 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) ) 240 continue; 241 } 242 243 if (!lfi) 244 continue; 245 246 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) 247 { 248 if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) 249 { 250 udf_release_data(bh); 251 return fi; 252 } 253 } 254 } 255 if (fibh->sbh != fibh->ebh) 256 udf_release_data(fibh->ebh); 257 udf_release_data(fibh->sbh); 258 udf_release_data(bh); 259 return NULL; 260 } 261 262 /* 263 * udf_lookup 264 * 265 * PURPOSE 266 * Look-up the inode for a given name. 267 * 268 * DESCRIPTION 269 * Required - lookup_dentry() will return -ENOTDIR if this routine is not 270 * available for a directory. The filesystem is useless if this routine is 271 * not available for at least the filesystem's root directory. 272 * 273 * This routine is passed an incomplete dentry - it must be completed by 274 * calling d_add(dentry, inode). If the name does not exist, then the 275 * specified inode must be set to null. An error should only be returned 276 * when the lookup fails for a reason other than the name not existing. 277 * Note that the directory inode semaphore is held during the call. 278 * 279 * Refer to lookup_dentry() in fs/namei.c 280 * lookup_dentry() -> lookup() -> real_lookup() -> . 281 * 282 * PRE-CONDITIONS 283 * dir Pointer to inode of parent directory. 284 * dentry Pointer to dentry to complete. 285 * nd Pointer to lookup nameidata 286 * 287 * POST-CONDITIONS 288 * <return> Zero on success. 289 * 290 * HISTORY 291 * July 1, 1997 - Andrew E. Mileski 292 * Written, tested, and released. 293 */ 294 295 static struct dentry * 296 udf_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 297 { 298 struct inode *inode = NULL; 299 struct fileIdentDesc cfi; 300 struct udf_fileident_bh fibh; 301 302 if (dentry->d_name.len > UDF_NAME_LEN-2) 303 return ERR_PTR(-ENAMETOOLONG); 304 305 lock_kernel(); 306 #ifdef UDF_RECOVERY 307 /* temporary shorthand for specifying files by inode number */ 308 if (!strncmp(dentry->d_name.name, ".B=", 3) ) 309 { 310 kernel_lb_addr lb = { 0, simple_strtoul(dentry->d_name.name+3, NULL, 0) }; 311 inode = udf_iget(dir->i_sb, lb); 312 if (!inode) 313 { 314 unlock_kernel(); 315 return ERR_PTR(-EACCES); 316 } 317 } 318 else 319 #endif /* UDF_RECOVERY */ 320 321 if (udf_find_entry(dir, dentry, &fibh, &cfi)) 322 { 323 if (fibh.sbh != fibh.ebh) 324 udf_release_data(fibh.ebh); 325 udf_release_data(fibh.sbh); 326 327 inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation)); 328 if ( !inode ) 329 { 330 unlock_kernel(); 331 return ERR_PTR(-EACCES); 332 } 333 } 334 unlock_kernel(); 335 d_add(dentry, inode); 336 return NULL; 337 } 338 339 static struct fileIdentDesc * 340 udf_add_entry(struct inode *dir, struct dentry *dentry, 341 struct udf_fileident_bh *fibh, 342 struct fileIdentDesc *cfi, int *err) 343 { 344 struct super_block *sb; 345 struct fileIdentDesc *fi=NULL; 346 char name[UDF_NAME_LEN], fname[UDF_NAME_LEN]; 347 int namelen; 348 loff_t f_pos; 349 int flen; 350 char *nameptr; 351 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2; 352 int nfidlen; 353 uint8_t lfi; 354 uint16_t liu; 355 int block; 356 kernel_lb_addr bloc, eloc; 357 uint32_t extoffset, elen, offset; 358 struct buffer_head *bh = NULL; 359 360 sb = dir->i_sb; 361 362 if (dentry) 363 { 364 if (!dentry->d_name.len) 365 { 366 *err = -EINVAL; 367 return NULL; 368 } 369 370 if ( !(namelen = udf_put_filename(sb, dentry->d_name.name, name, dentry->d_name.len))) 371 { 372 *err = -ENAMETOOLONG; 373 return NULL; 374 } 375 } 376 else 377 namelen = 0; 378 379 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3; 380 381 f_pos = (udf_ext0_offset(dir) >> 2); 382 383 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; 384 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 385 fibh->sbh = fibh->ebh = NULL; 386 else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 387 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30)) 388 { 389 offset >>= dir->i_sb->s_blocksize_bits; 390 block = udf_get_lb_pblock(dir->i_sb, eloc, offset); 391 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) 392 { 393 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 394 extoffset -= sizeof(short_ad); 395 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 396 extoffset -= sizeof(long_ad); 397 } 398 else 399 offset = 0; 400 401 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) 402 { 403 udf_release_data(bh); 404 *err = -EIO; 405 return NULL; 406 } 407 408 block = UDF_I_LOCATION(dir).logicalBlockNum; 409 410 } 411 else 412 { 413 block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0); 414 fibh->sbh = fibh->ebh = NULL; 415 fibh->soffset = fibh->eoffset = sb->s_blocksize; 416 goto add; 417 } 418 419 while ( (f_pos < size) ) 420 { 421 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh); 422 423 if (!fi) 424 { 425 if (fibh->sbh != fibh->ebh) 426 udf_release_data(fibh->ebh); 427 udf_release_data(fibh->sbh); 428 udf_release_data(bh); 429 *err = -EIO; 430 return NULL; 431 } 432 433 liu = le16_to_cpu(cfi->lengthOfImpUse); 434 lfi = cfi->lengthFileIdent; 435 436 if (fibh->sbh == fibh->ebh) 437 nameptr = fi->fileIdent + liu; 438 else 439 { 440 int poffset; /* Unpaded ending offset */ 441 442 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi; 443 444 if (poffset >= lfi) 445 nameptr = (char *)(fibh->ebh->b_data + poffset - lfi); 446 else 447 { 448 nameptr = fname; 449 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); 450 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset); 451 } 452 } 453 454 if ( (cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) 455 { 456 if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen) 457 { 458 udf_release_data(bh); 459 cfi->descTag.tagSerialNum = cpu_to_le16(1); 460 cfi->fileVersionNum = cpu_to_le16(1); 461 cfi->fileCharacteristics = 0; 462 cfi->lengthFileIdent = namelen; 463 cfi->lengthOfImpUse = cpu_to_le16(0); 464 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) 465 return fi; 466 else 467 { 468 *err = -EIO; 469 return NULL; 470 } 471 } 472 } 473 474 if (!lfi || !dentry) 475 continue; 476 477 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) && 478 udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) 479 { 480 if (fibh->sbh != fibh->ebh) 481 udf_release_data(fibh->ebh); 482 udf_release_data(fibh->sbh); 483 udf_release_data(bh); 484 *err = -EEXIST; 485 return NULL; 486 } 487 } 488 489 add: 490 f_pos += nfidlen; 491 492 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB && 493 sb->s_blocksize - fibh->eoffset < nfidlen) 494 { 495 udf_release_data(bh); 496 bh = NULL; 497 fibh->soffset -= udf_ext0_offset(dir); 498 fibh->eoffset -= udf_ext0_offset(dir); 499 f_pos -= (udf_ext0_offset(dir) >> 2); 500 if (fibh->sbh != fibh->ebh) 501 udf_release_data(fibh->ebh); 502 udf_release_data(fibh->sbh); 503 if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err))) 504 return NULL; 505 bloc = UDF_I_LOCATION(dir); 506 eloc.logicalBlockNum = block; 507 eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum; 508 elen = dir->i_sb->s_blocksize; 509 extoffset = udf_file_entry_alloc_offset(dir); 510 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 511 extoffset += sizeof(short_ad); 512 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 513 extoffset += sizeof(long_ad); 514 } 515 516 if (sb->s_blocksize - fibh->eoffset >= nfidlen) 517 { 518 fibh->soffset = fibh->eoffset; 519 fibh->eoffset += nfidlen; 520 if (fibh->sbh != fibh->ebh) 521 { 522 udf_release_data(fibh->sbh); 523 fibh->sbh = fibh->ebh; 524 } 525 526 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 527 { 528 block = UDF_I_LOCATION(dir).logicalBlockNum; 529 fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) + fibh->soffset - udf_ext0_offset(dir) + UDF_I_LENEATTR(dir)); 530 } 531 else 532 { 533 block = eloc.logicalBlockNum + ((elen - 1) >> 534 dir->i_sb->s_blocksize_bits); 535 fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset); 536 } 537 } 538 else 539 { 540 fibh->soffset = fibh->eoffset - sb->s_blocksize; 541 fibh->eoffset += nfidlen - sb->s_blocksize; 542 if (fibh->sbh != fibh->ebh) 543 { 544 udf_release_data(fibh->sbh); 545 fibh->sbh = fibh->ebh; 546 } 547 548 block = eloc.logicalBlockNum + ((elen - 1) >> 549 dir->i_sb->s_blocksize_bits); 550 551 if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err))) 552 { 553 udf_release_data(bh); 554 udf_release_data(fibh->sbh); 555 return NULL; 556 } 557 558 if (!(fibh->soffset)) 559 { 560 if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) == 561 (EXT_RECORDED_ALLOCATED >> 30)) 562 { 563 block = eloc.logicalBlockNum + ((elen - 1) >> 564 dir->i_sb->s_blocksize_bits); 565 } 566 else 567 block ++; 568 569 udf_release_data(fibh->sbh); 570 fibh->sbh = fibh->ebh; 571 fi = (struct fileIdentDesc *)(fibh->sbh->b_data); 572 } 573 else 574 { 575 fi = (struct fileIdentDesc *) 576 (fibh->sbh->b_data + sb->s_blocksize + fibh->soffset); 577 } 578 } 579 580 memset(cfi, 0, sizeof(struct fileIdentDesc)); 581 if (UDF_SB_UDFREV(sb) >= 0x0200) 582 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag)); 583 else 584 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag)); 585 cfi->fileVersionNum = cpu_to_le16(1); 586 cfi->lengthFileIdent = namelen; 587 cfi->lengthOfImpUse = cpu_to_le16(0); 588 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) 589 { 590 udf_release_data(bh); 591 dir->i_size += nfidlen; 592 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 593 UDF_I_LENALLOC(dir) += nfidlen; 594 mark_inode_dirty(dir); 595 return fi; 596 } 597 else 598 { 599 udf_release_data(bh); 600 if (fibh->sbh != fibh->ebh) 601 udf_release_data(fibh->ebh); 602 udf_release_data(fibh->sbh); 603 *err = -EIO; 604 return NULL; 605 } 606 } 607 608 static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, 609 struct udf_fileident_bh *fibh, struct fileIdentDesc *cfi) 610 { 611 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; 612 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 613 memset(&(cfi->icb), 0x00, sizeof(long_ad)); 614 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); 615 } 616 617 static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) 618 { 619 struct udf_fileident_bh fibh; 620 struct inode *inode; 621 struct fileIdentDesc cfi, *fi; 622 int err; 623 624 lock_kernel(); 625 inode = udf_new_inode(dir, mode, &err); 626 if (!inode) 627 { 628 unlock_kernel(); 629 return err; 630 } 631 632 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) 633 inode->i_data.a_ops = &udf_adinicb_aops; 634 else 635 inode->i_data.a_ops = &udf_aops; 636 inode->i_op = &udf_file_inode_operations; 637 inode->i_fop = &udf_file_operations; 638 inode->i_mode = mode; 639 mark_inode_dirty(inode); 640 641 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) 642 { 643 inode->i_nlink --; 644 mark_inode_dirty(inode); 645 iput(inode); 646 unlock_kernel(); 647 return err; 648 } 649 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 650 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); 651 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 652 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); 653 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 654 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 655 { 656 mark_inode_dirty(dir); 657 } 658 if (fibh.sbh != fibh.ebh) 659 udf_release_data(fibh.ebh); 660 udf_release_data(fibh.sbh); 661 unlock_kernel(); 662 d_instantiate(dentry, inode); 663 return 0; 664 } 665 666 static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t rdev) 667 { 668 struct inode * inode; 669 struct udf_fileident_bh fibh; 670 struct fileIdentDesc cfi, *fi; 671 int err; 672 673 if (!old_valid_dev(rdev)) 674 return -EINVAL; 675 676 lock_kernel(); 677 err = -EIO; 678 inode = udf_new_inode(dir, mode, &err); 679 if (!inode) 680 goto out; 681 682 inode->i_uid = current->fsuid; 683 init_special_inode(inode, mode, rdev); 684 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) 685 { 686 inode->i_nlink --; 687 mark_inode_dirty(inode); 688 iput(inode); 689 unlock_kernel(); 690 return err; 691 } 692 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 693 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); 694 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 695 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); 696 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 697 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 698 { 699 mark_inode_dirty(dir); 700 } 701 mark_inode_dirty(inode); 702 703 if (fibh.sbh != fibh.ebh) 704 udf_release_data(fibh.ebh); 705 udf_release_data(fibh.sbh); 706 d_instantiate(dentry, inode); 707 err = 0; 708 out: 709 unlock_kernel(); 710 return err; 711 } 712 713 static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode) 714 { 715 struct inode * inode; 716 struct udf_fileident_bh fibh; 717 struct fileIdentDesc cfi, *fi; 718 int err; 719 720 lock_kernel(); 721 err = -EMLINK; 722 if (dir->i_nlink >= (256<<sizeof(dir->i_nlink))-1) 723 goto out; 724 725 err = -EIO; 726 inode = udf_new_inode(dir, S_IFDIR, &err); 727 if (!inode) 728 goto out; 729 730 inode->i_op = &udf_dir_inode_operations; 731 inode->i_fop = &udf_dir_operations; 732 if (!(fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err))) 733 { 734 inode->i_nlink--; 735 mark_inode_dirty(inode); 736 iput(inode); 737 goto out; 738 } 739 inode->i_nlink = 2; 740 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 741 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir)); 742 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 743 cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL); 744 cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; 745 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); 746 udf_release_data(fibh.sbh); 747 inode->i_mode = S_IFDIR | mode; 748 if (dir->i_mode & S_ISGID) 749 inode->i_mode |= S_ISGID; 750 mark_inode_dirty(inode); 751 752 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) 753 { 754 inode->i_nlink = 0; 755 mark_inode_dirty(inode); 756 iput(inode); 757 goto out; 758 } 759 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 760 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); 761 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 762 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL); 763 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; 764 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 765 inc_nlink(dir); 766 mark_inode_dirty(dir); 767 d_instantiate(dentry, inode); 768 if (fibh.sbh != fibh.ebh) 769 udf_release_data(fibh.ebh); 770 udf_release_data(fibh.sbh); 771 err = 0; 772 out: 773 unlock_kernel(); 774 return err; 775 } 776 777 static int empty_dir(struct inode *dir) 778 { 779 struct fileIdentDesc *fi, cfi; 780 struct udf_fileident_bh fibh; 781 loff_t f_pos; 782 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2; 783 int block; 784 kernel_lb_addr bloc, eloc; 785 uint32_t extoffset, elen, offset; 786 struct buffer_head *bh = NULL; 787 788 f_pos = (udf_ext0_offset(dir) >> 2); 789 790 fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; 791 792 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 793 fibh.sbh = fibh.ebh = NULL; 794 else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 795 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30)) 796 { 797 offset >>= dir->i_sb->s_blocksize_bits; 798 block = udf_get_lb_pblock(dir->i_sb, eloc, offset); 799 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) 800 { 801 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 802 extoffset -= sizeof(short_ad); 803 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 804 extoffset -= sizeof(long_ad); 805 } 806 else 807 offset = 0; 808 809 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) 810 { 811 udf_release_data(bh); 812 return 0; 813 } 814 } 815 else 816 { 817 udf_release_data(bh); 818 return 0; 819 } 820 821 822 while ( (f_pos < size) ) 823 { 824 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh); 825 826 if (!fi) 827 { 828 if (fibh.sbh != fibh.ebh) 829 udf_release_data(fibh.ebh); 830 udf_release_data(fibh.sbh); 831 udf_release_data(bh); 832 return 0; 833 } 834 835 if (cfi.lengthFileIdent && (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) 836 { 837 if (fibh.sbh != fibh.ebh) 838 udf_release_data(fibh.ebh); 839 udf_release_data(fibh.sbh); 840 udf_release_data(bh); 841 return 0; 842 } 843 } 844 if (fibh.sbh != fibh.ebh) 845 udf_release_data(fibh.ebh); 846 udf_release_data(fibh.sbh); 847 udf_release_data(bh); 848 return 1; 849 } 850 851 static int udf_rmdir(struct inode * dir, struct dentry * dentry) 852 { 853 int retval; 854 struct inode * inode = dentry->d_inode; 855 struct udf_fileident_bh fibh; 856 struct fileIdentDesc *fi, cfi; 857 kernel_lb_addr tloc; 858 859 retval = -ENOENT; 860 lock_kernel(); 861 fi = udf_find_entry(dir, dentry, &fibh, &cfi); 862 if (!fi) 863 goto out; 864 865 retval = -EIO; 866 tloc = lelb_to_cpu(cfi.icb.extLocation); 867 if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino) 868 goto end_rmdir; 869 retval = -ENOTEMPTY; 870 if (!empty_dir(inode)) 871 goto end_rmdir; 872 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 873 if (retval) 874 goto end_rmdir; 875 if (inode->i_nlink != 2) 876 udf_warning(inode->i_sb, "udf_rmdir", 877 "empty directory has nlink != 2 (%d)", 878 inode->i_nlink); 879 clear_nlink(inode); 880 inode->i_size = 0; 881 inode_dec_link_count(dir); 882 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 883 mark_inode_dirty(dir); 884 885 end_rmdir: 886 if (fibh.sbh != fibh.ebh) 887 udf_release_data(fibh.ebh); 888 udf_release_data(fibh.sbh); 889 out: 890 unlock_kernel(); 891 return retval; 892 } 893 894 static int udf_unlink(struct inode * dir, struct dentry * dentry) 895 { 896 int retval; 897 struct inode * inode = dentry->d_inode; 898 struct udf_fileident_bh fibh; 899 struct fileIdentDesc *fi; 900 struct fileIdentDesc cfi; 901 kernel_lb_addr tloc; 902 903 retval = -ENOENT; 904 lock_kernel(); 905 fi = udf_find_entry(dir, dentry, &fibh, &cfi); 906 if (!fi) 907 goto out; 908 909 retval = -EIO; 910 tloc = lelb_to_cpu(cfi.icb.extLocation); 911 if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino) 912 goto end_unlink; 913 914 if (!inode->i_nlink) 915 { 916 udf_debug("Deleting nonexistent file (%lu), %d\n", 917 inode->i_ino, inode->i_nlink); 918 inode->i_nlink = 1; 919 } 920 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 921 if (retval) 922 goto end_unlink; 923 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 924 mark_inode_dirty(dir); 925 inode_dec_link_count(inode); 926 inode->i_ctime = dir->i_ctime; 927 retval = 0; 928 929 end_unlink: 930 if (fibh.sbh != fibh.ebh) 931 udf_release_data(fibh.ebh); 932 udf_release_data(fibh.sbh); 933 out: 934 unlock_kernel(); 935 return retval; 936 } 937 938 static int udf_symlink(struct inode * dir, struct dentry * dentry, const char * symname) 939 { 940 struct inode * inode; 941 struct pathComponent *pc; 942 char *compstart; 943 struct udf_fileident_bh fibh; 944 struct buffer_head *bh = NULL; 945 int eoffset, elen = 0; 946 struct fileIdentDesc *fi; 947 struct fileIdentDesc cfi; 948 char *ea; 949 int err; 950 int block; 951 char name[UDF_NAME_LEN]; 952 int namelen; 953 954 lock_kernel(); 955 if (!(inode = udf_new_inode(dir, S_IFLNK, &err))) 956 goto out; 957 958 inode->i_mode = S_IFLNK | S_IRWXUGO; 959 inode->i_data.a_ops = &udf_symlink_aops; 960 inode->i_op = &page_symlink_inode_operations; 961 962 if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB) 963 { 964 struct buffer_head *bh = NULL; 965 kernel_lb_addr bloc, eloc; 966 uint32_t elen, extoffset; 967 968 block = udf_new_block(inode->i_sb, inode, 969 UDF_I_LOCATION(inode).partitionReferenceNum, 970 UDF_I_LOCATION(inode).logicalBlockNum, &err); 971 if (!block) 972 goto out_no_entry; 973 bloc = UDF_I_LOCATION(inode); 974 eloc.logicalBlockNum = block; 975 eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum; 976 elen = inode->i_sb->s_blocksize; 977 UDF_I_LENEXTENTS(inode) = elen; 978 extoffset = udf_file_entry_alloc_offset(inode); 979 udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 0); 980 udf_release_data(bh); 981 982 block = udf_get_pblock(inode->i_sb, block, 983 UDF_I_LOCATION(inode).partitionReferenceNum, 0); 984 bh = udf_tread(inode->i_sb, block); 985 lock_buffer(bh); 986 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize); 987 set_buffer_uptodate(bh); 988 unlock_buffer(bh); 989 mark_buffer_dirty_inode(bh, inode); 990 ea = bh->b_data + udf_ext0_offset(inode); 991 } 992 else 993 ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); 994 995 eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode); 996 pc = (struct pathComponent *)ea; 997 998 if (*symname == '/') 999 { 1000 do 1001 { 1002 symname++; 1003 } while (*symname == '/'); 1004 1005 pc->componentType = 1; 1006 pc->lengthComponentIdent = 0; 1007 pc->componentFileVersionNum = 0; 1008 pc += sizeof(struct pathComponent); 1009 elen += sizeof(struct pathComponent); 1010 } 1011 1012 err = -ENAMETOOLONG; 1013 1014 while (*symname) 1015 { 1016 if (elen + sizeof(struct pathComponent) > eoffset) 1017 goto out_no_entry; 1018 1019 pc = (struct pathComponent *)(ea + elen); 1020 1021 compstart = (char *)symname; 1022 1023 do 1024 { 1025 symname++; 1026 } while (*symname && *symname != '/'); 1027 1028 pc->componentType = 5; 1029 pc->lengthComponentIdent = 0; 1030 pc->componentFileVersionNum = 0; 1031 if (compstart[0] == '.') 1032 { 1033 if ((symname-compstart) == 1) 1034 pc->componentType = 4; 1035 else if ((symname-compstart) == 2 && compstart[1] == '.') 1036 pc->componentType = 3; 1037 } 1038 1039 if (pc->componentType == 5) 1040 { 1041 if ( !(namelen = udf_put_filename(inode->i_sb, compstart, name, symname-compstart))) 1042 goto out_no_entry; 1043 1044 if (elen + sizeof(struct pathComponent) + namelen > eoffset) 1045 goto out_no_entry; 1046 else 1047 pc->lengthComponentIdent = namelen; 1048 1049 memcpy(pc->componentIdent, name, namelen); 1050 } 1051 1052 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; 1053 1054 if (*symname) 1055 { 1056 do 1057 { 1058 symname++; 1059 } while (*symname == '/'); 1060 } 1061 } 1062 1063 udf_release_data(bh); 1064 inode->i_size = elen; 1065 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) 1066 UDF_I_LENALLOC(inode) = inode->i_size; 1067 mark_inode_dirty(inode); 1068 1069 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) 1070 goto out_no_entry; 1071 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1072 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); 1073 if (UDF_SB_LVIDBH(inode->i_sb)) 1074 { 1075 struct logicalVolHeaderDesc *lvhd; 1076 uint64_t uniqueID; 1077 lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse); 1078 uniqueID = le64_to_cpu(lvhd->uniqueID); 1079 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1080 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); 1081 if (!(++uniqueID & 0x00000000FFFFFFFFUL)) 1082 uniqueID += 16; 1083 lvhd->uniqueID = cpu_to_le64(uniqueID); 1084 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); 1085 } 1086 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1087 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 1088 { 1089 mark_inode_dirty(dir); 1090 } 1091 if (fibh.sbh != fibh.ebh) 1092 udf_release_data(fibh.ebh); 1093 udf_release_data(fibh.sbh); 1094 d_instantiate(dentry, inode); 1095 err = 0; 1096 1097 out: 1098 unlock_kernel(); 1099 return err; 1100 1101 out_no_entry: 1102 inode_dec_link_count(inode); 1103 iput(inode); 1104 goto out; 1105 } 1106 1107 static int udf_link(struct dentry * old_dentry, struct inode * dir, 1108 struct dentry *dentry) 1109 { 1110 struct inode *inode = old_dentry->d_inode; 1111 struct udf_fileident_bh fibh; 1112 struct fileIdentDesc cfi, *fi; 1113 int err; 1114 1115 lock_kernel(); 1116 if (inode->i_nlink >= (256<<sizeof(inode->i_nlink))-1) 1117 { 1118 unlock_kernel(); 1119 return -EMLINK; 1120 } 1121 1122 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) 1123 { 1124 unlock_kernel(); 1125 return err; 1126 } 1127 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1128 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode)); 1129 if (UDF_SB_LVIDBH(inode->i_sb)) 1130 { 1131 struct logicalVolHeaderDesc *lvhd; 1132 uint64_t uniqueID; 1133 lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse); 1134 uniqueID = le64_to_cpu(lvhd->uniqueID); 1135 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1136 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); 1137 if (!(++uniqueID & 0x00000000FFFFFFFFUL)) 1138 uniqueID += 16; 1139 lvhd->uniqueID = cpu_to_le64(uniqueID); 1140 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb)); 1141 } 1142 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1143 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 1144 { 1145 mark_inode_dirty(dir); 1146 } 1147 if (fibh.sbh != fibh.ebh) 1148 udf_release_data(fibh.ebh); 1149 udf_release_data(fibh.sbh); 1150 inc_nlink(inode); 1151 inode->i_ctime = current_fs_time(inode->i_sb); 1152 mark_inode_dirty(inode); 1153 atomic_inc(&inode->i_count); 1154 d_instantiate(dentry, inode); 1155 unlock_kernel(); 1156 return 0; 1157 } 1158 1159 /* Anybody can rename anything with this: the permission checks are left to the 1160 * higher-level routines. 1161 */ 1162 static int udf_rename (struct inode * old_dir, struct dentry * old_dentry, 1163 struct inode * new_dir, struct dentry * new_dentry) 1164 { 1165 struct inode * old_inode = old_dentry->d_inode; 1166 struct inode * new_inode = new_dentry->d_inode; 1167 struct udf_fileident_bh ofibh, nfibh; 1168 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi; 1169 struct buffer_head *dir_bh = NULL; 1170 int retval = -ENOENT; 1171 kernel_lb_addr tloc; 1172 1173 lock_kernel(); 1174 if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi))) 1175 { 1176 if (ofibh.sbh != ofibh.ebh) 1177 udf_release_data(ofibh.ebh); 1178 udf_release_data(ofibh.sbh); 1179 } 1180 tloc = lelb_to_cpu(ocfi.icb.extLocation); 1181 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, tloc, 0) 1182 != old_inode->i_ino) 1183 goto end_rename; 1184 1185 nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi); 1186 if (nfi) 1187 { 1188 if (!new_inode) 1189 { 1190 if (nfibh.sbh != nfibh.ebh) 1191 udf_release_data(nfibh.ebh); 1192 udf_release_data(nfibh.sbh); 1193 nfi = NULL; 1194 } 1195 } 1196 if (S_ISDIR(old_inode->i_mode)) 1197 { 1198 uint32_t offset = udf_ext0_offset(old_inode); 1199 1200 if (new_inode) 1201 { 1202 retval = -ENOTEMPTY; 1203 if (!empty_dir(new_inode)) 1204 goto end_rename; 1205 } 1206 retval = -EIO; 1207 if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) 1208 { 1209 dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) - 1210 (UDF_I_EFE(old_inode) ? 1211 sizeof(struct extendedFileEntry) : 1212 sizeof(struct fileEntry)), 1213 old_inode->i_sb->s_blocksize, &offset); 1214 } 1215 else 1216 { 1217 dir_bh = udf_bread(old_inode, 0, 0, &retval); 1218 if (!dir_bh) 1219 goto end_rename; 1220 dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset); 1221 } 1222 if (!dir_fi) 1223 goto end_rename; 1224 tloc = lelb_to_cpu(dir_fi->icb.extLocation); 1225 if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) 1226 != old_dir->i_ino) 1227 goto end_rename; 1228 1229 retval = -EMLINK; 1230 if (!new_inode && new_dir->i_nlink >= (256<<sizeof(new_dir->i_nlink))-1) 1231 goto end_rename; 1232 } 1233 if (!nfi) 1234 { 1235 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval); 1236 if (!nfi) 1237 goto end_rename; 1238 } 1239 1240 /* 1241 * Like most other Unix systems, set the ctime for inodes on a 1242 * rename. 1243 */ 1244 old_inode->i_ctime = current_fs_time(old_inode->i_sb); 1245 mark_inode_dirty(old_inode); 1246 1247 /* 1248 * ok, that's it 1249 */ 1250 ncfi.fileVersionNum = ocfi.fileVersionNum; 1251 ncfi.fileCharacteristics = ocfi.fileCharacteristics; 1252 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(long_ad)); 1253 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL); 1254 1255 /* The old fid may have moved - find it again */ 1256 ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi); 1257 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); 1258 1259 if (new_inode) 1260 { 1261 new_inode->i_ctime = current_fs_time(new_inode->i_sb); 1262 inode_dec_link_count(new_inode); 1263 } 1264 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); 1265 mark_inode_dirty(old_dir); 1266 1267 if (dir_fi) 1268 { 1269 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir)); 1270 udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) + 1271 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); 1272 if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) 1273 { 1274 mark_inode_dirty(old_inode); 1275 } 1276 else 1277 mark_buffer_dirty_inode(dir_bh, old_inode); 1278 inode_dec_link_count(old_dir); 1279 if (new_inode) 1280 { 1281 inode_dec_link_count(new_inode); 1282 } 1283 else 1284 { 1285 inc_nlink(new_dir); 1286 mark_inode_dirty(new_dir); 1287 } 1288 } 1289 1290 if (ofi) 1291 { 1292 if (ofibh.sbh != ofibh.ebh) 1293 udf_release_data(ofibh.ebh); 1294 udf_release_data(ofibh.sbh); 1295 } 1296 1297 retval = 0; 1298 1299 end_rename: 1300 udf_release_data(dir_bh); 1301 if (nfi) 1302 { 1303 if (nfibh.sbh != nfibh.ebh) 1304 udf_release_data(nfibh.ebh); 1305 udf_release_data(nfibh.sbh); 1306 } 1307 unlock_kernel(); 1308 return retval; 1309 } 1310 1311 const struct inode_operations udf_dir_inode_operations = { 1312 .lookup = udf_lookup, 1313 .create = udf_create, 1314 .link = udf_link, 1315 .unlink = udf_unlink, 1316 .symlink = udf_symlink, 1317 .mkdir = udf_mkdir, 1318 .rmdir = udf_rmdir, 1319 .mknod = udf_mknod, 1320 .rename = udf_rename, 1321 }; 1322