![[BACK]](/icons/back.gif){kind=icon}
Return to hpux_file.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / hpux|
Return to hpux_file.c CVS log | Up to [local] / sys / compat / hpux |
1.1 nbrk 1: /* $OpenBSD: hpux_file.c,v 1.18 2007/03/15 10:22:30 art Exp $ */
2: /* $NetBSD: hpux_file.c,v 1.5 1997/04/27 21:40:48 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1995, 1997 Jason R. Thorpe. All rights reserved.
6: * Copyright (c) 1988 University of Utah.
7: * Copyright (c) 1990, 1993
8: * The Regents of the University of California. All rights reserved.
9: *
10: * This code is derived from software contributed to Berkeley by
11: * the Systems Programming Group of the University of Utah Computer
12: * Science Department.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * from: Utah $Hdr: hpux_compat.c 1.64 93/08/05$
39: *
40: * @(#)hpux_compat.c 8.4 (Berkeley) 2/13/94
41: */
42:
43: /*
44: * File-related routines for HP-UX binary compatibility. Partially
45: * modeled after sys/compat/linux/linux_file.c
46: */
47:
48: #include <sys/param.h>
49: #include <sys/systm.h>
50: #include <sys/signalvar.h>
51: #include <sys/kernel.h>
52: #include <sys/filedesc.h>
53: #include <sys/proc.h>
54: #include <sys/buf.h>
55: #include <sys/wait.h>
56: #include <sys/file.h>
57: #include <sys/namei.h>
58: #include <sys/vnode.h>
59: #include <sys/ioctl.h>
60: #include <sys/ptrace.h>
61: #include <sys/stat.h>
62: #include <sys/syslog.h>
63: #include <sys/malloc.h>
64: #include <sys/mount.h>
65: #include <sys/ipc.h>
66: #include <sys/user.h>
67: #include <sys/mman.h>
68:
69: #include <machine/cpu.h>
70: #include <machine/reg.h>
71: #include <machine/psl.h>
72: #include <machine/vmparam.h>
73:
74: #include <sys/syscallargs.h>
75:
76: #include <compat/hpux/hpux.h>
77: #include <compat/hpux/hpux_util.h>
78: #include <compat/hpux/hpux_termio.h>
79: #include <compat/hpux/hpux_syscall.h>
80: #include <compat/hpux/hpux_syscallargs.h>
81:
82: #include <machine/hpux_machdep.h>
83:
84: int hpux_stat1(struct proc *, void *, register_t *, int);
85: void bsd_to_hpux_stat(struct stat *, struct hpux_stat *);
86: void bsd_to_hpux_ostat(struct stat *, struct hpux_ostat *);
87:
88: /*
89: * HP-UX creat(2) system call.
90: *
91: * Just call open(2) with the TRUNC, CREAT and WRONLY flags.
92: */
93: int
94: hpux_sys_creat(p, v, retval)
95: struct proc *p;
96: void *v;
97: register_t *retval;
98: {
99: struct hpux_sys_creat_args /* {
100: syscallarg(char *) path;
101: syscallarg(int) mode;
102: } */ *uap = v;
103:
104: struct sys_open_args oa;
105: caddr_t sg;
106:
107: sg = stackgap_init(p->p_emul);
108: HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
109:
110: SCARG(&oa, path) = SCARG(uap, path);
111: SCARG(&oa, flags) = O_CREAT | O_TRUNC | O_WRONLY;
112: SCARG(&oa, mode) = SCARG(uap, mode);
113:
114: return sys_open(p, &oa, retval);
115: }
116:
117: /*
118: * HP-UX open(2) system call.
119: *
120: * We need to remap some of the bits in the mode mask:
121: *
122: * - O_CREAT, O_TRUNC, and O_EXCL must me remapped.
123: * - O_NONBLOCK is remapped and remembered.
124: * - O_FNDELAY is remembered.
125: * - O_SYNCIO is removed entirely.
126: */
127: int
128: hpux_sys_open(p, v, retval)
129: struct proc *p;
130: void *v;
131: register_t *retval;
132: {
133: struct hpux_sys_open_args /* {
134: syscallarg(char *) path;
135: syscallarg(int) flags;
136: syscallarg(int) mode;
137: } */ *uap = v;
138: struct sys_open_args oa;
139: int flags, nflags, error;
140: caddr_t sg;
141:
142: sg = stackgap_init(p->p_emul);
143:
144: /*
145: * Deal with the mode flags first, since they will affect
146: * how we check for the alternate path.
147: */
148: flags = SCARG(uap, flags);
149: nflags =
150: flags & ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT);
151: if (flags & HPUXFCREAT) {
152: /*
153: * Simulate the pre-NFS behavior that opening a
154: * file for READ+CREATE ignores the CREATE (unless
155: * EXCL is set in which case we will return the
156: * proper error).
157: */
158: if ((flags & HPUXFEXCL) || (FFLAGS(flags) & FWRITE))
159: nflags |= O_CREAT;
160: }
161: if (flags & HPUXFTRUNC)
162: nflags |= O_TRUNC;
163: if (flags & HPUXFEXCL)
164: nflags |= O_EXCL;
165: if (flags & HPUXNONBLOCK)
166: nflags |= O_NDELAY;
167:
168: /*
169: * Do the alternate pathname check.
170: */
171: if (SCARG(&oa, flags) & O_CREAT)
172: HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
173: else
174: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
175:
176: /*
177: * Fill in the new arguments and call the NetBSD open(2).
178: */
179: SCARG(&oa, path) = SCARG(uap, path);
180: SCARG(&oa, flags) = nflags;
181: SCARG(&oa, mode) = SCARG(uap, mode);
182:
183: error = sys_open(p, &oa, retval);
184:
185: /*
186: * Record non-blocking mode for fcntl, read, write, etc.
187: */
188: if ((error == 0) && (nflags & O_NDELAY))
189: p->p_fd->fd_ofileflags[*retval] |=
190: (flags & HPUXNONBLOCK) ?
191: HPUX_UF_NONBLOCK_ON : HPUX_UF_FNDELAY_ON;
192:
193: return (error);
194: }
195:
196: /*
197: * HP-UX fcntl(2) system call.
198: */
199: int
200: hpux_sys_fcntl(p, v, retval)
201: struct proc *p;
202: void *v;
203: register_t *retval;
204: {
205: struct hpux_sys_fcntl_args /* {
206: syscallarg(int) fd;
207: syscallarg(int) cmd;
208: syscallarg(int) arg;
209: } */ *uap = v;
210: int arg, mode, error, flg = F_POSIX;
211: struct file *fp;
212: char *pop;
213: struct hpux_flock hfl;
214: struct flock fl;
215: struct vnode *vp;
216: struct sys_fcntl_args fa;
217: struct filedesc *fdp = p->p_fd;
218:
219: if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
220: return (EBADF);
221: FREF(fp);
222:
223: pop = &p->p_fd->fd_ofileflags[SCARG(uap, fd)];
224: arg = SCARG(uap, arg);
225:
226: switch (SCARG(uap, cmd)) {
227: case F_SETFL:
228: if (arg & HPUXNONBLOCK)
229: *pop |= HPUX_UF_NONBLOCK_ON;
230: else
231: *pop &= ~HPUX_UF_NONBLOCK_ON;
232:
233: if (arg & HPUXNDELAY)
234: *pop |= HPUX_UF_FNDELAY_ON;
235: else
236: *pop &= ~HPUX_UF_FNDELAY_ON;
237:
238: if (*pop & (HPUX_UF_NONBLOCK_ON|HPUX_UF_FNDELAY_ON|HPUX_UF_FIONBIO_ON))
239: arg |= FNONBLOCK;
240: else
241: arg &= ~FNONBLOCK;
242:
243: arg &= ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFREMOTE);
244: break;
245:
246: case F_GETFL:
247: case F_DUPFD:
248: case F_GETFD:
249: case F_SETFD:
250: break;
251:
252: case HPUXF_SETLKW:
253: flg |= F_WAIT;
254: /* Fall into F_SETLK */
255:
256: case HPUXF_SETLK:
257: if (fp->f_type != DTYPE_VNODE) {
258: error = EBADF;
259: goto out;
260: }
261:
262: vp = (struct vnode *)fp->f_data;
263:
264: /* Copy in the lock structure */
265: error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&hfl,
266: sizeof (hfl));
267: if (error)
268: goto out;
269:
270: fl.l_start = hfl.hl_start;
271: fl.l_len = hfl.hl_len;
272: fl.l_pid = hfl.hl_pid;
273: fl.l_type = hfl.hl_type;
274: fl.l_whence = hfl.hl_whence;
275: if (fl.l_whence == SEEK_CUR)
276: fl.l_start += fp->f_offset;
277:
278: switch (fl.l_type) {
279: case F_RDLCK:
280: if ((fp->f_flag & FREAD) == 0) {
281: error = EBADF;
282: goto out;
283: }
284:
285: atomic_setbits_int(&p->p_flag, P_ADVLOCK);
286: error = VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg);
287: goto out;
288:
289: case F_WRLCK:
290: if ((fp->f_flag & FWRITE) == 0) {
291: error = EBADF;
292: goto out;
293: }
294: atomic_setbits_int(&p->p_flag, P_ADVLOCK);
295: error = VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg);
296: goto out;
297:
298: case F_UNLCK:
299: error = VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
300: F_POSIX);
301: goto out;
302:
303: default:
304: error = EINVAL;
305: goto out;
306: }
307: /* NOTREACHED */
308:
309: case F_GETLK:
310: if (fp->f_type != DTYPE_VNODE) {
311: error = EBADF;
312: goto out;
313: }
314:
315: vp = (struct vnode *)fp->f_data;
316:
317: /* Copy in the lock structure */
318: error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&hfl,
319: sizeof (hfl));
320: if (error)
321: goto out;
322:
323: fl.l_start = hfl.hl_start;
324: fl.l_len = hfl.hl_len;
325: fl.l_pid = hfl.hl_pid;
326: fl.l_type = hfl.hl_type;
327: fl.l_whence = hfl.hl_whence;
328: if (fl.l_whence == SEEK_CUR)
329: fl.l_start += fp->f_offset;
330:
331: if ((error =
332: VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX)))
333: goto out;
334:
335: hfl.hl_start = fl.l_start;
336: hfl.hl_len = fl.l_len;
337: hfl.hl_pid = fl.l_pid;
338: hfl.hl_type = fl.l_type;
339: hfl.hl_whence = fl.l_whence;
340: error = copyout((caddr_t)&hfl, (caddr_t)SCARG(uap, arg),
341: sizeof (hfl));
342: goto out;
343:
344: default:
345: error = EINVAL;
346: goto out;
347: }
348:
349: /*
350: * Pass whatever's left on to the NetBSD fcntl(2).
351: */
352: SCARG(&fa, fd) = SCARG(uap, fd);
353: SCARG(&fa, cmd) = SCARG(uap, cmd);
354: SCARG(&fa, arg) = (void *)arg;
355:
356: error = sys_fcntl(p, &fa, retval);
357:
358: if ((error == 0) && (SCARG(&fa, cmd) == F_GETFL)) {
359: mode = *retval;
360: *retval &= ~(O_CREAT|O_TRUNC|O_EXCL);
361: if (mode & FNONBLOCK) {
362: if (*pop & HPUX_UF_NONBLOCK_ON)
363: *retval |= HPUXNONBLOCK;
364:
365: if ((*pop & HPUX_UF_FNDELAY_ON) == 0)
366: *retval &= ~HPUXNDELAY;
367: }
368: if (mode & O_CREAT)
369: *retval |= HPUXFCREAT;
370:
371: if (mode & O_TRUNC)
372: *retval |= HPUXFTRUNC;
373:
374: if (mode & O_EXCL)
375: *retval |= HPUXFEXCL;
376: }
377: out:
378: FRELE(fp);
379: return (error);
380: }
381:
382: /*
383: * HP-UX fstat(2) system call.
384: */
385: int
386: hpux_sys_fstat(p, v, retval)
387: struct proc *p;
388: void *v;
389: register_t *retval;
390: {
391: struct hpux_sys_fstat_args /* {
392: syscallarg(int) fd;
393: syscallarg(struct hpux_stat *) sb;
394: } */ *uap = v;
395: struct sys_fstat_args fsa;
396: struct hpux_stat tmphst;
397: struct stat *st, tmpst;
398: caddr_t sg;
399: int error;
400:
401: sg = stackgap_init(p->p_emul);
402:
403: st = stackgap_alloc(&sg, sizeof (struct stat));
404:
405: SCARG(&fsa, fd) = SCARG(uap, fd);
406: SCARG(&fsa, sb) = st;
407:
408: if ((error = sys_fstat(p, &fsa, retval)))
409: return (error);
410:
411: if ((error = copyin(st, &tmpst, sizeof(tmpst))))
412: return (error);
413:
414: bsd_to_hpux_stat(&tmpst, &tmphst);
415:
416: return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_stat)));
417: }
418:
419: /*
420: * HP-UX stat(2) system call.
421: */
422: int
423: hpux_sys_stat(p, v, retval)
424: struct proc *p;
425: void *v;
426: register_t *retval;
427: {
428:
429: return (hpux_stat1(p, v, retval, 0));
430: }
431:
432: /*
433: * HP-UX lstat(2) system call.
434: */
435: int
436: hpux_sys_lstat(p, v, retval)
437: struct proc *p;
438: void *v;
439: register_t *retval;
440: {
441:
442: return (hpux_stat1(p, v, retval, 1));
443: }
444:
445: /*
446: * Do the meat of stat(2) and lstat(2).
447: */
448: int
449: hpux_stat1(p, v, retval, dolstat)
450: struct proc *p;
451: void *v;
452: register_t *retval;
453: int dolstat;
454: {
455: struct hpux_sys_stat_args /* {
456: syscallarg(char *) path;
457: syscallarg(struct hpux_stat *) sb;
458: } */ *uap = v;
459: struct sys_stat_args sa;
460: struct hpux_stat tmphst;
461: struct stat *st, tmpst;
462: caddr_t sg;
463: int error;
464:
465: sg = stackgap_init(p->p_emul);
466:
467: st = stackgap_alloc(&sg, sizeof (struct stat));
468: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
469:
470: SCARG(&sa, ub) = st;
471: SCARG(&sa, path) = SCARG(uap, path);
472:
473: if (dolstat)
474: error = sys_lstat(p, &sa, retval);
475: else
476: error = sys_stat(p, &sa, retval);
477:
478: if (error)
479: return (error);
480:
481: if ((error = copyin(st, &tmpst, sizeof(tmpst))))
482: return (error);
483:
484: bsd_to_hpux_stat(&tmpst, &tmphst);
485:
486: return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_stat)));
487: }
488:
489: #ifndef __hppa__
490: /*
491: * The old HP-UX fstat(2) system call.
492: */
493: int
494: hpux_sys_fstat_6x(p, v, retval)
495: struct proc *p;
496: void *v;
497: register_t *retval;
498: {
499: struct hpux_sys_fstat_6x_args /* {
500: syscallarg(int) fd;
501: syscallarg(struct hpux_ostat *) sb;
502: } */ *uap = v;
503: struct sys_fstat_args fsa;
504: struct hpux_ostat tmphst;
505: struct stat *st, tmpst;
506: caddr_t sg;
507: int error;
508:
509: sg = stackgap_init(p->p_emul);
510:
511: st = stackgap_alloc(&sg, sizeof (struct stat));
512:
513: SCARG(&fsa, fd) = SCARG(uap, fd);
514: SCARG(&fsa, sb) = st;
515:
516: if ((error = sys_fstat(p, &fsa, retval)))
517: return (error);
518:
519: if ((error = copyin(st, &tmpst, sizeof(tmpst))))
520: return (error);
521:
522: bsd_to_hpux_ostat(&tmpst, &tmphst);
523:
524: return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_ostat)));
525: }
526:
527: /*
528: * The old HP-UX stat(2) system call.
529: */
530: int
531: hpux_sys_stat_6x(p, v, retval)
532: struct proc *p;
533: void *v;
534: register_t *retval;
535: {
536: struct hpux_sys_stat_6x_args /* {
537: syscallarg(char *) path;
538: syscallarg(struct hpux_ostat *) sb;
539: } */ *uap = v;
540: struct sys_stat_args sa;
541: struct hpux_ostat tmphst;
542: struct stat *st, tmpst;
543: caddr_t sg;
544: int error;
545:
546: sg = stackgap_init(p->p_emul);
547:
548: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
549:
550: st = stackgap_alloc(&sg, sizeof (struct stat));
551: SCARG(&sa, ub) = st;
552: SCARG(&sa, path) = SCARG(uap, path);
553:
554: if ((error = sys_stat(p, &sa, retval)))
555: return (error);
556:
557: if ((error = copyin(st, &tmpst, sizeof(tmpst))))
558: return (error);
559:
560: bsd_to_hpux_ostat(&tmpst, &tmphst);
561:
562: return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_ostat)));
563: }
564:
565: /*
566: * Convert a NetBSD stat structure to an old-style HP-UX stat structure.
567: */
568: void
569: bsd_to_hpux_ostat(sb, hsb)
570: struct stat *sb;
571: struct hpux_ostat *hsb;
572: {
573:
574: bzero(hsb, sizeof(struct hpux_ostat));
575: hsb->hst_dev = (u_short)sb->st_dev;
576: hsb->hst_ino = (u_short)sb->st_ino;
577: hsb->hst_mode = (u_short)sb->st_mode;
578: hsb->hst_nlink = (u_short)sb->st_nlink;
579: hsb->hst_uid = (u_short)sb->st_uid;
580: hsb->hst_gid = (u_short)sb->st_gid;
581: hsb->hst_rdev = (u_short)sb->st_rdev;
582: if (sb->st_size < (off_t)(((off_t)1) << 32))
583: hsb->hst_size = (int)sb->st_size;
584: else
585: hsb->hst_size = -2;
586: hsb->hst_atime = (int)sb->st_atime;
587: hsb->hst_mtime = (int)sb->st_mtime;
588: hsb->hst_ctime = (int)sb->st_ctime;
589: }
590: #endif
591:
592: /*
593: * Convert a NetBSD stat structure to an HP-UX stat structure.
594: */
595: void
596: bsd_to_hpux_stat(sb, hsb)
597: struct stat *sb;
598: struct hpux_stat *hsb;
599: {
600:
601: bzero((caddr_t)hsb, sizeof(struct hpux_stat));
602: hsb->hst_dev = (long)sb->st_dev;
603: hsb->hst_ino = (u_long)sb->st_ino;
604: hsb->hst_mode = (u_short)sb->st_mode;
605: hsb->hst_nlink = (u_short)sb->st_nlink;
606: hsb->hst_uid = (u_long)sb->st_uid;
607: hsb->hst_gid = (u_long)sb->st_gid;
608: hsb->hst_rdev = (long)bsdtohpuxdev(sb->st_rdev);
609: /*
610: * XXX Let's just hope that the old binary doesn't lose.
611: */
612: hsb->hst_old_uid = (u_short)sb->st_uid;
613: hsb->hst_old_gid = (u_short)sb->st_gid;
614:
615: if (sb->st_size < (off_t)(((off_t)1) << 32))
616: hsb->hst_size = (long)sb->st_size;
617: else
618: hsb->hst_size = -2;
619: hsb->hst_atime = (long)sb->st_atime;
620: hsb->hst_mtime = (long)sb->st_mtime;
621: hsb->hst_ctime = (long)sb->st_ctime;
622: hsb->hst_blksize = (long)sb->st_blksize;
623: hsb->hst_blocks = (long)sb->st_blocks;
624: }
625:
626: /*
627: * HP-UX access(2) system call.
628: */
629: int
630: hpux_sys_access(p, v, retval)
631: struct proc *p;
632: void *v;
633: register_t *retval;
634: {
635: struct hpux_sys_access_args /* {
636: syscallarg(char *) path;
637: syscallarg(int) flags;
638: } */ *uap = v;
639: caddr_t sg = stackgap_init(p->p_emul);
640:
641: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
642:
643: return (sys_access(p, uap, retval));
644: }
645:
646: /*
647: * HP-UX unlink(2) system call.
648: */
649: int
650: hpux_sys_unlink(p, v, retval)
651: struct proc *p;
652: void *v;
653: register_t *retval;
654: {
655: struct hpux_sys_unlink_args /* {
656: syscallarg(char *) path;
657: } */ *uap = v;
658: caddr_t sg = stackgap_init(p->p_emul);
659:
660: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
661:
662: return (sys_unlink(p, uap, retval));
663: }
664:
665: /*
666: * HP-UX chdir(2) system call.
667: */
668: int
669: hpux_sys_chdir(p, v, retval)
670: struct proc *p;
671: void *v;
672: register_t *retval;
673: {
674: struct hpux_sys_chdir_args /* {
675: syscallarg(char *) path;
676: } */ *uap = v;
677: caddr_t sg = stackgap_init(p->p_emul);
678:
679: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
680:
681: return (sys_chdir(p, uap, retval));
682: }
683:
684: /*
685: * HP-UX mknod(2) system call.
686: */
687: int
688: hpux_sys_mknod(p, v, retval)
689: struct proc *p;
690: void *v;
691: register_t *retval;
692: {
693: struct hpux_sys_mknod_args /* {
694: syscallarg(char *) path;
695: syscallarg(int) mode;
696: syscallarf(int) dev;
697: } */ *uap = v;
698: caddr_t sg = stackgap_init(p->p_emul);
699: struct sys_mkfifo_args bma;
700:
701: HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
702:
703: /*
704: * BSD handles FIFOs separately.
705: */
706: if (S_ISFIFO(SCARG(uap, mode))) {
707: SCARG(&bma, path) = SCARG(uap, path);
708: SCARG(&bma, mode) = SCARG(uap, mode);
709: return (sys_mkfifo(p, uap, retval));
710: } else
711: return (sys_mknod(p, uap, retval));
712: }
713:
714: /*
715: * HP-UX chmod(2) system call.
716: */
717: int
718: hpux_sys_chmod(p, v, retval)
719: struct proc *p;
720: void *v;
721: register_t *retval;
722: {
723: struct hpux_sys_chmod_args /* {
724: syscallarg(char *) path;
725: syscallarg(int) mode;
726: } */ *uap = v;
727: caddr_t sg = stackgap_init(p->p_emul);
728:
729: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
730:
731: return (sys_chmod(p, uap, retval));
732: }
733:
734: /*
735: * HP-UX chown(2) system call.
736: */
737: int
738: hpux_sys_chown(p, v, retval)
739: struct proc *p;
740: void *v;
741: register_t *retval;
742: {
743: struct hpux_sys_chown_args /* {
744: syscallarg(char *) path;
745: syscallarg(int) uid;
746: syscallarg(int) gid;
747: } */ *uap = v;
748: caddr_t sg = stackgap_init(p->p_emul);
749:
750: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
751:
752: /* XXX What about older HP-UX executables? */
753:
754: return (sys_lchown(p, uap, retval));
755: }
756:
757: /*
758: * HP-UX rename(2) system call.
759: */
760: int
761: hpux_sys_rename(p, v, retval)
762: struct proc *p;
763: void *v;
764: register_t *retval;
765: {
766: struct hpux_sys_rename_args /* {
767: syscallarg(char *) from;
768: syscallarg(char *) to;
769: } */ *uap = v;
770: caddr_t sg = stackgap_init(p->p_emul);
771:
772: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, from));
773: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, to));
774:
775: return (sys_rename(p, uap, retval));
776: }
777:
778: /*
779: * HP-UX mkdir(2) system call.
780: */
781: int
782: hpux_sys_mkdir(p, v, retval)
783: struct proc *p;
784: void *v;
785: register_t *retval;
786: {
787: struct hpux_sys_mkdir_args /* {
788: syscallarg(char *) path;
789: syscallarg(int) mode;
790: } */ *uap = v;
791: caddr_t sg = stackgap_init(p->p_emul);
792:
793: HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
794:
795: return (sys_mkdir(p, uap, retval));
796: }
797:
798: /*
799: * HP-UX rmdir(2) system call.
800: */
801: int
802: hpux_sys_rmdir(p, v, retval)
803: struct proc *p;
804: void *v;
805: register_t *retval;
806: {
807: struct hpux_sys_rmdir_args /* {
808: syscallarg(char *) path;
809: } */ *uap = v;
810: caddr_t sg = stackgap_init(p->p_emul);
811:
812: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
813:
814: return (sys_rmdir(p, uap, retval));
815: }
816:
817: /*
818: * HP-UX symlink(2) system call.
819: */
820: int
821: hpux_sys_symlink(p, v, retval)
822: struct proc *p;
823: void *v;
824: register_t *retval;
825: {
826: struct hpux_sys_symlink_args /* {
827: syscallarg(char *) path;
828: syscallarg(char *) link;
829: } */ *uap = v;
830: caddr_t sg = stackgap_init(p->p_emul);
831:
832: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
833: HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, link));
834:
835: return (sys_symlink(p, uap, retval));
836: }
837:
838: /*
839: * HP-UX readlink(2) system call.
840: */
841: int
842: hpux_sys_readlink(p, v, retval)
843: struct proc *p;
844: void *v;
845: register_t *retval;
846: {
847: struct hpux_sys_readlink_args /* {
848: syscallarg(char *) path;
849: syscallarg(char *) buf;
850: syscallarg(int) count;
851: } */ *uap = v;
852: caddr_t sg = stackgap_init(p->p_emul);
853:
854: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
855:
856: return (sys_readlink(p, uap, retval));
857: }
858:
859: /*
860: * HP-UX truncate(2) system call.
861: */
862: int
863: hpux_sys_truncate(p, v, retval)
864: struct proc *p;
865: void *v;
866: register_t *retval;
867: {
868: struct hpux_sys_truncate_args /* {
869: syscallarg(char *) path;
870: syscallarg(long) length;
871: } */ *uap = v;
872: caddr_t sg = stackgap_init(p->p_emul);
873:
874: HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
875:
876: return (compat_43_sys_truncate(p, uap, retval));
877: }