Annotation of sys/isofs/cd9660/cd9660_lookup.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cd9660_lookup.c,v 1.14 2007/06/06 17:15:13 deraadt Exp $ */
2: /* $NetBSD: cd9660_lookup.c,v 1.18 1997/05/08 16:19:59 mycroft Exp $ */
3:
4: /*-
5: * Copyright (c) 1989, 1993, 1994
6: * The Regents of the University of California. All rights reserved.
7: *
8: * This code is derived from software contributed to Berkeley
9: * by Pace Willisson (pace@blitz.com). The Rock Ridge Extension
10: * Support code is derived from software contributed to Berkeley
11: * by Atsushi Murai (amurai@spec.co.jp).
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: *
37: * from: @(#)ufs_lookup.c 7.33 (Berkeley) 5/19/91
38: *
39: * @(#)cd9660_lookup.c 8.5 (Berkeley) 12/5/94
40: */
41:
42: #include <sys/param.h>
43: #include <sys/namei.h>
44: #include <sys/buf.h>
45: #include <sys/file.h>
46: #include <sys/vnode.h>
47: #include <sys/mount.h>
48: #include <sys/systm.h>
49: #include <sys/malloc.h>
50:
51: #include <isofs/cd9660/iso.h>
52: #include <isofs/cd9660/cd9660_extern.h>
53: #include <isofs/cd9660/cd9660_node.h>
54: #include <isofs/cd9660/iso_rrip.h>
55: #include <isofs/cd9660/cd9660_rrip.h>
56:
57: struct nchstats iso_nchstats;
58:
59: /*
60: * Convert a component of a pathname into a pointer to a locked inode.
61: * This is a very central and rather complicated routine.
62: * If the file system is not maintained in a strict tree hierarchy,
63: * this can result in a deadlock situation (see comments in code below).
64: *
65: * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
66: * whether the name is to be looked up, created, renamed, or deleted.
67: * When CREATE, RENAME, or DELETE is specified, information usable in
68: * creating, renaming, or deleting a directory entry may be calculated.
69: * If flag has LOCKPARENT or'ed into it and the target of the pathname
70: * exists, lookup returns both the target and its parent directory locked.
71: * When creating or renaming and LOCKPARENT is specified, the target may
72: * not be ".". When deleting and LOCKPARENT is specified, the target may
73: * be "."., but the caller must check to ensure it does an vrele and iput
74: * instead of two iputs.
75: *
76: * Overall outline of cd9660_lookup:
77: *
78: * check accessibility of directory
79: * look for name in cache, if found, then if at end of path
80: * and deleting or creating, drop it, else return name
81: * search for name in directory, to found or notfound
82: * notfound:
83: * if creating, return locked directory, leaving info on available slots
84: * else return error
85: * found:
86: * if at end of path and deleting, return information to allow delete
87: * if at end of path and rewriting (RENAME and LOCKPARENT), lock target
88: * inode and return info to allow rewrite
89: * if not at end, add name to cache; if at end and neither creating
90: * nor deleting, add name to cache
91: *
92: * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked.
93: */
94: int
95: cd9660_lookup(v)
96: void *v;
97: {
98: struct vop_lookup_args *ap = v;
99: register struct vnode *vdp; /* vnode for directory being searched */
100: register struct iso_node *dp; /* inode for directory being searched */
101: register struct iso_mnt *imp; /* file system that directory is in */
102: struct buf *bp; /* a buffer of directory entries */
103: struct iso_directory_record *ep = NULL;
104: /* the current directory entry */
105: int entryoffsetinblock; /* offset of ep in bp's buffer */
106: int saveoffset = -1; /* offset of last directory entry in dir */
107: int numdirpasses; /* strategy for directory search */
108: doff_t endsearch; /* offset to end directory search */
109: struct vnode *pdp; /* saved dp during symlink work */
110: struct vnode *tdp; /* returned by cd9660_vget_internal */
111: u_long bmask; /* block offset mask */
112: int lockparent; /* 1 => lockparent flag is set */
113: int wantparent; /* 1 => wantparent or lockparent flag */
114: int error;
115: ino_t ino = 0;
116: int reclen;
117: u_short namelen;
118: char *altname;
119: int res;
120: int assoc, len;
121: char *name;
122: struct vnode **vpp = ap->a_vpp;
123: struct componentname *cnp = ap->a_cnp;
124: struct ucred *cred = cnp->cn_cred;
125: int flags;
126: int nameiop = cnp->cn_nameiop;
127: struct proc *p = cnp->cn_proc;
128:
129: cnp->cn_flags &= ~PDIRUNLOCK;
130: flags = cnp->cn_flags;
131:
132: bp = NULL;
133: *vpp = NULL;
134: vdp = ap->a_dvp;
135: dp = VTOI(vdp);
136: imp = dp->i_mnt;
137: lockparent = flags & LOCKPARENT;
138: wantparent = flags & (LOCKPARENT|WANTPARENT);
139:
140: /*
141: * Check accessiblity of directory.
142: */
143: if ((error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_proc)) != 0)
144: return (error);
145:
146: if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
147: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
148: return (EROFS);
149:
150: /*
151: * We now have a segment name to search for, and a directory to search.
152: *
153: * Before tediously performing a linear scan of the directory,
154: * check the name cache to see if the directory/name pair
155: * we are looking for is known already.
156: */
157: if ((error = cache_lookup(vdp, vpp, cnp)) >= 0)
158: return (error);
159:
160: len = cnp->cn_namelen;
161: name = cnp->cn_nameptr;
162: /*
163: * A leading `=' means, we are looking for an associated file
164: */
165: assoc = (imp->iso_ftype != ISO_FTYPE_RRIP && *name == ASSOCCHAR);
166: if (assoc) {
167: len--;
168: name++;
169: }
170:
171: /*
172: * If there is cached information on a previous search of
173: * this directory, pick up where we last left off.
174: * We cache only lookups as these are the most common
175: * and have the greatest payoff. Caching CREATE has little
176: * benefit as it usually must search the entire directory
177: * to determine that the entry does not exist. Caching the
178: * location of the last DELETE or RENAME has not reduced
179: * profiling time and hence has been removed in the interest
180: * of simplicity.
181: */
182: bmask = imp->im_bmask;
183: if (nameiop != LOOKUP || dp->i_diroff == 0 ||
184: dp->i_diroff > dp->i_size) {
185: entryoffsetinblock = 0;
186: dp->i_offset = 0;
187: numdirpasses = 1;
188: } else {
189: dp->i_offset = dp->i_diroff;
190: if ((entryoffsetinblock = dp->i_offset & bmask) &&
191: (error = cd9660_bufatoff(dp, (off_t)dp->i_offset, NULL,
192: &bp)))
193: return (error);
194: numdirpasses = 2;
195: iso_nchstats.ncs_2passes++;
196: }
197: endsearch = dp->i_size;
198:
199: searchloop:
200: while (dp->i_offset < endsearch) {
201: /*
202: * If offset is on a block boundary,
203: * read the next directory block.
204: * Release previous if it exists.
205: */
206: if ((dp->i_offset & bmask) == 0) {
207: if (bp != NULL)
208: brelse(bp);
209: error = cd9660_bufatoff(dp, (off_t)dp->i_offset,
210: NULL, &bp);
211: if (error)
212: return (error);
213: entryoffsetinblock = 0;
214: }
215: /*
216: * Get pointer to next entry.
217: */
218: ep = (struct iso_directory_record *)
219: ((char *)bp->b_data + entryoffsetinblock);
220:
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: }
228:
229: if (reclen < ISO_DIRECTORY_RECORD_SIZE)
230: /* illegal entry, stop */
231: break;
232:
233: if (entryoffsetinblock + reclen > imp->logical_block_size)
234: /* entries are not allowed to cross boundaries */
235: break;
236:
237: namelen = isonum_711(ep->name_len);
238:
239: if (reclen < ISO_DIRECTORY_RECORD_SIZE + namelen)
240: /* illegal entry, stop */
241: break;
242:
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, imp->joliet_level))) {
266: if (isonum_711(ep->flags)&2)
267: ino = isodirino(ep, imp);
268: else
269: ino = dbtob(bp->b_blkno)
270: + entryoffsetinblock;
271: saveoffset = dp->i_offset;
272: } else if (ino)
273: goto foundino;
274: #ifdef NOSORTBUG /* On some CDs directory entries are not sorted correctly */
275: else if (res < 0)
276: goto notfound;
277: else if (res > 0 && numdirpasses == 2)
278: numdirpasses++;
279: #endif
280: }
281: break;
282: case ISO_FTYPE_RRIP:
283: if (isonum_711(ep->flags)&2)
284: ino = isodirino(ep, imp);
285: else
286: ino = dbtob(bp->b_blkno) + entryoffsetinblock;
287: dp->i_ino = ino;
288: MALLOC(altname, char *, NAME_MAX, M_TEMP, M_WAITOK);
289: cd9660_rrip_getname(ep,altname,&namelen,&dp->i_ino,imp);
290: if (namelen == cnp->cn_namelen
291: && !bcmp(name,altname,namelen)) {
292: FREE(altname, M_TEMP);
293: goto found;
294: }
295: FREE(altname, M_TEMP);
296: ino = 0;
297: break;
298: }
299: dp->i_offset += reclen;
300: entryoffsetinblock += reclen;
301: }
302: if (ino) {
303: foundino:
304: dp->i_ino = ino;
305: if (saveoffset != dp->i_offset) {
306: if (lblkno(imp, dp->i_offset) !=
307: lblkno(imp, saveoffset)) {
308: if (bp != NULL)
309: brelse(bp);
310: if ((error = cd9660_bufatoff(dp,
311: (off_t)saveoffset, NULL, &bp)) != 0)
312: return (error);
313: }
314: entryoffsetinblock = saveoffset & bmask;
315: ep = (struct iso_directory_record *)
316: ((char *)bp->b_data + entryoffsetinblock);
317: dp->i_offset = saveoffset;
318: }
319: goto found;
320: }
321: notfound:
322: /*
323: * If we started in the middle of the directory and failed
324: * to find our target, we must check the beginning as well.
325: */
326: if (numdirpasses == 2) {
327: numdirpasses--;
328: dp->i_offset = 0;
329: endsearch = dp->i_diroff;
330: goto searchloop;
331: }
332: if (bp != NULL)
333: brelse(bp);
334:
335: /*
336: * Insert name into cache (as non-existent) if appropriate.
337: */
338: if (cnp->cn_flags & MAKEENTRY)
339: cache_enter(vdp, *vpp, cnp);
340: if (nameiop == CREATE || nameiop == RENAME)
341: return (EJUSTRETURN);
342: return (ENOENT);
343:
344: found:
345: if (numdirpasses == 2)
346: iso_nchstats.ncs_pass2++;
347:
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;
355:
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;
376: /*
377: * If ino is different from dp->i_ino,
378: * it's a relocated directory.
379: */
380: if (flags & ISDOTDOT) {
381: brelse(bp);
382: VOP_UNLOCK(pdp, 0, p); /* race to get the inode */
383: cnp->cn_flags |= PDIRUNLOCK;
384: error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp,
385: dp->i_ino != ino, NULL);
386: if (error) {
387: if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p) == 0)
388: cnp->cn_flags &= ~PDIRUNLOCK;
389: return (error);
390: }
391: if (lockparent && (flags & ISLASTCN)) {
392: if ((error = vn_lock(pdp, LK_EXCLUSIVE, p))) {
393: vput(tdp);
394: return (error);
395: }
396: cnp->cn_flags &= ~PDIRUNLOCK;
397: }
398: *vpp = tdp;
399: } else if (dp->i_number == dp->i_ino) {
400: brelse(bp);
401: VREF(vdp); /* we want ourself, ie "." */
402: *vpp = vdp;
403: } else {
404: error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp,
405: dp->i_ino != ino, ep);
406: brelse(bp);
407: if (error)
408: return (error);
409: if (!lockparent || !(flags & ISLASTCN)) {
410: VOP_UNLOCK(pdp, 0, p);
411: cnp->cn_flags |= PDIRUNLOCK;
412: }
413: *vpp = tdp;
414: }
415:
416: /*
417: * Insert name into cache if appropriate.
418: */
419: if (cnp->cn_flags & MAKEENTRY)
420: cache_enter(vdp, *vpp, cnp);
421: return (0);
422: }
423:
424: /*
425: * Return buffer with the contents of block "offset" from the beginning of
426: * directory "ip". If "res" is non-zero, fill it in with a pointer to the
427: * remaining space in the directory.
428: */
429: int
430: cd9660_bufatoff(struct iso_node *ip, off_t offset, char **res,
431: struct buf **bpp)
432: {
433: struct iso_mnt *imp;
434: struct buf *bp;
435: daddr64_t lbn;
436: int bsize, error;
437: struct vnode *vp = ITOV(ip);
438:
439: imp = ip->i_mnt;
440: lbn = lblkno(imp, offset);
441: bsize = blksize(imp, ip, lbn);
442:
443: if ((error = bread(vp, lbn, bsize, NOCRED, &bp)) != 0) {
444: brelse(bp);
445: *bpp = NULL;
446: return (error);
447: }
448: if (res)
449: *res = (char *)bp->b_data + blkoff(imp, offset);
450: *bpp = bp;
451: return (0);
452: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cd9660_lookup.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / isofs / cd9660