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 56extern struct iconv_functions *udf_iconv; 57 58static vop_access_t udf_access; 59static vop_getattr_t udf_getattr; 60static vop_open_t udf_open; 61static vop_ioctl_t udf_ioctl; 62static vop_pathconf_t udf_pathconf; 63static vop_print_t udf_print; 64static vop_read_t udf_read; 65static vop_readdir_t udf_readdir; 66static vop_readlink_t udf_readlink; 67static vop_setattr_t udf_setattr; 68static vop_strategy_t udf_strategy; 69static vop_bmap_t udf_bmap; 70static vop_cachedlookup_t udf_lookup; 71static vop_reclaim_t udf_reclaim; 72static vop_vptofh_t udf_vptofh; 73static int udf_readatoffset(struct udf_node *node, int *size, off_t offset, 74 struct buf **bp, uint8_t **data); 75static int udf_bmap_internal(struct udf_node *node, off_t offset, 76 daddr_t *sector, uint32_t *max_size); 77 78static 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 99struct 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 109static MALLOC_DEFINE(M_UDFFID, "udf_fid", "UDF FileId structure"); 110static MALLOC_DEFINE(M_UDFDS, "udf_ds", "UDF Dirstream structure"); 111 112#define UDF_INVALID_BMAP -1 113 114int 115udf_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 */ 131static mode_t 132udf_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 151static int 152udf_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 181static int 182udf_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 191static 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 196static int 197udf_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 */ 211static void 212udf_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 280static int 281udf_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 335static int 336udf_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 */ 370static int 371udf_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 */ 381static int 382udf_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 403static int 404udf_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 421static inline int 422is_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 429static int 430udf_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 n = min(n, size - bp->b_resid); 491 if (error) { 492 brelse(bp); 493 return (error); 494 } 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 */ 508static int 509udf_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, (const char **)&unibuf, 530 (size_t *)&unilen, (char **)&destname, &destleft); 531 /* Unconverted character found */ 532 if (unilen > 0 && destleft > 0) { 533 *destname++ = '?'; 534 destleft--; 535 unibuf += 2; 536 unilen -= 2; 537 } 538 } 539 uma_zfree(udf_zone_trans, unip); 540 *destname = '\0'; 541 destlen = MAXNAMLEN - (int)destleft; 542 } else { 543 /* allocate a buffer big enough to hold an 8->16 bit expansion */ 544 transname = uma_zalloc(udf_zone_trans, M_WAITOK); 545 546 if ((unilen = (ssize_t)udf_UncompressUnicode(len, cs0string, transname)) == -1) { 547 printf("udf: Unicode translation failed\n"); 548 uma_zfree(udf_zone_trans, transname); 549 return 0; 550 } 551 552 for (i = 0; i < unilen ; i++) { 553 if (transname[i] & 0xff00) { 554 destname[i] = '.'; /* Fudge the 16bit chars */ 555 } else { 556 destname[i] = transname[i] & 0xff; 557 } 558 } 559 uma_zfree(udf_zone_trans, transname); 560 destname[unilen] = 0; 561 destlen = (int)unilen; 562 } 563 564 return (destlen); 565} 566 567/* 568 * Compare a CS0 dstring with a name passed in from the VFS layer. Return 569 * 0 on a successful match, nonzero otherwise. Unicode work may need to be done 570 * here also. 571 */ 572static int 573udf_cmpname(char *cs0string, char *cmpname, int cs0len, int cmplen, struct udf_mnt *udfmp) 574{ 575 char *transname; 576 int error = 0; 577 578 /* This is overkill, but not worth creating a new zone */ 579 transname = uma_zalloc(udf_zone_trans, M_WAITOK); 580 581 cs0len = udf_transname(cs0string, transname, cs0len, udfmp); 582 583 /* Easy check. If they aren't the same length, they aren't equal */ 584 if ((cs0len == 0) || (cs0len != cmplen)) 585 error = -1; 586 else 587 error = bcmp(transname, cmpname, cmplen); 588 589 uma_zfree(udf_zone_trans, transname); 590 return (error); 591} 592 593struct udf_uiodir { 594 struct dirent *dirent; 595 u_long *cookies; 596 int ncookies; 597 int acookies; 598 int eofflag; 599}; 600 601static int 602udf_uiodir(struct udf_uiodir *uiodir, int de_size, struct uio *uio, long cookie) 603{ 604 if (uiodir->cookies != NULL) { 605 if (++uiodir->acookies > uiodir->ncookies) { 606 uiodir->eofflag = 0; 607 return (-1); 608 } 609 *uiodir->cookies++ = cookie; 610 } 611 612 if (uio->uio_resid < de_size) { 613 uiodir->eofflag = 0; 614 return (-1); 615 } 616 617 return (uiomove(uiodir->dirent, de_size, uio)); 618} 619 620static struct udf_dirstream * 621udf_opendir(struct udf_node *node, int offset, int fsize, struct udf_mnt *udfmp) 622{ 623 struct udf_dirstream *ds; 624 625 ds = uma_zalloc(udf_zone_ds, M_WAITOK | M_ZERO); 626 627 ds->node = node; 628 ds->offset = offset; 629 ds->udfmp = udfmp; 630 ds->fsize = fsize; 631 632 return (ds); 633} 634 635static struct fileid_desc * 636udf_getfid(struct udf_dirstream *ds) 637{ 638 struct fileid_desc *fid; 639 int error, frag_size = 0, total_fid_size; 640 641 /* End of directory? */ 642 if (ds->offset + ds->off >= ds->fsize) { 643 ds->error = 0; 644 return (NULL); 645 } 646 647 /* Grab the first extent of the directory */ 648 if (ds->off == 0) { 649 ds->size = 0; 650 error = udf_readatoffset(ds->node, &ds->size, ds->offset, 651 &ds->bp, &ds->data); 652 if (error) { 653 ds->error = error; 654 if (ds->bp != NULL) 655 brelse(ds->bp); 656 return (NULL); 657 } 658 } 659 660 /* 661 * Clean up from a previous fragmented FID. 662 * XXX Is this the right place for this? 663 */ 664 if (ds->fid_fragment && ds->buf != NULL) { 665 ds->fid_fragment = 0; 666 free(ds->buf, M_UDFFID); 667 } 668 669 fid = (struct fileid_desc*)&ds->data[ds->off]; 670 671 /* 672 * Check to see if the fid is fragmented. The first test 673 * ensures that we don't wander off the end of the buffer 674 * looking for the l_iu and l_fi fields. 675 */ 676 if (ds->off + UDF_FID_SIZE > ds->size || 677 ds->off + le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE > ds->size){ 678 679 /* Copy what we have of the fid into a buffer */ 680 frag_size = ds->size - ds->off; 681 if (frag_size >= ds->udfmp->bsize) { 682 printf("udf: invalid FID fragment\n"); 683 ds->error = EINVAL; 684 return (NULL); 685 } 686 687 /* 688 * File ID descriptors can only be at most one 689 * logical sector in size. 690 */ 691 ds->buf = malloc(ds->udfmp->bsize, M_UDFFID, 692 M_WAITOK | M_ZERO); 693 bcopy(fid, ds->buf, frag_size); 694 695 /* Reduce all of the casting magic */ 696 fid = (struct fileid_desc*)ds->buf; 697 698 if (ds->bp != NULL) 699 brelse(ds->bp); 700 701 /* Fetch the next allocation */ 702 ds->offset += ds->size; 703 ds->size = 0; 704 error = udf_readatoffset(ds->node, &ds->size, ds->offset, 705 &ds->bp, &ds->data); 706 if (error) { 707 ds->error = error; 708 return (NULL); 709 } 710 711 /* 712 * If the fragment was so small that we didn't get 713 * the l_iu and l_fi fields, copy those in. 714 */ 715 if (frag_size < UDF_FID_SIZE) 716 bcopy(ds->data, &ds->buf[frag_size], 717 UDF_FID_SIZE - frag_size); 718 719 /* 720 * Now that we have enough of the fid to work with, 721 * copy in the rest of the fid from the new 722 * allocation. 723 */ 724 total_fid_size = UDF_FID_SIZE + le16toh(fid->l_iu) + fid->l_fi; 725 if (total_fid_size > ds->udfmp->bsize) { 726 printf("udf: invalid FID\n"); 727 ds->error = EIO; 728 return (NULL); 729 } 730 bcopy(ds->data, &ds->buf[frag_size], 731 total_fid_size - frag_size); 732 733 ds->fid_fragment = 1; 734 } else { 735 total_fid_size = le16toh(fid->l_iu) + fid->l_fi + UDF_FID_SIZE; 736 } 737 738 /* 739 * Update the offset. Align on a 4 byte boundary because the 740 * UDF spec says so. 741 */ 742 ds->this_off = ds->offset + ds->off; 743 if (!ds->fid_fragment) { 744 ds->off += (total_fid_size + 3) & ~0x03; 745 } else { 746 ds->off = (total_fid_size - frag_size + 3) & ~0x03; 747 } 748 749 return (fid); 750} 751 752static void 753udf_closedir(struct udf_dirstream *ds) 754{ 755 756 if (ds->bp != NULL) 757 brelse(ds->bp); 758 759 if (ds->fid_fragment && ds->buf != NULL) 760 free(ds->buf, M_UDFFID); 761 762 uma_zfree(udf_zone_ds, ds); 763} 764 765static int 766udf_readdir(struct vop_readdir_args *a) 767{ 768 struct vnode *vp; 769 struct uio *uio; 770 struct dirent dir; 771 struct udf_node *node; 772 struct udf_mnt *udfmp; 773 struct fileid_desc *fid; 774 struct udf_uiodir uiodir; 775 struct udf_dirstream *ds; 776 u_long *cookies = NULL; 777 int ncookies; 778 int error = 0; 779 780 vp = a->a_vp; 781 uio = a->a_uio; 782 node = VTON(vp); 783 udfmp = node->udfmp; 784 uiodir.eofflag = 1; 785 786 if (a->a_ncookies != NULL) { 787 /* 788 * Guess how many entries are needed. If we run out, this 789 * function will be called again and thing will pick up were 790 * it left off. 791 */ 792 ncookies = uio->uio_resid / 8; 793 cookies = malloc(sizeof(u_long) * ncookies, 794 M_TEMP, M_WAITOK); 795 if (cookies == NULL) 796 return (ENOMEM); 797 uiodir.ncookies = ncookies; 798 uiodir.cookies = cookies; 799 uiodir.acookies = 0; 800 } else { 801 uiodir.cookies = NULL; 802 } 803 804 /* 805 * Iterate through the file id descriptors. Give the parent dir 806 * entry special attention. 807 */ 808 ds = udf_opendir(node, uio->uio_offset, le64toh(node->fentry->inf_len), 809 node->udfmp); 810 811 while ((fid = udf_getfid(ds)) != NULL) { 812 813 /* XXX Should we return an error on a bad fid? */ 814 if (udf_checktag(&fid->tag, TAGID_FID)) { 815 printf("Invalid FID tag\n"); 816 hexdump(fid, UDF_FID_SIZE, NULL, 0); 817 error = EIO; 818 break; 819 } 820 821 /* Is this a deleted file? */ 822 if (fid->file_char & UDF_FILE_CHAR_DEL) 823 continue; 824 825 if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 826 /* Do up the '.' and '..' entries. Dummy values are 827 * used for the cookies since the offset here is 828 * usually zero, and NFS doesn't like that value 829 */ 830 dir.d_fileno = node->hash_id; 831 dir.d_type = DT_DIR; 832 dir.d_name[0] = '.'; 833 dir.d_name[1] = '\0'; 834 dir.d_namlen = 1; 835 dir.d_reclen = GENERIC_DIRSIZ(&dir); 836 uiodir.dirent = &dir; 837 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 1); 838 if (error) 839 break; 840 841 dir.d_fileno = udf_getid(&fid->icb); 842 dir.d_type = DT_DIR; 843 dir.d_name[0] = '.'; 844 dir.d_name[1] = '.'; 845 dir.d_name[2] = '\0'; 846 dir.d_namlen = 2; 847 dir.d_reclen = GENERIC_DIRSIZ(&dir); 848 uiodir.dirent = &dir; 849 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 2); 850 } else { 851 dir.d_namlen = udf_transname(&fid->data[fid->l_iu], 852 &dir.d_name[0], fid->l_fi, udfmp); 853 dir.d_fileno = udf_getid(&fid->icb); 854 dir.d_type = (fid->file_char & UDF_FILE_CHAR_DIR) ? 855 DT_DIR : DT_UNKNOWN; 856 dir.d_reclen = GENERIC_DIRSIZ(&dir); 857 uiodir.dirent = &dir; 858 error = udf_uiodir(&uiodir, dir.d_reclen, uio, 859 ds->this_off); 860 } 861 if (error) 862 break; 863 uio->uio_offset = ds->offset + ds->off; 864 } 865 866 /* tell the calling layer whether we need to be called again */ 867 *a->a_eofflag = uiodir.eofflag; 868 869 if (error < 0) 870 error = 0; 871 if (!error) 872 error = ds->error; 873 874 udf_closedir(ds); 875 876 if (a->a_ncookies != NULL) { 877 if (error) 878 free(cookies, M_TEMP); 879 else { 880 *a->a_ncookies = uiodir.acookies; 881 *a->a_cookies = cookies; 882 } 883 } 884 885 return (error); 886} 887 888static int 889udf_readlink(struct vop_readlink_args *ap) 890{ 891 struct path_component *pc, *end; 892 struct vnode *vp; 893 struct uio uio; 894 struct iovec iov[1]; 895 struct udf_node *node; 896 void *buf; 897 char *cp; 898 int error, len, root; 899 900 /* 901 * A symbolic link in UDF is a list of variable-length path 902 * component structures. We build a pathname in the caller's 903 * uio by traversing this list. 904 */ 905 vp = ap->a_vp; 906 node = VTON(vp); 907 len = le64toh(node->fentry->inf_len); 908 buf = malloc(len, M_DEVBUF, M_WAITOK); 909 iov[0].iov_len = len; 910 iov[0].iov_base = buf; 911 uio.uio_iov = iov; 912 uio.uio_iovcnt = 1; 913 uio.uio_offset = 0; 914 uio.uio_resid = iov[0].iov_len; 915 uio.uio_segflg = UIO_SYSSPACE; 916 uio.uio_rw = UIO_READ; 917 uio.uio_td = curthread; 918 error = VOP_READ(vp, &uio, 0, ap->a_cred); 919 if (error) 920 goto error; 921 922 pc = buf; 923 end = (void *)((char *)buf + len); 924 root = 0; 925 while (pc < end) { 926 switch (pc->type) { 927 case UDF_PATH_ROOT: 928 /* Only allow this at the beginning of a path. */ 929 if ((void *)pc != buf) { 930 error = EINVAL; 931 goto error; 932 } 933 cp = "/"; 934 len = 1; 935 root = 1; 936 break; 937 case UDF_PATH_DOT: 938 cp = "."; 939 len = 1; 940 break; 941 case UDF_PATH_DOTDOT: 942 cp = ".."; 943 len = 2; 944 break; 945 case UDF_PATH_PATH: 946 if (pc->length == 0) { 947 error = EINVAL; 948 goto error; 949 } 950 /* 951 * XXX: We only support CS8 which appears to map 952 * to ASCII directly. 953 */ 954 switch (pc->identifier[0]) { 955 case 8: 956 cp = pc->identifier + 1; 957 len = pc->length - 1; 958 break; 959 default: 960 error = EOPNOTSUPP; 961 goto error; 962 } 963 break; 964 default: 965 error = EINVAL; 966 goto error; 967 } 968 969 /* 970 * If this is not the first component, insert a path 971 * separator. 972 */ 973 if (pc != buf) { 974 /* If we started with root we already have a "/". */ 975 if (root) 976 goto skipslash; 977 root = 0; 978 if (ap->a_uio->uio_resid < 1) { 979 error = ENAMETOOLONG; 980 goto error; 981 } 982 error = uiomove("/", 1, ap->a_uio); 983 if (error) 984 break; 985 } 986 skipslash: 987 988 /* Append string at 'cp' of length 'len' to our path. */ 989 if (len > ap->a_uio->uio_resid) { 990 error = ENAMETOOLONG; 991 goto error; 992 } 993 error = uiomove(cp, len, ap->a_uio); 994 if (error) 995 break; 996 997 /* Advance to next component. */ 998 pc = (void *)((char *)pc + 4 + pc->length); 999 } 1000error: 1001 free(buf, M_DEVBUF); 1002 return (error); 1003} 1004 1005static int 1006udf_strategy(struct vop_strategy_args *a) 1007{ 1008 struct buf *bp; 1009 struct vnode *vp; 1010 struct udf_node *node; 1011 struct bufobj *bo; 1012 off_t offset; 1013 uint32_t maxsize; 1014 daddr_t sector; 1015 int error; 1016 1017 bp = a->a_bp; 1018 vp = a->a_vp; 1019 node = VTON(vp); 1020 1021 if (bp->b_blkno == bp->b_lblkno) { 1022 offset = lblktosize(node->udfmp, bp->b_lblkno); 1023 error = udf_bmap_internal(node, offset, §or, &maxsize); 1024 if (error) { 1025 clrbuf(bp); 1026 bp->b_blkno = -1; 1027 bufdone(bp); 1028 return (0); 1029 } 1030 /* bmap gives sector numbers, bio works with device blocks */ 1031 bp->b_blkno = sector << (node->udfmp->bshift - DEV_BSHIFT); 1032 } 1033 bo = node->udfmp->im_bo; 1034 bp->b_iooffset = dbtob(bp->b_blkno); 1035 BO_STRATEGY(bo, bp); 1036 return (0); 1037} 1038 1039static int 1040udf_bmap(struct vop_bmap_args *a) 1041{ 1042 struct udf_node *node; 1043 uint32_t max_size; 1044 daddr_t lsector; 1045 int nblk; 1046 int error; 1047 1048 node = VTON(a->a_vp); 1049 1050 if (a->a_bop != NULL) 1051 *a->a_bop = &node->udfmp->im_devvp->v_bufobj; 1052 if (a->a_bnp == NULL) 1053 return (0); 1054 if (a->a_runb) 1055 *a->a_runb = 0; 1056 1057 /* 1058 * UDF_INVALID_BMAP means data embedded into fentry, this is an internal 1059 * error that should not be propagated to calling code. 1060 * Most obvious mapping for this error is EOPNOTSUPP as we can not truly 1061 * translate block numbers in this case. 1062 * Incidentally, this return code will make vnode pager to use VOP_READ 1063 * to get data for mmap-ed pages and udf_read knows how to do the right 1064 * thing for this kind of files. 1065 */ 1066 error = udf_bmap_internal(node, a->a_bn << node->udfmp->bshift, 1067 &lsector, &max_size); 1068 if (error == UDF_INVALID_BMAP) 1069 return (EOPNOTSUPP); 1070 if (error) 1071 return (error); 1072 1073 /* Translate logical to physical sector number */ 1074 *a->a_bnp = lsector << (node->udfmp->bshift - DEV_BSHIFT); 1075 1076 /* 1077 * Determine maximum number of readahead blocks following the 1078 * requested block. 1079 */ 1080 if (a->a_runp) { 1081 nblk = (max_size >> node->udfmp->bshift) - 1; 1082 if (nblk <= 0) 1083 *a->a_runp = 0; 1084 else if (nblk >= (MAXBSIZE >> node->udfmp->bshift)) 1085 *a->a_runp = (MAXBSIZE >> node->udfmp->bshift) - 1; 1086 else 1087 *a->a_runp = nblk; 1088 } 1089 1090 if (a->a_runb) { 1091 *a->a_runb = 0; 1092 } 1093 1094 return (0); 1095} 1096 1097/* 1098 * The all powerful VOP_LOOKUP(). 1099 */ 1100static int 1101udf_lookup(struct vop_cachedlookup_args *a) 1102{ 1103 struct vnode *dvp; 1104 struct vnode *tdp = NULL; 1105 struct vnode **vpp = a->a_vpp; 1106 struct udf_node *node; 1107 struct udf_mnt *udfmp; 1108 struct fileid_desc *fid = NULL; 1109 struct udf_dirstream *ds; 1110 u_long nameiop; 1111 u_long flags; 1112 char *nameptr; 1113 long namelen; 1114 ino_t id = 0; 1115 int offset, error = 0; 1116 int fsize, lkflags, ltype, numdirpasses; 1117 1118 dvp = a->a_dvp; 1119 node = VTON(dvp); 1120 udfmp = node->udfmp; 1121 nameiop = a->a_cnp->cn_nameiop; 1122 flags = a->a_cnp->cn_flags; 1123 lkflags = a->a_cnp->cn_lkflags; 1124 nameptr = a->a_cnp->cn_nameptr; 1125 namelen = a->a_cnp->cn_namelen; 1126 fsize = le64toh(node->fentry->inf_len); 1127 1128 /* 1129 * If this is a LOOKUP and we've already partially searched through 1130 * the directory, pick up where we left off and flag that the 1131 * directory may need to be searched twice. For a full description, 1132 * see /sys/fs/cd9660/cd9660_lookup.c:cd9660_lookup() 1133 */ 1134 if (nameiop != LOOKUP || node->diroff == 0 || node->diroff > fsize) { 1135 offset = 0; 1136 numdirpasses = 1; 1137 } else { 1138 offset = node->diroff; 1139 numdirpasses = 2; 1140 nchstats.ncs_2passes++; 1141 } 1142 1143lookloop: 1144 ds = udf_opendir(node, offset, fsize, udfmp); 1145 1146 while ((fid = udf_getfid(ds)) != NULL) { 1147 1148 /* XXX Should we return an error on a bad fid? */ 1149 if (udf_checktag(&fid->tag, TAGID_FID)) { 1150 printf("udf_lookup: Invalid tag\n"); 1151 error = EIO; 1152 break; 1153 } 1154 1155 /* Is this a deleted file? */ 1156 if (fid->file_char & UDF_FILE_CHAR_DEL) 1157 continue; 1158 1159 if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) { 1160 if (flags & ISDOTDOT) { 1161 id = udf_getid(&fid->icb); 1162 break; 1163 } 1164 } else { 1165 if (!(udf_cmpname(&fid->data[fid->l_iu], 1166 nameptr, fid->l_fi, namelen, udfmp))) { 1167 id = udf_getid(&fid->icb); 1168 break; 1169 } 1170 } 1171 } 1172 1173 if (!error) 1174 error = ds->error; 1175 1176 /* XXX Bail out here? */ 1177 if (error) { 1178 udf_closedir(ds); 1179 return (error); 1180 } 1181 1182 /* Did we have a match? */ 1183 if (id) { 1184 /* 1185 * Remember where this entry was if it's the final 1186 * component. 1187 */ 1188 if ((flags & ISLASTCN) && nameiop == LOOKUP) 1189 node->diroff = ds->offset + ds->off; 1190 if (numdirpasses == 2) 1191 nchstats.ncs_pass2++; 1192 udf_closedir(ds); 1193 1194 if (flags & ISDOTDOT) { 1195 error = vn_vget_ino(dvp, id, lkflags, &tdp); 1196 } else if (node->hash_id == id) { 1197 VREF(dvp); /* we want ourself, ie "." */ 1198 /* 1199 * When we lookup "." we still can be asked to lock it 1200 * differently. 1201 */ 1202 ltype = lkflags & LK_TYPE_MASK; 1203 if (ltype != VOP_ISLOCKED(dvp)) { 1204 if (ltype == LK_EXCLUSIVE) 1205 vn_lock(dvp, LK_UPGRADE | LK_RETRY); 1206 else /* if (ltype == LK_SHARED) */ 1207 vn_lock(dvp, LK_DOWNGRADE | LK_RETRY); 1208 } 1209 tdp = dvp; 1210 } else 1211 error = udf_vget(udfmp->im_mountp, id, lkflags, &tdp); 1212 if (!error) { 1213 *vpp = tdp; 1214 /* Put this entry in the cache */ 1215 if (flags & MAKEENTRY) 1216 cache_enter(dvp, *vpp, a->a_cnp); 1217 } 1218 } else { 1219 /* Name wasn't found on this pass. Do another pass? */ 1220 if (numdirpasses == 2) { 1221 numdirpasses--; 1222 offset = 0; 1223 udf_closedir(ds); 1224 goto lookloop; 1225 } 1226 udf_closedir(ds); 1227 1228 /* Enter name into cache as non-existant */ 1229 if (flags & MAKEENTRY) 1230 cache_enter(dvp, *vpp, a->a_cnp); 1231 1232 if ((flags & ISLASTCN) && 1233 (nameiop == CREATE || nameiop == RENAME)) { 1234 error = EROFS; 1235 } else { 1236 error = ENOENT; 1237 } 1238 } 1239 1240 return (error); 1241} 1242 1243static int 1244udf_reclaim(struct vop_reclaim_args *a) 1245{ 1246 struct vnode *vp; 1247 struct udf_node *unode; 1248 1249 vp = a->a_vp; 1250 unode = VTON(vp); 1251 1252 /* 1253 * Destroy the vm object and flush associated pages. 1254 */ 1255 vnode_destroy_vobject(vp); 1256 1257 if (unode != NULL) { 1258 vfs_hash_remove(vp); 1259 1260 if (unode->fentry != NULL) 1261 free(unode->fentry, M_UDFFENTRY); 1262 uma_zfree(udf_zone_node, unode); 1263 vp->v_data = NULL; 1264 } 1265 1266 return (0); 1267} 1268 1269static int 1270udf_vptofh(struct vop_vptofh_args *a) 1271{ 1272 struct udf_node *node; 1273 struct ifid *ifhp; 1274 1275 node = VTON(a->a_vp); 1276 ifhp = (struct ifid *)a->a_fhp; 1277 ifhp->ifid_len = sizeof(struct ifid); 1278 ifhp->ifid_ino = node->hash_id; 1279 1280 return (0); 1281} 1282 1283/* 1284 * Read the block and then set the data pointer to correspond with the 1285 * offset passed in. Only read in at most 'size' bytes, and then set 'size' 1286 * to the number of bytes pointed to. If 'size' is zero, try to read in a 1287 * whole extent. 1288 * 1289 * Note that *bp may be assigned error or not. 1290 * 1291 */ 1292static int 1293udf_readatoffset(struct udf_node *node, int *size, off_t offset, 1294 struct buf **bp, uint8_t **data) 1295{ 1296 struct udf_mnt *udfmp = node->udfmp; 1297 struct vnode *vp = node->i_vnode; 1298 struct file_entry *fentry; 1299 struct buf *bp1; 1300 uint32_t max_size; 1301 daddr_t sector; 1302 off_t off; 1303 int adj_size; 1304 int error; 1305 1306 /* 1307 * This call is made *not* only to detect UDF_INVALID_BMAP case, 1308 * max_size is used as an ad-hoc read-ahead hint for "normal" case. 1309 */ 1310 error = udf_bmap_internal(node, offset, §or, &max_size); 1311 if (error == UDF_INVALID_BMAP) { 1312 /* 1313 * This error means that the file *data* is stored in the 1314 * allocation descriptor field of the file entry. 1315 */ 1316 fentry = node->fentry; 1317 *data = &fentry->data[le32toh(fentry->l_ea)]; 1318 *size = le32toh(fentry->l_ad); 1319 if (offset >= *size) 1320 *size = 0; 1321 else { 1322 *data += offset; 1323 *size -= offset; 1324 } 1325 return (0); 1326 } else if (error != 0) { 1327 return (error); 1328 } 1329 1330 /* Adjust the size so that it is within range */ 1331 if (*size == 0 || *size > max_size) 1332 *size = max_size; 1333 1334 /* 1335 * Because we will read starting at block boundary, we need to adjust 1336 * how much we need to read so that all promised data is in. 1337 * Also, we can't promise to read more than MAXBSIZE bytes starting 1338 * from block boundary, so adjust what we promise too. 1339 */ 1340 off = blkoff(udfmp, offset); 1341 *size = min(*size, MAXBSIZE - off); 1342 adj_size = (*size + off + udfmp->bmask) & ~udfmp->bmask; 1343 *bp = NULL; 1344 if ((error = bread(vp, lblkno(udfmp, offset), adj_size, NOCRED, bp))) { 1345 printf("warning: udf_readlblks returned error %d\n", error); 1346 /* note: *bp may be non-NULL */ 1347 return (error); 1348 } 1349 1350 bp1 = *bp; 1351 *data = (uint8_t *)&bp1->b_data[offset & udfmp->bmask]; 1352 return (0); 1353} 1354 1355/* 1356 * Translate a file offset into a logical block and then into a physical 1357 * block. 1358 * max_size - maximum number of bytes that can be read starting from given 1359 * offset, rather than beginning of calculated sector number 1360 */ 1361static int 1362udf_bmap_internal(struct udf_node *node, off_t offset, daddr_t *sector, 1363 uint32_t *max_size) 1364{ 1365 struct udf_mnt *udfmp; 1366 struct file_entry *fentry; 1367 void *icb; 1368 struct icb_tag *tag; 1369 uint32_t icblen = 0; 1370 daddr_t lsector; 1371 int ad_offset, ad_num = 0; 1372 int i, p_offset; 1373 1374 udfmp = node->udfmp; 1375 fentry = node->fentry; 1376 tag = &fentry->icbtag; 1377 1378 switch (le16toh(tag->strat_type)) { 1379 case 4: 1380 break; 1381 1382 case 4096: 1383 printf("Cannot deal with strategy4096 yet!\n"); 1384 return (ENODEV); 1385 1386 default: 1387 printf("Unknown strategy type %d\n", tag->strat_type); 1388 return (ENODEV); 1389 } 1390 1391 switch (le16toh(tag->flags) & 0x7) { 1392 case 0: 1393 /* 1394 * The allocation descriptor field is filled with short_ad's. 1395 * If the offset is beyond the current extent, look for the 1396 * next extent. 1397 */ 1398 do { 1399 offset -= icblen; 1400 ad_offset = sizeof(struct short_ad) * ad_num; 1401 if (ad_offset > le32toh(fentry->l_ad)) { 1402 printf("File offset out of bounds\n"); 1403 return (EINVAL); 1404 } 1405 icb = GETICB(short_ad, fentry, 1406 le32toh(fentry->l_ea) + ad_offset); 1407 icblen = GETICBLEN(short_ad, icb); 1408 ad_num++; 1409 } while(offset >= icblen); 1410 1411 lsector = (offset >> udfmp->bshift) + 1412 le32toh(((struct short_ad *)(icb))->pos); 1413 1414 *max_size = icblen - offset; 1415 1416 break; 1417 case 1: 1418 /* 1419 * The allocation descriptor field is filled with long_ad's 1420 * If the offset is beyond the current extent, look for the 1421 * next extent. 1422 */ 1423 do { 1424 offset -= icblen; 1425 ad_offset = sizeof(struct long_ad) * ad_num; 1426 if (ad_offset > le32toh(fentry->l_ad)) { 1427 printf("File offset out of bounds\n"); 1428 return (EINVAL); 1429 } 1430 icb = GETICB(long_ad, fentry, 1431 le32toh(fentry->l_ea) + ad_offset); 1432 icblen = GETICBLEN(long_ad, icb); 1433 ad_num++; 1434 } while(offset >= icblen); 1435 1436 lsector = (offset >> udfmp->bshift) + 1437 le32toh(((struct long_ad *)(icb))->loc.lb_num); 1438 1439 *max_size = icblen - offset; 1440 1441 break; 1442 case 3: 1443 /* 1444 * This type means that the file *data* is stored in the 1445 * allocation descriptor field of the file entry. 1446 */ 1447 *max_size = 0; 1448 *sector = node->hash_id + udfmp->part_start; 1449 1450 return (UDF_INVALID_BMAP); 1451 case 2: 1452 /* DirectCD does not use extended_ad's */ 1453 default: 1454 printf("Unsupported allocation descriptor %d\n", 1455 tag->flags & 0x7); 1456 return (ENODEV); 1457 } 1458 1459 *sector = lsector + udfmp->part_start; 1460 1461 /* 1462 * Check the sparing table. Each entry represents the beginning of 1463 * a packet. 1464 */ 1465 if (udfmp->s_table != NULL) { 1466 for (i = 0; i< udfmp->s_table_entries; i++) { 1467 p_offset = 1468 lsector - le32toh(udfmp->s_table->entries[i].org); 1469 if ((p_offset < udfmp->p_sectors) && (p_offset >= 0)) { 1470 *sector = 1471 le32toh(udfmp->s_table->entries[i].map) + 1472 p_offset; 1473 break; 1474 } 1475 } 1476 } 1477 1478 return (0); 1479} 1480