1 /* $NetBSD: ext2fs_lookup.c,v 1.78 2015/03/27 17:27:56 riastradh Exp $ */
2
3 /*
4 * Modified for NetBSD 1.2E
5 * May 1997, Manuel Bouyer
6 * Laboratoire d'informatique de Paris VI
7 */
8 /*
9 * modified for Lites 1.1
10 *
11 * Aug 1995, Godmar Back (gback@cs.utah.edu)
12 * University of Utah, Department of Computer Science
13 */
14 /*
15 * Copyright (c) 1989, 1993
16 * The Regents of the University of California. All rights reserved.
17 * (c) UNIX System Laboratories, Inc.
18 * All or some portions of this file are derived from material licensed
19 * to the University of California by American Telephone and Telegraph
20 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
21 * the permission of UNIX System Laboratories, Inc.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the above copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. Neither the name of the University nor the names of its contributors
32 * may be used to endorse or promote products derived from this software
33 * without specific prior written permission.
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
36 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
39 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
40 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
41 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
42 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
43 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
44 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
45 * SUCH DAMAGE.
46 *
47 * @(#)ufs_lookup.c 8.6 (Berkeley) 4/1/94
48 */
49
50 #include <sys/cdefs.h>
51 __KERNEL_RCSID(0, "$NetBSD: ext2fs_lookup.c,v 1.78 2015/03/27 17:27:56 riastradh Exp $");
52
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/namei.h>
56 #include <sys/buf.h>
57 #include <sys/file.h>
58 #include <sys/mount.h>
59 #include <sys/vnode.h>
60 #include <sys/kmem.h>
61 #include <sys/malloc.h>
62 #include <sys/dirent.h>
63 #include <sys/kauth.h>
64 #include <sys/proc.h>
65
66 #include <ufs/ufs/inode.h>
67 #include <ufs/ufs/ufsmount.h>
68 #include <ufs/ufs/ufs_extern.h>
69
70 #include <ufs/ext2fs/ext2fs_extern.h>
71 #include <ufs/ext2fs/ext2fs_dir.h>
72 #include <ufs/ext2fs/ext2fs.h>
73
74 #include <miscfs/genfs/genfs.h>
75
76 extern int dirchk;
77
78 static void ext2fs_dirconv2ffs(struct ext2fs_direct *e2dir,
79 struct dirent *ffsdir);
80 static int ext2fs_dirbadentry(struct vnode *dp,
81 struct ext2fs_direct *de,
82 int entryoffsetinblock);
83
84 /*
85 * the problem that is tackled below is the fact that FFS
86 * includes the terminating zero on disk while EXT2FS doesn't
87 * this implies that we need to introduce some padding.
88 * For instance, a filename "sbin" has normally a reclen 12
89 * in EXT2, but 16 in FFS.
90 * This reminds me of that Pepsi commercial: 'Kid saved a lousy nine cents...'
91 * If it wasn't for that, the complete ufs code for directories would
92 * have worked w/o changes (except for the difference in DIRBLKSIZ)
93 */
94 static void
ext2fs_dirconv2ffs(struct ext2fs_direct * e2dir,struct dirent * ffsdir)95 ext2fs_dirconv2ffs(struct ext2fs_direct *e2dir, struct dirent *ffsdir)
96 {
97 memset(ffsdir, 0, sizeof(struct dirent));
98 ffsdir->d_fileno = fs2h32(e2dir->e2d_ino);
99 ffsdir->d_namlen = e2dir->e2d_namlen;
100
101 ffsdir->d_type = DT_UNKNOWN; /* don't know more here */
102 #ifdef DIAGNOSTIC
103 #if MAXNAMLEN < E2FS_MAXNAMLEN
104 /*
105 * we should handle this more gracefully !
106 */
107 if (e2dir->e2d_namlen > MAXNAMLEN)
108 panic("ext2fs: e2dir->e2d_namlen");
109 #endif
110 #endif
111 strncpy(ffsdir->d_name, e2dir->e2d_name, ffsdir->d_namlen);
112
113 /* Godmar thinks: since e2dir->e2d_reclen can be big and means
114 nothing anyway, we compute our own reclen according to what
115 we think is right
116 */
117 ffsdir->d_reclen = _DIRENT_SIZE(ffsdir);
118 }
119
120 /*
121 * Vnode op for reading directories.
122 *
123 * Convert the on-disk entries to <sys/dirent.h> entries.
124 * the problem is that the conversion will blow up some entries by four bytes,
125 * so it can't be done in place. This is too bad. Right now the conversion is
126 * done entry by entry, the converted entry is sent via uiomove.
127 *
128 * XXX allocate a buffer, convert as many entries as possible, then send
129 * the whole buffer to uiomove
130 */
131 int
ext2fs_readdir(void * v)132 ext2fs_readdir(void *v)
133 {
134 struct vop_readdir_args /* {
135 struct vnode *a_vp;
136 struct uio *a_uio;
137 kauth_cred_t a_cred;
138 int **a_eofflag;
139 off_t **a_cookies;
140 int ncookies;
141 } */ *ap = v;
142 struct uio *uio = ap->a_uio;
143 int error;
144 size_t e2fs_count, readcnt;
145 struct vnode *vp = ap->a_vp;
146 struct m_ext2fs *fs = VTOI(vp)->i_e2fs;
147
148 struct ext2fs_direct *dp;
149 struct dirent *dstd;
150 struct uio auio;
151 struct iovec aiov;
152 void *dirbuf;
153 off_t off = uio->uio_offset;
154 off_t *cookies = NULL;
155 int nc = 0, ncookies = 0;
156 int e2d_reclen;
157
158 if (vp->v_type != VDIR)
159 return (ENOTDIR);
160
161 e2fs_count = uio->uio_resid;
162 /* Make sure we don't return partial entries. */
163 e2fs_count -= (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize -1);
164 if (e2fs_count <= 0)
165 return (EINVAL);
166
167 auio = *uio;
168 auio.uio_iov = &aiov;
169 auio.uio_iovcnt = 1;
170 aiov.iov_len = e2fs_count;
171 auio.uio_resid = e2fs_count;
172 UIO_SETUP_SYSSPACE(&auio);
173 dirbuf = kmem_alloc(e2fs_count, KM_SLEEP);
174 dstd = kmem_zalloc(sizeof(struct dirent), KM_SLEEP);
175 if (ap->a_ncookies) {
176 nc = e2fs_count / _DIRENT_MINSIZE((struct dirent *)0);
177 ncookies = nc;
178 cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
179 *ap->a_cookies = cookies;
180 }
181 aiov.iov_base = dirbuf;
182
183 error = UFS_BUFRD(ap->a_vp, &auio, 0, ap->a_cred);
184 if (error == 0) {
185 readcnt = e2fs_count - auio.uio_resid;
186 for (dp = (struct ext2fs_direct *)dirbuf;
187 (char *)dp < (char *)dirbuf + readcnt; ) {
188 e2d_reclen = fs2h16(dp->e2d_reclen);
189 if (e2d_reclen == 0) {
190 error = EIO;
191 break;
192 }
193 ext2fs_dirconv2ffs(dp, dstd);
194 if(dstd->d_reclen > uio->uio_resid) {
195 break;
196 }
197 error = uiomove(dstd, dstd->d_reclen, uio);
198 if (error != 0) {
199 break;
200 }
201 off = off + e2d_reclen;
202 if (cookies != NULL) {
203 *cookies++ = off;
204 if (--ncookies <= 0){
205 break; /* out of cookies */
206 }
207 }
208 /* advance dp */
209 dp = (struct ext2fs_direct *) ((char *)dp + e2d_reclen);
210 }
211 /* we need to correct uio_offset */
212 uio->uio_offset = off;
213 }
214 kmem_free(dirbuf, e2fs_count);
215 kmem_free(dstd, sizeof(*dstd));
216 *ap->a_eofflag = ext2fs_size(VTOI(ap->a_vp)) <= uio->uio_offset;
217 if (ap->a_ncookies) {
218 if (error) {
219 free(*ap->a_cookies, M_TEMP);
220 *ap->a_ncookies = 0;
221 *ap->a_cookies = NULL;
222 } else
223 *ap->a_ncookies = nc - ncookies;
224 }
225 return (error);
226 }
227
228 /*
229 * Convert a component of a pathname into a pointer to a locked inode.
230 * This is a very central and rather complicated routine.
231 * If the file system is not maintained in a strict tree hierarchy,
232 * this can result in a deadlock situation (see comments in code below).
233 *
234 * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
235 * on whether the name is to be looked up, created, renamed, or deleted.
236 * When CREATE, RENAME, or DELETE is specified, information usable in
237 * creating, renaming, or deleting a directory entry may be calculated.
238 * If flag has LOCKPARENT or'ed into it and the target of the pathname
239 * exists, lookup returns both the target and its parent directory locked.
240 * When creating or renaming and LOCKPARENT is specified, the target may
241 * not be ".". When deleting and LOCKPARENT is specified, the target may
242 * be "."., but the caller must check to ensure it does an vrele and vput
243 * instead of two vputs.
244 *
245 * Overall outline of ext2fs_lookup:
246 *
247 * check accessibility of directory
248 * look for name in cache, if found, then if at end of path
249 * and deleting or creating, drop it, else return name
250 * search for name in directory, to found or notfound
251 * notfound:
252 * if creating, return locked directory, leaving info on available slots
253 * else return error
254 * found:
255 * if at end of path and deleting, return information to allow delete
256 * if at end of path and rewriting (RENAME and LOCKPARENT), lock target
257 * inode and return info to allow rewrite
258 * if not at end, add name to cache; if at end and neither creating
259 * nor deleting, add name to cache
260 */
261 int
ext2fs_lookup(void * v)262 ext2fs_lookup(void *v)
263 {
264 struct vop_lookup_v2_args /* {
265 struct vnode *a_dvp;
266 struct vnode **a_vpp;
267 struct componentname *a_cnp;
268 } */ *ap = v;
269 struct vnode *vdp = ap->a_dvp; /* vnode for directory being searched */
270 struct inode *dp = VTOI(vdp); /* inode for directory being searched */
271 struct buf *bp; /* a buffer of directory entries */
272 struct ext2fs_direct *ep; /* the current directory entry */
273 int entryoffsetinblock; /* offset of ep in bp's buffer */
274 enum {NONE, COMPACT, FOUND} slotstatus;
275 doff_t slotoffset; /* offset of area with free space */
276 int slotsize; /* size of area at slotoffset */
277 int slotfreespace; /* amount of space free in slot */
278 int slotneeded; /* size of the entry we're seeking */
279 int numdirpasses; /* strategy for directory search */
280 doff_t endsearch; /* offset to end directory search */
281 doff_t prevoff; /* prev entry dp->i_offset */
282 struct vnode *tdp; /* returned by vcache_get */
283 doff_t enduseful; /* pointer past last used dir slot */
284 u_long bmask; /* block offset mask */
285 int namlen, error;
286 struct vnode **vpp = ap->a_vpp;
287 struct componentname *cnp = ap->a_cnp;
288 kauth_cred_t cred = cnp->cn_cred;
289 int flags;
290 int nameiop = cnp->cn_nameiop;
291 struct ufsmount *ump = dp->i_ump;
292 int dirblksiz = ump->um_dirblksiz;
293 ino_t foundino;
294 struct ufs_lookup_results *results;
295
296 flags = cnp->cn_flags;
297
298 bp = NULL;
299 slotoffset = -1;
300 *vpp = NULL;
301
302 /*
303 * Produce the auxiliary lookup results into i_crap. Increment
304 * its serial number so elsewhere we can tell if we're using
305 * stale results. This should not be done this way. XXX.
306 */
307 results = &dp->i_crap;
308 dp->i_crapcounter++;
309
310 /*
311 * Check accessiblity of directory.
312 */
313 if ((error = VOP_ACCESS(vdp, VEXEC, cred)) != 0)
314 return (error);
315
316 if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
317 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
318 return (EROFS);
319
320 /*
321 * We now have a segment name to search for, and a directory to search.
322 *
323 * Before tediously performing a linear scan of the directory,
324 * check the name cache to see if the directory/name pair
325 * we are looking for is known already.
326 */
327 if (cache_lookup(vdp, cnp->cn_nameptr, cnp->cn_namelen,
328 cnp->cn_nameiop, cnp->cn_flags, NULL, vpp)) {
329 return *vpp == NULLVP ? ENOENT : 0;
330 }
331
332 /*
333 * Suppress search for slots unless creating
334 * file and at end of pathname, in which case
335 * we watch for a place to put the new file in
336 * case it doesn't already exist.
337 */
338 slotstatus = FOUND;
339 slotfreespace = slotsize = slotneeded = 0;
340 if ((nameiop == CREATE || nameiop == RENAME) &&
341 (flags & ISLASTCN)) {
342 slotstatus = NONE;
343 slotneeded = EXT2FS_DIRSIZ(cnp->cn_namelen);
344 }
345
346 /*
347 * If there is cached information on a previous search of
348 * this directory, pick up where we last left off.
349 * We cache only lookups as these are the most common
350 * and have the greatest payoff. Caching CREATE has little
351 * benefit as it usually must search the entire directory
352 * to determine that the entry does not exist. Caching the
353 * location of the last DELETE or RENAME has not reduced
354 * profiling time and hence has been removed in the interest
355 * of simplicity.
356 */
357 bmask = vdp->v_mount->mnt_stat.f_iosize - 1;
358 if (nameiop != LOOKUP || results->ulr_diroff == 0 ||
359 results->ulr_diroff >= ext2fs_size(dp)) {
360 entryoffsetinblock = 0;
361 results->ulr_offset = 0;
362 numdirpasses = 1;
363 } else {
364 results->ulr_offset = results->ulr_diroff;
365 if ((entryoffsetinblock = results->ulr_offset & bmask) &&
366 (error = ext2fs_blkatoff(vdp, (off_t)results->ulr_offset, NULL, &bp)))
367 return (error);
368 numdirpasses = 2;
369 namecache_count_2passes();
370 }
371 prevoff = results->ulr_offset;
372 endsearch = roundup(ext2fs_size(dp), dirblksiz);
373 enduseful = 0;
374
375 searchloop:
376 while (results->ulr_offset < endsearch) {
377 if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD)
378 preempt();
379 /*
380 * If necessary, get the next directory block.
381 */
382 if ((results->ulr_offset & bmask) == 0) {
383 if (bp != NULL)
384 brelse(bp, 0);
385 error = ext2fs_blkatoff(vdp, (off_t)results->ulr_offset, NULL,
386 &bp);
387 if (error != 0)
388 return (error);
389 entryoffsetinblock = 0;
390 }
391 /*
392 * If still looking for a slot, and at a dirblksize
393 * boundary, have to start looking for free space again.
394 */
395 if (slotstatus == NONE &&
396 (entryoffsetinblock & (dirblksiz - 1)) == 0) {
397 slotoffset = -1;
398 slotfreespace = 0;
399 }
400 /*
401 * Get pointer to next entry.
402 * Full validation checks are slow, so we only check
403 * enough to insure forward progress through the
404 * directory. Complete checks can be run by patching
405 * "dirchk" to be true.
406 */
407 KASSERT(bp != NULL);
408 ep = (struct ext2fs_direct *)
409 ((char *)bp->b_data + entryoffsetinblock);
410 if (ep->e2d_reclen == 0 ||
411 (dirchk &&
412 ext2fs_dirbadentry(vdp, ep, entryoffsetinblock))) {
413 int i;
414
415 ufs_dirbad(dp, results->ulr_offset, "mangled entry");
416 i = dirblksiz - (entryoffsetinblock & (dirblksiz - 1));
417 results->ulr_offset += i;
418 entryoffsetinblock += i;
419 continue;
420 }
421
422 /*
423 * If an appropriate sized slot has not yet been found,
424 * check to see if one is available. Also accumulate space
425 * in the current block so that we can determine if
426 * compaction is viable.
427 */
428 if (slotstatus != FOUND) {
429 int size = fs2h16(ep->e2d_reclen);
430
431 if (ep->e2d_ino != 0)
432 size -= EXT2FS_DIRSIZ(ep->e2d_namlen);
433 if (size > 0) {
434 if (size >= slotneeded) {
435 slotstatus = FOUND;
436 slotoffset = results->ulr_offset;
437 slotsize = fs2h16(ep->e2d_reclen);
438 } else if (slotstatus == NONE) {
439 slotfreespace += size;
440 if (slotoffset == -1)
441 slotoffset = results->ulr_offset;
442 if (slotfreespace >= slotneeded) {
443 slotstatus = COMPACT;
444 slotsize = results->ulr_offset +
445 fs2h16(ep->e2d_reclen) -
446 slotoffset;
447 }
448 }
449 }
450 }
451
452 /*
453 * Check for a name match.
454 */
455 if (ep->e2d_ino) {
456 namlen = ep->e2d_namlen;
457 if (namlen == cnp->cn_namelen &&
458 !memcmp(cnp->cn_nameptr, ep->e2d_name,
459 (unsigned)namlen)) {
460 /*
461 * Save directory entry's inode number and
462 * reclen in ndp->ni_ufs area, and release
463 * directory buffer.
464 */
465 foundino = fs2h32(ep->e2d_ino);
466 results->ulr_reclen = fs2h16(ep->e2d_reclen);
467 goto found;
468 }
469 }
470 prevoff = results->ulr_offset;
471 results->ulr_offset += fs2h16(ep->e2d_reclen);
472 entryoffsetinblock += fs2h16(ep->e2d_reclen);
473 if (ep->e2d_ino)
474 enduseful = results->ulr_offset;
475 }
476 /* notfound: */
477 /*
478 * If we started in the middle of the directory and failed
479 * to find our target, we must check the beginning as well.
480 */
481 if (numdirpasses == 2) {
482 numdirpasses--;
483 results->ulr_offset = 0;
484 endsearch = results->ulr_diroff;
485 goto searchloop;
486 }
487 if (bp != NULL)
488 brelse(bp, 0);
489 /*
490 * If creating, and at end of pathname and current
491 * directory has not been removed, then can consider
492 * allowing file to be created.
493 */
494 if ((nameiop == CREATE || nameiop == RENAME) &&
495 (flags & ISLASTCN) && dp->i_e2fs_nlink != 0) {
496 /*
497 * Access for write is interpreted as allowing
498 * creation of files in the directory.
499 */
500 error = VOP_ACCESS(vdp, VWRITE, cred);
501 if (error)
502 return (error);
503 /*
504 * Return an indication of where the new directory
505 * entry should be put. If we didn't find a slot,
506 * then set results->ulr_count to 0 indicating
507 * that the new slot belongs at the end of the
508 * directory. If we found a slot, then the new entry
509 * can be put in the range from results->ulr_offset to
510 * results->ulr_offset + results->ulr_count.
511 */
512 if (slotstatus == NONE) {
513 results->ulr_offset = roundup(ext2fs_size(dp), dirblksiz);
514 results->ulr_count = 0;
515 enduseful = results->ulr_offset;
516 } else {
517 results->ulr_offset = slotoffset;
518 results->ulr_count = slotsize;
519 if (enduseful < slotoffset + slotsize)
520 enduseful = slotoffset + slotsize;
521 }
522 results->ulr_endoff = roundup(enduseful, dirblksiz);
523 #if 0
524 dp->i_flag |= IN_CHANGE | IN_UPDATE;
525 #endif
526 /*
527 * We return with the directory locked, so that
528 * the parameters we set up above will still be
529 * valid if we actually decide to do a direnter().
530 * We return ni_vp == NULL to indicate that the entry
531 * does not currently exist; we leave a pointer to
532 * the (locked) directory inode in ndp->ni_dvp.
533 *
534 * NB - if the directory is unlocked, then this
535 * information cannot be used.
536 */
537 return (EJUSTRETURN);
538 }
539 /*
540 * Insert name into cache (as non-existent) if appropriate.
541 */
542 if (nameiop != CREATE) {
543 cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen,
544 cnp->cn_flags);
545 }
546 return ENOENT;
547
548 found:
549 if (numdirpasses == 2)
550 namecache_count_pass2();
551 /*
552 * Check that directory length properly reflects presence
553 * of this entry.
554 */
555 if (results->ulr_offset + EXT2FS_DIRSIZ(ep->e2d_namlen) > ext2fs_size(dp)) {
556 ufs_dirbad(dp, results->ulr_offset, "i_size too small");
557 error = ext2fs_setsize(dp,
558 results->ulr_offset + EXT2FS_DIRSIZ(ep->e2d_namlen));
559 if (error) {
560 brelse(bp, 0);
561 return (error);
562 }
563 dp->i_flag |= IN_CHANGE | IN_UPDATE;
564 uvm_vnp_setsize(vdp, ext2fs_size(dp));
565 }
566 brelse(bp, 0);
567
568 /*
569 * Found component in pathname.
570 * If the final component of path name, save information
571 * in the cache as to where the entry was found.
572 */
573 if ((flags & ISLASTCN) && nameiop == LOOKUP)
574 results->ulr_diroff = results->ulr_offset &~ (dirblksiz - 1);
575
576 /*
577 * If deleting, and at end of pathname, return
578 * parameters which can be used to remove file.
579 * Lock the inode, being careful with ".".
580 */
581 if (nameiop == DELETE && (flags & ISLASTCN)) {
582 /*
583 * Return pointer to current entry in results->ulr_offset,
584 * and distance past previous entry (if there
585 * is a previous entry in this block) in results->ulr_count.
586 * Save directory inode pointer in ndp->ni_dvp for dirremove().
587 */
588 if ((results->ulr_offset & (dirblksiz - 1)) == 0)
589 results->ulr_count = 0;
590 else
591 results->ulr_count = results->ulr_offset - prevoff;
592 if (dp->i_number == foundino) {
593 vref(vdp);
594 tdp = vdp;
595 } else {
596 error = vcache_get(vdp->v_mount,
597 &foundino, sizeof(foundino), &tdp);
598 if (error)
599 return (error);
600 }
601 /*
602 * Write access to directory required to delete files.
603 */
604 if ((error = VOP_ACCESS(vdp, VWRITE, cred)) != 0) {
605 vrele(tdp);
606 return (error);
607 }
608 /*
609 * If directory is "sticky", then user must own
610 * the directory, or the file in it, else she
611 * may not delete it (unless she's root). This
612 * implements append-only directories.
613 */
614 if (dp->i_e2fs_mode & ISVTX) {
615 error = kauth_authorize_vnode(cred, KAUTH_VNODE_DELETE,
616 tdp, vdp, genfs_can_sticky(cred, dp->i_uid,
617 VTOI(tdp)->i_uid));
618 if (error) {
619 vrele(tdp);
620 return (EPERM);
621 }
622 }
623 *vpp = tdp;
624 return (0);
625 }
626
627 /*
628 * If rewriting (RENAME), return the inode and the
629 * information required to rewrite the present directory
630 * Must get inode of directory entry to verify it's a
631 * regular file, or empty directory.
632 */
633 if (nameiop == RENAME && (flags & ISLASTCN)) {
634 error = VOP_ACCESS(vdp, VWRITE, cred);
635 if (error)
636 return (error);
637 /*
638 * Careful about locking second inode.
639 * This can only occur if the target is ".".
640 */
641 if (dp->i_number == foundino)
642 return (EISDIR);
643 error = vcache_get(vdp->v_mount,
644 &foundino, sizeof(foundino), &tdp);
645 if (error)
646 return (error);
647 *vpp = tdp;
648 return (0);
649 }
650
651 if (dp->i_number == foundino) {
652 vref(vdp); /* we want ourself, ie "." */
653 *vpp = vdp;
654 } else {
655 error = vcache_get(vdp->v_mount,
656 &foundino, sizeof(foundino), &tdp);
657 if (error)
658 return (error);
659 *vpp = tdp;
660 }
661
662 /*
663 * Insert name into cache if appropriate.
664 */
665 cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
666 return 0;
667 }
668
669 /*
670 * Do consistency checking on a directory entry:
671 * record length must be multiple of 4
672 * entry must fit in rest of its dirblksize block
673 * record must be large enough to contain entry
674 * name is not longer than EXT2FS_MAXNAMLEN
675 * name must be as long as advertised, and null terminated
676 */
677 /*
678 * changed so that it confirms to ext2fs_check_dir_entry
679 */
680 static int
ext2fs_dirbadentry(struct vnode * dp,struct ext2fs_direct * de,int entryoffsetinblock)681 ext2fs_dirbadentry(struct vnode *dp, struct ext2fs_direct *de,
682 int entryoffsetinblock)
683 {
684 struct ufsmount *ump = VFSTOUFS(dp->v_mount);
685 int dirblksiz = ump->um_dirblksiz;
686
687 const char *error_msg = NULL;
688 int reclen = fs2h16(de->e2d_reclen);
689 int namlen = de->e2d_namlen;
690
691 if (reclen < EXT2FS_DIRSIZ(1)) /* e2d_namlen = 1 */
692 error_msg = "rec_len is smaller than minimal";
693 else if (reclen % 4 != 0)
694 error_msg = "rec_len % 4 != 0";
695 else if (namlen > EXT2FS_MAXNAMLEN)
696 error_msg = "namlen > EXT2FS_MAXNAMLEN";
697 else if (reclen < EXT2FS_DIRSIZ(namlen))
698 error_msg = "reclen is too small for name_len";
699 else if (entryoffsetinblock + reclen > dirblksiz)
700 error_msg = "directory entry across blocks";
701 else if (fs2h32(de->e2d_ino) >
702 VTOI(dp)->i_e2fs->e2fs.e2fs_icount)
703 error_msg = "inode out of bounds";
704
705 if (error_msg != NULL) {
706 printf( "bad directory entry: %s\n"
707 "offset=%d, inode=%lu, rec_len=%d, name_len=%d \n",
708 error_msg, entryoffsetinblock,
709 (unsigned long) fs2h32(de->e2d_ino),
710 reclen, namlen);
711 panic("ext2fs_dirbadentry");
712 }
713 return error_msg == NULL ? 0 : 1;
714 }
715
716 /*
717 * Write a directory entry after a call to namei, using the parameters
718 * that it left in nameidata. The argument ip is the inode which the new
719 * directory entry will refer to. Dvp is a pointer to the directory to
720 * be written, which was left locked by namei. Remaining parameters
721 * (ulr_offset, ulr_count) indicate how the space for the new
722 * entry is to be obtained.
723 */
724 int
ext2fs_direnter(struct inode * ip,struct vnode * dvp,const struct ufs_lookup_results * ulr,struct componentname * cnp)725 ext2fs_direnter(struct inode *ip, struct vnode *dvp,
726 const struct ufs_lookup_results *ulr,
727 struct componentname *cnp)
728 {
729 struct ext2fs_direct *ep, *nep;
730 struct inode *dp;
731 struct buf *bp;
732 struct ext2fs_direct newdir;
733 struct iovec aiov;
734 struct uio auio;
735 u_int dsize;
736 int error, loc, newentrysize, spacefree;
737 char *dirbuf;
738 struct ufsmount *ump = VFSTOUFS(dvp->v_mount);
739 int dirblksiz = ump->um_dirblksiz;
740
741 dp = VTOI(dvp);
742
743 newdir.e2d_ino = h2fs32(ip->i_number);
744 newdir.e2d_namlen = cnp->cn_namelen;
745 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
746 (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
747 newdir.e2d_type = inot2ext2dt(IFTODT(ip->i_e2fs_mode));
748 } else {
749 newdir.e2d_type = 0;
750 }
751 memcpy(newdir.e2d_name, cnp->cn_nameptr, (unsigned)cnp->cn_namelen + 1);
752 newentrysize = EXT2FS_DIRSIZ(cnp->cn_namelen);
753 if (ulr->ulr_count == 0) {
754 /*
755 * If ulr_count is 0, then namei could find no
756 * space in the directory. Here, ulr_offset will
757 * be on a directory block boundary and we will write the
758 * new entry into a fresh block.
759 */
760 if (ulr->ulr_offset & (dirblksiz - 1))
761 panic("ext2fs_direnter: newblk");
762 auio.uio_offset = ulr->ulr_offset;
763 newdir.e2d_reclen = h2fs16(dirblksiz);
764 auio.uio_resid = newentrysize;
765 aiov.iov_len = newentrysize;
766 aiov.iov_base = (void *)&newdir;
767 auio.uio_iov = &aiov;
768 auio.uio_iovcnt = 1;
769 auio.uio_rw = UIO_WRITE;
770 UIO_SETUP_SYSSPACE(&auio);
771 error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred);
772 if (dirblksiz > dvp->v_mount->mnt_stat.f_bsize)
773 /* XXX should grow with balloc() */
774 panic("ext2fs_direnter: frag size");
775 else if (!error) {
776 error = ext2fs_setsize(dp,
777 roundup(ext2fs_size(dp), dirblksiz));
778 if (error)
779 return (error);
780 dp->i_flag |= IN_CHANGE;
781 uvm_vnp_setsize(dvp, ext2fs_size(dp));
782 }
783 return (error);
784 }
785
786 /*
787 * If ulr_count is non-zero, then namei found space
788 * for the new entry in the range ulr_offset to
789 * ulr_offset + ulr_count in the directory.
790 * To use this space, we may have to compact the entries located
791 * there, by copying them together towards the beginning of the
792 * block, leaving the free space in one usable chunk at the end.
793 */
794
795 /*
796 * Get the block containing the space for the new directory entry.
797 */
798 if ((error = ext2fs_blkatoff(dvp, (off_t)ulr->ulr_offset, &dirbuf, &bp)) != 0)
799 return (error);
800 /*
801 * Find space for the new entry. In the simple case, the entry at
802 * offset base will have the space. If it does not, then namei
803 * arranged that compacting the region ulr_offset to
804 * ulr_offset + ulr_count would yield the
805 * space.
806 */
807 ep = (struct ext2fs_direct *)dirbuf;
808 dsize = EXT2FS_DIRSIZ(ep->e2d_namlen);
809 spacefree = fs2h16(ep->e2d_reclen) - dsize;
810 for (loc = fs2h16(ep->e2d_reclen); loc < ulr->ulr_count; ) {
811 nep = (struct ext2fs_direct *)(dirbuf + loc);
812 if (ep->e2d_ino) {
813 /* trim the existing slot */
814 ep->e2d_reclen = h2fs16(dsize);
815 ep = (struct ext2fs_direct *)((char *)ep + dsize);
816 } else {
817 /* overwrite; nothing there; header is ours */
818 spacefree += dsize;
819 }
820 dsize = EXT2FS_DIRSIZ(nep->e2d_namlen);
821 spacefree += fs2h16(nep->e2d_reclen) - dsize;
822 loc += fs2h16(nep->e2d_reclen);
823 memcpy((void *)ep, (void *)nep, dsize);
824 }
825 /*
826 * Update the pointer fields in the previous entry (if any),
827 * copy in the new entry, and write out the block.
828 */
829 if (ep->e2d_ino == 0) {
830 #ifdef DIAGNOSTIC
831 if (spacefree + dsize < newentrysize)
832 panic("ext2fs_direnter: compact1");
833 #endif
834 newdir.e2d_reclen = h2fs16(spacefree + dsize);
835 } else {
836 #ifdef DIAGNOSTIC
837 if (spacefree < newentrysize) {
838 printf("ext2fs_direnter: compact2 %u %u",
839 (u_int)spacefree, (u_int)newentrysize);
840 panic("ext2fs_direnter: compact2");
841 }
842 #endif
843 newdir.e2d_reclen = h2fs16(spacefree);
844 ep->e2d_reclen = h2fs16(dsize);
845 ep = (struct ext2fs_direct *)((char *)ep + dsize);
846 }
847 memcpy((void *)ep, (void *)&newdir, (u_int)newentrysize);
848 error = VOP_BWRITE(bp->b_vp, bp);
849 dp->i_flag |= IN_CHANGE | IN_UPDATE;
850 if (!error && ulr->ulr_endoff && ulr->ulr_endoff < ext2fs_size(dp))
851 error = ext2fs_truncate(dvp, (off_t)ulr->ulr_endoff, IO_SYNC,
852 cnp->cn_cred);
853 return (error);
854 }
855
856 /*
857 * Remove a directory entry after a call to namei, using
858 * the auxiliary results it provided. The entry
859 * ulr_offset contains the offset into the directory of the
860 * entry to be eliminated. The ulr_count field contains the
861 * size of the previous record in the directory. If this
862 * is 0, the first entry is being deleted, so we need only
863 * zero the inode number to mark the entry as free. If the
864 * entry is not the first in the directory, we must reclaim
865 * the space of the now empty record by adding the record size
866 * to the size of the previous entry.
867 */
868 int
ext2fs_dirremove(struct vnode * dvp,const struct ufs_lookup_results * ulr,struct componentname * cnp)869 ext2fs_dirremove(struct vnode *dvp, const struct ufs_lookup_results *ulr,
870 struct componentname *cnp)
871 {
872 struct inode *dp;
873 struct ext2fs_direct *ep;
874 struct buf *bp;
875 int error;
876
877 dp = VTOI(dvp);
878
879 if (ulr->ulr_count == 0) {
880 /*
881 * First entry in block: set d_ino to zero.
882 */
883 error = ext2fs_blkatoff(dvp, (off_t)ulr->ulr_offset,
884 (void *)&ep, &bp);
885 if (error != 0)
886 return (error);
887 ep->e2d_ino = 0;
888 error = VOP_BWRITE(bp->b_vp, bp);
889 dp->i_flag |= IN_CHANGE | IN_UPDATE;
890 return (error);
891 }
892 /*
893 * Collapse new free space into previous entry.
894 */
895 error = ext2fs_blkatoff(dvp, (off_t)(ulr->ulr_offset - ulr->ulr_count),
896 (void *)&ep, &bp);
897 if (error != 0)
898 return (error);
899 ep->e2d_reclen = h2fs16(fs2h16(ep->e2d_reclen) + ulr->ulr_reclen);
900 error = VOP_BWRITE(bp->b_vp, bp);
901 dp->i_flag |= IN_CHANGE | IN_UPDATE;
902 return (error);
903 }
904
905 /*
906 * Rewrite an existing directory entry to point at the inode
907 * supplied. The parameters describing the directory entry are
908 * set up by a call to namei.
909 */
910 int
ext2fs_dirrewrite(struct inode * dp,const struct ufs_lookup_results * ulr,struct inode * ip,struct componentname * cnp)911 ext2fs_dirrewrite(struct inode *dp, const struct ufs_lookup_results *ulr,
912 struct inode *ip, struct componentname *cnp)
913 {
914 struct buf *bp;
915 struct ext2fs_direct *ep;
916 struct vnode *vdp = ITOV(dp);
917 int error;
918
919 error = ext2fs_blkatoff(vdp, (off_t)ulr->ulr_offset, (void *)&ep, &bp);
920 if (error != 0)
921 return (error);
922 ep->e2d_ino = h2fs32(ip->i_number);
923 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
924 (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
925 ep->e2d_type = inot2ext2dt(IFTODT(ip->i_e2fs_mode));
926 } else {
927 ep->e2d_type = 0;
928 }
929 error = VOP_BWRITE(bp->b_vp, bp);
930 dp->i_flag |= IN_CHANGE | IN_UPDATE;
931 return (error);
932 }
933
934 /*
935 * Check if a directory is empty or not.
936 * Inode supplied must be locked.
937 *
938 * Using a struct dirtemplate here is not precisely
939 * what we want, but better than using a struct ext2fs_direct.
940 *
941 * NB: does not handle corrupted directories.
942 */
943 int
ext2fs_dirempty(struct inode * ip,ino_t parentino,kauth_cred_t cred)944 ext2fs_dirempty(struct inode *ip, ino_t parentino, kauth_cred_t cred)
945 {
946 off_t off;
947 struct ext2fs_dirtemplate dbuf;
948 struct ext2fs_direct *dp = (struct ext2fs_direct *)&dbuf;
949 int error, namlen;
950 size_t count;
951
952 #define MINDIRSIZ (sizeof (struct ext2fs_dirtemplate) / 2)
953
954 for (off = 0; off < ext2fs_size(ip); off += fs2h16(dp->e2d_reclen)) {
955 error = ufs_bufio(UIO_READ, ITOV(ip), (void *)dp, MINDIRSIZ,
956 off, IO_NODELOCKED, cred, &count, NULL);
957 /*
958 * Since we read MINDIRSIZ, residual must
959 * be 0 unless we're at end of file.
960 */
961 if (error || count != 0)
962 return (0);
963 /* avoid infinite loops */
964 if (dp->e2d_reclen == 0)
965 return (0);
966 /* skip empty entries */
967 if (dp->e2d_ino == 0)
968 continue;
969 /* accept only "." and ".." */
970 namlen = dp->e2d_namlen;
971 if (namlen > 2)
972 return (0);
973 if (dp->e2d_name[0] != '.')
974 return (0);
975 /*
976 * At this point namlen must be 1 or 2.
977 * 1 implies ".", 2 implies ".." if second
978 * char is also "."
979 */
980 if (namlen == 1)
981 continue;
982 if (dp->e2d_name[1] == '.' && fs2h32(dp->e2d_ino) == parentino)
983 continue;
984 return (0);
985 }
986 return (1);
987 }
988