[BACK]Return to cd9660_lookup.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / fs / cd9660

Annotation of src/sys/fs/cd9660/cd9660_lookup.c, Revision 1.24

1.24    ! dholland    1: /*     $NetBSD: cd9660_lookup.c,v 1.23 2012/12/20 08:03:42 hannken Exp $       */
1.1       jdolecek    2:
                      3: /*-
                      4:  * Copyright (c) 1989, 1993, 1994
                      5:  *     The Regents of the University of California.  All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to Berkeley
                      8:  * by Pace Willisson (pace@blitz.com).  The Rock Ridge Extension
                      9:  * Support code is derived from software contributed to Berkeley
                     10:  * by Atsushi Murai (amurai@spec.co.jp).
                     11:  *
                     12:  * Redistribution and use in source and binary forms, with or without
                     13:  * modification, are permitted provided that the following conditions
                     14:  * are met:
                     15:  * 1. Redistributions of source code must retain the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer.
                     17:  * 2. Redistributions in binary form must reproduce the above copyright
                     18:  *    notice, this list of conditions and the following disclaimer in the
                     19:  *    documentation and/or other materials provided with the distribution.
1.6       agc        20:  * 3. Neither the name of the University nor the names of its contributors
1.1       jdolecek   21:  *    may be used to endorse or promote products derived from this software
                     22:  *    without specific prior written permission.
                     23:  *
                     24:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     25:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     26:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     27:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     28:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     29:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     30:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     31:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     32:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     33:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     34:  * SUCH DAMAGE.
                     35:  *
                     36:  *     from: @(#)ufs_lookup.c  7.33 (Berkeley) 5/19/91
                     37:  *
                     38:  *     @(#)cd9660_lookup.c     8.5 (Berkeley) 5/27/95
                     39:  */
                     40:
                     41: #include <sys/cdefs.h>
1.24    ! dholland   42: __KERNEL_RCSID(0, "$NetBSD: cd9660_lookup.c,v 1.23 2012/12/20 08:03:42 hannken Exp $");
1.1       jdolecek   43:
                     44: #include <sys/param.h>
                     45: #include <sys/namei.h>
                     46: #include <sys/buf.h>
                     47: #include <sys/file.h>
                     48: #include <sys/vnode.h>
                     49: #include <sys/mount.h>
                     50: #include <sys/systm.h>
1.11      elad       51: #include <sys/kauth.h>
1.1       jdolecek   52:
                     53: #include <fs/cd9660/iso.h>
                     54: #include <fs/cd9660/cd9660_extern.h>
                     55: #include <fs/cd9660/cd9660_node.h>
                     56: #include <fs/cd9660/iso_rrip.h>
                     57: #include <fs/cd9660/cd9660_rrip.h>
                     58: #include <fs/cd9660/cd9660_mount.h>
                     59:
                     60: struct nchstats iso_nchstats;
                     61:
                     62: /*
                     63:  * Convert a component of a pathname into a pointer to a locked inode.
                     64:  * This is a very central and rather complicated routine.
                     65:  * If the file system is not maintained in a strict tree hierarchy,
                     66:  * this can result in a deadlock situation (see comments in code below).
                     67:  *
                     68:  * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
                     69:  * whether the name is to be looked up, created, renamed, or deleted.
                     70:  * When CREATE, RENAME, or DELETE is specified, information usable in
                     71:  * creating, renaming, or deleting a directory entry may be calculated.
1.12      chs        72:  * If the target of the pathname exists, lookup returns both the target
                     73:  * and its parent directory locked.
                     74:  * When creating or renaming, the target may * not be ".".
                     75:  * When deleting , the target may be "."., but the caller must check
                     76:  * to ensure it does an vrele and vput instead of two vputs.
1.1       jdolecek   77:  *
                     78:  * Overall outline of ufs_lookup:
                     79:  *
                     80:  *     check accessibility of directory
                     81:  *     look for name in cache, if found, then if at end of path
                     82:  *       and deleting or creating, drop it, else return name
                     83:  *     search for name in directory, to found or notfound
                     84:  * notfound:
                     85:  *     if creating, return locked directory, leaving info on available slots
                     86:  *     else return error
                     87:  * found:
                     88:  *     if at end of path and deleting, return information to allow delete
1.12      chs        89:  *     if at end of path and rewriting (RENAME), lock target
1.1       jdolecek   90:  *       inode and return info to allow rewrite
                     91:  *     if not at end, add name to cache; if at end and neither creating
                     92:  *       nor deleting, add name to cache
                     93:  */
                     94: int
