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