1 /* $NetBSD: cd9660_lookup.c,v 1.9 2005/12/11 12:24:25 christos Exp $ */ 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. 20 * 3. Neither the name of the University nor the names of its contributors 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> 42 __KERNEL_RCSID(0, "$NetBSD: cd9660_lookup.c,v 1.9 2005/12/11 12:24:25 christos Exp $"); 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> 51 52 #include <fs/cd9660/iso.h> 53 #include <fs/cd9660/cd9660_extern.h> 54 #include <fs/cd9660/cd9660_node.h> 55 #include <fs/cd9660/iso_rrip.h> 56 #include <fs/cd9660/cd9660_rrip.h> 57 #include <fs/cd9660/cd9660_mount.h> 58 59 struct nchstats iso_nchstats; 60 61 /* 62 * Convert a component of a pathname into a pointer to a locked inode. 63 * This is a very central and rather complicated routine. 64 * If the file system is not maintained in a strict tree hierarchy, 65 * this can result in a deadlock situation (see comments in code below). 66 * 67 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on 68 * whether the name is to be looked up, created, renamed, or deleted. 69 * When CREATE, RENAME, or DELETE is specified, information usable in 70 * creating, renaming, or deleting a directory entry may be calculated. 71 * If flag has LOCKPARENT or'ed into it and the target of the pathname 72 * exists, lookup returns both the target and its parent directory locked. 73 * When creating or renaming and LOCKPARENT is specified, the target may 74 * not be ".". When deleting and LOCKPARENT is specified, the target may 75 * be "."., but the caller must check to ensure it does an vrele and iput 76 * instead of two iputs. 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 89 * if at end of path and rewriting (RENAME and LOCKPARENT), lock target 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 * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent inode unlocked. 95 */ 96 int 97 cd9660_lookup(v) 98 void *v; 99 { 100 struct vop_lookup_args /* { 101 struct vnode *a_dvp; 102 struct vnode **a_vpp; 103 struct componentname *a_cnp; 104 } */ *ap = v; 105 struct vnode *vdp; /* vnode for directory being searched */ 106 struct iso_node *dp; /* inode for directory being searched */ 107 struct iso_mnt *imp; /* file system that directory is in */ 108 struct buf *bp; /* a buffer of directory entries */ 109 struct iso_directory_record *ep = NULL; 110 /* the current directory entry */ 111 int entryoffsetinblock; /* offset of ep in bp's buffer */ 112 int saveoffset = -1; /* offset of last directory entry in dir */ 113 int numdirpasses; /* strategy for directory search */ 114 doff_t endsearch; /* offset to end directory search */ 115 struct vnode *pdp; /* saved dp during symlink work */ 116 struct vnode *tdp; /* returned by cd9660_vget_internal */ 117 u_long bmask; /* block offset mask */ 118 int lockparent; /* 1 => lockparent flag is set */ 119 int error; 120 ino_t ino = 0; 121 int reclen; 122 u_short namelen; 123 char altname[NAME_MAX]; 124 int res; 125 int assoc, len; 126 const char *name; 127 struct vnode **vpp = ap->a_vpp; 128 struct componentname *cnp = ap->a_cnp; 129 struct ucred *cred = cnp->cn_cred; 130 int flags; 131 int nameiop = cnp->cn_nameiop; 132 133 cnp->cn_flags &= ~PDIRUNLOCK; 134 flags = cnp->cn_flags; 135 136 bp = NULL; 137 *vpp = NULL; 138 vdp = ap->a_dvp; 139 dp = VTOI(vdp); 140 imp = dp->i_mnt; 141 lockparent = flags & LOCKPARENT; 142 143 /* 144 * Check accessiblity of directory. 145 */ 146 if ((error = VOP_ACCESS(vdp, VEXEC, cred, cnp->cn_lwp)) != 0) 147 return (error); 148 149 if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) && 150 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 151 return (EROFS); 152 153 /* 154 * We now have a segment name to search for, and a directory to search. 155 * 156 * Before tediously performing a linear scan of the directory, 157 * check the name cache to see if the directory/name pair 158 * we are looking for is known already. 159 */ 160 if ((error = cache_lookup(vdp, vpp, cnp)) >= 0) 161 return (error); 162 163 len = cnp->cn_namelen; 164 name = cnp->cn_nameptr; 165 /* 166 * A leading `=' means, we are looking for an associated file 167 */ 168 assoc = (imp->iso_ftype != ISO_FTYPE_RRIP && *name == ASSOCCHAR); 169 if (assoc) { 170 len--; 171 name++; 172 } 173 174 /* 175 * If there is cached information on a previous search of 176 * this directory, pick up where we last left off. 177 * We cache only lookups as these are the most common 178 * and have the greatest payoff. Caching CREATE has little 179 * benefit as it usually must search the entire directory 180 * to determine that the entry does not exist. Caching the 181 * location of the last DELETE or RENAME has not reduced 182 * profiling time and hence has been removed in the interest 183 * of simplicity. 184 */ 185 bmask = imp->im_bmask; 186 if (nameiop != LOOKUP || dp->i_diroff == 0 || 187 dp->i_diroff > dp->i_size) { 188 entryoffsetinblock = 0; 189 dp->i_offset = 0; 190 numdirpasses = 1; 191 } else { 192 dp->i_offset = dp->i_diroff; 193 if ((entryoffsetinblock = dp->i_offset & bmask) && 194 (error = cd9660_blkatoff(vdp, (off_t)dp->i_offset, NULL, 195 &bp))) 196 return (error); 197 numdirpasses = 2; 198 iso_nchstats.ncs_2passes++; 199 } 200 endsearch = dp->i_size; 201 202 searchloop: 203 while (dp->i_offset < endsearch) { 204 /* 205 * If offset is on a block boundary, 206 * read the next directory block. 207 * Release previous if it exists. 208 */ 209 if ((dp->i_offset & bmask) == 0) { 210 if (bp != NULL) 211 brelse(bp); 212 error = cd9660_blkatoff(vdp, (off_t)dp->i_offset, 213 NULL, &bp); 214 if (error) 215 return (error); 216 entryoffsetinblock = 0; 217 } 218 /* 219 * Get pointer to next entry. 220 */ 221 ep = (struct iso_directory_record *) 222 ((char *)bp->b_data + entryoffsetinblock); 223 224 reclen = isonum_711(ep->length); 225 if (reclen == 0) { 226 /* skip to next block, if any */ 227 dp->i_offset = 228 (dp->i_offset & ~bmask) + imp->logical_block_size; 229 continue; 230 } 231 232 if (reclen < ISO_DIRECTORY_RECORD_SIZE) 233 /* illegal entry, stop */ 234 break; 235 236 if (entryoffsetinblock + reclen > imp->logical_block_size) 237 /* entries are not allowed to cross boundaries */ 238 break; 239 240 namelen = isonum_711(ep->name_len); 241 242 if (reclen < ISO_DIRECTORY_RECORD_SIZE + namelen) 243 /* illegal entry, stop */ 244 break; 245 246 /* 247 * Check for a name match. 248 */ 249 switch (imp->iso_ftype) { 250 default: 251 if ((!(isonum_711(ep->flags)&4)) == !assoc) { 252 if ((len == 1 253 && *name == '.') 254 || (flags & ISDOTDOT)) { 255 if (namelen == 1 256 && ep->name[0] == ((flags & ISDOTDOT) ? 1 : 0)) { 257 /* 258 * Save directory entry's inode number and 259 * release directory buffer. 260 */ 261 dp->i_ino = isodirino(ep, imp); 262 goto found; 263 } 264 if (namelen != 1 265 || ep->name[0] != 0) 266 goto notfound; 267 } else if (!(res = isofncmp(name,len, 268 ep->name,namelen, 269 imp->im_joliet_level))) { 270 if (isonum_711(ep->flags)&2) 271 ino = isodirino(ep, imp); 272 else 273 ino = dbtob(bp->b_blkno) 274 + entryoffsetinblock; 275 saveoffset = dp->i_offset; 276 } else if (ino) 277 goto foundino; 278 #ifdef NOSORTBUG /* On some CDs directory entries are not sorted correctly */ 279 else if (res < 0) 280 goto notfound; 281 else if (res > 0 && numdirpasses == 2) 282 numdirpasses++; 283 #endif 284 } 285 break; 286 case ISO_FTYPE_RRIP: 287 if (isonum_711(ep->flags)&2) 288 ino = isodirino(ep, imp); 289 else 290 ino = dbtob(bp->b_blkno) + entryoffsetinblock; 291 dp->i_ino = ino; 292 cd9660_rrip_getname(ep,altname,&namelen,&dp->i_ino,imp); 293 if (namelen == cnp->cn_namelen) { 294 if (imp->im_flags & ISOFSMNT_RRCASEINS) { 295 if (strncasecmp(name, altname, namelen) == 0) 296 goto found; 297 } else { 298 if (memcmp(name, altname, namelen) == 0) 299 goto found; 300 } 301 } 302 ino = 0; 303 break; 304 } 305 dp->i_offset += reclen; 306 entryoffsetinblock += reclen; 307 } 308 if (ino) { 309 foundino: 310 dp->i_ino = ino; 311 if (saveoffset != dp->i_offset) { 312 if (lblkno(imp, dp->i_offset) != 313 lblkno(imp, saveoffset)) { 314 if (bp != NULL) 315 brelse(bp); 316 if ((error = cd9660_blkatoff(vdp, 317 (off_t)saveoffset, NULL, &bp)) != 0) 318 return (error); 319 } 320 entryoffsetinblock = saveoffset & bmask; 321 ep = (struct iso_directory_record *) 322 ((char *)bp->b_data + entryoffsetinblock); 323 dp->i_offset = saveoffset; 324 } 325 goto found; 326 } 327 notfound: 328 /* 329 * If we started in the middle of the directory and failed 330 * to find our target, we must check the beginning as well. 331 */ 332 if (numdirpasses == 2) { 333 numdirpasses--; 334 dp->i_offset = 0; 335 endsearch = dp->i_diroff; 336 goto searchloop; 337 } 338 if (bp != NULL) 339 brelse(bp); 340 341 /* 342 * Insert name into cache (as non-existent) if appropriate. 343 */ 344 if (cnp->cn_flags & MAKEENTRY) 345 cache_enter(vdp, *vpp, cnp); 346 if (nameiop == CREATE || nameiop == RENAME) 347 return (EROFS); 348 return (ENOENT); 349 350 found: 351 if (numdirpasses == 2) 352 iso_nchstats.ncs_pass2++; 353 354 /* 355 * Found component in pathname. 356 * If the final component of path name, save information 357 * in the cache as to where the entry was found. 358 */ 359 if ((flags & ISLASTCN) && nameiop == LOOKUP) 360 dp->i_diroff = dp->i_offset; 361 362 /* 363 * Step through the translation in the name. We do not `iput' the 364 * directory because we may need it again if a symbolic link 365 * is relative to the current directory. Instead we save it 366 * unlocked as "pdp". We must get the target inode before unlocking 367 * the directory to insure that the inode will not be removed 368 * before we get it. We prevent deadlock by always fetching 369 * inodes from the root, moving down the directory tree. Thus 370 * when following backward pointers ".." we must unlock the 371 * parent directory before getting the requested directory. 372 * There is a potential race condition here if both the current 373 * and parent directories are removed before the `iget' for the 374 * inode associated with ".." returns. We hope that this occurs 375 * infrequently since we cannot avoid this race condition without 376 * implementing a sophisticated deadlock detection algorithm. 377 * Note also that this simple deadlock detection scheme will not 378 * work if the file system has any hard links other than ".." 379 * that point backwards in the directory structure. 380 */ 381 pdp = vdp; 382 /* 383 * If ino is different from dp->i_ino, 384 * it's a relocated directory. 385 */ 386 if (flags & ISDOTDOT) { 387 VOP_UNLOCK(pdp, 0); /* race to get the inode */ 388 cnp->cn_flags |= PDIRUNLOCK; 389 error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, 390 dp->i_ino != ino, ep); 391 brelse(bp); 392 if (error) { 393 if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY) == 0) 394 cnp->cn_flags &= ~PDIRUNLOCK; 395 return (error); 396 } 397 if (lockparent && (flags & ISLASTCN)) { 398 if ((error = vn_lock(pdp, LK_EXCLUSIVE))) { 399 vput(tdp); 400 return (error); 401 } 402 cnp->cn_flags &= ~PDIRUNLOCK; 403 } 404 *vpp = tdp; 405 } else if (dp->i_number == dp->i_ino) { 406 brelse(bp); 407 VREF(vdp); /* we want ourself, ie "." */ 408 *vpp = vdp; 409 } else { 410 error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, 411 dp->i_ino != ino, ep); 412 brelse(bp); 413 if (error) 414 return (error); 415 if (!lockparent || !(flags & ISLASTCN)) { 416 VOP_UNLOCK(pdp, 0); 417 cnp->cn_flags |= PDIRUNLOCK; 418 } 419 *vpp = tdp; 420 } 421 422 /* 423 * Insert name into cache if appropriate. 424 */ 425 if (cnp->cn_flags & MAKEENTRY) 426 cache_enter(vdp, *vpp, cnp); 427 return (0); 428 } 429 430 /* 431 * Return buffer with the contents of block "offset" from the beginning of 432 * directory "ip". If "res" is non-zero, fill it in with a pointer to the 433 * remaining space in the directory. 434 */ 435 int 436 cd9660_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp) 437 { 438 struct iso_node *ip; 439 struct iso_mnt *imp; 440 struct buf *bp; 441 daddr_t lbn; 442 int bsize, error; 443 444 ip = VTOI(vp); 445 imp = ip->i_mnt; 446 lbn = lblkno(imp, offset); 447 bsize = blksize(imp, ip, lbn); 448 449 if ((error = bread(vp, lbn, bsize, NOCRED, &bp)) != 0) { 450 brelse(bp); 451 *bpp = NULL; 452 return (error); 453 } 454 if (res) 455 *res = (char *)bp->b_data + blkoff(imp, offset); 456 *bpp = bp; 457 return (0); 458 } 459