1.15      matt       95: cd9660_lookup(void *v)
1.1       jdolecek   96: {
                     97:        struct vop_lookup_args /* {
                     98:                struct vnode *a_dvp;
                     99:                struct vnode **a_vpp;
                    100:                struct componentname *a_cnp;
                    101:        } */ *ap = v;
                    102:        struct vnode *vdp;              /* vnode for directory being searched */
                    103:        struct iso_node *dp;            /* inode for directory being searched */
                    104:        struct iso_mnt *imp;            /* file system that directory is in */
                    105:        struct buf *bp;                 /* a buffer of directory entries */
                    106:        struct iso_directory_record *ep = NULL;
                    107:                                        /* the current directory entry */
                    108:        int entryoffsetinblock;         /* offset of ep in bp's buffer */
                    109:        int saveoffset = -1;            /* offset of last directory entry in dir */
                    110:        int numdirpasses;               /* strategy for directory search */
                    111:        doff_t endsearch;               /* offset to end directory search */
                    112:        struct vnode *pdp;              /* saved dp during symlink work */
                    113:        struct vnode *tdp;              /* returned by cd9660_vget_internal */
                    114:        u_long bmask;                   /* block offset mask */
                    115:        int error;
                    116:        ino_t ino = 0;
                    117:        int reclen;
                    118:        u_short namelen;
1.19      christos  119:        char altname[ISO_MAXNAMLEN];
1.1       jdolecek  120:        int res;
                    121:        int assoc, len;
                    122:        const char *name;
                    123:        struct vnode **vpp = ap->a_vpp;
                    124:        struct componentname *cnp = ap->a_cnp;
1.11      elad      125:        kauth_cred_t cred = cnp->cn_cred;
1.1       jdolecek  126:        int flags;
                    127:        int nameiop = cnp->cn_nameiop;
1.7       perry     128:
1.1       jdolecek  129:        flags = cnp->cn_flags;
                    130:
                    131:        bp = NULL;
                    132:        *vpp = NULL;
                    133:        vdp = ap->a_dvp;
                    134:        dp = VTOI(vdp);
                    135:        imp = dp->i_mnt;
1.7       perry     136:
1.1       jdolecek  137:        /*
                    138:         * Check accessiblity of directory.
                    139:         */
1.14      pooka     140:        if ((error = VOP_ACCESS(vdp, VEXEC, cred)) != 0)
1.1       jdolecek  141:                return (error);
                    142:
                    143:        if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
                    144:            (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
                    145:                return (EROFS);
                    146:
                    147:        /*
                    148:         * We now have a segment name to search for, and a directory to search.
                    149:         *
                    150:         * Before tediously performing a linear scan of the directory,
                    151:         * check the name cache to see if the directory/name pair
                    152:         * we are looking for is known already.
                    153:         */
1.22      dholland  154:        if (cache_lookup(vdp, cnp->cn_nameptr, cnp->cn_namelen,
                    155:                         cnp->cn_nameiop, cnp->cn_flags, NULL, vpp)) {
1.21      dholland  156:                return *vpp == NULLVP ? ENOENT : 0;
                    157:        }
1.7       perry     158:
1.1       jdolecek  159:        len = cnp->cn_namelen;
                    160:        name = cnp->cn_nameptr;
                    161:        /*
                    162:         * A leading `=' means, we are looking for an associated file
                    163:         */
                    164:        assoc = (imp->iso_ftype != ISO_FTYPE_RRIP && *name == ASSOCCHAR);
                    165:        if (assoc) {
                    166:                len--;
                    167:                name++;
                    168:        }
1.7       perry     169:
1.1       jdolecek  170:        /*
                    171:         * If there is cached information on a previous search of
                    172:         * this directory, pick up where we last left off.
                    173:         * We cache only lookups as these are the most common
                    174:         * and have the greatest payoff. Caching CREATE has little
                    175:         * benefit as it usually must search the entire directory
                    176:         * to determine that the entry does not exist. Caching the
                    177:         * location of the last DELETE or RENAME has not reduced
                    178:         * profiling time and hence has been removed in the interest
                    179:         * of simplicity.
                    180:         */
                    181:        bmask = imp->im_bmask;
                    182:        if (nameiop != LOOKUP || dp->i_diroff == 0 ||
                    183:            dp->i_diroff > dp->i_size) {
                    184:                entryoffsetinblock = 0;
                    185:                dp->i_offset = 0;
                    186:                numdirpasses = 1;
                    187:        } else {
                    188:                dp->i_offset = dp->i_diroff;
                    189:                if ((entryoffsetinblock = dp->i_offset & bmask) &&
1.8       yamt      190:                    (error = cd9660_blkatoff(vdp, (off_t)dp->i_offset, NULL,
                    191:                    &bp)))
1.1       jdolecek  192:                                return (error);
                    193:                numdirpasses = 2;
                    194:                iso_nchstats.ncs_2passes++;
                    195:        }
                    196:        endsearch = dp->i_size;
1.7       perry     197:
1.1       jdolecek  198: searchloop:
                    199:        while (dp->i_offset < endsearch) {
                    200:                /*
                    201:                 * If offset is on a block boundary,
                    202:                 * read the next directory block.
                    203:                 * Release previous if it exists.
                    204:                 */
                    205:                if ((dp->i_offset & bmask) == 0) {
                    206:                        if (bp != NULL)
1.13      ad        207:                                brelse(bp, 0);
1.8       yamt      208:                        error = cd9660_blkatoff(vdp, (off_t)dp->i_offset,
1.1       jdolecek  209:                                             NULL, &bp);
                    210:                        if (error)
                    211:                                return (error);
                    212:                        entryoffsetinblock = 0;
                    213:                }
                    214:                /*
                    215:                 * Get pointer to next entry.
                    216:                 */
1.10      christos  217:                KASSERT(bp != NULL);
1.1       jdolecek  218:                ep = (struct iso_directory_record *)
                    219:                        ((char *)bp->b_data + entryoffsetinblock);
1.7       perry     220:
1.1       jdolecek  221:                reclen = isonum_711(ep->length);
                    222:                if (reclen == 0) {
                    223:                        /* skip to next block, if any */
                    224:                        dp->i_offset =
                    225:                            (dp->i_offset & ~bmask) + imp->logical_block_size;
                    226:                        continue;
                    227:                }
1.7       perry     228:
1.1       jdolecek  229:                if (reclen < ISO_DIRECTORY_RECORD_SIZE)
                    230:                        /* illegal entry, stop */
                    231:                        break;
1.7       perry     232:
1.1       jdolecek  233:                if (entryoffsetinblock + reclen > imp->logical_block_size)
                    234:                        /* entries are not allowed to cross boundaries */
                    235:                        break;
1.7       perry     236:
1.1       jdolecek  237:                namelen = isonum_711(ep->name_len);
1.7       perry     238:
1.1       jdolecek  239:                if (reclen < ISO_DIRECTORY_RECORD_SIZE + namelen)
                    240:                        /* illegal entry, stop */
                    241:                        break;
1.7       perry     242:
1.1       jdolecek  243:                /*
                    244:                 * Check for a name match.
                    245:                 */
                    246:                switch (imp->iso_ftype) {
                    247:                default:
                    248:                        if ((!(isonum_711(ep->flags)&4)) == !assoc) {
                    249:                                if ((len == 1
                    250:                                     && *name == '.')
                    251:                                    || (flags & ISDOTDOT)) {
                    252:                                        if (namelen == 1
                    253:                                            && ep->name[0] == ((flags & ISDOTDOT) ? 1 : 0)) {
                    254:                                                /*
                    255:                                                 * Save directory entry's inode number and
                    256:                                                 * release directory buffer.
                    257:                                                 */
                    258:                                                dp->i_ino = isodirino(ep, imp);
                    259:                                                goto found;
                    260:                                        }
                    261:                                        if (namelen != 1
                    262:                                            || ep->name[0] != 0)
                    263:                                                goto notfound;
                    264:                                } else if (!(res = isofncmp(name,len,
                    265:                                                   ep->name,namelen,
                    266:                                                   imp->im_joliet_level))) {
                    267:                                        if (isonum_711(ep->flags)&2)
                    268:                                                ino = isodirino(ep, imp);
                    269:                                        else
                    270:                                                ino = dbtob(bp->b_blkno)
                    271:                                                        + entryoffsetinblock;
                    272:                                        saveoffset = dp->i_offset;
                    273:                                } else if (ino)
                    274:                                        goto foundino;
                    275: #ifdef NOSORTBUG       /* On some CDs directory entries are not sorted correctly */
                    276:                                else if (res < 0)
                    277:                                        goto notfound;
                    278:                                else if (res > 0 && numdirpasses == 2)
                    279:                                        numdirpasses++;
                    280: #endif
                    281:                        }
                    282:                        break;
                    283:                case ISO_FTYPE_RRIP:
                    284:                        if (isonum_711(ep->flags)&2)
                    285:                                ino = isodirino(ep, imp);
                    286:                        else
                    287:                                ino = dbtob(bp->b_blkno) + entryoffsetinblock;
                    288:                        dp->i_ino = ino;
                    289:                        cd9660_rrip_getname(ep,altname,&namelen,&dp->i_ino,imp);
                    290:                        if (namelen == cnp->cn_namelen) {
                    291:                                if (imp->im_flags & ISOFSMNT_RRCASEINS) {
                    292:                                        if (strncasecmp(name, altname, namelen) == 0)
                    293:                                                goto found;
                    294:                                } else {
                    295:                                        if (memcmp(name, altname, namelen) == 0)
                    296:                                                goto found;
                    297:                                }
                    298:                        }
                    299:                        ino = 0;
                    300:                        break;
                    301:                }
                    302:                dp->i_offset += reclen;
                    303:                entryoffsetinblock += reclen;
                    304:        }
                    305:        if (ino) {
                    306: foundino:
                    307:                dp->i_ino = ino;
                    308:                if (saveoffset != dp->i_offset) {
                    309:                        if (lblkno(imp, dp->i_offset) !=
                    310:                            lblkno(imp, saveoffset)) {
                    311:                                if (bp != NULL)
1.13      ad        312:                                        brelse(bp, 0);
1.8       yamt      313:                                if ((error = cd9660_blkatoff(vdp,
1.1       jdolecek  314:                                            (off_t)saveoffset, NULL, &bp)) != 0)
                    315:                                        return (error);
                    316:                        }
                    317:                        entryoffsetinblock = saveoffset & bmask;
                    318:                        ep = (struct iso_directory_record *)
                    319:                                ((char *)bp->b_data + entryoffsetinblock);
                    320:                        dp->i_offset = saveoffset;
                    321:                }
                    322:                goto found;
                    323:        }
                    324: notfound:
                    325:        /*
                    326:         * If we started in the middle of the directory and failed
                    327:         * to find our target, we must check the beginning as well.
                    328:         */
                    329:        if (numdirpasses == 2) {
                    330:                numdirpasses--;
                    331:                dp->i_offset = 0;
                    332:                endsearch = dp->i_diroff;
                    333:                goto searchloop;
                    334:        }
                    335:        if (bp != NULL)
1.13      ad        336:                brelse(bp, 0);
1.1       jdolecek  337:
                    338:        /*
                    339:         * Insert name into cache (as non-existent) if appropriate.
                    340:         */
1.22      dholland  341:        cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
1.20      rmind     342:        return (nameiop == CREATE || nameiop == RENAME) ? EROFS : ENOENT;
1.7       perry     343:
1.1       jdolecek  344: found:
                    345:        if (numdirpasses == 2)
                    346:                iso_nchstats.ncs_pass2++;
1.7       perry     347:
1.1       jdolecek  348:        /*
                    349:         * Found component in pathname.
                    350:         * If the final component of path name, save information
                    351:         * in the cache as to where the entry was found.
                    352:         */
                    353:        if ((flags & ISLASTCN) && nameiop == LOOKUP)
                    354:                dp->i_diroff = dp->i_offset;
1.7       perry     355:
1.1       jdolecek  356:        /*
                    357:         * Step through the translation in the name.  We do not `iput' the
                    358:         * directory because we may need it again if a symbolic link
                    359:         * is relative to the current directory.  Instead we save it
                    360:         * unlocked as "pdp".  We must get the target inode before unlocking
                    361:         * the directory to insure that the inode will not be removed
                    362:         * before we get it.  We prevent deadlock by always fetching
                    363:         * inodes from the root, moving down the directory tree. Thus
                    364:         * when following backward pointers ".." we must unlock the
                    365:         * parent directory before getting the requested directory.
                    366:         * There is a potential race condition here if both the current
                    367:         * and parent directories are removed before the `iget' for the
                    368:         * inode associated with ".." returns.  We hope that this occurs
                    369:         * infrequently since we cannot avoid this race condition without
                    370:         * implementing a sophisticated deadlock detection algorithm.
                    371:         * Note also that this simple deadlock detection scheme will not
                    372:         * work if the file system has any hard links other than ".."
                    373:         * that point backwards in the directory structure.
                    374:         */
                    375:        pdp = vdp;
1.12      chs       376:
1.1       jdolecek  377:        /*
                    378:         * If ino is different from dp->i_ino,
                    379:         * it's a relocated directory.
                    380:         */
1.13      ad        381:        brelse(bp, 0);
1.1       jdolecek  382:        if (flags & ISDOTDOT) {
1.18      hannken   383:                VOP_UNLOCK(pdp);        /* race to get the inode */
1.1       jdolecek  384:                error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp,
1.4       thorpej   385:                                             dp->i_ino != ino, ep);
1.12      chs       386:                vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY);
                    387:                if (error)
                    388:                        return error;
1.1       jdolecek  389:                *vpp = tdp;
                    390:        } else if (dp->i_number == dp->i_ino) {
1.17      pooka     391:                vref(vdp);      /* we want ourself, ie "." */
1.1       jdolecek  392:                *vpp = vdp;
                    393:        } else {
                    394:                error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp,
1.4       thorpej   395:                                             dp->i_ino != ino, ep);
1.1       jdolecek  396:                if (error)
                    397:                        return (error);
                    398:                *vpp = tdp;
                    399:        }
