?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

16c3edea3bae0dd652d04f8a43165457fb9290d1
[dragonfly.git] / sys / emulation / linux / linux_file.c
blob16c3edea3bae0dd652d04f8a43165457fb9290d1
1 /*-
2 * Copyright (c) 1994-1995 Søren Schmidt
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software withough specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/compat/linux/linux_file.c,v 1.41.2.6 2003/01/06 09:19:43 fjoe Exp $
29 * $DragonFly: src/sys/emulation/linux/linux_file.c,v 1.39 2008/09/28 05:08:16 dillon Exp $
30 */
31
32 #include "opt_compat.h"
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/conf.h>
37 #include <sys/dirent.h>
38 #include <sys/fcntl.h>
39 #include <sys/file.h>
40 #include <sys/stat.h>
41 #include <sys/filedesc.h>
42 #include <sys/kern_syscall.h>
43 #include <sys/lock.h>
44 #include <sys/malloc.h>
45 #include <sys/mount.h>
46 #include <sys/nlookup.h>
47 #include <sys/proc.h>
48 #include <sys/sysproto.h>
49 #include <sys/tty.h>
50 #include <sys/vnode.h>
51
52 #include <vfs/ufs/quota.h>
53 #include <vfs/ufs/ufsmount.h>
54
55 #include <sys/file2.h>
56 #include <sys/mplock2.h>
57
58 #include <arch_linux/linux.h>
59 #include <arch_linux/linux_proto.h>
60 #include "linux_util.h"
61
62 /*
63 * MPALMOSTSAFE
64 */
65 int
66 sys_linux_creat(struct linux_creat_args *args)
67 {
68 struct nlookupdata nd;
69 char *path;
70 int error;
71
72 error = linux_copyin_path(args->path, &path, LINUX_PATH_CREATE);
73 if (error)
74 return (error);
75 #ifdef DEBUG
76 if (ldebug(creat))
77 kprintf(ARGS(creat, "%s, %d"), path, args->mode);
78 #endif
79 get_mplock();
80 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
81 if (error == 0) {
82 error = kern_open(&nd, O_WRONLY | O_CREAT | O_TRUNC,
83 args->mode, &args->sysmsg_iresult);
84 }
85 rel_mplock();
86 linux_free_path(&path);
87 return(error);
88 }
89
90 /*
91 * MPALMOSTSAFE
92 */
93 int
94 sys_linux_open(struct linux_open_args *args)
95 {
96 struct thread *td = curthread;
97 struct proc *p = td->td_proc;
98 struct nlookupdata nd;
99 char *path;
100 int error, flags;
101
102 if (args->flags & LINUX_O_CREAT) {
103 error = linux_copyin_path(args->path, &path,
104 LINUX_PATH_CREATE);
105 } else {
106 error = linux_copyin_path(args->path, &path,
107 LINUX_PATH_EXISTS);
108 }
109 if (error)
110 return (error);
111
112 #ifdef DEBUG
113 if (ldebug(open))
114 kprintf(ARGS(open, "%s, 0x%x, 0x%x"), path, args->flags,
115 args->mode);
116 #endif
117 flags = 0;
118 if (args->flags & LINUX_O_RDONLY)
119 flags |= O_RDONLY;
120 if (args->flags & LINUX_O_WRONLY)
121 flags |= O_WRONLY;
122 if (args->flags & LINUX_O_RDWR)
123 flags |= O_RDWR;
124 if (args->flags & LINUX_O_NDELAY)
125 flags |= O_NONBLOCK;
126 if (args->flags & LINUX_O_APPEND)
127 flags |= O_APPEND;
128 if (args->flags & LINUX_O_SYNC)
129 flags |= O_FSYNC;
130 if (args->flags & LINUX_O_NONBLOCK)
131 flags |= O_NONBLOCK;
132 if (args->flags & LINUX_FASYNC)
133 flags |= O_ASYNC;
134 if (args->flags & LINUX_O_CREAT)
135 flags |= O_CREAT;
136 if (args->flags & LINUX_O_TRUNC)
137 flags |= O_TRUNC;
138 if (args->flags & LINUX_O_EXCL)
139 flags |= O_EXCL;
140 if (args->flags & LINUX_O_NOCTTY)
141 flags |= O_NOCTTY;
142 get_mplock();
143 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
144 if (error == 0) {
145 error = kern_open(&nd, flags,
146 args->mode, &args->sysmsg_iresult);
147 }
148
149 if (error == 0 && !(flags & O_NOCTTY) &&
150 SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
151 struct file *fp;
152
153 fp = holdfp(p->p_fd, args->sysmsg_iresult, -1);
154 if (fp) {
155 if (fp->f_type == DTYPE_VNODE) {
156 fo_ioctl(fp, TIOCSCTTY, NULL,
157 td->td_ucred, NULL);
158 }
159 fdrop(fp);
160 }
161 }
162 rel_mplock();
163 #ifdef DEBUG
164 if (ldebug(open))
165 kprintf(LMSG("open returns error %d"), error);
166 #endif
167 linux_free_path(&path);
168 return error;
169 }
170
171 /*
172 * MPSAFE
173 */
174 int
175 sys_linux_lseek(struct linux_lseek_args *args)
176 {
177 int error;
178
179 #ifdef DEBUG
180 if (ldebug(lseek))
181 kprintf(ARGS(lseek, "%d, %ld, %d"),
182 args->fdes, (long)args->off, args->whence);
183 #endif
184 error = kern_lseek(args->fdes, args->off, args->whence,
185 &args->sysmsg_offset);
186
187 return error;
188 }
189
190 /*
191 * MPSAFE
192 */
193 int
194 sys_linux_llseek(struct linux_llseek_args *args)
195 {
196 int error;
197 off_t off, res;
198
199 #ifdef DEBUG
200 if (ldebug(llseek))
201 kprintf(ARGS(llseek, "%d, %d:%d, %d"),
202 args->fd, args->ohigh, args->olow, args->whence);
203 #endif
204 off = (args->olow) | (((off_t) args->ohigh) << 32);
205
206 error = kern_lseek(args->fd, off, args->whence, &res);
207
208 if (error == 0)
209 error = copyout(&res, args->res, sizeof(res));
210 return (error);
211 }
212
213 /*
214 * MPSAFE
215 */
216 int
217 sys_linux_readdir(struct linux_readdir_args *args)
218 {
219 struct linux_getdents_args lda;
220 int error;
221
222 lda.fd = args->fd;
223 lda.dent = args->dent;
224 lda.count = -1;
225 lda.sysmsg_iresult = 0;
226 error = sys_linux_getdents(&lda);
227 args->sysmsg_iresult = lda.sysmsg_iresult;
228 return(error);
229 }
230
231 /*
232 * Note that linux_getdents(2) and linux_getdents64(2) have the same
233 * arguments. They only differ in the definition of struct dirent they
234 * operate on. We use this to common the code, with the exception of
235 * accessing struct dirent. Note that linux_readdir(2) is implemented
236 * by means of linux_getdents(2). In this case we never operate on
237 * struct dirent64 and thus don't need to handle it...
238 */
239
240 struct l_dirent {
241 l_long d_ino;
242 l_off_t d_off;
243 l_ushort d_reclen;
244 char d_name[LINUX_NAME_MAX + 1];
245 };
246
247 struct l_dirent64 {
248 uint64_t d_ino;
249 int64_t d_off;
250 l_ushort d_reclen;
251 u_char d_type;
252 char d_name[LINUX_NAME_MAX + 1];
253 };
254
255 #define LINUX_RECLEN(de,namlen) \
256 ALIGN((((char *)&(de)->d_name - (char *)de) + (namlen) + 1))
257
258 #define LINUX_DIRBLKSIZ 512
259
260 /*
261 * MPALMOSTSAFE
262 */
263 static int
264 getdents_common(struct linux_getdents64_args *args, int is64bit)
265 {
266 struct thread *td = curthread;
267 struct proc *p = td->td_proc;
268 struct dirent *bdp;
269 struct vnode *vp;
270 caddr_t inp, buf; /* BSD-format */
271 int reclen; /* BSD-format */
272 size_t len;
273 caddr_t outp; /* Linux-format */
274 int linuxreclen = 0; /* Linux-format */
275 size_t resid;
276 struct file *fp;
277 struct uio auio;
278 struct iovec aiov;
279 struct vattr va;
280 off_t off;
281 struct l_dirent linux_dirent;
282 struct l_dirent64 linux_dirent64;
283 int error, eofflag, justone;
284 size_t buflen, nbytes;
285 off_t *cookies = NULL, *cookiep;
286 int ncookies;
287
288 if ((error = holdvnode(p->p_fd, args->fd, &fp)) != 0)
289 return (error);
290
291 get_mplock();
292 if ((fp->f_flag & FREAD) == 0) {
293 error = EBADF;
294 goto done;
295 }
296
297 vp = (struct vnode *) fp->f_data;
298 if (vp->v_type != VDIR) {
299 error = EINVAL;
300 goto done;
301 }
302
303 if ((error = VOP_GETATTR(vp, &va)) != 0)
304 goto done;
305
306 nbytes = args->count;
307 if (nbytes == (size_t)-1) {
308 /* readdir(2) case. Always struct dirent. */
309 if (is64bit) {
310 error = EINVAL;
311 goto done;
312 }
313 nbytes = sizeof(linux_dirent);
314 justone = 1;
315 } else {
316 justone = 0;
317 }
318 if ((size_t)nbytes < 0)
319 nbytes = 0;
320
321 off = fp->f_offset;
322
323 buflen = max(LINUX_DIRBLKSIZ, nbytes);
324 buflen = min(buflen, MAXBSIZE);
325 buf = kmalloc(buflen, M_TEMP, M_WAITOK);
326
327 again:
328 aiov.iov_base = buf;
329 aiov.iov_len = buflen;
330 auio.uio_iov = &aiov;
331 auio.uio_iovcnt = 1;
332 auio.uio_rw = UIO_READ;
333 auio.uio_segflg = UIO_SYSSPACE;
334 auio.uio_td = td;
335 auio.uio_resid = buflen;
336 auio.uio_offset = off;
337
338 if (cookies) {
339 kfree(cookies, M_TEMP);
340 cookies = NULL;
341 }
342
343 eofflag = 0;
344 ncookies = 0;
345 if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies,
346 &cookies)))
347 goto out;
348
349 inp = buf;
350 outp = (caddr_t)args->dirent;
351 resid = nbytes;
352 if (auio.uio_resid >= buflen)
353 goto eof;
354 len = buflen - auio.uio_resid;
355 cookiep = cookies;
356
357 if (cookies) {
358 /*
359 * When using cookies, the vfs has the option of reading from
360 * a different offset than that supplied (UFS truncates the
361 * offset to a block boundary to make sure that it never reads
362 * partway through a directory entry, even if the directory
363 * has been compacted).
364 */
365 while (len > 0 && ncookies > 0 && *cookiep < off) {
366 bdp = (struct dirent *) inp;
367 len -= _DIRENT_DIRSIZ(bdp);
368 inp += _DIRENT_DIRSIZ(bdp);
369 cookiep++;
370 ncookies--;
371 }
372 }
373
374 while (len > 0) {
375 if (cookiep && ncookies == 0)
376 break;
377 bdp = (struct dirent *) inp;
378 reclen = _DIRENT_DIRSIZ(bdp);
379 if (reclen & 3) {
380 error = EFAULT;
381 goto out;
382 }
383
384 if (bdp->d_ino == 0) {
385 inp += reclen;
386 if (cookiep) {
387 off = *cookiep++;
388 ++off;
389 ncookies--;
390 } else {
391 off += reclen;
392 }
393 len -= reclen;
394 continue;
395 }
396
397 linuxreclen = (is64bit)
398 ? LINUX_RECLEN(&linux_dirent64, bdp->d_namlen)
399 : LINUX_RECLEN(&linux_dirent, bdp->d_namlen);
400
401 if (reclen > len || resid < linuxreclen) {
402 outp++;
403 break;
404 }
405
406 bzero(&linux_dirent, sizeof(linux_dirent));
407 bzero(&linux_dirent64, sizeof(linux_dirent64));
408 if (justone) {
409 /* readdir(2) case. */
410 linux_dirent.d_ino = (l_long)INO64TO32(bdp->d_ino);
411 linux_dirent.d_off = (l_off_t)linuxreclen;
412 linux_dirent.d_reclen = (l_ushort)bdp->d_namlen;
413 strcpy(linux_dirent.d_name, bdp->d_name);
414 error = copyout(&linux_dirent, outp, linuxreclen);
415 } else {
416 if (is64bit) {
417 linux_dirent64.d_ino = bdp->d_ino;
418 linux_dirent64.d_off = (cookiep)
419 ? (l_off_t)*cookiep
420 : (l_off_t)(off + reclen);
421 linux_dirent64.d_reclen =
422 (l_ushort)linuxreclen;
423 linux_dirent64.d_type = bdp->d_type;
424 strcpy(linux_dirent64.d_name, bdp->d_name);
425 error = copyout(&linux_dirent64, outp,
426 linuxreclen);
427 } else {
428 linux_dirent.d_ino = INO64TO32(bdp->d_ino);
429 linux_dirent.d_off = (cookiep)
430 ? (l_off_t)*cookiep
431 : (l_off_t)(off + reclen);
432 linux_dirent.d_reclen = (l_ushort)linuxreclen;
433 strcpy(linux_dirent.d_name, bdp->d_name);
434 error = copyout(&linux_dirent, outp,
435 linuxreclen);
436 }
437 }
438 if (error)
439 goto out;
440
441 inp += reclen;
442 if (cookiep) {
443 off = *cookiep++;
444 ++off;
445 ncookies--;
446 } else {
447 off += reclen;
448 }
449
450 outp += linuxreclen;
451 resid -= linuxreclen;
452 len -= reclen;
453 if (justone)
454 break;
455 }
456
457 if (outp == (caddr_t)args->dirent && eofflag == 0)
458 goto again;
459
460 fp->f_offset = off;
461 if (justone)
462 nbytes = resid + linuxreclen;
463
464 eof:
465 args->sysmsg_iresult = (int)(nbytes - resid);
466
467 out:
468 if (cookies)
469 kfree(cookies, M_TEMP);
470
471 kfree(buf, M_TEMP);
472 done:
473 rel_mplock();
474 fdrop(fp);
475 return (error);
476 }
477
478 /*
479 * MPSAFE
480 */
481 int
482 sys_linux_getdents(struct linux_getdents_args *args)
483 {
484 #ifdef DEBUG
485 if (ldebug(getdents))
486 kprintf(ARGS(getdents, "%d, *, %d"), args->fd, args->count);
487 #endif
488 return (getdents_common((struct linux_getdents64_args*)args, 0));
489 }
490
491 /*
492 * MPSAFE
493 */
494 int
495 sys_linux_getdents64(struct linux_getdents64_args *args)
496 {
497 #ifdef DEBUG
498 if (ldebug(getdents64))
499 kprintf(ARGS(getdents64, "%d, *, %d"), args->fd, args->count);
500 #endif
501 return (getdents_common(args, 1));
502 }
503
504 /*
505 * These exist mainly for hooks for doing /compat/linux translation.
506 *
507 * MPALMOSTSAFE
508 */
509 int
510 sys_linux_access(struct linux_access_args *args)
511 {
512 struct nlookupdata nd;
513 char *path;
514 int error;
515
516 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
517 if (error)
518 return (error);
519 #ifdef DEBUG
520 if (ldebug(access))
521 kprintf(ARGS(access, "%s, %d"), path, args->flags);
522 #endif
523 get_mplock();
524 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
525 if (error == 0)
526 error = kern_access(&nd, args->flags, 0);
527 nlookup_done(&nd);
528 rel_mplock();
529 linux_free_path(&path);
530 return(error);
531 }
532
533 /*
534 * MPALMOSTSAFE
535 */
536 int
537 sys_linux_unlink(struct linux_unlink_args *args)
538 {
539 struct nlookupdata nd;
540 char *path;
541 int error;
542
543 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
544 if (error)
545 return (error);
546 #ifdef DEBUG
547 if (ldebug(unlink))
548 kprintf(ARGS(unlink, "%s"), path);
549 #endif
550 get_mplock();
551 error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
552 if (error == 0)
553 error = kern_unlink(&nd);
554 nlookup_done(&nd);
555 rel_mplock();
556 linux_free_path(&path);
557 return(error);
558 }
559
560 /*
561 * MPALMOSTSAFE
562 */
563 int
564 sys_linux_chdir(struct linux_chdir_args *args)
565 {
566 struct nlookupdata nd;
567 char *path;
568 int error;
569
570 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
571 if (error)
572 return (error);
573 #ifdef DEBUG
574 if (ldebug(chdir))
575 kprintf(ARGS(chdir, "%s"), path);
576 #endif
577 get_mplock();
578 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
579 if (error == 0) {
580 error = kern_chdir(&nd);
581 nlookup_done(&nd);
582 }
583 rel_mplock();
584 linux_free_path(&path);
585 return(error);
586 }
587
588 /*
589 * MPALMOSTSAFE
590 */
591 int
592 sys_linux_chmod(struct linux_chmod_args *args)
593 {
594 struct nlookupdata nd;
595 char *path;
596 int error;
597
598 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
599 if (error)
600 return (error);
601 #ifdef DEBUG
602 if (ldebug(chmod))
603 kprintf(ARGS(chmod, "%s, %d"), path, args->mode);
604 #endif
605 get_mplock();
606 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
607 if (error == 0)
608 error = kern_chmod(&nd, args->mode);
609 nlookup_done(&nd);
610 rel_mplock();
611 linux_free_path(&path);
612 return(error);
613 }
614
615 /*
616 * MPALMOSTSAFE
617 */
618 int
619 sys_linux_mkdir(struct linux_mkdir_args *args)
620 {
621 struct nlookupdata nd;
622 char *path;
623 int error;
624
625 error = linux_copyin_path(args->path, &path, LINUX_PATH_CREATE);
626 if (error)
627 return (error);
628 #ifdef DEBUG
629 if (ldebug(mkdir))
630 kprintf(ARGS(mkdir, "%s, %d"), path, args->mode);
631 #endif
632 get_mplock();
633 error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
634 if (error == 0)
635 error = kern_mkdir(&nd, args->mode);
636 nlookup_done(&nd);
637 rel_mplock();
638
639 linux_free_path(&path);
640 return(error);
641 }
642
643 /*
644 * MPALMOSTSAFE
645 */
646 int
647 sys_linux_rmdir(struct linux_rmdir_args *args)
648 {
649 struct nlookupdata nd;
650 char *path;
651 int error;
652
653 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
654 if (error)
655 return (error);
656 #ifdef DEBUG
657 if (ldebug(rmdir))
658 kprintf(ARGS(rmdir, "%s"), path);
659 #endif
660 get_mplock();
661 error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
662 if (error == 0)
663 error = kern_rmdir(&nd);
664 nlookup_done(&nd);
665 rel_mplock();
666 linux_free_path(&path);
667 return(error);
668 }
669
670 /*
671 * MPALMOSTSAFE
672 */
673 int
674 sys_linux_rename(struct linux_rename_args *args)
675 {
676 struct nlookupdata fromnd, tond;
677 char *from, *to;
678 int error;
679
680 error = linux_copyin_path(args->from, &from, LINUX_PATH_EXISTS);
681 if (error)
682 return (error);
683 error = linux_copyin_path(args->to, &to, LINUX_PATH_CREATE);
684 if (error) {
685 linux_free_path(&from);
686 return (error);
687 }
688 #ifdef DEBUG
689 if (ldebug(rename))
690 kprintf(ARGS(rename, "%s, %s"), from, to);
691 #endif
692 get_mplock();
693 error = nlookup_init(&fromnd, from, UIO_SYSSPACE, 0);
694 if (error == 0) {
695 error = nlookup_init(&tond, to, UIO_SYSSPACE, 0);
696 if (error == 0)
697 error = kern_rename(&fromnd, &tond);
698 nlookup_done(&tond);
699 }
700 nlookup_done(&fromnd);
701 rel_mplock();
702 linux_free_path(&from);
703 linux_free_path(&to);
704 return(error);
705 }
706
707 /*
708 * MPALMOSTSAFE
709 */
710 int
711 sys_linux_symlink(struct linux_symlink_args *args)
712 {
713 struct thread *td = curthread;
714 struct nlookupdata nd;
715 char *path, *link;
716 int error;
717 int mode;
718
719 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
720 if (error)
721 return (error);
722 error = linux_copyin_path(args->to, &link, LINUX_PATH_CREATE);
723 if (error) {
724 linux_free_path(&path);
725 return (error);
726 }
727 #ifdef DEBUG
728 if (ldebug(symlink))
729 kprintf(ARGS(symlink, "%s, %s"), path, link);
730 #endif
731 get_mplock();
732 error = nlookup_init(&nd, link, UIO_SYSSPACE, 0);
733 if (error == 0) {
734 mode = ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask;
735 error = kern_symlink(&nd, path, mode);
736 }
737 nlookup_done(&nd);
738 rel_mplock();
739 linux_free_path(&path);
740 linux_free_path(&link);
741 return(error);
742 }
743
744 /*
745 * MPALMOSTSAFE
746 */
747 int
748 sys_linux_readlink(struct linux_readlink_args *args)
749 {
750 struct nlookupdata nd;
751 char *path;
752 int error;
753
754 error = linux_copyin_path(args->name, &path, LINUX_PATH_EXISTS);
755 if (error)
756 return (error);
757 #ifdef DEBUG
758 if (ldebug(readlink))
759 kprintf(ARGS(readlink, "%s, %p, %d"), path, (void *)args->buf,
760 args->count);
761 #endif
762 get_mplock();
763 error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
764 if (error == 0) {
765 error = kern_readlink(&nd, args->buf, args->count,
766 &args->sysmsg_iresult);
767 }
768 nlookup_done(&nd);
769 rel_mplock();
770 linux_free_path(&path);
771 return(error);
772 }
773
774 /*
775 * MPALMOSTSAFE
776 */
777 int
778 sys_linux_truncate(struct linux_truncate_args *args)
779 {
780 struct nlookupdata nd;
781 char *path;
782 int error;
783
784 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
785 if (error)
786 return (error);
787 #ifdef DEBUG
788 if (ldebug(truncate))
789 kprintf(ARGS(truncate, "%s, %ld"), path,
790 (long)args->length);
791 #endif
792 get_mplock();
793 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
794 if (error == 0)
795 error = kern_truncate(&nd, args->length);
796 nlookup_done(&nd);
797 rel_mplock();
798 linux_free_path(&path);
799 return(error);
800 }
801
802 /*
803 * MPALMOSTSAFE
804 */
805 int
806 sys_linux_truncate64(struct linux_truncate64_args *args)
807 {
808 struct nlookupdata nd;
809 char *path;
810 int error;
811
812 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
813 if (error)
814 return (error);
815 #ifdef DEBUG
816 if (ldebug(truncate64))
817 kprintf(ARGS(truncate64, "%s, %lld"), path,
818 (off_t)args->length);
819 #endif
820 get_mplock();
821 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
822 if (error == 0)
823 error = kern_truncate(&nd, args->length);
824 nlookup_done(&nd);
825 rel_mplock();
826 linux_free_path(&path);
827 return error;
828 }
829
830 /*
831 * MPALMOSTSAFE
832 */
833 int
834 sys_linux_ftruncate(struct linux_ftruncate_args *args)
835 {
836 int error;
837
838 #ifdef DEBUG
839 if (ldebug(ftruncate))
840 kprintf(ARGS(ftruncate, "%d, %ld"), args->fd,
841 (long)args->length);
842 #endif
843 get_mplock();
844 error = kern_ftruncate(args->fd, args->length);
845 rel_mplock();
846
847 return error;
848 }
849
850 /*
851 * MPALMOSTSAFE
852 */
853 int
854 sys_linux_ftruncate64(struct linux_ftruncate64_args *args)
855 {
856 int error;
857
858 #ifdef DEBUG
859 if (ldebug(ftruncate))
860 kprintf(ARGS(ftruncate64, "%d, %lld"), args->fd,
861 (off_t)args->length);
862 #endif
863 get_mplock();
864 error = kern_ftruncate(args->fd, args->length);
865 rel_mplock();
866
867 return error;
868 }
869
870 /*
871 * MPALMOSTSAFE
872 */
873 int
874 sys_linux_link(struct linux_link_args *args)
875 {
876 struct nlookupdata nd, linknd;
877 char *path, *link;
878 int error;
879
880 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
881 if (error)
882 return (error);
883 error = linux_copyin_path(args->to, &link, LINUX_PATH_CREATE);
884 if (error) {
885 linux_free_path(&path);
886 return (error);
887 }
888 #ifdef DEBUG
889 if (ldebug(link))
890 kprintf(ARGS(link, "%s, %s"), path, link);
891 #endif
892 get_mplock();
893 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
894 if (error == 0) {
895 error = nlookup_init(&linknd, link, UIO_SYSSPACE, 0);
896 if (error == 0)
897 error = kern_link(&nd, &linknd);
898 nlookup_done(&linknd);
899 }
900 nlookup_done(&nd);
901 rel_mplock();
902 linux_free_path(&path);
903 linux_free_path(&link);
904 return(error);
905 }
906
907 /*
908 * MPSAFE
909 */
910 int
911 sys_linux_fdatasync(struct linux_fdatasync_args *uap)
912 {
913 struct fsync_args bsd;
914 int error;
915
916 bsd.fd = uap->fd;
917 bsd.sysmsg_iresult = 0;
918
919 error = sys_fsync(&bsd);
920 uap->sysmsg_iresult = bsd.sysmsg_iresult;
921 return(error);
922 }
923
924 /*
925 * MPSAFE
926 */
927 int
928 sys_linux_pread(struct linux_pread_args *uap)
929 {
930 struct thread *td = curthread;
931 struct uio auio;
932 struct iovec aiov;
933 int error;
934
935 aiov.iov_base = uap->buf;
936 aiov.iov_len = uap->nbyte;
937 auio.uio_iov = &aiov;
938 auio.uio_iovcnt = 1;
939 auio.uio_offset = uap->offset;
940 auio.uio_resid = uap->nbyte;
941 auio.uio_rw = UIO_READ;
942 auio.uio_segflg = UIO_USERSPACE;
943 auio.uio_td = td;
944
945 if ((ssize_t)auio.uio_resid < 0) {
946 error = EINVAL;
947 } else {
948 error = kern_preadv(uap->fd, &auio, O_FOFFSET,
949 &uap->sysmsg_szresult);
950 }
951 return(error);
952 }
953
954 /*
955 * MPSAFE
956 */
957 int
958 sys_linux_pwrite(struct linux_pwrite_args *uap)
959 {
960 struct thread *td = curthread;
961 struct uio auio;
962 struct iovec aiov;
963 int error;
964
965 aiov.iov_base = uap->buf;
966 aiov.iov_len = uap->nbyte;
967 auio.uio_iov = &aiov;
968 auio.uio_iovcnt = 1;
969 auio.uio_offset = uap->offset;
970 auio.uio_resid = uap->nbyte;
971 auio.uio_rw = UIO_WRITE;
972 auio.uio_segflg = UIO_USERSPACE;
973 auio.uio_td = td;
974
975 if ((ssize_t)auio.uio_resid < 0) {
976 error = EINVAL;
977 } else {
978 error = kern_pwritev(uap->fd, &auio, O_FOFFSET,
979 &uap->sysmsg_szresult);
980 }
981 return(error);
982 }
983
984 /*
985 * MPSAFE
986 */
987 int
988 sys_linux_oldumount(struct linux_oldumount_args *args)
989 {
990 struct linux_umount_args args2;
991 int error;
992
993 args2.path = args->path;
994 args2.flags = 0;
995 args2.sysmsg_iresult = 0;
996 error = sys_linux_umount(&args2);
997 args->sysmsg_iresult = args2.sysmsg_iresult;
998 return(error);
999 }
1000
1001 /*
1002 * MPSAFE
1003 */
1004 int
1005 sys_linux_umount(struct linux_umount_args *args)
1006 {
1007 struct unmount_args bsd;
1008 int error;
1009
1010 bsd.path = args->path;
1011 bsd.flags = args->flags; /* XXX correct? */
1012 bsd.sysmsg_iresult = 0;
1013
1014 error = sys_unmount(&bsd);
1015 args->sysmsg_iresult = bsd.sysmsg_iresult;
1016 return(error);
1017 }
1018
1019 /*
1020 * fcntl family of syscalls
1021 */
1022 struct l_flock {
1023 l_short l_type;
1024 l_short l_whence;
1025 l_off_t l_start;
1026 l_off_t l_len;
1027 l_pid_t l_pid;
1028 };
1029
1030 /*
1031 * MPSAFE
1032 */
1033 static void
1034 linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock)
1035 {
1036 switch (linux_flock->l_type) {
1037 case LINUX_F_RDLCK:
1038 bsd_flock->l_type = F_RDLCK;
1039 break;
1040 case LINUX_F_WRLCK:
1041 bsd_flock->l_type = F_WRLCK;
1042 break;
1043 case LINUX_F_UNLCK:
1044 bsd_flock->l_type = F_UNLCK;
1045 break;
1046 default:
1047 bsd_flock->l_type = -1;
1048 break;
1049 }
1050 bsd_flock->l_whence = linux_flock->l_whence;
1051 bsd_flock->l_start = (off_t)linux_flock->l_start;
1052 bsd_flock->l_len = (off_t)linux_flock->l_len;
1053 bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1054 }
1055
1056 /*
1057 * MPSAFE
1058 */
1059 static void
1060 bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock)
1061 {
1062 switch (bsd_flock->l_type) {
1063 case F_RDLCK:
1064 linux_flock->l_type = LINUX_F_RDLCK;
1065 break;
1066 case F_WRLCK:
1067 linux_flock->l_type = LINUX_F_WRLCK;
1068 break;
1069 case F_UNLCK:
1070 linux_flock->l_type = LINUX_F_UNLCK;
1071 break;
1072 }
1073 linux_flock->l_whence = bsd_flock->l_whence;
1074 linux_flock->l_start = (l_off_t)bsd_flock->l_start;
1075 linux_flock->l_len = (l_off_t)bsd_flock->l_len;
1076 linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1077 }
1078
1079 #if defined(__i386__)
1080 struct l_flock64 {
1081 l_short l_type;
1082 l_short l_whence;
1083 l_loff_t l_start;
1084 l_loff_t l_len;
1085 l_pid_t l_pid;
1086 };
1087
1088 /*
1089 * MPSAFE
1090 */
1091 static void
1092 linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock)
1093 {
1094 switch (linux_flock->l_type) {
1095 case LINUX_F_RDLCK:
1096 bsd_flock->l_type = F_RDLCK;
1097 break;
1098 case LINUX_F_WRLCK:
1099 bsd_flock->l_type = F_WRLCK;
1100 break;
1101 case LINUX_F_UNLCK:
1102 bsd_flock->l_type = F_UNLCK;
1103 break;
1104 default:
1105 bsd_flock->l_type = -1;
1106 break;
1107 }
1108 bsd_flock->l_whence = linux_flock->l_whence;
1109 bsd_flock->l_start = (off_t)linux_flock->l_start;
1110 bsd_flock->l_len = (off_t)linux_flock->l_len;
1111 bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1112 }
1113
1114 /*
1115 * MPSAFE
1116 */
1117 static void
1118 bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock)
1119 {
1120 switch (bsd_flock->l_type) {
1121 case F_RDLCK:
1122 linux_flock->l_type = LINUX_F_RDLCK;
1123 break;
1124 case F_WRLCK:
1125 linux_flock->l_type = LINUX_F_WRLCK;
1126 break;
1127 case F_UNLCK:
1128 linux_flock->l_type = LINUX_F_UNLCK;
1129 break;
1130 }
1131 linux_flock->l_whence = bsd_flock->l_whence;
1132 linux_flock->l_start = (l_loff_t)bsd_flock->l_start;
1133 linux_flock->l_len = (l_loff_t)bsd_flock->l_len;
1134 linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1135 }
1136 #endif /* __i386__ */
1137
1138 /*
1139 * MPSAFE
1140 */
1141 static int
1142 linux_fcntl_common(struct linux_fcntl64_args *args)
1143 {
1144 struct thread *td = curthread;
1145 struct l_flock linux_flock;
1146 struct file *fp;
1147 union fcntl_dat dat;
1148 int error, cmd;
1149
1150 switch (args->cmd) {
1151 case LINUX_F_DUPFD:
1152 cmd = F_DUPFD;
1153 dat.fc_fd = args->arg;
1154 break;
1155 case LINUX_F_GETFD:
1156 cmd = F_GETFD;
1157 break;
1158 case LINUX_F_SETFD:
1159 cmd = F_SETFD;
1160 dat.fc_cloexec = args->arg;
1161 break;
1162 case LINUX_F_GETFL:
1163 cmd = F_GETFL;
1164 break;
1165 case LINUX_F_SETFL:
1166 cmd = F_SETFL;
1167 dat.fc_flags = 0;
1168 if (args->arg & LINUX_O_NDELAY)
1169 dat.fc_flags |= O_NONBLOCK;
1170 if (args->arg & LINUX_O_APPEND)
1171 dat.fc_flags |= O_APPEND;
1172 if (args->arg & LINUX_O_SYNC)
1173 dat.fc_flags |= O_FSYNC;
1174 if (args->arg & LINUX_FASYNC)
1175 dat.fc_flags |= O_ASYNC;
1176 break;
1177 case LINUX_F_GETLK:
1178 case LINUX_F_SETLK:
1179 case LINUX_F_SETLKW:
1180 cmd = F_GETLK;
1181 error = copyin((caddr_t)args->arg, &linux_flock,
1182 sizeof(linux_flock));
1183 if (error)
1184 return (error);
1185 linux_to_bsd_flock(&linux_flock, &dat.fc_flock);
1186 break;
1187 case LINUX_F_GETOWN:
1188 cmd = F_GETOWN;
1189 break;
1190 case LINUX_F_SETOWN:
1191 /*
1192 * XXX some Linux applications depend on F_SETOWN having no
1193 * significant effect for pipes (SIGIO is not delivered for
1194 * pipes under Linux-2.2.35 at least).
1195 */
1196 fp = holdfp(td->td_proc->p_fd, args->fd, -1);
1197 if (fp == NULL)
1198 return (EBADF);
1199 if (fp->f_type == DTYPE_PIPE) {
1200 fdrop(fp);
1201 return (EINVAL);
1202 }
1203 fdrop(fp);
1204 cmd = F_SETOWN;
1205 dat.fc_owner = args->arg;
1206 break;
1207 default:
1208 return (EINVAL);
1209 }
1210
1211 /* MPSAFE */
1212 error = kern_fcntl(args->fd, cmd, &dat, td->td_ucred);
1213
1214 if (error == 0) {
1215 switch (args->cmd) {
1216 case LINUX_F_DUPFD:
1217 args->sysmsg_iresult = dat.fc_fd;
1218 break;
1219 case LINUX_F_GETFD:
1220 args->sysmsg_iresult = dat.fc_cloexec;
1221 break;
1222 case LINUX_F_SETFD:
1223 break;
1224 case LINUX_F_GETFL:
1225 args->sysmsg_iresult = 0;
1226 if (dat.fc_flags & O_RDONLY)
1227 args->sysmsg_iresult |= LINUX_O_RDONLY;
1228 if (dat.fc_flags & O_WRONLY)
1229 args->sysmsg_iresult |= LINUX_O_WRONLY;
1230 if (dat.fc_flags & O_RDWR)
1231 args->sysmsg_iresult |= LINUX_O_RDWR;
1232 if (dat.fc_flags & O_NDELAY)
1233 args->sysmsg_iresult |= LINUX_O_NONBLOCK;
1234 if (dat.fc_flags & O_APPEND)
1235 args->sysmsg_iresult |= LINUX_O_APPEND;
1236 if (dat.fc_flags & O_FSYNC)
1237 args->sysmsg_iresult |= LINUX_O_SYNC;
1238 if (dat.fc_flags & O_ASYNC)
1239 args->sysmsg_iresult |= LINUX_FASYNC;
1240 break;
1241 case LINUX_F_GETLK:
1242 bsd_to_linux_flock(&dat.fc_flock, &linux_flock);
1243 error = copyout(&linux_flock, (caddr_t)args->arg,
1244 sizeof(linux_flock));
1245 break;
1246 case LINUX_F_SETLK:
1247 case LINUX_F_SETLKW:
1248 break;
1249 case LINUX_F_GETOWN:
1250 args->sysmsg_iresult = dat.fc_owner;
1251 break;
1252 case LINUX_F_SETOWN:
1253 break;
1254 }
1255 }
1256
1257 return(error);
1258 }
1259
1260 /*
1261 * MPSAFE
1262 */
1263 int
1264 sys_linux_fcntl(struct linux_fcntl_args *args)
1265 {
1266 struct linux_fcntl64_args args64;
1267 int error;
1268
1269 #ifdef DEBUG
1270 if (ldebug(fcntl))
1271 kprintf(ARGS(fcntl, "%d, %08x, *"), args->fd, args->cmd);
1272 #endif
1273
1274 args64.fd = args->fd;
1275 args64.cmd = args->cmd;
1276 args64.arg = args->arg;
1277 args64.sysmsg_iresult = 0;
1278 error = linux_fcntl_common(&args64);
1279 args->sysmsg_iresult = args64.sysmsg_iresult;
1280 return(error);
1281 }
1282
1283 #if defined(__i386__)
1284 /*
1285 * MPSAFE
1286 */
1287 int
1288 sys_linux_fcntl64(struct linux_fcntl64_args *args)
1289 {
1290 struct thread *td = curthread;
1291 struct l_flock64 linux_flock;
1292 union fcntl_dat dat;
1293 int error, cmd = 0;
1294
1295 #ifdef DEBUG
1296 if (ldebug(fcntl64))
1297 kprintf(ARGS(fcntl64, "%d, %08x, *"), args->fd, args->cmd);
1298 #endif
1299 if (args->cmd == LINUX_F_GETLK64 || args->cmd == LINUX_F_SETLK64 ||
1300 args->cmd == LINUX_F_SETLKW64) {
1301 switch (args->cmd) {
1302 case LINUX_F_GETLK64:
1303 cmd = F_GETLK;
1304 break;
1305 case LINUX_F_SETLK64:
1306 cmd = F_SETLK;
1307 break;
1308 case LINUX_F_SETLKW64:
1309 cmd = F_SETLKW;
1310 break;
1311 }
1312
1313 error = copyin((caddr_t)args->arg, &linux_flock,
1314 sizeof(linux_flock));
1315 if (error)
1316 return (error);
1317 linux_to_bsd_flock64(&linux_flock, &dat.fc_flock);
1318
1319 /* MPSAFE */
1320 error = kern_fcntl(args->fd, cmd, &dat, td->td_ucred);
1321
1322 if (error == 0 && args->cmd == LINUX_F_GETLK64) {
1323 bsd_to_linux_flock64(&dat.fc_flock, &linux_flock);
1324 error = copyout(&linux_flock, (caddr_t)args->arg,
1325 sizeof(linux_flock));
1326 }
1327 } else {
1328 error = linux_fcntl_common(args);
1329 }
1330
1331 return (error);
1332 }
1333 #endif /* __i386__ */
1334
1335 /*
1336 * MPALMOSTSAFE
1337 */
1338 int
1339 sys_linux_chown(struct linux_chown_args *args)
1340 {
1341 struct nlookupdata nd;
1342 char *path;
1343 int error;
1344
1345 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
1346 if (error)
1347 return (error);
1348 #ifdef DEBUG
1349 if (ldebug(chown))
1350 kprintf(ARGS(chown, "%s, %d, %d"), path, args->uid, args->gid);
1351 #endif
1352 get_mplock();
1353 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
1354 if (error == 0)
1355 error = kern_chown(&nd, args->uid, args->gid);
1356 nlookup_done(&nd);
1357 rel_mplock();
1358 linux_free_path(&path);
1359 return(error);
1360 }
1361
1362 /*
1363 * MPALMOSTSAFE
1364 */
1365 int
1366 sys_linux_lchown(struct linux_lchown_args *args)
1367 {
1368 struct nlookupdata nd;
1369 char *path;
1370 int error;
1371
1372 error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
1373 if (error)
1374 return (error);
1375 #ifdef DEBUG
1376 if (ldebug(lchown))
1377 kprintf(ARGS(lchown, "%s, %d, %d"), path, args->uid, args->gid);
1378 #endif
1379 get_mplock();
1380 error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
1381 if (error == 0)
1382 error = kern_chown(&nd, args->uid, args->gid);
1383 nlookup_done(&nd);
1384 rel_mplock();
1385 linux_free_path(&path);
1386 return(error);
1387 }
1388
DragonFly BSD