![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pcfs_vfsops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / pcfs|
Return to pcfs_vfsops.c CVS log | Up to [Net/2] / Net2 / pcfs |
1.1 root 1: /*
2: * Written by Paul Popelka ([email protected])
3: *
4: * You can do anything you want with this software,
5: * just don't say you wrote it,
6: * and don't remove this notice.
7: *
8: * This software is provided "as is".
9: *
10: * The author supplies this software to be publicly
11: * redistributed on the understanding that the author
12: * is not responsible for the correct functioning of
13: * this software in any circumstances and is not liable
14: * for any damages caused by this software.
15: *
16: * October 1992
17: *
18: * April 6, 1993:
19: * Changed MOUNT_PCFS to MOUNT_MSDOS, this whole package should be renamed
20: * to msdosfs, but I did not have the time to do it. Some one please do
21: * this and resubmit it to the patchkit!
22: * Rodney W. Grimes
23: *
24: * pcfs_vfsops.c,v 1.4.2.1 1993/08/05 02:37:21 cgd Exp
25: */
26:
27: #include "param.h"
28: #include "systm.h"
29: #include "namei.h"
30: #include "proc.h"
31: #include "kernel.h"
32: #include "vnode.h"
33: #include "specdev.h" /* defines v_rdev */
34: #include "mount.h"
35: #include "buf.h"
36: #include "file.h"
37: #include "malloc.h"
38:
39: #include "bpb.h"
40: #include "bootsect.h"
41: #include "direntry.h"
42: #include "denode.h"
43: #include "pcfsmount.h"
44: #include "fat.h"
45:
46: int pcfsdoforce = 0; /* 1 = force unmount */
47:
48: /*
49: * mp -
50: * path - addr in user space of mount point (ie /usr or whatever)
51: * data - addr in user space of mount params including the
52: * name of the block special file to treat as a filesystem.
53: * ndp -
54: * p -
55: */
56: int
57: pcfs_mount(mp, path, data, ndp, p)
58: struct mount *mp;
59: char *path;
60: caddr_t data;
61: struct nameidata *ndp;
62: struct proc *p;
63: {
64: struct vnode *devvp; /* vnode for blk device to mount */
65: struct pcfs_args args; /* will hold data from mount request */
66: struct pcfsmount *pmp; /* pcfs specific mount control block */
67: int error;
68: u_int size;
69:
70: /*
71: * Copy in the args for the mount request.
72: */
73: if (error = copyin(data, (caddr_t)&args, sizeof(struct pcfs_args)))
74: return error;
75:
76: /*
77: * Check to see if they want it to be an exportable
78: * filesystem via nfs. And, if they do, should it
79: * be read only, and what uid is root to be mapped
80: * to.
81: */
82: if ((args.exflags & MNT_EXPORTED) || (mp->mnt_flag & MNT_EXPORTED)) {
83: if (args.exflags & MNT_EXPORTED)
84: mp->mnt_flag |= MNT_EXPORTED;
85: else
86: mp->mnt_flag &= ~MNT_EXPORTED;
87: if (args.exflags & MNT_EXRDONLY)
88: mp->mnt_flag |= MNT_EXRDONLY;
89: else
90: mp->mnt_flag &= ~MNT_EXRDONLY;
91: mp->mnt_exroot = args.exroot;
92: }
93:
94: /*
95: * If they just want to update then be sure we can
96: * do what is asked. Can't change a filesystem from
97: * read/write to read only. Why?
98: * And if they've supplied a new device file name then we
99: * continue, otherwise return.
100: */
101: if (mp->mnt_flag & MNT_UPDATE) {
102: pmp = (struct pcfsmount *)mp->mnt_data;
103: if (pmp->pm_ronly && (mp->mnt_flag & MNT_RDONLY) == 0)
104: pmp->pm_ronly = 0;
105: if (args.fspec == 0)
106: return 0;
107: }
108:
109: /*
110: * Now, lookup the name of the block device this
111: * mount or name update request is to apply to.
112: */
113: ndp->ni_nameiop = LOOKUP | FOLLOW;
114: ndp->ni_segflg = UIO_USERSPACE;
115: ndp->ni_dirp = args.fspec;
116: if (error = namei(ndp, p))
117: return error;
118:
119: /*
120: * Be sure they've given us a block device to treat
121: * as a filesystem. And, that its major number is
122: * within the bdevsw table.
123: */
124: devvp = ndp->ni_vp;
125: if (devvp->v_type != VBLK) {
126: vrele(devvp); /* namei() acquires this? */
127: return ENOTBLK;
128: }
129: if (major(devvp->v_rdev) >= nblkdev) {
130: vrele(devvp);
131: return ENXIO;
132: }
133:
134: /*
135: * If this is an update, then make sure the vnode
136: * for the block special device is the same as the
137: * one our filesystem is in.
138: */
139: if (mp->mnt_flag & MNT_UPDATE) {
140: if (devvp != pmp->pm_devvp)
141: error = EINVAL;
142: else
143: vrele(devvp);
144: } else {
145:
146: /*
147: * Well, it's not an update, it's a real mount request.
148: * Time to get dirty.
149: */
150: error = mountpcfs(devvp, mp, p);
151: }
152: if (error) {
153: vrele(devvp);
154: return error;
155: }
156:
157: /*
158: * Copy in the name of the directory the filesystem
159: * is to be mounted on.
160: * Then copy in the name of the block special file
161: * representing the filesystem being mounted.
162: * And we clear the remainder of the character strings
163: * to be tidy.
164: * Then, we try to fill in the filesystem stats structure
165: * as best we can with whatever applies from a dos file
166: * system.
167: */
168: pmp = (struct pcfsmount *)mp->mnt_data;
169: copyinstr(path, (caddr_t)mp->mnt_stat.f_mntonname,
170: sizeof(mp->mnt_stat.f_mntonname)-1, &size);
171: bzero(mp->mnt_stat.f_mntonname + size,
172: sizeof(mp->mnt_stat.f_mntonname) - size);
173: copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN-1, &size);
174: bzero(mp->mnt_stat.f_mntfromname + size,
175: MNAMELEN - size);
176: (void)pcfs_statfs(mp, &mp->mnt_stat, p);
177: #if defined(PCFSDEBUG)
178: printf("pcfs_mount(): mp %x, pmp %x, inusemap %x\n", mp, pmp, pmp->pm_inusemap);
179: #endif /* defined(PCFSDEBUG) */
180: return 0;
181: }
182:
183: int
184: mountpcfs(devvp, mp, p)
185: struct vnode *devvp;
186: struct mount *mp;
187: struct proc *p;
188: {
189: int i;
190: u_long bpc;
191: int bit;
192: int error = 0;
193: int needclose;
194: int ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
195: dev_t dev = devvp->v_rdev;
196: union bootsector *bsp;
197: struct pcfsmount *pmp = NULL;
198: struct buf *bp0 = NULL;
199: struct byte_bpb33 *b33;
200: struct byte_bpb50 *b50;
201:
202: /*
203: * Multiple mounts of the same block special file
204: * aren't allowed. Make sure no one else has the
205: * special file open. And flush any old buffers
206: * from this filesystem. Presumably this prevents
207: * us from running into buffers that are the wrong
208: * blocksize.
209: * NOTE: mountedon() is a part of the ufs filesystem.
210: * If the ufs filesystem is not gen'ed into the system
211: * we will get an unresolved reference.
212: */
213: if (error = mountedon(devvp))
214: return error;
215: if (vcount(devvp) > 1)
216: return EBUSY;
217: vinvalbuf(devvp, 1);
218:
219: /*
220: * Now open the block special file.
221: */
222: if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p))
223: return error;
224: needclose = 1;
225:
226: /*
227: * Read the boot sector of the filesystem, and then
228: * check the boot signature. If not a dos boot sector
229: * then error out. We could also add some checking on
230: * the bsOemName field. So far I've seen the following
231: * values:
232: * "IBM 3.3"
233: * "MSDOS3.3"
234: * "MSDOS5.0"
235: */
236: if (error = bread(devvp, 0, 512, NOCRED, &bp0))
237: goto error_exit;
238: bp0->b_flags |= B_AGE;
239: bsp = (union bootsector *)bp0->b_un.b_addr;
240: b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;
241: b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;
242: if (bsp->bs50.bsBootSectSig != BOOTSIG) {
243: error = EINVAL;
244: goto error_exit;
245: }
246:
247: pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK);
248: pmp->pm_inusemap = NULL;
249: pmp->pm_mountp = mp;
250:
251: /*
252: * Compute several useful quantities from the bpb in
253: * the bootsector. Copy in the dos 5 variant of the
254: * bpb then fix up the fields that are different between
255: * dos 5 and dos 3.3.
256: */
257: pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);
258: pmp->pm_SectPerClust = b50->bpbSecPerClust;
259: pmp->pm_ResSectors = getushort(b50->bpbResSectors);
260: pmp->pm_FATs = b50->bpbFATs;
261: pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);
262: pmp->pm_Sectors = getushort(b50->bpbSectors);
263: pmp->pm_Media = b50->bpbMedia;
264: pmp->pm_FATsecs = getushort(b50->bpbFATsecs);
265: pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack);
266: pmp->pm_Heads = getushort(b50->bpbHeads);
267: if (pmp->pm_Sectors == 0) {
268: pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs);
269: pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors);
270: } else {
271: pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs);
272: pmp->pm_HugeSectors = pmp->pm_Sectors;
273: }
274: pmp->pm_fatblk = pmp->pm_ResSectors;
275: pmp->pm_rootdirblk = pmp->pm_fatblk +
276: (pmp->pm_FATs * pmp->pm_FATsecs);
277: pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry))
278: /
279: pmp->pm_BytesPerSec; /* in sectors */
280: pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize;
281: pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) /
282: pmp->pm_SectPerClust;
283: pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1;
284: pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec;
285: if (FAT12(pmp))
286: /* This will usually be a floppy disk.
287: * This size makes sure that one fat entry will not be split
288: * across multiple blocks. */
289: pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec;
290: else
291: /* This will usually be a hard disk.
292: * Reading or writing one block should be quite fast. */
293: pmp->pm_fatblocksize = MAXBSIZE;
294: pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec;
295:
296: if ((pmp->pm_rootdirsize % pmp->pm_SectPerClust) != 0)
297: printf("mountpcfs(): root directory is not a multiple of the clustersize in length\n");
298:
299: /*
300: * Compute mask and shift value for isolating cluster relative
301: * byte offsets and cluster numbers from a file offset.
302: */
303: bpc = pmp->pm_SectPerClust * pmp->pm_BytesPerSec;
304: if (!bpc || (bpc & (bpc - 1))) {
305: error = EINVAL;
306: goto error_exit;
307: }
308: pmp->pm_bpcluster = bpc;
309: pmp->pm_depclust = bpc/sizeof(struct direntry);
310: pmp->pm_crbomask = bpc - 1;
311: pmp->pm_cnshift = ffs(bpc) - 1;
312:
313: pmp->pm_brbomask = 0x01ff; /* 512 byte blocks only (so far) */
314: pmp->pm_bnshift = 9; /* shift right 9 bits to get bn */
315:
316: /*
317: * Release the bootsector buffer.
318: */
319: brelse(bp0);
320: bp0 = NULL;
321:
322: /*
323: * Allocate memory for the bitmap of allocated clusters,
324: * and then fill it in.
325: */
326: pmp->pm_inusemap = malloc((pmp->pm_maxcluster / 8) + 1,
327: M_MSDOSFSFAT, M_WAITOK);
328:
329: /*
330: * fillinusemap() needs pm_devvp.
331: */
332: pmp->pm_dev = dev;
333: pmp->pm_devvp = devvp;
334:
335: /*
336: * Have the inuse map filled in.
337: */
338: error = fillinusemap(pmp);
339: if (error)
340: goto error_exit;
341:
342: /*
343: * If they want fat updates to be synchronous then let
344: * them suffer the performance degradation in exchange
345: * for the on disk copy of the fat being correct just
346: * about all the time. I suppose this would be a good
347: * thing to turn on if the kernel is still flakey.
348: */
349: pmp->pm_waitonfat = mp->mnt_flag & MNT_SYNCHRONOUS;
350:
351: /*
352: * Finish up.
353: */
354: pmp->pm_ronly = ronly;
355: if (ronly == 0)
356: pmp->pm_fmod = 1;
357: mp->mnt_data = (qaddr_t)pmp;
358: mp->mnt_stat.f_fsid.val[0] = (long)dev;
359: mp->mnt_stat.f_fsid.val[1] = MOUNT_MSDOS;
360: mp->mnt_flag |= MNT_LOCAL;
361: #if defined(QUOTA)
362: /*
363: * If we ever do quotas for DOS filesystems this would
364: * be a place to fill in the info in the pcfsmount
365: * structure.
366: * You dolt, quotas on dos filesystems make no sense
367: * because files have no owners on dos filesystems.
368: * of course there is some empty space in the directory
369: * entry where we could put uid's and gid's.
370: */
371: #endif /* defined(QUOTA) */
372: devvp->v_specflags |= SI_MOUNTEDON;
373:
374: return 0;
375:
376: error_exit:;
377: if (bp0)
378: brelse(bp0);
379: if (needclose)
380: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE,
381: NOCRED, p);
382: if (pmp) {
383: if (pmp->pm_inusemap)
384: free((caddr_t)pmp->pm_inusemap, M_MSDOSFSFAT);
385: free((caddr_t)pmp, M_MSDOSFSMNT);
386: mp->mnt_data = (qaddr_t)0;
387: }
388: return error;
389: }
390:
391: int
392: pcfs_start(mp, flags, p)
393: struct mount *mp;
394: int flags;
395: struct proc *p;
396: {
397: return 0;
398: }
399:
400: /*
401: * Unmount the filesystem described by mp.
402: */
403: int
404: pcfs_unmount(mp, mntflags, p)
405: struct mount *mp;
406: int mntflags;
407: struct proc *p;
408: {
409: int flags = 0;
410: int error;
411: struct pcfsmount *pmp = (struct pcfsmount *)mp->mnt_data;
412: struct vnode *vp = pmp->pm_devvp;
413:
414: if (mntflags & MNT_FORCE) {
415: if (!pcfsdoforce)
416: return EINVAL;
417: flags |= FORCECLOSE;
418: }
419: mntflushbuf(mp, 0);
420: if (mntinvalbuf(mp))
421: return EBUSY;
422: #if defined(QUOTA)
423: #endif /* defined(QUOTA) */
424: if (error = vflush(mp, NULLVP, flags))
425: return error;
426: pmp->pm_devvp->v_specflags &= ~SI_MOUNTEDON;
427: #if defined(PCFSDEBUG)
428: printf("pcfs_umount(): just before calling VOP_CLOSE()\n");
429: printf("flag %08x, usecount %d, writecount %d, holdcnt %d\n",
430: vp->v_flag, vp->v_usecount, vp->v_writecount, vp->v_holdcnt);
431: printf("lastr %d, id %d, mount %08x, op %08x\n",
432: vp->v_lastr, vp->v_id, vp->v_mount, vp->v_op);
433: printf("freef %08x, freeb %08x, mountf %08x, mountb %08x\n",
434: vp->v_freef, vp->v_freeb, vp->v_mountf, vp->v_mountb);
435: printf("cleanblkhd %08x, dirtyblkhd %08x, numoutput %d, type %d\n",
436: vp->v_cleanblkhd, vp->v_dirtyblkhd, vp->v_numoutput, vp->v_type);
437: printf("union %08x, tag %d, data[0] %08x, data[1] %08x\n",
438: vp->v_socket, vp->v_tag, vp->v_data[0], vp->v_data[1]);
439: #endif /* defined(PCFSDEBUG) */
440: error = VOP_CLOSE(pmp->pm_devvp, pmp->pm_ronly ? FREAD : FREAD|FWRITE,
441: NOCRED, p);
442: vrele(pmp->pm_devvp);
443: free((caddr_t)pmp->pm_inusemap, M_MSDOSFSFAT);
444: free((caddr_t)pmp, M_MSDOSFSMNT);
445: mp->mnt_data = (qaddr_t)0;
446: mp->mnt_flag &= ~MNT_LOCAL;
447: return error;
448: }
449:
450: int
451: pcfs_root(mp, vpp)
452: struct mount *mp;
453: struct vnode **vpp;
454: {
455: struct denode *ndep;
456: struct pcfsmount *pmp = (struct pcfsmount *)(mp->mnt_data);
457: int error;
458:
459: error = deget(pmp, PCFSROOT, PCFSROOT_OFS, NULL, &ndep);
460: #if defined(PCFSDEBUG)
461: printf("pcfs_root(); mp %08x, pmp %08x, ndep %08x, vp %08x\n",
462: mp, pmp, ndep, DETOV(ndep));
463: #endif /* defined(PCFSDEBUG) */
464: if (error == 0)
465: *vpp = DETOV(ndep);
466: return error;
467: }
468:
469: int
470: pcfs_quotactl(mp, cmds, uid, arg, p)
471: struct mount *mp;
472: int cmds;
473: uid_t uid;
474: caddr_t arg;
475: struct proc *p;
476: {
477: #if defined(QUOTA)
478: #else
479: return EOPNOTSUPP;
480: #endif /* defined(QUOTA) */
481: }
482:
483: int
484: pcfs_statfs(mp, sbp, p)
485: struct mount *mp;
486: struct statfs *sbp;
487: struct proc *p;
488: {
489: struct pcfsmount *pmp = (struct pcfsmount *)mp->mnt_data;
490:
491: /*
492: * Fill in the stat block.
493: */
494: sbp->f_type = MOUNT_MSDOS;
495: sbp->f_fsize = pmp->pm_bpcluster;
496: sbp->f_bsize = pmp->pm_bpcluster;
497: sbp->f_blocks = pmp->pm_nmbrofclusters;
498: sbp->f_bfree = pmp->pm_freeclustercount;
499: sbp->f_bavail = pmp->pm_freeclustercount;
500: sbp->f_files = pmp->pm_RootDirEnts;
501: sbp->f_ffree = 0; /* what to put in here? */
502:
503: /*
504: * Copy the mounted on and mounted from names into
505: * the passed in stat block, if it is not the one
506: * in the mount structure.
507: */
508: if (sbp != &mp->mnt_stat) {
509: bcopy((caddr_t)mp->mnt_stat.f_mntonname,
510: (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
511: bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
512: (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
513: }
514: return 0;
515: }
516:
517: int
518: pcfs_sync(mp, waitfor)
519: struct mount *mp;
520: int waitfor;
521: {
522: struct vnode *vp;
523: struct denode *dep;
524: struct pcfsmount *pmp;
525: int error;
526: int allerror = 0;
527:
528: pmp = (struct pcfsmount *)mp->mnt_data;
529:
530: /*
531: * If we ever switch to not updating all of the fats
532: * all the time, this would be the place to update them
533: * from the first one.
534: */
535: if (pmp->pm_fmod) {
536: if (pmp->pm_ronly) {
537: printf("pcfs_sync(): writing to readonly filesystem\n");
538: return EINVAL;
539: } else {
540: /* update fats here */
541: }
542: }
543:
544: /*
545: * Go thru in memory denodes and write them out along
546: * with unwritten file blocks.
547: */
548: loop:
549: for (vp = mp->mnt_mounth; vp; vp = vp->v_mountf) {
550: if (vp->v_mount != mp) /* not ours anymore */
551: goto loop;
552: if (VOP_ISLOCKED(vp)) /* file is busy */
553: continue;
554: dep = VTODE(vp);
555: if ((dep->de_flag & DEUPD) == 0 && vp->v_dirtyblkhd == NULL)
556: continue;
557: if (vget(vp)) /* not there anymore? */
558: goto loop;
559: if (vp->v_dirtyblkhd) /* flush dirty file blocks */
560: vflushbuf(vp, 0);
561: if ((dep->de_flag & DEUPD) &&
562: (error = deupdat(dep, &time, 0)))
563: allerror = error;
564: vput(vp); /* done with this one */
565: }
566:
567: /*
568: * Flush filesystem control info.
569: */
570: vflushbuf(pmp->pm_devvp, waitfor == MNT_WAIT ? B_SYNC : 0);
571: return allerror;
572: }
573:
574: int
575: pcfs_fhtovp (mp, fhp, vpp)
576: struct mount *mp;
577: struct fid *fhp;
578: struct vnode **vpp;
579: {
580: struct pcfsmount *pmp = (struct pcfsmount *)mp->mnt_data;
581: struct defid *defhp = (struct defid *)fhp;
582: struct denode *dep;
583: int error;
584:
585: error = deget (pmp, defhp->defid_dirclust, defhp->defid_dirofs,
586: NULL, &dep);
587: if (error)
588: return (error);
589: *vpp = DETOV (dep);
590: return (0);
591: }
592:
593:
594: int
595: pcfs_vptofh (vp, fhp)
596: struct vnode *vp;
597: struct fid *fhp;
598: {
599: struct denode *dep = VTODE(vp);
600: struct defid *defhp = (struct defid *)fhp;
601:
602: defhp->defid_len = sizeof(struct defid);
603: defhp->defid_dirclust = dep->de_dirclust;
604: defhp->defid_dirofs = dep->de_diroffset;
605: /* defhp->defid_gen = ip->i_gen; */
606: return (0);
607: }
608:
609: struct vfsops pcfs_vfsops = {
610: pcfs_mount,
611: pcfs_start,
612: pcfs_unmount,
613: pcfs_root,
614: pcfs_quotactl,
615: pcfs_statfs,
616: pcfs_sync,
617: pcfs_fhtovp,
618: pcfs_vptofh,
619: pcfs_init
620: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.