Annotation of sys/isofs/udf/udf_vnops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: udf_vnops.c,v 1.27 2007/06/06 17:15:13 deraadt Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org>
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: *
! 28: * $FreeBSD: src/sys/fs/udf/udf_vnops.c,v 1.50 2005/01/28 14:42:16 phk Exp $
! 29: */
! 30:
! 31: /*
! 32: * Ported to OpenBSD by Pedro Martelletto <pedro@openbsd.org> in February 2005.
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/namei.h>
! 38: #include <sys/kernel.h>
! 39: #include <sys/malloc.h>
! 40: #include <sys/mutex.h>
! 41: #include <sys/stat.h>
! 42: #include <sys/buf.h>
! 43: #include <sys/pool.h>
! 44: #include <sys/lock.h>
! 45: #include <sys/mount.h>
! 46: #include <sys/vnode.h>
! 47: #include <sys/dirent.h>
! 48: #include <sys/queue.h>
! 49: #include <sys/unistd.h>
! 50: #include <sys/endian.h>
! 51:
! 52: #include <miscfs/specfs/specdev.h>
! 53:
! 54: #include <isofs/udf/ecma167-udf.h>
! 55: #include <isofs/udf/udf.h>
! 56: #include <isofs/udf/udf_extern.h>
! 57:
! 58: int udf_bmap_internal(struct unode *, off_t, daddr64_t *, uint32_t *);
! 59:
! 60: int (**udf_vnodeop_p)(void *);
! 61: struct vnodeopv_entry_desc udf_vnodeop_entries[] = {
! 62: { &vop_default_desc, vn_default_error },
! 63: { &vop_access_desc, udf_access }, /* access */
! 64: { &vop_bmap_desc, udf_bmap }, /* bmap */
! 65: { &vop_lookup_desc, udf_lookup }, /* lookup */
! 66: { &vop_getattr_desc, udf_getattr }, /* getattr */
! 67: { &vop_open_desc, udf_open }, /* open */
! 68: { &vop_close_desc, udf_close }, /* close */
! 69: { &vop_ioctl_desc, udf_ioctl }, /* ioctl */
! 70: { &vop_read_desc, udf_read }, /* read */
! 71: { &vop_readdir_desc, udf_readdir }, /* readdir */
! 72: { &vop_readlink_desc, udf_readlink }, /* readlink */
! 73: { &vop_inactive_desc, udf_inactive }, /* inactive */
! 74: { &vop_reclaim_desc, udf_reclaim }, /* reclaim */
! 75: { &vop_strategy_desc, udf_strategy }, /* strategy */
! 76: { &vop_lock_desc, udf_lock }, /* lock */
! 77: { &vop_unlock_desc, udf_unlock }, /* unlock */
! 78: { &vop_islocked_desc, udf_islocked }, /* islocked */
! 79: { &vop_print_desc, udf_print }, /* print */
! 80: { NULL, NULL }
! 81: };
! 82: struct vnodeopv_desc udf_vnodeop_opv_desc =
! 83: { &udf_vnodeop_p, udf_vnodeop_entries };
! 84:
! 85: #define UDF_INVALID_BMAP -1
! 86:
! 87: /* Look up a unode based on the ino_t passed in and return its vnode */
! 88: int
! 89: udf_hashlookup(struct umount *ump, ino_t id, int flags, struct vnode **vpp)
! 90: {
! 91: struct unode *up;
! 92: struct udf_hash_lh *lh;
! 93: struct proc *p = curproc;
! 94: int error;
! 95:
! 96: *vpp = NULL;
! 97:
! 98: loop:
! 99: mtx_enter(&ump->um_hashmtx);
! 100: lh = &ump->um_hashtbl[id & ump->um_hashsz];
! 101: if (lh == NULL) {
! 102: mtx_leave(&ump->um_hashmtx);
! 103: return (ENOENT);
! 104: }
! 105:
! 106: LIST_FOREACH(up, lh, u_le) {
! 107: if (up->u_ino == id) {
! 108: mtx_leave(&ump->um_hashmtx);
! 109: error = vget(up->u_vnode, flags, p);
! 110: if (error == ENOENT)
! 111: goto loop;
! 112: if (error)
! 113: return (error);
! 114: *vpp = up->u_vnode;
! 115: return (0);
! 116: }
! 117: }
! 118:
! 119: mtx_leave(&ump->um_hashmtx);
! 120:
! 121: return (0);
! 122: }
! 123:
! 124: int
! 125: udf_hashins(struct unode *up)
! 126: {
! 127: struct umount *ump;
! 128: struct udf_hash_lh *lh;
! 129: struct proc *p = curproc;
! 130:
! 131: ump = up->u_ump;
! 132:
! 133: vn_lock(up->u_vnode, LK_EXCLUSIVE | LK_RETRY, p);
! 134: mtx_enter(&ump->um_hashmtx);
! 135: lh = &ump->um_hashtbl[up->u_ino & ump->um_hashsz];
! 136: if (lh == NULL)
! 137: LIST_INIT(lh);
! 138: LIST_INSERT_HEAD(lh, up, u_le);
! 139: mtx_leave(&ump->um_hashmtx);
! 140:
! 141: return (0);
! 142: }
! 143:
! 144: int
! 145: udf_hashrem(struct unode *up)
! 146: {
! 147: struct umount *ump;
! 148: struct udf_hash_lh *lh;
! 149:
! 150: ump = up->u_ump;
! 151:
! 152: mtx_enter(&ump->um_hashmtx);
! 153: lh = &ump->um_hashtbl[up->u_ino & ump->um_hashsz];
! 154: if (lh == NULL)
! 155: panic("hash entry is NULL, up->u_ino = %d", up->u_ino);
! 156: LIST_REMOVE(up, u_le);
! 157: mtx_leave(&ump->um_hashmtx);
! 158:
! 159: return (0);
! 160: }
! 161:
! 162: int
! 163: udf_allocv(struct mount *mp, struct vnode **vpp, struct proc *p)
! 164: {
! 165: int error;
! 166: struct vnode *vp;
! 167:
! 168: error = getnewvnode(VT_UDF, mp, udf_vnodeop_p, &vp);
! 169: if (error) {
! 170: printf("udf_allocv: failed to allocate new vnode\n");
! 171: return (error);
! 172: }
! 173:
! 174: *vpp = vp;
! 175: return (0);
! 176: }
! 177:
! 178: /* Convert file entry permission (5 bits per owner/group/user) to a mode_t */
! 179: static mode_t
! 180: udf_permtomode(struct unode *up)
! 181: {
! 182: uint32_t perm;
! 183: uint16_t flags;
! 184: mode_t mode;
! 185:
! 186: perm = letoh32(up->u_fentry->perm);
! 187: flags = letoh16(up->u_fentry->icbtag.flags);
! 188:
! 189: mode = perm & UDF_FENTRY_PERM_USER_MASK;
! 190: mode |= ((perm & UDF_FENTRY_PERM_GRP_MASK) >> 2);
! 191: mode |= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4);
! 192: mode |= ((flags & UDF_ICB_TAG_FLAGS_STICKY) << 4);
! 193: mode |= ((flags & UDF_ICB_TAG_FLAGS_SETGID) << 6);
! 194: mode |= ((flags & UDF_ICB_TAG_FLAGS_SETUID) << 8);
! 195:
! 196: return (mode);
! 197: }
! 198:
! 199: int
! 200: udf_access(void *v)
! 201: {
! 202: struct vop_access_args *ap = v;
! 203: struct vnode *vp;
! 204: struct unode *up;
! 205: mode_t a_mode, mode;
! 206:
! 207: vp = ap->a_vp;
! 208: up = VTOU(vp);
! 209: a_mode = ap->a_mode;
! 210:
! 211: if (a_mode & VWRITE) {
! 212: switch (vp->v_type) {
! 213: case VDIR:
! 214: case VLNK:
! 215: case VREG:
! 216: return (EROFS);
! 217: /* NOTREACHED */
! 218: default:
! 219: break;
! 220: }
! 221: }
! 222:
! 223: mode = udf_permtomode(up);
! 224:
! 225: return (vaccess(mode, up->u_fentry->uid, up->u_fentry->gid, a_mode,
! 226: ap->a_cred));
! 227: }
! 228:
! 229: static int mon_lens[2][12] = {
! 230: {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
! 231: {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
! 232: };
! 233:
! 234: static int
! 235: udf_isaleapyear(int year)
! 236: {
! 237: int i;
! 238:
! 239: i = (year % 4) ? 0 : 1;
! 240: i &= (year % 100) ? 1 : 0;
! 241: i |= (year % 400) ? 0 : 1;
! 242:
! 243: return (i);
! 244: }
! 245:
! 246: /*
! 247: * This is just a rough hack. Daylight savings isn't calculated and tv_nsec
! 248: * is ignored.
! 249: * Timezone calculation compliments of Julian Elischer <julian@elischer.org>.
! 250: */
! 251: static void
! 252: udf_timetotimespec(struct timestamp *time, struct timespec *t)
! 253: {
! 254: int i, lpyear, daysinyear, year;
! 255: union {
! 256: uint16_t u_tz_offset;
! 257: int16_t s_tz_offset;
! 258: } tz;
! 259:
! 260: t->tv_nsec = 0;
! 261:
! 262: /* DirectCD seems to like using bogus year values */
! 263: year = letoh16(time->year);
! 264: if (year < 1970) {
! 265: t->tv_sec = 0;
! 266: return;
! 267: }
! 268:
! 269: /* Calculate the time and day */
! 270: t->tv_sec = time->second;
! 271: t->tv_sec += time->minute * 60;
! 272: t->tv_sec += time->hour * 3600;
! 273: t->tv_sec += time->day * 3600 * 24;
! 274:
! 275: /* Calculate the month */
! 276: lpyear = udf_isaleapyear(year);
! 277: for (i = 1; i < time->month; i++)
! 278: t->tv_sec += mon_lens[lpyear][i] * 3600 * 24;
! 279:
! 280: /* Speed up the calculation */
! 281: if (year > 1979)
! 282: t->tv_sec += 315532800;
! 283: if (year > 1989)
! 284: t->tv_sec += 315619200;
! 285: if (year > 1999)
! 286: t->tv_sec += 315532800;
! 287: for (i = 2000; i < year; i++) {
! 288: daysinyear = udf_isaleapyear(i) + 365 ;
! 289: t->tv_sec += daysinyear * 3600 * 24;
! 290: }
! 291:
! 292: /*
! 293: * Calculate the time zone. The timezone is 12 bit signed 2's
! 294: * compliment, so we gotta do some extra magic to handle it right.
! 295: */
! 296: tz.u_tz_offset = letoh16(time->type_tz);
! 297: tz.u_tz_offset &= 0x0fff;
! 298: if (tz.u_tz_offset & 0x0800)
! 299: tz.u_tz_offset |= 0xf000; /* extend the sign to 16 bits */
! 300: if ((time->type_tz & 0x1000) && (tz.s_tz_offset != -2047))
! 301: t->tv_sec -= tz.s_tz_offset * 60;
! 302:
! 303: return;
! 304: }
! 305:
! 306: int
! 307: udf_getattr(void *v)
! 308: {
! 309: struct vop_getattr_args *ap = v;
! 310: struct vnode *vp;
! 311: struct unode *up;
! 312: struct vattr *vap;
! 313: struct file_entry *fentry;
! 314: struct timespec ts;
! 315:
! 316: ts.tv_sec = 0;
! 317:
! 318: vp = ap->a_vp;
! 319: vap = ap->a_vap;
! 320: up = VTOU(vp);
! 321: fentry = up->u_fentry;
! 322:
! 323: vap->va_fsid = up->u_dev;
! 324: vap->va_fileid = up->u_ino;
! 325: vap->va_mode = udf_permtomode(up);
! 326: vap->va_nlink = letoh16(fentry->link_cnt);
! 327: /*
! 328: * The spec says that -1 is valid for uid/gid and indicates an
! 329: * invalid uid/gid. How should this be represented?
! 330: */
! 331: vap->va_uid = (letoh32(fentry->uid) == -1) ? 0 : letoh32(fentry->uid);
! 332: vap->va_gid = (letoh32(fentry->gid) == -1) ? 0 : letoh32(fentry->gid);
! 333: udf_timetotimespec(&fentry->atime, &vap->va_atime);
! 334: udf_timetotimespec(&fentry->mtime, &vap->va_mtime);
! 335: vap->va_ctime = vap->va_mtime; /* Stored as an Extended Attribute */
! 336: vap->va_rdev = 0;
! 337: if (vp->v_type & VDIR) {
! 338: vap->va_nlink++; /* Count a reference to ourselves */
! 339: /*
! 340: * Directories that are recorded within their ICB will show
! 341: * as having 0 blocks recorded. Since tradition dictates
! 342: * that directories consume at least one logical block,
! 343: * make it appear so.
! 344: */
! 345: if (fentry->logblks_rec != 0) {
! 346: vap->va_size =
! 347: letoh64(fentry->logblks_rec) * up->u_ump->um_bsize;
! 348: } else {
! 349: vap->va_size = up->u_ump->um_bsize;
! 350: }
! 351: } else {
! 352: vap->va_size = letoh64(fentry->inf_len);
! 353: }
! 354: vap->va_flags = 0;
! 355: vap->va_gen = 1;
! 356: vap->va_blocksize = up->u_ump->um_bsize;
! 357: vap->va_bytes = letoh64(fentry->inf_len);
! 358: vap->va_type = vp->v_type;
! 359: vap->va_filerev = 0;
! 360:
! 361: return (0);
! 362: }
! 363:
! 364: int
! 365: udf_open(void *v)
! 366: {
! 367: return (0); /* Nothing to be done at this point */
! 368: }
! 369:
! 370: int
! 371: udf_close(void *v)
! 372: {
! 373: return (0); /* Nothing to be done at this point */
! 374: }
! 375:
! 376: /*
! 377: * File specific ioctls.
! 378: */
! 379: int
! 380: udf_ioctl(void *v)
! 381: {
! 382: return (ENOTTY);
! 383: }
! 384:
! 385: /*
! 386: * I'm not sure that this has much value in a read-only filesystem, but
! 387: * cd9660 has it too.
! 388: */
! 389: #if 0
! 390: static int
! 391: udf_pathconf(struct vop_pathconf_args *a)
! 392: {
! 393:
! 394: switch (ap->a_name) {
! 395: case _PC_LINK_MAX:
! 396: *ap->a_retval = 65535;
! 397: return (0);
! 398: case _PC_NAME_MAX:
! 399: *ap->a_retval = NAME_MAX;
! 400: return (0);
! 401: case _PC_PATH_MAX:
! 402: *ap->a_retval = PATH_MAX;
! 403: return (0);
! 404: case _PC_NO_TRUNC:
! 405: *ap->a_retval = 1;
! 406: return (0);
! 407: default:
! 408: return (EINVAL);
! 409: }
! 410: }
! 411: #endif
! 412:
! 413: int
! 414: udf_read(void *v)
! 415: {
! 416: struct vop_read_args *ap = v;
! 417: struct vnode *vp = ap->a_vp;
! 418: struct uio *uio = ap->a_uio;
! 419: struct unode *up = VTOU(vp);
! 420: struct buf *bp;
! 421: uint8_t *data;
! 422: off_t fsize, offset;
! 423: int error = 0;
! 424: int size;
! 425:
! 426: if (uio->uio_offset < 0)
! 427: return (EINVAL);
! 428:
! 429: fsize = letoh64(up->u_fentry->inf_len);
! 430:
! 431: while (uio->uio_offset < fsize && uio->uio_resid > 0) {
! 432: offset = uio->uio_offset;
! 433: if (uio->uio_resid + offset <= fsize)
! 434: size = uio->uio_resid;
! 435: else
! 436: size = fsize - offset;
! 437: error = udf_readatoffset(up, &size, offset, &bp, &data);
! 438: if (error == 0)
! 439: error = uiomove(data, size, uio);
! 440: if (bp != NULL)
! 441: brelse(bp);
! 442: if (error)
! 443: break;
! 444: };
! 445:
! 446: return (error);
! 447: }
! 448:
! 449: /*
! 450: * Translate the name from a CS0 dstring to a 16-bit Unicode String.
! 451: * Hooks need to be placed in here to translate from Unicode to the encoding
! 452: * that the kernel/user expects. Return the length of the translated string.
! 453: */
! 454: int
! 455: udf_transname(char *cs0string, char *destname, int len, struct umount *ump)
! 456: {
! 457: unicode_t *transname;
! 458: int i, unilen = 0, destlen;
! 459:
! 460: if (len > MAXNAMLEN) {
! 461: #ifdef DIAGNOSTIC
! 462: printf("udf_transname(): name too long\n");
! 463: #endif
! 464: return (0);
! 465: }
! 466:
! 467: /* allocate a buffer big enough to hold an 8->16 bit expansion */
! 468: transname = pool_get(&udf_trans_pool, PR_WAITOK);
! 469:
! 470: if ((unilen = udf_rawnametounicode(len, cs0string, transname)) == -1) {
! 471: #ifdef DIAGNOSTIC
! 472: printf("udf_transname(): Unicode translation failed\n");
! 473: #endif
! 474: pool_put(&udf_trans_pool, transname);
! 475: return (0);
! 476: }
! 477:
! 478: /* Pack it back to 8-bit Unicode. */
! 479: for (i = 0; i < unilen ; i++)
! 480: if (transname[i] & 0xff00)
! 481: destname[i] = '?'; /* Fudge the 16bit chars */
! 482: else
! 483: destname[i] = transname[i] & 0xff;
! 484:
! 485: pool_put(&udf_trans_pool, transname);
! 486:
! 487: /* Don't forget to terminate the string. */
! 488: destname[unilen] = 0;
! 489: destlen = unilen;
! 490:
! 491: return (destlen);
! 492: }
! 493:
! 494: /*
! 495: * Compare a CS0 dstring with a name passed in from the VFS layer. Return
! 496: * 0 on a successful match, nonzero otherwise. Unicode work may need to be
! 497: * done here also.
! 498: */
! 499: static int
! 500: udf_cmpname(char *cs0string, char *cmpname, int cs0len, int cmplen, struct umount *ump)
! 501: {
! 502: char *transname;
! 503: int error = 0;
! 504:
! 505: /* This is overkill, but not worth creating a new pool */
! 506: transname = pool_get(&udf_trans_pool, PR_WAITOK);
! 507:
! 508: cs0len = udf_transname(cs0string, transname, cs0len, ump);
! 509:
! 510: /* Easy check. If they aren't the same length, they aren't equal */
! 511: if ((cs0len == 0) || (cs0len != cmplen))
! 512: error = -1;
! 513: else
! 514: error = bcmp(transname, cmpname, cmplen);
! 515:
! 516: pool_put(&udf_trans_pool, transname);
! 517:
! 518: return (error);
! 519: }
! 520:
! 521: struct udf_uiodir {
! 522: struct dirent *dirent;
! 523: u_long *cookies;
! 524: int ncookies;
! 525: int acookies;
! 526: int eofflag;
! 527: };
! 528:
! 529: static int
! 530: udf_uiodir(struct udf_uiodir *uiodir, int de_size, struct uio *uio, long cookie)
! 531: {
! 532: if (uiodir->cookies != NULL) {
! 533: if (++uiodir->acookies > uiodir->ncookies) {
! 534: uiodir->eofflag = 0;
! 535: return (-1);
! 536: }
! 537: *uiodir->cookies++ = cookie;
! 538: }
! 539:
! 540: if (uio->uio_resid < de_size) {
! 541: uiodir->eofflag = 0;
! 542: return (-1);
! 543: }
! 544:
! 545: return (uiomove(uiodir->dirent, de_size, uio));
! 546: }
! 547:
! 548: static struct udf_dirstream *
! 549: udf_opendir(struct unode *up, int offset, int fsize, struct umount *ump)
! 550: {
! 551: struct udf_dirstream *ds;
! 552:
! 553: ds = pool_get(&udf_ds_pool, PR_WAITOK);
! 554: bzero(ds, sizeof(struct udf_dirstream));
! 555:
! 556: ds->node = up;
! 557: ds->offset = offset;
! 558: ds->ump = ump;
! 559: ds->fsize = fsize;
! 560:
! 561: return (ds);
! 562: }
! 563:
! 564: static struct fileid_desc *
! 565: udf_getfid(struct udf_dirstream *ds)
! 566: {
! 567: struct fileid_desc *fid;
! 568: int error, frag_size = 0, total_fid_size;
! 569:
! 570: /* End of directory? */
! 571: if (ds->offset + ds->off >= ds->fsize) {
! 572: ds->error = 0;
! 573: return (NULL);
! 574: }
! 575:
! 576: /* Grab the first extent of the directory */
! 577: if (ds->off == 0) {
! 578: ds->size = 0;
! 579: error = udf_readatoffset(ds->node, &ds->size, ds->offset,
! 580: &ds->bp, &ds->data);
! 581: if (error) {
! 582: ds->error = error;
! 583: if (ds->bp != NULL)
! 584: brelse(ds->bp);
! 585: return (NULL);
! 586: }
! 587: }
! 588:
! 589: /*
! 590: * Clean up from a previous fragmented FID.
! 591: * Is this the right place for this?
! 592: */
! 593: if (ds->fid_fragment && ds->buf != NULL) {
! 594: ds->fid_fragment = 0;
! 595: free(ds->buf, M_UDFFID);
! 596: }
! 597:
! 598: fid = (struct fileid_desc*)&ds->data[ds->off];
! 599:
! 600: /*
! 601: * Check to see if the fid is fragmented. The first test
! 602: * ensures that we don't wander off the end of the buffer
! 603: * looking for the l_iu and l_fi fields.
! 604: */
! 605: if (ds->off + UDF_FID_SIZE > ds->size ||
! 606: ds->off + letoh16(fid->l_iu) + fid->l_fi + UDF_FID_SIZE > ds->size){
! 607:
! 608: /* Copy what we have of the fid into a buffer */
! 609: frag_size = ds->size - ds->off;
! 610: if (frag_size >= ds->ump->um_bsize) {
! 611: printf("udf: invalid FID fragment\n");
! 612: ds->error = EINVAL;
! 613: return (NULL);
! 614: }
! 615:
! 616: /*
! 617: * File ID descriptors can only be at most one
! 618: * logical sector in size.
! 619: */
! 620: ds->buf = malloc(ds->ump->um_bsize, M_UDFFID, M_WAITOK);
! 621: bzero(ds->buf, ds->ump->um_bsize);
! 622: bcopy(fid, ds->buf, frag_size);
! 623:
! 624: /* Reduce all of the casting magic */
! 625: fid = (struct fileid_desc*)ds->buf;
! 626:
! 627: if (ds->bp != NULL)
! 628: brelse(ds->bp);
! 629:
! 630: /* Fetch the next allocation */
! 631: ds->offset += ds->size;
! 632: ds->size = 0;
! 633: error = udf_readatoffset(ds->node, &ds->size, ds->offset,
! 634: &ds->bp, &ds->data);
! 635: if (error) {
! 636: ds->error = error;
! 637: return (NULL);
! 638: }
! 639:
! 640: /*
! 641: * If the fragment was so small that we didn't get
! 642: * the l_iu and l_fi fields, copy those in.
! 643: */
! 644: if (frag_size < UDF_FID_SIZE)
! 645: bcopy(ds->data, &ds->buf[frag_size],
! 646: UDF_FID_SIZE - frag_size);
! 647:
! 648: /*
! 649: * Now that we have enough of the fid to work with,
! 650: * copy in the rest of the fid from the new
! 651: * allocation.
! 652: */
! 653: total_fid_size = UDF_FID_SIZE + letoh16(fid->l_iu) + fid->l_fi;
! 654: if (total_fid_size > ds->ump->um_bsize) {
! 655: printf("udf: invalid FID\n");
! 656: ds->error = EIO;
! 657: return (NULL);
! 658: }
! 659: bcopy(ds->data, &ds->buf[frag_size],
! 660: total_fid_size - frag_size);
! 661:
! 662: ds->fid_fragment = 1;
! 663: } else {
! 664: total_fid_size = letoh16(fid->l_iu) + fid->l_fi + UDF_FID_SIZE;
! 665: }
! 666:
! 667: /*
! 668: * Update the offset. Align on a 4 byte boundary because the
! 669: * UDF spec says so.
! 670: */
! 671: ds->this_off = ds->off;
! 672: if (!ds->fid_fragment) {
! 673: ds->off += (total_fid_size + 3) & ~0x03;
! 674: } else {
! 675: ds->off = (total_fid_size - frag_size + 3) & ~0x03;
! 676: }
! 677:
! 678: return (fid);
! 679: }
! 680:
! 681: static void
! 682: udf_closedir(struct udf_dirstream *ds)
! 683: {
! 684:
! 685: if (ds->bp != NULL)
! 686: brelse(ds->bp);
! 687:
! 688: if (ds->fid_fragment && ds->buf != NULL)
! 689: free(ds->buf, M_UDFFID);
! 690:
! 691: pool_put(&udf_ds_pool, ds);
! 692: }
! 693:
! 694: int
! 695: udf_readdir(void *v)
! 696: {
! 697: struct vop_readdir_args *ap = v;
! 698: struct vnode *vp;
! 699: struct uio *uio;
! 700: struct dirent dir;
! 701: struct unode *up;
! 702: struct umount *ump;
! 703: struct fileid_desc *fid;
! 704: struct udf_uiodir uiodir;
! 705: struct udf_dirstream *ds;
! 706: u_long *cookies = NULL;
! 707: int ncookies;
! 708: int error = 0;
! 709:
! 710: #define GENERIC_DIRSIZ(dp) \
! 711: ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))
! 712:
! 713: vp = ap->a_vp;
! 714: uio = ap->a_uio;
! 715: up = VTOU(vp);
! 716: ump = up->u_ump;
! 717: uiodir.eofflag = 1;
! 718:
! 719: if (ap->a_ncookies != NULL) {
! 720: /*
! 721: * Guess how many entries are needed. If we run out, this
! 722: * function will be called again and thing will pick up were
! 723: * it left off.
! 724: */
! 725: ncookies = uio->uio_resid / 8;
! 726: MALLOC(cookies, u_long *, sizeof(u_long) * ncookies,
! 727: M_TEMP, M_WAITOK);
! 728: uiodir.ncookies = ncookies;
! 729: uiodir.cookies = cookies;
! 730: uiodir.acookies = 0;
! 731: } else {
! 732: uiodir.cookies = NULL;
! 733: }
! 734:
! 735: /*
! 736: * Iterate through the file id descriptors. Give the parent dir
! 737: * entry special attention.
! 738: */
! 739: ds = udf_opendir(up, uio->uio_offset,
! 740: letoh64(up->u_fentry->inf_len), up->u_ump);
! 741:
! 742: while ((fid = udf_getfid(ds)) != NULL) {
! 743:
! 744: /* Should we return an error on a bad fid? */
! 745: if (udf_checktag(&fid->tag, TAGID_FID)) {
! 746: printf("Invalid FID tag\n");
! 747: error = EIO;
! 748: break;
! 749: }
! 750:
! 751: /* Is this a deleted file? */
! 752: if (fid->file_char & UDF_FILE_CHAR_DEL)
! 753: continue;
! 754:
! 755: if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) {
! 756: /* Do up the '.' and '..' entries. Dummy values are
! 757: * used for the cookies since the offset here is
! 758: * usually zero, and NFS doesn't like that value
! 759: */
! 760: dir.d_fileno = up->u_ino;
! 761: dir.d_type = DT_DIR;
! 762: dir.d_name[0] = '.';
! 763: dir.d_name[1] = '\0';
! 764: dir.d_namlen = 1;
! 765: dir.d_reclen = GENERIC_DIRSIZ(&dir);
! 766: uiodir.dirent = &dir;
! 767: error = udf_uiodir(&uiodir, dir.d_reclen, uio, 1);
! 768: if (error)
! 769: break;
! 770:
! 771: dir.d_fileno = udf_getid(&fid->icb);
! 772: dir.d_type = DT_DIR;
! 773: dir.d_name[0] = '.';
! 774: dir.d_name[1] = '.';
! 775: dir.d_name[2] = '\0';
! 776: dir.d_namlen = 2;
! 777: dir.d_reclen = GENERIC_DIRSIZ(&dir);
! 778: uiodir.dirent = &dir;
! 779: error = udf_uiodir(&uiodir, dir.d_reclen, uio, 2);
! 780: } else {
! 781: dir.d_namlen = udf_transname(&fid->data[fid->l_iu],
! 782: &dir.d_name[0], fid->l_fi, ump);
! 783: dir.d_fileno = udf_getid(&fid->icb);
! 784: dir.d_type = (fid->file_char & UDF_FILE_CHAR_DIR) ?
! 785: DT_DIR : DT_UNKNOWN;
! 786: dir.d_reclen = GENERIC_DIRSIZ(&dir);
! 787: uiodir.dirent = &dir;
! 788: error = udf_uiodir(&uiodir, dir.d_reclen, uio,
! 789: ds->this_off);
! 790: }
! 791: if (error) {
! 792: printf("uiomove returned %d\n", error);
! 793: break;
! 794: }
! 795:
! 796: }
! 797:
! 798: #undef GENERIC_DIRSIZ
! 799:
! 800: /* tell the calling layer whether we need to be called again */
! 801: *ap->a_eofflag = uiodir.eofflag;
! 802: uio->uio_offset = ds->offset + ds->off;
! 803:
! 804: if (!error)
! 805: error = ds->error;
! 806:
! 807: udf_closedir(ds);
! 808:
! 809: if (ap->a_ncookies != NULL) {
! 810: if (error)
! 811: FREE(cookies, M_TEMP);
! 812: else {
! 813: *ap->a_ncookies = uiodir.acookies;
! 814: *ap->a_cookies = cookies;
! 815: }
! 816: }
! 817:
! 818: return (error);
! 819: }
! 820:
! 821: /* Are there any implementations out there that do soft-links? */
! 822: int
! 823: udf_readlink(void *v)
! 824: {
! 825: return (EOPNOTSUPP);
! 826: }
! 827:
! 828: int
! 829: udf_strategy(void *v)
! 830: {
! 831: struct vop_strategy_args *ap = v;
! 832: struct buf *bp;
! 833: struct vnode *vp;
! 834: struct unode *up;
! 835: int maxsize, s, error;
! 836:
! 837: bp = ap->a_bp;
! 838: vp = bp->b_vp;
! 839: up = VTOU(vp);
! 840:
! 841: /* cd9660 has this test reversed, but it seems more logical this way */
! 842: if (bp->b_blkno != bp->b_lblkno) {
! 843: /*
! 844: * Files that are embedded in the fentry don't translate well
! 845: * to a block number. Reject.
! 846: */
! 847: if (udf_bmap_internal(up, bp->b_lblkno * up->u_ump->um_bsize,
! 848: &bp->b_lblkno, &maxsize)) {
! 849: clrbuf(bp);
! 850: bp->b_blkno = -1;
! 851: }
! 852: } else {
! 853: error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
! 854: if (error) {
! 855: bp->b_error = error;
! 856: bp->b_flags |= B_ERROR;
! 857: s = splbio();
! 858: biodone(bp);
! 859: splx(s);
! 860: return (error);
! 861: }
! 862:
! 863: if ((long)bp->b_blkno == -1)
! 864: clrbuf(bp);
! 865: }
! 866:
! 867: if ((long)bp->b_blkno == -1) {
! 868: s = splbio();
! 869: biodone(bp);
! 870: splx(s);
! 871: } else {
! 872: bp->b_dev = vp->v_rdev;
! 873: VOCALL(up->u_devvp->v_op, VOFFSET(vop_strategy), ap);
! 874: }
! 875:
! 876: return (0);
! 877: }
! 878:
! 879: int
! 880: udf_lock(void *v)
! 881: {
! 882: struct vop_lock_args *ap = v;
! 883:
! 884: struct vnode *vp = ap->a_vp;
! 885:
! 886: return (lockmgr(&VTOU(vp)->u_lock, ap->a_flags, NULL));
! 887: }
! 888:
! 889: int
! 890: udf_unlock(void *v)
! 891: {
! 892: struct vop_unlock_args *ap = v;
! 893:
! 894: struct vnode *vp = ap->a_vp;
! 895:
! 896: return (lockmgr(&VTOU(vp)->u_lock, ap->a_flags | LK_RELEASE, NULL));
! 897: }
! 898:
! 899: int
! 900: udf_islocked(void *v)
! 901: {
! 902: struct vop_islocked_args *ap = v;
! 903:
! 904: return (lockstatus(&VTOU(ap->a_vp)->u_lock));
! 905: }
! 906:
! 907: int
! 908: udf_print(void *v)
! 909: {
! 910: struct vop_print_args *ap = v;
! 911: struct vnode *vp = ap->a_vp;
! 912: struct unode *up = VTOU(vp);
! 913:
! 914: /*
! 915: * Complete the information given by vprint().
! 916: */
! 917: printf("tag VT_UDF, hash id %u\n", up->u_ino);
! 918: #ifdef DIAGNOSTIC
! 919: lockmgr_printinfo(&up->u_lock);
! 920: printf("\n");
! 921: #endif
! 922: return (0);
! 923: }
! 924:
! 925: int
! 926: udf_bmap(void *v)
! 927: {
! 928: struct vop_bmap_args *ap = v;
! 929: struct unode *up;
! 930: uint32_t max_size;
! 931: daddr64_t lsector;
! 932: int error;
! 933:
! 934: up = VTOU(ap->a_vp);
! 935:
! 936: if (ap->a_vpp != NULL)
! 937: *ap->a_vpp = up->u_devvp;
! 938: if (ap->a_bnp == NULL)
! 939: return (0);
! 940:
! 941: error = udf_bmap_internal(up, ap->a_bn * up->u_ump->um_bsize,
! 942: &lsector, &max_size);
! 943: if (error)
! 944: return (error);
! 945:
! 946: /* Translate logical to physical sector number */
! 947: *ap->a_bnp = lsector << (up->u_ump->um_bshift - DEV_BSHIFT);
! 948:
! 949: /* Punt on read-ahead for now */
! 950: if (ap->a_runp)
! 951: *ap->a_runp = 0;
! 952:
! 953: return (0);
! 954: }
! 955:
! 956: /*
! 957: * The all powerful VOP_LOOKUP().
! 958: */
! 959: int
! 960: udf_lookup(void *v)
! 961: {
! 962: struct vop_lookup_args *ap = v;
! 963: struct vnode *dvp;
! 964: struct vnode *tdp = NULL;
! 965: struct vnode **vpp = ap->a_vpp;
! 966: struct unode *up;
! 967: struct umount *ump;
! 968: struct fileid_desc *fid = NULL;
! 969: struct udf_dirstream *ds;
! 970: struct proc *p;
! 971: u_long nameiop;
! 972: u_long flags;
! 973: char *nameptr;
! 974: long namelen;
! 975: ino_t id = 0;
! 976: int offset, error = 0;
! 977: int numdirpasses, fsize;
! 978:
! 979: extern struct nchstats nchstats;
! 980:
! 981: dvp = ap->a_dvp;
! 982: up = VTOU(dvp);
! 983: ump = up->u_ump;
! 984: nameiop = ap->a_cnp->cn_nameiop;
! 985: flags = ap->a_cnp->cn_flags;
! 986: nameptr = ap->a_cnp->cn_nameptr;
! 987: namelen = ap->a_cnp->cn_namelen;
! 988: fsize = letoh64(up->u_fentry->inf_len);
! 989: p = ap->a_cnp->cn_proc;
! 990: *vpp = NULL;
! 991:
! 992: /*
! 993: * Make sure the process can scan the requested directory.
! 994: */
! 995: error = VOP_ACCESS(dvp, VEXEC, ap->a_cnp->cn_cred, p);
! 996: if (error)
! 997: return (error);
! 998:
! 999: /*
! 1000: * Check if the (directory, name) tuple has been already cached.
! 1001: */
! 1002: error = cache_lookup(dvp, vpp, ap->a_cnp);
! 1003: if (error >= 0)
! 1004: return (error);
! 1005: else
! 1006: error = 0;
! 1007:
! 1008: /*
! 1009: * If dvp is what's being looked up, then return it.
! 1010: */
! 1011: if (ap->a_cnp->cn_namelen == 1 && ap->a_cnp->cn_nameptr[0] == '.') {
! 1012: VREF(dvp);
! 1013: *vpp = dvp;
! 1014: return (0);
! 1015: }
! 1016:
! 1017: /*
! 1018: * If this is a LOOKUP and we've already partially searched through
! 1019: * the directory, pick up where we left off and flag that the
! 1020: * directory may need to be searched twice. For a full description,
! 1021: * see /sys/isofs/cd9660/cd9660_lookup.c:cd9660_lookup()
! 1022: */
! 1023: if (nameiop != LOOKUP || up->u_diroff == 0 || up->u_diroff > fsize) {
! 1024: offset = 0;
! 1025: numdirpasses = 1;
! 1026: } else {
! 1027: offset = up->u_diroff;
! 1028: numdirpasses = 2;
! 1029: nchstats.ncs_2passes++;
! 1030: }
! 1031:
! 1032: lookloop:
! 1033: ds = udf_opendir(up, offset, fsize, ump);
! 1034:
! 1035: while ((fid = udf_getfid(ds)) != NULL) {
! 1036: /* Check for a valid FID tag. */
! 1037: if (udf_checktag(&fid->tag, TAGID_FID)) {
! 1038: printf("udf_lookup: Invalid tag\n");
! 1039: error = EIO;
! 1040: break;
! 1041: }
! 1042:
! 1043: /* Is this a deleted file? */
! 1044: if (fid->file_char & UDF_FILE_CHAR_DEL)
! 1045: continue;
! 1046:
! 1047: if ((fid->l_fi == 0) && (fid->file_char & UDF_FILE_CHAR_PAR)) {
! 1048: if (flags & ISDOTDOT) {
! 1049: id = udf_getid(&fid->icb);
! 1050: break;
! 1051: }
! 1052: } else {
! 1053: if (!(udf_cmpname(&fid->data[fid->l_iu],
! 1054: nameptr, fid->l_fi, namelen, ump))) {
! 1055: id = udf_getid(&fid->icb);
! 1056: break;
! 1057: }
! 1058: }
! 1059: }
! 1060:
! 1061: if (!error)
! 1062: error = ds->error;
! 1063:
! 1064: if (error) {
! 1065: udf_closedir(ds);
! 1066: return (error);
! 1067: }
! 1068:
! 1069: /* Did we have a match? */
! 1070: if (id) {
! 1071: error = udf_vget(ump->um_mountp, id, &tdp);
! 1072: if (!error) {
! 1073: /*
! 1074: * Remember where this entry was if it's the final
! 1075: * component.
! 1076: */
! 1077: if ((flags & ISLASTCN) && nameiop == LOOKUP)
! 1078: up->u_diroff = ds->offset + ds->off;
! 1079: if (numdirpasses == 2)
! 1080: nchstats.ncs_pass2++;
! 1081: if (!(flags & LOCKPARENT) || !(flags & ISLASTCN)) {
! 1082: ap->a_cnp->cn_flags |= PDIRUNLOCK;
! 1083: VOP_UNLOCK(dvp, 0, p);
! 1084: }
! 1085:
! 1086: *vpp = tdp;
! 1087: }
! 1088: } else {
! 1089: /* Name wasn't found on this pass. Do another pass? */
! 1090: if (numdirpasses == 2) {
! 1091: numdirpasses--;
! 1092: offset = 0;
! 1093: udf_closedir(ds);
! 1094: goto lookloop;
! 1095: }
! 1096:
! 1097: if ((flags & ISLASTCN) &&
! 1098: (nameiop == CREATE || nameiop == RENAME)) {
! 1099: error = EROFS;
! 1100: } else {
! 1101: error = ENOENT;
! 1102: }
! 1103: }
! 1104:
! 1105: /*
! 1106: * Cache the result of this lookup.
! 1107: */
! 1108: if (flags & MAKEENTRY)
! 1109: cache_enter(dvp, *vpp, ap->a_cnp);
! 1110:
! 1111: udf_closedir(ds);
! 1112:
! 1113: return (error);
! 1114: }
! 1115:
! 1116: int
! 1117: udf_inactive(void *v)
! 1118: {
! 1119: struct vop_inactive_args *ap = v;
! 1120: struct vnode *vp = ap->a_vp;
! 1121: struct proc *p = ap->a_p;
! 1122:
! 1123: /*
! 1124: * No need to sync anything, so just unlock the vnode and return.
! 1125: */
! 1126: VOP_UNLOCK(vp, 0, p);
! 1127:
! 1128: return (0);
! 1129: }
! 1130:
! 1131: int
! 1132: udf_reclaim(void *v)
! 1133: {
! 1134: struct vop_reclaim_args *ap = v;
! 1135: struct vnode *vp;
! 1136: struct unode *up;
! 1137:
! 1138: vp = ap->a_vp;
! 1139: up = VTOU(vp);
! 1140:
! 1141: if (up != NULL) {
! 1142: udf_hashrem(up);
! 1143: if (up->u_devvp) {
! 1144: vrele(up->u_devvp);
! 1145: up->u_devvp = 0;
! 1146: }
! 1147:
! 1148: if (up->u_fentry != NULL)
! 1149: free(up->u_fentry, M_UDFFENTRY);
! 1150:
! 1151: pool_put(&unode_pool, up);
! 1152: vp->v_data = NULL;
! 1153: }
! 1154:
! 1155: return (0);
! 1156: }
! 1157:
! 1158: /*
! 1159: * Read the block and then set the data pointer to correspond with the
! 1160: * offset passed in. Only read in at most 'size' bytes, and then set 'size'
! 1161: * to the number of bytes pointed to. If 'size' is zero, try to read in a
! 1162: * whole extent.
! 1163: *
! 1164: * Note that *bp may be assigned error or not.
! 1165: *
! 1166: */
! 1167: int
! 1168: udf_readatoffset(struct unode *up, int *size, off_t offset,
! 1169: struct buf **bp, uint8_t **data)
! 1170: {
! 1171: struct umount *ump;
! 1172: struct file_entry *fentry = NULL;
! 1173: struct buf *bp1;
! 1174: uint32_t max_size;
! 1175: daddr64_t sector;
! 1176: int error;
! 1177:
! 1178: ump = up->u_ump;
! 1179:
! 1180: *bp = NULL;
! 1181: error = udf_bmap_internal(up, offset, §or, &max_size);
! 1182: if (error == UDF_INVALID_BMAP) {
! 1183: /*
! 1184: * This error means that the file *data* is stored in the
! 1185: * allocation descriptor field of the file entry.
! 1186: */
! 1187: fentry = up->u_fentry;
! 1188: *data = &fentry->data[letoh32(fentry->l_ea)];
! 1189: *size = letoh32(fentry->l_ad);
! 1190: return (0);
! 1191: } else if (error != 0) {
! 1192: return (error);
! 1193: }
! 1194:
! 1195: /* Adjust the size so that it is within range */
! 1196: if (*size == 0 || *size > max_size)
! 1197: *size = max_size;
! 1198: *size = min(*size, MAXBSIZE);
! 1199:
! 1200: if ((error = udf_readlblks(ump, sector, *size, bp))) {
! 1201: printf("warning: udf_readlblks returned error %d\n", error);
! 1202: /* note: *bp may be non-NULL */
! 1203: return (error);
! 1204: }
! 1205:
! 1206: bp1 = *bp;
! 1207: *data = (uint8_t *)&bp1->b_data[offset % ump->um_bsize];
! 1208: return (0);
! 1209: }
! 1210:
! 1211: /*
! 1212: * Translate a file offset into a logical block and then into a physical
! 1213: * block.
! 1214: */
! 1215: int
! 1216: udf_bmap_internal(struct unode *up, off_t offset, daddr64_t *sector,
! 1217: uint32_t *max_size)
! 1218: {
! 1219: struct umount *ump;
! 1220: struct file_entry *fentry;
! 1221: void *icb;
! 1222: struct icb_tag *tag;
! 1223: uint32_t icblen = 0;
! 1224: daddr64_t lsector;
! 1225: int ad_offset, ad_num = 0;
! 1226: int i, p_offset;
! 1227:
! 1228: ump = up->u_ump;
! 1229: fentry = up->u_fentry;
! 1230: tag = &fentry->icbtag;
! 1231:
! 1232: switch (letoh16(tag->strat_type)) {
! 1233: case 4:
! 1234: break;
! 1235:
! 1236: case 4096:
! 1237: printf("Cannot deal with strategy4096 yet!\n");
! 1238: return (ENODEV);
! 1239:
! 1240: default:
! 1241: printf("Unknown strategy type %d\n", tag->strat_type);
! 1242: return (ENODEV);
! 1243: }
! 1244:
! 1245: switch (letoh16(tag->flags) & 0x7) {
! 1246: case 0:
! 1247: /*
! 1248: * The allocation descriptor field is filled with short_ad's.
! 1249: * If the offset is beyond the current extent, look for the
! 1250: * next extent.
! 1251: */
! 1252: do {
! 1253: offset -= icblen;
! 1254: ad_offset = sizeof(struct short_ad) * ad_num;
! 1255: if (ad_offset > letoh32(fentry->l_ad)) {
! 1256: printf("File offset out of bounds\n");
! 1257: return (EINVAL);
! 1258: }
! 1259: icb = GETICB(short_ad, fentry,
! 1260: letoh32(fentry->l_ea) + ad_offset);
! 1261: icblen = GETICBLEN(short_ad, icb);
! 1262: ad_num++;
! 1263: } while(offset >= icblen);
! 1264:
! 1265: lsector = (offset >> ump->um_bshift) +
! 1266: letoh32(((struct short_ad *)(icb))->pos);
! 1267:
! 1268: *max_size = GETICBLEN(short_ad, icb);
! 1269:
! 1270: break;
! 1271: case 1:
! 1272: /*
! 1273: * The allocation descriptor field is filled with long_ad's
! 1274: * If the offset is beyond the current extent, look for the
! 1275: * next extent.
! 1276: */
! 1277: do {
! 1278: offset -= icblen;
! 1279: ad_offset = sizeof(struct long_ad) * ad_num;
! 1280: if (ad_offset > letoh32(fentry->l_ad)) {
! 1281: printf("File offset out of bounds\n");
! 1282: return (EINVAL);
! 1283: }
! 1284: icb = GETICB(long_ad, fentry,
! 1285: letoh32(fentry->l_ea) + ad_offset);
! 1286: icblen = GETICBLEN(long_ad, icb);
! 1287: ad_num++;
! 1288: } while(offset >= icblen);
! 1289:
! 1290: lsector = (offset >> ump->um_bshift) +
! 1291: letoh32(((struct long_ad *)(icb))->loc.lb_num);
! 1292:
! 1293: *max_size = GETICBLEN(long_ad, icb);
! 1294:
! 1295: break;
! 1296: case 3:
! 1297: /*
! 1298: * This type means that the file *data* is stored in the
! 1299: * allocation descriptor field of the file entry.
! 1300: */
! 1301: *max_size = 0;
! 1302: *sector = up->u_ino + ump->um_start;
! 1303:
! 1304: return (UDF_INVALID_BMAP);
! 1305: case 2:
! 1306: /* DirectCD does not use extended_ad's */
! 1307: default:
! 1308: printf("Unsupported allocation descriptor %d\n",
! 1309: tag->flags & 0x7);
! 1310: return (ENODEV);
! 1311: }
! 1312:
! 1313: *sector = lsector + ump->um_start;
! 1314:
! 1315: /*
! 1316: * Check the sparing table. Each entry represents the beginning of
! 1317: * a packet.
! 1318: */
! 1319: if (ump->um_stbl != NULL) {
! 1320: for (i = 0; i< ump->um_stbl_len; i++) {
! 1321: p_offset =
! 1322: lsector - letoh32(ump->um_stbl->entries[i].org);
! 1323: if ((p_offset < ump->um_psecs) && (p_offset >= 0)) {
! 1324: *sector =
! 1325: letoh32(ump->um_stbl->entries[i].map) +
! 1326: p_offset;
! 1327: break;
! 1328: }
! 1329: }
! 1330: }
! 1331:
! 1332: return (0);
! 1333: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to udf_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / isofs / udf