Annotation of sys/msdosfs/msdosfs_vnops.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: msdosfs_vnops.c,v 1.64 2007/06/02 02:04:21 deraadt Exp $ */
2: /* $NetBSD: msdosfs_vnops.c,v 1.63 1997/10/17 11:24:19 ws Exp $ */
3:
4: /*-
5: * Copyright (C) 2005 Thomas Wang.
6: * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
7: * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
8: * All rights reserved.
9: * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by TooLs GmbH.
22: * 4. The name of TooLs GmbH may not be used to endorse or promote products
23: * derived from this software without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
26: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28: * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
30: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
31: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
32: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
33: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
34: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35: */
36: /*
37: * Written by Paul Popelka (paulp@uts.amdahl.com)
38: *
39: * You can do anything you want with this software, just don't say you wrote
40: * it, and don't remove this notice.
41: *
42: * This software is provided "as is".
43: *
44: * The author supplies this software to be publicly redistributed on the
45: * understanding that the author is not responsible for the correct
46: * functioning of this software in any circumstances and is not liable for
47: * any damages caused by this software.
48: *
49: * October 1992
50: */
51:
52: #include <sys/param.h>
53: #include <sys/systm.h>
54: #include <sys/namei.h>
55: #include <sys/resourcevar.h> /* defines plimit structure in proc struct */
56: #include <sys/kernel.h>
57: #include <sys/file.h> /* define FWRITE ... */
58: #include <sys/stat.h>
59: #include <sys/buf.h>
60: #include <sys/proc.h>
61: #include <sys/mount.h>
62: #include <sys/vnode.h>
63: #include <sys/signalvar.h>
64: #include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */
65: #include <sys/malloc.h>
66: #include <sys/pool.h>
67: #include <sys/dirent.h> /* defines dirent structure */
68: #include <sys/lockf.h>
69: #include <sys/poll.h>
70:
71: #include <uvm/uvm_extern.h>
72:
73: #include <msdosfs/bpb.h>
74: #include <msdosfs/direntry.h>
75: #include <msdosfs/denode.h>
76: #include <msdosfs/msdosfsmount.h>
77: #include <msdosfs/fat.h>
78:
79: static uint32_t fileidhash(uint64_t);
80:
81: /*
82: * Some general notes:
83: *
84: * In the ufs filesystem the inodes, superblocks, and indirect blocks are
85: * read/written using the vnode for the filesystem. Blocks that represent
86: * the contents of a file are read/written using the vnode for the file
87: * (including directories when they are read/written as files). This
88: * presents problems for the dos filesystem because data that should be in
89: * an inode (if dos had them) resides in the directory itself. Since we
90: * must update directory entries without the benefit of having the vnode
91: * for the directory we must use the vnode for the filesystem. This means
92: * that when a directory is actually read/written (via read, write, or
93: * readdir, or seek) we must use the vnode for the filesystem instead of
94: * the vnode for the directory as would happen in ufs. This is to insure we
95: * retrieve the correct block from the buffer cache since the hash value is
96: * based upon the vnode address and the desired block number.
97: */
98:
99: /*
100: * Create a regular file. On entry the directory to contain the file being
101: * created is locked. We must release before we return. We must also free
102: * the pathname buffer pointed at by cnp->cn_pnbuf, always on error, or
103: * only if the SAVESTART bit in cn_flags is clear on success.
104: */
105: int
106: msdosfs_create(v)
107: void *v;
108: {
109: struct vop_create_args *ap = v;
110: struct componentname *cnp = ap->a_cnp;
111: struct denode ndirent;
112: struct denode *dep;
113: struct denode *pdep = VTODE(ap->a_dvp);
114: int error;
115: struct timespec ts;
116:
117: #ifdef MSDOSFS_DEBUG
118: printf("msdosfs_create(cnp %08x, vap %08x\n", cnp, ap->a_vap);
119: #endif
120:
121: /*
122: * If this is the root directory and there is no space left we
123: * can't do anything. This is because the root directory can not
124: * change size.
125: */
126: if (pdep->de_StartCluster == MSDOSFSROOT
127: && pdep->de_fndoffset >= pdep->de_FileSize) {
128: error = ENOSPC;
129: goto bad;
130: }
131:
132: /*
133: * Create a directory entry for the file, then call createde() to
134: * have it installed. NOTE: DOS files are always executable. We
135: * use the absence of the owner write bit to make the file
136: * readonly.
137: */
138: #ifdef DIAGNOSTIC
139: if ((cnp->cn_flags & HASBUF) == 0)
140: panic("msdosfs_create: no name");
141: #endif
142: bzero(&ndirent, sizeof(ndirent));
143: if ((error = uniqdosname(pdep, cnp, ndirent.de_Name)) != 0)
144: goto bad;
145:
146: ndirent.de_Attributes = (ap->a_vap->va_mode & VWRITE) ?
147: ATTR_ARCHIVE : ATTR_ARCHIVE | ATTR_READONLY;
148: ndirent.de_StartCluster = 0;
149: ndirent.de_FileSize = 0;
150: ndirent.de_dev = pdep->de_dev;
151: ndirent.de_devvp = pdep->de_devvp;
152: ndirent.de_pmp = pdep->de_pmp;
153: ndirent.de_flag = DE_ACCESS | DE_CREATE | DE_UPDATE;
154: getnanotime(&ts);
155: DETIMES(&ndirent, &ts, &ts, &ts);
156: if ((error = createde(&ndirent, pdep, &dep, cnp)) != 0)
157: goto bad;
158: if ((cnp->cn_flags & SAVESTART) == 0)
159: pool_put(&namei_pool, cnp->cn_pnbuf);
160: vput(ap->a_dvp);
161: *ap->a_vpp = DETOV(dep);
162: return (0);
163:
164: bad:
165: pool_put(&namei_pool, cnp->cn_pnbuf);
166: vput(ap->a_dvp);
167: return (error);
168: }
169:
170: int
171: msdosfs_mknod(v)
172: void *v;
173: {
174: struct vop_mknod_args *ap = v;
175:
176: pool_put(&namei_pool, ap->a_cnp->cn_pnbuf);
177: vput(ap->a_dvp);
178: return (EINVAL);
179: }
180:
181: int
182: msdosfs_open(v)
183: void *v;
184: {
185: #if 0
186: struct vop_open_args /* {
187: struct vnode *a_vp;
188: int a_mode;
189: struct ucred *a_cred;
190: struct proc *a_p;
191: } */ *ap;
192: #endif
193:
194: return (0);
195: }
196:
197: int
198: msdosfs_close(v)
199: void *v;
200: {
201: struct vop_close_args *ap = v;
202: struct vnode *vp = ap->a_vp;
203: struct denode *dep = VTODE(vp);
204: struct timespec ts;
205:
206: if (vp->v_usecount > 1 && !VOP_ISLOCKED(vp)) {
207: getnanotime(&ts);
208: DETIMES(dep, &ts, &ts, &ts);
209: }
210: return (0);
211: }
212:
213: int
214: msdosfs_access(v)
215: void *v;
216: {
217: struct vop_access_args *ap = v;
218: struct denode *dep = VTODE(ap->a_vp);
219: struct msdosfsmount *pmp = dep->de_pmp;
220: mode_t dosmode;
221:
222: dosmode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH);
223: if ((dep->de_Attributes & ATTR_READONLY) == 0)
224: dosmode |= (S_IWUSR|S_IWGRP|S_IWOTH);
225: dosmode &= pmp->pm_mask;
226: if (dep->de_Attributes & ATTR_DIRECTORY
227: && pmp->pm_flags & MSDOSFSMNT_ALLOWDIRX) {
228: dosmode |= (dosmode & S_IRUSR) ? S_IXUSR : 0;
229: dosmode |= (dosmode & S_IRGRP) ? S_IXGRP : 0;
230: dosmode |= (dosmode & S_IROTH) ? S_IXOTH : 0;
231: }
232:
233: return (vaccess(dosmode, pmp->pm_uid, pmp->pm_gid, ap->a_mode,
234: ap->a_cred));
235: }
236:
237: int
238: msdosfs_getattr(v)
239: void *v;
240: {
241: struct vop_getattr_args *ap = v;
242: struct denode *dep = VTODE(ap->a_vp);
243: struct msdosfsmount *pmp = dep->de_pmp;
244: struct vattr *vap = ap->a_vap;
245: struct timespec ts;
246: uint32_t fileid;
247:
248: getnanotime(&ts);
249: DETIMES(dep, &ts, &ts, &ts);
250: vap->va_fsid = dep->de_dev;
251:
252: /*
253: * The following computation of the fileid must be the same as
254: * that used in msdosfs_readdir() to compute d_fileno. If not,
255: * pwd doesn't work.
256: *
257: * We now use the starting cluster number as the fileid/fileno.
258: * This works for both files and directories (including the root
259: * directory, on FAT32). Even on FAT32, this will at most be a
260: * 28-bit number, as the high 4 bits of FAT32 cluster numbers
261: * are reserved.
262: *
263: * However, we do need to do something for 0-length files, which
264: * will not have a starting cluster number.
265: *
266: * These files cannot be directories, since (except for /, which
267: * is special-cased anyway) directories contain entries for . and
268: * .., so must have non-zero length.
269: *
270: * In this case, we just create a non-cryptographic hash of the
271: * original fileid calculation, and set the top bit.
272: *
273: * This algorithm has the benefit that all directories, and all
274: * non-zero-length files, will have fileids that are persistent
275: * across mounts and reboots, and that cannot collide (as long
276: * as the filesystem is not corrupt). Zero-length files will
277: * have fileids that are persistent, but that may collide. We
278: * will just have to live with that.
279: */
280: fileid = dep->de_StartCluster;
281:
282: if (dep->de_Attributes & ATTR_DIRECTORY) {
283: /* Special-case root */
284: if (dep->de_StartCluster == MSDOSFSROOT)
285: fileid = FAT32(pmp) ? pmp->pm_rootdirblk : 1;
286: } else {
287: if (dep->de_FileSize == 0) {
288: uint32_t dirsperblk;
289: uint64_t fileid64;
290:
291: dirsperblk = pmp->pm_BytesPerSec /
292: sizeof(struct direntry);
293:
294: fileid64 = (dep->de_dirclust == MSDOSFSROOT) ?
295: roottobn(pmp, 0) : cntobn(pmp, dep->de_dirclust);
296: fileid64 *= dirsperblk;
297: fileid64 += dep->de_diroffset / sizeof(struct direntry);
298:
299: fileid = fileidhash(fileid64);
300: }
301: }
302:
303: vap->va_fileid = fileid;
304: vap->va_mode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) |
305: ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH));
306: vap->va_mode &= dep->de_pmp->pm_mask;
307: if (dep->de_Attributes & ATTR_DIRECTORY) {
308: vap->va_mode |= S_IFDIR;
309: if (pmp->pm_flags & MSDOSFSMNT_ALLOWDIRX) {
310: vap->va_mode |= (vap->va_mode & S_IRUSR) ? S_IXUSR : 0;
311: vap->va_mode |= (vap->va_mode & S_IRGRP) ? S_IXGRP : 0;
312: vap->va_mode |= (vap->va_mode & S_IROTH) ? S_IXOTH : 0;
313: }
314: }
315: vap->va_nlink = 1;
316: vap->va_gid = dep->de_pmp->pm_gid;
317: vap->va_uid = dep->de_pmp->pm_uid;
318: vap->va_rdev = 0;
319: vap->va_size = dep->de_FileSize;
320: dos2unixtime(dep->de_MDate, dep->de_MTime, 0, &vap->va_mtime);
321: if (dep->de_pmp->pm_flags & MSDOSFSMNT_LONGNAME) {
322: dos2unixtime(dep->de_ADate, 0, 0, &vap->va_atime);
323: dos2unixtime(dep->de_CDate, dep->de_CTime, dep->de_CTimeHundredth, &vap->va_ctime);
324: } else {
325: vap->va_atime = vap->va_mtime;
326: vap->va_ctime = vap->va_mtime;
327: }
328: vap->va_flags = 0;
329: if ((dep->de_Attributes & ATTR_ARCHIVE) == 0)
330: vap->va_flags |= SF_ARCHIVED;
331: vap->va_gen = 0;
332: vap->va_blocksize = dep->de_pmp->pm_bpcluster;
333: vap->va_bytes = (dep->de_FileSize + dep->de_pmp->pm_crbomask) &
334: ~(dep->de_pmp->pm_crbomask);
335: vap->va_type = ap->a_vp->v_type;
336: return (0);
337: }
338:
339: int
340: msdosfs_setattr(v)
341: void *v;
342: {
343: struct vop_setattr_args *ap = v;
344: int error = 0;
345: struct denode *dep = VTODE(ap->a_vp);
346: struct vattr *vap = ap->a_vap;
347: struct ucred *cred = ap->a_cred;
348:
349: #ifdef MSDOSFS_DEBUG
350: printf("msdosfs_setattr(): vp %08x, vap %08x, cred %08x, p %08x\n",
351: ap->a_vp, vap, cred, ap->a_p);
352: #endif
353: if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
354: (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
355: (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
356: (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL) ||
357: (vap->va_uid != VNOVAL) || (vap->va_gid != VNOVAL)) {
358: #ifdef MSDOSFS_DEBUG
359: printf("msdosfs_setattr(): returning EINVAL\n");
360: printf(" va_type %d, va_nlink %x, va_fsid %x, va_fileid %x\n",
361: vap->va_type, vap->va_nlink, vap->va_fsid, vap->va_fileid);
362: printf(" va_blocksize %x, va_rdev %x, va_bytes %x, va_gen %x\n",
363: vap->va_blocksize, vap->va_rdev, vap->va_bytes, vap->va_gen);
364: printf(" va_uid %x, va_gid %x\n",
365: vap->va_uid, vap->va_gid);
366: #endif
367: return (EINVAL);
368: }
369: /*
370: * Directories must not ever get their attributes modified
371: */
372: if (ap->a_vp->v_type == VDIR)
373: return EISDIR;
374:
375: if (vap->va_size != VNOVAL) {
376: error = detrunc(dep, (uint32_t)vap->va_size, 0, cred, ap->a_p);
377: if (error)
378: return (error);
379: }
380: if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
381: if (cred->cr_uid != dep->de_pmp->pm_uid &&
382: (error = suser_ucred(cred)) &&
383: ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
384: (error = VOP_ACCESS(ap->a_vp, VWRITE, cred, ap->a_p))))
385: return (error);
386: if (!(dep->de_pmp->pm_flags & MSDOSFSMNT_NOWIN95)
387: && vap->va_atime.tv_sec != VNOVAL)
388: unix2dostime(&vap->va_atime, &dep->de_ADate, NULL, NULL);
389: if (vap->va_mtime.tv_sec != VNOVAL)
390: unix2dostime(&vap->va_mtime, &dep->de_MDate, &dep->de_MTime, NULL);
391: dep->de_Attributes |= ATTR_ARCHIVE;
392: dep->de_flag |= DE_MODIFIED;
393: }
394: /*
395: * DOS files only have the ability to have their writability
396: * attribute set, so we use the owner write bit to set the readonly
397: * attribute.
398: */
399: if (vap->va_mode != (mode_t)VNOVAL) {
400: if (cred->cr_uid != dep->de_pmp->pm_uid &&
401: (error = suser_ucred(cred)))
402: return (error);
403: /* We ignore the read and execute bits. */
404: if (vap->va_mode & VWRITE)
405: dep->de_Attributes &= ~ATTR_READONLY;
406: else
407: dep->de_Attributes |= ATTR_READONLY;
408: dep->de_flag |= DE_MODIFIED;
409: }
410: /*
411: * Allow the `archived' bit to be toggled.
412: */
413: if (vap->va_flags != VNOVAL) {
414: if (cred->cr_uid != dep->de_pmp->pm_uid &&
415: (error = suser_ucred(cred)))
416: return (error);
417: if (vap->va_flags & SF_ARCHIVED)
418: dep->de_Attributes &= ~ATTR_ARCHIVE;
419: else
420: dep->de_Attributes |= ATTR_ARCHIVE;
421: dep->de_flag |= DE_MODIFIED;
422: }
423: return (deupdat(dep, 1));
424: }
425:
426: int
427: msdosfs_read(v)
428: void *v;
429: {
430: struct vop_read_args *ap = v;
431: int error = 0;
432: uint32_t diff;
433: int blsize;
434: int isadir;
435: uint32_t n;
436: long on;
437: daddr64_t lbn, rablock, rablkno;
438: struct buf *bp;
439: struct vnode *vp = ap->a_vp;
440: struct denode *dep = VTODE(vp);
441: struct msdosfsmount *pmp = dep->de_pmp;
442: struct uio *uio = ap->a_uio;
443:
444: /*
445: * If they didn't ask for any data, then we are done.
446: */
447: if (uio->uio_resid == 0)
448: return (0);
449: if (uio->uio_offset < 0)
450: return (EINVAL);
451:
452: isadir = dep->de_Attributes & ATTR_DIRECTORY;
453: do {
454: if (uio->uio_offset >= dep->de_FileSize)
455: return (0);
456:
457: lbn = de_cluster(pmp, uio->uio_offset);
458: on = uio->uio_offset & pmp->pm_crbomask;
459: n = min((uint32_t) (pmp->pm_bpcluster - on), uio->uio_resid);
460:
461: /*
462: * de_FileSize is uint32_t, and we know that uio_offset <
463: * de_FileSize, so uio->uio_offset < 2^32. Therefore
464: * the cast to uint32_t on the next line is safe.
465: */
466: diff = dep->de_FileSize - (uint32_t)uio->uio_offset;
467: if (diff < n)
468: n = diff;
469:
470: /* convert cluster # to block # if a directory */
471: if (isadir) {
472: error = pcbmap(dep, lbn, &lbn, 0, &blsize);
473: if (error)
474: return (error);
475: }
476: /*
477: * If we are operating on a directory file then be sure to
478: * do i/o with the vnode for the filesystem instead of the
479: * vnode for the directory.
480: */
481: if (isadir) {
482: error = bread(pmp->pm_devvp, lbn, blsize, NOCRED, &bp);
483: } else {
484: rablock = lbn + 1;
485: rablkno = de_cn2bn(pmp, rablock);
486: if (dep->de_lastr + 1 == lbn &&
487: de_cn2off(pmp, rablock) < dep->de_FileSize)
488: error = breadn(vp, de_cn2bn(pmp, lbn),
489: pmp->pm_bpcluster, &rablkno,
490: &pmp->pm_bpcluster, 1, NOCRED, &bp);
491: else
492: error = bread(vp, de_cn2bn(pmp, lbn),
493: pmp->pm_bpcluster, NOCRED, &bp);
494: dep->de_lastr = lbn;
495: }
496: n = min(n, pmp->pm_bpcluster - bp->b_resid);
497: if (error) {
498: brelse(bp);
499: return (error);
500: }
501: error = uiomove(bp->b_data + on, (int) n, uio);
502: brelse(bp);
503: } while (error == 0 && uio->uio_resid > 0 && n != 0);
504: if (!isadir && !(vp->v_mount->mnt_flag & MNT_NOATIME))
505: dep->de_flag |= DE_ACCESS;
506: return (error);
507: }
508:
509: /*
510: * Write data to a file or directory.
511: */
512: int
513: msdosfs_write(v)
514: void *v;
515: {
516: struct vop_write_args *ap = v;
517: int n;
518: int croffset;
519: int resid;
520: uint32_t osize;
521: int error = 0;
522: uint32_t count, lastcn;
523: daddr64_t bn;
524: struct buf *bp;
525: int ioflag = ap->a_ioflag;
526: struct uio *uio = ap->a_uio;
527: struct proc *p = uio->uio_procp;
528: struct vnode *vp = ap->a_vp;
529: struct vnode *thisvp;
530: struct denode *dep = VTODE(vp);
531: struct msdosfsmount *pmp = dep->de_pmp;
532: struct ucred *cred = ap->a_cred;
533:
534: #ifdef MSDOSFS_DEBUG
535: printf("msdosfs_write(vp %08x, uio %08x, ioflag %08x, cred %08x\n",
536: vp, uio, ioflag, cred);
537: printf("msdosfs_write(): diroff %d, dirclust %d, startcluster %d\n",
538: dep->de_diroffset, dep->de_dirclust, dep->de_StartCluster);
539: #endif
540:
541: switch (vp->v_type) {
542: case VREG:
543: if (ioflag & IO_APPEND)
544: uio->uio_offset = dep->de_FileSize;
545: thisvp = vp;
546: break;
547: case VDIR:
548: return EISDIR;
549: default:
550: panic("msdosfs_write(): bad file type");
551: }
552:
553: if (uio->uio_offset < 0)
554: return (EINVAL);
555:
556: if (uio->uio_resid == 0)
557: return (0);
558:
559: /* Don't bother to try to write files larger than the f/s limit */
560: if (uio->uio_offset + uio->uio_resid > MSDOSFS_FILESIZE_MAX)
561: return (EFBIG);
562:
563: /*
564: * If they've exceeded their filesize limit, tell them about it.
565: */
566: if (p &&
567: ((uio->uio_offset + uio->uio_resid) >
568: p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) {
569: psignal(p, SIGXFSZ);
570: return (EFBIG);
571: }
572:
573: /*
574: * If the offset we are starting the write at is beyond the end of
575: * the file, then they've done a seek. Unix filesystems allow
576: * files with holes in them, DOS doesn't so we must fill the hole
577: * with zeroed blocks.
578: */
579: if (uio->uio_offset > dep->de_FileSize) {
580: if ((error = deextend(dep, uio->uio_offset, cred)) != 0)
581: return (error);
582: }
583:
584: /*
585: * Remember some values in case the write fails.
586: */
587: resid = uio->uio_resid;
588: osize = dep->de_FileSize;
589:
590: /*
591: * If we write beyond the end of the file, extend it to its ultimate
592: * size ahead of the time to hopefully get a contiguous area.
593: */
594: if (uio->uio_offset + resid > osize) {
595: count = de_clcount(pmp, uio->uio_offset + resid) -
596: de_clcount(pmp, osize);
597: if ((error = extendfile(dep, count, NULL, NULL, 0)) &&
598: (error != ENOSPC || (ioflag & IO_UNIT)))
599: goto errexit;
600: lastcn = dep->de_fc[FC_LASTFC].fc_frcn;
601: } else
602: lastcn = de_clcount(pmp, osize) - 1;
603:
604: do {
605: if (de_cluster(pmp, uio->uio_offset) > lastcn) {
606: error = ENOSPC;
607: break;
608: }
609:
610: bn = de_blk(pmp, uio->uio_offset);
611: if ((uio->uio_offset & pmp->pm_crbomask) == 0
612: && (de_blk(pmp, uio->uio_offset + uio->uio_resid) > de_blk(pmp, uio->uio_offset)
613: || uio->uio_offset + uio->uio_resid >= dep->de_FileSize)) {
614: /*
615: * If either the whole cluster gets written,
616: * or we write the cluster from its start beyond EOF,
617: * then no need to read data from disk.
618: */
619: bp = getblk(thisvp, bn, pmp->pm_bpcluster, 0, 0);
620: clrbuf(bp);
621: /*
622: * Do the bmap now, since pcbmap needs buffers
623: * for the fat table. (see msdosfs_strategy)
624: */
625: if (bp->b_blkno == bp->b_lblkno) {
626: error = pcbmap(dep,
627: de_bn2cn(pmp, bp->b_lblkno),
628: &bp->b_blkno, 0, 0);
629: if (error)
630: bp->b_blkno = -1;
631: }
632: if (bp->b_blkno == -1) {
633: brelse(bp);
634: if (!error)
635: error = EIO; /* XXX */
636: break;
637: }
638: } else {
639: /*
640: * The block we need to write into exists, so read it in.
641: */
642: error = bread(thisvp, bn, pmp->pm_bpcluster,
643: NOCRED, &bp);
644: if (error) {
645: brelse(bp);
646: break;
647: }
648: }
649:
650: croffset = uio->uio_offset & pmp->pm_crbomask;
651: n = min(uio->uio_resid, pmp->pm_bpcluster - croffset);
652: if (uio->uio_offset + n > dep->de_FileSize) {
653: dep->de_FileSize = uio->uio_offset + n;
654: uvm_vnp_setsize(vp, dep->de_FileSize);
655: }
656: uvm_vnp_uncache(vp);
657: /*
658: * Should these vnode_pager_* functions be done on dir
659: * files?
660: */
661:
662: /*
663: * Copy the data from user space into the buf header.
664: */
665: error = uiomove(bp->b_data + croffset, n, uio);
666:
667: /*
668: * If they want this synchronous then write it and wait for
669: * it. Otherwise, if on a cluster boundary write it
670: * asynchronously so we can move on to the next block
671: * without delay. Otherwise do a delayed write because we
672: * may want to write somemore into the block later.
673: */
674: if (ioflag & IO_SYNC)
675: (void) bwrite(bp);
676: else if (n + croffset == pmp->pm_bpcluster)
677: bawrite(bp);
678: else
679: bdwrite(bp);
680: dep->de_flag |= DE_UPDATE;
681: } while (error == 0 && uio->uio_resid > 0);
682:
683: /*
684: * If the write failed and they want us to, truncate the file back
685: * to the size it was before the write was attempted.
686: */
687: errexit:
688: if (error) {
689: if (ioflag & IO_UNIT) {
690: detrunc(dep, osize, ioflag & IO_SYNC, NOCRED, NULL);
691: uio->uio_offset -= resid - uio->uio_resid;
692: uio->uio_resid = resid;
693: } else {
694: detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC, NOCRED, NULL);
695: if (uio->uio_resid != resid)
696: error = 0;
697: }
698: } else if (ioflag & IO_SYNC)
699: error = deupdat(dep, 1);
700: return (error);
701: }
702:
703: int
704: msdosfs_ioctl(v)
705: void *v;
706: {
707: #if 0
708: struct vop_ioctl_args /* {
709: struct vnode *a_vp;
710: uint32_t a_command;
711: caddr_t a_data;
712: int a_fflag;
713: struct ucred *a_cred;
714: struct proc *a_p;
715: } */ *ap;
716: #endif
717:
718: return (ENOTTY);
719: }
720:
721: int
722: msdosfs_poll(v)
723: void *v;
724: {
725: struct vop_poll_args *ap = v;
726:
727: return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
728: }
729:
730: /*
731: * Flush the blocks of a file to disk.
732: *
733: * This function is worthless for vnodes that represent directories. Maybe we
734: * could just do a sync if they try an fsync on a directory file.
735: */
736: int
737: msdosfs_fsync(v)
738: void *v;
739: {
740: struct vop_fsync_args *ap = v;
741: struct vnode *vp = ap->a_vp;
742:
743: vflushbuf(vp, ap->a_waitfor == MNT_WAIT);
744: return (deupdat(VTODE(vp), ap->a_waitfor == MNT_WAIT));
745: }
746:
747: /*
748: * Flush the blocks of a file to disk.
749: *
750: * This function is worthless for vnodes that represent directories. Maybe we
751: * could just do a sync if they try an fsync on a directory file.
752: */
753: int
754: msdosfs_remove(v)
755: void *v;
756: {
757: struct vop_remove_args *ap = v;
758: struct denode *dep = VTODE(ap->a_vp);
759: struct denode *ddep = VTODE(ap->a_dvp);
760: int error;
761:
762: if (ap->a_vp->v_type == VDIR)
763: error = EPERM;
764: else
765: error = removede(ddep, dep);
766: #ifdef MSDOSFS_DEBUG
767: printf("msdosfs_remove(), dep %08x, v_usecount %d\n", dep, ap->a_vp->v_usecount);
768: #endif
769: if (ddep == dep)
770: vrele(ap->a_vp);
771: else
772: vput(ap->a_vp); /* causes msdosfs_inactive() to be called
773: * via vrele() */
774: vput(ap->a_dvp);
775: return (error);
776: }
777:
778: /*
779: * DOS filesystems don't know what links are. But since we already called
780: * msdosfs_lookup() with create and lockparent, the parent is locked so we
781: * have to free it before we return the error.
782: */
783: int
784: msdosfs_link(v)
785: void *v;
786: {
787: struct vop_link_args *ap = v;
788:
789: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
790: vput(ap->a_dvp);
791: return (EOPNOTSUPP);
792: }
793:
794: /*
795: * Renames on files require moving the denode to a new hash queue since the
796: * denode's location is used to compute which hash queue to put the file
797: * in. Unless it is a rename in place. For example "mv a b".
798: *
799: * What follows is the basic algorithm:
800: *
801: * if (file move) {
802: * if (dest file exists) {
803: * remove dest file
804: * }
805: * if (dest and src in same directory) {
806: * rewrite name in existing directory slot
807: * } else {
808: * write new entry in dest directory
809: * update offset and dirclust in denode
810: * move denode to new hash chain
811: * clear old directory entry
812: * }
813: * } else {
814: * directory move
815: * if (dest directory exists) {
816: * if (dest is not empty) {
817: * return ENOTEMPTY
818: * }
819: * remove dest directory
820: * }
821: * if (dest and src in same directory) {
822: * rewrite name in existing entry
823: * } else {
824: * be sure dest is not a child of src directory
825: * write entry in dest directory
826: * update "." and ".." in moved directory
827: * update offset and dirclust in denode
828: * move denode to new hash chain
829: * clear old directory entry for moved directory
830: * }
831: * }
832: *
833: * On entry:
834: * source's parent directory is unlocked
835: * source file or directory is unlocked
836: * destination's parent directory is locked
837: * destination file or directory is locked if it exists
838: *
839: * On exit:
840: * all denodes should be released
841: *
842: * Notes:
843: * I'm not sure how the memory containing the pathnames pointed at by the
844: * componentname structures is freed, there may be some memory bleeding
845: * for each rename done.
846: */
847: int
848: msdosfs_rename(v)
849: void *v;
850: {
851: struct vop_rename_args *ap = v;
852: struct vnode *tvp = ap->a_tvp;
853: register struct vnode *tdvp = ap->a_tdvp;
854: struct vnode *fvp = ap->a_fvp;
855: register struct vnode *fdvp = ap->a_fdvp;
856: register struct componentname *tcnp = ap->a_tcnp;
857: register struct componentname *fcnp = ap->a_fcnp;
858: struct proc *p = curproc; /* XXX */
859: register struct denode *ip, *xp, *dp, *zp;
860: u_char toname[11], oldname[11];
861: uint32_t from_diroffset, to_diroffset;
862: u_char to_count;
863: int doingdirectory = 0, newparent = 0;
864: int error;
865: uint32_t cn, pcl;
866: daddr64_t bn;
867: struct msdosfsmount *pmp;
868: struct direntry *dotdotp;
869: struct buf *bp;
870:
871: pmp = VFSTOMSDOSFS(fdvp->v_mount);
872:
873: #ifdef DIAGNOSTIC
874: if ((tcnp->cn_flags & HASBUF) == 0 ||
875: (fcnp->cn_flags & HASBUF) == 0)
876: panic("msdosfs_rename: no name");
877: #endif
878: /*
879: * Check for cross-device rename.
880: */
881: if ((fvp->v_mount != tdvp->v_mount) ||
882: (tvp && (fvp->v_mount != tvp->v_mount))) {
883: error = EXDEV;
884: abortit:
885: VOP_ABORTOP(tdvp, tcnp);
886: if (tdvp == tvp)
887: vrele(tdvp);
888: else
889: vput(tdvp);
890: if (tvp)
891: vput(tvp);
892: VOP_ABORTOP(fdvp, fcnp);
893: vrele(fdvp);
894: vrele(fvp);
895: return (error);
896: }
897:
898: /*
899: * If source and dest are the same, do nothing.
900: */
901: if (tvp == fvp) {
902: error = 0;
903: goto abortit;
904: }
905:
906: /* */
907: if ((error = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, p)) != 0)
908: goto abortit;
909: dp = VTODE(fdvp);
910: ip = VTODE(fvp);
911:
912: /*
913: * Be sure we are not renaming ".", "..", or an alias of ".". This
914: * leads to a crippled directory tree. It's pretty tough to do a
915: * "ls" or "pwd" with the "." directory entry missing, and "cd .."
916: * doesn't work if the ".." entry is missing.
917: */
918: if (ip->de_Attributes & ATTR_DIRECTORY) {
919: /*
920: * Avoid ".", "..", and aliases of "." for obvious reasons.
921: */
922: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
923: dp == ip ||
924: (fcnp->cn_flags & ISDOTDOT) ||
925: (tcnp->cn_flags & ISDOTDOT) ||
926: (ip->de_flag & DE_RENAME)) {
927: VOP_UNLOCK(fvp, 0, p);
928: error = EINVAL;
929: goto abortit;
930: }
931: ip->de_flag |= DE_RENAME;
932: doingdirectory++;
933: }
934:
935: /*
936: * When the target exists, both the directory
937: * and target vnodes are returned locked.
938: */
939: dp = VTODE(tdvp);
940: xp = tvp ? VTODE(tvp) : NULL;
941: /*
942: * Remember direntry place to use for destination
943: */
944: to_diroffset = dp->de_fndoffset;
945: to_count = dp->de_fndcnt;
946:
947: /*
948: * If ".." must be changed (ie the directory gets a new
949: * parent) then the source directory must not be in the
950: * directory hierarchy above the target, as this would
951: * orphan everything below the source directory. Also
952: * the user must have write permission in the source so
953: * as to be able to change "..". We must repeat the call
954: * to namei, as the parent directory is unlocked by the
955: * call to doscheckpath().
956: */
957: error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
958: VOP_UNLOCK(fvp, 0, p);
959: if (VTODE(fdvp)->de_StartCluster != VTODE(tdvp)->de_StartCluster)
960: newparent = 1;
961: vrele(fdvp);
962: if (doingdirectory && newparent) {
963: if (error) /* write access check above */
964: goto bad1;
965: if (xp != NULL)
966: vput(tvp);
967: /*
968: * doscheckpath() vput()'s dp,
969: * so we have to do a relookup afterwards
970: */
971: if ((error = doscheckpath(ip, dp)) != 0)
972: goto out;
973: if ((tcnp->cn_flags & SAVESTART) == 0)
974: panic("msdosfs_rename: lost to startdir");
975: if ((error = relookup(tdvp, &tvp, tcnp)) != 0)
976: goto out;
977: dp = VTODE(tdvp);
978: xp = tvp ? VTODE(tvp) : NULL;
979: }
980:
981: if (xp != NULL) {
982: /*
983: * Target must be empty if a directory and have no links
984: * to it. Also, ensure source and target are compatible
985: * (both directories, or both not directories).
986: */
987: if (xp->de_Attributes & ATTR_DIRECTORY) {
988: if (!dosdirempty(xp)) {
989: error = ENOTEMPTY;
990: goto bad1;
991: }
992: if (!doingdirectory) {
993: error = ENOTDIR;
994: goto bad1;
995: }
996: cache_purge(tdvp);
997: } else if (doingdirectory) {
998: error = EISDIR;
999: goto bad1;
1000: }
1001: if ((error = removede(dp, xp)) != 0)
1002: goto bad1;
1003: vput(tvp);
1004: xp = NULL;
1005: }
1006:
1007: /*
1008: * Convert the filename in tcnp into a dos filename. We copy this
1009: * into the denode and directory entry for the destination
1010: * file/directory.
1011: */
1012: if ((error = uniqdosname(VTODE(tdvp), tcnp, toname)) != 0)
1013: goto bad1;
1014:
1015: /*
1016: * Since from wasn't locked at various places above,
1017: * have to do a relookup here.
1018: */
1019: fcnp->cn_flags &= ~MODMASK;
1020: fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
1021: if ((fcnp->cn_flags & SAVESTART) == 0)
1022: panic("msdosfs_rename: lost from startdir");
1023: if (!newparent)
1024: VOP_UNLOCK(tdvp, 0, p);
1025: (void) relookup(fdvp, &fvp, fcnp);
1026: if (fvp == NULL) {
1027: /*
1028: * From name has disappeared.
1029: */
1030: if (doingdirectory)
1031: panic("rename: lost dir entry");
1032: vrele(ap->a_fvp);
1033: if (newparent)
1034: VOP_UNLOCK(tdvp, 0, p);
1035: vrele(tdvp);
1036: return 0;
1037: }
1038: xp = VTODE(fvp);
1039: zp = VTODE(fdvp);
1040: from_diroffset = zp->de_fndoffset;
1041:
1042: /*
1043: * Ensure that the directory entry still exists and has not
1044: * changed till now. If the source is a file the entry may
1045: * have been unlinked or renamed. In either case there is
1046: * no further work to be done. If the source is a directory
1047: * then it cannot have been rmdir'ed or renamed; this is
1048: * prohibited by the DE_RENAME flag.
1049: */
1050: if (xp != ip) {
1051: if (doingdirectory)
1052: panic("rename: lost dir entry");
1053: vrele(ap->a_fvp);
1054: if (newparent)
1055: VOP_UNLOCK(fdvp, 0, p);
1056: xp = NULL;
1057: } else {
1058: vrele(fvp);
1059: xp = NULL;
1060:
1061: /*
1062: * First write a new entry in the destination
1063: * directory and mark the entry in the source directory
1064: * as deleted. Then move the denode to the correct hash
1065: * chain for its new location in the filesystem. And, if
1066: * we moved a directory, then update its .. entry to point
1067: * to the new parent directory.
1068: */
1069: bcopy(ip->de_Name, oldname, 11);
1070: bcopy(toname, ip->de_Name, 11); /* update denode */
1071: dp->de_fndoffset = to_diroffset;
1072: dp->de_fndcnt = to_count;
1073: error = createde(ip, dp, (struct denode **)0, tcnp);
1074: if (error) {
1075: bcopy(oldname, ip->de_Name, 11);
1076: if (newparent)
1077: VOP_UNLOCK(fdvp, 0, p);
1078: goto bad;
1079: }
1080: ip->de_refcnt++;
1081: zp->de_fndoffset = from_diroffset;
1082: if ((error = removede(zp, ip)) != 0) {
1083: /* XXX should really panic here, fs is corrupt */
1084: if (newparent)
1085: VOP_UNLOCK(fdvp, 0, p);
1086: goto bad;
1087: }
1088:
1089: cache_purge(fvp);
1090:
1091: if (!doingdirectory) {
1092: error = pcbmap(dp, de_cluster(pmp, to_diroffset), 0,
1093: &ip->de_dirclust, 0);
1094: if (error) {
1095: /* XXX should really panic here, fs is corrupt */
1096: if (newparent)
1097: VOP_UNLOCK(fdvp, 0, p);
1098: goto bad;
1099: }
1100: if (ip->de_dirclust != MSDOSFSROOT)
1101: ip->de_diroffset = to_diroffset & pmp->pm_crbomask;
1102: }
1103: reinsert(ip);
1104: if (newparent)
1105: VOP_UNLOCK(fdvp, 0, p);
1106: }
1107:
1108: /*
1109: * If we moved a directory to a new parent directory, then we must
1110: * fixup the ".." entry in the moved directory.
1111: */
1112: if (doingdirectory && newparent) {
1113: cn = ip->de_StartCluster;
1114: if (cn == MSDOSFSROOT) {
1115: /* this should never happen */
1116: panic("msdosfs_rename: updating .. in root directory?");
1117: } else
1118: bn = cntobn(pmp, cn);
1119: error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster,
1120: NOCRED, &bp);
1121: if (error) {
1122: /* XXX should really panic here, fs is corrupt */
1123: brelse(bp);
1124: goto bad;
1125: }
1126: dotdotp = (struct direntry *)bp->b_data;
1127: putushort(dotdotp[0].deStartCluster, cn);
1128: pcl = dp->de_StartCluster;
1129: if (FAT32(pmp) && pcl == pmp->pm_rootdirblk)
1130: pcl = 0;
1131: putushort(dotdotp[1].deStartCluster, pcl);
1132: if (FAT32(pmp)) {
1133: putushort(dotdotp[0].deHighClust, cn >> 16);
1134: putushort(dotdotp[1].deHighClust, pcl >> 16);
1135: }
1136: if ((error = bwrite(bp)) != 0) {
1137: /* XXX should really panic here, fs is corrupt */
1138: goto bad;
1139: }
1140: }
1141:
1142: bad:
1143: VOP_UNLOCK(fvp, 0, p);
1144: vrele(fdvp);
1145: bad1:
1146: if (xp)
1147: vput(tvp);
1148: vput(tdvp);
1149: out:
1150: ip->de_flag &= ~DE_RENAME;
1151: vrele(fvp);
1152: return (error);
1153:
1154: }
1155:
1156: struct {
1157: struct direntry dot;
1158: struct direntry dotdot;
1159: } dosdirtemplate = {
1160: { ". ", " ", /* the . entry */
1161: ATTR_DIRECTORY, /* file attribute */
1162: CASE_LOWER_BASE | CASE_LOWER_EXT, /* lower case */
1163: 0, /* create time 100ths */
1164: { 0, 0 }, { 0, 0 }, /* create time & date */
1165: { 0, 0 }, /* access date */
1166: { 0, 0 }, /* high bits of start cluster */
1167: { 210, 4 }, { 210, 4 }, /* modify time & date */
1168: { 0, 0 }, /* startcluster */
1169: { 0, 0, 0, 0 } /* filesize */
1170: },
1171: { ".. ", " ", /* the .. entry */
1172: ATTR_DIRECTORY, /* file attribute */
1173: CASE_LOWER_BASE | CASE_LOWER_EXT, /* lower case */
1174: 0, /* create time 100ths */
1175: { 0, 0 }, { 0, 0 }, /* create time & date */
1176: { 0, 0 }, /* access date */
1177: { 0, 0 }, /* high bits of start cluster */
1178: { 210, 4 }, { 210, 4 }, /* modify time & date */
1179: { 0, 0 }, /* startcluster */
1180: { 0, 0, 0, 0 } /* filesize */
1181: }
1182: };
1183:
1184: int
1185: msdosfs_mkdir(v)
1186: void *v;
1187: {
1188: struct vop_mkdir_args *ap = v;
1189: struct componentname *cnp = ap->a_cnp;
1190: struct denode ndirent;
1191: struct denode *dep;
1192: struct denode *pdep = VTODE(ap->a_dvp);
1193: int error;
1194: daddr64_t bn;
1195: uint32_t newcluster, pcl;
1196: struct direntry *denp;
1197: struct msdosfsmount *pmp = pdep->de_pmp;
1198: struct buf *bp;
1199: struct timespec ts;
1200:
1201: /*
1202: * If this is the root directory and there is no space left we
1203: * can't do anything. This is because the root directory can not
1204: * change size.
1205: */
1206: if (pdep->de_StartCluster == MSDOSFSROOT
1207: && pdep->de_fndoffset >= pdep->de_FileSize) {
1208: error = ENOSPC;
1209: goto bad2;
1210: }
1211:
1212: /*
1213: * Allocate a cluster to hold the about to be created directory.
1214: */
1215: error = clusteralloc(pmp, 0, 1, CLUST_EOFE, &newcluster, NULL);
1216: if (error)
1217: goto bad2;
1218:
1219: bzero(&ndirent, sizeof(ndirent));
1220: ndirent.de_pmp = pmp;
1221: ndirent.de_flag = DE_ACCESS | DE_CREATE | DE_UPDATE;
1222: getnanotime(&ts);
1223: DETIMES(&ndirent, &ts, &ts, &ts);
1224:
1225: /*
1226: * Now fill the cluster with the "." and ".." entries. And write
1227: * the cluster to disk. This way it is there for the parent
1228: * directory to be pointing at if there were a crash.
1229: */
1230: bn = cntobn(pmp, newcluster);
1231: /* always succeeds */
1232: bp = getblk(pmp->pm_devvp, bn, pmp->pm_bpcluster, 0, 0);
1233: bzero(bp->b_data, pmp->pm_bpcluster);
1234: bcopy(&dosdirtemplate, bp->b_data, sizeof dosdirtemplate);
1235: denp = (struct direntry *)bp->b_data;
1236: putushort(denp[0].deStartCluster, newcluster);
1237: putushort(denp[0].deCDate, ndirent.de_CDate);
1238: putushort(denp[0].deCTime, ndirent.de_CTime);
1239: denp[0].deCTimeHundredth = ndirent.de_CTimeHundredth;
1240: putushort(denp[0].deADate, ndirent.de_ADate);
1241: putushort(denp[0].deMDate, ndirent.de_MDate);
1242: putushort(denp[0].deMTime, ndirent.de_MTime);
1243: pcl = pdep->de_StartCluster;
1244: if (FAT32(pmp) && pcl == pmp->pm_rootdirblk)
1245: pcl = 0;
1246: putushort(denp[1].deStartCluster, pcl);
1247: putushort(denp[1].deCDate, ndirent.de_CDate);
1248: putushort(denp[1].deCTime, ndirent.de_CTime);
1249: denp[1].deCTimeHundredth = ndirent.de_CTimeHundredth;
1250: putushort(denp[1].deADate, ndirent.de_ADate);
1251: putushort(denp[1].deMDate, ndirent.de_MDate);
1252: putushort(denp[1].deMTime, ndirent.de_MTime);
1253: if (FAT32(pmp)) {
1254: putushort(denp[0].deHighClust, newcluster >> 16);
1255: putushort(denp[1].deHighClust, pdep->de_StartCluster >> 16);
1256: }
1257:
1258: if ((error = bwrite(bp)) != 0)
1259: goto bad;
1260:
1261: /*
1262: * Now build up a directory entry pointing to the newly allocated
1263: * cluster. This will be written to an empty slot in the parent
1264: * directory.
1265: */
1266: #ifdef DIAGNOSTIC
1267: if ((cnp->cn_flags & HASBUF) == 0)
1268: panic("msdosfs_mkdir: no name");
1269: #endif
1270: if ((error = uniqdosname(pdep, cnp, ndirent.de_Name)) != 0)
1271: goto bad;
1272:
1273: ndirent.de_Attributes = ATTR_DIRECTORY;
1274: ndirent.de_StartCluster = newcluster;
1275: ndirent.de_FileSize = 0;
1276: ndirent.de_dev = pdep->de_dev;
1277: ndirent.de_devvp = pdep->de_devvp;
1278: if ((error = createde(&ndirent, pdep, &dep, cnp)) != 0)
1279: goto bad;
1280: if ((cnp->cn_flags & SAVESTART) == 0)
1281: pool_put(&namei_pool, cnp->cn_pnbuf);
1282: vput(ap->a_dvp);
1283: *ap->a_vpp = DETOV(dep);
1284: return (0);
1285:
1286: bad:
1287: clusterfree(pmp, newcluster, NULL);
1288: bad2:
1289: pool_put(&namei_pool, cnp->cn_pnbuf);
1290: vput(ap->a_dvp);
1291: return (error);
1292: }
1293:
1294: int
1295: msdosfs_rmdir(v)
1296: void *v;
1297: {
1298: struct vop_rmdir_args *ap = v;
1299: register struct vnode *vp = ap->a_vp;
1300: register struct vnode *dvp = ap->a_dvp;
1301: register struct componentname *cnp = ap->a_cnp;
1302: register struct denode *ip, *dp;
1303: int error;
1304:
1305: ip = VTODE(vp);
1306: dp = VTODE(dvp);
1307: /*
1308: * No rmdir "." please.
1309: */
1310: if (dp == ip) {
1311: vrele(dvp);
1312: vput(vp);
1313: return (EINVAL);
1314: }
1315: /*
1316: * Verify the directory is empty (and valid).
1317: * (Rmdir ".." won't be valid since
1318: * ".." will contain a reference to
1319: * the current directory and thus be
1320: * non-empty.)
1321: */
1322: error = 0;
1323: if (!dosdirempty(ip) || ip->de_flag & DE_RENAME) {
1324: error = ENOTEMPTY;
1325: goto out;
1326: }
1327: /*
1328: * Delete the entry from the directory. For dos filesystems this
1329: * gets rid of the directory entry on disk, the in memory copy
1330: * still exists but the de_refcnt is <= 0. This prevents it from
1331: * being found by deget(). When the vput() on dep is done we give
1332: * up access and eventually msdosfs_reclaim() will be called which
1333: * will remove it from the denode cache.
1334: */
1335: if ((error = removede(dp, ip)) != 0)
1336: goto out;
1337: /*
1338: * This is where we decrement the link count in the parent
1339: * directory. Since dos filesystems don't do this we just purge
1340: * the name cache and let go of the parent directory denode.
1341: */
1342: cache_purge(dvp);
1343: vput(dvp);
1344: dvp = NULL;
1345: /*
1346: * Truncate the directory that is being deleted.
1347: */
1348: error = detrunc(ip, (uint32_t)0, IO_SYNC, cnp->cn_cred, cnp->cn_proc);
1349: cache_purge(vp);
1350: out:
1351: if (dvp)
1352: vput(dvp);
1353: vput(vp);
1354: return (error);
1355: }
1356:
1357: /*
1358: * DOS filesystems don't know what symlinks are.
1359: */
1360: int
1361: msdosfs_symlink(v)
1362: void *v;
1363: {
1364: struct vop_symlink_args *ap = v;
1365:
1366: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
1367: vput(ap->a_dvp);
1368: return (EOPNOTSUPP);
1369: }
1370:
1371: int
1372: msdosfs_readdir(v)
1373: void *v;
1374: {
1375: struct vop_readdir_args *ap = v;
1376: int error = 0;
1377: int diff;
1378: long n;
1379: int blsize;
1380: long on;
1381: long lost;
1382: long count;
1383: uint32_t dirsperblk;
1384: uint32_t cn, lbn;
1385: uint32_t fileno;
1386: long bias = 0;
1387: daddr64_t bn;
1388: struct buf *bp;
1389: struct denode *dep = VTODE(ap->a_vp);
1390: struct msdosfsmount *pmp = dep->de_pmp;
1391: struct direntry *dentp;
1392: struct dirent dirbuf;
1393: struct uio *uio = ap->a_uio;
1394: u_long *cookies = NULL;
1395: int ncookies = 0;
1396: off_t offset, wlast = -1;
1397: int chksum = -1;
1398:
1399: #ifdef MSDOSFS_DEBUG
1400: printf("msdosfs_readdir(): vp %08x, uio %08x, cred %08x, eofflagp %08x\n",
1401: ap->a_vp, uio, ap->a_cred, ap->a_eofflag);
1402: #endif
1403:
1404: /*
1405: * msdosfs_readdir() won't operate properly on regular files since
1406: * it does i/o only with the filesystem vnode, and hence can
1407: * retrieve the wrong block from the buffer cache for a plain file.
1408: * So, fail attempts to readdir() on a plain file.
1409: */
1410: if ((dep->de_Attributes & ATTR_DIRECTORY) == 0)
1411: return (ENOTDIR);
1412:
1413: /*
1414: * To be safe, initialize dirbuf
1415: */
1416: bzero(dirbuf.d_name, sizeof(dirbuf.d_name));
1417:
1418: /*
1419: * If the user buffer is smaller than the size of one dos directory
1420: * entry or the file offset is not a multiple of the size of a
1421: * directory entry, then we fail the read.
1422: */
1423: count = uio->uio_resid & ~(sizeof(struct direntry) - 1);
1424: offset = uio->uio_offset;
1425: if (count < sizeof(struct direntry) ||
1426: (offset & (sizeof(struct direntry) - 1)))
1427: return (EINVAL);
1428: lost = uio->uio_resid - count;
1429: uio->uio_resid = count;
1430:
1431: if (ap->a_ncookies) {
1432: ncookies = uio->uio_resid / sizeof(struct direntry) + 3;
1433: MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP,
1434: M_WAITOK);
1435: *ap->a_cookies = cookies;
1436: *ap->a_ncookies = ncookies;
1437: }
1438:
1439: dirsperblk = pmp->pm_BytesPerSec / sizeof(struct direntry);
1440:
1441: /*
1442: * If they are reading from the root directory then, we simulate
1443: * the . and .. entries since these don't exist in the root
1444: * directory. We also set the offset bias to make up for having to
1445: * simulate these entries. By this I mean that at file offset 64 we
1446: * read the first entry in the root directory that lives on disk.
1447: */
1448: if (dep->de_StartCluster == MSDOSFSROOT
1449: || (FAT32(pmp) && dep->de_StartCluster == pmp->pm_rootdirblk)) {
1450: #if 0
1451: printf("msdosfs_readdir(): going after . or .. in root dir, offset %d\n",
1452: offset);
1453: #endif
1454: bias = 2 * sizeof(struct direntry);
1455: if (offset < bias) {
1456: for (n = (int)offset / sizeof(struct direntry);
1457: n < 2; n++) {
1458: if (FAT32(pmp))
1459: dirbuf.d_fileno = pmp->pm_rootdirblk;
1460: else
1461: dirbuf.d_fileno = 1;
1462: dirbuf.d_type = DT_DIR;
1463: switch (n) {
1464: case 0:
1465: dirbuf.d_namlen = 1;
1466: strlcpy(dirbuf.d_name, ".",
1467: sizeof dirbuf.d_name);
1468: break;
1469: case 1:
1470: dirbuf.d_namlen = 2;
1471: strlcpy(dirbuf.d_name, "..",
1472: sizeof dirbuf.d_name);
1473: break;
1474: }
1475: dirbuf.d_reclen = DIRENT_SIZE(&dirbuf);
1476: if (uio->uio_resid < dirbuf.d_reclen)
1477: goto out;
1478: error = uiomove((caddr_t) &dirbuf,
1479: dirbuf.d_reclen, uio);
1480: if (error)
1481: goto out;
1482: offset += sizeof(struct direntry);
1483: if (cookies) {
1484: *cookies++ = offset;
1485: if (--ncookies <= 0)
1486: goto out;
1487: }
1488: }
1489: }
1490: }
1491:
1492: while (uio->uio_resid > 0) {
1493: lbn = de_cluster(pmp, offset - bias);
1494: on = (offset - bias) & pmp->pm_crbomask;
1495: n = min(pmp->pm_bpcluster - on, uio->uio_resid);
1496: diff = dep->de_FileSize - (offset - bias);
1497: if (diff <= 0)
1498: break;
1499: n = min(n, diff);
1500: if ((error = pcbmap(dep, lbn, &bn, &cn, &blsize)) != 0)
1501: break;
1502: error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
1503: if (error) {
1504: brelse(bp);
1505: return (error);
1506: }
1507: n = min(n, blsize - bp->b_resid);
1508:
1509: /*
1510: * Convert from dos directory entries to fs-independent
1511: * directory entries.
1512: */
1513: for (dentp = (struct direntry *)(bp->b_data + on);
1514: (char *)dentp < bp->b_data + on + n;
1515: dentp++, offset += sizeof(struct direntry)) {
1516: #if 0
1517: printf("rd: dentp %08x prev %08x crnt %08x deName %02x attr %02x\n",
1518: dentp, prev, crnt, dentp->deName[0], dentp->deAttributes);
1519: #endif
1520: /*
1521: * If this is an unused entry, we can stop.
1522: */
1523: if (dentp->deName[0] == SLOT_EMPTY) {
1524: brelse(bp);
1525: goto out;
1526: }
1527: /*
1528: * Skip deleted entries.
1529: */
1530: if (dentp->deName[0] == SLOT_DELETED) {
1531: chksum = -1;
1532: wlast = -1;
1533: continue;
1534: }
1535:
1536: /*
1537: * Handle Win95 long directory entries
1538: */
1539: if (dentp->deAttributes == ATTR_WIN95) {
1540: struct winentry *wep;
1541: if (pmp->pm_flags & MSDOSFSMNT_SHORTNAME)
1542: continue;
1543: wep = (struct winentry *)dentp;
1544: chksum = win2unixfn(wep, &dirbuf, chksum);
1545: if (wep->weCnt & WIN_LAST)
1546: wlast = offset;
1547: continue;
1548: }
1549:
1550: /*
1551: * Skip volume labels
1552: */
1553: if (dentp->deAttributes & ATTR_VOLUME) {
1554: chksum = -1;
1555: wlast = -1;
1556: continue;
1557: }
1558:
1559: /*
1560: * This computation of d_fileno must match
1561: * the computation of va_fileid in
1562: * msdosfs_getattr.
1563: */
1564: fileno = getushort(dentp->deStartCluster);
1565: if (FAT32(pmp))
1566: fileno |= getushort(dentp->deHighClust) << 16;
1567:
1568: if (dentp->deAttributes & ATTR_DIRECTORY) {
1569: /* Special-case root */
1570: if (fileno == MSDOSFSROOT) {
1571: fileno = FAT32(pmp) ?
1572: pmp->pm_rootdirblk : 1;
1573: }
1574:
1575: dirbuf.d_fileno = fileno;
1576: dirbuf.d_type = DT_DIR;
1577: } else {
1578: if (getulong(dentp->deFileSize) == 0) {
1579: uint64_t fileno64;
1580:
1581: fileno64 = (cn == MSDOSFSROOT) ?
1582: roottobn(pmp, 0) : cntobn(pmp, cn);
1583:
1584: fileno64 *= dirsperblk;
1585: fileno64 += dentp -
1586: (struct direntry *)bp->b_data;
1587:
1588: fileno = fileidhash(fileno64);
1589: }
1590:
1591: dirbuf.d_fileno = fileno;
1592: dirbuf.d_type = DT_REG;
1593: }
1594:
1595: if (chksum != winChksum(dentp->deName))
1596: dirbuf.d_namlen = dos2unixfn(dentp->deName,
1597: (u_char *)dirbuf.d_name,
1598: pmp->pm_flags & MSDOSFSMNT_SHORTNAME);
1599: else
1600: dirbuf.d_name[dirbuf.d_namlen] = 0;
1601: chksum = -1;
1602: dirbuf.d_reclen = DIRENT_SIZE(&dirbuf);
1603: if (uio->uio_resid < dirbuf.d_reclen) {
1604: brelse(bp);
1605: /* Remember long-name offset. */
1606: if (wlast != -1)
1607: offset = wlast;
1608: goto out;
1609: }
1610: wlast = -1;
1611: error = uiomove((caddr_t) &dirbuf,
1612: dirbuf.d_reclen, uio);
1613: if (error) {
1614: brelse(bp);
1615: goto out;
1616: }
1617: if (cookies) {
1618: *cookies++ = offset + sizeof(struct direntry);
1619: if (--ncookies <= 0) {
1620: brelse(bp);
1621: goto out;
1622: }
1623: }
1624: }
1625: brelse(bp);
1626: }
1627:
1628: out:
1629: /* Subtract unused cookies */
1630: if (ap->a_ncookies)
1631: *ap->a_ncookies -= ncookies;
1632:
1633: uio->uio_offset = offset;
1634: uio->uio_resid += lost;
1635: if (dep->de_FileSize - (offset - bias) <= 0)
1636: *ap->a_eofflag = 1;
1637: else
1638: *ap->a_eofflag = 0;
1639: return (error);
1640: }
1641:
1642: /*
1643: * DOS filesystems don't know what symlinks are.
1644: */
1645: int
1646: msdosfs_readlink(v)
1647: void *v;
1648: {
1649: #if 0
1650: struct vop_readlink_args /* {
1651: struct vnode *a_vp;
1652: struct uio *a_uio;
1653: struct ucred *a_cred;
1654: } */ *ap;
1655: #endif
1656:
1657: return (EINVAL);
1658: }
1659:
1660: int
1661: msdosfs_lock(v)
1662: void *v;
1663: {
1664: struct vop_lock_args *ap = v;
1665: struct vnode *vp = ap->a_vp;
1666:
1667: return (lockmgr(&VTODE(vp)->de_lock, ap->a_flags, NULL));
1668: }
1669:
1670: int
1671: msdosfs_unlock(v)
1672: void *v;
1673: {
1674: struct vop_unlock_args *ap = v;
1675: struct vnode *vp = ap->a_vp;
1676:
1677: return (lockmgr(&VTODE(vp)->de_lock, ap->a_flags | LK_RELEASE, NULL));
1678: }
1679:
1680: int
1681: msdosfs_islocked(v)
1682: void *v;
1683: {
1684: struct vop_islocked_args *ap = v;
1685:
1686: return (lockstatus(&VTODE(ap->a_vp)->de_lock));
1687: }
1688:
1689: /*
1690: * vp - address of vnode file the file
1691: * bn - which cluster we are interested in mapping to a filesystem block number.
1692: * vpp - returns the vnode for the block special file holding the filesystem
1693: * containing the file of interest
1694: * bnp - address of where to return the filesystem relative block number
1695: */
1696: int
1697: msdosfs_bmap(v)
1698: void *v;
1699: {
1700: struct vop_bmap_args *ap = v;
1701: struct denode *dep = VTODE(ap->a_vp);
1702: struct msdosfsmount *pmp = dep->de_pmp;
1703:
1704: if (ap->a_vpp != NULL)
1705: *ap->a_vpp = dep->de_devvp;
1706: if (ap->a_bnp == NULL)
1707: return (0);
1708: if (ap->a_runp) {
1709: /*
1710: * Sequential clusters should be counted here.
1711: */
1712: *ap->a_runp = 0;
1713: }
1714: return (pcbmap(dep, de_bn2cn(pmp, ap->a_bn), ap->a_bnp, 0, 0));
1715: }
1716:
1717: int
1718: msdosfs_strategy(v)
1719: void *v;
1720: {
1721: struct vop_strategy_args *ap = v;
1722: struct buf *bp = ap->a_bp;
1723: struct denode *dep = VTODE(bp->b_vp);
1724: struct vnode *vp;
1725: int error = 0;
1726: int s;
1727:
1728: if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR)
1729: panic("msdosfs_strategy: spec");
1730: /*
1731: * If we don't already know the filesystem relative block number
1732: * then get it using pcbmap(). If pcbmap() returns the block
1733: * number as -1 then we've got a hole in the file. DOS filesystems
1734: * don't allow files with holes, so we shouldn't ever see this.
1735: */
1736: if (bp->b_blkno == bp->b_lblkno) {
1737: error = pcbmap(dep, de_bn2cn(dep->de_pmp, bp->b_lblkno),
1738: &bp->b_blkno, 0, 0);
1739: if (error)
1740: bp->b_blkno = -1;
1741: if (bp->b_blkno == -1)
1742: clrbuf(bp);
1743: }
1744: if (bp->b_blkno == -1) {
1745: s = splbio();
1746: biodone(bp);
1747: splx(s);
1748: return (error);
1749: }
1750:
1751: /*
1752: * Read/write the block from/to the disk that contains the desired
1753: * file block.
1754: */
1755:
1756: vp = dep->de_devvp;
1757: bp->b_dev = vp->v_rdev;
1758: VOCALL(vp->v_op, VOFFSET(vop_strategy), ap);
1759: return (0);
1760: }
1761:
1762: int
1763: msdosfs_print(v)
1764: void *v;
1765: {
1766: struct vop_print_args *ap = v;
1767: struct denode *dep = VTODE(ap->a_vp);
1768:
1769: printf(
1770: "tag VT_MSDOSFS, startcluster %ld, dircluster %ld, diroffset %ld ",
1771: dep->de_StartCluster, dep->de_dirclust, dep->de_diroffset);
1772: printf(" dev %d, %d, %s\n",
1773: major(dep->de_dev), minor(dep->de_dev),
1774: VOP_ISLOCKED(ap->a_vp) ? "(LOCKED)" : "");
1775: #ifdef DIAGNOSTIC
1776: lockmgr_printinfo(&dep->de_lock);
1777: #endif
1778:
1779: return (0);
1780: }
1781:
1782: int
1783: msdosfs_advlock(v)
1784: void *v;
1785: {
1786: struct vop_advlock_args *ap = v;
1787: register struct denode *dep = VTODE(ap->a_vp);
1788:
1789: return (lf_advlock(&dep->de_lockf, dep->de_FileSize, ap->a_id, ap->a_op,
1790: ap->a_fl, ap->a_flags));
1791: }
1792:
1793: int
1794: msdosfs_pathconf(v)
1795: void *v;
1796: {
1797: struct vop_pathconf_args *ap = v;
1798: struct msdosfsmount *pmp = VTODE(ap->a_vp)->de_pmp;
1799:
1800: switch (ap->a_name) {
1801: case _PC_LINK_MAX:
1802: *ap->a_retval = 1;
1803: return (0);
1804: case _PC_NAME_MAX:
1805: *ap->a_retval = pmp->pm_flags & MSDOSFSMNT_LONGNAME ? WIN_MAXLEN : 12;
1806: return (0);
1807: case _PC_PATH_MAX:
1808: *ap->a_retval = PATH_MAX;
1809: return (0);
1810: case _PC_CHOWN_RESTRICTED:
1811: *ap->a_retval = 1;
1812: return (0);
1813: case _PC_NO_TRUNC:
1814: *ap->a_retval = 0;
1815: return (0);
1816: default:
1817: return (EINVAL);
1818: }
1819: /* NOTREACHED */
1820: }
1821:
1822: /*
1823: * Thomas Wang's hash function, severely hacked to always set the high
1824: * bit on the number it returns (so no longer a proper hash function).
1825: */
1826: static uint32_t
1827: fileidhash(uint64_t fileid)
1828: {
1829: uint64_t c1 = 0x6e5ea73858134343LL;
1830: uint64_t c2 = 0xb34e8f99a2ec9ef5LL;
1831:
1832: /*
1833: * We now have the original fileid value, as 64-bit value.
1834: * We need to reduce it to 32-bits, with the top bit set.
1835: */
1836: fileid ^= ((c1 ^ fileid) >> 32);
1837: fileid *= c1;
1838: fileid ^= ((c2 ^ fileid) >> 31);
1839: fileid *= c2;
1840: fileid ^= ((c1 ^ fileid) >> 32);
1841:
1842: return (uint32_t)(fileid | 0x80000000);
1843: }
1844:
1845: /* Global vfs data structures for msdosfs */
1846: int (**msdosfs_vnodeop_p)(void *);
1847: struct vnodeopv_entry_desc msdosfs_vnodeop_entries[] = {
1848: { &vop_default_desc, vn_default_error },
1849: { &vop_lookup_desc, msdosfs_lookup }, /* lookup */
1850: { &vop_create_desc, msdosfs_create }, /* create */
1851: { &vop_mknod_desc, msdosfs_mknod }, /* mknod */
1852: { &vop_open_desc, msdosfs_open }, /* open */
1853: { &vop_close_desc, msdosfs_close }, /* close */
1854: { &vop_access_desc, msdosfs_access }, /* access */
1855: { &vop_getattr_desc, msdosfs_getattr }, /* getattr */
1856: { &vop_setattr_desc, msdosfs_setattr }, /* setattr */
1857: { &vop_read_desc, msdosfs_read }, /* read */
1858: { &vop_write_desc, msdosfs_write }, /* write */
1859: { &vop_ioctl_desc, msdosfs_ioctl }, /* ioctl */
1860: { &vop_poll_desc, msdosfs_poll }, /* poll */
1861: { &vop_fsync_desc, msdosfs_fsync }, /* fsync */
1862: { &vop_remove_desc, msdosfs_remove }, /* remove */
1863: { &vop_link_desc, msdosfs_link }, /* link */
1864: { &vop_rename_desc, msdosfs_rename }, /* rename */
1865: { &vop_mkdir_desc, msdosfs_mkdir }, /* mkdir */
1866: { &vop_rmdir_desc, msdosfs_rmdir }, /* rmdir */
1867: { &vop_symlink_desc, msdosfs_symlink }, /* symlink */
1868: { &vop_readdir_desc, msdosfs_readdir }, /* readdir */
1869: { &vop_readlink_desc, msdosfs_readlink }, /* readlink */
1870: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
1871: { &vop_inactive_desc, msdosfs_inactive }, /* inactive */
1872: { &vop_reclaim_desc, msdosfs_reclaim }, /* reclaim */
1873: { &vop_lock_desc, msdosfs_lock }, /* lock */
1874: { &vop_unlock_desc, msdosfs_unlock }, /* unlock */
1875: { &vop_bmap_desc, msdosfs_bmap }, /* bmap */
1876: { &vop_strategy_desc, msdosfs_strategy }, /* strategy */
1877: { &vop_print_desc, msdosfs_print }, /* print */
1878: { &vop_islocked_desc, msdosfs_islocked }, /* islocked */
1879: { &vop_pathconf_desc, msdosfs_pathconf }, /* pathconf */
1880: { &vop_advlock_desc, msdosfs_advlock }, /* advlock */
1881: { &vop_bwrite_desc, vop_generic_bwrite }, /* bwrite */
1882: { (struct vnodeop_desc *)NULL, (int (*)(void *))NULL }
1883: };
1884: struct vnodeopv_desc msdosfs_vnodeop_opv_desc =
1885: { &msdosfs_vnodeop_p, msdosfs_vnodeop_entries };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to msdosfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / msdosfs