1 /* $NetBSD: msdosfs_lookup.c,v 1.34 2015/03/28 19:24:05 maxv Exp $ */
2
3 /*-
4 * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
5 * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
6 * All rights reserved.
7 * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by TooLs GmbH.
20 * 4. The name of TooLs GmbH may not be used to endorse or promote products
21 * derived from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
29 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
31 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
32 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34 /*
35 * Written by Paul Popelka (paulp@uts.amdahl.com)
36 *
37 * You can do anything you want with this software, just don't say you wrote
38 * it, and don't remove this notice.
39 *
40 * This software is provided "as is".
41 *
42 * The author supplies this software to be publicly redistributed on the
43 * understanding that the author is not responsible for the correct
44 * functioning of this software in any circumstances and is not liable for
45 * any damages caused by this software.
46 *
47 * October 1992
48 */
49
50 #if HAVE_NBTOOL_CONFIG_H
51 #include "nbtool_config.h"
52 #endif
53
54 #include <sys/cdefs.h>
55 __KERNEL_RCSID(0, "$NetBSD: msdosfs_lookup.c,v 1.34 2015/03/28 19:24:05 maxv Exp $");
56
57 #include <sys/param.h>
58
59 #ifdef _KERNEL
60 #include <sys/systm.h>
61 #include <sys/mount.h>
62 #include <sys/kauth.h>
63 #include <sys/namei.h>
64 #include <sys/dirent.h>
65 #include <sys/buf.h>
66 #include <sys/vnode.h>
67 #include <sys/atomic.h>
68 #else
69 #include <ffs/buf.h>
70 #endif /* _KERNEL */
71
72 #include <fs/msdosfs/bpb.h>
73 #include <fs/msdosfs/direntry.h>
74 #include <fs/msdosfs/denode.h>
75 #include <fs/msdosfs/msdosfsmount.h>
76 #include <fs/msdosfs/fat.h>
77
78
79 #ifdef _KERNEL
80 /*
81 * When we search a directory the blocks containing directory entries are
82 * read and examined. The directory entries contain information that would
83 * normally be in the inode of a unix filesystem. This means that some of
84 * a directory's contents may also be in memory resident denodes (sort of
85 * an inode). This can cause problems if we are searching while some other
86 * process is modifying a directory. To prevent one process from accessing
87 * incompletely modified directory information we depend upon being the
88 * sole owner of a directory block. bread/brelse provide this service.
89 * This being the case, when a process modifies a directory it must first
90 * acquire the disk block that contains the directory entry to be modified.
91 * Then update the disk block and the denode, and then write the disk block
92 * out to disk. This way disk blocks containing directory entries and in
93 * memory denode's will be in synch.
94 */
95 int
msdosfs_lookup(void * v)96 msdosfs_lookup(void *v)
97 {
98 struct vop_lookup_v2_args /* {
99 struct vnode *a_dvp;
100 struct vnode **a_vpp;
101 struct componentname *a_cnp;
102 } */ *ap = v;
103 struct vnode *vdp = ap->a_dvp;
104 struct vnode **vpp = ap->a_vpp;
105 struct componentname *cnp = ap->a_cnp;
106 daddr_t bn;
107 int error;
108 int slotcount;
109 int slotoffset = 0;
110 int frcn;
111 u_long cluster;
112 int blkoff;
113 int diroff;
114 int blsize;
115 int isadir; /* ~0 if found direntry is a directory */
116 u_long scn; /* starting cluster number */
117 struct denode *dp;
118 struct msdosfsmount *pmp;
119 struct buf *bp = 0;
120 struct direntry *dep;
121 u_char dosfilename[12];
122 int flags;
123 int nameiop = cnp->cn_nameiop;
124 int wincnt = 1;
125 int chksum = -1, chksum_ok;
126 int olddos = 1;
127
128 flags = cnp->cn_flags;
129
130 #ifdef MSDOSFS_DEBUG
131 printf("msdosfs_lookup(): looking for %.*s\n",
132 (int)cnp->cn_namelen, cnp->cn_nameptr);
133 #endif
134 dp = VTODE(vdp);
135 pmp = dp->de_pmp;
136 *vpp = NULL;
137 #ifdef MSDOSFS_DEBUG
138 printf("msdosfs_lookup(): vdp %p, dp %p, Attr %02x\n",
139 vdp, dp, dp->de_Attributes);
140 #endif
141
142 /*
143 * Check accessiblity of directory.
144 */
145 if ((error = VOP_ACCESS(vdp, VEXEC, cnp->cn_cred)) != 0)
146 return (error);
147
148 if ((flags & ISLASTCN) && (vdp->v_mount->mnt_flag & MNT_RDONLY) &&
149 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
150 return (EROFS);
151
152 /*
153 * We now have a segment name to search for, and a directory to search.
154 *
155 * Before tediously performing a linear scan of the directory,
156 * check the name cache to see if the directory/name pair
157 * we are looking for is known already.
158 */
159 if (cache_lookup(vdp, cnp->cn_nameptr, cnp->cn_namelen,
160 cnp->cn_nameiop, cnp->cn_flags, NULL, vpp)) {
161 return *vpp == NULLVP ? ENOENT: 0;
162 }
163
164 /*
165 * If they are going after the . or .. entry in the root directory,
166 * they won't find it. DOS filesystems don't have them in the root
167 * directory. So, we fake it. deget() is in on this scam too.
168 */
169 if ((vdp->v_vflag & VV_ROOT) && cnp->cn_nameptr[0] == '.' &&
170 (cnp->cn_namelen == 1 ||
171 (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.'))) {
172 isadir = ATTR_DIRECTORY;
173 scn = MSDOSFSROOT;
174 #ifdef MSDOSFS_DEBUG
175 printf("msdosfs_lookup(): looking for . or .. in root directory\n");
176 #endif
177 cluster = MSDOSFSROOT;
178 blkoff = MSDOSFSROOT_OFS;
179 goto foundroot;
180 }
181
182 switch (unix2dosfn((const u_char *)cnp->cn_nameptr, dosfilename,
183 cnp->cn_namelen, 0)) {
184 case 0:
185 return (EINVAL);
186 case 1:
187 break;
188 case 2:
189 wincnt = winSlotCnt((const u_char *)cnp->cn_nameptr,
190 cnp->cn_namelen) + 1;
191 break;
192 case 3:
193 olddos = 0;
194 wincnt = winSlotCnt((const u_char *)cnp->cn_nameptr,
195 cnp->cn_namelen) + 1;
196 break;
197 }
198 if (pmp->pm_flags & MSDOSFSMNT_SHORTNAME)
199 wincnt = 1;
200
201 /*
202 * Suppress search for slots unless creating
203 * file and at end of pathname, in which case
204 * we watch for a place to put the new file in
205 * case it doesn't already exist.
206 */
207 slotcount = wincnt;
208 if ((nameiop == CREATE || nameiop == RENAME) &&
209 (flags & ISLASTCN))
210 slotcount = 0;
211
212 #ifdef MSDOSFS_DEBUG
213 printf("msdosfs_lookup(): dos filename: %s\n", dosfilename);
214 #endif
215 /*
216 * Search the directory pointed at by vdp for the name pointed at
217 * by cnp->cn_nameptr.
218 */
219
220 /*
221 * The outer loop ranges over the clusters that make up the
222 * directory. Note that the root directory is different from all
223 * other directories. It has a fixed number of blocks that are not
224 * part of the pool of allocatable clusters. So, we treat it a
225 * little differently. The root directory starts at "cluster" 0.
226 */
227 diroff = 0;
228 for (frcn = 0; diroff < dp->de_FileSize; frcn++) {
229 if ((error = pcbmap(dp, frcn, &bn, &cluster, &blsize)) != 0) {
230 if (error == E2BIG)
231 break;
232 return (error);
233 }
234 error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
235 0, &bp);
236 if (error) {
237 return (error);
238 }
239 for (blkoff = 0; blkoff < blsize;
240 blkoff += sizeof(struct direntry),
241 diroff += sizeof(struct direntry)) {
242 dep = (struct direntry *)((char *)bp->b_data + blkoff);
243 /*
244 * If the slot is empty and we are still looking
245 * for an empty then remember this one. If the
246 * slot is not empty then check to see if it
247 * matches what we are looking for. If the slot
248 * has never been filled with anything, then the
249 * remainder of the directory has never been used,
250 * so there is no point in searching it.
251 */
252 if (dep->deName[0] == SLOT_EMPTY ||
253 dep->deName[0] == SLOT_DELETED) {
254 /*
255 * Drop memory of previous long matches
256 */
257 chksum = -1;
258
259 if (slotcount < wincnt) {
260 slotcount++;
261 slotoffset = diroff;
262 }
263 if (dep->deName[0] == SLOT_EMPTY) {
264 brelse(bp, 0);
265 goto notfound;
266 }
267 } else {
268 /*
269 * If there wasn't enough space for our
270 * winentries, forget about the empty space
271 */
272 if (slotcount < wincnt)
273 slotcount = 0;
274
275 /*
276 * Check for Win95 long filename entry
277 */
278 if (dep->deAttributes == ATTR_WIN95) {
279 if (pmp->pm_flags & MSDOSFSMNT_SHORTNAME)
280 continue;
281
282 chksum = winChkName((const u_char *)cnp->cn_nameptr,
283 cnp->cn_namelen,
284 (struct winentry *)dep,
285 chksum);
286 continue;
287 }
288
289 /*
290 * Ignore volume labels (anywhere, not just
291 * the root directory).
292 */
293 if (dep->deAttributes & ATTR_VOLUME) {
294 chksum = -1;
295 continue;
296 }
297
298 /*
299 * Check for a checksum or name match
300 */
301 chksum_ok = (chksum == winChksum(dep->deName));
302 if (!chksum_ok && (
303 !olddos ||
304 memcmp(&dosfilename[0],dep->deName,8) ||
305 memcmp(&dosfilename[8],dep->deExtension,3))) {
306 chksum = -1;
307 continue;
308 }
309 #ifdef MSDOSFS_DEBUG
310 printf("msdosfs_lookup(): match blkoff %d, diroff %d\n",
311 blkoff, diroff);
312 #endif
313 /*
314 * Remember where this directory
315 * entry came from for whoever did
316 * this lookup.
317 */
318 dp->de_fndoffset = diroff;
319 if (chksum_ok && nameiop == RENAME) {
320 /*
321 * Target had correct long name
322 * directory entries, reuse them
323 * as needed.
324 */
325 dp->de_fndcnt = wincnt - 1;
326 } else {
327 /*
328 * Long name directory entries
329 * not present or corrupt, can only
330 * reuse dos directory entry.
331 */
332 dp->de_fndcnt = 0;
333 }
334
335 goto found;
336 }
337 } /* for (blkoff = 0; .... */
338 /*
339 * Release the buffer holding the directory cluster just
340 * searched.
341 */
342 brelse(bp, 0);
343 } /* for (frcn = 0; ; frcn++) */
344
345 notfound:
346 /*
347 * We hold no disk buffers at this point.
348 */
349
350 /*
351 * If we get here we didn't find the entry we were looking for. But
352 * that's ok if we are creating or renaming and are at the end of
353 * the pathname and the directory hasn't been removed.
354 */
355 #ifdef MSDOSFS_DEBUG
356 printf("msdosfs_lookup(): op %d, refcnt %ld, slotcount %d, slotoffset %d\n",
357 nameiop, dp->de_refcnt, slotcount, slotoffset);
358 #endif
359 if ((nameiop == CREATE || nameiop == RENAME) &&
360 (flags & ISLASTCN) && dp->de_refcnt != 0) {
361 /*
362 * Access for write is interpreted as allowing
363 * creation of files in the directory.
364 */
365 error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred);
366 if (error)
367 return (error);
368
369 /*
370 * Fixup the slot description to point to the place where
371 * we might put the new DOS direntry (putting the Win95
372 * long name entries before that)
373 */
374 if (!slotcount) {
375 slotcount = 1;
376 slotoffset = diroff;
377 }
378 if (wincnt > slotcount) {
379 slotoffset +=
380 sizeof(struct direntry) * (wincnt - slotcount);
381 }
382
383 /*
384 * Return an indication of where the new directory
385 * entry should be put.
386 */
387 dp->de_fndoffset = slotoffset;
388 dp->de_fndcnt = wincnt - 1;
389
390 /*
391 * We return with the directory locked, so that
392 * the parameters we set up above will still be
393 * valid if we actually decide to do a direnter().
394 * We return ni_vp == NULL to indicate that the entry
395 * does not currently exist; we leave a pointer to
396 * the (locked) directory inode in ndp->ni_dvp.
397 *
398 * NB - if the directory is unlocked, then this
399 * information cannot be used.
400 */
401 return (EJUSTRETURN);
402 }
403
404 #if 0
405 /*
406 * Insert name into cache (as non-existent) if appropriate.
407 *
408 * XXX Negative caching is broken for msdosfs because the name
409 * cache doesn't understand peculiarities such as case insensitivity
410 * and 8.3 filenames. Hence, it may not invalidate all negative
411 * entries if a file with this name is later created.
412 * e.g. creating a file 'foo' won't invalidate a negative entry
413 * for 'FOO'.
414 */
415 if (nameiop != CREATE)
416 cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen,
417 cnp->cn_flags);
418 #endif
419
420 return (ENOENT);
421
422 found:
423 /*
424 * NOTE: We still have the buffer with matched directory entry at
425 * this point.
426 */
427 isadir = dep->deAttributes & ATTR_DIRECTORY;
428 scn = getushort(dep->deStartCluster);
429 if (FAT32(pmp)) {
430 scn |= getushort(dep->deHighClust) << 16;
431 if (scn == pmp->pm_rootdirblk) {
432 /*
433 * There should actually be 0 here.
434 * Just ignore the error.
435 */
436 scn = MSDOSFSROOT;
437 }
438 }
439
440 if (isadir) {
441 cluster = scn;
442 if (cluster == MSDOSFSROOT)
443 blkoff = MSDOSFSROOT_OFS;
444 else
445 blkoff = 0;
446 } else if (cluster == MSDOSFSROOT)
447 blkoff = diroff;
448
449 /*
450 * Now release buf to allow deget to read the entry again.
451 * Reserving it here and giving it to deget could result
452 * in a deadlock.
453 */
454 brelse(bp, 0);
455
456 foundroot:
457 /*
458 * If we entered at foundroot, then we are looking for the . or ..
459 * entry of the filesystems root directory. isadir and scn were
460 * setup before jumping here. And, bp is already null.
461 */
462 if (FAT32(pmp) && scn == MSDOSFSROOT)
463 scn = pmp->pm_rootdirblk;
464
465 /*
466 * If deleting, and at end of pathname, return
467 * parameters which can be used to remove file.
468 * Lock the inode, being careful with ".".
469 */
470 if (nameiop == DELETE && (flags & ISLASTCN)) {
471 /*
472 * Don't allow deleting the root.
473 */
474 if (blkoff == MSDOSFSROOT_OFS)
475 return EINVAL;
476
477 /*
478 * Write access to directory required to delete files.
479 */
480 error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred);
481 if (error)
482 return (error);
483
484 /*
485 * Return pointer to current entry in dp->i_offset.
486 * Save directory inode pointer in ndp->ni_dvp for dirremove().
487 */
488 if (dp->de_StartCluster == scn && isadir) { /* "." */
489 vref(vdp);
490 *vpp = vdp;
491 return (0);
492 }
493 error = deget(pmp, cluster, blkoff, vpp);
494 return error;
495 }
496
497 /*
498 * If rewriting (RENAME), return the inode and the
499 * information required to rewrite the present directory
500 * Must get inode of directory entry to verify it's a
501 * regular file, or empty directory.
502 */
503 if (nameiop == RENAME && (flags & ISLASTCN)) {
504
505 if (vdp->v_mount->mnt_flag & MNT_RDONLY)
506 return (EROFS);
507
508 if (blkoff == MSDOSFSROOT_OFS)
509 return EINVAL;
510
511 error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred);
512 if (error)
513 return (error);
514
515 /*
516 * Careful about locking second inode.
517 * This can only occur if the target is ".".
518 */
519 if (dp->de_StartCluster == scn && isadir)
520 return (EISDIR);
521
522 error = deget(pmp, cluster, blkoff, vpp);
523 return error;
524 }
525
526 if (dp->de_StartCluster == scn && isadir) {
527 vref(vdp); /* we want ourself, ie "." */
528 *vpp = vdp;
529 } else if ((error = deget(pmp, cluster, blkoff, vpp)) != 0) {
530 return error;
531 }
532
533 /*
534 * Insert name into cache if appropriate.
535 */
536 cache_enter(vdp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
537
538 return 0;
539 }
540 #endif /* _KERNEL */
541
542 /*
543 * dep - directory entry to copy into the directory
544 * ddep - directory to add to
545 * depp - return the address of the denode for the created directory entry
546 * if depp != 0
547 * cnp - componentname needed for Win95 long filenames
548 */
549 int
createde(struct denode * dep,struct denode * ddep,struct denode ** depp,struct componentname * cnp)550 createde(struct denode *dep, struct denode *ddep, struct denode **depp, struct componentname *cnp)
551 {
552 int error, rberror;
553 u_long dirclust, clusoffset;
554 u_long fndoffset, havecnt = 0, wcnt = 1, i;
555 struct direntry *ndep;
556 struct msdosfsmount *pmp = ddep->de_pmp;
557 struct buf *bp;
558 daddr_t bn;
559 int blsize;
560 #ifdef _KERNEL
561 int async = ddep->de_pmp->pm_mountp->mnt_flag & MNT_ASYNC;
562 #else
563 #define async 0
564 #endif
565
566 #ifdef MSDOSFS_DEBUG
567 printf("createde(dep %p, ddep %p, depp %p, cnp %p)\n",
568 dep, ddep, depp, cnp);
569 #endif
570
571 /*
572 * If no space left in the directory then allocate another cluster
573 * and chain it onto the end of the file. There is one exception
574 * to this. That is, if the root directory has no more space it
575 * can NOT be expanded. extendfile() checks for and fails attempts
576 * to extend the root directory. We just return an error in that
577 * case.
578 */
579 if (ddep->de_fndoffset >= ddep->de_FileSize) {
580 u_long needlen = ddep->de_fndoffset + sizeof(struct direntry)
581 - ddep->de_FileSize;
582 dirclust = de_clcount(pmp, needlen);
583 if ((error = extendfile(ddep, dirclust, 0, 0, DE_CLEAR)) != 0) {
584 (void)detrunc(ddep, ddep->de_FileSize, 0, NOCRED);
585 goto err_norollback;
586 }
587
588 /*
589 * Update the size of the directory
590 */
591 ddep->de_FileSize += de_cn2off(pmp, dirclust);
592 }
593
594 /*
595 * We just read in the cluster with space. Copy the new directory
596 * entry in. Then write it to disk. NOTE: DOS directories
597 * do not get smaller as clusters are emptied.
598 */
599 error = pcbmap(ddep, de_cluster(pmp, ddep->de_fndoffset),
600 &bn, &dirclust, &blsize);
601 if (error)
602 goto err_norollback;
603 clusoffset = ddep->de_fndoffset;
604 if (dirclust != MSDOSFSROOT)
605 clusoffset &= pmp->pm_crbomask;
606 if ((error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
607 B_MODIFY, &bp)) != 0) {
608 goto err_norollback;
609 }
610 ndep = bptoep(pmp, bp, clusoffset);
611
612 DE_EXTERNALIZE(ndep, dep);
613
614 /*
615 * Now write the Win95 long name
616 */
617 if (ddep->de_fndcnt > 0) {
618 u_int8_t chksum = winChksum(ndep->deName);
619 const u_char *un = (const u_char *)cnp->cn_nameptr;
620 int unlen = cnp->cn_namelen;
621 u_long xhavecnt;
622
623 fndoffset = ddep->de_fndoffset;
624 xhavecnt = ddep->de_fndcnt + 1;
625
626 for(; wcnt < xhavecnt; wcnt++) {
627 if ((fndoffset & pmp->pm_crbomask) == 0) {
628 /* we should never get here if ddep is root
629 * directory */
630
631 if (async)
632 (void) bdwrite(bp);
633 else if ((error = bwrite(bp)) != 0)
634 goto rollback;
635
636 fndoffset -= sizeof(struct direntry);
637 error = pcbmap(ddep,
638 de_cluster(pmp, fndoffset),
639 &bn, 0, &blsize);
640 if (error)
641 goto rollback;
642
643 error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn),
644 blsize, B_MODIFY, &bp);
645 if (error) {
646 goto rollback;
647 }
648 ndep = bptoep(pmp, bp,
649 fndoffset & pmp->pm_crbomask);
650 } else {
651 ndep--;
652 fndoffset -= sizeof(struct direntry);
653 }
654 if (!unix2winfn(un, unlen, (struct winentry *)ndep,
655 wcnt, chksum))
656 break;
657 }
658 }
659
660 if (async)
661 bdwrite(bp);
662 else if ((error = bwrite(bp)) != 0)
663 goto rollback;
664
665 /*
666 * If they want us to return with the denode gotten.
667 */
668 if (depp) {
669 u_long diroffset = clusoffset;
670
671 if (dep->de_Attributes & ATTR_DIRECTORY) {
672 dirclust = dep->de_StartCluster;
673 if (FAT32(pmp) && dirclust == pmp->pm_rootdirblk)
674 dirclust = MSDOSFSROOT;
675 if (dirclust == MSDOSFSROOT)
676 diroffset = MSDOSFSROOT_OFS;
677 else
678 diroffset = 0;
679 }
680 #ifdef MAKEFS
681 error = deget(pmp, dirclust, diroffset, depp);
682 #else
683 struct vnode *vp;
684
685 error = deget(pmp, dirclust, diroffset, &vp);
686 if (error == 0)
687 *depp = VTODE(vp);
688 else
689 *depp = NULL;
690 #endif
691 return error;
692 }
693
694 return 0;
695
696 rollback:
697 /*
698 * Mark all slots modified so far as deleted. Note that we
699 * can't just call removede(), since directory is not in
700 * consistent state.
701 */
702 fndoffset = ddep->de_fndoffset;
703 rberror = pcbmap(ddep, de_cluster(pmp, fndoffset),
704 &bn, NULL, &blsize);
705 if (rberror)
706 goto err_norollback;
707 if ((rberror = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
708 B_MODIFY, &bp)) != 0) {
709 goto err_norollback;
710 }
711 ndep = bptoep(pmp, bp, clusoffset);
712
713 havecnt = ddep->de_fndcnt + 1;
714 for(i = wcnt; i <= havecnt; i++) {
715 /* mark entry as deleted */
716 ndep->deName[0] = SLOT_DELETED;
717
718 if ((fndoffset & pmp->pm_crbomask) == 0) {
719 /* we should never get here if ddep is root
720 * directory */
721
722 if (async)
723 bdwrite(bp);
724 else if ((rberror = bwrite(bp)) != 0)
725 goto err_norollback;
726
727 fndoffset -= sizeof(struct direntry);
728 rberror = pcbmap(ddep,
729 de_cluster(pmp, fndoffset),
730 &bn, 0, &blsize);
731 if (rberror)
732 goto err_norollback;
733
734 rberror = bread(pmp->pm_devvp, de_bn2kb(pmp, bn),
735 blsize, B_MODIFY, &bp);
736 if (rberror) {
737 goto err_norollback;
738 }
739 ndep = bptoep(pmp, bp, fndoffset);
740 } else {
741 ndep--;
742 fndoffset -= sizeof(struct direntry);
743 }
744 }
745
746 /* ignore any further error */
747 if (async)
748 (void) bdwrite(bp);
749 else
750 (void) bwrite(bp);
751
752 err_norollback:
753 return error;
754 }
755
756 /*
757 * Be sure a directory is empty except for "." and "..". Return 1 if empty,
758 * return 0 if not empty or error.
759 */
760 int
dosdirempty(struct denode * dep)761 dosdirempty(struct denode *dep)
762 {
763 int blsize;
764 int error;
765 u_long cn;
766 daddr_t bn;
767 struct buf *bp;
768 struct msdosfsmount *pmp = dep->de_pmp;
769 struct direntry *dentp;
770
771 /*
772 * Since the filesize field in directory entries for a directory is
773 * zero, we just have to feel our way through the directory until
774 * we hit end of file.
775 */
776 for (cn = 0;; cn++) {
777 if ((error = pcbmap(dep, cn, &bn, 0, &blsize)) != 0) {
778 if (error == E2BIG)
779 return (1); /* it's empty */
780 return (0);
781 }
782 error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
783 0, &bp);
784 if (error) {
785 return (0);
786 }
787 for (dentp = (struct direntry *)bp->b_data;
788 (char *)dentp < (char *)bp->b_data + blsize;
789 dentp++) {
790 if (dentp->deName[0] != SLOT_DELETED &&
791 (dentp->deAttributes & ATTR_VOLUME) == 0) {
792 /*
793 * In dos directories an entry whose name
794 * starts with SLOT_EMPTY (0) starts the
795 * beginning of the unused part of the
796 * directory, so we can just return that it
797 * is empty.
798 */
799 if (dentp->deName[0] == SLOT_EMPTY) {
800 brelse(bp, 0);
801 return (1);
802 }
803 /*
804 * Any names other than "." and ".." in a
805 * directory mean it is not empty.
806 */
807 if (memcmp(dentp->deName, ". ", 11) &&
808 memcmp(dentp->deName, ".. ", 11)) {
809 brelse(bp, 0);
810 #ifdef MSDOSFS_DEBUG
811 printf("dosdirempty(): found %.11s, %d, %d\n",
812 dentp->deName, dentp->deName[0],
813 dentp->deName[1]);
814 #endif
815 return (0); /* not empty */
816 }
817 }
818 }
819 brelse(bp, 0);
820 }
821 /* NOTREACHED */
822 }
823
824 /*
825 * Check to see if the directory described by target is in some
826 * subdirectory of source. This prevents something like the following from
827 * succeeding and leaving a bunch or files and directories orphaned. mv
828 * /a/b/c /a/b/c/d/e/f Where c and f are directories.
829 *
830 * source - the inode for /a/b/c
831 * target - the inode for /a/b/c/d/e/f
832 *
833 * Returns 0 if target is NOT a subdirectory of source.
834 * Otherwise returns a non-zero error number.
835 * The target inode is always unlocked on return.
836 */
837 int
doscheckpath(struct denode * source,struct denode * target)838 doscheckpath(struct denode *source, struct denode *target)
839 {
840 u_long scn;
841 struct msdosfsmount *pmp;
842 struct direntry *ep;
843 struct denode *dep;
844 struct buf *bp = NULL;
845 int error = 0;
846
847 dep = target;
848 if ((target->de_Attributes & ATTR_DIRECTORY) == 0 ||
849 (source->de_Attributes & ATTR_DIRECTORY) == 0) {
850 error = ENOTDIR;
851 goto out;
852 }
853 if (dep->de_StartCluster == source->de_StartCluster) {
854 error = EEXIST;
855 goto out;
856 }
857 if (dep->de_StartCluster == MSDOSFSROOT)
858 goto out;
859 pmp = dep->de_pmp;
860 #ifdef DIAGNOSTIC
861 if (pmp != source->de_pmp)
862 panic("doscheckpath: source and target on different filesystems");
863 #endif
864 if (FAT32(pmp) && dep->de_StartCluster == pmp->pm_rootdirblk)
865 goto out;
866
867 for (;;) {
868 if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) {
869 error = ENOTDIR;
870 break;
871 }
872 scn = dep->de_StartCluster;
873 error = bread(pmp->pm_devvp, de_bn2kb(pmp, cntobn(pmp, scn)),
874 pmp->pm_bpcluster, 0, &bp);
875 if (error)
876 break;
877
878 ep = (struct direntry *) bp->b_data + 1;
879 if ((ep->deAttributes & ATTR_DIRECTORY) == 0 ||
880 memcmp(ep->deName, ".. ", 11) != 0) {
881 error = ENOTDIR;
882 break;
883 }
884 scn = getushort(ep->deStartCluster);
885 if (FAT32(pmp))
886 scn |= getushort(ep->deHighClust) << 16;
887
888 if (scn == source->de_StartCluster) {
889 error = EINVAL;
890 break;
891 }
892 if (scn == MSDOSFSROOT)
893 break;
894 if (FAT32(pmp) && scn == pmp->pm_rootdirblk) {
895 /*
896 * scn should be 0 in this case,
897 * but we silently ignore the error.
898 */
899 break;
900 }
901
902 vput(DETOV(dep));
903 brelse(bp, 0);
904 bp = NULL;
905 #ifdef MAKEFS
906 /* NOTE: deget() clears dep on error */
907 if ((error = deget(pmp, scn, 0, &dep)) != 0)
908 break;
909 #else
910 struct vnode *vp;
911
912 dep = NULL;
913 error = deget(pmp, scn, 0, &vp);
914 if (error)
915 break;
916 error = vn_lock(vp, LK_EXCLUSIVE);
917 if (error) {
918 vrele(vp);
919 break;
920 }
921 dep = VTODE(vp);
922 #endif
923 }
924 out:
925 if (bp)
926 brelse(bp, 0);
927 if (error == ENOTDIR)
928 printf("doscheckpath(): .. not a directory?\n");
929 if (dep != NULL)
930 vput(DETOV(dep));
931 return (error);
932 }
933
934 /*
935 * Read in the disk block containing the directory entry (dirclu, dirofs)
936 * and return the address of the buf header, and the address of the
937 * directory entry within the block.
938 */
939 int
readep(struct msdosfsmount * pmp,u_long dirclust,u_long diroffset,struct buf ** bpp,struct direntry ** epp)940 readep(struct msdosfsmount *pmp, u_long dirclust, u_long diroffset, struct buf **bpp, struct direntry **epp)
941 {
942 int error;
943 daddr_t bn;
944 int blsize;
945
946 blsize = pmp->pm_bpcluster;
947 if (dirclust == MSDOSFSROOT
948 && de_blk(pmp, diroffset + blsize) > pmp->pm_rootdirsize)
949 blsize = de_bn2off(pmp, pmp->pm_rootdirsize) & pmp->pm_crbomask;
950 bn = detobn(pmp, dirclust, diroffset);
951 if ((error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
952 0, bpp)) != 0) {
953 *bpp = NULL;
954 return (error);
955 }
956 if (epp)
957 *epp = bptoep(pmp, *bpp, diroffset);
958 return (0);
959 }
960
961 /*
962 * Read in the disk block containing the directory entry dep came from and
963 * return the address of the buf header, and the address of the directory
964 * entry within the block.
965 */
966 int
readde(struct denode * dep,struct buf ** bpp,struct direntry ** epp)967 readde(struct denode *dep, struct buf **bpp, struct direntry **epp)
968 {
969 return (readep(dep->de_pmp, dep->de_dirclust, dep->de_diroffset,
970 bpp, epp));
971 }
972
973 /*
974 * Remove a directory entry. At this point the file represented by the
975 * directory entry to be removed is still full length until noone has it
976 * open. When the file no longer being used msdosfs_inactive() is called
977 * and will truncate the file to 0 length. When the vnode containing the
978 * denode is needed for some other purpose by VFS it will call
979 * msdosfs_reclaim() which will remove the denode from the denode cache.
980 */
981 int
removede(struct denode * pdep,struct denode * dep)982 removede(struct denode *pdep, struct denode *dep)
983 /* pdep: directory where the entry is removed */
984 /* dep: file to be removed */
985 {
986 int error;
987 struct direntry *ep;
988 struct buf *bp;
989 daddr_t bn;
990 int blsize;
991 struct msdosfsmount *pmp = pdep->de_pmp;
992 u_long offset = pdep->de_fndoffset;
993 #ifdef _KERNEL
994 int async = pdep->de_pmp->pm_mountp->mnt_flag & MNT_ASYNC;
995 #else
996 #define async 0
997 #endif
998
999 #ifdef MSDOSFS_DEBUG
1000 printf("removede(): filename %s, dep %p, offset %08lx\n",
1001 dep->de_Name, dep, offset);
1002 #endif
1003
1004 if (--dep->de_refcnt == 0) {
1005 #ifndef MAKEFS
1006 struct denode_key old_key = dep->de_key;
1007 struct denode_key new_key = dep->de_key;
1008
1009 KASSERT(new_key.dk_dirgen == NULL);
1010 new_key.dk_dirgen = dep;
1011 vcache_rekey_enter(pmp->pm_mountp, DETOV(dep), &old_key,
1012 sizeof(old_key), &new_key, sizeof(new_key));
1013 dep->de_key = new_key;
1014 vcache_rekey_exit(pmp->pm_mountp, DETOV(dep), &old_key,
1015 sizeof(old_key), &dep->de_key, sizeof(dep->de_key));
1016 #endif
1017 }
1018 offset += sizeof(struct direntry);
1019 do {
1020 offset -= sizeof(struct direntry);
1021 error = pcbmap(pdep, de_cluster(pmp, offset), &bn, 0, &blsize);
1022 if (error)
1023 return error;
1024 error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
1025 B_MODIFY, &bp);
1026 if (error) {
1027 return error;
1028 }
1029 ep = bptoep(pmp, bp, offset);
1030 /*
1031 * Check whether, if we came here the second time, i.e.
1032 * when underflowing into the previous block, the last
1033 * entry in this block is a longfilename entry, too.
1034 */
1035 if (ep->deAttributes != ATTR_WIN95
1036 && offset != pdep->de_fndoffset) {
1037 brelse(bp, 0);
1038 break;
1039 }
1040 offset += sizeof(struct direntry);
1041 while (1) {
1042 /*
1043 * We are a bit agressive here in that we delete any Win95
1044 * entries preceding this entry, not just the ones we "own".
1045 * Since these presumably aren't valid anyway,
1046 * there should be no harm.
1047 */
1048 offset -= sizeof(struct direntry);
1049 ep--->deName[0] = SLOT_DELETED;
1050 if ((pmp->pm_flags & MSDOSFSMNT_NOWIN95)
1051 || !(offset & pmp->pm_crbomask)
1052 || ep->deAttributes != ATTR_WIN95)
1053 break;
1054 }
1055 if (async)
1056 bdwrite(bp);
1057 else if ((error = bwrite(bp)) != 0)
1058 return error;
1059 } while (!(pmp->pm_flags & MSDOSFSMNT_NOWIN95)
1060 && !(offset & pmp->pm_crbomask)
1061 && offset);
1062 return 0;
1063 }
1064
1065 /*
1066 * Create a unique DOS name in dvp
1067 */
1068 int
uniqdosname(struct denode * dep,struct componentname * cnp,u_char * cp)1069 uniqdosname(struct denode *dep, struct componentname *cnp, u_char *cp)
1070 {
1071 struct msdosfsmount *pmp = dep->de_pmp;
1072 struct direntry *dentp;
1073 int gen;
1074 int blsize;
1075 u_long cn;
1076 daddr_t bn;
1077 struct buf *bp;
1078 int error;
1079
1080 for (gen = 1;; gen++) {
1081 /*
1082 * Generate DOS name with generation number
1083 */
1084 if (!unix2dosfn((const u_char *)cnp->cn_nameptr, cp,
1085 cnp->cn_namelen, gen))
1086 return gen == 1 ? EINVAL : EEXIST;
1087
1088 /*
1089 * Now look for a dir entry with this exact name
1090 */
1091 for (cn = error = 0; !error; cn++) {
1092 if ((error = pcbmap(dep, cn, &bn, 0, &blsize)) != 0) {
1093 if (error == E2BIG) /* EOF reached and not found */
1094 return 0;
1095 return error;
1096 }
1097 error = bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
1098 0, &bp);
1099 if (error) {
1100 return error;
1101 }
1102 for (dentp = (struct direntry *)bp->b_data;
1103 (char *)dentp < (char *)bp->b_data + blsize;
1104 dentp++) {
1105 if (dentp->deName[0] == SLOT_EMPTY) {
1106 /*
1107 * Last used entry and not found
1108 */
1109 brelse(bp, 0);
1110 return 0;
1111 }
1112 /*
1113 * Ignore volume labels and Win95 entries
1114 */
1115 if (dentp->deAttributes & ATTR_VOLUME)
1116 continue;
1117 if (!memcmp(dentp->deName, cp, 11)) {
1118 error = EEXIST;
1119 break;
1120 }
1121 }
1122 brelse(bp, 0);
1123 }
1124 }
1125 }
1126
1127 /*
1128 * Find any Win'95 long filename entry in directory dep
1129 */
1130 int
findwin95(struct denode * dep)1131 findwin95(struct denode *dep)
1132 {
1133 struct msdosfsmount *pmp = dep->de_pmp;
1134 struct direntry *dentp;
1135 int blsize, win95;
1136 u_long cn;
1137 daddr_t bn;
1138 struct buf *bp;
1139
1140 win95 = 1;
1141 /*
1142 * Read through the directory looking for Win'95 entries
1143 * XXX Note: Error currently handled just as EOF
1144 */
1145 for (cn = 0;; cn++) {
1146 if (pcbmap(dep, cn, &bn, 0, &blsize))
1147 return win95;
1148 if (bread(pmp->pm_devvp, de_bn2kb(pmp, bn), blsize,
1149 0, &bp)) {
1150 return win95;
1151 }
1152 for (dentp = (struct direntry *)bp->b_data;
1153 (char *)dentp < (char *)bp->b_data + blsize;
1154 dentp++) {
1155 if (dentp->deName[0] == SLOT_EMPTY) {
1156 /*
1157 * Last used entry and not found
1158 */
1159 brelse(bp, 0);
1160 return win95;
1161 }
1162 if (dentp->deName[0] == SLOT_DELETED) {
1163 /*
1164 * Ignore deleted files
1165 * Note: might be an indication of Win'95
1166 * anyway XXX
1167 */
1168 continue;
1169 }
1170 if (dentp->deAttributes == ATTR_WIN95) {
1171 brelse(bp, 0);
1172 return 1;
1173 }
1174 win95 = 0;
1175 }
1176 brelse(bp, 0);
1177 }
1178 }
1179