1 /* $NetBSD: sys_descrip.c,v 1.7.4.1 2009/02/02 02:53:51 snj Exp $ */
2
3 /*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * Copyright (c) 1982, 1986, 1989, 1991, 1993
31 * The Regents of the University of California. All rights reserved.
32 * (c) UNIX System Laboratories, Inc.
33 * All or some portions of this file are derived from material licensed
34 * to the University of California by American Telephone and Telegraph
35 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
36 * the permission of UNIX System Laboratories, Inc.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. Neither the name of the University nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60 * SUCH DAMAGE.
61 *
62 * @(#)kern_descrip.c 8.8 (Berkeley) 2/14/95
63 */
64
65 /*
66 * System calls on descriptors.
67 */
68
69 #include <sys/cdefs.h>
70 __KERNEL_RCSID(0, "$NetBSD: sys_descrip.c,v 1.7.4.1 2009/02/02 02:53:51 snj Exp $");
71
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/filedesc.h>
75 #include <sys/kernel.h>
76 #include <sys/vnode.h>
77 #include <sys/proc.h>
78 #include <sys/file.h>
79 #include <sys/namei.h>
80 #include <sys/socket.h>
81 #include <sys/socketvar.h>
82 #include <sys/stat.h>
83 #include <sys/ioctl.h>
84 #include <sys/fcntl.h>
85 #include <sys/malloc.h>
86 #include <sys/pool.h>
87 #include <sys/syslog.h>
88 #include <sys/unistd.h>
89 #include <sys/resourcevar.h>
90 #include <sys/conf.h>
91 #include <sys/event.h>
92 #include <sys/kauth.h>
93 #include <sys/atomic.h>
94 #include <sys/mount.h>
95 #include <sys/syscallargs.h>
96
97 /*
98 * Duplicate a file descriptor.
99 */
100 int
101 sys_dup(struct lwp *l, const struct sys_dup_args *uap, register_t *retval)
102 {
103 /* {
104 syscallarg(int) fd;
105 } */
106 int new, error, old;
107 file_t *fp;
108
109 old = SCARG(uap, fd);
110
111 if ((fp = fd_getfile(old)) == NULL) {
112 return EBADF;
113 }
114 error = fd_dup(fp, 0, &new, false);
115 fd_putfile(old);
116 *retval = new;
117 return error;
118 }
119
120 /*
121 * Duplicate a file descriptor to a particular value.
122 */
123 int
124 sys_dup2(struct lwp *l, const struct sys_dup2_args *uap, register_t *retval)
125 {
126 /* {
127 syscallarg(int) from;
128 syscallarg(int) to;
129 } */
130 int old, new, error;
131 file_t *fp;
132
133 old = SCARG(uap, from);
134 new = SCARG(uap, to);
135
136 if ((fp = fd_getfile(old)) == NULL) {
137 return EBADF;
138 }
139 mutex_enter(&fp->f_lock);
140 fp->f_count++;
141 mutex_exit(&fp->f_lock);
142 fd_putfile(old);
143
144 if ((u_int)new >= curproc->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
145 (u_int)new >= maxfiles) {
146 error = EBADF;
147 } else if (old == new) {
148 error = 0;
149 } else {
150 error = fd_dup2(fp, new);
151 }
152 closef(fp);
153 *retval = new;
154
155 return error;
156 }
157
158 /*
159 * fcntl call which is being passed to the file's fs.
160 */
161 static int
162 fcntl_forfs(int fd, file_t *fp, int cmd, void *arg)
163 {
164 int error;
165 u_int size;
166 void *data, *memp;
167 #define STK_PARAMS 128
168 char stkbuf[STK_PARAMS];
169
170 if ((fp->f_flag & (FREAD | FWRITE)) == 0)
171 return (EBADF);
172
173 /*
174 * Interpret high order word to find amount of data to be
175 * copied to/from the user's address space.
176 */
177 size = (size_t)F_PARAM_LEN(cmd);
178 if (size > F_PARAM_MAX)
179 return (EINVAL);
180 memp = NULL;
181 if (size > sizeof(stkbuf)) {
182 memp = kmem_alloc(size, KM_SLEEP);
183 data = memp;
184 } else
185 data = stkbuf;
186 if (cmd & F_FSIN) {
187 if (size) {
188 error = copyin(arg, data, size);
189 if (error) {
190 if (memp)
191 kmem_free(memp, size);
192 return (error);
193 }
194 } else
195 *(void **)data = arg;
196 } else if ((cmd & F_FSOUT) != 0 && size != 0) {
197 /*
198 * Zero the buffer so the user always
199 * gets back something deterministic.
200 */
201 memset(data, 0, size);
202 } else if (cmd & F_FSVOID)
203 *(void **)data = arg;
204
205
206 error = (*fp->f_ops->fo_fcntl)(fp, cmd, data);
207
208 /*
209 * Copy any data to user, size was
210 * already set and checked above.
211 */
212 if (error == 0 && (cmd & F_FSOUT) && size)
213 error = copyout(data, arg, size);
214 if (memp)
215 kmem_free(memp, size);
216 return (error);
217 }
218
219 int
220 do_fcntl_lock(int fd, int cmd, struct flock *fl)
221 {
222 file_t *fp;
223 vnode_t *vp;
224 proc_t *p;
225 int error, flg;
226
227 if ((fp = fd_getfile(fd)) == NULL)
228 return EBADF;
229 if (fp->f_type != DTYPE_VNODE) {
230 fd_putfile(fd);
231 return EINVAL;
232 }
233 vp = fp->f_data;
234 if (fl->l_whence == SEEK_CUR)
235 fl->l_start += fp->f_offset;
236
237 flg = F_POSIX;
238 p = curproc;
239
240 switch (cmd) {
241 case F_SETLKW:
242 flg |= F_WAIT;
243 /* Fall into F_SETLK */
244
245 case F_SETLK:
246 switch (fl->l_type) {
247 case F_RDLCK:
248 if ((fp->f_flag & FREAD) == 0) {
249 error = EBADF;
250 break;
251 }
252 if ((p->p_flag & PK_ADVLOCK) == 0) {
253 mutex_enter(p->p_lock);
254 p->p_flag |= PK_ADVLOCK;
255 mutex_exit(p->p_lock);
256 }
257 error = VOP_ADVLOCK(vp, p, F_SETLK, fl, flg);
258 break;
259
260 case F_WRLCK:
261 if ((fp->f_flag & FWRITE) == 0) {
262 error = EBADF;
263 break;
264 }
265 if ((p->p_flag & PK_ADVLOCK) == 0) {
266 mutex_enter(p->p_lock);
267 p->p_flag |= PK_ADVLOCK;
268 mutex_exit(p->p_lock);
269 }
270 error = VOP_ADVLOCK(vp, p, F_SETLK, fl, flg);
271 break;
272
273 case F_UNLCK:
274 error = VOP_ADVLOCK(vp, p, F_UNLCK, fl, F_POSIX);
275 break;
276
277 default:
278 error = EINVAL;
279 break;
280 }
281 break;
282
283 case F_GETLK:
284 if (fl->l_type != F_RDLCK &&
285 fl->l_type != F_WRLCK &&
286 fl->l_type != F_UNLCK) {
287 error = EINVAL;
288 break;
289 }
290 error = VOP_ADVLOCK(vp, p, F_GETLK, fl, F_POSIX);
291 break;
292
293 default:
294 error = EINVAL;
295 break;
296 }
297
298 fd_putfile(fd);
299 return error;
300 }
301
302 /*
303 * The file control system call.
304 */
305 int
306 sys_fcntl(struct lwp *l, const struct sys_fcntl_args *uap, register_t *retval)
307 {
308 /* {
309 syscallarg(int) fd;
310 syscallarg(int) cmd;
311 syscallarg(void *) arg;
312 } */
313 int fd, i, tmp, error, cmd, newmin;
314 filedesc_t *fdp;
315 file_t *fp;
316 fdfile_t *ff;
317 struct flock fl;
318
319 fd = SCARG(uap, fd);
320 cmd = SCARG(uap, cmd);
321 fdp = l->l_fd;
322 error = 0;
323
324 switch (cmd) {
325 case F_CLOSEM:
326 if (fd < 0)
327 return EBADF;
328 while ((i = fdp->fd_lastfile) >= fd) {
329 if (fd_getfile(i) == NULL) {
330 /* Another thread has updated. */
331 continue;
332 }
333 fd_close(i);
334 }
335 return 0;
336
337 case F_MAXFD:
338 *retval = fdp->fd_lastfile;
339 return 0;
340
341 case F_SETLKW:
342 case F_SETLK:
343 case F_GETLK:
344 error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
345 if (error)
346 return error;
347 error = do_fcntl_lock(fd, cmd, &fl);
348 if (cmd == F_GETLK && error == 0)
349 error = copyout(&fl, SCARG(uap, arg), sizeof(fl));
350 return error;
351
352 default:
353 /* Handled below */
354 break;
355 }
356
357 if ((fp = fd_getfile(fd)) == NULL)
358 return (EBADF);
359 ff = fdp->fd_ofiles[fd];
360
361 if ((cmd & F_FSCTL)) {
362 error = fcntl_forfs(fd, fp, cmd, SCARG(uap, arg));
363 fd_putfile(fd);
364 return error;
365 }
366
367 switch (cmd) {
368 case F_DUPFD:
369 newmin = (long)SCARG(uap, arg);
370 if ((u_int)newmin >=
371 l->l_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
372 (u_int)newmin >= maxfiles) {
373 fd_putfile(fd);
374 return EINVAL;
375 }
376 error = fd_dup(fp, newmin, &i, false);
377 *retval = i;
378 break;
379
380 case F_GETFD:
381 *retval = ff->ff_exclose;
382 break;
383
384 case F_SETFD:
385 if ((long)SCARG(uap, arg) & 1) {
386 ff->ff_exclose = true;
387 fdp->fd_exclose = true;
388 } else {
389 ff->ff_exclose = false;
390 }
391 break;
392
393 case F_GETFL:
394 *retval = OFLAGS(fp->f_flag);
395 break;
396
397 case F_SETFL:
398 /* XXX not guaranteed to be atomic. */
399 tmp = FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
400 error = (*fp->f_ops->fo_fcntl)(fp, F_SETFL, &tmp);
401 if (error)
402 break;
403 i = tmp ^ fp->f_flag;
404 if (i & FNONBLOCK) {
405 int flgs = tmp & FNONBLOCK;
406 error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, &flgs);
407 if (error) {
408 (*fp->f_ops->fo_fcntl)(fp, F_SETFL,
409 &fp->f_flag);
410 break;
411 }
412 }
413 if (i & FASYNC) {
414 int flgs = tmp & FASYNC;
415 error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, &flgs);
416 if (error) {
417 if (i & FNONBLOCK) {
418 tmp = fp->f_flag & FNONBLOCK;
419 (void)(*fp->f_ops->fo_ioctl)(fp,
420 FIONBIO, &tmp);
421 }
422 (*fp->f_ops->fo_fcntl)(fp, F_SETFL,
423 &fp->f_flag);
424 break;
425 }
426 }
427 fp->f_flag = (fp->f_flag & ~FCNTLFLAGS) | tmp;
428 break;
429
430 case F_GETOWN:
431 error = (*fp->f_ops->fo_ioctl)(fp, FIOGETOWN, &tmp);
432 *retval = tmp;
433 break;
434
435 case F_SETOWN:
436 tmp = (int)(uintptr_t) SCARG(uap, arg);
437 error = (*fp->f_ops->fo_ioctl)(fp, FIOSETOWN, &tmp);
438 break;
439
440 default:
441 error = EINVAL;
442 }
443
444 fd_putfile(fd);
445 return (error);
446 }
447
448 /*
449 * Close a file descriptor.
450 */
451 int
452 sys_close(struct lwp *l, const struct sys_close_args *uap, register_t *retval)
453 {
454 /* {
455 syscallarg(int) fd;
456 } */
457
458 if (fd_getfile(SCARG(uap, fd)) == NULL) {
459 return EBADF;
460 }
461 return fd_close(SCARG(uap, fd));
462 }
463
464 /*
465 * Return status information about a file descriptor.
466 * Common function for compat code.
467 */
468 int
469 do_sys_fstat(int fd, struct stat *sb)
470 {
471 file_t *fp;
472 int error;
473
474 if ((fp = fd_getfile(fd)) == NULL) {
475 return EBADF;
476 }
477 error = (*fp->f_ops->fo_stat)(fp, sb);
478 fd_putfile(fd);
479
480 return error;
481 }
482
483 /*
484 * Return status information about a file descriptor.
485 */
486 int
487 sys___fstat30(struct lwp *l, const struct sys___fstat30_args *uap,
488 register_t *retval)
489 {
490 /* {
491 syscallarg(int) fd;
492 syscallarg(struct stat *) sb;
493 } */
494 struct stat sb;
495 int error;
496
497 error = do_sys_fstat(SCARG(uap, fd), &sb);
498 if (error == 0) {
499 error = copyout(&sb, SCARG(uap, sb), sizeof(sb));
500 }
501 return error;
502 }
503
504 /*
505 * Return pathconf information about a file descriptor.
506 */
507 int
508 sys_fpathconf(struct lwp *l, const struct sys_fpathconf_args *uap,
509 register_t *retval)
510 {
511 /* {
512 syscallarg(int) fd;
513 syscallarg(int) name;
514 } */
515 int fd, error;
516 file_t *fp;
517
518 fd = SCARG(uap, fd);
519 error = 0;
520
521 if ((fp = fd_getfile(fd)) == NULL) {
522 return (EBADF);
523 }
524 switch (fp->f_type) {
525 case DTYPE_SOCKET:
526 case DTYPE_PIPE:
527 if (SCARG(uap, name) != _PC_PIPE_BUF)
528 error = EINVAL;
529 else
530 *retval = PIPE_BUF;
531 break;
532
533 case DTYPE_VNODE:
534 error = VOP_PATHCONF(fp->f_data, SCARG(uap, name), retval);
535 break;
536
537 case DTYPE_KQUEUE:
538 error = EINVAL;
539 break;
540
541 default:
542 error = EOPNOTSUPP;
543 break;
544 }
545
546 fd_putfile(fd);
547 return (error);
548 }
549
550 /*
551 * Apply an advisory lock on a file descriptor.
552 *
553 * Just attempt to get a record lock of the requested type on
554 * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
555 */
556 /* ARGSUSED */
557 int
558 sys_flock(struct lwp *l, const struct sys_flock_args *uap, register_t *retval)
559 {
560 /* {
561 syscallarg(int) fd;
562 syscallarg(int) how;
563 } */
564 int fd, how, error;
565 file_t *fp;
566 vnode_t *vp;
567 struct flock lf;
568 proc_t *p;
569
570 fd = SCARG(uap, fd);
571 how = SCARG(uap, how);
572 error = 0;
573
574 if ((fp = fd_getfile(fd)) == NULL) {
575 return EBADF;
576 }
577 if (fp->f_type != DTYPE_VNODE) {
578 fd_putfile(fd);
579 return EOPNOTSUPP;
580 }
581
582 vp = fp->f_data;
583 lf.l_whence = SEEK_SET;
584 lf.l_start = 0;
585 lf.l_len = 0;
586 if (how & LOCK_UN) {
587 lf.l_type = F_UNLCK;
588 atomic_and_uint(&fp->f_flag, ~FHASLOCK);
589 error = VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
590 fd_putfile(fd);
591 return error;
592 }
593 if (how & LOCK_EX) {
594 lf.l_type = F_WRLCK;
595 } else if (how & LOCK_SH) {
596 lf.l_type = F_RDLCK;
597 } else {
598 fd_putfile(fd);
599 return EINVAL;
600 }
601 atomic_or_uint(&fp->f_flag, FHASLOCK);
602 p = curproc;
603 if (how & LOCK_NB) {
604 error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK);
605 } else {
606 error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK|F_WAIT);
607 }
608 fd_putfile(fd);
609 return error;
610 }
611
612 int
613 do_posix_fadvise(int fd, off_t offset, off_t len, int advice)
614 {
615 file_t *fp;
616 int error;
617
618 if ((fp = fd_getfile(fd)) == NULL) {
619 return EBADF;
620 }
621 if (fp->f_type != DTYPE_VNODE) {
622 if (fp->f_type == DTYPE_PIPE || fp->f_type == DTYPE_SOCKET) {
623 error = ESPIPE;
624 } else {
625 error = EOPNOTSUPP;
626 }
627 fd_putfile(fd);
628 return error;
629 }
630
631 switch (advice) {
632 case POSIX_FADV_NORMAL:
633 case POSIX_FADV_RANDOM:
634 case POSIX_FADV_SEQUENTIAL:
635 KASSERT(POSIX_FADV_NORMAL == UVM_ADV_NORMAL);
636 KASSERT(POSIX_FADV_RANDOM == UVM_ADV_RANDOM);
637 KASSERT(POSIX_FADV_SEQUENTIAL == UVM_ADV_SEQUENTIAL);
638
639 /*
640 * We ignore offset and size. must lock the file to
641 * do this, as f_advice is sub-word sized.
642 */
643 mutex_enter(&fp->f_lock);
644 fp->f_advice = (u_char)advice;
645 mutex_exit(&fp->f_lock);
646 error = 0;
647 break;
648
649 case POSIX_FADV_WILLNEED:
650 case POSIX_FADV_DONTNEED:
651 case POSIX_FADV_NOREUSE:
652 /* Not implemented yet. */
653 error = 0;
654 break;
655 default:
656 error = EINVAL;
657 break;
658 }
659
660 fd_putfile(fd);
661 return error;
662 }
663
664 int
665 sys___posix_fadvise50(struct lwp *l,
666 const struct sys___posix_fadvise50_args *uap,
667 register_t *retval)
668 {
669 /* {
670 syscallarg(int) fd;
671 syscallarg(int) pad;
672 syscallarg(off_t) offset;
673 syscallarg(off_t) len;
674 syscallarg(int) advice;
675 } */
676
677 return do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset),
678 SCARG(uap, len), SCARG(uap, advice));
679 }
Cache object: 21b24bf79847078fa00a6993b8252c8d
|