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>