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 /* Is there any extent whose size we need to round up? */ 412 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && elen) { 413 elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1); 414 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 415 epos.offset -= sizeof(struct short_ad); 416 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 417 epos.offset -= sizeof(struct long_ad); 418 udf_write_aext(dir, &epos, &eloc, elen, 1); 419 } 420 f_pos += nfidlen; 421 422 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB && 423 sb->s_blocksize - fibh->eoffset < nfidlen) { 424 brelse(epos.bh); 425 epos.bh = NULL; 426 fibh->soffset -= udf_ext0_offset(dir); 427 fibh->eoffset -= udf_ext0_offset(dir); 428 f_pos -= udf_ext0_offset(dir); 429 if (fibh->sbh != fibh->ebh) 430 brelse(fibh->ebh); 431 brelse(fibh->sbh); 432 fibh->sbh = fibh->ebh = 433 udf_expand_dir_adinicb(dir, &block, err); 434 if (!fibh->sbh) 435 goto out_err; 436 epos.block = dinfo->i_location; 437 epos.offset = udf_file_entry_alloc_offset(dir); 438 /* Load extent udf_expand_dir_adinicb() has created */ 439 udf_current_aext(dir, &epos, &eloc, &elen, 1); 440 } 441 442 if (sb->s_blocksize - fibh->eoffset >= nfidlen) { 443 fibh->soffset = fibh->eoffset; 444 fibh->eoffset += nfidlen; 445 if (fibh->sbh != fibh->ebh) { 446 brelse(fibh->sbh); 447 fibh->sbh = fibh->ebh; 448 } 449 450 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 451 block = dinfo->i_location.logicalBlockNum; 452 fi = (struct fileIdentDesc *) 453 (dinfo->i_ext.i_data + 454 fibh->soffset - 455 udf_ext0_offset(dir) + 456 dinfo->i_lenEAttr); 457 } else { 458 block = eloc.logicalBlockNum + 459 ((elen - 1) >> 460 dir->i_sb->s_blocksize_bits); 461 fi = (struct fileIdentDesc *) 462 (fibh->sbh->b_data + fibh->soffset); 463 } 464 } else { 465 fibh->soffset = fibh->eoffset - sb->s_blocksize; 466 fibh->eoffset += nfidlen - sb->s_blocksize; 467 if (fibh->sbh != fibh->ebh) { 468 brelse(fibh->sbh); 469 fibh->sbh = fibh->ebh; 470 } 471 472 block = eloc.logicalBlockNum + ((elen - 1) >> 473 dir->i_sb->s_blocksize_bits); 474 fibh->ebh = udf_bread(dir, 475 f_pos >> dir->i_sb->s_blocksize_bits, 1, err); 476 if (!fibh->ebh) 477 goto out_err; 478 479 if (!fibh->soffset) { 480 if (udf_next_aext(dir, &epos, &eloc, &elen, 1) == 481 (EXT_RECORDED_ALLOCATED >> 30)) { 482 block = eloc.logicalBlockNum + ((elen - 1) >> 483 dir->i_sb->s_blocksize_bits); 484 } else 485 block++; 486 487 brelse(fibh->sbh); 488 fibh->sbh = fibh->ebh; 489 fi = (struct fileIdentDesc *)(fibh->sbh->b_data); 490 } else { 491 fi = (struct fileIdentDesc *) 492 (fibh->sbh->b_data + sb->s_blocksize + 493 fibh->soffset); 494 } 495 } 496 497 memset(cfi, 0, sizeof(struct fileIdentDesc)); 498 if (UDF_SB(sb)->s_udfrev >= 0x0200) 499 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, 500 sizeof(struct tag)); 501 else 502 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, 503 sizeof(struct tag)); 504 cfi->fileVersionNum = cpu_to_le16(1); 505 cfi->lengthFileIdent = namelen; 506 cfi->lengthOfImpUse = cpu_to_le16(0); 507 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { 508 dir->i_size += nfidlen; 509 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 510 dinfo->i_lenAlloc += nfidlen; 511 mark_inode_dirty(dir); 512 goto out_ok; 513 } else { 514 *err = -EIO; 515 goto out_err; 516 } 517 518 out_err: 519 fi = NULL; 520 if (fibh->sbh != fibh->ebh) 521 brelse(fibh->ebh); 522 brelse(fibh->sbh); 523 out_ok: 524 brelse(epos.bh); 525 kfree(name); 526 return fi; 527 } 528 529 static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, 530 struct udf_fileident_bh *fibh, 531 struct fileIdentDesc *cfi) 532 { 533 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; 534 535 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 536 memset(&(cfi->icb), 0x00, sizeof(struct long_ad)); 537 538 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); 539 } 540 541 static int udf_create(struct inode *dir, struct dentry *dentry, int mode, 542 struct nameidata *nd) 543 { 544 struct udf_fileident_bh fibh; 545 struct inode *inode; 546 struct fileIdentDesc cfi, *fi; 547 int err; 548 struct udf_inode_info *iinfo; 549 550 lock_kernel(); 551 inode = udf_new_inode(dir, mode, &err); 552 if (!inode) { 553 unlock_kernel(); 554 return err; 555 } 556 557 iinfo = UDF_I(inode); 558 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 559 inode->i_data.a_ops = &udf_adinicb_aops; 560 else 561 inode->i_data.a_ops = &udf_aops; 562 inode->i_op = &udf_file_inode_operations; 563 inode->i_fop = &udf_file_operations; 564 inode->i_mode = mode; 565 mark_inode_dirty(inode); 566 567 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 568 if (!fi) { 569 inode->i_nlink--; 570 mark_inode_dirty(inode); 571 iput(inode); 572 unlock_kernel(); 573 return err; 574 } 575 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 576 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 577 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 578 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 579 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 580 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 581 mark_inode_dirty(dir); 582 if (fibh.sbh != fibh.ebh) 583 brelse(fibh.ebh); 584 brelse(fibh.sbh); 585 unlock_kernel(); 586 d_instantiate(dentry, inode); 587 588 return 0; 589 } 590 591 static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode, 592 dev_t rdev) 593 { 594 struct inode *inode; 595 struct udf_fileident_bh fibh; 596 struct fileIdentDesc cfi, *fi; 597 int err; 598 struct udf_inode_info *iinfo; 599 600 if (!old_valid_dev(rdev)) 601 return -EINVAL; 602 603 lock_kernel(); 604 err = -EIO; 605 inode = udf_new_inode(dir, mode, &err); 606 if (!inode) 607 goto out; 608 609 iinfo = UDF_I(inode); 610 inode->i_uid = current_fsuid(); 611 init_special_inode(inode, mode, rdev); 612 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 613 if (!fi) { 614 inode->i_nlink--; 615 mark_inode_dirty(inode); 616 iput(inode); 617 unlock_kernel(); 618 return err; 619 } 620 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 621 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 622 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 623 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 624 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 625 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 626 mark_inode_dirty(dir); 627 mark_inode_dirty(inode); 628 629 if (fibh.sbh != fibh.ebh) 630 brelse(fibh.ebh); 631 brelse(fibh.sbh); 632 d_instantiate(dentry, inode); 633 err = 0; 634 635 out: 636 unlock_kernel(); 637 return err; 638 } 639 640 static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode) 641 { 642 struct inode *inode; 643 struct udf_fileident_bh fibh; 644 struct fileIdentDesc cfi, *fi; 645 int err; 646 struct udf_inode_info *dinfo = UDF_I(dir); 647 struct udf_inode_info *iinfo; 648 649 lock_kernel(); 650 err = -EMLINK; 651 if (dir->i_nlink >= (256 << sizeof(dir->i_nlink)) - 1) 652 goto out; 653 654 err = -EIO; 655 inode = udf_new_inode(dir, S_IFDIR, &err); 656 if (!inode) 657 goto out; 658 659 iinfo = UDF_I(inode); 660 inode->i_op = &udf_dir_inode_operations; 661 inode->i_fop = &udf_dir_operations; 662 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err); 663 if (!fi) { 664 inode->i_nlink--; 665 mark_inode_dirty(inode); 666 iput(inode); 667 goto out; 668 } 669 inode->i_nlink = 2; 670 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 671 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location); 672 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 673 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL); 674 cfi.fileCharacteristics = 675 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; 676 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); 677 brelse(fibh.sbh); 678 inode->i_mode = S_IFDIR | mode; 679 if (dir->i_mode & S_ISGID) 680 inode->i_mode |= S_ISGID; 681 mark_inode_dirty(inode); 682 683 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 684 if (!fi) { 685 inode->i_nlink = 0; 686 mark_inode_dirty(inode); 687 iput(inode); 688 goto out; 689 } 690 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 691 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 692 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 693 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 694 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; 695 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 696 inc_nlink(dir); 697 mark_inode_dirty(dir); 698 d_instantiate(dentry, inode); 699 if (fibh.sbh != fibh.ebh) 700 brelse(fibh.ebh); 701 brelse(fibh.sbh); 702 err = 0; 703 704 out: 705 unlock_kernel(); 706 return err; 707 } 708 709 static int empty_dir(struct inode *dir) 710 { 711 struct fileIdentDesc *fi, cfi; 712 struct udf_fileident_bh fibh; 713 loff_t f_pos; 714 loff_t size = udf_ext0_offset(dir) + dir->i_size; 715 int block; 716 struct kernel_lb_addr eloc; 717 uint32_t elen; 718 sector_t offset; 719 struct extent_position epos = {}; 720 struct udf_inode_info *dinfo = UDF_I(dir); 721 722 f_pos = udf_ext0_offset(dir); 723 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 724 725 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 726 fibh.sbh = fibh.ebh = NULL; 727 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, 728 &epos, &eloc, &elen, &offset) == 729 (EXT_RECORDED_ALLOCATED >> 30)) { 730 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); 731 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 732 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 733 epos.offset -= sizeof(struct short_ad); 734 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 735 epos.offset -= sizeof(struct long_ad); 736 } else 737 offset = 0; 738 739 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); 740 if (!fibh.sbh) { 741 brelse(epos.bh); 742 return 0; 743 } 744 } else { 745 brelse(epos.bh); 746 return 0; 747 } 748 749 while (f_pos < size) { 750 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, 751 &elen, &offset); 752 if (!fi) { 753 if (fibh.sbh != fibh.ebh) 754 brelse(fibh.ebh); 755 brelse(fibh.sbh); 756 brelse(epos.bh); 757 return 0; 758 } 759 760 if (cfi.lengthFileIdent && 761 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) { 762 if (fibh.sbh != fibh.ebh) 763 brelse(fibh.ebh); 764 brelse(fibh.sbh); 765 brelse(epos.bh); 766 return 0; 767 } 768 } 769 770 if (fibh.sbh != fibh.ebh) 771 brelse(fibh.ebh); 772 brelse(fibh.sbh); 773 brelse(epos.bh); 774 775 return 1; 776 } 777 778 static int udf_rmdir(struct inode *dir, struct dentry *dentry) 779 { 780 int retval; 781 struct inode *inode = dentry->d_inode; 782 struct udf_fileident_bh fibh; 783 struct fileIdentDesc *fi, cfi; 784 struct kernel_lb_addr tloc; 785 786 retval = -ENOENT; 787 lock_kernel(); 788 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 789 if (!fi) 790 goto out; 791 792 retval = -EIO; 793 tloc = lelb_to_cpu(cfi.icb.extLocation); 794 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 795 goto end_rmdir; 796 retval = -ENOTEMPTY; 797 if (!empty_dir(inode)) 798 goto end_rmdir; 799 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 800 if (retval) 801 goto end_rmdir; 802 if (inode->i_nlink != 2) 803 udf_warning(inode->i_sb, "udf_rmdir", 804 "empty directory has nlink != 2 (%d)", 805 inode->i_nlink); 806 clear_nlink(inode); 807 inode->i_size = 0; 808 inode_dec_link_count(dir); 809 inode->i_ctime = dir->i_ctime = dir->i_mtime = 810 current_fs_time(dir->i_sb); 811 mark_inode_dirty(dir); 812 813 end_rmdir: 814 if (fibh.sbh != fibh.ebh) 815 brelse(fibh.ebh); 816 brelse(fibh.sbh); 817 818 out: 819 unlock_kernel(); 820 return retval; 821 } 822 823 static int udf_unlink(struct inode *dir, struct dentry *dentry) 824 { 825 int retval; 826 struct inode *inode = dentry->d_inode; 827 struct udf_fileident_bh fibh; 828 struct fileIdentDesc *fi; 829 struct fileIdentDesc cfi; 830 struct kernel_lb_addr tloc; 831 832 retval = -ENOENT; 833 lock_kernel(); 834 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 835 if (!fi) 836 goto out; 837 838 retval = -EIO; 839 tloc = lelb_to_cpu(cfi.icb.extLocation); 840 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 841 goto end_unlink; 842 843 if (!inode->i_nlink) { 844 udf_debug("Deleting nonexistent file (%lu), %d\n", 845 inode->i_ino, inode->i_nlink); 846 inode->i_nlink = 1; 847 } 848 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 849 if (retval) 850 goto end_unlink; 851 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 852 mark_inode_dirty(dir); 853 inode_dec_link_count(inode); 854 inode->i_ctime = dir->i_ctime; 855 retval = 0; 856 857 end_unlink: 858 if (fibh.sbh != fibh.ebh) 859 brelse(fibh.ebh); 860 brelse(fibh.sbh); 861 862 out: 863 unlock_kernel(); 864 return retval; 865 } 866 867 static int udf_symlink(struct inode *dir, struct dentry *dentry, 868 const char *symname) 869 { 870 struct inode *inode; 871 struct pathComponent *pc; 872 char *compstart; 873 struct udf_fileident_bh fibh; 874 struct extent_position epos = {}; 875 int eoffset, elen = 0; 876 struct fileIdentDesc *fi; 877 struct fileIdentDesc cfi; 878 char *ea; 879 int err; 880 int block; 881 char *name = NULL; 882 int namelen; 883 struct buffer_head *bh; 884 struct udf_inode_info *iinfo; 885 886 lock_kernel(); 887 inode = udf_new_inode(dir, S_IFLNK, &err); 888 if (!inode) 889 goto out; 890 891 name = kmalloc(UDF_NAME_LEN, GFP_NOFS); 892 if (!name) { 893 err = -ENOMEM; 894 goto out_no_entry; 895 } 896 897 iinfo = UDF_I(inode); 898 inode->i_mode = S_IFLNK | S_IRWXUGO; 899 inode->i_data.a_ops = &udf_symlink_aops; 900 inode->i_op = &page_symlink_inode_operations; 901 902 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 903 struct kernel_lb_addr eloc; 904 uint32_t bsize; 905 906 block = udf_new_block(inode->i_sb, inode, 907 iinfo->i_location.partitionReferenceNum, 908 iinfo->i_location.logicalBlockNum, &err); 909 if (!block) 910 goto out_no_entry; 911 epos.block = iinfo->i_location; 912 epos.offset = udf_file_entry_alloc_offset(inode); 913 epos.bh = NULL; 914 eloc.logicalBlockNum = block; 915 eloc.partitionReferenceNum = 916 iinfo->i_location.partitionReferenceNum; 917 bsize = inode->i_sb->s_blocksize; 918 iinfo->i_lenExtents = bsize; 919 udf_add_aext(inode, &epos, &eloc, bsize, 0); 920 brelse(epos.bh); 921 922 block = udf_get_pblock(inode->i_sb, block, 923 iinfo->i_location.partitionReferenceNum, 924 0); 925 epos.bh = udf_tread(inode->i_sb, block); 926 lock_buffer(epos.bh); 927 memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize); 928 set_buffer_uptodate(epos.bh); 929 unlock_buffer(epos.bh); 930 mark_buffer_dirty_inode(epos.bh, inode); 931 ea = epos.bh->b_data + udf_ext0_offset(inode); 932 } else 933 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr; 934 935 eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode); 936 pc = (struct pathComponent *)ea; 937 938 if (*symname == '/') { 939 do { 940 symname++; 941 } while (*symname == '/'); 942 943 pc->componentType = 1; 944 pc->lengthComponentIdent = 0; 945 pc->componentFileVersionNum = 0; 946 elen += sizeof(struct pathComponent); 947 } 948 949 err = -ENAMETOOLONG; 950 951 while (*symname) { 952 if (elen + sizeof(struct pathComponent) > eoffset) 953 goto out_no_entry; 954 955 pc = (struct pathComponent *)(ea + elen); 956 957 compstart = (char *)symname; 958 959 do { 960 symname++; 961 } while (*symname && *symname != '/'); 962 963 pc->componentType = 5; 964 pc->lengthComponentIdent = 0; 965 pc->componentFileVersionNum = 0; 966 if (compstart[0] == '.') { 967 if ((symname - compstart) == 1) 968 pc->componentType = 4; 969 else if ((symname - compstart) == 2 && 970 compstart[1] == '.') 971 pc->componentType = 3; 972 } 973 974 if (pc->componentType == 5) { 975 namelen = udf_put_filename(inode->i_sb, compstart, name, 976 symname - compstart); 977 if (!namelen) 978 goto out_no_entry; 979 980 if (elen + sizeof(struct pathComponent) + namelen > 981 eoffset) 982 goto out_no_entry; 983 else 984 pc->lengthComponentIdent = namelen; 985 986 memcpy(pc->componentIdent, name, namelen); 987 } 988 989 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; 990 991 if (*symname) { 992 do { 993 symname++; 994 } while (*symname == '/'); 995 } 996 } 997 998 brelse(epos.bh); 999 inode->i_size = elen; 1000 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1001 iinfo->i_lenAlloc = inode->i_size; 1002 mark_inode_dirty(inode); 1003 1004 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 1005 if (!fi) 1006 goto out_no_entry; 1007 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1008 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 1009 bh = UDF_SB(inode->i_sb)->s_lvid_bh; 1010 if (bh) { 1011 struct logicalVolIntegrityDesc *lvid = 1012 (struct logicalVolIntegrityDesc *)bh->b_data; 1013 struct logicalVolHeaderDesc *lvhd; 1014 uint64_t uniqueID; 1015 lvhd = (struct logicalVolHeaderDesc *) 1016 lvid->logicalVolContentsUse; 1017 uniqueID = le64_to_cpu(lvhd->uniqueID); 1018 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1019 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); 1020 if (!(++uniqueID & 0x00000000FFFFFFFFUL)) 1021 uniqueID += 16; 1022 lvhd->uniqueID = cpu_to_le64(uniqueID); 1023 mark_buffer_dirty(bh); 1024 } 1025 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1026 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1027 mark_inode_dirty(dir); 1028 if (fibh.sbh != fibh.ebh) 1029 brelse(fibh.ebh); 1030 brelse(fibh.sbh); 1031 d_instantiate(dentry, inode); 1032 err = 0; 1033 1034 out: 1035 kfree(name); 1036 unlock_kernel(); 1037 return err; 1038 1039 out_no_entry: 1040 inode_dec_link_count(inode); 1041 iput(inode); 1042 goto out; 1043 } 1044 1045 static int udf_link(struct dentry *old_dentry, struct inode *dir, 1046 struct dentry *dentry) 1047 { 1048 struct inode *inode = old_dentry->d_inode; 1049 struct udf_fileident_bh fibh; 1050 struct fileIdentDesc cfi, *fi; 1051 int err; 1052 struct buffer_head *bh; 1053 1054 lock_kernel(); 1055 if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) { 1056 unlock_kernel(); 1057 return -EMLINK; 1058 } 1059 1060 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 1061 if (!fi) { 1062 unlock_kernel(); 1063 return err; 1064 } 1065 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1066 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location); 1067 bh = UDF_SB(inode->i_sb)->s_lvid_bh; 1068 if (bh) { 1069 struct logicalVolIntegrityDesc *lvid = 1070 (struct logicalVolIntegrityDesc *)bh->b_data; 1071 struct logicalVolHeaderDesc *lvhd; 1072 uint64_t uniqueID; 1073 lvhd = (struct logicalVolHeaderDesc *) 1074 (lvid->logicalVolContentsUse); 1075 uniqueID = le64_to_cpu(lvhd->uniqueID); 1076 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1077 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); 1078 if (!(++uniqueID & 0x00000000FFFFFFFFUL)) 1079 uniqueID += 16; 1080 lvhd->uniqueID = cpu_to_le64(uniqueID); 1081 mark_buffer_dirty(bh); 1082 } 1083 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1084 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1085 mark_inode_dirty(dir); 1086 1087 if (fibh.sbh != fibh.ebh) 1088 brelse(fibh.ebh); 1089 brelse(fibh.sbh); 1090 inc_nlink(inode); 1091 inode->i_ctime = current_fs_time(inode->i_sb); 1092 mark_inode_dirty(inode); 1093 atomic_inc(&inode->i_count); 1094 d_instantiate(dentry, inode); 1095 unlock_kernel(); 1096 1097 return 0; 1098 } 1099 1100 /* Anybody can rename anything with this: the permission checks are left to the 1101 * higher-level routines. 1102 */ 1103 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, 1104 struct inode *new_dir, struct dentry *new_dentry) 1105 { 1106 struct inode *old_inode = old_dentry->d_inode; 1107 struct inode *new_inode = new_dentry->d_inode; 1108 struct udf_fileident_bh ofibh, nfibh; 1109 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL; 1110 struct fileIdentDesc ocfi, ncfi; 1111 struct buffer_head *dir_bh = NULL; 1112 int retval = -ENOENT; 1113 struct kernel_lb_addr tloc; 1114 struct udf_inode_info *old_iinfo = UDF_I(old_inode); 1115 1116 lock_kernel(); 1117 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1118 if (ofi) { 1119 if (ofibh.sbh != ofibh.ebh) 1120 brelse(ofibh.ebh); 1121 brelse(ofibh.sbh); 1122 } 1123 tloc = lelb_to_cpu(ocfi.icb.extLocation); 1124 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0) 1125 != old_inode->i_ino) 1126 goto end_rename; 1127 1128 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi); 1129 if (nfi) { 1130 if (!new_inode) { 1131 if (nfibh.sbh != nfibh.ebh) 1132 brelse(nfibh.ebh); 1133 brelse(nfibh.sbh); 1134 nfi = NULL; 1135 } 1136 } 1137 if (S_ISDIR(old_inode->i_mode)) { 1138 int offset = udf_ext0_offset(old_inode); 1139 1140 if (new_inode) { 1141 retval = -ENOTEMPTY; 1142 if (!empty_dir(new_inode)) 1143 goto end_rename; 1144 } 1145 retval = -EIO; 1146 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 1147 dir_fi = udf_get_fileident( 1148 old_iinfo->i_ext.i_data - 1149 (old_iinfo->i_efe ? 1150 sizeof(struct extendedFileEntry) : 1151 sizeof(struct fileEntry)), 1152 old_inode->i_sb->s_blocksize, &offset); 1153 } else { 1154 dir_bh = udf_bread(old_inode, 0, 0, &retval); 1155 if (!dir_bh) 1156 goto end_rename; 1157 dir_fi = udf_get_fileident(dir_bh->b_data, 1158 old_inode->i_sb->s_blocksize, &offset); 1159 } 1160 if (!dir_fi) 1161 goto end_rename; 1162 tloc = lelb_to_cpu(dir_fi->icb.extLocation); 1163 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) != 1164 old_dir->i_ino) 1165 goto end_rename; 1166 1167 retval = -EMLINK; 1168 if (!new_inode && 1169 new_dir->i_nlink >= 1170 (256 << sizeof(new_dir->i_nlink)) - 1) 1171 goto end_rename; 1172 } 1173 if (!nfi) { 1174 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, 1175 &retval); 1176 if (!nfi) 1177 goto end_rename; 1178 } 1179 1180 /* 1181 * Like most other Unix systems, set the ctime for inodes on a 1182 * rename. 1183 */ 1184 old_inode->i_ctime = current_fs_time(old_inode->i_sb); 1185 mark_inode_dirty(old_inode); 1186 1187 /* 1188 * ok, that's it 1189 */ 1190 ncfi.fileVersionNum = ocfi.fileVersionNum; 1191 ncfi.fileCharacteristics = ocfi.fileCharacteristics; 1192 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad)); 1193 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL); 1194 1195 /* The old fid may have moved - find it again */ 1196 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1197 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); 1198 1199 if (new_inode) { 1200 new_inode->i_ctime = current_fs_time(new_inode->i_sb); 1201 inode_dec_link_count(new_inode); 1202 } 1203 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); 1204 mark_inode_dirty(old_dir); 1205 1206 if (dir_fi) { 1207 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location); 1208 udf_update_tag((char *)dir_fi, 1209 (sizeof(struct fileIdentDesc) + 1210 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); 1211 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1212 mark_inode_dirty(old_inode); 1213 else 1214 mark_buffer_dirty_inode(dir_bh, old_inode); 1215 1216 inode_dec_link_count(old_dir); 1217 if (new_inode) 1218 inode_dec_link_count(new_inode); 1219 else { 1220 inc_nlink(new_dir); 1221 mark_inode_dirty(new_dir); 1222 } 1223 } 1224 1225 if (ofi) { 1226 if (ofibh.sbh != ofibh.ebh) 1227 brelse(ofibh.ebh); 1228 brelse(ofibh.sbh); 1229 } 1230 1231 retval = 0; 1232 1233 end_rename: 1234 brelse(dir_bh); 1235 if (nfi) { 1236 if (nfibh.sbh != nfibh.ebh) 1237 brelse(nfibh.ebh); 1238 brelse(nfibh.sbh); 1239 } 1240 unlock_kernel(); 1241 1242 return retval; 1243 } 1244 1245 static struct dentry *udf_get_parent(struct dentry *child) 1246 { 1247 struct kernel_lb_addr tloc; 1248 struct inode *inode = NULL; 1249 struct qstr dotdot = {.name = "..", .len = 2}; 1250 struct fileIdentDesc cfi; 1251 struct udf_fileident_bh fibh; 1252 1253 lock_kernel(); 1254 if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi)) 1255 goto out_unlock; 1256 1257 if (fibh.sbh != fibh.ebh) 1258 brelse(fibh.ebh); 1259 brelse(fibh.sbh); 1260 1261 tloc = lelb_to_cpu(cfi.icb.extLocation); 1262 inode = udf_iget(child->d_inode->i_sb, &tloc); 1263 if (!inode) 1264 goto out_unlock; 1265 unlock_kernel(); 1266 1267 return d_obtain_alias(inode); 1268 out_unlock: 1269 unlock_kernel(); 1270 return ERR_PTR(-EACCES); 1271 } 1272 1273 1274 static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block, 1275 u16 partref, __u32 generation) 1276 { 1277 struct inode *inode; 1278 struct kernel_lb_addr loc; 1279 1280 if (block == 0) 1281 return ERR_PTR(-ESTALE); 1282 1283 loc.logicalBlockNum = block; 1284 loc.partitionReferenceNum = partref; 1285 inode = udf_iget(sb, &loc); 1286 1287 if (inode == NULL) 1288 return ERR_PTR(-ENOMEM); 1289 1290 if (generation && inode->i_generation != generation) { 1291 iput(inode); 1292 return ERR_PTR(-ESTALE); 1293 } 1294 return d_obtain_alias(inode); 1295 } 1296 1297 static struct dentry *udf_fh_to_dentry(struct super_block *sb, 1298 struct fid *fid, int fh_len, int fh_type) 1299 { 1300 if ((fh_len != 3 && fh_len != 5) || 1301 (fh_type != FILEID_UDF_WITH_PARENT && 1302 fh_type != FILEID_UDF_WITHOUT_PARENT)) 1303 return NULL; 1304 1305 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref, 1306 fid->udf.generation); 1307 } 1308 1309 static struct dentry *udf_fh_to_parent(struct super_block *sb, 1310 struct fid *fid, int fh_len, int fh_type) 1311 { 1312 if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT) 1313 return NULL; 1314 1315 return udf_nfs_get_inode(sb, fid->udf.parent_block, 1316 fid->udf.parent_partref, 1317 fid->udf.parent_generation); 1318 } 1319 static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp, 1320 int connectable) 1321 { 1322 int len = *lenp; 1323 struct inode *inode = de->d_inode; 1324 struct kernel_lb_addr location = UDF_I(inode)->i_location; 1325 struct fid *fid = (struct fid *)fh; 1326 int type = FILEID_UDF_WITHOUT_PARENT; 1327 1328 if (len < 3 || (connectable && len < 5)) 1329 return 255; 1330 1331 *lenp = 3; 1332 fid->udf.block = location.logicalBlockNum; 1333 fid->udf.partref = location.partitionReferenceNum; 1334 fid->udf.generation = inode->i_generation; 1335 1336 if (connectable && !S_ISDIR(inode->i_mode)) { 1337 spin_lock(&de->d_lock); 1338 inode = de->d_parent->d_inode; 1339 location = UDF_I(inode)->i_location; 1340 fid->udf.parent_block = location.logicalBlockNum; 1341 fid->udf.parent_partref = location.partitionReferenceNum; 1342 fid->udf.parent_generation = inode->i_generation; 1343 spin_unlock(&de->d_lock); 1344 *lenp = 5; 1345 type = FILEID_UDF_WITH_PARENT; 1346 } 1347 1348 return type; 1349 } 1350 1351 const struct export_operations udf_export_ops = { 1352 .encode_fh = udf_encode_fh, 1353 .fh_to_dentry = udf_fh_to_dentry, 1354 .fh_to_parent = udf_fh_to_parent, 1355 .get_parent = udf_get_parent, 1356 }; 1357 1358 const struct inode_operations udf_dir_inode_operations = { 1359 .lookup = udf_lookup, 1360 .create = udf_create, 1361 .link = udf_link, 1362 .unlink = udf_unlink, 1363 .symlink = udf_symlink, 1364 .mkdir = udf_mkdir, 1365 .rmdir = udf_rmdir, 1366 .mknod = udf_mknod, 1367 .rename = udf_rename, 1368 }; 1369