Annotation of sys/compat/ultrix/ultrix_fs.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ultrix_fs.c,v 1.14 2006/03/05 21:48:56 miod Exp $ */
2: /* $NetBSD: ultrix_fs.c,v 1.4 1996/04/07 17:23:06 jonathan Exp $ */
3:
4: /*
5: * Copyright (c) 1995
6: * Jonathan Stone (hereinafter referred to as the author)
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. The name of the author may not be used to endorse or promote products
17: * derived from this software without specific prior written permission.
18: *
19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
20: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
23: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29: * SUCH DAMAGE.
30: */
31:
32: #include <sys/param.h>
33: #include <sys/systm.h>
34: #include <sys/malloc.h>
35: #include <sys/exec.h>
36: #include <sys/namei.h>
37: #include <sys/mount.h>
38: #include <net/if.h>
39: #include <netinet/in.h>
40:
41: #include <nfs/rpcv2.h>
42: #include <nfs/nfsproto.h>
43: #include <nfs/nfs.h>
44:
45: #include <sys/syscallargs.h>
46: #include <compat/ultrix/ultrix_syscallargs.h>
47:
48: #include <uvm/uvm_extern.h>
49:
50: #define ULTRIX_MAXPATHLEN 1024
51:
52: /**
53: ** Ultrix filesystem operations: mount(), getmnt().
54: ** These are included purely so one can place an (ECOFF or ELF)
55: ** NetBSD/pmax kernel in an Ultrix root filesystem, boot it,
56: ** and over-write the Ultrix root parition with NetBSD binaries.
57: **/
58:
59: /*
60: * Ultrix file system data structure, as modified by
61: * Ultrix getmntent(). This structure is padded to 2560 bytes, for
62: * compatibility with the size the Ultrix kernel and user apps expect.
63: */
64: struct ultrix_fs_data {
65: u_int32_t ufsd_flags; /* how mounted */
66: u_int32_t ufsd_mtsize; /* max transfer size in bytes */
67: u_int32_t ufsd_otsize; /* optimal transfer size in bytes */
68: u_int32_t ufsd_bsize; /* fs block size (bytes) for vm code */
69: u_int32_t ufsd_fstype; /* see ../h/fs_types.h */
70: u_int32_t ufsd_gtot; /* total number of gnodes */
71: u_int32_t ufsd_gfree; /* # of free gnodes */
72: u_int32_t ufsd_btot; /* total number of 1K blocks */
73: u_int32_t ufsd_bfree; /* # of free 1K blocks */
74: u_int32_t ufsd_bfreen; /* user consumable 1K blocks */
75: u_int32_t ufsd_pgthresh; /* min size in bytes before paging*/
76: int32_t ufsd_uid; /* uid that mounted me */
77: int16_t ufsd_dev; /* major/minor of fs */
78: int16_t ufsd_exroot; /* root mapping from exports */
79: char ufsd_devname[ULTRIX_MAXPATHLEN + 4]; /* name of dev */
80: char ufsd_path[ULTRIX_MAXPATHLEN + 4]; /* name of mnt point */
81: u_int32_t ufsd_nupdate; /* number of writes */
82: u_int32_t ufsd_pad[112]; /* pad to 2560 bytes. */
83: };
84:
85: /*
86: * Get statistics on mounted filesystems.
87: */
88: #if 0
89: struct ultrix_getmnt_args {
90: int32_t *start;
91: struct ultrix_fs_data *buf;
92: int32_t bufsize;
93: int32_t mode;
94: char *path;
95: };
96:
97: #endif
98: /*
99: * Ultrix getmnt() flags.
100: * The operation getmnt() should perform is incoded in the flag
101: * argument. There are two independent attributes.
102: *
103: * ULTRIX_NOSTAT_xxx will never hang, but it may not return
104: * up-to-date statistics. (For NFS clients, it returns whatever is
105: * in the cache.) ULTRIX_STAT_xxx returns up-to-date info but may
106: * hang (e.g., on dead NFS servers).
107: *
108: * ULTRIX_xxSTAT_ONE returns statistics on just one filesystem, determined
109: * by the parth argument. ULTRIX_xxSTAT_MANY ignores the path argument and
110: * returns info on as many filesystems fit in the structure.
111: * the start argument, which should be zero on the first call,
112: * can be used to iterate over all filesystems.
113: *
114: */
115: #define ULTRIX_NOSTAT_MANY 1
116: #define ULTRIX_STAT_MANY 2
117: #define ULTRIX_STAT_ONE 3
118: #define ULTRIX_NOSTAT_ONE 4
119:
120: /*
121: * Ultrix gnode-layer filesystem codes.
122: */
123: #define ULTRIX_FSTYPE_UNKNOWN 0x0
124: #define ULTRIX_FSTYPE_ULTRIX 0x1 /* Ultrix UFS: basically 4.2bsd FFS */
125: #define ULTRIX_FSTYPE_NFS 0x5 /* NFS v2 */
126:
127: /*
128: * Ultrix mount(2) options
129: */
130: #define ULTRIX_NM_RONLY 0x0001 /* mount read-only */
131: #define ULTRIX_NM_SOFT 0x0002 /* soft mount (hard is default) */
132: #define ULTRIX_NM_WSIZE 0x0004 /* set write size */
133: #define ULTRIX_NM_RSIZE 0x0008 /* set read size */
134: #define ULTRIX_NM_TIMEO 0x0010 /* set initial timeout */
135: #define ULTRIX_NM_RETRANS 0x0020 /* set number of request retries */
136: #define ULTRIX_NM_HOSTNAME 0x0040 /* set hostname for error printf */
137: #define ULTRIX_NM_PGTHRESH 0x0080 /* set page threshold for exec */
138: #define ULTRIX_NM_INT 0x0100 /* allow hard mount keyboard interrupts */
139: #define ULTRIX_NM_NOAC 0x0200 /* don't cache attributes */
140:
141:
142: /*
143: * Construct an Ultrix getmnt() ultrix_fs_data from the native NetBSD
144: * struct statfs.
145: */
146: static void
147: make_ultrix_mntent(sp, tem)
148: register struct statfs *sp;
149: register struct ultrix_fs_data *tem;
150: {
151:
152: bzero(tem, sizeof (*tem));
153:
154: tem->ufsd_flags = sp->f_flags; /* XXX translate */
155: tem->ufsd_mtsize = sp->f_bsize; /* XXX max transfer size */
156: tem->ufsd_otsize = sp->f_iosize;
157: tem->ufsd_bsize = sp->f_bsize;
158: /*
159: * Translate file system type. NetBSD/1.1 has f_type zero,
160: * and uses an fstype string instead.
161: * For now, map types not in Ultrix (kernfs, null, procfs...)
162: * to UFS, since Ultrix mout will try and call mount_unknown
163: * for ULTRIX_FSTYPE_UNKNOWN, but lacks a mount_unknown binary.
164: */
165: tem->ufsd_fstype = ULTRIX_FSTYPE_NFS;
166: if (strcmp(sp->f_fstypename, "ffs") == 0)
167: tem->ufsd_fstype = ULTRIX_FSTYPE_ULTRIX;
168:
169: tem->ufsd_gtot = sp->f_files; /* total "gnodes" */
170: tem->ufsd_gfree = sp->f_ffree; /* free "gnodes" */
171: tem->ufsd_btot = sp->f_blocks; /* total 1k blocks */
172: #ifdef needsmorethought /* XXX */
173: /* tem->ufsd_bfree = sp->f_bfree; */ /* free 1k blocks */
174: /* tem->ufsd_bfree = sp->f_bavail; */ /* free 1k blocks */
175: #endif
176:
177: tem->ufsd_bfreen = sp->f_bavail; /* blocks available to users */
178: tem->ufsd_pgthresh = 0; /* not relevant */
179: tem->ufsd_uid = 0; /* XXX kept where ?*/
180: tem->ufsd_dev = 0; /* ?? */
181: tem->ufsd_exroot = 0; /* ?? */
182: strlcpy(tem->ufsd_path, sp->f_mntonname, sizeof(tem->ufsd_path));
183: strlcpy(tem->ufsd_devname, sp->f_mntfromname,
184: sizeof(tem->ufsd_devname));
185: #if 0
186: /* In NetBSD-1.1, filesystem type is unused and always 0 */
187: printf("mntent: %s type %d\n", tem->ufsd_devname, tem->ufsd_fstype);
188: printf("mntent: %s tot %d free %d user%d\n",
189: tem->ufsd_devname, sp->f_blocks, sp->f_bfree, sp->f_bavail);
190: #endif
191: }
192:
193: int
194: ultrix_sys_getmnt(p, v, retval)
195: struct proc *p;
196: void *v;
197: int *retval;
198: {
199: struct ultrix_sys_getmnt_args *uap = v;
200: struct mount *mp, *nmp;
201: struct statfs *sp;
202: struct ultrix_fs_data *sfsp;
203: char *path;
204: int mntflags;
205: int skip;
206: int start;
207: long count, maxcount;
208: int error = 0;
209:
210: path = NULL;
211: error = 0;
212: maxcount = SCARG(uap, bufsize) / sizeof(struct ultrix_fs_data);
213: sfsp = SCARG(uap, buf);
214:
215: if (SCARG(uap, mode) == ULTRIX_STAT_ONE ||
216: SCARG(uap, mode) == ULTRIX_STAT_MANY)
217: mntflags = MNT_WAIT;
218: else
219: mntflags = MNT_NOWAIT;
220:
221: if (SCARG(uap, mode) == ULTRIX_STAT_ONE || SCARG(uap, mode) == ULTRIX_NOSTAT_ONE) {
222: /*
223: * Only get info on mountpoints that matches the path
224: * provided.
225: */
226: MALLOC(path, char *, MAXPATHLEN, M_TEMP, M_WAITOK);
227: if ((error = copyinstr(SCARG(uap, path), path,
228: MAXPATHLEN, NULL)) != 0)
229: goto bad;
230: maxcount = 1;
231: } else {
232: /*
233: * Get info on any mountpoints, somewhat like readdir().
234: * Find out how many mount list entries to skip, and skip
235: * them.
236: */
237: if ((error = copyin((caddr_t)SCARG(uap, start), &start,
238: sizeof(*SCARG(uap, start)))) != 0)
239: goto bad;
240: for (skip = start, mp = CIRCLEQ_FIRST(&mountlist);
241: mp != CIRCLEQ_END(&mountlist) && skip-- > 0; mp = nmp)
242: nmp = CIRCLEQ_NEXT(mp, mnt_list);
243: }
244:
245: for (count = 0, mp = CIRCLEQ_FIRST(&mountlist);
246: mp != CIRCLEQ_END(&mountlist) && count < maxcount; mp = nmp) {
247: nmp = CIRCLEQ_NEXT(mp, mnt_list);
248: if (sfsp != NULL) {
249: struct ultrix_fs_data tem;
250: sp = &mp->mnt_stat;
251:
252: /*
253: * If requested, refresh the fsstat cache.
254: */
255: if ((mntflags & MNT_WAIT) != 0 &&
256: (error = VFS_STATFS(mp, sp, p)) != 0)
257: continue;
258:
259: /*
260: * XXX what does this do? -- cgd
261: */
262: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
263: if (path == NULL ||
264: strcmp(path, sp->f_mntonname) == 0) {
265: make_ultrix_mntent(sp, &tem);
266: if ((error = copyout((caddr_t)&tem, sfsp,
267: sizeof(tem))) != 0)
268: goto bad;
269: sfsp++;
270: count++;
271: }
272: }
273: }
274:
275: if (sfsp != NULL && count > maxcount)
276: *retval = maxcount;
277: else
278: *retval = count;
279:
280: bad:
281: if (path)
282: FREE(path, M_TEMP);
283: return (error);
284: }
285:
286:
287:
288: /* Old-style inet sockaddr (no len field) as passed to Ultrix mount(2) */
289: struct osockaddr_in {
290: short sin_family;
291: u_short sin_port;
292: struct in_addr sin_addr;
293: char sin_zero[8];
294: };
295:
296:
297: /*
298: * fstype-dependent structure passed to Ultrix mount(2) when
299: * mounting NFS filesystems
300: */
301: struct ultrix_nfs_args {
302: struct osockaddr_in *addr; /* file server address */
303: void *fh; /* file handle to be mounted */
304: int flags; /* flags */
305: int wsize; /* write size in bytes */
306: int rsize; /* read size in bytes */
307: int timeo; /* initial timeout in .1 secs */
308: int retrans; /* times to retry send */
309: char *hostname; /* server's hostname */
310: char *optstr; /* string of nfs mount options*/
311: int gfs_flags; /* gnode flags (ugh) */
312: int pg_thresh; /* paging threshold ? */
313: };
314:
315:
316: /*
317: * fstype-dependent structure passed to Ultrix mount(2) when
318: * mounting local (4.2bsd FFS) filesystems
319: */
320: struct ultrix_ufs_args {
321: u_long ufs_flags; /* mount flags?*/
322: u_long ufs_pgthresh; /* minimum file size to page */
323: };
324:
325: int
326: ultrix_sys_mount(p, v, retval)
327: struct proc *p;
328: void *v;
329: int *retval;
330: {
331: struct ultrix_sys_mount_args *uap = v;
332:
333: int error;
334: int otype = SCARG(uap, type);
335: char fsname[MFSNAMELEN];
336: char * fstype;
337: struct sys_mount_args nuap;
338: caddr_t sg = stackgap_init(p->p_emul);
339: caddr_t usp = stackgap_alloc(&sg, 1024 /* XXX */);
340:
341: bzero(&nuap, sizeof(nuap));
342: SCARG(&nuap, flags) = 0;
343:
344: /*
345: * Translate Ultrix integer mount codes for UFS and NFS to
346: * NetBSD fstype strings. Other Ultrix filesystem types
347: * (msdos, DEC ods-2) are not supported.
348: */
349: if (otype == ULTRIX_FSTYPE_ULTRIX)
350: fstype = "ufs";
351: else if (otype == ULTRIX_FSTYPE_NFS)
352: fstype = "nfs";
353: else
354: return (EINVAL);
355:
356: /* Translate the Ultrix mount-readonly option parameter */
357: if (SCARG(uap, rdonly))
358: SCARG(&nuap, flags) |= MNT_RDONLY;
359:
360: /* Copy string-ified version of mount type back out to user space */
361: SCARG(&nuap, type) = (char *)usp;
362: if ((error = copyout(fstype, (void *)SCARG(&nuap, type),
363: strlen(fstype)+1)) != 0) {
364: return (error);
365: }
366: usp += strlen(fstype)+1;
367:
368: #ifdef later
369: parse ultrix mount option string and set NetBSD flags
370: #endif
371: SCARG(&nuap, path) = SCARG(uap, dir);
372:
373: if (otype == ULTRIX_FSTYPE_ULTRIX) {
374: /* attempt to mount a native, rather than 4.2bsd, ffs */
375: struct ufs_args ua;
376:
377: ua.fspec = SCARG(uap, special);
378: bzero(&ua.export_info, sizeof(ua.export_info));
379: SCARG(&nuap, data) = usp;
380:
381: if ((error = copyout(&ua, SCARG(&nuap, data),
382: sizeof ua)) !=0) {
383: return(error);
384: }
385: /*
386: * Ultrix mount has no MNT_UPDATE flag.
387: * Attempt to see if this is the root we're mounting,
388: * and if so, set MNT_UPDATE so we can mount / read-write.
389: */
390: fsname[0] = 0;
391: if ((error = copyinstr((caddr_t)SCARG(&nuap, path), fsname,
392: sizeof fsname, (u_int *)0)) != 0)
393: return(error);
394: if (strcmp(fsname, "/") == 0) {
395: SCARG(&nuap, flags) |= MNT_UPDATE;
396: printf("COMPAT_ULTRIX: mount with MNT_UPDATE on %s\n",
397: fsname);
398: }
399: } else if (otype == ULTRIX_FSTYPE_NFS) {
400: struct ultrix_nfs_args una;
401: struct nfs_args na;
402: struct osockaddr_in osa;
403: struct sockaddr_in *sap = (struct sockaddr_in *)& osa;
404:
405: bzero(&osa, sizeof(osa));
406: bzero(&una, sizeof(una));
407: if ((error = copyin(SCARG(uap, data), &una, sizeof una)) !=0) {
408: return (error);
409: }
410: /*
411: * This is the only syscall boundary the
412: * address of the server passes, so do backwards
413: * compatibility on 4.3style sockaddrs here.
414: */
415: if ((error = copyin(una.addr, &osa, sizeof osa)) != 0) {
416: printf("ultrix_mount: nfs copyin osa\n");
417: return (error);
418: }
419: sap->sin_family = (u_char)osa.sin_family;
420: sap->sin_len = sizeof(*sap);
421: /* allocate space above caller's stack for nfs_args */
422: SCARG(&nuap, data) = usp;
423: usp += sizeof (na);
424: /* allocate space above caller's stack for server sockaddr */
425: na.version = NFS_ARGSVERSION;
426: na.addr = (struct sockaddr *)usp;
427: usp += sizeof(*sap);
428: na.addrlen = sap->sin_len;
429: na.sotype = SOCK_DGRAM;
430: na.proto = IPPROTO_UDP;
431: na.fh = una.fh;
432: na.fhsize = NFSX_V2FH;
433: na.flags = /*una.flags;*/ NFSMNT_NOCONN;
434: na.wsize = una.wsize;
435: na.rsize = una.rsize;
436: na.timeo = una.timeo;
437: na.retrans = una.retrans;
438: na.hostname = una.hostname;
439: if ((error = copyout(sap, na.addr, sizeof (*sap) )) != 0)
440: return (error);
441: if ((error = copyout(&na, SCARG(&nuap, data), sizeof na)) != 0)
442: return (error);
443: }
444: return (sys_mount(p, &nuap, retval));
445: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ultrix_fs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ultrix