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