1 /* $NetBSD: netbsd32_fs.c,v 1.74 2016/03/21 22:42:56 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.74 2016/03/21 22:42:56 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
67 static int dofilereadv32(int, struct file *, struct netbsd32_iovec *,
68 int, off_t *, int, register_t *);
69 static int dofilewritev32(int, struct file *, struct netbsd32_iovec *,
70 int, off_t *, int, register_t *);
71
72 struct iovec *
netbsd32_get_iov(struct netbsd32_iovec * iov32,int iovlen,struct iovec * aiov,int aiov_len)73 netbsd32_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
109 int
netbsd32_readv(struct lwp * l,const struct netbsd32_readv_args * uap,register_t * retval)110 netbsd32_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! */
134 int
dofilereadv32(int fd,struct file * fp,struct netbsd32_iovec * iovp,int iovcnt,off_t * offset,int flags,register_t * retval)135 dofilereadv32(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;
206 done:
207 if (needfree)
208 kmem_free(needfree, iovlen);
209 out:
210 fd_putfile(fd);
211 return (error);
212 }
213
214 int
netbsd32_writev(struct lwp * l,const struct netbsd32_writev_args * uap,register_t * retval)215 netbsd32_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
238 int
dofilewritev32(int fd,struct file * fp,struct netbsd32_iovec * iovp,int iovcnt,off_t * offset,int flags,register_t * retval)239 dofilewritev32(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 ktrgenio(fd, UIO_WRITE, ktriov, cnt, error);
311 kmem_free(ktriov, iovlen);
312 }
313 *retval = cnt;
314 done:
315 if (needfree)
316 kmem_free(needfree, iovlen);
317 out:
318 fd_putfile(fd);
319 return (error);
320 }
321
322 /*
323 * Common routines to set access and modification times given a vnode.
324 */
325 static int
get_utimes32(const netbsd32_timevalp_t * tptr,struct timeval * tv,struct timeval ** tvp)326 get_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
347 static int
get_utimens32(const netbsd32_timespecp_t * tptr,struct timespec * ts,struct timespec ** tsp)348 get_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
369 int
netbsd32___utimes50(struct lwp * l,const struct netbsd32___utimes50_args * uap,register_t * retval)370 netbsd32___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
387 static int
netbds32_copyout_statvfs(const void * kp,void * up,size_t len)388 netbds32_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
401 int
netbsd32_statvfs1(struct lwp * l,const struct netbsd32_statvfs1_args * uap,register_t * retval)402 netbsd32_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
420 int
netbsd32_fstatvfs1(struct lwp * l,const struct netbsd32_fstatvfs1_args * uap,register_t * retval)421 netbsd32_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
439 int
netbsd32_getvfsstat(struct lwp * l,const struct netbsd32_getvfsstat_args * uap,register_t * retval)440 netbsd32_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
453 int
netbsd32___fhstatvfs140(struct lwp * l,const struct netbsd32___fhstatvfs140_args * uap,register_t * retval)454 netbsd32___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
476 int
netbsd32___futimes50(struct lwp * l,const struct netbsd32___futimes50_args * uap,register_t * retval)477 netbsd32___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
501 int
netbsd32___getdents30(struct lwp * l,const struct netbsd32___getdents30_args * uap,register_t * retval)502 netbsd32___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 *retval = done;
523 out:
524 fd_putfile(SCARG(uap, fd));
525 return (error);
526 }
527
528 int
netbsd32___lutimes50(struct lwp * l,const struct netbsd32___lutimes50_args * uap,register_t * retval)529 netbsd32___lutimes50(struct lwp *l,
530 const struct netbsd32___lutimes50_args *uap, register_t *retval)
531 {
532 /* {
533 syscallarg(const netbsd32_charp) path;
534 syscallarg(const netbsd32_timevalp_t) tptr;
535 } */
536 int error;
537 struct timeval tv[2], *tvp;
538
539 error = get_utimes32(SCARG_P32(uap, tptr), tv, &tvp);
540 if (error != 0)
541 return error;
542
543 return do_sys_utimes(l, NULL, SCARG_P32(uap, path), NOFOLLOW,
544 tvp, UIO_SYSSPACE);
545 }
546
547 int
netbsd32___stat50(struct lwp * l,const struct netbsd32___stat50_args * uap,register_t * retval)548 netbsd32___stat50(struct lwp *l, const struct netbsd32___stat50_args *uap, register_t *retval)
549 {
550 /* {
551 syscallarg(const netbsd32_charp) path;
552 syscallarg(netbsd32_statp_t) ub;
553 } */
554 struct netbsd32_stat sb32;
555 struct stat sb;
556 int error;
557 const char *path;
558
559 path = SCARG_P32(uap, path);
560
561 error = do_sys_stat(path, FOLLOW, &sb);
562 if (error)
563 return (error);
564 netbsd32_from_stat(&sb, &sb32);
565 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
566 return (error);
567 }
568
569 int
netbsd32___fstat50(struct lwp * l,const struct netbsd32___fstat50_args * uap,register_t * retval)570 netbsd32___fstat50(struct lwp *l, const struct netbsd32___fstat50_args *uap, register_t *retval)
571 {
572 /* {
573 syscallarg(int) fd;
574 syscallarg(netbsd32_statp_t) sb;
575 } */
576 struct netbsd32_stat sb32;
577 struct stat ub;
578 int error;
579
580 error = do_sys_fstat(SCARG(uap, fd), &ub);
581 if (error == 0) {
582 netbsd32_from_stat(&ub, &sb32);
583 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32));
584 }
585 return (error);
586 }
587
588 int
netbsd32___lstat50(struct lwp * l,const struct netbsd32___lstat50_args * uap,register_t * retval)589 netbsd32___lstat50(struct lwp *l, const struct netbsd32___lstat50_args *uap, register_t *retval)
590 {
591 /* {
592 syscallarg(const netbsd32_charp) path;
593 syscallarg(netbsd32_statp_t) ub;
594 } */
595 struct netbsd32_stat sb32;
596 struct stat sb;
597 int error;
598 const char *path;
599
600 path = SCARG_P32(uap, path);
601
602 error = do_sys_stat(path, NOFOLLOW, &sb);
603 if (error)
604 return (error);
605 netbsd32_from_stat(&sb, &sb32);
606 error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
607 return (error);
608 }
609
610 int
netbsd32___fhstat50(struct lwp * l,const struct netbsd32___fhstat50_args * uap,register_t * retval)611 netbsd32___fhstat50(struct lwp *l, const struct netbsd32___fhstat50_args *uap, register_t *retval)
612 {
613 /* {
614 syscallarg(const netbsd32_pointer_t) fhp;
615 syscallarg(netbsd32_size_t) fh_size;
616 syscallarg(netbsd32_statp_t) sb;
617 } */
618 struct stat sb;
619 struct netbsd32_stat sb32;
620 int error;
621
622 error = do_fhstat(l, SCARG_P32(uap, fhp), SCARG(uap, fh_size), &sb);
623 if (error == 0) {
624 netbsd32_from_stat(&sb, &sb32);
625 error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb));
626 }
627 return error;
628 }
629
630 int
netbsd32_preadv(struct lwp * l,const struct netbsd32_preadv_args * uap,register_t * retval)631 netbsd32_preadv(struct lwp *l, const struct netbsd32_preadv_args *uap, register_t *retval)
632 {
633 /* {
634 syscallarg(int) fd;
635 syscallarg(const netbsd32_iovecp_t) iovp;
636 syscallarg(int) iovcnt;
637 syscallarg(int) pad;
638 syscallarg(netbsd32_off_t) offset;
639 } */
640 file_t *fp;
641 struct vnode *vp;
642 off_t offset;
643 int error, fd = SCARG(uap, fd);
644
645 if ((fp = fd_getfile(fd)) == NULL)
646 return (EBADF);
647
648 if ((fp->f_flag & FREAD) == 0) {
649 fd_putfile(fd);
650 return (EBADF);
651 }
652
653 vp = fp->f_vnode;
654 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
655 error = ESPIPE;
656 goto out;
657 }
658
659 offset = SCARG(uap, offset);
660
661 /*
662 * XXX This works because no file systems actually
663 * XXX take any action on the seek operation.
664 */
665 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0)
666 goto out;
667
668 return (dofilereadv32(fd, fp, SCARG_P32(uap, iovp),
669 SCARG(uap, iovcnt), &offset, 0, retval));
670
671 out:
672 fd_putfile(fd);
673 return (error);
674 }
675
676 int
netbsd32_pwritev(struct lwp * l,const struct netbsd32_pwritev_args * uap,register_t * retval)677 netbsd32_pwritev(struct lwp *l, const struct netbsd32_pwritev_args *uap, register_t *retval)
678 {
679 /* {
680 syscallarg(int) fd;
681 syscallarg(const netbsd32_iovecp_t) iovp;
682 syscallarg(int) iovcnt;
683 syscallarg(int) pad;
684 syscallarg(netbsd32_off_t) offset;
685 } */
686 file_t *fp;
687 struct vnode *vp;
688 off_t offset;
689 int error, fd = SCARG(uap, fd);
690
691 if ((fp = fd_getfile(fd)) == NULL)
692 return (EBADF);
693
694 if ((fp->f_flag & FWRITE) == 0) {
695 fd_putfile(fd);
696 return (EBADF);
697 }
698
699 vp = fp->f_vnode;
700 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
701 error = ESPIPE;
702 goto out;
703 }
704
705 offset = SCARG(uap, offset);
706
707 /*
708 * XXX This works because no file systems actually
709 * XXX take any action on the seek operation.
710 */
711 if ((error = VOP_SEEK(vp, fp->f_offset, offset, fp->f_cred)) != 0)
712 goto out;
713
714 return (dofilewritev32(fd, fp, SCARG_P32(uap, iovp),
715 SCARG(uap, iovcnt), &offset, 0, retval));
716
717 out:
718 fd_putfile(fd);
719 return (error);
720 }
721
722 /*
723 * Find pathname of process's current directory.
724 *
725 * Use vfs vnode-to-name reverse cache; if that fails, fall back
726 * to reading directory contents.
727 */
728 /* XXX NH Why does this exist */
729 int
730 getcwd_common(struct vnode *, struct vnode *,
731 char **, char *, int, int, struct lwp *);
732
733 int
netbsd32___getcwd(struct lwp * l,const struct netbsd32___getcwd_args * uap,register_t * retval)734 netbsd32___getcwd(struct lwp *l, const struct netbsd32___getcwd_args *uap, register_t *retval)
735 {
736 /* {
737 syscallarg(char *) bufp;
738 syscallarg(size_t) length;
739 } */
740 struct proc *p = l->l_proc;
741 int error;
742 char *path;
743 char *bp, *bend;
744 int len = (int)SCARG(uap, length);
745 int lenused;
746 struct cwdinfo *cwdi;
747
748 if (len > MAXPATHLEN*4)
749 len = MAXPATHLEN*4;
750 else if (len < 2)
751 return ERANGE;
752
753 path = kmem_alloc(len, KM_SLEEP);
754 if (!path)
755 return ENOMEM;
756
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
netbsd32___mount50(struct lwp * l,const struct netbsd32___mount50_args * uap,register_t * retval)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 } fs_args32;
805 union {
806 struct ufs_args ufs_args;
807 struct mfs_args mfs_args;
808 struct iso_args iso_args;
809 struct nfs_args nfs_args;
810 struct msdosfs_args msdosfs_args;
811 struct tmpfs_args tmpfs_args;
812 } fs_args;
813 const char *type = SCARG_P32(uap, type);
814 const char *path = SCARG_P32(uap, path);
815 int flags = SCARG(uap, flags);
816 void *data = SCARG_P32(uap, data);
817 size_t data_len = SCARG(uap, data_len);
818 enum uio_seg data_seg;
819 size_t len;
820 int error;
821
822 error = copyinstr(type, mtype, sizeof(mtype), &len);
823 if (error)
824 return error;
825 if (strcmp(mtype, MOUNT_TMPFS) == 0) {
826 if (data_len != sizeof(fs_args32.tmpfs_args))
827 return EINVAL;
828 if ((flags & MNT_GETARGS) == 0) {
829 error = copyin(data, &fs_args32.tmpfs_args,
830 sizeof(fs_args32.tmpfs_args));
831 if (error)
832 return error;
833 fs_args.tmpfs_args.ta_version =
834 fs_args32.tmpfs_args.ta_version;
835 fs_args.tmpfs_args.ta_nodes_max =
836 fs_args32.tmpfs_args.ta_nodes_max;
837 fs_args.tmpfs_args.ta_size_max =
838 fs_args32.tmpfs_args.ta_size_max;
839 fs_args.tmpfs_args.ta_root_uid =
840 fs_args32.tmpfs_args.ta_root_uid;
841 fs_args.tmpfs_args.ta_root_gid =
842 fs_args32.tmpfs_args.ta_root_gid;
843 fs_args.tmpfs_args.ta_root_mode =
844 fs_args32.tmpfs_args.ta_root_mode;
845 }
846 data_seg = UIO_SYSSPACE;
847 data = &fs_args.tmpfs_args;
848 data_len = sizeof(fs_args.tmpfs_args);
849 } else if (strcmp(mtype, MOUNT_MFS) == 0) {
850 if (data_len != sizeof(fs_args32.mfs_args))
851 return EINVAL;
852 if ((flags & MNT_GETARGS) == 0) {
853 error = copyin(data, &fs_args32.mfs_args,
854 sizeof(fs_args32.mfs_args));
855 if (error)
856 return error;
857 fs_args.mfs_args.fspec =
858 NETBSD32PTR64(fs_args32.mfs_args.fspec);
859 memset(&fs_args.mfs_args._pad1, 0,
860 sizeof(fs_args.mfs_args._pad1));
861 fs_args.mfs_args.base =
862 NETBSD32PTR64(fs_args32.mfs_args.base);
863 fs_args.mfs_args.size = fs_args32.mfs_args.size;
864 }
865 data_seg = UIO_SYSSPACE;
866 data = &fs_args.mfs_args;
867 data_len = sizeof(fs_args.mfs_args);
868 } else if ((strcmp(mtype, MOUNT_UFS) == 0) ||
869 (strcmp(mtype, MOUNT_EXT2FS) == 0) ||
870 (strcmp(mtype, MOUNT_LFS) == 0)) {
871 if (data_len > sizeof(fs_args32.ufs_args))
872 return EINVAL;
873 if ((flags & MNT_GETARGS) == 0) {
874 error = copyin(data, &fs_args32.ufs_args,
875 sizeof(fs_args32.ufs_args));
876 if (error)
877 return error;
878 fs_args.ufs_args.fspec =
879 NETBSD32PTR64(fs_args32.ufs_args.fspec);
880 }
881 data_seg = UIO_SYSSPACE;
882 data = &fs_args.ufs_args;
883 data_len = sizeof(fs_args.ufs_args);
884 } else if (strcmp(mtype, MOUNT_CD9660) == 0) {
885 if (data_len != sizeof(fs_args32.iso_args))
886 return EINVAL;
887 if ((flags & MNT_GETARGS) == 0) {
888 error = copyin(data, &fs_args32.iso_args,
889 sizeof(fs_args32.iso_args));
890 if (error)
891 return error;
892 fs_args.iso_args.fspec =
893 NETBSD32PTR64(fs_args32.iso_args.fspec);
894 memset(&fs_args.iso_args._pad1, 0,
895 sizeof(fs_args.iso_args._pad1));
896 fs_args.iso_args.flags = fs_args32.iso_args.flags;
897 }
898 data_seg = UIO_SYSSPACE;
899 data = &fs_args.iso_args;
900 data_len = sizeof(fs_args.iso_args);
901 } else if (strcmp(mtype, MOUNT_MSDOS) == 0) {
902 if (data_len != sizeof(fs_args32.msdosfs_args))
903 return EINVAL;
904 if ((flags & MNT_GETARGS) == 0) {
905 error = copyin(data, &fs_args32.msdosfs_args,
906 sizeof(fs_args32.msdosfs_args));
907 if (error)
908 return error;
909 fs_args.msdosfs_args.fspec =
910 NETBSD32PTR64(fs_args32.msdosfs_args.fspec);
911 memset(&fs_args.msdosfs_args._pad1, 0,
912 sizeof(fs_args.msdosfs_args._pad1));
913 fs_args.msdosfs_args.uid =
914 fs_args32.msdosfs_args.uid;
915 fs_args.msdosfs_args.gid =
916 fs_args32.msdosfs_args.gid;
917 fs_args.msdosfs_args.mask =
918 fs_args32.msdosfs_args.mask;
919 fs_args.msdosfs_args.flags =
920 fs_args32.msdosfs_args.flags;
921 fs_args.msdosfs_args.version =
922 fs_args32.msdosfs_args.version;
923 fs_args.msdosfs_args.dirmask =
924 fs_args32.msdosfs_args.dirmask;
925 fs_args.msdosfs_args.gmtoff =
926 fs_args32.msdosfs_args.gmtoff;
927 }
928 data_seg = UIO_SYSSPACE;
929 data = &fs_args.msdosfs_args;
930 data_len = sizeof(fs_args.msdosfs_args);
931 } else if (strcmp(mtype, MOUNT_NFS) == 0) {
932 if (data_len != sizeof(fs_args32.nfs_args))
933 return EINVAL;
934 if ((flags & MNT_GETARGS) == 0) {
935 error = copyin(data, &fs_args32.nfs_args,
936 sizeof(fs_args32.nfs_args));
937 if (error)
938 return error;
939 fs_args.nfs_args.version = fs_args32.nfs_args.version;
940 fs_args.nfs_args.addr =
941 NETBSD32PTR64(fs_args32.nfs_args.addr);
942 memcpy(&fs_args.nfs_args.addrlen,
943 &fs_args32.nfs_args.addrlen,
944 offsetof(struct nfs_args, fh)
945 - offsetof(struct nfs_args, addrlen));
946 fs_args.nfs_args.fh =
947 NETBSD32PTR64(fs_args32.nfs_args.fh);
948 memcpy(&fs_args.nfs_args.fhsize,
949 &fs_args32.nfs_args.fhsize,
950 offsetof(struct nfs_args, hostname)
951 - offsetof(struct nfs_args, fhsize));
952 fs_args.nfs_args.hostname =
953 NETBSD32PTR64(fs_args32.nfs_args.hostname);
954 }
955 data_seg = UIO_SYSSPACE;
956 data = &fs_args.nfs_args;
957 data_len = sizeof(fs_args.nfs_args);
958 } else {
959 data_seg = UIO_USERSPACE;
960 }
961 error = do_sys_mount(l, mtype, UIO_SYSSPACE, path, flags, data, data_seg,
962 data_len, retval);
963 if (error)
964 return error;
965 if (flags & MNT_GETARGS) {
966 data_len = *retval;
967 if (strcmp(mtype, MOUNT_TMPFS) == 0) {
968 if (data_len != sizeof(fs_args.tmpfs_args))
969 return EINVAL;
970 fs_args32.tmpfs_args.ta_version =
971 fs_args.tmpfs_args.ta_version;
972 fs_args32.tmpfs_args.ta_nodes_max =
973 fs_args.tmpfs_args.ta_nodes_max;
974 fs_args32.tmpfs_args.ta_size_max =
975 fs_args.tmpfs_args.ta_size_max;
976 fs_args32.tmpfs_args.ta_root_uid =
977 fs_args.tmpfs_args.ta_root_uid;
978 fs_args32.tmpfs_args.ta_root_gid =
979 fs_args.tmpfs_args.ta_root_gid;
980 fs_args32.tmpfs_args.ta_root_mode =
981 fs_args.tmpfs_args.ta_root_mode;
982 error = copyout(&fs_args32.tmpfs_args, data,
983 sizeof(fs_args32.tmpfs_args));
984 } else if (strcmp(mtype, MOUNT_MFS) == 0) {
985 if (data_len != sizeof(fs_args.mfs_args))
986 return EINVAL;
987 NETBSD32PTR32(fs_args32.mfs_args.fspec,
988 fs_args.mfs_args.fspec);
989 memset(&fs_args32.mfs_args._pad1, 0,
990 sizeof(fs_args32.mfs_args._pad1));
991 NETBSD32PTR32(fs_args32.mfs_args.base,
992 fs_args.mfs_args.base);
993 fs_args32.mfs_args.size = fs_args.mfs_args.size;
994 error = copyout(&fs_args32.mfs_args, data,
995 sizeof(fs_args32.mfs_args));
996 } else if (strcmp(mtype, MOUNT_UFS) == 0) {
997 if (data_len != sizeof(fs_args.ufs_args))
998 return EINVAL;
999 NETBSD32PTR32(fs_args32.ufs_args.fspec,
1000 fs_args.ufs_args.fspec);
1001 error = copyout(&fs_args32.ufs_args, data,
1002 sizeof(fs_args32.ufs_args));
1003 } else if (strcmp(mtype, MOUNT_CD9660) == 0) {
1004 if (data_len != sizeof(fs_args.iso_args))
1005 return EINVAL;
1006 NETBSD32PTR32(fs_args32.iso_args.fspec,
1007 fs_args.iso_args.fspec);
1008 memset(&fs_args32.iso_args._pad1, 0,
1009 sizeof(fs_args32.iso_args._pad1));
1010 fs_args32.iso_args.flags = fs_args.iso_args.flags;
1011 error = copyout(&fs_args32.iso_args, data,
1012 sizeof(fs_args32.iso_args));
1013 } else if (strcmp(mtype, MOUNT_NFS) == 0) {
1014 if (data_len != sizeof(fs_args.nfs_args))
1015 return EINVAL;
1016 error = copyin(data, &fs_args32.nfs_args,
1017 sizeof(fs_args32.nfs_args));
1018 if (error)
1019 return error;
1020 fs_args.nfs_args.version = fs_args32.nfs_args.version;
1021 NETBSD32PTR32(fs_args32.nfs_args.addr,
1022 fs_args.nfs_args.addr);
1023 memcpy(&fs_args32.nfs_args.addrlen,
1024 &fs_args.nfs_args.addrlen,
1025 offsetof(struct nfs_args, fh)
1026 - offsetof(struct nfs_args, addrlen));
1027 NETBSD32PTR32(fs_args32.nfs_args.fh,
1028 fs_args.nfs_args.fh);
1029 memcpy(&fs_args32.nfs_args.fhsize,
1030 &fs_args.nfs_args.fhsize,
1031 offsetof(struct nfs_args, hostname)
1032 - offsetof(struct nfs_args, fhsize));
1033 NETBSD32PTR32(fs_args32.nfs_args.hostname,
1034 fs_args.nfs_args.hostname);
1035 error = copyout(&fs_args32.nfs_args, data,
1036 sizeof(fs_args32.nfs_args));
1037 }
1038 }
1039 return error;
1040 }
1041
1042 int
netbsd32_linkat(struct lwp * l,const struct netbsd32_linkat_args * uap,register_t * retval)1043 netbsd32_linkat(struct lwp *l, const struct netbsd32_linkat_args *uap,
1044 register_t *retval)
1045 {
1046 /* {
1047 syscallarg(int) fd1;
1048 syscallarg(const netbsd32_charp) name1;
1049 syscallarg(int) fd2;
1050 syscallarg(const netbsd32_charp) name2;
1051 syscallarg(int) flags;
1052 } */
1053 struct sys_linkat_args ua;
1054
1055 NETBSD32TO64_UAP(fd1);
1056 NETBSD32TOP_UAP(name1, const char);
1057 NETBSD32TO64_UAP(fd2);
1058 NETBSD32TOP_UAP(name2, const char);
1059 NETBSD32TO64_UAP(flags);
1060
1061 return sys_linkat(l, &ua, retval);
1062 }
1063
1064 int
netbsd32_renameat(struct lwp * l,const struct netbsd32_renameat_args * uap,register_t * retval)1065 netbsd32_renameat(struct lwp *l, const struct netbsd32_renameat_args *uap,
1066 register_t *retval)
1067 {
1068 /* {
1069 syscallarg(int) fromfd;
1070 syscallarg(const netbsd32_charp) from;
1071 syscallarg(int) tofd;
1072 syscallarg(const netbsd32_charp) to;
1073 } */
1074 struct sys_renameat_args ua;
1075
1076 NETBSD32TO64_UAP(fromfd);
1077 NETBSD32TOP_UAP(from, const char);
1078 NETBSD32TO64_UAP(tofd);
1079 NETBSD32TOP_UAP(to, const char);
1080
1081 return sys_renameat(l, &ua, retval);
1082 }
1083
1084 int
netbsd32_mkfifoat(struct lwp * l,const struct netbsd32_mkfifoat_args * uap,register_t * retval)1085 netbsd32_mkfifoat(struct lwp *l, const struct netbsd32_mkfifoat_args *uap,
1086 register_t *retval)
1087 {
1088 /* {
1089 syscallarg(int) fd;
1090 syscallarg(const netbsd32_charp) path;
1091 syscallarg(mode_t) mode;
1092 } */
1093 struct sys_mkfifoat_args ua;
1094
1095 NETBSD32TO64_UAP(fd);
1096 NETBSD32TOP_UAP(path, const char);
1097 NETBSD32TO64_UAP(mode);
1098
1099 return sys_mkfifoat(l, &ua, retval);
1100 }
1101
1102 int
netbsd32_mknodat(struct lwp * l,const struct netbsd32_mknodat_args * uap,register_t * retval)1103 netbsd32_mknodat(struct lwp *l, const struct netbsd32_mknodat_args *uap,
1104 register_t *retval)
1105 {
1106 /* {
1107 syscallarg(int) fd;
1108 syscallarg(netbsd32_charp) path;
1109 syscallarg(mode_t) mode;
1110 syscallarg(int) pad;
1111 syscallarg(netbsd32_dev_t) dev;
1112 } */
1113 struct sys_mknodat_args ua;
1114
1115 NETBSD32TO64_UAP(fd);
1116 NETBSD32TOP_UAP(path, const char);
1117 NETBSD32TO64_UAP(mode);
1118 NETBSD32TO64_UAP(PAD);
1119 NETBSD32TO64_UAP(dev);
1120
1121 return sys_mknodat(l, &ua, retval);
1122 }
1123
1124 int
netbsd32_mkdirat(struct lwp * l,const struct netbsd32_mkdirat_args * uap,register_t * retval)1125 netbsd32_mkdirat(struct lwp *l, const struct netbsd32_mkdirat_args *uap,
1126 register_t *retval)
1127 {
1128 /* {
1129 syscallarg(int) fd;
1130 syscallarg(netbsd32_charp) path;
1131 syscallarg(mode_t) mode;
1132 } */
1133 struct sys_mkdirat_args ua;
1134
1135 NETBSD32TO64_UAP(fd);
1136 NETBSD32TOP_UAP(path, const char);
1137 NETBSD32TO64_UAP(mode);
1138
1139 return sys_mkdirat(l, &ua, retval);
1140 }
1141
1142 int
netbsd32_faccessat(struct lwp * l,const struct netbsd32_faccessat_args * uap,register_t * retval)1143 netbsd32_faccessat(struct lwp *l, const struct netbsd32_faccessat_args *uap,
1144 register_t *retval)
1145 {
1146 /* {
1147 syscallarg(int) fd;
1148 syscallarg(netbsd32_charp) path;
1149 syscallarg(int) amode;
1150 syscallarg(int) flag;
1151 } */
1152 struct sys_faccessat_args ua;
1153
1154 NETBSD32TO64_UAP(fd);
1155 NETBSD32TOP_UAP(path, const char);
1156 NETBSD32TO64_UAP(amode);
1157 NETBSD32TO64_UAP(flag);
1158
1159 return sys_faccessat(l, &ua, retval);
1160 }
1161
1162 int
netbsd32_fchmodat(struct lwp * l,const struct netbsd32_fchmodat_args * uap,register_t * retval)1163 netbsd32_fchmodat(struct lwp *l, const struct netbsd32_fchmodat_args *uap,
1164 register_t *retval)
1165 {
1166 /* {
1167 syscallarg(int) fd;
1168 syscallarg(netbsd32_charp) path;
1169 syscallarg(mode_t) mode;
1170 syscallarg(int) flag;
1171 } */
1172 struct sys_fchmodat_args ua;
1173
1174 NETBSD32TO64_UAP(fd);
1175 NETBSD32TOP_UAP(path, const char);
1176 NETBSD32TO64_UAP(mode);
1177 NETBSD32TO64_UAP(flag);
1178
1179 return sys_fchmodat(l, &ua, retval);
1180 }
1181
1182 int
netbsd32_fchownat(struct lwp * l,const struct netbsd32_fchownat_args * uap,register_t * retval)1183 netbsd32_fchownat(struct lwp *l, const struct netbsd32_fchownat_args *uap,
1184 register_t *retval)
1185 {
1186 /* {
1187 syscallarg(int) fd;
1188 syscallarg(netbsd32_charp) path;
1189 syscallarg(uid_t) owner;
1190 syscallarg(gid_t) group;
1191 syscallarg(int) flag;
1192 } */
1193 struct sys_fchownat_args ua;
1194
1195 NETBSD32TO64_UAP(fd);
1196 NETBSD32TOP_UAP(path, const char);
1197 NETBSD32TO64_UAP(owner);
1198 NETBSD32TO64_UAP(group);
1199 NETBSD32TO64_UAP(flag);
1200
1201 return sys_fchownat(l, &ua, retval);
1202 }
1203
1204 int
netbsd32_fstatat(struct lwp * l,const struct netbsd32_fstatat_args * uap,register_t * retval)1205 netbsd32_fstatat(struct lwp *l, const struct netbsd32_fstatat_args *uap,
1206 register_t *retval)
1207 {
1208 /* {
1209 syscallarg(int) fd;
1210 syscallarg(netbsd32_charp) path;
1211 syscallarg(netbsd32_statp_t) buf;
1212 syscallarg(int) flag;
1213 } */
1214 struct netbsd32_stat sb32;
1215 struct stat sb;
1216 int follow;
1217 int error;
1218
1219 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
1220
1221 error = do_sys_statat(l, SCARG(uap, fd), SCARG_P32(uap, path),
1222 follow, &sb);
1223 if (error)
1224 return error;
1225 netbsd32_from_stat(&sb, &sb32);
1226 return copyout(&sb32, SCARG_P32(uap, buf), sizeof(sb32));
1227 }
1228
1229 int
netbsd32_utimensat(struct lwp * l,const struct netbsd32_utimensat_args * uap,register_t * retval)1230 netbsd32_utimensat(struct lwp *l, const struct netbsd32_utimensat_args *uap,
1231 register_t *retval)
1232 {
1233 /* {
1234 syscallarg(int) fd;
1235 syscallarg(netbsd32_charp) path;
1236 syscallarg(netbsd32_timespecp_t) tptr;
1237 syscallarg(int) flag;
1238 } */
1239 struct timespec ts[2], *tsp = NULL /* XXXgcc */;
1240 int follow;
1241 int error;
1242
1243 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp);
1244 if (error != 0)
1245 return error;
1246
1247 follow = (SCARG(uap, flag) & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
1248
1249 return do_sys_utimensat(l, SCARG(uap, fd), NULL,
1250 SCARG_P32(uap, path), follow, tsp, UIO_SYSSPACE);
1251 }
1252
1253 int
netbsd32_openat(struct lwp * l,const struct netbsd32_openat_args * uap,register_t * retval)1254 netbsd32_openat(struct lwp *l, const struct netbsd32_openat_args *uap,
1255 register_t *retval)
1256 {
1257 /* {
1258 syscallarg(int) fd;
1259 syscallarg(netbsd32_charp) path;
1260 syscallarg(int) oflags;
1261 syscallarg(mode_t) mode;
1262 } */
1263 struct sys_openat_args ua;
1264
1265 NETBSD32TO64_UAP(fd);
1266 NETBSD32TOP_UAP(path, const char);
1267 NETBSD32TO64_UAP(oflags);
1268 NETBSD32TO64_UAP(mode);
1269
1270 return sys_openat(l, &ua, retval);
1271 }
1272
1273 int
netbsd32_readlinkat(struct lwp * l,const struct netbsd32_readlinkat_args * uap,register_t * retval)1274 netbsd32_readlinkat(struct lwp *l, const struct netbsd32_readlinkat_args *uap,
1275 register_t *retval)
1276 {
1277 /* {
1278 syscallarg(int) fd;
1279 syscallarg(netbsd32_charp) path;
1280 syscallarg(netbsd32_charp) buf;
1281 syscallarg(netbsd32_size_t) bufsize;
1282 } */
1283 struct sys_readlinkat_args ua;
1284
1285 NETBSD32TO64_UAP(fd);
1286 NETBSD32TOP_UAP(path, const char *);
1287 NETBSD32TOP_UAP(buf, char *);
1288 NETBSD32TOX_UAP(bufsize, size_t);
1289
1290 return sys_readlinkat(l, &ua, retval);
1291 }
1292
1293 int
netbsd32_symlinkat(struct lwp * l,const struct netbsd32_symlinkat_args * uap,register_t * retval)1294 netbsd32_symlinkat(struct lwp *l, const struct netbsd32_symlinkat_args *uap,
1295 register_t *retval)
1296 {
1297 /* {
1298 syscallarg(netbsd32_charp) path1;
1299 syscallarg(int) fd;
1300 syscallarg(netbsd32_charp) path2;
1301 } */
1302 struct sys_symlinkat_args ua;
1303
1304 NETBSD32TOP_UAP(path1, const char *);
1305 NETBSD32TO64_UAP(fd);
1306 NETBSD32TOP_UAP(path2, const char *);
1307
1308 return sys_symlinkat(l, &ua, retval);
1309 }
1310
1311 int
netbsd32_unlinkat(struct lwp * l,const struct netbsd32_unlinkat_args * uap,register_t * retval)1312 netbsd32_unlinkat(struct lwp *l, const struct netbsd32_unlinkat_args *uap,
1313 register_t *retval)
1314 {
1315 /* {
1316 syscallarg(int) fd;
1317 syscallarg(netbsd32_charp) path;
1318 syscallarg(int) flag;
1319 } */
1320 struct sys_unlinkat_args ua;
1321
1322 NETBSD32TO64_UAP(fd);
1323 NETBSD32TOP_UAP(path, const char *);
1324 NETBSD32TO64_UAP(flag);
1325
1326 return sys_unlinkat(l, &ua, retval);
1327 }
1328
1329 int
netbsd32_futimens(struct lwp * l,const struct netbsd32_futimens_args * uap,register_t * retval)1330 netbsd32_futimens(struct lwp *l, const struct netbsd32_futimens_args *uap,
1331 register_t *retval)
1332 {
1333 /* {
1334 syscallarg(int) fd;
1335 syscallarg(netbsd32_timespecp_t) tptr;
1336 } */
1337 struct timespec ts[2], *tsp = NULL /* XXXgcc */;
1338 file_t *fp;
1339 int error;
1340
1341 error = get_utimens32(SCARG_P32(uap, tptr), ts, &tsp);
1342 if (error != 0)
1343 return error;
1344
1345 /* fd_getvnode() will use the descriptor for us */
1346 if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
1347 return (error);
1348 error = do_sys_utimensat(l, AT_FDCWD, fp->f_vnode, NULL, 0,
1349 tsp, UIO_SYSSPACE);
1350 fd_putfile(SCARG(uap, fd));
1351 return (error);
1352 }
1353