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