1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1994-1995 Søren Schmidt
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 AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, 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 __FBSDID("$FreeBSD$");
31
32 #include "opt_compat.h"
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/capsicum.h>
37 #include <sys/conf.h>
38 #include <sys/dirent.h>
39 #include <sys/fcntl.h>
40 #include <sys/file.h>
41 #include <sys/filedesc.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/mman.h>
45 #include <sys/mount.h>
46 #include <sys/mutex.h>
47 #include <sys/namei.h>
48 #include <sys/proc.h>
49 #include <sys/stat.h>
50 #include <sys/sx.h>
51 #include <sys/syscallsubr.h>
52 #include <sys/sysproto.h>
53 #include <sys/tty.h>
54 #include <sys/unistd.h>
55 #include <sys/vnode.h>
56
57 #ifdef COMPAT_LINUX32
58 #include <compat/freebsd32/freebsd32_misc.h>
59 #include <machine/../linux32/linux.h>
60 #include <machine/../linux32/linux32_proto.h>
61 #else
62 #include <machine/../linux/linux.h>
63 #include <machine/../linux/linux_proto.h>
64 #endif
65 #include <compat/linux/linux_misc.h>
66 #include <compat/linux/linux_util.h>
67 #include <compat/linux/linux_file.h>
68
69 static int linux_common_open(struct thread *, int, const char *, int, int,
70 enum uio_seg);
71 static int linux_getdents_error(struct thread *, int, int);
72
73 static struct bsd_to_linux_bitmap seal_bitmap[] = {
74 BITMAP_1t1_LINUX(F_SEAL_SEAL),
75 BITMAP_1t1_LINUX(F_SEAL_SHRINK),
76 BITMAP_1t1_LINUX(F_SEAL_GROW),
77 BITMAP_1t1_LINUX(F_SEAL_WRITE),
78 };
79
80 #define MFD_HUGETLB_ENTRY(_size) \
81 { \
82 .bsd_value = MFD_HUGE_##_size, \
83 .linux_value = LINUX_HUGETLB_FLAG_ENCODE_##_size \
84 }
85 static struct bsd_to_linux_bitmap mfd_bitmap[] = {
86 BITMAP_1t1_LINUX(MFD_CLOEXEC),
87 BITMAP_1t1_LINUX(MFD_ALLOW_SEALING),
88 BITMAP_1t1_LINUX(MFD_HUGETLB),
89 MFD_HUGETLB_ENTRY(64KB),
90 MFD_HUGETLB_ENTRY(512KB),
91 MFD_HUGETLB_ENTRY(1MB),
92 MFD_HUGETLB_ENTRY(2MB),
93 MFD_HUGETLB_ENTRY(8MB),
94 MFD_HUGETLB_ENTRY(16MB),
95 MFD_HUGETLB_ENTRY(32MB),
96 MFD_HUGETLB_ENTRY(256MB),
97 MFD_HUGETLB_ENTRY(512MB),
98 MFD_HUGETLB_ENTRY(1GB),
99 MFD_HUGETLB_ENTRY(2GB),
100 MFD_HUGETLB_ENTRY(16GB),
101 };
102 #undef MFD_HUGETLB_ENTRY
103
104 #ifdef LINUX_LEGACY_SYSCALLS
105 int
106 linux_creat(struct thread *td, struct linux_creat_args *args)
107 {
108 char *path;
109 int error;
110
111 if (!LUSECONVPATH(td)) {
112 return (kern_openat(td, AT_FDCWD, args->path, UIO_USERSPACE,
113 O_WRONLY | O_CREAT | O_TRUNC, args->mode));
114 }
115 LCONVPATHEXIST(td, args->path, &path);
116 error = kern_openat(td, AT_FDCWD, path, UIO_SYSSPACE,
117 O_WRONLY | O_CREAT | O_TRUNC, args->mode);
118 LFREEPATH(path);
119 return (error);
120 }
121 #endif
122
123 static int
124 linux_common_openflags(int l_flags)
125 {
126 int bsd_flags;
127
128 bsd_flags = 0;
129 switch (l_flags & LINUX_O_ACCMODE) {
130 case LINUX_O_WRONLY:
131 bsd_flags |= O_WRONLY;
132 break;
133 case LINUX_O_RDWR:
134 bsd_flags |= O_RDWR;
135 break;
136 default:
137 bsd_flags |= O_RDONLY;
138 }
139 if (l_flags & LINUX_O_NDELAY)
140 bsd_flags |= O_NONBLOCK;
141 if (l_flags & LINUX_O_APPEND)
142 bsd_flags |= O_APPEND;
143 if (l_flags & LINUX_O_SYNC)
144 bsd_flags |= O_FSYNC;
145 if (l_flags & LINUX_O_CLOEXEC)
146 bsd_flags |= O_CLOEXEC;
147 if (l_flags & LINUX_O_NONBLOCK)
148 bsd_flags |= O_NONBLOCK;
149 if (l_flags & LINUX_O_ASYNC)
150 bsd_flags |= O_ASYNC;
151 if (l_flags & LINUX_O_CREAT)
152 bsd_flags |= O_CREAT;
153 if (l_flags & LINUX_O_TRUNC)
154 bsd_flags |= O_TRUNC;
155 if (l_flags & LINUX_O_EXCL)
156 bsd_flags |= O_EXCL;
157 if (l_flags & LINUX_O_NOCTTY)
158 bsd_flags |= O_NOCTTY;
159 if (l_flags & LINUX_O_DIRECT)
160 bsd_flags |= O_DIRECT;
161 if (l_flags & LINUX_O_NOFOLLOW)
162 bsd_flags |= O_NOFOLLOW;
163 if (l_flags & LINUX_O_DIRECTORY)
164 bsd_flags |= O_DIRECTORY;
165 /* XXX LINUX_O_NOATIME: unable to be easily implemented. */
166 return (bsd_flags);
167 }
168
169 static int
170 linux_common_open(struct thread *td, int dirfd, const char *path, int l_flags,
171 int mode, enum uio_seg seg)
172 {
173 struct proc *p = td->td_proc;
174 struct file *fp;
175 int fd;
176 int bsd_flags, error;
177
178 bsd_flags = linux_common_openflags(l_flags);
179 error = kern_openat(td, dirfd, path, seg, bsd_flags, mode);
180 if (error != 0) {
181 if (error == EMLINK)
182 error = ELOOP;
183 goto done;
184 }
185 if (p->p_flag & P_CONTROLT)
186 goto done;
187 if (bsd_flags & O_NOCTTY)
188 goto done;
189
190 /*
191 * XXX In between kern_openat() and fget(), another process
192 * having the same filedesc could use that fd without
193 * checking below.
194 */
195 fd = td->td_retval[0];
196 if (fget(td, fd, &cap_ioctl_rights, &fp) == 0) {
197 if (fp->f_type != DTYPE_VNODE) {
198 fdrop(fp, td);
199 goto done;
200 }
201 sx_slock(&proctree_lock);
202 PROC_LOCK(p);
203 if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
204 PROC_UNLOCK(p);
205 sx_sunlock(&proctree_lock);
206 /* XXXPJD: Verify if TIOCSCTTY is allowed. */
207 (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0,
208 td->td_ucred, td);
209 } else {
210 PROC_UNLOCK(p);
211 sx_sunlock(&proctree_lock);
212 }
213 fdrop(fp, td);
214 }
215
216 done:
217 return (error);
218 }
219
220 int
221 linux_openat(struct thread *td, struct linux_openat_args *args)
222 {
223 char *path;
224 int dfd, error;
225
226 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
227 if (!LUSECONVPATH(td)) {
228 return (linux_common_open(td, dfd, args->filename, args->flags,
229 args->mode, UIO_USERSPACE));
230 }
231 if (args->flags & LINUX_O_CREAT)
232 LCONVPATH_AT(td, args->filename, &path, 1, dfd);
233 else
234 LCONVPATH_AT(td, args->filename, &path, 0, dfd);
235
236 error = linux_common_open(td, dfd, path, args->flags, args->mode,
237 UIO_SYSSPACE);
238 LFREEPATH(path);
239 return (error);
240 }
241
242 #ifdef LINUX_LEGACY_SYSCALLS
243 int
244 linux_open(struct thread *td, struct linux_open_args *args)
245 {
246 char *path;
247 int error;
248
249 if (!LUSECONVPATH(td)) {
250 return (linux_common_open(td, AT_FDCWD, args->path, args->flags,
251 args->mode, UIO_USERSPACE));
252 }
253 if (args->flags & LINUX_O_CREAT)
254 LCONVPATHCREAT(td, args->path, &path);
255 else
256 LCONVPATHEXIST(td, args->path, &path);
257
258 error = linux_common_open(td, AT_FDCWD, path, args->flags, args->mode,
259 UIO_SYSSPACE);
260 LFREEPATH(path);
261 return (error);
262 }
263 #endif
264
265 int
266 linux_name_to_handle_at(struct thread *td,
267 struct linux_name_to_handle_at_args *args)
268 {
269 static const l_int valid_flags = (LINUX_AT_SYMLINK_FOLLOW |
270 LINUX_AT_EMPTY_PATH);
271 static const l_uint fh_size = sizeof(fhandle_t);
272
273 fhandle_t fh;
274 l_uint fh_bytes;
275 l_int mount_id;
276 int error, fd, bsd_flags;
277
278 if (args->flags & ~valid_flags)
279 return (EINVAL);
280 if (args->flags & LINUX_AT_EMPTY_PATH)
281 /* XXX: not supported yet */
282 return (EOPNOTSUPP);
283
284 fd = args->dirfd;
285 if (fd == LINUX_AT_FDCWD)
286 fd = AT_FDCWD;
287
288 bsd_flags = 0;
289 if (!(args->flags & LINUX_AT_SYMLINK_FOLLOW))
290 bsd_flags |= AT_SYMLINK_NOFOLLOW;
291
292 if (!LUSECONVPATH(td)) {
293 error = kern_getfhat(td, bsd_flags, fd, args->name,
294 UIO_USERSPACE, &fh, UIO_SYSSPACE);
295 } else {
296 char *path;
297
298 LCONVPATH_AT(td, args->name, &path, 0, fd);
299 error = kern_getfhat(td, bsd_flags, fd, path, UIO_SYSSPACE,
300 &fh, UIO_SYSSPACE);
301 LFREEPATH(path);
302 }
303 if (error != 0)
304 return (error);
305
306 /* Emit mount_id -- required before EOVERFLOW case. */
307 mount_id = (fh.fh_fsid.val[0] ^ fh.fh_fsid.val[1]);
308 error = copyout(&mount_id, args->mnt_id, sizeof(mount_id));
309 if (error != 0)
310 return (error);
311
312 /* Check if there is room for handle. */
313 error = copyin(&args->handle->handle_bytes, &fh_bytes,
314 sizeof(fh_bytes));
315 if (error != 0)
316 return (error);
317
318 if (fh_bytes < fh_size) {
319 error = copyout(&fh_size, &args->handle->handle_bytes,
320 sizeof(fh_size));
321 if (error == 0)
322 error = EOVERFLOW;
323 return (error);
324 }
325
326 /* Emit handle. */
327 mount_id = 0;
328 /*
329 * We don't use handle_type for anything yet, but initialize a known
330 * value.
331 */
332 error = copyout(&mount_id, &args->handle->handle_type,
333 sizeof(mount_id));
334 if (error != 0)
335 return (error);
336
337 error = copyout(&fh, &args->handle->f_handle,
338 sizeof(fh));
339 return (error);
340 }
341
342 int
343 linux_open_by_handle_at(struct thread *td,
344 struct linux_open_by_handle_at_args *args)
345 {
346 l_uint fh_bytes;
347 int bsd_flags, error;
348
349 error = copyin(&args->handle->handle_bytes, &fh_bytes,
350 sizeof(fh_bytes));
351 if (error != 0)
352 return (error);
353
354 if (fh_bytes < sizeof(fhandle_t))
355 return (EINVAL);
356
357 bsd_flags = linux_common_openflags(args->flags);
358 return (kern_fhopen(td, (void *)&args->handle->f_handle, bsd_flags));
359 }
360
361 int
362 linux_lseek(struct thread *td, struct linux_lseek_args *args)
363 {
364
365 return (kern_lseek(td, args->fdes, args->off, args->whence));
366 }
367
368 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
369 int
370 linux_llseek(struct thread *td, struct linux_llseek_args *args)
371 {
372 int error;
373 off_t off;
374
375 off = (args->olow) | (((off_t) args->ohigh) << 32);
376
377 error = kern_lseek(td, args->fd, off, args->whence);
378 if (error != 0)
379 return (error);
380
381 error = copyout(td->td_retval, args->res, sizeof(off_t));
382 if (error != 0)
383 return (error);
384
385 td->td_retval[0] = 0;
386 return (0);
387 }
388 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
389
390 /*
391 * Note that linux_getdents(2) and linux_getdents64(2) have the same
392 * arguments. They only differ in the definition of struct dirent they
393 * operate on.
394 * Note that linux_readdir(2) is a special case of linux_getdents(2)
395 * where count is always equals 1, meaning that the buffer is one
396 * dirent-structure in size and that the code can't handle more anyway.
397 * Note that linux_readdir(2) can't be implemented by means of linux_getdents(2)
398 * as in case when the *dent buffer size is equal to 1 linux_getdents(2) will
399 * trash user stack.
400 */
401
402 static int
403 linux_getdents_error(struct thread *td, int fd, int err)
404 {
405 struct vnode *vp;
406 struct file *fp;
407 int error;
408
409 /* Linux return ENOTDIR in case when fd is not a directory. */
410 error = getvnode(td, fd, &cap_read_rights, &fp);
411 if (error != 0)
412 return (error);
413 vp = fp->f_vnode;
414 if (vp->v_type != VDIR) {
415 fdrop(fp, td);
416 return (ENOTDIR);
417 }
418 fdrop(fp, td);
419 return (err);
420 }
421
422 struct l_dirent {
423 l_ulong d_ino;
424 l_off_t d_off;
425 l_ushort d_reclen;
426 char d_name[LINUX_NAME_MAX + 1];
427 };
428
429 struct l_dirent64 {
430 uint64_t d_ino;
431 int64_t d_off;
432 l_ushort d_reclen;
433 u_char d_type;
434 char d_name[LINUX_NAME_MAX + 1];
435 };
436
437 /*
438 * Linux uses the last byte in the dirent buffer to store d_type,
439 * at least glibc-2.7 requires it. That is why l_dirent is padded with 2 bytes.
440 */
441 #define LINUX_RECLEN(namlen) \
442 roundup(offsetof(struct l_dirent, d_name) + (namlen) + 2, sizeof(l_ulong))
443
444 #define LINUX_RECLEN64(namlen) \
445 roundup(offsetof(struct l_dirent64, d_name) + (namlen) + 1, \
446 sizeof(uint64_t))
447
448 #ifdef LINUX_LEGACY_SYSCALLS
449 int
450 linux_getdents(struct thread *td, struct linux_getdents_args *args)
451 {
452 struct dirent *bdp;
453 caddr_t inp, buf; /* BSD-format */
454 int len, reclen; /* BSD-format */
455 caddr_t outp; /* Linux-format */
456 int resid, linuxreclen; /* Linux-format */
457 caddr_t lbuf; /* Linux-format */
458 off_t base;
459 struct l_dirent *linux_dirent;
460 int buflen, error;
461 size_t retval;
462
463 buflen = min(args->count, MAXBSIZE);
464 buf = malloc(buflen, M_TEMP, M_WAITOK);
465
466 error = kern_getdirentries(td, args->fd, buf, buflen,
467 &base, NULL, UIO_SYSSPACE);
468 if (error != 0) {
469 error = linux_getdents_error(td, args->fd, error);
470 goto out1;
471 }
472
473 lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO);
474
475 len = td->td_retval[0];
476 inp = buf;
477 outp = (caddr_t)args->dent;
478 resid = args->count;
479 retval = 0;
480
481 while (len > 0) {
482 bdp = (struct dirent *) inp;
483 reclen = bdp->d_reclen;
484 linuxreclen = LINUX_RECLEN(bdp->d_namlen);
485 /*
486 * No more space in the user supplied dirent buffer.
487 * Return EINVAL.
488 */
489 if (resid < linuxreclen) {
490 error = EINVAL;
491 goto out;
492 }
493
494 linux_dirent = (struct l_dirent*)lbuf;
495 linux_dirent->d_ino = bdp->d_fileno;
496 linux_dirent->d_off = base + reclen;
497 linux_dirent->d_reclen = linuxreclen;
498 /*
499 * Copy d_type to last byte of l_dirent buffer
500 */
501 lbuf[linuxreclen - 1] = bdp->d_type;
502 strlcpy(linux_dirent->d_name, bdp->d_name,
503 linuxreclen - offsetof(struct l_dirent, d_name)-1);
504 error = copyout(linux_dirent, outp, linuxreclen);
505 if (error != 0)
506 goto out;
507
508 inp += reclen;
509 base += reclen;
510 len -= reclen;
511
512 retval += linuxreclen;
513 outp += linuxreclen;
514 resid -= linuxreclen;
515 }
516 td->td_retval[0] = retval;
517
518 out:
519 free(lbuf, M_TEMP);
520 out1:
521 free(buf, M_TEMP);
522 return (error);
523 }
524 #endif
525
526 int
527 linux_getdents64(struct thread *td, struct linux_getdents64_args *args)
528 {
529 struct dirent *bdp;
530 caddr_t inp, buf; /* BSD-format */
531 int len, reclen; /* BSD-format */
532 caddr_t outp; /* Linux-format */
533 int resid, linuxreclen; /* Linux-format */
534 caddr_t lbuf; /* Linux-format */
535 off_t base;
536 struct l_dirent64 *linux_dirent64;
537 int buflen, error;
538 size_t retval;
539
540 buflen = min(args->count, MAXBSIZE);
541 buf = malloc(buflen, M_TEMP, M_WAITOK);
542
543 error = kern_getdirentries(td, args->fd, buf, buflen,
544 &base, NULL, UIO_SYSSPACE);
545 if (error != 0) {
546 error = linux_getdents_error(td, args->fd, error);
547 goto out1;
548 }
549
550 lbuf = malloc(LINUX_RECLEN64(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO);
551
552 len = td->td_retval[0];
553 inp = buf;
554 outp = (caddr_t)args->dirent;
555 resid = args->count;
556 retval = 0;
557
558 while (len > 0) {
559 bdp = (struct dirent *) inp;
560 reclen = bdp->d_reclen;
561 linuxreclen = LINUX_RECLEN64(bdp->d_namlen);
562 /*
563 * No more space in the user supplied dirent buffer.
564 * Return EINVAL.
565 */
566 if (resid < linuxreclen) {
567 error = EINVAL;
568 goto out;
569 }
570
571 linux_dirent64 = (struct l_dirent64*)lbuf;
572 linux_dirent64->d_ino = bdp->d_fileno;
573 linux_dirent64->d_off = base + reclen;
574 linux_dirent64->d_reclen = linuxreclen;
575 linux_dirent64->d_type = bdp->d_type;
576 strlcpy(linux_dirent64->d_name, bdp->d_name,
577 linuxreclen - offsetof(struct l_dirent64, d_name));
578 error = copyout(linux_dirent64, outp, linuxreclen);
579 if (error != 0)
580 goto out;
581
582 inp += reclen;
583 base += reclen;
584 len -= reclen;
585
586 retval += linuxreclen;
587 outp += linuxreclen;
588 resid -= linuxreclen;
589 }
590 td->td_retval[0] = retval;
591
592 out:
593 free(lbuf, M_TEMP);
594 out1:
595 free(buf, M_TEMP);
596 return (error);
597 }
598
599 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
600 int
601 linux_readdir(struct thread *td, struct linux_readdir_args *args)
602 {
603 struct dirent *bdp;
604 caddr_t buf; /* BSD-format */
605 int linuxreclen; /* Linux-format */
606 caddr_t lbuf; /* Linux-format */
607 off_t base;
608 struct l_dirent *linux_dirent;
609 int buflen, error;
610
611 buflen = LINUX_RECLEN(LINUX_NAME_MAX);
612 buf = malloc(buflen, M_TEMP, M_WAITOK);
613
614 error = kern_getdirentries(td, args->fd, buf, buflen,
615 &base, NULL, UIO_SYSSPACE);
616 if (error != 0) {
617 error = linux_getdents_error(td, args->fd, error);
618 goto out;
619 }
620 if (td->td_retval[0] == 0)
621 goto out;
622
623 lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_TEMP, M_WAITOK | M_ZERO);
624
625 bdp = (struct dirent *) buf;
626 linuxreclen = LINUX_RECLEN(bdp->d_namlen);
627
628 linux_dirent = (struct l_dirent*)lbuf;
629 linux_dirent->d_ino = bdp->d_fileno;
630 linux_dirent->d_off = linuxreclen;
631 linux_dirent->d_reclen = bdp->d_namlen;
632 strlcpy(linux_dirent->d_name, bdp->d_name,
633 linuxreclen - offsetof(struct l_dirent, d_name));
634 error = copyout(linux_dirent, args->dent, linuxreclen);
635 if (error == 0)
636 td->td_retval[0] = linuxreclen;
637
638 free(lbuf, M_TEMP);
639 out:
640 free(buf, M_TEMP);
641 return (error);
642 }
643 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
644
645 /*
646 * These exist mainly for hooks for doing /compat/linux translation.
647 */
648
649 #ifdef LINUX_LEGACY_SYSCALLS
650 int
651 linux_access(struct thread *td, struct linux_access_args *args)
652 {
653 char *path;
654 int error;
655
656 /* Linux convention. */
657 if (args->amode & ~(F_OK | X_OK | W_OK | R_OK))
658 return (EINVAL);
659
660 if (!LUSECONVPATH(td)) {
661 error = kern_accessat(td, AT_FDCWD, args->path, UIO_USERSPACE, 0,
662 args->amode);
663 } else {
664 LCONVPATHEXIST(td, args->path, &path);
665 error = kern_accessat(td, AT_FDCWD, path, UIO_SYSSPACE, 0,
666 args->amode);
667 LFREEPATH(path);
668 }
669
670 return (error);
671 }
672 #endif
673
674 int
675 linux_faccessat(struct thread *td, struct linux_faccessat_args *args)
676 {
677 char *path;
678 int error, dfd;
679
680 /* Linux convention. */
681 if (args->amode & ~(F_OK | X_OK | W_OK | R_OK))
682 return (EINVAL);
683
684 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
685 if (!LUSECONVPATH(td)) {
686 error = kern_accessat(td, dfd, args->filename, UIO_USERSPACE, 0, args->amode);
687 } else {
688 LCONVPATHEXIST_AT(td, args->filename, &path, dfd);
689 error = kern_accessat(td, dfd, path, UIO_SYSSPACE, 0, args->amode);
690 LFREEPATH(path);
691 }
692
693 return (error);
694 }
695
696 #ifdef LINUX_LEGACY_SYSCALLS
697 int
698 linux_unlink(struct thread *td, struct linux_unlink_args *args)
699 {
700 char *path;
701 int error;
702 struct stat st;
703
704 if (!LUSECONVPATH(td)) {
705 error = kern_funlinkat(td, AT_FDCWD, args->path, FD_NONE,
706 UIO_USERSPACE, 0, 0);
707 if (error == EPERM) {
708 /* Introduce POSIX noncompliant behaviour of Linux */
709 if (kern_statat(td, 0, AT_FDCWD, args->path,
710 UIO_SYSSPACE, &st, NULL) == 0) {
711 if (S_ISDIR(st.st_mode))
712 error = EISDIR;
713 }
714 }
715 } else {
716 LCONVPATHEXIST(td, args->path, &path);
717 error = kern_funlinkat(td, AT_FDCWD, path, FD_NONE, UIO_SYSSPACE, 0, 0);
718 if (error == EPERM) {
719 /* Introduce POSIX noncompliant behaviour of Linux */
720 if (kern_statat(td, 0, AT_FDCWD, path, UIO_SYSSPACE, &st,
721 NULL) == 0) {
722 if (S_ISDIR(st.st_mode))
723 error = EISDIR;
724 }
725 }
726 LFREEPATH(path);
727 }
728
729 return (error);
730 }
731 #endif
732
733 static int
734 linux_unlinkat_impl(struct thread *td, enum uio_seg pathseg, const char *path,
735 int dfd, struct linux_unlinkat_args *args)
736 {
737 struct stat st;
738 int error;
739
740 if (args->flag & LINUX_AT_REMOVEDIR)
741 error = kern_frmdirat(td, dfd, path, FD_NONE, pathseg, 0);
742 else
743 error = kern_funlinkat(td, dfd, path, FD_NONE, pathseg, 0, 0);
744 if (error == EPERM && !(args->flag & LINUX_AT_REMOVEDIR)) {
745 /* Introduce POSIX noncompliant behaviour of Linux */
746 if (kern_statat(td, AT_SYMLINK_NOFOLLOW, dfd, path,
747 UIO_SYSSPACE, &st, NULL) == 0 && S_ISDIR(st.st_mode))
748 error = EISDIR;
749 }
750 return (error);
751 }
752
753 int
754 linux_unlinkat(struct thread *td, struct linux_unlinkat_args *args)
755 {
756 char *path;
757 int error, dfd;
758
759 if (args->flag & ~LINUX_AT_REMOVEDIR)
760 return (EINVAL);
761 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
762 if (!LUSECONVPATH(td)) {
763 return (linux_unlinkat_impl(td, UIO_USERSPACE, args->pathname,
764 dfd, args));
765 }
766 LCONVPATHEXIST_AT(td, args->pathname, &path, dfd);
767 error = linux_unlinkat_impl(td, UIO_SYSSPACE, path, dfd, args);
768 LFREEPATH(path);
769 return (error);
770 }
771 int
772 linux_chdir(struct thread *td, struct linux_chdir_args *args)
773 {
774 char *path;
775 int error;
776
777 if (!LUSECONVPATH(td)) {
778 return (kern_chdir(td, args->path, UIO_USERSPACE));
779 }
780 LCONVPATHEXIST(td, args->path, &path);
781 error = kern_chdir(td, path, UIO_SYSSPACE);
782 LFREEPATH(path);
783 return (error);
784 }
785
786 #ifdef LINUX_LEGACY_SYSCALLS
787 int
788 linux_chmod(struct thread *td, struct linux_chmod_args *args)
789 {
790 char *path;
791 int error;
792
793 if (!LUSECONVPATH(td)) {
794 return (kern_fchmodat(td, AT_FDCWD, args->path, UIO_USERSPACE,
795 args->mode, 0));
796 }
797 LCONVPATHEXIST(td, args->path, &path);
798 error = kern_fchmodat(td, AT_FDCWD, path, UIO_SYSSPACE, args->mode, 0);
799 LFREEPATH(path);
800 return (error);
801 }
802 #endif
803
804 int
805 linux_fchmodat(struct thread *td, struct linux_fchmodat_args *args)
806 {
807 char *path;
808 int error, dfd;
809
810 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
811 if (!LUSECONVPATH(td)) {
812 return (kern_fchmodat(td, dfd, args->filename, UIO_USERSPACE,
813 args->mode, 0));
814 }
815 LCONVPATHEXIST_AT(td, args->filename, &path, dfd);
816 error = kern_fchmodat(td, dfd, path, UIO_SYSSPACE, args->mode, 0);
817 LFREEPATH(path);
818 return (error);
819 }
820
821 #ifdef LINUX_LEGACY_SYSCALLS
822 int
823 linux_mkdir(struct thread *td, struct linux_mkdir_args *args)
824 {
825 char *path;
826 int error;
827
828 if (!LUSECONVPATH(td)) {
829 return (kern_mkdirat(td, AT_FDCWD, args->path, UIO_USERSPACE, args->mode));
830 }
831 LCONVPATHCREAT(td, args->path, &path);
832 error = kern_mkdirat(td, AT_FDCWD, path, UIO_SYSSPACE, args->mode);
833 LFREEPATH(path);
834 return (error);
835 }
836 #endif
837
838 int
839 linux_mkdirat(struct thread *td, struct linux_mkdirat_args *args)
840 {
841 char *path;
842 int error, dfd;
843
844 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
845 if (!LUSECONVPATH(td)) {
846 return (kern_mkdirat(td, dfd, args->pathname, UIO_USERSPACE, args->mode));
847 }
848 LCONVPATHCREAT_AT(td, args->pathname, &path, dfd);
849 error = kern_mkdirat(td, dfd, path, UIO_SYSSPACE, args->mode);
850 LFREEPATH(path);
851 return (error);
852 }
853
854 #ifdef LINUX_LEGACY_SYSCALLS
855 int
856 linux_rmdir(struct thread *td, struct linux_rmdir_args *args)
857 {
858 char *path;
859 int error;
860
861 if (!LUSECONVPATH(td)) {
862 return (kern_frmdirat(td, AT_FDCWD, args->path, FD_NONE,
863 UIO_USERSPACE, 0));
864 }
865 LCONVPATHEXIST(td, args->path, &path);
866 error = kern_frmdirat(td, AT_FDCWD, path, FD_NONE, UIO_SYSSPACE, 0);
867 LFREEPATH(path);
868 return (error);
869 }
870
871 int
872 linux_rename(struct thread *td, struct linux_rename_args *args)
873 {
874 char *from, *to;
875 int error;
876
877 if (!LUSECONVPATH(td)) {
878 return (kern_renameat(td, AT_FDCWD, args->from, AT_FDCWD,
879 args->to, UIO_USERSPACE));
880 }
881 LCONVPATHEXIST(td, args->from, &from);
882 /* Expand LCONVPATHCREATE so that `from' can be freed on errors */
883 error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD);
884 if (to == NULL) {
885 LFREEPATH(from);
886 return (error);
887 }
888 error = kern_renameat(td, AT_FDCWD, from, AT_FDCWD, to, UIO_SYSSPACE);
889 LFREEPATH(from);
890 LFREEPATH(to);
891 return (error);
892 }
893 #endif
894
895 int
896 linux_renameat(struct thread *td, struct linux_renameat_args *args)
897 {
898 struct linux_renameat2_args renameat2_args = {
899 .olddfd = args->olddfd,
900 .oldname = args->oldname,
901 .newdfd = args->newdfd,
902 .newname = args->newname,
903 .flags = 0
904 };
905
906 return (linux_renameat2(td, &renameat2_args));
907 }
908
909 int
910 linux_renameat2(struct thread *td, struct linux_renameat2_args *args)
911 {
912 char *from, *to;
913 int error, olddfd, newdfd;
914
915 if (args->flags != 0) {
916 if (args->flags & ~(LINUX_RENAME_EXCHANGE |
917 LINUX_RENAME_NOREPLACE | LINUX_RENAME_WHITEOUT))
918 return (EINVAL);
919 if (args->flags & LINUX_RENAME_EXCHANGE &&
920 args->flags & (LINUX_RENAME_NOREPLACE |
921 LINUX_RENAME_WHITEOUT))
922 return (EINVAL);
923 #if 0
924 /*
925 * This spams the console on Ubuntu Focal.
926 *
927 * What's needed here is a general mechanism to let users know
928 * about missing features without hogging the system.
929 */
930 linux_msg(td, "renameat2 unsupported flags 0x%x",
931 args->flags);
932 #endif
933 return (EINVAL);
934 }
935
936 olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
937 newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
938 if (!LUSECONVPATH(td)) {
939 return (kern_renameat(td, olddfd, args->oldname, newdfd,
940 args->newname, UIO_USERSPACE));
941 }
942 LCONVPATHEXIST_AT(td, args->oldname, &from, olddfd);
943 /* Expand LCONVPATHCREATE so that `from' can be freed on errors */
944 error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, newdfd);
945 if (to == NULL) {
946 LFREEPATH(from);
947 return (error);
948 }
949 error = kern_renameat(td, olddfd, from, newdfd, to, UIO_SYSSPACE);
950 LFREEPATH(from);
951 LFREEPATH(to);
952 return (error);
953 }
954
955 #ifdef LINUX_LEGACY_SYSCALLS
956 int
957 linux_symlink(struct thread *td, struct linux_symlink_args *args)
958 {
959 char *path, *to;
960 int error;
961
962 if (!LUSECONVPATH(td)) {
963 return (kern_symlinkat(td, args->path, AT_FDCWD, args->to,
964 UIO_USERSPACE));
965 }
966 LCONVPATHEXIST(td, args->path, &path);
967 /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
968 error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD);
969 if (to == NULL) {
970 LFREEPATH(path);
971 return (error);
972 }
973 error = kern_symlinkat(td, path, AT_FDCWD, to, UIO_SYSSPACE);
974 LFREEPATH(path);
975 LFREEPATH(to);
976 return (error);
977 }
978 #endif
979
980 int
981 linux_symlinkat(struct thread *td, struct linux_symlinkat_args *args)
982 {
983 char *path, *to;
984 int error, dfd;
985
986 dfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
987 if (!LUSECONVPATH(td)) {
988 return (kern_symlinkat(td, args->oldname, dfd, args->newname,
989 UIO_USERSPACE));
990 }
991 LCONVPATHEXIST(td, args->oldname, &path);
992 /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
993 error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, dfd);
994 if (to == NULL) {
995 LFREEPATH(path);
996 return (error);
997 }
998 error = kern_symlinkat(td, path, dfd, to, UIO_SYSSPACE);
999 LFREEPATH(path);
1000 LFREEPATH(to);
1001 return (error);
1002 }
1003
1004 #ifdef LINUX_LEGACY_SYSCALLS
1005 int
1006 linux_readlink(struct thread *td, struct linux_readlink_args *args)
1007 {
1008 char *name;
1009 int error;
1010
1011 if (!LUSECONVPATH(td)) {
1012 return (kern_readlinkat(td, AT_FDCWD, args->name, UIO_USERSPACE,
1013 args->buf, UIO_USERSPACE, args->count));
1014 }
1015 LCONVPATHEXIST(td, args->name, &name);
1016 error = kern_readlinkat(td, AT_FDCWD, name, UIO_SYSSPACE,
1017 args->buf, UIO_USERSPACE, args->count);
1018 LFREEPATH(name);
1019 return (error);
1020 }
1021 #endif
1022
1023 int
1024 linux_readlinkat(struct thread *td, struct linux_readlinkat_args *args)
1025 {
1026 char *name;
1027 int error, dfd;
1028
1029 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
1030 if (!LUSECONVPATH(td)) {
1031 return (kern_readlinkat(td, dfd, args->path, UIO_USERSPACE,
1032 args->buf, UIO_USERSPACE, args->bufsiz));
1033 }
1034 LCONVPATHEXIST_AT(td, args->path, &name, dfd);
1035 error = kern_readlinkat(td, dfd, name, UIO_SYSSPACE, args->buf,
1036 UIO_USERSPACE, args->bufsiz);
1037 LFREEPATH(name);
1038 return (error);
1039 }
1040
1041 int
1042 linux_truncate(struct thread *td, struct linux_truncate_args *args)
1043 {
1044 char *path;
1045 int error;
1046
1047 if (!LUSECONVPATH(td)) {
1048 return (kern_truncate(td, args->path, UIO_USERSPACE, args->length));
1049 }
1050 LCONVPATHEXIST(td, args->path, &path);
1051 error = kern_truncate(td, path, UIO_SYSSPACE, args->length);
1052 LFREEPATH(path);
1053 return (error);
1054 }
1055
1056 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1057 int
1058 linux_truncate64(struct thread *td, struct linux_truncate64_args *args)
1059 {
1060 char *path;
1061 off_t length;
1062 int error;
1063
1064 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1065 length = PAIR32TO64(off_t, args->length);
1066 #else
1067 length = args->length;
1068 #endif
1069
1070 if (!LUSECONVPATH(td)) {
1071 return (kern_truncate(td, args->path, UIO_USERSPACE, length));
1072 }
1073 LCONVPATHEXIST(td, args->path, &path);
1074 error = kern_truncate(td, path, UIO_SYSSPACE, length);
1075 LFREEPATH(path);
1076 return (error);
1077 }
1078 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1079
1080 int
1081 linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args)
1082 {
1083
1084 return (kern_ftruncate(td, args->fd, args->length));
1085 }
1086
1087 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1088 int
1089 linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
1090 {
1091 off_t length;
1092
1093 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1094 length = PAIR32TO64(off_t, args->length);
1095 #else
1096 length = args->length;
1097 #endif
1098
1099 return (kern_ftruncate(td, args->fd, length));
1100 }
1101 #endif
1102
1103 #ifdef LINUX_LEGACY_SYSCALLS
1104 int
1105 linux_link(struct thread *td, struct linux_link_args *args)
1106 {
1107 char *path, *to;
1108 int error;
1109
1110 if (!LUSECONVPATH(td)) {
1111 return (kern_linkat(td, AT_FDCWD, AT_FDCWD, args->path, args->to,
1112 UIO_USERSPACE, FOLLOW));
1113 }
1114 LCONVPATHEXIST(td, args->path, &path);
1115 /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
1116 error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1, AT_FDCWD);
1117 if (to == NULL) {
1118 LFREEPATH(path);
1119 return (error);
1120 }
1121 error = kern_linkat(td, AT_FDCWD, AT_FDCWD, path, to, UIO_SYSSPACE,
1122 FOLLOW);
1123 LFREEPATH(path);
1124 LFREEPATH(to);
1125 return (error);
1126 }
1127 #endif
1128
1129 int
1130 linux_linkat(struct thread *td, struct linux_linkat_args *args)
1131 {
1132 char *path, *to;
1133 int error, olddfd, newdfd, follow;
1134
1135 if (args->flag & ~LINUX_AT_SYMLINK_FOLLOW)
1136 return (EINVAL);
1137
1138 olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
1139 newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
1140 follow = (args->flag & LINUX_AT_SYMLINK_FOLLOW) == 0 ? NOFOLLOW :
1141 FOLLOW;
1142 if (!LUSECONVPATH(td)) {
1143 return (kern_linkat(td, olddfd, newdfd, args->oldname,
1144 args->newname, UIO_USERSPACE, follow));
1145 }
1146 LCONVPATHEXIST_AT(td, args->oldname, &path, olddfd);
1147 /* Expand LCONVPATHCREATE so that `path' can be freed on errors */
1148 error = linux_emul_convpath(td, args->newname, UIO_USERSPACE, &to, 1, newdfd);
1149 if (to == NULL) {
1150 LFREEPATH(path);
1151 return (error);
1152 }
1153 error = kern_linkat(td, olddfd, newdfd, path, to, UIO_SYSSPACE, follow);
1154 LFREEPATH(path);
1155 LFREEPATH(to);
1156 return (error);
1157 }
1158
1159 int
1160 linux_fdatasync(struct thread *td, struct linux_fdatasync_args *uap)
1161 {
1162
1163 return (kern_fsync(td, uap->fd, false));
1164 }
1165
1166 int
1167 linux_sync_file_range(struct thread *td, struct linux_sync_file_range_args *uap)
1168 {
1169 off_t nbytes, offset;
1170
1171 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1172 nbytes = PAIR32TO64(off_t, uap->nbytes);
1173 offset = PAIR32TO64(off_t, uap->offset);
1174 #else
1175 nbytes = uap->nbytes;
1176 offset = uap->offset;
1177 #endif
1178
1179 if (offset < 0 || nbytes < 0 ||
1180 (uap->flags & ~(LINUX_SYNC_FILE_RANGE_WAIT_BEFORE |
1181 LINUX_SYNC_FILE_RANGE_WRITE |
1182 LINUX_SYNC_FILE_RANGE_WAIT_AFTER)) != 0) {
1183 return (EINVAL);
1184 }
1185
1186 return (kern_fsync(td, uap->fd, false));
1187 }
1188
1189 int
1190 linux_pread(struct thread *td, struct linux_pread_args *uap)
1191 {
1192 struct vnode *vp;
1193 off_t offset;
1194 int error;
1195
1196 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1197 offset = PAIR32TO64(off_t, uap->offset);
1198 #else
1199 offset = uap->offset;
1200 #endif
1201
1202 error = kern_pread(td, uap->fd, uap->buf, uap->nbyte, offset);
1203 if (error == 0) {
1204 /* This seems to violate POSIX but Linux does it. */
1205 error = fgetvp(td, uap->fd, &cap_pread_rights, &vp);
1206 if (error != 0)
1207 return (error);
1208 if (vp->v_type == VDIR)
1209 error = EISDIR;
1210 vrele(vp);
1211 }
1212 return (error);
1213 }
1214
1215 int
1216 linux_pwrite(struct thread *td, struct linux_pwrite_args *uap)
1217 {
1218 off_t offset;
1219
1220 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1221 offset = PAIR32TO64(off_t, uap->offset);
1222 #else
1223 offset = uap->offset;
1224 #endif
1225
1226 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, offset));
1227 }
1228
1229 int
1230 linux_preadv(struct thread *td, struct linux_preadv_args *uap)
1231 {
1232 struct uio *auio;
1233 int error;
1234 off_t offset;
1235
1236 /*
1237 * According http://man7.org/linux/man-pages/man2/preadv.2.html#NOTES
1238 * pos_l and pos_h, respectively, contain the
1239 * low order and high order 32 bits of offset.
1240 */
1241 offset = (((off_t)uap->pos_h << (sizeof(offset) * 4)) <<
1242 (sizeof(offset) * 4)) | uap->pos_l;
1243 if (offset < 0)
1244 return (EINVAL);
1245 #ifdef COMPAT_LINUX32
1246 error = linux32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio);
1247 #else
1248 error = copyinuio(uap->vec, uap->vlen, &auio);
1249 #endif
1250 if (error != 0)
1251 return (error);
1252 error = kern_preadv(td, uap->fd, auio, offset);
1253 free(auio, M_IOV);
1254 return (error);
1255 }
1256
1257 int
1258 linux_pwritev(struct thread *td, struct linux_pwritev_args *uap)
1259 {
1260 struct uio *auio;
1261 int error;
1262 off_t offset;
1263
1264 /*
1265 * According http://man7.org/linux/man-pages/man2/pwritev.2.html#NOTES
1266 * pos_l and pos_h, respectively, contain the
1267 * low order and high order 32 bits of offset.
1268 */
1269 offset = (((off_t)uap->pos_h << (sizeof(offset) * 4)) <<
1270 (sizeof(offset) * 4)) | uap->pos_l;
1271 if (offset < 0)
1272 return (EINVAL);
1273 #ifdef COMPAT_LINUX32
1274 error = linux32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio);
1275 #else
1276 error = copyinuio(uap->vec, uap->vlen, &auio);
1277 #endif
1278 if (error != 0)
1279 return (error);
1280 error = kern_pwritev(td, uap->fd, auio, offset);
1281 free(auio, M_IOV);
1282 return (error);
1283 }
1284
1285 int
1286 linux_mount(struct thread *td, struct linux_mount_args *args)
1287 {
1288 struct mntarg *ma = NULL;
1289 char *fstypename, *mntonname, *mntfromname, *data;
1290 int error, fsflags;
1291
1292 fstypename = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1293 mntonname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1294 mntfromname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1295 data = NULL;
1296 error = copyinstr(args->filesystemtype, fstypename, MNAMELEN - 1,
1297 NULL);
1298 if (error != 0)
1299 goto out;
1300 if (args->specialfile != NULL) {
1301 error = copyinstr(args->specialfile, mntfromname, MNAMELEN - 1, NULL);
1302 if (error != 0)
1303 goto out;
1304 } else {
1305 mntfromname[0] = '\0';
1306 }
1307 error = copyinstr(args->dir, mntonname, MNAMELEN - 1, NULL);
1308 if (error != 0)
1309 goto out;
1310
1311 if (strcmp(fstypename, "ext2") == 0) {
1312 strcpy(fstypename, "ext2fs");
1313 } else if (strcmp(fstypename, "proc") == 0) {
1314 strcpy(fstypename, "linprocfs");
1315 } else if (strcmp(fstypename, "vfat") == 0) {
1316 strcpy(fstypename, "msdosfs");
1317 } else if (strcmp(fstypename, "fuse") == 0) {
1318 char *fuse_options, *fuse_option, *fuse_name;
1319
1320 if (strcmp(mntfromname, "fuse") == 0)
1321 strcpy(mntfromname, "/dev/fuse");
1322
1323 strcpy(fstypename, "fusefs");
1324 data = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1325 error = copyinstr(args->data, data, MNAMELEN - 1, NULL);
1326 if (error != 0)
1327 goto out;
1328
1329 fuse_options = data;
1330 while ((fuse_option = strsep(&fuse_options, ",")) != NULL) {
1331 fuse_name = strsep(&fuse_option, "=");
1332 if (fuse_name == NULL || fuse_option == NULL)
1333 goto out;
1334 ma = mount_arg(ma, fuse_name, fuse_option, -1);
1335 }
1336
1337 /*
1338 * The FUSE server uses Linux errno values instead of FreeBSD
1339 * ones; add a flag to tell fuse(4) to do errno translation.
1340 */
1341 ma = mount_arg(ma, "linux_errnos", "1", -1);
1342 }
1343
1344 fsflags = 0;
1345
1346 /*
1347 * Linux SYNC flag is not included; the closest equivalent
1348 * FreeBSD has is !ASYNC, which is our default.
1349 */
1350 if (args->rwflag & LINUX_MS_RDONLY)
1351 fsflags |= MNT_RDONLY;
1352 if (args->rwflag & LINUX_MS_NOSUID)
1353 fsflags |= MNT_NOSUID;
1354 if (args->rwflag & LINUX_MS_NOEXEC)
1355 fsflags |= MNT_NOEXEC;
1356 if (args->rwflag & LINUX_MS_REMOUNT)
1357 fsflags |= MNT_UPDATE;
1358
1359 ma = mount_arg(ma, "fstype", fstypename, -1);
1360 ma = mount_arg(ma, "fspath", mntonname, -1);
1361 ma = mount_arg(ma, "from", mntfromname, -1);
1362 error = kernel_mount(ma, fsflags);
1363 out:
1364 free(fstypename, M_TEMP);
1365 free(mntonname, M_TEMP);
1366 free(mntfromname, M_TEMP);
1367 free(data, M_TEMP);
1368 return (error);
1369 }
1370
1371 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1372 int
1373 linux_oldumount(struct thread *td, struct linux_oldumount_args *args)
1374 {
1375
1376 return (kern_unmount(td, args->path, 0));
1377 }
1378 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1379
1380 #ifdef LINUX_LEGACY_SYSCALLS
1381 int
1382 linux_umount(struct thread *td, struct linux_umount_args *args)
1383 {
1384 int flags;
1385
1386 flags = 0;
1387 if ((args->flags & LINUX_MNT_FORCE) != 0) {
1388 args->flags &= ~LINUX_MNT_FORCE;
1389 flags |= MNT_FORCE;
1390 }
1391 if (args->flags != 0) {
1392 linux_msg(td, "unsupported umount2 flags %#x", args->flags);
1393 return (EINVAL);
1394 }
1395
1396 return (kern_unmount(td, args->path, flags));
1397 }
1398 #endif
1399
1400 /*
1401 * fcntl family of syscalls
1402 */
1403
1404 struct l_flock {
1405 l_short l_type;
1406 l_short l_whence;
1407 l_off_t l_start;
1408 l_off_t l_len;
1409 l_pid_t l_pid;
1410 }
1411 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1412 __packed
1413 #endif
1414 ;
1415
1416 static void
1417 linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock)
1418 {
1419 switch (linux_flock->l_type) {
1420 case LINUX_F_RDLCK:
1421 bsd_flock->l_type = F_RDLCK;
1422 break;
1423 case LINUX_F_WRLCK:
1424 bsd_flock->l_type = F_WRLCK;
1425 break;
1426 case LINUX_F_UNLCK:
1427 bsd_flock->l_type = F_UNLCK;
1428 break;
1429 default:
1430 bsd_flock->l_type = -1;
1431 break;
1432 }
1433 bsd_flock->l_whence = linux_flock->l_whence;
1434 bsd_flock->l_start = (off_t)linux_flock->l_start;
1435 bsd_flock->l_len = (off_t)linux_flock->l_len;
1436 bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1437 bsd_flock->l_sysid = 0;
1438 }
1439
1440 static void
1441 bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock)
1442 {
1443 switch (bsd_flock->l_type) {
1444 case F_RDLCK:
1445 linux_flock->l_type = LINUX_F_RDLCK;
1446 break;
1447 case F_WRLCK:
1448 linux_flock->l_type = LINUX_F_WRLCK;
1449 break;
1450 case F_UNLCK:
1451 linux_flock->l_type = LINUX_F_UNLCK;
1452 break;
1453 }
1454 linux_flock->l_whence = bsd_flock->l_whence;
1455 linux_flock->l_start = (l_off_t)bsd_flock->l_start;
1456 linux_flock->l_len = (l_off_t)bsd_flock->l_len;
1457 linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1458 }
1459
1460 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1461 struct l_flock64 {
1462 l_short l_type;
1463 l_short l_whence;
1464 l_loff_t l_start;
1465 l_loff_t l_len;
1466 l_pid_t l_pid;
1467 }
1468 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1469 __packed
1470 #endif
1471 ;
1472
1473 static void
1474 linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock)
1475 {
1476 switch (linux_flock->l_type) {
1477 case LINUX_F_RDLCK:
1478 bsd_flock->l_type = F_RDLCK;
1479 break;
1480 case LINUX_F_WRLCK:
1481 bsd_flock->l_type = F_WRLCK;
1482 break;
1483 case LINUX_F_UNLCK:
1484 bsd_flock->l_type = F_UNLCK;
1485 break;
1486 default:
1487 bsd_flock->l_type = -1;
1488 break;
1489 }
1490 bsd_flock->l_whence = linux_flock->l_whence;
1491 bsd_flock->l_start = (off_t)linux_flock->l_start;
1492 bsd_flock->l_len = (off_t)linux_flock->l_len;
1493 bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1494 bsd_flock->l_sysid = 0;
1495 }
1496
1497 static void
1498 bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock)
1499 {
1500 switch (bsd_flock->l_type) {
1501 case F_RDLCK:
1502 linux_flock->l_type = LINUX_F_RDLCK;
1503 break;
1504 case F_WRLCK:
1505 linux_flock->l_type = LINUX_F_WRLCK;
1506 break;
1507 case F_UNLCK:
1508 linux_flock->l_type = LINUX_F_UNLCK;
1509 break;
1510 }
1511 linux_flock->l_whence = bsd_flock->l_whence;
1512 linux_flock->l_start = (l_loff_t)bsd_flock->l_start;
1513 linux_flock->l_len = (l_loff_t)bsd_flock->l_len;
1514 linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1515 }
1516 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1517
1518 static int
1519 fcntl_common(struct thread *td, struct linux_fcntl_args *args)
1520 {
1521 struct l_flock linux_flock;
1522 struct flock bsd_flock;
1523 struct file *fp;
1524 long arg;
1525 int error, result;
1526
1527 switch (args->cmd) {
1528 case LINUX_F_DUPFD:
1529 return (kern_fcntl(td, args->fd, F_DUPFD, args->arg));
1530
1531 case LINUX_F_GETFD:
1532 return (kern_fcntl(td, args->fd, F_GETFD, 0));
1533
1534 case LINUX_F_SETFD:
1535 return (kern_fcntl(td, args->fd, F_SETFD, args->arg));
1536
1537 case LINUX_F_GETFL:
1538 error = kern_fcntl(td, args->fd, F_GETFL, 0);
1539 result = td->td_retval[0];
1540 td->td_retval[0] = 0;
1541 if (result & O_RDONLY)
1542 td->td_retval[0] |= LINUX_O_RDONLY;
1543 if (result & O_WRONLY)
1544 td->td_retval[0] |= LINUX_O_WRONLY;
1545 if (result & O_RDWR)
1546 td->td_retval[0] |= LINUX_O_RDWR;
1547 if (result & O_NDELAY)
1548 td->td_retval[0] |= LINUX_O_NONBLOCK;
1549 if (result & O_APPEND)
1550 td->td_retval[0] |= LINUX_O_APPEND;
1551 if (result & O_FSYNC)
1552 td->td_retval[0] |= LINUX_O_SYNC;
1553 if (result & O_ASYNC)
1554 td->td_retval[0] |= LINUX_O_ASYNC;
1555 #ifdef LINUX_O_NOFOLLOW
1556 if (result & O_NOFOLLOW)
1557 td->td_retval[0] |= LINUX_O_NOFOLLOW;
1558 #endif
1559 #ifdef LINUX_O_DIRECT
1560 if (result & O_DIRECT)
1561 td->td_retval[0] |= LINUX_O_DIRECT;
1562 #endif
1563 return (error);
1564
1565 case LINUX_F_SETFL:
1566 arg = 0;
1567 if (args->arg & LINUX_O_NDELAY)
1568 arg |= O_NONBLOCK;
1569 if (args->arg & LINUX_O_APPEND)
1570 arg |= O_APPEND;
1571 if (args->arg & LINUX_O_SYNC)
1572 arg |= O_FSYNC;
1573 if (args->arg & LINUX_O_ASYNC)
1574 arg |= O_ASYNC;
1575 #ifdef LINUX_O_NOFOLLOW
1576 if (args->arg & LINUX_O_NOFOLLOW)
1577 arg |= O_NOFOLLOW;
1578 #endif
1579 #ifdef LINUX_O_DIRECT
1580 if (args->arg & LINUX_O_DIRECT)
1581 arg |= O_DIRECT;
1582 #endif
1583 return (kern_fcntl(td, args->fd, F_SETFL, arg));
1584
1585 case LINUX_F_GETLK:
1586 error = copyin((void *)args->arg, &linux_flock,
1587 sizeof(linux_flock));
1588 if (error)
1589 return (error);
1590 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1591 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
1592 if (error)
1593 return (error);
1594 bsd_to_linux_flock(&bsd_flock, &linux_flock);
1595 return (copyout(&linux_flock, (void *)args->arg,
1596 sizeof(linux_flock)));
1597
1598 case LINUX_F_SETLK:
1599 error = copyin((void *)args->arg, &linux_flock,
1600 sizeof(linux_flock));
1601 if (error)
1602 return (error);
1603 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1604 return (kern_fcntl(td, args->fd, F_SETLK,
1605 (intptr_t)&bsd_flock));
1606
1607 case LINUX_F_SETLKW:
1608 error = copyin((void *)args->arg, &linux_flock,
1609 sizeof(linux_flock));
1610 if (error)
1611 return (error);
1612 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1613 return (kern_fcntl(td, args->fd, F_SETLKW,
1614 (intptr_t)&bsd_flock));
1615
1616 case LINUX_F_GETOWN:
1617 return (kern_fcntl(td, args->fd, F_GETOWN, 0));
1618
1619 case LINUX_F_SETOWN:
1620 /*
1621 * XXX some Linux applications depend on F_SETOWN having no
1622 * significant effect for pipes (SIGIO is not delivered for
1623 * pipes under Linux-2.2.35 at least).
1624 */
1625 error = fget(td, args->fd,
1626 &cap_fcntl_rights, &fp);
1627 if (error)
1628 return (error);
1629 if (fp->f_type == DTYPE_PIPE) {
1630 fdrop(fp, td);
1631 return (EINVAL);
1632 }
1633 fdrop(fp, td);
1634
1635 return (kern_fcntl(td, args->fd, F_SETOWN, args->arg));
1636
1637 case LINUX_F_DUPFD_CLOEXEC:
1638 return (kern_fcntl(td, args->fd, F_DUPFD_CLOEXEC, args->arg));
1639 /*
1640 * Our F_SEAL_* values match Linux one for maximum compatibility. So we
1641 * only needed to account for different values for fcntl(2) commands.
1642 */
1643 case LINUX_F_GET_SEALS:
1644 error = kern_fcntl(td, args->fd, F_GET_SEALS, 0);
1645 if (error != 0)
1646 return (error);
1647 td->td_retval[0] = bsd_to_linux_bits(td->td_retval[0],
1648 seal_bitmap, 0);
1649 return (0);
1650
1651 case LINUX_F_ADD_SEALS:
1652 return (kern_fcntl(td, args->fd, F_ADD_SEALS,
1653 linux_to_bsd_bits(args->arg, seal_bitmap, 0)));
1654 default:
1655 linux_msg(td, "unsupported fcntl cmd %d", args->cmd);
1656 return (EINVAL);
1657 }
1658 }
1659
1660 int
1661 linux_fcntl(struct thread *td, struct linux_fcntl_args *args)
1662 {
1663
1664 return (fcntl_common(td, args));
1665 }
1666
1667 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1668 int
1669 linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args)
1670 {
1671 struct l_flock64 linux_flock;
1672 struct flock bsd_flock;
1673 struct linux_fcntl_args fcntl_args;
1674 int error;
1675
1676 switch (args->cmd) {
1677 case LINUX_F_GETLK64:
1678 error = copyin((void *)args->arg, &linux_flock,
1679 sizeof(linux_flock));
1680 if (error)
1681 return (error);
1682 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1683 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
1684 if (error)
1685 return (error);
1686 bsd_to_linux_flock64(&bsd_flock, &linux_flock);
1687 return (copyout(&linux_flock, (void *)args->arg,
1688 sizeof(linux_flock)));
1689
1690 case LINUX_F_SETLK64:
1691 error = copyin((void *)args->arg, &linux_flock,
1692 sizeof(linux_flock));
1693 if (error)
1694 return (error);
1695 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1696 return (kern_fcntl(td, args->fd, F_SETLK,
1697 (intptr_t)&bsd_flock));
1698
1699 case LINUX_F_SETLKW64:
1700 error = copyin((void *)args->arg, &linux_flock,
1701 sizeof(linux_flock));
1702 if (error)
1703 return (error);
1704 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1705 return (kern_fcntl(td, args->fd, F_SETLKW,
1706 (intptr_t)&bsd_flock));
1707 }
1708
1709 fcntl_args.fd = args->fd;
1710 fcntl_args.cmd = args->cmd;
1711 fcntl_args.arg = args->arg;
1712 return (fcntl_common(td, &fcntl_args));
1713 }
1714 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1715
1716 #ifdef LINUX_LEGACY_SYSCALLS
1717 int
1718 linux_chown(struct thread *td, struct linux_chown_args *args)
1719 {
1720 char *path;
1721 int error;
1722
1723 if (!LUSECONVPATH(td)) {
1724 return (kern_fchownat(td, AT_FDCWD, args->path, UIO_USERSPACE,
1725 args->uid, args->gid, 0));
1726 }
1727 LCONVPATHEXIST(td, args->path, &path);
1728 error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE, args->uid,
1729 args->gid, 0);
1730 LFREEPATH(path);
1731 return (error);
1732 }
1733 #endif
1734
1735 int
1736 linux_fchownat(struct thread *td, struct linux_fchownat_args *args)
1737 {
1738 char *path;
1739 int error, dfd, flag;
1740
1741 if (args->flag & ~LINUX_AT_SYMLINK_NOFOLLOW)
1742 return (EINVAL);
1743
1744 dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
1745 flag = (args->flag & LINUX_AT_SYMLINK_NOFOLLOW) == 0 ? 0 :
1746 AT_SYMLINK_NOFOLLOW;
1747 if (!LUSECONVPATH(td)) {
1748 return (kern_fchownat(td, dfd, args->filename, UIO_USERSPACE,
1749 args->uid, args->gid, flag));
1750 }
1751 LCONVPATHEXIST_AT(td, args->filename, &path, dfd);
1752 error = kern_fchownat(td, dfd, path, UIO_SYSSPACE, args->uid, args->gid,
1753 flag);
1754 LFREEPATH(path);
1755 return (error);
1756 }
1757
1758 #ifdef LINUX_LEGACY_SYSCALLS
1759 int
1760 linux_lchown(struct thread *td, struct linux_lchown_args *args)
1761 {
1762 char *path;
1763 int error;
1764
1765 if (!LUSECONVPATH(td)) {
1766 return (kern_fchownat(td, AT_FDCWD, args->path, UIO_USERSPACE, args->uid,
1767 args->gid, AT_SYMLINK_NOFOLLOW));
1768 }
1769 LCONVPATHEXIST(td, args->path, &path);
1770 error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE, args->uid, args->gid,
1771 AT_SYMLINK_NOFOLLOW);
1772 LFREEPATH(path);
1773 return (error);
1774 }
1775 #endif
1776
1777 static int
1778 convert_fadvice(int advice)
1779 {
1780 switch (advice) {
1781 case LINUX_POSIX_FADV_NORMAL:
1782 return (POSIX_FADV_NORMAL);
1783 case LINUX_POSIX_FADV_RANDOM:
1784 return (POSIX_FADV_RANDOM);
1785 case LINUX_POSIX_FADV_SEQUENTIAL:
1786 return (POSIX_FADV_SEQUENTIAL);
1787 case LINUX_POSIX_FADV_WILLNEED:
1788 return (POSIX_FADV_WILLNEED);
1789 case LINUX_POSIX_FADV_DONTNEED:
1790 return (POSIX_FADV_DONTNEED);
1791 case LINUX_POSIX_FADV_NOREUSE:
1792 return (POSIX_FADV_NOREUSE);
1793 default:
1794 return (-1);
1795 }
1796 }
1797
1798 int
1799 linux_fadvise64(struct thread *td, struct linux_fadvise64_args *args)
1800 {
1801 off_t offset;
1802 int advice;
1803
1804 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1805 offset = PAIR32TO64(off_t, args->offset);
1806 #else
1807 offset = args->offset;
1808 #endif
1809
1810 advice = convert_fadvice(args->advice);
1811 if (advice == -1)
1812 return (EINVAL);
1813 return (kern_posix_fadvise(td, args->fd, offset, args->len, advice));
1814 }
1815
1816 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1817 int
1818 linux_fadvise64_64(struct thread *td, struct linux_fadvise64_64_args *args)
1819 {
1820 off_t len, offset;
1821 int advice;
1822
1823 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1824 len = PAIR32TO64(off_t, args->len);
1825 offset = PAIR32TO64(off_t, args->offset);
1826 #else
1827 len = args->len;
1828 offset = args->offset;
1829 #endif
1830
1831 advice = convert_fadvice(args->advice);
1832 if (advice == -1)
1833 return (EINVAL);
1834 return (kern_posix_fadvise(td, args->fd, offset, len, advice));
1835 }
1836 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1837
1838 #ifdef LINUX_LEGACY_SYSCALLS
1839 int
1840 linux_pipe(struct thread *td, struct linux_pipe_args *args)
1841 {
1842 int fildes[2];
1843 int error;
1844
1845 error = kern_pipe(td, fildes, 0, NULL, NULL);
1846 if (error != 0)
1847 return (error);
1848
1849 error = copyout(fildes, args->pipefds, sizeof(fildes));
1850 if (error != 0) {
1851 (void)kern_close(td, fildes[0]);
1852 (void)kern_close(td, fildes[1]);
1853 }
1854
1855 return (error);
1856 }
1857 #endif
1858
1859 int
1860 linux_pipe2(struct thread *td, struct linux_pipe2_args *args)
1861 {
1862 int fildes[2];
1863 int error, flags;
1864
1865 if ((args->flags & ~(LINUX_O_NONBLOCK | LINUX_O_CLOEXEC)) != 0)
1866 return (EINVAL);
1867
1868 flags = 0;
1869 if ((args->flags & LINUX_O_NONBLOCK) != 0)
1870 flags |= O_NONBLOCK;
1871 if ((args->flags & LINUX_O_CLOEXEC) != 0)
1872 flags |= O_CLOEXEC;
1873 error = kern_pipe(td, fildes, flags, NULL, NULL);
1874 if (error != 0)
1875 return (error);
1876
1877 error = copyout(fildes, args->pipefds, sizeof(fildes));
1878 if (error != 0) {
1879 (void)kern_close(td, fildes[0]);
1880 (void)kern_close(td, fildes[1]);
1881 }
1882
1883 return (error);
1884 }
1885
1886 int
1887 linux_dup3(struct thread *td, struct linux_dup3_args *args)
1888 {
1889 int cmd;
1890 intptr_t newfd;
1891
1892 if (args->oldfd == args->newfd)
1893 return (EINVAL);
1894 if ((args->flags & ~LINUX_O_CLOEXEC) != 0)
1895 return (EINVAL);
1896 if (args->flags & LINUX_O_CLOEXEC)
1897 cmd = F_DUP2FD_CLOEXEC;
1898 else
1899 cmd = F_DUP2FD;
1900
1901 newfd = args->newfd;
1902 return (kern_fcntl(td, args->oldfd, cmd, newfd));
1903 }
1904
1905 int
1906 linux_fallocate(struct thread *td, struct linux_fallocate_args *args)
1907 {
1908 off_t len, offset;
1909
1910 /*
1911 * We emulate only posix_fallocate system call for which
1912 * mode should be 0.
1913 */
1914 if (args->mode != 0)
1915 return (EOPNOTSUPP);
1916
1917 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1918 len = PAIR32TO64(off_t, args->len);
1919 offset = PAIR32TO64(off_t, args->offset);
1920 #else
1921 len = args->len;
1922 offset = args->offset;
1923 #endif
1924
1925 return (kern_posix_fallocate(td, args->fd, offset, len));
1926 }
1927
1928 int
1929 linux_copy_file_range(struct thread *td, struct linux_copy_file_range_args
1930 *args)
1931 {
1932 l_loff_t inoff, outoff, *inoffp, *outoffp;
1933 int error, flags;
1934
1935 /*
1936 * copy_file_range(2) on Linux doesn't define any flags (yet), so is
1937 * the native implementation. Enforce it.
1938 */
1939 if (args->flags != 0) {
1940 linux_msg(td, "copy_file_range unsupported flags 0x%x",
1941 args->flags);
1942 return (EINVAL);
1943 }
1944 flags = 0;
1945 inoffp = outoffp = NULL;
1946 if (args->off_in != NULL) {
1947 error = copyin(args->off_in, &inoff, sizeof(l_loff_t));
1948 if (error != 0)
1949 return (error);
1950 inoffp = &inoff;
1951 }
1952 if (args->off_out != NULL) {
1953 error = copyin(args->off_out, &outoff, sizeof(l_loff_t));
1954 if (error != 0)
1955 return (error);
1956 outoffp = &outoff;
1957 }
1958
1959 error = kern_copy_file_range(td, args->fd_in, inoffp, args->fd_out,
1960 outoffp, args->len, flags);
1961 if (error == 0 && args->off_in != NULL)
1962 error = copyout(inoffp, args->off_in, sizeof(l_loff_t));
1963 if (error == 0 && args->off_out != NULL)
1964 error = copyout(outoffp, args->off_out, sizeof(l_loff_t));
1965 return (error);
1966 }
1967
1968 #define LINUX_MEMFD_PREFIX "memfd:"
1969
1970 int
1971 linux_memfd_create(struct thread *td, struct linux_memfd_create_args *args)
1972 {
1973 char memfd_name[LINUX_NAME_MAX + 1];
1974 int error, flags, shmflags, oflags;
1975
1976 /*
1977 * This is our clever trick to avoid the heap allocation to copy in the
1978 * uname. We don't really need to go this far out of our way, but it
1979 * does keep the rest of this function fairly clean as they don't have
1980 * to worry about cleanup on the way out.
1981 */
1982 error = copyinstr(args->uname_ptr,
1983 memfd_name + sizeof(LINUX_MEMFD_PREFIX) - 1,
1984 LINUX_NAME_MAX - sizeof(LINUX_MEMFD_PREFIX) - 1, NULL);
1985 if (error != 0) {
1986 if (error == ENAMETOOLONG)
1987 error = EINVAL;
1988 return (error);
1989 }
1990
1991 memcpy(memfd_name, LINUX_MEMFD_PREFIX, sizeof(LINUX_MEMFD_PREFIX) - 1);
1992 flags = linux_to_bsd_bits(args->flags, mfd_bitmap, 0);
1993 if ((flags & ~(MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_HUGETLB |
1994 MFD_HUGE_MASK)) != 0)
1995 return (EINVAL);
1996 /* Size specified but no HUGETLB. */
1997 if ((flags & MFD_HUGE_MASK) != 0 && (flags & MFD_HUGETLB) == 0)
1998 return (EINVAL);
1999 /* We don't actually support HUGETLB. */
2000 if ((flags & MFD_HUGETLB) != 0)
2001 return (ENOSYS);
2002 oflags = O_RDWR;
2003 shmflags = SHM_GROW_ON_WRITE;
2004 if ((flags & MFD_CLOEXEC) != 0)
2005 oflags |= O_CLOEXEC;
2006 if ((flags & MFD_ALLOW_SEALING) != 0)
2007 shmflags |= SHM_ALLOW_SEALING;
2008 return (kern_shm_open2(td, SHM_ANON, oflags, 0, shmflags, NULL,
2009 memfd_name));
2010 }
2011
2012 int
2013 linux_splice(struct thread *td, struct linux_splice_args *args)
2014 {
2015
2016 linux_msg(td, "syscall splice not really implemented");
2017
2018 /*
2019 * splice(2) is documented to return EINVAL in various circumstances;
2020 * returning it instead of ENOSYS should hint the caller to use fallback
2021 * instead.
2022 */
2023 return (EINVAL);
2024 }
Cache object: f91dcbcb8d5216283b16f4e8026e7ef1
|