Annotation of sys/compat/ibcs2/ibcs2_stat.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ibcs2_stat.c,v 1.13 2004/07/09 23:52:02 millert Exp $ */
2: /* $NetBSD: ibcs2_stat.c,v 1.5 1996/05/03 17:05:32 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Scott Bartram
6: * All rights reserved.
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 ANY EXPRESS OR
20: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: #include <sys/param.h>
32: #include <sys/systm.h>
33: #include <sys/namei.h>
34: #include <sys/proc.h>
35: #include <sys/file.h>
36: #include <sys/stat.h>
37: #include <sys/filedesc.h>
38: #include <sys/ioctl.h>
39: #include <sys/kernel.h>
40: #include <sys/mount.h>
41: #include <sys/malloc.h>
42: #include <sys/vnode.h>
43: #include <sys/syscallargs.h>
44:
45: #include <uvm/uvm_extern.h>
46:
47: #include <compat/ibcs2/ibcs2_types.h>
48: #include <compat/ibcs2/ibcs2_fcntl.h>
49: #include <compat/ibcs2/ibcs2_signal.h>
50: #include <compat/ibcs2/ibcs2_stat.h>
51: #include <compat/ibcs2/ibcs2_statfs.h>
52: #include <compat/ibcs2/ibcs2_syscallargs.h>
53: #include <compat/ibcs2/ibcs2_ustat.h>
54: #include <compat/ibcs2/ibcs2_util.h>
55: #include <compat/ibcs2/ibcs2_utsname.h>
56:
57: static void bsd_stat2ibcs_stat(struct stat43 *, struct ibcs2_stat *);
58: static int cvt_statfs(struct statfs *, caddr_t, int);
59:
60: static void
61: bsd_stat2ibcs_stat(st, st4)
62: struct stat43 *st;
63: struct ibcs2_stat *st4;
64: {
65: bzero(st4, sizeof(*st4));
66: st4->st_dev = (ibcs2_dev_t)st->st_dev;
67: st4->st_ino = (ibcs2_ino_t)st->st_ino;
68: st4->st_mode = (ibcs2_mode_t)st->st_mode;
69: st4->st_nlink = (ibcs2_nlink_t)st->st_nlink;
70: st4->st_uid = (ibcs2_uid_t)st->st_uid;
71: st4->st_gid = (ibcs2_gid_t)st->st_gid;
72: st4->st_rdev = (ibcs2_dev_t)st->st_rdev;
73: st4->st_size = (ibcs2_off_t)st->st_size;
74: st4->st_atim = (ibcs2_time_t)st->st_atime;
75: st4->st_mtim = (ibcs2_time_t)st->st_mtime;
76: st4->st_ctim = (ibcs2_time_t)st->st_ctime;
77: }
78:
79: static int
80: cvt_statfs(sp, buf, len)
81: struct statfs *sp;
82: caddr_t buf;
83: int len;
84: {
85: struct ibcs2_statfs ssfs;
86:
87: if (len < 0)
88: return (EINVAL);
89: if (len > sizeof(ssfs))
90: len = sizeof(ssfs);
91:
92: bzero(&ssfs, sizeof ssfs);
93: ssfs.f_fstyp = 0;
94: ssfs.f_bsize = sp->f_bsize;
95: ssfs.f_frsize = 0;
96: ssfs.f_blocks = sp->f_blocks;
97: ssfs.f_bfree = sp->f_bfree;
98: ssfs.f_files = sp->f_files;
99: ssfs.f_ffree = sp->f_ffree;
100: ssfs.f_fname[0] = 0;
101: ssfs.f_fpack[0] = 0;
102: return copyout((caddr_t)&ssfs, buf, len);
103: }
104:
105: int
106: ibcs2_sys_statfs(p, v, retval)
107: struct proc *p;
108: void *v;
109: register_t *retval;
110: {
111: struct ibcs2_sys_statfs_args /* {
112: syscallarg(char *) path;
113: syscallarg(struct ibcs2_statfs *) buf;
114: syscallarg(int) len;
115: syscallarg(int) fstype;
116: } */ *uap = v;
117: register struct mount *mp;
118: register struct statfs *sp;
119: int error;
120: struct nameidata nd;
121: caddr_t sg = stackgap_init(p->p_emul);
122:
123: IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
124: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
125: if ((error = namei(&nd)) != 0)
126: return (error);
127: mp = nd.ni_vp->v_mount;
128: sp = &mp->mnt_stat;
129: vrele(nd.ni_vp);
130: if ((error = VFS_STATFS(mp, sp, p)) != 0)
131: return (error);
132: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
133: return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
134: }
135:
136: int
137: ibcs2_sys_fstatfs(p, v, retval)
138: struct proc *p;
139: void *v;
140: register_t *retval;
141: {
142: struct ibcs2_sys_fstatfs_args /* {
143: syscallarg(int) fd;
144: syscallarg(struct ibcs2_statfs *) buf;
145: syscallarg(int) len;
146: syscallarg(int) fstype;
147: } */ *uap = v;
148: struct file *fp;
149: struct mount *mp;
150: register struct statfs *sp;
151: int error;
152:
153: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
154: return (error);
155: mp = ((struct vnode *)fp->f_data)->v_mount;
156: sp = &mp->mnt_stat;
157: error = VFS_STATFS(mp, sp, p);
158: FRELE(fp);
159: if (error)
160: return (error);
161: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
162: return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len));
163: }
164:
165: int
166: ibcs2_sys_stat(p, v, retval)
167: struct proc *p;
168: void *v;
169: register_t *retval;
170: {
171: struct ibcs2_sys_stat_args /* {
172: syscallarg(char *) path;
173: syscallarg(struct ibcs2_stat *) st;
174: } */ *uap = v;
175: struct stat43 st;
176: struct ibcs2_stat ibcs2_st;
177: struct compat_43_sys_stat_args cup;
178: int error;
179: caddr_t sg = stackgap_init(p->p_emul);
180:
181: SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
182: IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
183: SCARG(&cup, path) = SCARG(uap, path);
184:
185: if ((error = compat_43_sys_stat(p, &cup, retval)) != 0)
186: return error;
187: if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
188: return error;
189: bsd_stat2ibcs_stat(&st, &ibcs2_st);
190: return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
191: ibcs2_stat_len);
192: }
193:
194: int
195: ibcs2_sys_lstat(p, v, retval)
196: struct proc *p;
197: void *v;
198: register_t *retval;
199: {
200: struct ibcs2_sys_lstat_args /* {
201: syscallarg(char *) path;
202: syscallarg(struct ibcs2_stat *) st;
203: } */ *uap = v;
204: struct stat43 st;
205: struct ibcs2_stat ibcs2_st;
206: struct compat_43_sys_lstat_args cup;
207: int error;
208: caddr_t sg = stackgap_init(p->p_emul);
209:
210: SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st));
211: IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
212: SCARG(&cup, path) = SCARG(uap, path);
213:
214: if ((error = compat_43_sys_lstat(p, &cup, retval)) != 0)
215: return error;
216: if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0)
217: return error;
218: bsd_stat2ibcs_stat(&st, &ibcs2_st);
219: return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
220: ibcs2_stat_len);
221: }
222:
223: int
224: ibcs2_sys_fstat(p, v, retval)
225: struct proc *p;
226: void *v;
227: register_t *retval;
228: {
229: struct ibcs2_sys_fstat_args /* {
230: syscallarg(int) fd;
231: syscallarg(struct ibcs2_stat *) st;
232: } */ *uap = v;
233: struct stat43 st;
234: struct ibcs2_stat ibcs2_st;
235: struct compat_43_sys_fstat_args cup;
236: int error;
237: caddr_t sg = stackgap_init(p->p_emul);
238:
239: SCARG(&cup, fd) = SCARG(uap, fd);
240: SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st));
241: if ((error = compat_43_sys_fstat(p, &cup, retval)) != 0)
242: return error;
243: if ((error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0)
244: return error;
245: bsd_stat2ibcs_stat(&st, &ibcs2_st);
246: return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st),
247: ibcs2_stat_len);
248: }
249:
250: int
251: ibcs2_sys_utssys(p, v, retval)
252: struct proc *p;
253: void *v;
254: register_t *retval;
255: {
256: struct ibcs2_sys_utssys_args /* {
257: syscallarg(int) a1;
258: syscallarg(int) a2;
259: syscallarg(int) flag;
260: } */ *uap = v;
261:
262: switch (SCARG(uap, flag)) {
263: case 0: /* uname(2) */
264: {
265: struct ibcs2_utsname sut;
266: extern char machine[];
267:
268: bzero(&sut, ibcs2_utsname_len);
269: bcopy(ostype, sut.sysname, sizeof(sut.sysname) - 1);
270: bcopy(hostname, sut.nodename, sizeof(sut.nodename));
271: sut.nodename[sizeof(sut.nodename)-1] = '\0';
272: bcopy(osrelease, sut.release, sizeof(sut.release) - 1);
273: strlcpy(sut.version, "1", sizeof(sut.version));
274: bcopy(machine, sut.machine, sizeof(sut.machine) - 1);
275:
276: return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, a1),
277: ibcs2_utsname_len);
278: }
279:
280: case 2: /* ustat(2) */
281: {
282: return ENOSYS; /* XXX - TODO */
283: }
284:
285: default:
286: return ENOSYS;
287: }
288: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ibcs2_stat.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ibcs2