1.7       perry     400:
1.1       jdolecek  401:        /*
                    402:         * Insert name into cache if appropriate.
                    403:         */
1.22      dholland  404:        cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
1.20      rmind     405:        return 0;
1.1       jdolecek  406: }
                    407:
                    408: /*
                    409:  * Return buffer with the contents of block "offset" from the beginning of
                    410:  * directory "ip".  If "res" is non-zero, fill it in with a pointer to the
                    411:  * remaining space in the directory.
                    412:  */
                    413: int
1.8       yamt      414: cd9660_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp)
1.1       jdolecek  415: {
                    416:        struct iso_node *ip;
                    417:        struct iso_mnt *imp;
                    418:        struct buf *bp;
                    419:        daddr_t lbn;
                    420:        int bsize, error;
                    421:
1.8       yamt      422:        ip = VTOI(vp);
1.1       jdolecek  423:        imp = ip->i_mnt;
1.8       yamt      424:        lbn = lblkno(imp, offset);
1.24    ! dholland  425:        bsize = cd9660_blksize(imp, ip, lbn);
1.7       perry     426:
1.16      hannken   427:        if ((error = bread(vp, lbn, bsize, NOCRED, 0, &bp)) != 0) {
1.8       yamt      428:                *bpp = NULL;
1.1       jdolecek  429:                return (error);
                    430:        }
1.8       yamt      431:        if (res)
1.24    ! dholland  432:                *res = (char *)bp->b_data + cd9660_blkoff(imp, offset);
1.8       yamt      433:        *bpp = bp;
1.1       jdolecek  434:        return (0);
                    435: }

CVSweb <webmaster@jp.NetBSD.org>