1 /*- 2 * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 /* udf_vnops.c */ 30 /* Take care of the vnode side of things */ 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/namei.h> 35 #include <sys/kernel.h> 36 #include <sys/malloc.h> 37 #include <sys/stat.h> 38 #include <sys/bio.h> 39 #include <sys/conf.h> 40 #include <sys/buf.h> 41 #include <sys/iconv.h> 42 #include <sys/mount.h> 43 #include <sys/vnode.h> 44 #include <sys/dirent.h> 45 #include <sys/queue.h> 46 #include <sys/unistd.h> 47 #include <sys/endian.h> 48 49 #include <vm/uma.h> 50 51 #include <fs/udf/ecma167-udf.h> 52 #include <fs/udf/osta.h> 53 #include <fs/udf/udf.h> 54 #include <fs/udf/udf_mount.h> 55 56 extern struct iconv_functions *udf_iconv; 57 58 static vop_access_t udf_access; 59 static vop_getattr_t udf_getattr; 60 static vop_open_t udf_open; 61 static vop_ioctl_t udf_ioctl; 62 static vop_pathconf_t udf_pathconf; 63 static vop_print_t udf_print; 64 static vop_read_t udf_read; 65 static vop_readdir_t udf_readdir; 66 static vop_readlink_t udf_readlink; 67 static vop_setattr_t udf_setattr; 68 static vop_strategy_t udf_strategy; 69 static vop_bmap_t udf_bmap; 70 static vop_cachedlookup_t udf_lookup; 71 static vop_reclaim_t udf_reclaim; 72 static vop_vptofh_t udf_vptofh; 73 static int udf_readatoffset(struct udf_node *node, int *size, off_t offset, 74 struct buf **bp, uint8_t **data); 75 static int udf_bmap_internal(struct udf_node *node, off_t offset, 76 daddr_t *sector, uint32_t *max_size); 77 78 static struct vop_vector udf_vnodeops = { 79 .vop_default = &default_vnodeops, 80 81 .vop_access = udf_access, 82 .vop_bmap = udf_bmap, 83 .vop_cachedlookup = udf_lookup, 84 .vop_getattr = udf_getattr, 85 .vop_ioctl = udf_ioctl, 86 .vop_lookup = vfs_cache_lookup, 87 .vop_open = udf_open, 88 .vop_pathconf = udf_pathconf, 89 .vop_print = udf_print, 90 .vop_read = udf_read, 91 .vop_readdir = udf_readdir, 92 .vop_readlink = udf_readlink, 93 .vop_reclaim = udf_reclaim, 94 .vop_setattr = udf_setattr, 95 .vop_strategy = udf_strategy, 96 .vop_vptofh = udf_vptofh, 97 }; 98 99 struct vop_vector udf_fifoops = { 100 .vop_default = &fifo_specops, 101 .vop_access = udf_access, 102 .vop_getattr = udf_getattr, 103 .vop_print = udf_print, 104 .vop_reclaim = udf_reclaim, 105 .vop_setattr = udf_setattr, 106 .vop_vptofh = udf_vptofh, 107 }; 108 109 static MALLOC_DEFINE(M_UDFFID, "udf_fid", "UDF FileId structure"); 110 static MALLOC_DEFINE(M_UDFDS, "udf_ds", "UDF Dirstream structure"); 111 112 #define UDF_INVALID_BMAP -1 113 114 int 115 udf_allocv(struct mount *mp, struct vnode **vpp, struct thread *td) 116 { 117 int error; 118 struct vnode *vp; 119 120 error = getnewvnode("udf", mp, &udf_vnodeops, &vp); 121 if (error) { 122 printf("udf_allocv: failed to allocate new vnode\n"); 123 return (error); 124 } 125 126 *vpp = vp; 127 return (0); 128 } 129 130 /* Convert file entry permission (5 bits per owner/group/user) to a mode_t */ 131 static mode_t 132 udf_permtomode(struct udf_node *node) 133 { 134 uint32_t perm; 135 uint16_t flags; 136 mode_t mode; 137 138 perm = le32toh(node->fentry->perm); 139 flags = le16toh(node->fentry->icbtag.flags); 140 141 mode = perm & UDF_FENTRY_PERM_USER_MASK; 142 mode |= ((perm & UDF_FENTRY_PERM_GRP_MASK) >> 2); 143 mode |= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4); 144 mode |= ((flags & UDF_ICB_TAG_FLAGS_STICKY) << 4); 145 mode |= ((flags & UDF_ICB_TAG_FLAGS_SETGID) << 6); 146 mode |= ((flags & UDF_ICB_TAG_FLAGS_SETUID) << 8); 147 148 return (mode); 149 } 150 151 static int 152 udf_access(struct vop_access_args *a) 153 { 154 struct vnode *vp; 155 struct udf_node *node; 156 accmode_t accmode; 157 mode_t mode; 158 159 vp = a->a_vp; 160 node = VTON(vp); 161 accmode = a->a_accmode; 162 163 if (accmode & VWRITE) { 164 switch (vp->v_type) { 165 case VDIR: 166 case VLNK: 167 case VREG: 168 return (EROFS); 169 /* NOT REACHED */ 170 default: 171 break; 172 } 173 } 174 175 mode = udf_permtomode(node); 176 177 return (vaccess(vp->v_type, mode, node->fentry->uid, node->fentry->gid, 178 accmode, a->a_cred, NULL)); 179 } 180 181 static int 182 udf_open(struct vop_open_args *ap) { 183 struct udf_node *np = VTON(ap->a_vp); 184 off_t fsize; 185 186 fsize = le64toh(np->fentry->inf_len); 187 vnode_create_vobject(ap->a_vp, fsize, ap->a_td); 188 return 0; 189 } 190 191 static const int mon_lens[2][12] = { 192 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}, 193 {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335} 194 }; 195 196 static int 197 udf_isaleapyear(int year) 198 { 199 int i; 200 201 i = (year % 4) ? 0 : 1; 202 i &= (year % 100) ? 1 : 0; 203 i |= (year % 400) ? 0 : 1; 204 205 return i; 206 } 207 208 /* 209 * Timezone calculation compliments of Julian Elischer <julian@elischer.org>. 210 */ 211 static void 212 udf_timetotimespec(struct timestamp *time, struct timespec *t) 213 { 214 int i, lpyear, daysinyear, year, startyear; 215 union { 216 uint16_t u_tz_offset; 217 int16_t s_tz_offset; 218 } tz; 219 220 /* 221 * DirectCD seems to like using bogus year values. 222 * Don't trust time->month as it will be used for an array index. 223 */ 224 year = le16toh(time->year); 225 if (year < 1970 || time->month < 1 || time->month > 12) { 226 t->tv_sec = 0; 227 t->tv_nsec = 0; 228 return; 229 } 230 231 /* Calculate the time and day */ 232 t->tv_sec = time->second; 233 t->tv_sec += time->minute * 60; 234 t->tv_sec += time->hour * 3600; 235 t->tv_sec += (time->day - 1) * 3600 * 24; 236 237 /* Calculate the month */ 238 lpyear = udf_isaleapyear(year); 239 t->tv_sec += mon_lens[lpyear][time->month - 1] * 3600 * 24; 240 241 /* Speed up the calculation */ 242 startyear = 1970; 243 if (year > 2009) { 244 t->tv_sec += 1262304000; 245 startyear += 40; 246 } else if (year > 1999) { 247 t->tv_sec += 946684800; 248 startyear += 30; 249 } else if (year > 1989) { 250 t->tv_sec += 631152000; 251 startyear += 20; 252 } else if (year > 1979) { 253 t->tv_sec += 315532800; 254 startyear += 10; 255 } 256 257 daysinyear = (year - startyear) * 365; 258 for (i = startyear; i < year; i++) 259 daysinyear += udf_isaleapyear(i); 260 t->tv_sec += daysinyear * 3600 * 24; 261 262 /* Calculate microseconds */ 263 t->tv_nsec = time->centisec * 10000 + time->hund_usec * 100 + 264 time->usec; 265 266 /* 267 * Calculate the time zone. The timezone is 12 bit signed 2's 268 * complement, so we gotta do some extra magic to handle it right. 269 */ 270 tz.u_tz_offset = le16toh(time->type_tz); 271 tz.u_tz_offset &= 0x0fff; 272 if (tz.u_tz_offset & 0x0800) 273 tz.u_tz_offset |= 0xf000; /* extend the sign to 16 bits */ 274 if ((le16toh(time->type_tz) & 0x1000) && (tz.s_tz_offset != -2047)) 275 t->tv_sec -= tz.s_tz_offset * 60; 276 277 return; 278 } 279 280 static int 281 udf_getattr(struct vop_getattr_args *a) 282 { 283 struct vnode *vp; 284 struct udf_node *node; 285 struct vattr *vap; 286 struct file_entry *fentry; 287 struct timespec ts; 288 289 ts.tv_sec = 0; 290 291 vp = a->a_vp; 292 vap = a->a_vap; 293 node = VTON(vp); 294 fentry = node->fentry; 295 296 vap->va_fsid = dev2udev(node->udfmp->im_dev); 297 vap->va_fileid = node->hash_id; 298 vap->va_mode = udf_permtomode(node); 299 vap->va_nlink = le16toh(fentry->link_cnt); 300 /* 301 * XXX The spec says that -1 is valid for uid/gid and indicates an 302 * invalid uid/gid. How should this be represented? 303 */ 304 vap->va_uid = (le32toh(fentry->uid) == -1) ? 0 : le32toh(fentry->uid); 305 vap->va_gid = (le32toh(fentry->gid) == -1) ? 0 : le32toh(fentry->gid); 306 udf_timetotimespec(&fentry->atime, &vap->va_atime); 307 udf_timetotimespec(&fentry->mtime, &vap->va_mtime); 308 vap->va_ctime = vap->va_mtime; /* XXX Stored as an Extended Attribute */ 309 vap->va_rdev = NODEV; 310 if (vp->v_type & VDIR) { 311 /* 312 * Directories that are recorded within their ICB will show 313 * as having 0 blocks recorded. Since tradition dictates 314 * that directories consume at least one logical block, 315 * make it appear so. 316 */ 317 if (fentry->logblks_rec != 0) { 318 vap->va_size = 319 le64toh(fentry->logblks_rec) * node->udfmp->bsize; 320 } else { 321 vap->va_size = node->udfmp->bsize; 322 } 323 } else { 324 vap->va_size = le64toh(fentry->inf_len); 325 } 326 vap->va_flags = 0; 327 vap->va_gen = 1; 328 vap->va_blocksize = node->udfmp->bsize; 329 vap->va_bytes = le64toh(fentry->inf_len); 330 vap->va_type = vp->v_type; 331 vap->va_filerev = 0; /* XXX */ 332 return (0); 333 } 334 335 static int 336 udf_setattr(struct vop_setattr_args *a) 337 { 338 struct vnode *vp; 339 struct vattr *vap; 340 341 vp = a->a_vp; 342 vap = a->a_vap; 343 if (vap->va_flags != (u_long)VNOVAL || vap->va_uid != (uid_t)VNOVAL || 344 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 345 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) 346 return (EROFS); 347 if (vap->va_size != (u_quad_t)VNOVAL) { 348 switch (vp->v_type) { 349 case VDIR: 350 return (EISDIR); 351 case VLNK: 352 case VREG: 353 return (EROFS); 354 case VCHR: 355 case VBLK: 356 case VSOCK: 357 case VFIFO: 358 case VNON: 359 case VBAD: 360 case VMARKER: 361 return (0); 362 } 363 } 364 return (0); 365 } 366 367 /* 368 * File specific ioctls. 369 */ 370 static int 371 udf_ioctl(struct vop_ioctl_args *a) 372 { 373 printf("%s called\n", __func__); 374 return (ENOTTY); 375 } 376 377 /* 378 * I'm not sure that this has much value in a read-only filesystem, but 379 * cd9660 has it too. 380 */ 381 static int 382 udf_pathconf(struct vop_pathconf_args *a) 383 { 384 385 switch (a->a_name) { 386 case _PC_LINK_MAX: 387 *a->a_retval = 65535; 388 return (0); 389 case _PC_NAME_MAX: 390 *a->a_retval = NAME_MAX; 391 return (0); 392 case _PC_PATH_MAX: 393 *a->a_retval = PATH_MAX; 394 return (0); 395 case _PC_NO_TRUNC: 396 *a->a_retval = 1; 397 return (0); 398 default: 399 return (EINVAL); 400 } 401 } 402 403 static int 404 udf_print(struct vop_print_args *ap) 405 { 406 struct vnode *vp = ap->a_vp; 407 struct udf_node *node = VTON(vp); 408 409 printf(" ino %lu, on dev %s", (u_long)node->hash_id, 410 devtoname(node->udfmp->im_dev)); 411 if (vp->v_type == VFIFO) 412 fifo_printinfo(vp); 413 printf("\n"); 414 return (0); 415 } 416 417 #define lblkno(udfmp, loc) ((loc) >> (udfmp)->bshift) 418 #define blkoff(udfmp, loc) ((loc) & (udfmp)->bmask) 419 #define lblktosize(udfmp, blk) ((blk) << (udfmp)->bshift) 420 421 static inline int 422 is_data_in_fentry(const struct udf_node *node) 423 { 424 const struct file_entry *fentry = node->fentry; 425 426 return ((le16toh(fentry->icbtag.flags) & 0x7) == 3); 427 } 428 429 static int 430 udf_read(struct vop_read_args *ap) 431 { 432 struct vnode *vp = ap->a_vp; 433 struct uio *uio = ap->a_uio; 434 struct udf_node *node = VTON(vp); 435 struct udf_mnt *udfmp; 436 struct file_entry *fentry; 437 struct buf *bp; 438 uint8_t *data; 439 daddr_t lbn, rablock; 440 off_t diff, fsize; 441 ssize_t n; 442 int error = 0; 443 long size, on; 444 445 if (uio->uio_resid == 0) 446 return (0); 447 if (uio->uio_offset < 0) 448 return (EINVAL); 449 450 if (is_data_in_fentry(node)) { 451 fentry = node->fentry; 452 data = &fentry->data[le32toh(fentry->l_ea)]; 453 fsize = le32toh(fentry->l_ad); 454 455 n = uio->uio_resid; 456 diff = fsize - uio->uio_offset; 457 if (diff <= 0) 458 return (0); 459 if (diff < n) 460 n = diff; 461 error = uiomove(data + uio->uio_offset, (int)n, uio); 462 return (error); 463 } 464 465 fsize = le64toh(node->fentry->inf_len); 466 udfmp = node->udfmp; 467 do { 468 lbn = lblkno(udfmp, uio->uio_offset); 469 on = blkoff(udfmp, uio->uio_offset); 470 n = min((u_int)(udfmp->bsize - on), 471 uio->uio_resid); 472 diff = fsize - uio->uio_offset; 473 if (diff <= 0) 474 return (0); 475 if (diff < n) 476 n = diff; 477 size = udfmp->bsize; 478 rablock = lbn + 1; 479 if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) { 480 if (lblktosize(udfmp, rablock) < fsize) { 481 error = cluster_read(vp, fsize, lbn, size, 482 NOCRED, uio->uio_resid, 483 (ap->a_ioflag >> 16), 0, &bp); 484 } else { 485 error = bread(vp, lbn, size, NOCRED, &bp); 486 } 487 } else { 488 error = bread(vp, lbn, size, NOCRED, &bp); 489 } 490 if (error != 0) { 491 brelse(bp); 492 return (error); 493 } 494 n = min(n, size - bp->b_resid); 495 496 error = uiomove(bp->b_data + on, (int)n, uio); 497 brelse(bp); 498 } while (error == 0 && uio->uio_resid > 0 && n != 0); 499 return (error); 500 } 501 502 /* 503 * Call the OSTA routines to translate the name from a CS0 dstring to a 504 * 16-bit Unicode String. Hooks need to be placed in here to translate from 505 * Unicode to the encoding that the kernel/user expects. Return the length 506 * of the translated string. 507 */ 508 static int 509 udf_transname(char *cs0string, char *destname, int len, struct udf_mnt *udfmp) 510 { 511 unicode_t *transname; 512 char *unibuf, *unip; 513 int i, destlen; 514 ssize_t unilen = 0; 515 size_t destleft = MAXNAMLEN; 516 517 /* Convert 16-bit Unicode to destname */ 518 if (udfmp->im_flags & UDFMNT_KICONV && udf_iconv) { 519 /* allocate a buffer big enough to hold an 8->16 bit expansion */ 520 unibuf = uma_zalloc(udf_zone_trans, M_WAITOK); 521 unip = unibuf; 522 if ((unilen = (ssize_t)udf_UncompressUnicodeByte(len, cs0string, unibuf)) == -1) { 523 printf("udf: Unicode translation failed\n"); 524 uma_zfree(udf_zone_trans, unibuf); 525 return 0; 526 } 527 528 while (unilen > 0 && destleft > 0) { 529 udf_iconv->conv(udfmp->im_d2l, __DECONST(const char **, 530 &unibuf), (size_t *)&unilen, (char **)&destname, 531 &destleft); 532 /* Unconverted character found */ 533 if (unilen > 0 && destleft > 0) { 534 *destname++ = '?'; 535 destleft--; 536 unibuf += 2; 537 unilen -= 2; 538 } 539 } 540 uma_zfree(udf_zone_trans, unip); 541 *destname = '\0'; 542 destlen = MAXNAMLEN - (int)destleft; 543 } else { 544 /* allocate a buffer big enough to hold an 8->16 bit expansion */ 545 transname = uma_zalloc(udf_zone_trans, M_WAITOK); 546 547 if ((unilen = (ssize_t)udf_UncompressUnicode(len, cs0string, transname)) == -1) { 548 printf("udf: Unicode translation failed\n"); 549 uma_zfree(udf_zone_trans, transname); 550 return 0; 551 } 552 553 for (i = 0; i < unilen ; i++) { 554 if (transname[i] & 0xff00) { 555 destname[i] = '.'; /* Fudge the 16bit chars */ 556 } else { 557 destname[i] = transname[i] & 0xff; 558 } 559 } 560 uma_zfree(udf_zone_trans, transname); 561 destname[unilen] = 0; 562 destlen = (int)unilen; 563 } 564 565 return (destlen); 566 } 567 568 /* 569 * Compare a CS0 dstring with a name passed in from the VFS layer. Return 570 * 0 on a successful match, nonzero otherwise. Unicode work may need to be done 571 * here also. 572 */ 573 static int 574 udf_cmpname(char *cs0string, char *cmpname, int cs0len, int cmplen, struct udf_mnt *udfmp) 575 { 576 char *transname; 577 int error = 0; 578 579 /* This is overkill, but not worth creating a new zone */ 580 transname = uma_zalloc(udf_zone_trans, M_WAITOK); 581 582 cs0len = udf_transname(cs0string, transname, cs0len, udfmp); 583 584 /* Easy check. If they aren't the same length, they aren't equal */ 585 if ((cs0len == 0) || (cs0len != cmplen)) 586 error = -1; 587 else 588 error = bcmp(transname, cmpname, cmplen); 589 590 uma_zfree(udf_zone_trans, transname); 591 return (error); 592 } 593 594 struct udf_uiodir { 595 struct dirent *dirent; 596 u_long *cookies; 597 int ncookies; 598 int acookies; 599 int eofflag; 600 }; 601 602 static int 603 udf_uiodir(struct udf_uiodir *uiodir, int de_size, struct uio *uio, long cookie) 604 { 605 if (uiodir->cookies != NULL) { 606 if (++uiodir->acookies > uiodir->ncookies) { 607 uiodir->eofflag = 0; 608 return (-1); 609 } 610 *uiodir->cookies++ = cookie; 611 } 612 613 if (uio->uio_resid < de_size) { 614 uiodir->eofflag = 0; 615 return (-1); 616 } 617 618 return (uiomove(uiodir->dirent, de_size, uio)); 619 } 620 621 static struct udf_dirstream * 622 udf_opendir(struct udf_node *node, int offset, int fsize, struct udf_mnt *udfmp) 623 { 624 struct udf_dirstream *ds; 625 626 ds = uma_zalloc(udf_zone_ds, M_WAITOK | M_ZERO); 627 628 ds->node = node; 629 ds->offset = offset; 630 ds->udfmp = udfmp; 631 ds->fsize = fsize; 632 633 return (ds); 634 } 635 636 static struct fileid_desc * 637 udf_getfid(struct udf_dirstream *ds) 638 { 639 struct fileid_desc *fid; 640 int error, frag_size = 0, total_fid_size; 641 642 /* End of directory? */ 643 if (ds->offset + ds->off >= ds->fsize) { 644 ds->error = 0; 645 return (NULL); 646 } 647 648 /* Grab the first extent of the directory */ 649 if (ds->off == 0) { 650 ds->size = 0; 651 error = udf_readatoffset(ds->node, &ds->size, ds->offset, 652 &ds->bp, &ds->data); 653 if (error) { 654 ds->error = error; 655 if (ds->bp != NULL) 656 brelse(ds->bp); 657 return (NULL); 658 } 659 } 660 661 /* 662 * Clean up from a previous fragmented FID. 663 * XXX Is this the right place for this? 664 */ 665 if (ds->fid_fragment && ds->buf != NULL) { 666 ds->fid_fragment = 0; 667 free(ds->buf, M_UDFFID); 668 } 669 670 fid = (struct fileid_desc*)&ds->data[ds->off]; 671 672 /* 673 * Check to see if the fid is fragmented. The first test 674 * ensures that we don't wander off the end of the buffer 675 * looking for the l_iu and l_fi fields. 676 */ 677 if (ds->off + UDF_FID_SIZE > ds->size || 678 ds->off + le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE > ds->size){ 679 680 /* Copy what we have of the fid into a buffer */ 681 frag_size = ds->size - ds->off; 682 if (frag_size >= ds->udfmp->bsize) { 683 printf("udf: invalid FID fragment\n"); 684 ds->error = EINVAL; 685 return (NULL); 686 } 687 688 /* 689 * File ID descriptors can only be at most one 690 * logical sector in size. 691 */ 692 ds->buf = malloc(ds->udfmp->bsize, M_UDFFID, 693 M_WAITOK | M_ZERO); 694 bcopy(fid, ds->buf, frag_size); 695 696 /* Reduce all of the casting magic */ 697 fid = (struct fileid_desc*)ds->buf; 698 699 if (ds->bp != NULL) 700 brelse(ds->bp); 701 702 /* Fetch the next allocation */ 703 ds->offset += ds->size; 704 ds->size = 0; 705 error = udf_readatoffset(ds->node, &ds->size, ds->offset, 706 &ds->bp, &ds->data); 707 if (error) { 708 ds->error = error; 709 return (NULL); 710 } 711 712 /* 713 * If the fragment was so small that we didn't get 714 * the l_iu and l_fi fields, copy those in. 715 */ 716 if (frag_size < UDF_FID_SIZE) 717 bcopy(ds->data, &ds->buf[frag_size], 718 UDF_FID_SIZE - frag_size); 719 720 /* 721 * Now that we have enough of the fid to work with, 722 * copy in the rest of the fid from the new 723 * allocation. 724 */ 725 total_fid_size = UDF_FID_SIZE + le16toh(fid->l_iu) + fid->l_fi; 726 if (total_fid_size > ds->udfmp->bsize) { 727 printf("udf: invalid FID\n"); 728 ds->error = EIO; 729 return (NULL); 730 } 731 bcopy(ds->data, &ds->buf[frag_size], 732 total_fid_size - frag_size); 733 734 ds->fid_fragment = 1; 735 } else { 736 total_fid_size = le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE; 737 } 738 739 /* 740 * Update the offset. Align on a 4 byte boundary because the 741 * UDF spec says so. 742 */ 743 ds->this_off = ds->offset + ds->off; 744 if (!ds->fid_fragment) { 745 ds->off += (total_fid_size + 3) & ~0x03; 746 } else { 747 ds->off = (total_fid_size - frag_size + 3) & ~0x03; 748 } 749 750 return (fid); 751 } 752 753 static void 754 udf_closedir(struct udf_dirstream *ds) 755 { 756 757 if (ds->bp != NULL) 758 brelse(ds->bp); 759 760 if (ds->fid_fragment && ds->buf != NULL) 761 free(ds->buf, M_UDFFID); 762 763 uma_zfree(udf_zone_ds, ds); 764 } 765 766 static int 767 udf_readdir(struct vop_readdir_args *a) 768 { 769 struct vnode *vp; 770 struct uio *uio; 771 struct dirent dir; 772 struct udf_node *node; 773 struct udf_mnt *udfmp; 774 struct fileid_desc *fid; 775 struct udf_uiodir uiodir; 776 struct udf_dirstream *ds; 777 u_long *cookies = NULL; 778 int ncookies; 779 int error = 0; 780 781 vp = a->a_vp; 782 uio = a->a_uio; 783 node = VTON(vp); 784 udfmp = node->udfmp; 785 uiodir.eofflag = 1; 786 787 if (a->a_ncookies != NULL) { 788 /* 789 * Guess how many entries are needed. If we run out, this 790 * function will be called again and thing will pick up were 791 * it left off. 792 */ 793 ncookies = uio->uio_resid / 8; 794 cookies = malloc(sizeof(u_long) * ncookies, 795 M_TEMP, M_WAITOK); 796 if (cookies == NULL) 797 return (ENOMEM); 798 uiodir.ncookies = ncookies; 799 uiodir.cookies = cookies; 800 uiodir.acookies = 0; 801 } else { 802 uiodir.cookies = NULL; 803 } 804 805 /* 806 * Iterate through the file id descriptors. Give the parent dir 807 * entry special attention. 808 */ 809 ds = udf_opendir(node, uio->uio_offset, le64toh(node->fentry->inf_len), 810 node->udfmp); 811 812 while ((fid = udf_getfid(ds)) != NULL) { 813 814 /* XXX Should we return an error on a bad fid? */ 815 if (udf_checktag(&fid->tag, TAGID_FID)) { 816 printf("Invalid FID tag\n"); 817 hexdump(fid, UDF_FID_SIZE, NULL, 0); 818 error = EIO; 819 break; 820 } 821 822 /* Is this a deleted file? */ 823 if (fid->file_char & UDF_FILE_CHAR_DEL) 824 continue; 825 826 if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 827 /* Do up the '.' and '..' entries. Dummy values are 828 * used for the cookies since the offset here is 829 * usually zero, and NFS doesn't like that value 830 */ 831 dir.d_fileno = node->hash_id; 832 dir.d_type = DT_DIR; 833 dir.d_name[0] = '.'; 834 dir.d_name[1] = '\0'; 835 dir.d_namlen = 1; 836 dir.d_reclen = GENERIC_DIRSIZ(&dir); 837 uiodir.dirent = &dir; 838 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 1); 839 if (error) 840 break; 841 842 dir.d_fileno = udf_getid(&fid->icb); 843 dir.d_type = DT_DIR; 844 dir.d_name[0] = '.'; 845 dir.d_name[1] = '.'; 846 dir.d_name[2] = '\0'; 847 dir.d_namlen = 2; 848 dir.d_reclen = GENERIC_DIRSIZ(&dir); 849 uiodir.dirent = &dir; 850 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 2); 851 } else { 852 dir.d_namlen = udf_transname(&fid->data[fid->l_iu], 853 &dir.d_name[0], fid->l_fi, udfmp); 854 dir.d_fileno = udf_getid(&fid->icb); 855 dir.d_type = (fid->file_char & UDF_FILE_CHAR_DIR) ? 856 DT_DIR : DT_UNKNOWN; 857 dir.d_reclen = GENERIC_DIRSIZ(&dir); 858 uiodir.dirent = &dir; 859 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 860 ds->this_off); 861 } 862 if (error) 863 break; 864 uio->uio_offset = ds->offset + ds->off; 865 } 866 867 /* tell the calling layer whether we need to be called again */ 868 *a->a_eofflag = uiodir.eofflag; 869 870 if (error < 0) 871 error = 0; 872 if (!error) 873 error = ds->error; 874 875 udf_closedir(ds); 876 877 if (a->a_ncookies != NULL) { 878 if (error) 879 free(cookies, M_TEMP); 880 else { 881 *a->a_ncookies = uiodir.acookies; 882 *a->a_cookies = cookies; 883 } 884 } 885 886 return (error); 887 } 888 889 static int 890 udf_readlink(struct vop_readlink_args *ap) 891 { 892 struct path_component *pc, *end; 893 struct vnode *vp; 894 struct uio uio; 895 struct iovec iov[1]; 896 struct udf_node *node; 897 void *buf; 898 char *cp; 899 int error, len, root; 900 901 /* 902 * A symbolic link in UDF is a list of variable-length path 903 * component structures. We build a pathname in the caller's 904 * uio by traversing this list. 905 */ 906 vp = ap->a_vp; 907 node = VTON(vp); 908 len = le64toh(node->fentry->inf_len); 909 buf = malloc(len, M_DEVBUF, M_WAITOK); 910 iov[0].iov_len = len; 911 iov[0].iov_base = buf; 912 uio.uio_iov = iov; 913 uio.uio_iovcnt = 1; 914 uio.uio_offset = 0; 915 uio.uio_resid = iov[0].iov_len; 916 uio.uio_segflg = UIO_SYSSPACE; 917 uio.uio_rw = UIO_READ; 918 uio.uio_td = curthread; 919 error = VOP_READ(vp, &uio, 0, ap->a_cred); 920 if (error) 921 goto error; 922 923 pc = buf; 924 end = (void *)((char *)buf + len); 925 root = 0; 926 while (pc < end) { 927 switch (pc->type) { 928 case UDF_PATH_ROOT: 929 /* Only allow this at the beginning of a path. */ 930 if ((void *)pc != buf) { 931 error = EINVAL; 932 goto error; 933 } 934 cp = "/"; 935 len = 1; 936 root = 1; 937 break; 938 case UDF_PATH_DOT: 939 cp = "."; 940 len = 1; 941 break; 942 case UDF_PATH_DOTDOT: 943 cp = ".."; 944 len = 2; 945 break; 946 case UDF_PATH_PATH: 947 if (pc->length == 0) { 948 error = EINVAL; 949 goto error; 950 } 951 /* 952 * XXX: We only support CS8 which appears to map 953 * to ASCII directly. 954 */ 955 switch (pc->identifier[0]) { 956 case 8: 957 cp = pc->identifier + 1; 958 len = pc->length - 1; 959 break; 960 default: 961 error = EOPNOTSUPP; 962 goto error; 963 } 964 break; 965 default: 966 error = EINVAL; 967 goto error; 968 } 969 970 /* 971 * If this is not the first component, insert a path 972 * separator. 973 */ 974 if (pc != buf) { 975 /* If we started with root we already have a "/". */ 976 if (root) 977 goto skipslash; 978 root = 0; 979 if (ap->a_uio->uio_resid < 1) { 980 error = ENAMETOOLONG; 981 goto error; 982 } 983 error = uiomove("/", 1, ap->a_uio); 984 if (error) 985 break; 986 } 987 skipslash: 988 989 /* Append string at 'cp' of length 'len' to our path. */ 990 if (len > ap->a_uio->uio_resid) { 991 error = ENAMETOOLONG; 992 goto error; 993 } 994 error = uiomove(cp, len, ap->a_uio); 995 if (error) 996 break; 997 998 /* Advance to next component. */ 999 pc = (void *)((char *)pc + 4 + pc->length); 1000 } 1001 error: 1002 free(buf, M_DEVBUF); 1003 return (error); 1004 } 1005 1006 static int 1007 udf_strategy(struct vop_strategy_args *a) 1008 { 1009 struct buf *bp; 1010 struct vnode *vp; 1011 struct udf_node *node; 1012 struct bufobj *bo; 1013 off_t offset; 1014 uint32_t maxsize; 1015 daddr_t sector; 1016 int error; 1017 1018 bp = a->a_bp; 1019 vp = a->a_vp; 1020 node = VTON(vp); 1021 1022 if (bp->b_blkno == bp->b_lblkno) { 1023 offset = lblktosize(node->udfmp, bp->b_lblkno); 1024 error = udf_bmap_internal(node, offset, §or, &maxsize); 1025 if (error) { 1026 clrbuf(bp); 1027 bp->b_blkno = -1; 1028 bufdone(bp); 1029 return (0); 1030 } 1031 /* bmap gives sector numbers, bio works with device blocks */ 1032 bp->b_blkno = sector << (node->udfmp->bshift - DEV_BSHIFT); 1033 } 1034 bo = node->udfmp->im_bo; 1035 bp->b_iooffset = dbtob(bp->b_blkno); 1036 BO_STRATEGY(bo, bp); 1037 return (0); 1038 } 1039 1040 static int 1041 udf_bmap(struct vop_bmap_args *a) 1042 { 1043 struct udf_node *node; 1044 uint32_t max_size; 1045 daddr_t lsector; 1046 int nblk; 1047 int error; 1048 1049 node = VTON(a->a_vp); 1050 1051 if (a->a_bop != NULL) 1052 *a->a_bop = &node->udfmp->im_devvp->v_bufobj; 1053 if (a->a_bnp == NULL) 1054 return (0); 1055 if (a->a_runb) 1056 *a->a_runb = 0; 1057 1058 /* 1059 * UDF_INVALID_BMAP means data embedded into fentry, this is an internal 1060 * error that should not be propagated to calling code. 1061 * Most obvious mapping for this error is EOPNOTSUPP as we can not truly 1062 * translate block numbers in this case. 1063 * Incidentally, this return code will make vnode pager to use VOP_READ 1064 * to get data for mmap-ed pages and udf_read knows how to do the right 1065 * thing for this kind of files. 1066 */ 1067 error = udf_bmap_internal(node, a->a_bn << node->udfmp->bshift, 1068 &lsector, &max_size); 1069 if (error == UDF_INVALID_BMAP) 1070 return (EOPNOTSUPP); 1071 if (error) 1072 return (error); 1073 1074 /* Translate logical to physical sector number */ 1075 *a->a_bnp = lsector << (node->udfmp->bshift - DEV_BSHIFT); 1076 1077 /* 1078 * Determine maximum number of readahead blocks following the 1079 * requested block. 1080 */ 1081 if (a->a_runp) { 1082 nblk = (max_size >> node->udfmp->bshift) - 1; 1083 if (nblk <= 0) 1084 *a->a_runp = 0; 1085 else if (nblk >= (MAXBSIZE >> node->udfmp->bshift)) 1086 *a->a_runp = (MAXBSIZE >> node->udfmp->bshift) - 1; 1087 else 1088 *a->a_runp = nblk; 1089 } 1090 1091 if (a->a_runb) { 1092 *a->a_runb = 0; 1093 } 1094 1095 return (0); 1096 } 1097 1098 /* 1099 * The all powerful VOP_LOOKUP(). 1100 */ 1101 static int 1102 udf_lookup(struct vop_cachedlookup_args *a) 1103 { 1104 struct vnode *dvp; 1105 struct vnode *tdp = NULL; 1106 struct vnode **vpp = a->a_vpp; 1107 struct udf_node *node; 1108 struct udf_mnt *udfmp; 1109 struct fileid_desc *fid = NULL; 1110 struct udf_dirstream *ds; 1111 u_long nameiop; 1112 u_long flags; 1113 char *nameptr; 1114 long namelen; 1115 ino_t id = 0; 1116 int offset, error = 0; 1117 int fsize, lkflags, ltype, numdirpasses; 1118 1119 dvp = a->a_dvp; 1120 node = VTON(dvp); 1121 udfmp = node->udfmp; 1122 nameiop = a->a_cnp->cn_nameiop; 1123 flags = a->a_cnp->cn_flags; 1124 lkflags = a->a_cnp->cn_lkflags; 1125 nameptr = a->a_cnp->cn_nameptr; 1126 namelen = a->a_cnp->cn_namelen; 1127 fsize = le64toh(node->fentry->inf_len); 1128 1129 /* 1130 * If this is a LOOKUP and we've already partially searched through 1131 * the directory, pick up where we left off and flag that the 1132 * directory may need to be searched twice. For a full description, 1133 * see /sys/fs/cd9660/cd9660_lookup.c:cd9660_lookup() 1134 */ 1135 if (nameiop != LOOKUP || node->diroff == 0 || node->diroff > fsize) { 1136 offset = 0; 1137 numdirpasses = 1; 1138 } else { 1139 offset = node->diroff; 1140 numdirpasses = 2; 1141 nchstats.ncs_2passes++; 1142 } 1143 1144 lookloop: 1145 ds = udf_opendir(node, offset, fsize, udfmp); 1146 1147 while ((fid = udf_getfid(ds)) != NULL) { 1148 1149 /* XXX Should we return an error on a bad fid? */ 1150 if (udf_checktag(&fid->tag, TAGID_FID)) { 1151 printf("udf_lookup: Invalid tag\n"); 1152 error = EIO; 1153 break; 1154 } 1155 1156 /* Is this a deleted file? */ 1157 if (fid->file_char & UDF_FILE_CHAR_DEL) 1158 continue; 1159 1160 if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 1161 if (flags & ISDOTDOT) { 1162 id = udf_getid(&fid->icb); 1163 break; 1164 } 1165 } else { 1166 if (!(udf_cmpname(&fid->data[fid->l_iu], 1167 nameptr, fid->l_fi, namelen, udfmp))) { 1168 id = udf_getid(&fid->icb); 1169 break; 1170 } 1171 } 1172 } 1173 1174 if (!error) 1175 error = ds->error; 1176 1177 /* XXX Bail out here? */ 1178 if (error) { 1179 udf_closedir(ds); 1180 return (error); 1181 } 1182 1183 /* Did we have a match? */ 1184 if (id) { 1185 /* 1186 * Remember where this entry was if it's the final 1187 * component. 1188 */ 1189 if ((flags & ISLASTCN) && nameiop == LOOKUP) 1190 node->diroff = ds->offset + ds->off; 1191 if (numdirpasses == 2) 1192 nchstats.ncs_pass2++; 1193 udf_closedir(ds); 1194 1195 if (flags & ISDOTDOT) { 1196 error = vn_vget_ino(dvp, id, lkflags, &tdp); 1197 } else if (node->hash_id == id) { 1198 VREF(dvp); /* we want ourself, ie "." */ 1199 /* 1200 * When we lookup "." we still can be asked to lock it 1201 * differently. 1202 */ 1203 ltype = lkflags & LK_TYPE_MASK; 1204 if (ltype != VOP_ISLOCKED(dvp)) { 1205 if (ltype == LK_EXCLUSIVE) 1206 vn_lock(dvp, LK_UPGRADE | LK_RETRY); 1207 else /* if (ltype == LK_SHARED) */ 1208 vn_lock(dvp, LK_DOWNGRADE | LK_RETRY); 1209 } 1210 tdp = dvp; 1211 } else 1212 error = udf_vget(udfmp->im_mountp, id, lkflags, &tdp); 1213 if (!error) { 1214 *vpp = tdp; 1215 /* Put this entry in the cache */ 1216 if (flags & MAKEENTRY) 1217 cache_enter(dvp, *vpp, a->a_cnp); 1218 } 1219 } else { 1220 /* Name wasn't found on this pass. Do another pass? */ 1221 if (numdirpasses == 2) { 1222 numdirpasses--; 1223 offset = 0; 1224 udf_closedir(ds); 1225 goto lookloop; 1226 } 1227 udf_closedir(ds); 1228 1229 /* Enter name into cache as non-existant */ 1230 if (flags & MAKEENTRY) 1231 cache_enter(dvp, *vpp, a->a_cnp); 1232 1233 if ((flags & ISLASTCN) && 1234 (nameiop == CREATE || nameiop == RENAME)) { 1235 error = EROFS; 1236 } else { 1237 error = ENOENT; 1238 } 1239 } 1240 1241 return (error); 1242 } 1243 1244 static int 1245 udf_reclaim(struct vop_reclaim_args *a) 1246 { 1247 struct vnode *vp; 1248 struct udf_node *unode; 1249 1250 vp = a->a_vp; 1251 unode = VTON(vp); 1252 1253 /* 1254 * Destroy the vm object and flush associated pages. 1255 */ 1256 vnode_destroy_vobject(vp); 1257 1258 if (unode != NULL) { 1259 vfs_hash_remove(vp); 1260 1261 if (unode->fentry != NULL) 1262 free(unode->fentry, M_UDFFENTRY); 1263 uma_zfree(udf_zone_node, unode); 1264 vp->v_data = NULL; 1265 } 1266 1267 return (0); 1268 } 1269 1270 static int 1271 udf_vptofh(struct vop_vptofh_args *a) 1272 { 1273 struct udf_node *node; 1274 struct ifid *ifhp; 1275 1276 node = VTON(a->a_vp); 1277 ifhp = (struct ifid *)a->a_fhp; 1278 ifhp->ifid_len = sizeof(struct ifid); 1279 ifhp->ifid_ino = node->hash_id; 1280 1281 return (0); 1282 } 1283 1284 /* 1285 * Read the block and then set the data pointer to correspond with the 1286 * offset passed in. Only read in at most 'size' bytes, and then set 'size' 1287 * to the number of bytes pointed to. If 'size' is zero, try to read in a 1288 * whole extent. 1289 * 1290 * Note that *bp may be assigned error or not. 1291 * 1292 */ 1293 static int 1294 udf_readatoffset(struct udf_node *node, int *size, off_t offset, 1295 struct buf **bp, uint8_t **data) 1296 { 1297 struct udf_mnt *udfmp = node->udfmp; 1298 struct vnode *vp = node->i_vnode; 1299 struct file_entry *fentry; 1300 struct buf *bp1; 1301 uint32_t max_size; 1302 daddr_t sector; 1303 off_t off; 1304 int adj_size; 1305 int error; 1306 1307 /* 1308 * This call is made *not* only to detect UDF_INVALID_BMAP case, 1309 * max_size is used as an ad-hoc read-ahead hint for "normal" case. 1310 */ 1311 error = udf_bmap_internal(node, offset, §or, &max_size); 1312 if (error == UDF_INVALID_BMAP) { 1313 /* 1314 * This error means that the file *data* is stored in the 1315 * allocation descriptor field of the file entry. 1316 */ 1317 fentry = node->fentry; 1318 *data = &fentry->data[le32toh(fentry->l_ea)]; 1319 *size = le32toh(fentry->l_ad); 1320 if (offset >= *size) 1321 *size = 0; 1322 else { 1323 *data += offset; 1324 *size -= offset; 1325 } 1326 return (0); 1327 } else if (error != 0) { 1328 return (error); 1329 } 1330 1331 /* Adjust the size so that it is within range */ 1332 if (*size == 0 || *size > max_size) 1333 *size = max_size; 1334 1335 /* 1336 * Because we will read starting at block boundary, we need to adjust 1337 * how much we need to read so that all promised data is in. 1338 * Also, we can't promise to read more than MAXBSIZE bytes starting 1339 * from block boundary, so adjust what we promise too. 1340 */ 1341 off = blkoff(udfmp, offset); 1342 *size = min(*size, MAXBSIZE - off); 1343 adj_size = (*size + off + udfmp->bmask) & ~udfmp->bmask; 1344 *bp = NULL; 1345 if ((error = bread(vp, lblkno(udfmp, offset), adj_size, NOCRED, bp))) { 1346 printf("warning: udf_readlblks returned error %d\n", error); 1347 /* note: *bp may be non-NULL */ 1348 return (error); 1349 } 1350 1351 bp1 = *bp; 1352 *data = (uint8_t *)&bp1->b_data[offset & udfmp->bmask]; 1353 return (0); 1354 } 1355 1356 /* 1357 * Translate a file offset into a logical block and then into a physical 1358 * block. 1359 * max_size - maximum number of bytes that can be read starting from given 1360 * offset, rather than beginning of calculated sector number 1361 */ 1362 static int 1363 udf_bmap_internal(struct udf_node *node, off_t offset, daddr_t *sector, 1364 uint32_t *max_size) 1365 { 1366 struct udf_mnt *udfmp; 1367 struct file_entry *fentry; 1368 void *icb; 1369 struct icb_tag *tag; 1370 uint32_t icblen = 0; 1371 daddr_t lsector; 1372 int ad_offset, ad_num = 0; 1373 int i, p_offset; 1374 1375 udfmp = node->udfmp; 1376 fentry = node->fentry; 1377 tag = &fentry->icbtag; 1378 1379 switch (le16toh(tag->strat_type)) { 1380 case 4: 1381 break; 1382 1383 case 4096: 1384 printf("Cannot deal with strategy4096 yet!\n"); 1385 return (ENODEV); 1386 1387 default: 1388 printf("Unknown strategy type %d\n", tag->strat_type); 1389 return (ENODEV); 1390 } 1391 1392 switch (le16toh(tag->flags) & 0x7) { 1393 case 0: 1394 /* 1395 * The allocation descriptor field is filled with short_ad's. 1396 * If the offset is beyond the current extent, look for the 1397 * next extent. 1398 */ 1399 do { 1400 offset -= icblen; 1401 ad_offset = sizeof(struct short_ad) * ad_num; 1402 if (ad_offset > le32toh(fentry->l_ad)) { 1403 printf("File offset out of bounds\n"); 1404 return (EINVAL); 1405 } 1406 icb = GETICB(short_ad, fentry, 1407 le32toh(fentry->l_ea) + ad_offset); 1408 icblen = GETICBLEN(short_ad, icb); 1409 ad_num++; 1410 } while(offset >= icblen); 1411 1412 lsector = (offset >> udfmp->bshift) + 1413 le32toh(((struct short_ad *)(icb))->pos); 1414 1415 *max_size = icblen - offset; 1416 1417 break; 1418 case 1: 1419 /* 1420 * The allocation descriptor field is filled with long_ad's 1421 * If the offset is beyond the current extent, look for the 1422 * next extent. 1423 */ 1424 do { 1425 offset -= icblen; 1426 ad_offset = sizeof(struct long_ad) * ad_num; 1427 if (ad_offset > le32toh(fentry->l_ad)) { 1428 printf("File offset out of bounds\n"); 1429 return (EINVAL); 1430 } 1431 icb = GETICB(long_ad, fentry, 1432 le32toh(fentry->l_ea) + ad_offset); 1433 icblen = GETICBLEN(long_ad, icb); 1434 ad_num++; 1435 } while(offset >= icblen); 1436 1437 lsector = (offset >> udfmp->bshift) + 1438 le32toh(((struct long_ad *)(icb))->loc.lb_num); 1439 1440 *max_size = icblen - offset; 1441 1442 break; 1443 case 3: 1444 /* 1445 * This type means that the file *data* is stored in the 1446 * allocation descriptor field of the file entry. 1447 */ 1448 *max_size = 0; 1449 *sector = node->hash_id + udfmp->part_start; 1450 1451 return (UDF_INVALID_BMAP); 1452 case 2: 1453 /* DirectCD does not use extended_ad's */ 1454 default: 1455 printf("Unsupported allocation descriptor %d\n", 1456 tag->flags & 0x7); 1457 return (ENODEV); 1458 } 1459 1460 *sector = lsector + udfmp->part_start; 1461 1462 /* 1463 * Check the sparing table. Each entry represents the beginning of 1464 * a packet. 1465 */ 1466 if (udfmp->s_table != NULL) { 1467 for (i = 0; i< udfmp->s_table_entries; i++) { 1468 p_offset = 1469 lsector - le32toh(udfmp->s_table->entries[i].org); 1470 if ((p_offset < udfmp->p_sectors) && (p_offset >= 0)) { 1471 *sector = 1472 le32toh(udfmp->s_table->entries[i].map) + 1473 p_offset; 1474 break; 1475 } 1476 } 1477 } 1478 1479 return (0); 1480 } 1481