1/* $NetBSD: netbsd32_fs.c,v 1.78 2016/10/21 07:45:16 mrg Exp $ */
2
3/*
4 * Copyright (c) 1998, 2001 Matthew R. Green
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: netbsd32_fs.c,v 1.78 2016/10/21 07:45:16 mrg Exp $");
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/mount.h>
35#include <sys/socket.h>
36#include <sys/socketvar.h>
37#include <sys/stat.h>
38#include <sys/time.h>
39#include <sys/ktrace.h>
40#include <sys/resourcevar.h>
41#include <sys/vnode.h>
42#include <sys/file.h>
43#include <sys/filedesc.h>
44#include <sys/namei.h>
45#include <sys/statvfs.h>
46#include <sys/syscallargs.h>
47#include <sys/proc.h>
48#include <sys/dirent.h>
49#include <sys/kauth.h>
50#include <sys/vfs_syscalls.h>
51
52#include <fs/cd9660/cd9660_mount.h>
53#include <fs/tmpfs/tmpfs_args.h>
54#include <fs/msdosfs/bpb.h>
55#include <fs/msdosfs/msdosfsmount.h>
56#include <ufs/ufs/ufsmount.h>
57
58#define NFS_ARGS_ONLY
59#include <nfs/nfsmount.h>
60
61#include <compat/netbsd32/netbsd32.h>
62#include <compat/netbsd32/netbsd32_syscallargs.h>
63#include <compat/netbsd32/netbsd32_conv.h>
64#include <compat/sys/mount.h>
65
66
67static int dofilereadv32(int, struct file *, struct netbsd32_iovec *,
68 int, off_t *, int, register_t *);
69static int dofilewritev32(int, struct file *, struct netbsd32_iovec *,
70 int, off_t *, int, register_t *);
71
72struct iovec *
73netbsd32_get_iov(struct netbsd32_iovec *iov32, int iovlen, struct iovec *aiov,
74 int aiov_len)
75{
76#define N_IOV32 8
77 struct netbsd32_iovec aiov32[N_IOV32];
78 struct iovec *iov = aiov;
79 struct iovec *iovp;
80 int i, n, j;
81 int error;
82
83 if (iovlen < 0 || iovlen > IOV_MAX)
84 return NULL;
85
86 if (iovlen > aiov_len)
87 iov = kmem_alloc(iovlen * sizeof(*iov), KM_SLEEP);
88
89 iovp = iov;
90 for (i = 0; i < iovlen; iov32 += N_IOV32, i += N_IOV32) {
91 n = iovlen - i;
92 if (n > N_IOV32)
93 n = N_IOV32;
94 error = copyin(iov32, aiov32, n * sizeof (*iov32));
95 if (error != 0) {
96 if (iov != aiov)
97 kmem_free(iov, iovlen * sizeof(*iov));
98 return NULL;
99 }
100 for (j = 0; j < n; iovp++, j++) {
101 iovp->iov_base = NETBSD32PTR64(aiov32[j].iov_base);
102 iovp->iov_len = aiov32[j].iov_len;
103 }
104 }
105 return iov;
106#undef N_IOV32
107}
108
109int
110netbsd32_readv(struct lwp *l, const struct netbsd32_readv_args *uap, register_t *retval)
111{
112 /* {
113 syscallarg(int) fd;
114 syscallarg(const netbsd32_iovecp_t) iovp;
115 syscallarg(int) iovcnt;
116 } */
117 int fd = SCARG(uap, fd);
118 file_t *fp;
119
120 if ((fp = fd_getfile(fd)) == NULL)
121 return (EBADF);
122
123 if ((fp->f_flag & FREAD) == 0) {
124 fd_putfile(fd);
125 return (EBADF);
126 }
127
128 return (dofilereadv32(fd, fp,
129 (struct netbsd32_iovec *)SCARG_P32(uap, iovp),
130 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval));
131}
132
133/* Damn thing copies in the iovec! */
134int
135dofilereadv32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval)
136{
137 struct uio auio;
138 struct iovec *iov;
139 struct iovec *needfree;
140 struct iovec aiov[UIO_SMALLIOV];
141 long i, cnt, error = 0;
142 u_int iovlen;
143 struct iovec *ktriov = NULL;
144
145 /* note: can't use iovlen until iovcnt is validated */
146 iovlen = iovcnt * sizeof(struct iovec);
147 if ((u_int)iovcnt > UIO_SMALLIOV) {
148 if ((u_int)iovcnt > IOV_MAX) {
149 error = EINVAL;
150 goto out;
151 }
152 iov = kmem_alloc(iovlen, KM_SLEEP);
153 needfree = iov;
154 } else if ((u_int)iovcnt > 0) {
155 iov = aiov;
156 needfree = NULL;
157 } else {
158 error = EINVAL;
159 goto out;
160 }
161
162 auio.uio_iov = iov;
163 auio.uio_iovcnt = iovcnt;
164 auio.uio_rw = UIO_READ;
165 auio.uio_vmspace = curproc->p_vmspace;
166 error = netbsd32_to_iovecin(iovp, iov, iovcnt);
167 if (error)
168 goto done;
169 auio.uio_resid = 0;
170 for (i = 0; i < iovcnt; i++) {
171 auio.uio_resid += iov->iov_len;
172 /*
173 * Reads return ssize_t because -1 is returned on error.
174 * Therefore we must restrict the length to SSIZE_MAX to
175 * avoid garbage return values.
176 */
177 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
178 error = EINVAL;
179 goto done;
180 }
181 iov++;
182 }
183
184 /*
185 * if tracing, save a copy of iovec
186 */
187 if (ktrpoint(KTR_GENIO)) {
188 ktriov = kmem_alloc(iovlen, KM_SLEEP);
189 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen);
190 }
191
192 cnt = auio.uio_resid;
193 error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags);
194 if (error)
195 if (auio.uio_resid != cnt && (error == ERESTART ||
196 error == EINTR || error == EWOULDBLOCK))
197 error = 0;
198 cnt -= auio.uio_resid;
199
200 if (ktriov != NULL) {
201 ktrgeniov(fd, UIO_READ, ktriov, cnt, error);
202 kmem_free(ktriov, iovlen);
203 }
204
205 *retval = cnt;
206done:
207 if (needfree)
208 kmem_free(needfree, iovlen);
209out:
210 fd_putfile(fd);
211 return (error);
212}
213
214int
215netbsd32_writev(struct lwp *l, const struct netbsd32_writev_args *uap, register_t *retval)
216{
217 /* {
218 syscallarg(int) fd;
219 syscallarg(const netbsd32_iovecp_t) iovp;
220 syscallarg(int) iovcnt;
221 } */
222 int fd = SCARG(uap, fd);
223 file_t *fp;
224
225 if ((fp = fd_getfile(fd)) == NULL)
226 return (EBADF);
227
228 if ((fp->f_flag & FWRITE) == 0) {
229 fd_putfile(fd);
230 return (EBADF);
231 }
232
233 return (dofilewritev32(fd, fp,
234 (struct netbsd32_iovec *)SCARG_P32(uap, iovp),
235 SCARG(uap, iovcnt), &fp->f_offset, FOF_UPDATE_OFFSET, retval));
236}
237
238int
239dofilewritev32(int fd, struct file *fp, struct netbsd32_iovec *iovp, int iovcnt, off_t *offset, int flags, register_t *retval)
240{
241 struct uio auio;
242 struct iovec *iov;
243 struct iovec *needfree;
244 struct iovec aiov[UIO_SMALLIOV];
245 long i, cnt, error = 0;
246 u_int iovlen;
247 struct iovec *ktriov = NULL;
248
249 /* note: can't use iovlen until iovcnt is validated */
250 iovlen = iovcnt * sizeof(struct iovec);
251 if ((u_int)iovcnt > UIO_SMALLIOV) {
252 if ((u_int)iovcnt > IOV_MAX) {
253 error = EINVAL;
254 goto out;
255 }
256 iov = kmem_alloc(iovlen, KM_SLEEP);
257 needfree = iov;
258 } else if ((u_int)iovcnt > 0) {
259 iov = aiov;
260 needfree = NULL;
261 } else {
262 error = EINVAL;
263 goto out;
264 }
265
266 auio.uio_iov = iov;
267 auio.uio_iovcnt = iovcnt;
268 auio.uio_rw = UIO_WRITE;
269 auio.uio_vmspace = curproc->p_vmspace;
270 error = netbsd32_to_iovecin(iovp, iov, iovcnt);
271 if (error)
272 goto done;
273 auio.uio_resid = 0;
274 for (i = 0; i < iovcnt; i++) {
275 auio.uio_resid += iov->iov_len;
276 /*
277 * Writes return ssize_t because -1 is returned on error.
278 * Therefore we must restrict the length to SSIZE_MAX to
279 * avoid garbage return values.
280 */
281 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
282 error = EINVAL;
283 goto done;
284 }
285 iov++;
286 }
287
288 /*
289 * if tracing, save a copy of iovec
290 */
291 if (ktrpoint(KTR_GENIO)) {
292 ktriov = kmem_alloc(iovlen, KM_SLEEP);
293 memcpy((void *)ktriov, (void *)auio.uio_iov, iovlen);
294 }
295
296 cnt = auio.uio_resid;
297 error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags);
298 if (error) {
299 if (auio.uio_resid != cnt && (error == ERESTART ||
300 error == EINTR || error == EWOULDBLOCK))
301 error = 0;
302 if (error == EPIPE && (fp->f_flag & FNOSIGPIPE) == 0) {
303 mutex_enter(proc_lock);
304 psignal(curproc, SIGPIPE);
305 mutex_exit(proc_lock);
306 }
307 }
308 cnt -= auio.uio_resid;
309 if (ktriov != NULL) {
310 ktrgeniov(fd, UIO_WRITE, ktriov, cnt, error);
311 kmem_free(ktriov, iovlen);
312 }
313 *retval = cnt;
314done:
315 if (needfree)
316 kmem_free(needfree, iovlen);
317out:
318 fd_putfile(fd);
319 return (error);
320}
321
322/*
323 * Common routines to set access and modification times given a vnode.
324 */
325static int
326get_utimes32(const netbsd32_timevalp_t *tptr, struct timeval *tv,
327 struct timeval **tvp)
328{
329 int error;
330 struct netbsd32_timeval tv32[2];
331
332 if (tptr == NULL) {
333 *tvp = NULL;
334 return 0;
335 }
336
337 error = copyin(tptr, tv32, sizeof(tv32));
338 if (error)
339 return error;
340 netbsd32_to_timeval(&tv32[0], &tv[0]);
341 netbsd32_to_timeval(&tv32[1], &tv[1]);
342
343 *tvp = tv;
344 return 0;
345}
346
347static int
348get_utimens32(const netbsd32_timespecp_t *tptr, struct timespec *ts,
349 struct timespec **tsp)
350{
351 int error;
352 struct netbsd32_timespec ts32[2];
353
354 if (tptr == NULL) {
355 *tsp = NULL;
356 return 0;
357 }
358
359 error = copyin(tptr, ts32, sizeof(ts32));
360 if (error)
361 return error;
362 netbsd32_to_timespec(&ts32[0], &ts[0]);
363 netbsd32_to_timespec(&ts32[1], &ts[1]);
364
365 *tsp = ts;
366 return 0;
367}
368
369int
370netbsd32___utimes50(struct lwp *l, const struct netbsd32___utimes50_args *uap, register_t *retval)
371{
372 /* {
373 syscallarg(const netbsd32_charp) path;
374 syscallarg(const netbsd32_timevalp_t) tptr;
375 } */
376 int error;
377 struct timeval tv[2], *tvp;
378
379 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
380 if (error != 0)
381 return error;
382
383 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW,
384 tvp, UIO_SYSSPACE);
385}
386
387static int
388netbds32_copyout_statvfs(const void *kp, void *up, size_t len)
389{
390 struct netbsd32_statvfs *sbuf_32;
391 int error;
392
393 sbuf_32 = kmem_alloc(sizeof(*sbuf_32), KM_SLEEP);
394 netbsd32_from_statvfs(kp, sbuf_32);
395 error = copyout(sbuf_32, up, sizeof(*sbuf_32));
396 kmem_free(sbuf_32, sizeof(*sbuf_32));
397
398 return error;
399}
400
401int
402netbsd32_statvfs1(struct lwp *l, const struct netbsd32_statvfs1_args *uap, register_t *retval)
403{
404 /* {
405 syscallarg(const netbsd32_charp) path;
406 syscallarg(netbsd32_statvfsp_t) buf;
407 syscallarg(int) flags;
408 } */
409 struct statvfs *sb;
410 int error;
411
412 sb = STATVFSBUF_GET();
413 error = do_sys_pstatvfs(l, SCARG_P32(uap, path), SCARG(uap, flags), sb);
414 if (error == 0)
415 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0);
416 STATVFSBUF_PUT(sb);
417 return error;
418}
419
420int
421netbsd32_fstatvfs1(struct lwp *l, const struct netbsd32_fstatvfs1_args *uap, register_t *retval)
422{
423 /* {
424 syscallarg(int) fd;
425 syscallarg(netbsd32_statvfsp_t) buf;
426 syscallarg(int) flags;
427 } */
428 struct statvfs *sb;
429 int error;
430
431 sb = STATVFSBUF_GET();
432 error = do_sys_fstatvfs(l, SCARG(uap, fd), SCARG(uap, flags), sb);
433 if (error == 0)
434 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0);
435 STATVFSBUF_PUT(sb);
436 return error;
437}
438
439int
440netbsd32_getvfsstat(struct lwp *l, const struct netbsd32_getvfsstat_args *uap, register_t *retval)
441{
442 /* {
443 syscallarg(netbsd32_statvfsp_t) buf;
444 syscallarg(netbsd32_size_t) bufsize;
445 syscallarg(int) flags;
446 } */
447
448 return do_sys_getvfsstat(l, SCARG_P32(uap, buf), SCARG(uap, bufsize),
449 SCARG(uap, flags), netbds32_copyout_statvfs,
450 sizeof (struct netbsd32_statvfs), retval);
451}
452
453int
454netbsd32___fhstatvfs140(struct lwp *l, const struct netbsd32___fhstatvfs140_args *uap, register_t *retval)
455{
456 /* {
457 syscallarg(const netbsd32_pointer_t) fhp;
458 syscallarg(netbsd32_size_t) fh_size;
459 syscallarg(netbsd32_statvfsp_t) buf;
460 syscallarg(int) flags;
461 } */
462 struct statvfs *sb;
463 int error;
464
465 sb = STATVFSBUF_GET();
466 error = do_fhstatvfs(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), sb,
467 SCARG(uap, flags));
468
469 if (error == 0)
470 error = netbds32_copyout_statvfs(sb, SCARG_P32(uap, buf), 0);
471 STATVFSBUF_PUT(sb);
472
473 return error;
474}
475
476int
477netbsd32___futimes50(struct lwp *l, const struct netbsd32___futimes50_args *uap, register_t *retval)
478{
479 /* {
480 syscallarg(int) fd;
481 syscallarg(const netbsd32_timevalp_t) tptr;
482 } */
483 int error;
484 file_t *fp;
485 struct timeval tv[2], *tvp;
486
487 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
488 if (error != 0)
489 return error;
490
491 /* fd_getvnode() will use the descriptor for us */
492 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
493 return (error);
494
495 error = do_sys_utimes(l, fp->f_vnode, NULL, 0, tvp, UIO_SYSSPACE);
496
497 fd_putfile(SCARG(uap, fd));
498 return (error);
499}
500
501int
502netbsd32___getdents30(struct lwp *l,
503 const struct netbsd32___getdents30_args *uap, register_t *retval)
504{
505 /* {
506 syscallarg(int) fd;
507 syscallarg(netbsd32_charp) buf;
508 syscallarg(netbsd32_size_t) count;
509 } */
510 file_t *fp;
511 int error, done;
512
513 /* fd_getvnode() will use the descriptor for us */
514 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
515 return (error);
516 if ((fp->f_flag & FREAD) == 0) {
517 error = EBADF;
518 goto out;
519 }
520 error = vn_readdir(fp, SCARG_P32(uap, buf),
521 UIO_USERSPACE, SCARG(uap, count), &done, l, 0, 0);
522 ktrgenio(SCARG(uap, fd), UIO_READ, SCARG_P32(uap, buf), done, error);
523 *retval = done;
524 out:
525 fd_putfile(SCARG(uap, fd));
526 return (error);
527}
528
529int
530netbsd32___lutimes50(struct lwp *l,
531 const struct netbsd32___lutimes50_args *uap, register_t *retval)
532{
533 /* {
534 syscallarg(const netbsd32_charp) path;
535 syscallarg(const netbsd32_timevalp_t) tptr;
536 } */
537 int error;
538 struct timeval tv[2], *tvp;
539
540 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
541 if (error != 0)
542 return error;
543
544 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW,
545 tvp, UIO_SYSSPACE);
546}
547
548int
549netbsd32___stat50(struct lwp *l, const struct netbsd32___stat50_args *uap, register_t *retval)
550{
551 /* {
552 syscallarg(const netbsd32_charp) path;
553 syscallarg(netbsd32_statp_t) ub;
554 } */
555 struct netbsd32_stat sb32;
556 struct stat sb;
557 int error;
558 const char *path;
559
560 path = SCARG_P32(uap, path);
561
562 error = do_sys_stat(path, FOLLOW, &sb);
563 if (error)
564 return (error);
565 netbsd32_from_stat(&sb, &sb32);
566 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
567 return (error);
568}
569
570int
571netbsd32___fstat50(struct lwp *l, const struct netbsd32___fstat50_args *uap, register_t *retval)
572{
573 /* {
574 syscallarg(int) fd;
575 syscallarg(netbsd32_statp_t) sb;
576 } */
577 struct netbsd32_stat sb32;
578 struct stat ub;
579 int error;
580
581 error = do_sys_fstat(SCARG(uap, fd), &ub);
582 if (error == 0) {
583 netbsd32_from_stat(&ub, &sb32);
584 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32));
585 }
586 return (error);
587}
588
589int
590netbsd32___lstat50(struct lwp *l, const struct netbsd32___lstat50_args *uap, register_t *retval)
591{
592 /* {
593 syscallarg(const netbsd32_charp) path;
594 syscallarg(netbsd32_statp_t) ub;
595 } */
596 struct netbsd32_stat sb32;
597 struct stat sb;
598 int error;
599 const char *path;
600
601 path = SCARG_P32(uap, path);
602
603 error = do_sys_stat(path, NOFOLLOW, &sb);
604 if (error)
605 return (error);
606 netbsd32_from_stat(&sb, &sb32);
607 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
608 return (error);
609}
610
611int
612netbsd32___fhstat50(struct lwp *l, const struct netbsd32___fhstat50_args *uap, register_t *retval)
613{
614 /* {
615 syscallarg(const netbsd32_pointer_t) fhp;
616 syscallarg(netbsd32_size_t) fh_size;
617 syscallarg(netbsd32_statp_t) sb;
618 } */
619 struct stat sb;
620 struct netbsd32_stat sb32;
621 int error;
622
623 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb);
624 if (error == 0) {
625 netbsd32_from_stat(&sb, &sb32);
626 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb));
627 }
628 return error;
629}
630
631int
632netbsd32_preadv(struct lwp *l, const struct netbsd32_preadv_args *uap, register_t *retval)
633{
634 /* {
635 syscallarg(int) fd;
636 syscallarg(const netbsd32_iovecp_t) iovp;
637 syscallarg(int) iovcnt;
638 syscallarg(int) pad;
639 syscallarg(netbsd32_off_t) offset;
640 } */
641 file_t *fp;
642 struct vnode *vp;
643 off_t offset;
644 int error, fd = SCARG(uap, fd);
645
646 if ((fp = fd_getfile(fd)) == NULL)
647 return (EBADF);
648
649 if ((fp->f_flag & FREAD) == 0) {
650 fd_putfile(fd);
651 return (EBADF);
652 }
653
654 vp = fp->f_vnode;
655 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
656 error = ESPIPE;
657 goto out;
658 }
659
660 offset = SCARG(uap, offset);
661
662 /*
663 * XXX This works because no file systems actually
664 * XXX take any action on the seek operation.
665 */
666 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0)
667 goto out;
668
669 return (dofilereadv32(fd, fp, SCARG_P32(uap, iovp),
670 SCARG(uap, iovcnt), &offset, 0, retval));
671
672out:
673 fd_putfile(fd);
674 return (error);
675}
676
677int
678netbsd32_pwritev(struct lwp *l, const struct netbsd32_pwritev_args *uap, register_t *retval)
679{
680 /* {
681 syscallarg(int) fd;
682 syscallarg(const netbsd32_iovecp_t) iovp;
683 syscallarg(int) iovcnt;
684 syscallarg(int) pad;
685 syscallarg(netbsd32_off_t) offset;
686 } */
687 file_t *fp;
688 struct vnode *vp;
689 off_t offset;
690 int error, fd = SCARG(uap, fd);
691
692 if ((fp = fd_getfile(fd)) == NULL)
693 return (EBADF);
694
695 if ((fp->f_flag & FWRITE) == 0) {
696 fd_putfile(fd);
697 return (EBADF);
698 }
699
700 vp = fp->f_vnode;
701 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
702 error = ESPIPE;
703 goto out;
704 }
705
706 offset = SCARG(uap, offset);
707
708 /*
709 * XXX This works because no file systems actually
710 * XXX take any action on the seek operation.
711 */
712 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0)
713 goto out;
714
715 return (dofilewritev32(fd, fp, SCARG_P32(uap, iovp),
716 SCARG(uap, iovcnt), &offset, 0, retval));
717
718out:
719 fd_putfile(fd);
720 return (error);
721}
722
723/*
724 * Find pathname of process's current directory.
725 *
726 * Use vfs vnode-to-name reverse cache; if that fails, fall back
727 * to reading directory contents.
728 */
729/* XXX NH Why does this exist */
730int
731getcwd_common(struct vnode *, struct vnode *,
732 char **, char *, int, int, struct lwp *);
733
734int
735netbsd32___getcwd(struct lwp *l, const struct netbsd32___getcwd_args *uap, register_t *retval)
736{
737 /* {
738 syscallarg(char *) bufp;
739 syscallarg(size_t) length;
740 } */
741 struct proc *p = l->l_proc;
742 int error;
743 char *path;
744 char *bp, *bend;
745 int len = (int)SCARG(uap, length);
746 int lenused;
747 struct cwdinfo *cwdi;
748
749 if (len > MAXPATHLEN*4)
750 len = MAXPATHLEN*4;
751 else if (len < 2)
752 return ERANGE;
753
754 path = kmem_alloc(len, KM_SLEEP);
755 if (!path)
756 return ENOMEM;
757
758 bp = &path[len];
759 bend = bp;
760 *(--bp) = '\0';
761
762 /*
763 * 5th argument here is "max number of vnodes to traverse".
764 * Since each entry takes up at least 2 bytes in the output buffer,
765 * limit it to N/2 vnodes for an N byte buffer.
766 */
767#define GETCWD_CHECK_ACCESS 0x0001
768 cwdi = p->p_cwdi;
769 rw_enter(&cwdi->cwdi_lock, RW_READER);
770 error = getcwd_common (cwdi->cwdi_cdir, NULL, &bp, path, len/2,
771 GETCWD_CHECK_ACCESS, l);
772 rw_exit(&cwdi->cwdi_lock);
773
774 if (error)
775 goto out;
776 lenused = bend - bp;
777 *retval = lenused;
778 /* put the result into user buffer */
779 error = copyout(bp, SCARG_P32(uap, bufp), lenused);
780
781out:
782 kmem_free(path, len);
783 return error;
784}
785
786int
787netbsd32___mount50(struct lwp *l, const struct netbsd32___mount50_args *uap,
788 register_t *retval)
789{
790 /* {
791 syscallarg(netbsd32_charp) type;
792 syscallarg(netbsd32_charp) path;
793 syscallarg(int) flags;
794 syscallarg(netbsd32_voidp) data;
795 syscallarg(netbsd32_size_t) data_len;
796 } */
797 char mtype[MNAMELEN];
798 union {
799 struct netbsd32_ufs_args ufs_args;
800 struct netbsd32_mfs_args mfs_args;
801 struct netbsd32_iso_args iso_args;
802 struct netbsd32_nfs_args nfs_args;
803 struct netbsd32_msdosfs_args msdosfs_args;
804 struct netbsd32_tmpfs_args tmpfs_args;
805 } fs_args32;
806 union {
807 struct ufs_args ufs_args;
808 struct mfs_args mfs_args;
809 struct iso_args iso_args;
810 struct nfs_args nfs_args;
811 struct msdosfs_args msdosfs_args;
812 struct tmpfs_args tmpfs_args;
813 } fs_args;
814 const char *type = SCARG_P32(uap, type);
815 const char *path = SCARG_P32(uap, path);
816 int flags = SCARG(uap, flags);
817 void *data = SCARG_P32(uap, data);
818 size_t data_len = SCARG(uap, data_len);
819 enum uio_seg data_seg;
820 size_t len;
821 int error;
822
823 error = copyinstr(type, mtype, sizeof(mtype), &len);
824 if (error)
825 return error;
826 if (strcmp(mtype, MOUNT_TMPFS) == 0) {
827 if (data_len != sizeof(fs_args32.tmpfs_args))
828 return EINVAL;
829 if ((flags & MNT_GETARGS) == 0) {
830 error = copyin(data, &fs_args32.tmpfs_args,
831 sizeof(fs_args32.tmpfs_args));
832 if (error)
833 return error;
834 fs_args.tmpfs_args.ta_version =
835 fs_args32.tmpfs_args.ta_version;
836 fs_args.tmpfs_args.ta_nodes_max =
837 fs_args32.tmpfs_args.ta_nodes_max;
838 fs_args.tmpfs_args.ta_size_max =
839 fs_args32.tmpfs_args.ta_size_max;
840 fs_args.tmpfs_args.ta_root_uid =
841 fs_args32.tmpfs_args.ta_root_uid;
842 fs_args.tmpfs_args.ta_root_gid =
843 fs_args32.tmpfs_args.ta_root_gid;
844 fs_args.tmpfs_args.ta_root_mode =
845 fs_args32.tmpfs_args.ta_root_mode;
846 }
847 data_seg = UIO_SYSSPACE;
848 data = &fs_args.tmpfs_args;
849 data_len = sizeof(fs_args.tmpfs_args);
850 } else if (strcmp(mtype, MOUNT_MFS) == 0) {
851 if (data_len != sizeof(fs_args32.mfs_args))
852 return EINVAL;
853 if ((flags & MNT_GETARGS) == 0) {
854 error = copyin(data, &fs_args32.mfs_args,
855 sizeof(fs_args32.mfs_args));
856 if (error)
857 return error;
858 fs_args.mfs_args.fspec =
859 NETBSD32PTR64(fs_args32.mfs_args.fspec);
860 memset(&fs_args.mfs_args._pad1, 0,
861 sizeof(fs_args.mfs_args._pad1));
862 fs_args.mfs_args.base =
863 NETBSD32PTR64(fs_args32.mfs_args.base);
864 fs_args.mfs_args.size = fs_args32.mfs_args.size;
865 }
866 data_seg = UIO_SYSSPACE;
867 data = &fs_args.mfs_args;
868 data_len = sizeof(fs_args.mfs_args);
869 } else if ((strcmp(mtype, MOUNT_UFS) == 0) ||
870 (strcmp(mtype, MOUNT_EXT2FS) == 0) ||
871 (strcmp(mtype, MOUNT_LFS) == 0)) {
872 if (data_len > sizeof(fs_args32.ufs_args))
873 return EINVAL;
874 if ((flags & MNT_GETARGS) == 0) {
875 error = copyin(data, &fs_args32.ufs_args,
876 sizeof(fs_args32.ufs_args));
877 if (error)
878 return error;
879 fs_args.ufs_args.fspec =
880 NETBSD32PTR64(fs_args32.ufs_args.fspec);
881 }
882 data_seg = UIO_SYSSPACE;
883 data = &fs_args.ufs_args;
884 data_len = sizeof(fs_args.ufs_args);
885 } else if (strcmp(mtype, MOUNT_CD9660) == 0) {
886 if (data_len != sizeof(fs_args32.iso_args))
887 return EINVAL;
888 if ((flags & MNT_GETARGS) == 0) {
889 error = copyin(data, &fs_args32.iso_args,
890 sizeof(fs_args32.iso_args));
891 if (error)
892 return error;
893 fs_args.iso_args.fspec =
894 NETBSD32PTR64(fs_args32.iso_args.fspec);
895 memset(&fs_args.iso_args._pad1, 0,
896 sizeof(fs_args.iso_args._pad1));
897 fs_args.iso_args.flags = fs_args32.iso_args.flags;
898 }
899 data_seg = UIO_SYSSPACE;
900 data = &fs_args.iso_args;
901 data_len = sizeof(fs_args.iso_args);
902 } else if (strcmp(mtype, MOUNT_MSDOS) == 0) {
903 if (data_len != sizeof(fs_args32.msdosfs_args))
904 return EINVAL;
905 if ((flags & MNT_GETARGS) == 0) {
906 error = copyin(data, &fs_args32.msdosfs_args,
907 sizeof(fs_args32.msdosfs_args));
908 if (error)
909 return error;
910 fs_args.msdosfs_args.fspec =
911 NETBSD32PTR64(fs_args32.msdosfs_args.fspec);
912 memset(&fs_args.msdosfs_args._pad1, 0,
913 sizeof(fs_args.msdosfs_args._pad1));
914 fs_args.msdosfs_args.uid =
915 fs_args32.msdosfs_args.uid;
916 fs_args.msdosfs_args.gid =
917 fs_args32.msdosfs_args.gid;
918 fs_args.msdosfs_args.mask =
919 fs_args32.msdosfs_args.mask;
920 fs_args.msdosfs_args.flags =
921 fs_args32.msdosfs_args.flags;
922 fs_args.msdosfs_args.version =
923 fs_args32.msdosfs_args.version;
924 fs_args.msdosfs_args.dirmask =
925 fs_args32.msdosfs_args.dirmask;
926 fs_args.msdosfs_args.gmtoff =
927 fs_args32.msdosfs_args.gmtoff;
928 }
929 data_seg = UIO_SYSSPACE;
930 data = &fs_args.msdosfs_args;
931 data_len = sizeof(fs_args.msdosfs_args);
932 } else if (strcmp(mtype, MOUNT_NFS) == 0) {
933 if (data_len != sizeof(fs_args32.nfs_args))
934 return EINVAL;
935 if ((flags & MNT_GETARGS) == 0) {
936 error = copyin(data, &fs_args32.nfs_args,
937 sizeof(fs_args32.nfs_args));
938 if (error)
939 return error;
940 fs_args.nfs_args.version = fs_args32.nfs_args.version;
941 fs_args.nfs_args.addr =
942 NETBSD32PTR64(fs_args32.nfs_args.addr);
943 memcpy(&fs_args.nfs_args.addrlen,
944 &fs_args32.nfs_args.addrlen,
945 offsetof(struct nfs_args, fh)
946 - offsetof(struct nfs_args, addrlen));
947 fs_args.nfs_args.fh =
948 NETBSD32PTR64(fs_args32.nfs_args.fh);
949 memcpy(&fs_args.nfs_args.fhsize,
950 &fs_args32.nfs_args.fhsize,
951 offsetof(struct nfs_args, hostname)
952 - offsetof(struct nfs_args, fhsize));
953 fs_args.nfs_args.hostname =
954 NETBSD32PTR64(fs_args32.nfs_args.hostname);
955 }
956 data_seg = UIO_SYSSPACE;
957 data = &fs_args.nfs_args;
958 data_len = sizeof(fs_args.nfs_args);
959 } else {
960 data_seg = UIO_USERSPACE;
961 }
962 error = do_sys_mount(l, mtype, UIO_SYSSPACE, path, flags, data, data_seg,
963 data_len, retval);
964 if (error)
965 return error;
966 if (flags & MNT_GETARGS) {
967 data_len = *retval;
968 if (strcmp(mtype, MOUNT_TMPFS) == 0) {
969 if (data_len != sizeof(fs_args.tmpfs_args))
970 return EINVAL;
971 fs_args32.tmpfs_args.ta_version =
972 fs_args.tmpfs_args.ta_version;
973 fs_args32.tmpfs_args.ta_nodes_max =
974 fs_args.tmpfs_args.ta_nodes_max;
975 fs_args32.tmpfs_args.ta_size_max =
976 fs_args.tmpfs_args.ta_size_max;
977 fs_args32.tmpfs_args.ta_root_uid =
978 fs_args.tmpfs_args.ta_root_uid;
979 fs_args32.tmpfs_args.ta_root_gid =
980 fs_args.tmpfs_args.ta_root_gid;
981 fs_args32.tmpfs_args.ta_root_mode =
982 fs_args.tmpfs_args.ta_root_mode;
983 error = copyout(&fs_args32.tmpfs_args, data,
984 sizeof(fs_args32.tmpfs_args));
985 } else if (strcmp(mtype, MOUNT_MFS) == 0) {
986 if (data_len != sizeof(fs_args.mfs_args))
987 return EINVAL;
988 NETBSD32PTR32(fs_args32.mfs_args.fspec,
989 fs_args.mfs_args.fspec);
990 memset(&fs_args32.mfs_args._pad1, 0,
991 sizeof(fs_args32.mfs_args._pad1));
992 NETBSD32PTR32(fs_args32.mfs_args.base,
993 fs_args.mfs_args.base);
994 fs_args32.mfs_args.size = fs_args.mfs_args.size;
995 error = copyout(&fs_args32.mfs_args, data,
996 sizeof(fs_args32.mfs_args));
997 } else if (strcmp(mtype, MOUNT_UFS) == 0) {
998 if (data_len != sizeof(fs_args.ufs_args))
999 return EINVAL;
1000 NETBSD32PTR32(fs_args32.ufs_args.fspec,
1001 fs_args.ufs_args.fspec);
1002 error = copyout(&fs_args32.ufs_args, data,
1003 sizeof(fs_args32.ufs_args));
1004 } else if (strcmp(mtype, MOUNT_CD9660) == 0) {
1005 if (data_len != sizeof(fs_args.iso_args))
1006 return EINVAL;
1007 NETBSD32PTR32(fs_args32.iso_args.fspec,
1008 fs_args.iso_args.fspec);
1009 memset(&fs_args32.iso_args._pad1, 0,
1010 sizeof(fs_args32.iso_args._pad1));
1011 fs_args32.iso_args.flags = fs_args.iso_args.flags;
1012 error = copyout(&fs_args32.iso_args, data,
1013 sizeof(fs_args32.iso_args));
1014 } else if (strcmp(mtype, MOUNT_NFS) == 0) {
1015 if (data_len != sizeof(fs_args.nfs_args))
1016 return EINVAL;
1017 error = copyin(data, &fs_args32.nfs_args,
1018 sizeof(fs_args32.nfs_args));
1019 if (error)
1020 return error;
1021 fs_args.nfs_args.version = fs_args32.nfs_args.version;
1022 NETBSD32PTR32(fs_args32.nfs_args.addr,
1023 fs_args.nfs_args.addr);
1024 memcpy(&fs_args32.nfs_args.addrlen,
1025 &fs_args.nfs_args.addrlen,
1026 offsetof(struct nfs_args, fh)
1027 - offsetof(struct nfs_args, addrlen));
1028 NETBSD32PTR32(fs_args32.nfs_args.fh,
1029 fs_args.nfs_args.fh);
1030 memcpy(&fs_args32.nfs_args.fhsize,
1031 &fs_args.nfs_args.fhsize,
1032 offsetof(struct nfs_args, hostname)
1033 - offsetof(struct nfs_args, fhsize));
1034 NETBSD32PTR32(fs_args32.nfs_args.hostname,
1035 fs_args.nfs_args.hostname);
1036 error = copyout(&fs_args32.nfs_args, data,
1037 sizeof(fs_args32.nfs_args));
1038 }
1039 }
1040 return error;
1041}
1042
1043int
1044netbsd32_linkat(struct lwp *l, const struct netbsd32_linkat_args *uap,
1045 register_t *retval)
1046{
1047 /* {
1048 syscallarg(int) fd1;
1049 syscallarg(const netbsd32_charp) name1;
1050 syscallarg(int) fd2;
1051 syscallarg(const netbsd32_charp) name2;
1052 syscallarg(int) flags;
1053 } */
1054 struct sys_linkat_args ua;
1055
1056 NETBSD32TO64_UAP(fd1);
1057 NETBSD32TOP_UAP(name1, const char);
1058 NETBSD32TO64_UAP(fd2);
1059 NETBSD32TOP_UAP(name2, const char);
1060 NETBSD32TO64_UAP(flags);
1061
1062 return sys_linkat(l, &ua, retval);
1063}
1064
1065int
1066netbsd32_renameat(struct lwp *l, const struct netbsd32_renameat_args *uap,
1067 register_t *retval)
1068{
1069 /* {
1070 syscallarg(int) fromfd;
1071 syscallarg(const netbsd32_charp) from;
1072 syscallarg(int) tofd;
1073 syscallarg(const netbsd32_charp) to;
1074 } */
1075 struct sys_renameat_args ua;
1076
1077 NETBSD32TO64_UAP(fromfd);
1078 NETBSD32TOP_UAP(from, const char);
1079 NETBSD32TO64_UAP(tofd);
1080 NETBSD32TOP_UAP(to, const char);
1081
1082 return sys_renameat(l, &ua, retval);
1083}
1084
1085int
1086netbsd32_mkfifoat(struct lwp *l, const struct netbsd32_mkfifoat_args *uap,
1087 register_t *retval)
1088{
1089 /* {
1090 syscallarg(int) fd;
1091 syscallarg(const netbsd32_charp) path;
1092 syscallarg(mode_t) mode;
1093 } */
1094 struct sys_mkfifoat_args ua;
1095
1096 NETBSD32TO64_UAP(fd);
1097 NETBSD32TOP_UAP(path, const char);
1098 NETBSD32TO64_UAP(mode);
1099
1100 return sys_mkfifoat(l, &ua, retval);
1101}
1102
1103int
1104netbsd32_mknodat(struct lwp *l, const struct netbsd32_mknodat_args *uap,
1105 register_t *retval)
1106{
1107 /* {
1108 syscallarg(int) fd;
1109 syscallarg(netbsd32_charp) path;
1110 syscallarg(mode_t) mode;
1111 syscallarg(int) pad;
1112 syscallarg(netbsd32_dev_t) dev;
1113 } */
1114 struct sys_mknodat_args ua;
1115
1116 NETBSD32TO64_UAP(fd);
1117 NETBSD32TOP_UAP(path, const char);
1118 NETBSD32TO64_UAP(mode);
1119 NETBSD32TO64_UAP(PAD);
1120 NETBSD32TO64_UAP(dev);
1121
1122 return sys_mknodat(l, &ua, retval);
1123}
1124
1125int
1126netbsd32_mkdirat(struct lwp *l, const struct netbsd32_mkdirat_args *uap,
1127 register_t *retval)
1128{
1129 /* {
1130 syscallarg(int) fd;
1131 syscallarg(netbsd32_charp) path;
1132 syscallarg(mode_t) mode;
1133 } */
1134 struct sys_mkdirat_args ua;
1135
1136 NETBSD32TO64_UAP(fd);
1137 NETBSD32TOP_UAP(path, const char);
1138 NETBSD32TO64_UAP(mode);
1139
1140 return sys_mkdirat(l, &ua, retval);
1141}
1142
1143int
1144netbsd32_faccessat(struct lwp *l, const struct netbsd32_faccessat_args *uap,
1145 register_t *retval)
1146{
1147 /* {
1148 syscallarg(int) fd;
1149 syscallarg(netbsd32_charp) path;
1150 syscallarg(int) amode;
1151 syscallarg(int) flag;
1152 } */
1153 struct sys_faccessat_args ua;
1154
1155 NETBSD32TO64_UAP(fd);
1156 NETBSD32TOP_UAP(path, const char);
1157 NETBSD32TO64_UAP(amode);
1158 NETBSD32TO64_UAP(flag);
1159
1160 return sys_faccessat(l, &ua, retval);
1161}
1162
1163int
1164netbsd32_fchmodat(struct lwp *l, const struct netbsd32_fchmodat_args *uap,
1165 register_t *retval)
1166{
1167 /* {
1168 syscallarg(int) fd;
1169 syscallarg(netbsd32_charp) path;
1170 syscallarg(mode_t) mode;
1171 syscallarg(int) flag;
1172 } */
1173 struct sys_fchmodat_args ua;
1174
1175 NETBSD32TO64_UAP(fd);
1176 NETBSD32TOP_UAP(path, const char);
1177 NETBSD32TO64_UAP(mode);
1178 NETBSD32TO64_UAP(flag);
1179
1180 return sys_fchmodat(l, &ua, retval);
1181}
1182
1183int
1184netbsd32_fchownat(struct lwp *l, const struct netbsd32_fchownat_args *uap,
1185 register_t *retval)
1186{
1187 /* {
1188 syscallarg(int) fd;
1189 syscallarg(netbsd32_charp) path;
1190 syscallarg(uid_t) owner;
1191 syscallarg(gid_t) group;
1192 syscallarg(int) flag;
1193 } */
1194 struct sys_fchownat_args ua;
1195
1196 NETBSD32TO64_UAP(fd);
1197 NETBSD32TOP_UAP(path, const char);
1198 NETBSD32TO64_UAP(owner);
1199 NETBSD32TO64_UAP(group);
1200 NETBSD32TO64_UAP(flag);
1201
1202 return sys_fchownat(l, &ua, retval);
1203}
1204
1205int
1206netbsd32_fstatat(struct lwp *l, const struct netbsd32_fstatat_args *uap,
1207 register_t *retval)
1208{
1209 /* {
1210 syscallarg(int) fd;
1211 syscallarg(netbsd32_charp) path;
1212 syscallarg(netbsd32_statp_t) buf;
1213 syscallarg(int) flag;
1214 } */
1215 struct netbsd32_stat sb32;
1216 struct stat sb;
1217 int follow;
1218 int error;
1219
1220 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
1221
1222 error = do_sys_statat(l, SCARG(uap, fd), SCARG_P32(uap, path),
1223 follow, &sb);
1224 if (error)
1225 return error;
1226 netbsd32_from_stat(&sb, &sb32);
1227 return copyout(&sb32, SCARG_P32(uap, buf), sizeof(sb32));
1228}
1229
1230int
1231netbsd32_utimensat(struct lwp *l, const struct netbsd32_utimensat_args *uap,
1232 register_t *retval)
1233{
1234 /* {
1235 syscallarg(int) fd;
1236 syscallarg(netbsd32_charp) path;
1237 syscallarg(netbsd32_timespecp_t) tptr;
1238 syscallarg(int) flag;
1239 } */
1240 struct timespec ts[2], *tsp = NULL /* XXXgcc */;
1241 int follow;
1242 int error;
1243
1244 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp);
1245 if (error != 0)
1246 return error;
1247
1248 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
1249
1250 return do_sys_utimensat(l, SCARG(uap, fd), NULL,
1251 SCARG_P32(uap, path), follow, tsp, UIO_SYSSPACE);
1252}
1253
1254int
1255netbsd32_openat(struct lwp *l, const struct netbsd32_openat_args *uap,
1256 register_t *retval)
1257{
1258 /* {
1259 syscallarg(int) fd;
1260 syscallarg(netbsd32_charp) path;
1261 syscallarg(int) oflags;
1262 syscallarg(mode_t) mode;
1263 } */
1264 struct sys_openat_args ua;
1265
1266 NETBSD32TO64_UAP(fd);
1267 NETBSD32TOP_UAP(path, const char);
1268 NETBSD32TO64_UAP(oflags);
1269 NETBSD32TO64_UAP(mode);
1270
1271 return sys_openat(l, &ua, retval);
1272}
1273
1274int
1275netbsd32_readlinkat(struct lwp *l, const struct netbsd32_readlinkat_args *uap,
1276 register_t *retval)
1277{
1278 /* {
1279 syscallarg(int) fd;
1280 syscallarg(netbsd32_charp) path;
1281 syscallarg(netbsd32_charp) buf;
1282 syscallarg(netbsd32_size_t) bufsize;
1283 } */
1284 struct sys_readlinkat_args ua;
1285
1286 NETBSD32TO64_UAP(fd);
1287 NETBSD32TOP_UAP(path, const char *);
1288 NETBSD32TOP_UAP(buf, char *);
1289 NETBSD32TOX_UAP(bufsize, size_t);
1290
1291 return sys_readlinkat(l, &ua, retval);
1292}
1293
1294int
1295netbsd32_symlinkat(struct lwp *l, const struct netbsd32_symlinkat_args *uap,
1296 register_t *retval)
1297{
1298 /* {
1299 syscallarg(netbsd32_charp) path1;
1300 syscallarg(int) fd;
1301 syscallarg(netbsd32_charp) path2;
1302 } */
1303 struct sys_symlinkat_args ua;
1304
1305 NETBSD32TOP_UAP(path1, const char *);
1306 NETBSD32TO64_UAP(fd);
1307 NETBSD32TOP_UAP(path2, const char *);
1308
1309 return sys_symlinkat(l, &ua, retval);
1310}
1311
1312int
1313netbsd32_unlinkat(struct lwp *l, const struct netbsd32_unlinkat_args *uap,
1314 register_t *retval)
1315{
1316 /* {
1317 syscallarg(int) fd;
1318 syscallarg(netbsd32_charp) path;
1319 syscallarg(int) flag;
1320 } */
1321 struct sys_unlinkat_args ua;
1322
1323 NETBSD32TO64_UAP(fd);
1324 NETBSD32TOP_UAP(path, const char *);
1325 NETBSD32TO64_UAP(flag);
1326
1327 return sys_unlinkat(l, &ua, retval);
1328}
1329
1330int
1331netbsd32_futimens(struct lwp *l, const struct netbsd32_futimens_args *uap,
1332 register_t *retval)
1333{
1334 /* {
1335 syscallarg(int) fd;
1336 syscallarg(netbsd32_timespecp_t) tptr;
1337 } */
1338 struct timespec ts[2], *tsp = NULL /* XXXgcc */;
1339 file_t *fp;
1340 int error;
1341
1342 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp);
1343 if (error != 0)
1344 return error;
1345
1346 /* fd_getvnode() will use the descriptor for us */
1347 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
1348 return (error);
1349 error = do_sys_utimensat(l, AT_FDCWD, fp->f_vnode, NULL, 0,
1350 tsp, UIO_SYSSPACE);
1351 fd_putfile(SCARG(uap, fd));
1352 return (error);
1353}
1354