1 /*-
2 * Copyright (c) 1995 Steven Wallace
3 * Copyright (c) 1994, 1995 Scott Bartram
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This software was developed by the Computer Systems Engineering group
8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
9 * contributed to Berkeley.
10 *
11 * All advertising materials mentioning features or use of this software
12 * must display the following acknowledgement:
13 * This product includes software developed by the University of
14 * California, Lawrence Berkeley Laboratory.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. All advertising materials mentioning features or use of this software
25 * must display the following acknowledgement:
26 * This product includes software developed by the University of
27 * California, Berkeley and its contributors.
28 * 4. Neither the name of the University nor the names of its contributors
29 * may be used to endorse or promote products derived from this software
30 * without specific prior written permission.
31 *
32 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42 * SUCH DAMAGE.
43 *
44 * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
45 *
46 * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93
47 */
48
49 #include <sys/cdefs.h>
50 __FBSDID("$FreeBSD: releng/8.0/sys/i386/ibcs2/ibcs2_misc.c 195458 2009-07-08 15:23:18Z trasz $");
51
52 /*
53 * IBCS2 compatibility module.
54 *
55 * IBCS2 system calls that are implemented differently in BSD are
56 * handled here.
57 */
58 #include <sys/param.h>
59 #include <sys/systm.h>
60 #include <sys/dirent.h>
61 #include <sys/fcntl.h>
62 #include <sys/filedesc.h>
63 #include <sys/imgact.h>
64 #include <sys/kernel.h>
65 #include <sys/lock.h>
66 #include <sys/malloc.h>
67 #include <sys/file.h> /* Must come after sys/malloc.h */
68 #include <sys/mutex.h>
69 #include <sys/namei.h>
70 #include <sys/priv.h>
71 #include <sys/reboot.h>
72 #include <sys/resourcevar.h>
73 #include <sys/stat.h>
74 #include <sys/sysctl.h>
75 #include <sys/syscallsubr.h>
76 #include <sys/sysproto.h>
77 #include <sys/time.h>
78 #include <sys/times.h>
79 #include <sys/vnode.h>
80 #include <sys/wait.h>
81
82 #include <machine/cpu.h>
83
84 #include <i386/ibcs2/ibcs2_dirent.h>
85 #include <i386/ibcs2/ibcs2_signal.h>
86 #include <i386/ibcs2/ibcs2_proto.h>
87 #include <i386/ibcs2/ibcs2_unistd.h>
88 #include <i386/ibcs2/ibcs2_util.h>
89 #include <i386/ibcs2/ibcs2_utime.h>
90 #include <i386/ibcs2/ibcs2_xenix.h>
91
92 #include <security/mac/mac_framework.h>
93
94 int
95 ibcs2_ulimit(td, uap)
96 struct thread *td;
97 struct ibcs2_ulimit_args *uap;
98 {
99 struct rlimit rl;
100 struct proc *p;
101 int error;
102 #define IBCS2_GETFSIZE 1
103 #define IBCS2_SETFSIZE 2
104 #define IBCS2_GETPSIZE 3
105 #define IBCS2_GETDTABLESIZE 4
106
107 p = td->td_proc;
108 switch (uap->cmd) {
109 case IBCS2_GETFSIZE:
110 PROC_LOCK(p);
111 td->td_retval[0] = lim_cur(p, RLIMIT_FSIZE);
112 PROC_UNLOCK(p);
113 if (td->td_retval[0] == -1)
114 td->td_retval[0] = 0x7fffffff;
115 return 0;
116 case IBCS2_SETFSIZE:
117 PROC_LOCK(p);
118 rl.rlim_max = lim_max(p, RLIMIT_FSIZE);
119 PROC_UNLOCK(p);
120 rl.rlim_cur = uap->newlimit;
121 error = kern_setrlimit(td, RLIMIT_FSIZE, &rl);
122 if (!error) {
123 PROC_LOCK(p);
124 td->td_retval[0] = lim_cur(p, RLIMIT_FSIZE);
125 PROC_UNLOCK(p);
126 } else {
127 DPRINTF(("failed "));
128 }
129 return error;
130 case IBCS2_GETPSIZE:
131 PROC_LOCK(p);
132 td->td_retval[0] = lim_cur(p, RLIMIT_RSS); /* XXX */
133 PROC_UNLOCK(p);
134 return 0;
135 case IBCS2_GETDTABLESIZE:
136 uap->cmd = IBCS2_SC_OPEN_MAX;
137 return ibcs2_sysconf(td, (struct ibcs2_sysconf_args *)uap);
138 default:
139 return ENOSYS;
140 }
141 }
142
143 #define IBCS2_WSTOPPED 0177
144 #define IBCS2_STOPCODE(sig) ((sig) << 8 | IBCS2_WSTOPPED)
145 int
146 ibcs2_wait(td, uap)
147 struct thread *td;
148 struct ibcs2_wait_args *uap;
149 {
150 int error, options, status;
151 int *statusp;
152 pid_t pid;
153 struct trapframe *tf = td->td_frame;
154
155 if ((tf->tf_eflags & (PSL_Z|PSL_PF|PSL_N|PSL_V))
156 == (PSL_Z|PSL_PF|PSL_N|PSL_V)) {
157 /* waitpid */
158 pid = uap->a1;
159 statusp = (int *)uap->a2;
160 options = uap->a3;
161 } else {
162 /* wait */
163 pid = WAIT_ANY;
164 statusp = (int *)uap->a1;
165 options = 0;
166 }
167 error = kern_wait(td, pid, &status, options, NULL);
168 if (error)
169 return error;
170 if (statusp) {
171 /*
172 * Convert status/signal result.
173 */
174 if (WIFSTOPPED(status)) {
175 if (WSTOPSIG(status) <= 0 ||
176 WSTOPSIG(status) > IBCS2_SIGTBLSZ)
177 return (EINVAL);
178 status =
179 IBCS2_STOPCODE(bsd_to_ibcs2_sig[_SIG_IDX(WSTOPSIG(status))]);
180 } else if (WIFSIGNALED(status)) {
181 if (WTERMSIG(status) <= 0 ||
182 WTERMSIG(status) > IBCS2_SIGTBLSZ)
183 return (EINVAL);
184 status = bsd_to_ibcs2_sig[_SIG_IDX(WTERMSIG(status))];
185 }
186 /* else exit status -- identical */
187
188 /* record result/status */
189 td->td_retval[1] = status;
190 return copyout(&status, statusp, sizeof(status));
191 }
192
193 return 0;
194 }
195
196 int
197 ibcs2_execv(td, uap)
198 struct thread *td;
199 struct ibcs2_execv_args *uap;
200 {
201 struct image_args eargs;
202 char *path;
203 int error;
204
205 CHECKALTEXIST(td, uap->path, &path);
206
207 error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, uap->argp, NULL);
208 free(path, M_TEMP);
209 if (error == 0)
210 error = kern_execve(td, &eargs, NULL);
211 return (error);
212 }
213
214 int
215 ibcs2_execve(td, uap)
216 struct thread *td;
217 struct ibcs2_execve_args *uap;
218 {
219 struct image_args eargs;
220 char *path;
221 int error;
222
223 CHECKALTEXIST(td, uap->path, &path);
224
225 error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, uap->argp,
226 uap->envp);
227 free(path, M_TEMP);
228 if (error == 0)
229 error = kern_execve(td, &eargs, NULL);
230 return (error);
231 }
232
233 int
234 ibcs2_umount(td, uap)
235 struct thread *td;
236 struct ibcs2_umount_args *uap;
237 {
238 struct unmount_args um;
239
240 um.path = uap->name;
241 um.flags = 0;
242 return unmount(td, &um);
243 }
244
245 int
246 ibcs2_mount(td, uap)
247 struct thread *td;
248 struct ibcs2_mount_args *uap;
249 {
250 #ifdef notyet
251 int oflags = uap->flags, nflags, error;
252 char fsname[MFSNAMELEN];
253
254 if (oflags & (IBCS2_MS_NOSUB | IBCS2_MS_SYS5))
255 return (EINVAL);
256 if ((oflags & IBCS2_MS_NEWTYPE) == 0)
257 return (EINVAL);
258 nflags = 0;
259 if (oflags & IBCS2_MS_RDONLY)
260 nflags |= MNT_RDONLY;
261 if (oflags & IBCS2_MS_NOSUID)
262 nflags |= MNT_NOSUID;
263 if (oflags & IBCS2_MS_REMOUNT)
264 nflags |= MNT_UPDATE;
265 uap->flags = nflags;
266
267 if (error = copyinstr((caddr_t)uap->type, fsname, sizeof fsname,
268 (u_int *)0))
269 return (error);
270
271 if (strcmp(fsname, "4.2") == 0) {
272 uap->type = (caddr_t)STACK_ALLOC();
273 if (error = copyout("ufs", uap->type, sizeof("ufs")))
274 return (error);
275 } else if (strcmp(fsname, "nfs") == 0) {
276 struct ibcs2_nfs_args sna;
277 struct sockaddr_in sain;
278 struct nfs_args na;
279 struct sockaddr sa;
280
281 if (error = copyin(uap->data, &sna, sizeof sna))
282 return (error);
283 if (error = copyin(sna.addr, &sain, sizeof sain))
284 return (error);
285 bcopy(&sain, &sa, sizeof sa);
286 sa.sa_len = sizeof(sain);
287 uap->data = (caddr_t)STACK_ALLOC();
288 na.addr = (struct sockaddr *)((int)uap->data + sizeof na);
289 na.sotype = SOCK_DGRAM;
290 na.proto = IPPROTO_UDP;
291 na.fh = (nfsv2fh_t *)sna.fh;
292 na.flags = sna.flags;
293 na.wsize = sna.wsize;
294 na.rsize = sna.rsize;
295 na.timeo = sna.timeo;
296 na.retrans = sna.retrans;
297 na.hostname = sna.hostname;
298
299 if (error = copyout(&sa, na.addr, sizeof sa))
300 return (error);
301 if (error = copyout(&na, uap->data, sizeof na))
302 return (error);
303 }
304 return (mount(td, uap));
305 #else
306 return EINVAL;
307 #endif
308 }
309
310 /*
311 * Read iBCS2-style directory entries. We suck them into kernel space so
312 * that they can be massaged before being copied out to user code. Like
313 * SunOS, we squish out `empty' entries.
314 *
315 * This is quite ugly, but what do you expect from compatibility code?
316 */
317
318 int
319 ibcs2_getdents(td, uap)
320 struct thread *td;
321 register struct ibcs2_getdents_args *uap;
322 {
323 register struct vnode *vp;
324 register caddr_t inp, buf; /* BSD-format */
325 register int len, reclen; /* BSD-format */
326 register caddr_t outp; /* iBCS2-format */
327 register int resid; /* iBCS2-format */
328 struct file *fp;
329 struct uio auio;
330 struct iovec aiov;
331 struct ibcs2_dirent idb;
332 off_t off; /* true file offset */
333 int buflen, error, eofflag, vfslocked;
334 u_long *cookies = NULL, *cookiep;
335 int ncookies;
336 #define BSD_DIRENT(cp) ((struct dirent *)(cp))
337 #define IBCS2_RECLEN(reclen) (reclen + sizeof(u_short))
338
339 if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
340 return (error);
341 if ((fp->f_flag & FREAD) == 0) {
342 fdrop(fp, td);
343 return (EBADF);
344 }
345 vp = fp->f_vnode;
346 vfslocked = VFS_LOCK_GIANT(vp->v_mount);
347 if (vp->v_type != VDIR) { /* XXX vnode readdir op should do this */
348 VFS_UNLOCK_GIANT(vfslocked);
349 fdrop(fp, td);
350 return (EINVAL);
351 }
352
353 off = fp->f_offset;
354 #define DIRBLKSIZ 512 /* XXX we used to use ufs's DIRBLKSIZ */
355 buflen = max(DIRBLKSIZ, uap->nbytes);
356 buflen = min(buflen, MAXBSIZE);
357 buf = malloc(buflen, M_TEMP, M_WAITOK);
358 vn_lock(vp, LK_SHARED | LK_RETRY);
359 again:
360 aiov.iov_base = buf;
361 aiov.iov_len = buflen;
362 auio.uio_iov = &aiov;
363 auio.uio_iovcnt = 1;
364 auio.uio_rw = UIO_READ;
365 auio.uio_segflg = UIO_SYSSPACE;
366 auio.uio_td = td;
367 auio.uio_resid = buflen;
368 auio.uio_offset = off;
369
370 if (cookies) {
371 free(cookies, M_TEMP);
372 cookies = NULL;
373 }
374
375 #ifdef MAC
376 error = mac_vnode_check_readdir(td->td_ucred, vp);
377 if (error)
378 goto out;
379 #endif
380
381 /*
382 * First we read into the malloc'ed buffer, then
383 * we massage it into user space, one record at a time.
384 */
385 if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies)) != 0)
386 goto out;
387 inp = buf;
388 outp = uap->buf;
389 resid = uap->nbytes;
390 if ((len = buflen - auio.uio_resid) <= 0)
391 goto eof;
392
393 cookiep = cookies;
394
395 if (cookies) {
396 /*
397 * When using cookies, the vfs has the option of reading from
398 * a different offset than that supplied (UFS truncates the
399 * offset to a block boundary to make sure that it never reads
400 * partway through a directory entry, even if the directory
401 * has been compacted).
402 */
403 while (len > 0 && ncookies > 0 && *cookiep <= off) {
404 len -= BSD_DIRENT(inp)->d_reclen;
405 inp += BSD_DIRENT(inp)->d_reclen;
406 cookiep++;
407 ncookies--;
408 }
409 }
410
411 for (; len > 0; len -= reclen) {
412 if (cookiep && ncookies == 0)
413 break;
414 reclen = BSD_DIRENT(inp)->d_reclen;
415 if (reclen & 3) {
416 printf("ibcs2_getdents: reclen=%d\n", reclen);
417 error = EFAULT;
418 goto out;
419 }
420 if (BSD_DIRENT(inp)->d_fileno == 0) {
421 inp += reclen; /* it is a hole; squish it out */
422 if (cookiep) {
423 off = *cookiep++;
424 ncookies--;
425 } else
426 off += reclen;
427 continue;
428 }
429 if (reclen > len || resid < IBCS2_RECLEN(reclen)) {
430 /* entry too big for buffer, so just stop */
431 outp++;
432 break;
433 }
434 /*
435 * Massage in place to make an iBCS2-shaped dirent (otherwise
436 * we have to worry about touching user memory outside of
437 * the copyout() call).
438 */
439 idb.d_ino = (ibcs2_ino_t)BSD_DIRENT(inp)->d_fileno;
440 idb.d_off = (ibcs2_off_t)off;
441 idb.d_reclen = (u_short)IBCS2_RECLEN(reclen);
442 if ((error = copyout((caddr_t)&idb, outp, 10)) != 0 ||
443 (error = copyout(BSD_DIRENT(inp)->d_name, outp + 10,
444 BSD_DIRENT(inp)->d_namlen + 1)) != 0)
445 goto out;
446 /* advance past this real entry */
447 if (cookiep) {
448 off = *cookiep++;
449 ncookies--;
450 } else
451 off += reclen;
452 inp += reclen;
453 /* advance output past iBCS2-shaped entry */
454 outp += IBCS2_RECLEN(reclen);
455 resid -= IBCS2_RECLEN(reclen);
456 }
457 /* if we squished out the whole block, try again */
458 if (outp == uap->buf)
459 goto again;
460 fp->f_offset = off; /* update the vnode offset */
461 eof:
462 td->td_retval[0] = uap->nbytes - resid;
463 out:
464 VOP_UNLOCK(vp, 0);
465 VFS_UNLOCK_GIANT(vfslocked);
466 fdrop(fp, td);
467 if (cookies)
468 free(cookies, M_TEMP);
469 free(buf, M_TEMP);
470 return (error);
471 }
472
473 int
474 ibcs2_read(td, uap)
475 struct thread *td;
476 struct ibcs2_read_args *uap;
477 {
478 register struct vnode *vp;
479 register caddr_t inp, buf; /* BSD-format */
480 register int len, reclen; /* BSD-format */
481 register caddr_t outp; /* iBCS2-format */
482 register int resid; /* iBCS2-format */
483 struct file *fp;
484 struct uio auio;
485 struct iovec aiov;
486 struct ibcs2_direct {
487 ibcs2_ino_t ino;
488 char name[14];
489 } idb;
490 off_t off; /* true file offset */
491 int buflen, error, eofflag, size, vfslocked;
492 u_long *cookies = NULL, *cookiep;
493 int ncookies;
494
495 if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0) {
496 if (error == EINVAL)
497 return read(td, (struct read_args *)uap);
498 else
499 return error;
500 }
501 if ((fp->f_flag & FREAD) == 0) {
502 fdrop(fp, td);
503 return (EBADF);
504 }
505 vp = fp->f_vnode;
506 vfslocked = VFS_LOCK_GIANT(vp->v_mount);
507 if (vp->v_type != VDIR) {
508 VFS_UNLOCK_GIANT(vfslocked);
509 fdrop(fp, td);
510 return read(td, (struct read_args *)uap);
511 }
512
513 off = fp->f_offset;
514
515 DPRINTF(("ibcs2_read: read directory\n"));
516
517 buflen = max(DIRBLKSIZ, uap->nbytes);
518 buflen = min(buflen, MAXBSIZE);
519 buf = malloc(buflen, M_TEMP, M_WAITOK);
520 vn_lock(vp, LK_SHARED | LK_RETRY);
521 again:
522 aiov.iov_base = buf;
523 aiov.iov_len = buflen;
524 auio.uio_iov = &aiov;
525 auio.uio_iovcnt = 1;
526 auio.uio_rw = UIO_READ;
527 auio.uio_segflg = UIO_SYSSPACE;
528 auio.uio_td = td;
529 auio.uio_resid = buflen;
530 auio.uio_offset = off;
531
532 if (cookies) {
533 free(cookies, M_TEMP);
534 cookies = NULL;
535 }
536
537 #ifdef MAC
538 error = mac_vnode_check_readdir(td->td_ucred, vp);
539 if (error)
540 goto out;
541 #endif
542
543 /*
544 * First we read into the malloc'ed buffer, then
545 * we massage it into user space, one record at a time.
546 */
547 if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies)) != 0) {
548 DPRINTF(("VOP_READDIR failed: %d\n", error));
549 goto out;
550 }
551 inp = buf;
552 outp = uap->buf;
553 resid = uap->nbytes;
554 if ((len = buflen - auio.uio_resid) <= 0)
555 goto eof;
556
557 cookiep = cookies;
558
559 if (cookies) {
560 /*
561 * When using cookies, the vfs has the option of reading from
562 * a different offset than that supplied (UFS truncates the
563 * offset to a block boundary to make sure that it never reads
564 * partway through a directory entry, even if the directory
565 * has been compacted).
566 */
567 while (len > 0 && ncookies > 0 && *cookiep <= off) {
568 len -= BSD_DIRENT(inp)->d_reclen;
569 inp += BSD_DIRENT(inp)->d_reclen;
570 cookiep++;
571 ncookies--;
572 }
573 }
574
575 for (; len > 0 && resid > 0; len -= reclen) {
576 if (cookiep && ncookies == 0)
577 break;
578 reclen = BSD_DIRENT(inp)->d_reclen;
579 if (reclen & 3) {
580 printf("ibcs2_read: reclen=%d\n", reclen);
581 error = EFAULT;
582 goto out;
583 }
584 if (BSD_DIRENT(inp)->d_fileno == 0) {
585 inp += reclen; /* it is a hole; squish it out */
586 if (cookiep) {
587 off = *cookiep++;
588 ncookies--;
589 } else
590 off += reclen;
591 continue;
592 }
593 if (reclen > len || resid < sizeof(struct ibcs2_direct)) {
594 /* entry too big for buffer, so just stop */
595 outp++;
596 break;
597 }
598 /*
599 * Massage in place to make an iBCS2-shaped dirent (otherwise
600 * we have to worry about touching user memory outside of
601 * the copyout() call).
602 *
603 * TODO: if length(filename) > 14, then break filename into
604 * multiple entries and set inode = 0xffff except last
605 */
606 idb.ino = (BSD_DIRENT(inp)->d_fileno > 0xfffe) ? 0xfffe :
607 BSD_DIRENT(inp)->d_fileno;
608 (void)copystr(BSD_DIRENT(inp)->d_name, idb.name, 14, &size);
609 bzero(idb.name + size, 14 - size);
610 if ((error = copyout(&idb, outp, sizeof(struct ibcs2_direct))) != 0)
611 goto out;
612 /* advance past this real entry */
613 if (cookiep) {
614 off = *cookiep++;
615 ncookies--;
616 } else
617 off += reclen;
618 inp += reclen;
619 /* advance output past iBCS2-shaped entry */
620 outp += sizeof(struct ibcs2_direct);
621 resid -= sizeof(struct ibcs2_direct);
622 }
623 /* if we squished out the whole block, try again */
624 if (outp == uap->buf)
625 goto again;
626 fp->f_offset = off; /* update the vnode offset */
627 eof:
628 td->td_retval[0] = uap->nbytes - resid;
629 out:
630 VOP_UNLOCK(vp, 0);
631 VFS_UNLOCK_GIANT(vfslocked);
632 fdrop(fp, td);
633 if (cookies)
634 free(cookies, M_TEMP);
635 free(buf, M_TEMP);
636 return (error);
637 }
638
639 int
640 ibcs2_mknod(td, uap)
641 struct thread *td;
642 struct ibcs2_mknod_args *uap;
643 {
644 char *path;
645 int error;
646
647 CHECKALTCREAT(td, uap->path, &path);
648 if (S_ISFIFO(uap->mode))
649 error = kern_mkfifo(td, path, UIO_SYSSPACE, uap->mode);
650 else
651 error = kern_mknod(td, path, UIO_SYSSPACE, uap->mode, uap->dev);
652 free(path, M_TEMP);
653 return (error);
654 }
655
656 int
657 ibcs2_getgroups(td, uap)
658 struct thread *td;
659 struct ibcs2_getgroups_args *uap;
660 {
661 ibcs2_gid_t *iset;
662 gid_t *gp;
663 u_int i, ngrp;
664 int error;
665
666 if (uap->gidsetsize < 0)
667 return (EINVAL);
668 ngrp = MIN(uap->gidsetsize, NGROUPS);
669 gp = malloc(ngrp * sizeof(*gp), M_TEMP, M_WAITOK);
670 error = kern_getgroups(td, &ngrp, gp);
671 if (error)
672 goto out;
673 if (uap->gidsetsize > 0) {
674 iset = malloc(ngrp * sizeof(*iset), M_TEMP, M_WAITOK);
675 for (i = 0; i < ngrp; i++)
676 iset[i] = (ibcs2_gid_t)gp[i];
677 error = copyout(iset, uap->gidset, ngrp * sizeof(ibcs2_gid_t));
678 free(iset, M_TEMP);
679 }
680 if (error == 0)
681 td->td_retval[0] = ngrp;
682 out:
683 free(gp, M_TEMP);
684 return (error);
685 }
686
687 int
688 ibcs2_setgroups(td, uap)
689 struct thread *td;
690 struct ibcs2_setgroups_args *uap;
691 {
692 ibcs2_gid_t *iset;
693 gid_t *gp;
694 int error, i;
695
696 if (uap->gidsetsize < 0 || uap->gidsetsize > NGROUPS)
697 return (EINVAL);
698 if (uap->gidsetsize && uap->gidset == NULL)
699 return (EINVAL);
700 gp = malloc(uap->gidsetsize * sizeof(*gp), M_TEMP, M_WAITOK);
701 if (uap->gidsetsize) {
702 iset = malloc(uap->gidsetsize * sizeof(*iset), M_TEMP, M_WAITOK);
703 error = copyin(uap->gidset, iset, sizeof(ibcs2_gid_t) *
704 uap->gidsetsize);
705 if (error) {
706 free(iset, M_TEMP);
707 goto out;
708 }
709 for (i = 0; i < uap->gidsetsize; i++)
710 gp[i] = (gid_t)iset[i];
711 }
712
713 error = kern_setgroups(td, uap->gidsetsize, gp);
714 out:
715 free(gp, M_TEMP);
716 return (error);
717 }
718
719 int
720 ibcs2_setuid(td, uap)
721 struct thread *td;
722 struct ibcs2_setuid_args *uap;
723 {
724 struct setuid_args sa;
725
726 sa.uid = (uid_t)uap->uid;
727 return setuid(td, &sa);
728 }
729
730 int
731 ibcs2_setgid(td, uap)
732 struct thread *td;
733 struct ibcs2_setgid_args *uap;
734 {
735 struct setgid_args sa;
736
737 sa.gid = (gid_t)uap->gid;
738 return setgid(td, &sa);
739 }
740
741 int
742 ibcs2_time(td, uap)
743 struct thread *td;
744 struct ibcs2_time_args *uap;
745 {
746 struct timeval tv;
747
748 microtime(&tv);
749 td->td_retval[0] = tv.tv_sec;
750 if (uap->tp)
751 return copyout((caddr_t)&tv.tv_sec, (caddr_t)uap->tp,
752 sizeof(ibcs2_time_t));
753 else
754 return 0;
755 }
756
757 int
758 ibcs2_pathconf(td, uap)
759 struct thread *td;
760 struct ibcs2_pathconf_args *uap;
761 {
762 char *path;
763 int error;
764
765 CHECKALTEXIST(td, uap->path, &path);
766 uap->name++; /* iBCS2 _PC_* defines are offset by one */
767 error = kern_pathconf(td, path, UIO_SYSSPACE, uap->name, FOLLOW);
768 free(path, M_TEMP);
769 return (error);
770 }
771
772 int
773 ibcs2_fpathconf(td, uap)
774 struct thread *td;
775 struct ibcs2_fpathconf_args *uap;
776 {
777 uap->name++; /* iBCS2 _PC_* defines are offset by one */
778 return fpathconf(td, (struct fpathconf_args *)uap);
779 }
780
781 int
782 ibcs2_sysconf(td, uap)
783 struct thread *td;
784 struct ibcs2_sysconf_args *uap;
785 {
786 int mib[2], value, len, error;
787 struct proc *p;
788
789 p = td->td_proc;
790 switch(uap->name) {
791 case IBCS2_SC_ARG_MAX:
792 mib[1] = KERN_ARGMAX;
793 break;
794
795 case IBCS2_SC_CHILD_MAX:
796 PROC_LOCK(p);
797 td->td_retval[0] = lim_cur(td->td_proc, RLIMIT_NPROC);
798 PROC_UNLOCK(p);
799 return 0;
800
801 case IBCS2_SC_CLK_TCK:
802 td->td_retval[0] = hz;
803 return 0;
804
805 case IBCS2_SC_NGROUPS_MAX:
806 mib[1] = KERN_NGROUPS;
807 break;
808
809 case IBCS2_SC_OPEN_MAX:
810 PROC_LOCK(p);
811 td->td_retval[0] = lim_cur(td->td_proc, RLIMIT_NOFILE);
812 PROC_UNLOCK(p);
813 return 0;
814
815 case IBCS2_SC_JOB_CONTROL:
816 mib[1] = KERN_JOB_CONTROL;
817 break;
818
819 case IBCS2_SC_SAVED_IDS:
820 mib[1] = KERN_SAVED_IDS;
821 break;
822
823 case IBCS2_SC_VERSION:
824 mib[1] = KERN_POSIX1;
825 break;
826
827 case IBCS2_SC_PASS_MAX:
828 td->td_retval[0] = 128; /* XXX - should we create PASS_MAX ? */
829 return 0;
830
831 case IBCS2_SC_XOPEN_VERSION:
832 td->td_retval[0] = 2; /* XXX: What should that be? */
833 return 0;
834
835 default:
836 return EINVAL;
837 }
838
839 mib[0] = CTL_KERN;
840 len = sizeof(value);
841 error = kernel_sysctl(td, mib, 2, &value, &len, NULL, 0, NULL, 0);
842 if (error)
843 return error;
844 td->td_retval[0] = value;
845 return 0;
846 }
847
848 int
849 ibcs2_alarm(td, uap)
850 struct thread *td;
851 struct ibcs2_alarm_args *uap;
852 {
853 struct itimerval itv, oitv;
854 int error;
855
856 timevalclear(&itv.it_interval);
857 itv.it_value.tv_sec = uap->sec;
858 itv.it_value.tv_usec = 0;
859 error = kern_setitimer(td, ITIMER_REAL, &itv, &oitv);
860 if (error)
861 return (error);
862 if (oitv.it_value.tv_usec != 0)
863 oitv.it_value.tv_sec++;
864 td->td_retval[0] = oitv.it_value.tv_sec;
865 return (0);
866 }
867
868 int
869 ibcs2_times(td, uap)
870 struct thread *td;
871 struct ibcs2_times_args *uap;
872 {
873 struct rusage ru;
874 struct timeval t;
875 struct tms tms;
876 int error;
877
878 #define CONVTCK(r) (r.tv_sec * hz + r.tv_usec / (1000000 / hz))
879
880 error = kern_getrusage(td, RUSAGE_SELF, &ru);
881 if (error)
882 return (error);
883 tms.tms_utime = CONVTCK(ru.ru_utime);
884 tms.tms_stime = CONVTCK(ru.ru_stime);
885
886 error = kern_getrusage(td, RUSAGE_CHILDREN, &ru);
887 if (error)
888 return (error);
889 tms.tms_cutime = CONVTCK(ru.ru_utime);
890 tms.tms_cstime = CONVTCK(ru.ru_stime);
891
892 microtime(&t);
893 td->td_retval[0] = CONVTCK(t);
894
895 return (copyout(&tms, uap->tp, sizeof(struct tms)));
896 }
897
898 int
899 ibcs2_stime(td, uap)
900 struct thread *td;
901 struct ibcs2_stime_args *uap;
902 {
903 struct timeval tv;
904 long secs;
905 int error;
906
907 error = copyin(uap->timep, &secs, sizeof(long));
908 if (error)
909 return (error);
910 tv.tv_sec = secs;
911 tv.tv_usec = 0;
912 error = kern_settimeofday(td, &tv, NULL);
913 if (error)
914 error = EPERM;
915 return (error);
916 }
917
918 int
919 ibcs2_utime(td, uap)
920 struct thread *td;
921 struct ibcs2_utime_args *uap;
922 {
923 struct ibcs2_utimbuf ubuf;
924 struct timeval tbuf[2], *tp;
925 char *path;
926 int error;
927
928 if (uap->buf) {
929 error = copyin(uap->buf, &ubuf, sizeof(ubuf));
930 if (error)
931 return (error);
932 tbuf[0].tv_sec = ubuf.actime;
933 tbuf[0].tv_usec = 0;
934 tbuf[1].tv_sec = ubuf.modtime;
935 tbuf[1].tv_usec = 0;
936 tp = tbuf;
937 } else
938 tp = NULL;
939
940 CHECKALTEXIST(td, uap->path, &path);
941 error = kern_utimes(td, path, UIO_SYSSPACE, tp, UIO_SYSSPACE);
942 free(path, M_TEMP);
943 return (error);
944 }
945
946 int
947 ibcs2_nice(td, uap)
948 struct thread *td;
949 struct ibcs2_nice_args *uap;
950 {
951 int error;
952 struct setpriority_args sa;
953
954 sa.which = PRIO_PROCESS;
955 sa.who = 0;
956 sa.prio = td->td_proc->p_nice + uap->incr;
957 if ((error = setpriority(td, &sa)) != 0)
958 return EPERM;
959 td->td_retval[0] = td->td_proc->p_nice;
960 return 0;
961 }
962
963 /*
964 * iBCS2 getpgrp, setpgrp, setsid, and setpgid
965 */
966
967 int
968 ibcs2_pgrpsys(td, uap)
969 struct thread *td;
970 struct ibcs2_pgrpsys_args *uap;
971 {
972 struct proc *p = td->td_proc;
973 switch (uap->type) {
974 case 0: /* getpgrp */
975 PROC_LOCK(p);
976 td->td_retval[0] = p->p_pgrp->pg_id;
977 PROC_UNLOCK(p);
978 return 0;
979
980 case 1: /* setpgrp */
981 {
982 struct setpgid_args sa;
983
984 sa.pid = 0;
985 sa.pgid = 0;
986 setpgid(td, &sa);
987 PROC_LOCK(p);
988 td->td_retval[0] = p->p_pgrp->pg_id;
989 PROC_UNLOCK(p);
990 return 0;
991 }
992
993 case 2: /* setpgid */
994 {
995 struct setpgid_args sa;
996
997 sa.pid = uap->pid;
998 sa.pgid = uap->pgid;
999 return setpgid(td, &sa);
1000 }
1001
1002 case 3: /* setsid */
1003 return setsid(td, NULL);
1004
1005 default:
1006 return EINVAL;
1007 }
1008 }
1009
1010 /*
1011 * XXX - need to check for nested calls
1012 */
1013
1014 int
1015 ibcs2_plock(td, uap)
1016 struct thread *td;
1017 struct ibcs2_plock_args *uap;
1018 {
1019 int error;
1020 #define IBCS2_UNLOCK 0
1021 #define IBCS2_PROCLOCK 1
1022 #define IBCS2_TEXTLOCK 2
1023 #define IBCS2_DATALOCK 4
1024
1025
1026 switch(uap->cmd) {
1027 case IBCS2_UNLOCK:
1028 error = priv_check(td, PRIV_VM_MUNLOCK);
1029 if (error)
1030 return (error);
1031 /* XXX - TODO */
1032 return (0);
1033
1034 case IBCS2_PROCLOCK:
1035 case IBCS2_TEXTLOCK:
1036 case IBCS2_DATALOCK:
1037 error = priv_check(td, PRIV_VM_MLOCK);
1038 if (error)
1039 return (error);
1040 /* XXX - TODO */
1041 return 0;
1042 }
1043 return EINVAL;
1044 }
1045
1046 int
1047 ibcs2_uadmin(td, uap)
1048 struct thread *td;
1049 struct ibcs2_uadmin_args *uap;
1050 {
1051 #define SCO_A_REBOOT 1
1052 #define SCO_A_SHUTDOWN 2
1053 #define SCO_A_REMOUNT 4
1054 #define SCO_A_CLOCK 8
1055 #define SCO_A_SETCONFIG 128
1056 #define SCO_A_GETDEV 130
1057
1058 #define SCO_AD_HALT 0
1059 #define SCO_AD_BOOT 1
1060 #define SCO_AD_IBOOT 2
1061 #define SCO_AD_PWRDOWN 3
1062 #define SCO_AD_PWRNAP 4
1063
1064 #define SCO_AD_PANICBOOT 1
1065
1066 #define SCO_AD_GETBMAJ 0
1067 #define SCO_AD_GETCMAJ 1
1068
1069 switch(uap->cmd) {
1070 case SCO_A_REBOOT:
1071 case SCO_A_SHUTDOWN:
1072 switch(uap->func) {
1073 struct reboot_args r;
1074 case SCO_AD_HALT:
1075 case SCO_AD_PWRDOWN:
1076 case SCO_AD_PWRNAP:
1077 r.opt = RB_HALT;
1078 return (reboot(td, &r));
1079 case SCO_AD_BOOT:
1080 case SCO_AD_IBOOT:
1081 r.opt = RB_AUTOBOOT;
1082 return (reboot(td, &r));
1083 }
1084 return EINVAL;
1085 case SCO_A_REMOUNT:
1086 case SCO_A_CLOCK:
1087 case SCO_A_SETCONFIG:
1088 return 0;
1089 case SCO_A_GETDEV:
1090 return EINVAL; /* XXX - TODO */
1091 }
1092 return EINVAL;
1093 }
1094
1095 int
1096 ibcs2_sysfs(td, uap)
1097 struct thread *td;
1098 struct ibcs2_sysfs_args *uap;
1099 {
1100 #define IBCS2_GETFSIND 1
1101 #define IBCS2_GETFSTYP 2
1102 #define IBCS2_GETNFSTYP 3
1103
1104 switch(uap->cmd) {
1105 case IBCS2_GETFSIND:
1106 case IBCS2_GETFSTYP:
1107 case IBCS2_GETNFSTYP:
1108 break;
1109 }
1110 return EINVAL; /* XXX - TODO */
1111 }
1112
1113 int
1114 ibcs2_unlink(td, uap)
1115 struct thread *td;
1116 struct ibcs2_unlink_args *uap;
1117 {
1118 char *path;
1119 int error;
1120
1121 CHECKALTEXIST(td, uap->path, &path);
1122 error = kern_unlink(td, path, UIO_SYSSPACE);
1123 free(path, M_TEMP);
1124 return (error);
1125 }
1126
1127 int
1128 ibcs2_chdir(td, uap)
1129 struct thread *td;
1130 struct ibcs2_chdir_args *uap;
1131 {
1132 char *path;
1133 int error;
1134
1135 CHECKALTEXIST(td, uap->path, &path);
1136 error = kern_chdir(td, path, UIO_SYSSPACE);
1137 free(path, M_TEMP);
1138 return (error);
1139 }
1140
1141 int
1142 ibcs2_chmod(td, uap)
1143 struct thread *td;
1144 struct ibcs2_chmod_args *uap;
1145 {
1146 char *path;
1147 int error;
1148
1149 CHECKALTEXIST(td, uap->path, &path);
1150 error = kern_chmod(td, path, UIO_SYSSPACE, uap->mode);
1151 free(path, M_TEMP);
1152 return (error);
1153 }
1154
1155 int
1156 ibcs2_chown(td, uap)
1157 struct thread *td;
1158 struct ibcs2_chown_args *uap;
1159 {
1160 char *path;
1161 int error;
1162
1163 CHECKALTEXIST(td, uap->path, &path);
1164 error = kern_chown(td, path, UIO_SYSSPACE, uap->uid, uap->gid);
1165 free(path, M_TEMP);
1166 return (error);
1167 }
1168
1169 int
1170 ibcs2_rmdir(td, uap)
1171 struct thread *td;
1172 struct ibcs2_rmdir_args *uap;
1173 {
1174 char *path;
1175 int error;
1176
1177 CHECKALTEXIST(td, uap->path, &path);
1178 error = kern_rmdir(td, path, UIO_SYSSPACE);
1179 free(path, M_TEMP);
1180 return (error);
1181 }
1182
1183 int
1184 ibcs2_mkdir(td, uap)
1185 struct thread *td;
1186 struct ibcs2_mkdir_args *uap;
1187 {
1188 char *path;
1189 int error;
1190
1191 CHECKALTEXIST(td, uap->path, &path);
1192 error = kern_mkdir(td, path, UIO_SYSSPACE, uap->mode);
1193 free(path, M_TEMP);
1194 return (error);
1195 }
1196
1197 int
1198 ibcs2_symlink(td, uap)
1199 struct thread *td;
1200 struct ibcs2_symlink_args *uap;
1201 {
1202 char *path, *link;
1203 int error;
1204
1205 CHECKALTEXIST(td, uap->path, &path);
1206
1207 /*
1208 * Have to expand CHECKALTCREAT() so that 'path' can be freed on
1209 * errors.
1210 */
1211 error = ibcs2_emul_find(td, uap->link, UIO_USERSPACE, &link, 1);
1212 if (link == NULL) {
1213 free(path, M_TEMP);
1214 return (error);
1215 }
1216 error = kern_symlink(td, path, link, UIO_SYSSPACE);
1217 free(path, M_TEMP);
1218 free(link, M_TEMP);
1219 return (error);
1220 }
1221
1222 int
1223 ibcs2_rename(td, uap)
1224 struct thread *td;
1225 struct ibcs2_rename_args *uap;
1226 {
1227 char *from, *to;
1228 int error;
1229
1230 CHECKALTEXIST(td, uap->from, &from);
1231
1232 /*
1233 * Have to expand CHECKALTCREAT() so that 'from' can be freed on
1234 * errors.
1235 */
1236 error = ibcs2_emul_find(td, uap->to, UIO_USERSPACE, &to, 1);
1237 if (to == NULL) {
1238 free(from, M_TEMP);
1239 return (error);
1240 }
1241 error = kern_rename(td, from, to, UIO_SYSSPACE);
1242 free(from, M_TEMP);
1243 free(to, M_TEMP);
1244 return (error);
1245 }
1246
1247 int
1248 ibcs2_readlink(td, uap)
1249 struct thread *td;
1250 struct ibcs2_readlink_args *uap;
1251 {
1252 char *path;
1253 int error;
1254
1255 CHECKALTEXIST(td, uap->path, &path);
1256 error = kern_readlink(td, path, UIO_SYSSPACE, uap->buf, UIO_USERSPACE,
1257 uap->count);
1258 free(path, M_TEMP);
1259 return (error);
1260 }
Cache object: a882e8c27c8e4d77f1ed3da3b847feec
|