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