2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * Direct file pointer API functions for in-kernel operations on files. These
37 * functions provide a open/read/write/close like interface within the kernel
38 * for operating on files that are not necessarily associated with processes
39 * and which do not (typically) have descriptors.
41 * FUTURE: file handle conversion routines to support checkpointing,
42 * and additional file operations (ioctl, fcntl).
45 #include <sys/param.h>
46 #include <sys/kernel.h>
47 #include <sys/systm.h>
48 #include <sys/malloc.h>
49 #include <sys/sysproto.h>
51 #include <sys/filedesc.h>
52 #include <sys/sysctl.h>
53 #include <sys/vnode.h>
56 #include <sys/nlookup.h>
59 #include <sys/filio.h>
60 #include <sys/fcntl.h>
61 #include <sys/unistd.h>
62 #include <sys/resourcevar.h>
63 #include <sys/event.h>
67 #include <vm/vm_param.h>
70 #include <vm/vm_map.h>
71 #include <vm/vm_object.h>
72 #include <vm/vm_page.h>
73 #include <vm/vm_pager.h>
74 #include <vm/vm_pageout.h>
75 #include <vm/vm_extern.h>
76 #include <vm/vm_kern.h>
78 #include <sys/file2.h>
79 #include <machine/limits.h>
81 typedef struct file *file_t;
86 * Open a file as specified. Use O_* flags for flags.
88 * NOTE! O_ROOTCRED not quite working yet, vn_open() asserts that the
89 * cred must match the process's cred. XXX
91 * NOTE! when fp_open() is called from a pure thread, root creds are
95 fp_open(const char *path, int flags, int mode, file_t *fpp)
97 struct nlookupdata nd;
102 if ((error = falloc(NULL, fpp, NULL)) != 0)
107 if ((flags & O_ROOTCRED) == 0)
108 fsetcred(fp, td->td_proc->p_ucred);
110 error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_LOCKVP);
111 flags = FFLAGS(flags);
113 error = vn_open(&nd, fp, flags, mode);
124 * fp_vpopen(): convert a vnode to a file pointer, call VOP_OPEN() on the
125 * the vnode. The vnode must be refd and locked.
127 * On success the vnode's ref is inherited by the file pointer and the caller
128 * should not vrele() it, and the vnode is unlocked.
130 * On failure the vnode remains locked and refd and the caller is responsible
134 fp_vpopen(struct vnode *vp, int flags, file_t *fpp)
144 * Vnode checks (from vn_open())
146 if (vp->v_type == VLNK) {
150 if (vp->v_type == VSOCK) {
154 flags = FFLAGS(flags);
156 if (flags & (FWRITE | O_TRUNC)) {
157 if (vp->v_type == VDIR) {
161 error = vn_writechk(vp, NULL);
169 error = VOP_ACCESS(vp, vmode, td->td_proc->p_ucred);
177 if ((error = falloc(NULL, fpp, NULL)) != 0)
180 if ((flags & O_ROOTCRED) == 0 && td->td_proc)
181 fsetcred(fp, td->td_proc->p_ucred);
183 error = VOP_OPEN(vp, flags, td->td_proc->p_ucred, fp);
190 fp->f_ops = &badfileops; /* open failed, don't close */
193 /* leave the vnode intact, but fall through and unlock it anyway */
200 * fp_*read() is meant to operate like the normal descriptor based syscalls
201 * would. Note that if 'buf' points to user memory a UIO_USERSPACE
202 * transfer will be used.
205 fp_pread(file_t fp, void *buf, size_t nbytes, off_t offset, ssize_t *res,
215 if (nbytes > LONG_MAX)
217 bzero(&auio, sizeof(auio));
218 aiov.iov_base = (caddr_t)buf;
219 aiov.iov_len = nbytes;
220 auio.uio_iov = &aiov;
222 auio.uio_offset = offset;
223 auio.uio_resid = nbytes;
224 auio.uio_rw = UIO_READ;
225 auio.uio_segflg = seg;
226 auio.uio_td = curthread;
229 error = fo_read(fp, &auio, fp->f_cred, O_FOFFSET);
231 if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
232 error == EWOULDBLOCK)
237 count -= auio.uio_resid;
244 fp_read(file_t fp, void *buf, size_t nbytes, ssize_t *res, int all,
254 if (nbytes > LONG_MAX)
256 bzero(&auio, sizeof(auio));
257 aiov.iov_base = (caddr_t)buf;
258 aiov.iov_len = nbytes;
259 auio.uio_iov = &aiov;
262 auio.uio_resid = nbytes;
263 auio.uio_rw = UIO_READ;
264 auio.uio_segflg = seg;
265 auio.uio_td = curthread;
268 * If all is false call fo_read() once.
269 * If all is true we attempt to read the entire request. We have to
270 * break out of the loop if an unrecoverable error or EOF occurs.
273 lastresid = auio.uio_resid;
274 error = fo_read(fp, &auio, fp->f_cred, 0);
275 } while (all && auio.uio_resid &&
276 ((error == 0 && auio.uio_resid != lastresid) ||
277 error == ERESTART || error == EINTR));
278 if (all && error == 0 && auio.uio_resid)
282 * If an error occured but some data was read, silently forget the
283 * error. However, if this is a non-blocking descriptor and 'all'
284 * was specified, return an error even if some data was read (this
285 * is considered a bug in the caller for using an illegal combination
286 * of 'all' and a non-blocking descriptor).
289 if (auio.uio_resid != nbytes) {
290 if (error == ERESTART || error == EINTR)
292 if (error == EWOULDBLOCK && all == 0)
297 *res = nbytes - auio.uio_resid;
302 fp_pwrite(file_t fp, void *buf, size_t nbytes, off_t offset, ssize_t *res,
312 if (nbytes > LONG_MAX)
314 bzero(&auio, sizeof(auio));
315 aiov.iov_base = (caddr_t)buf;
316 aiov.iov_len = nbytes;
317 auio.uio_iov = &aiov;
319 auio.uio_offset = offset;
320 auio.uio_resid = nbytes;
321 auio.uio_rw = UIO_WRITE;
322 auio.uio_segflg = seg;
323 auio.uio_td = curthread;
326 error = fo_write(fp, &auio, fp->f_cred, O_FOFFSET);
328 if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
329 error == EWOULDBLOCK)
334 count -= auio.uio_resid;
342 fp_write(file_t fp, void *buf, size_t nbytes, ssize_t *res, enum uio_seg seg)
351 if (nbytes > LONG_MAX)
353 bzero(&auio, sizeof(auio));
354 aiov.iov_base = (caddr_t)buf;
355 aiov.iov_len = nbytes;
356 auio.uio_iov = &aiov;
359 auio.uio_resid = nbytes;
360 auio.uio_rw = UIO_WRITE;
361 auio.uio_segflg = seg;
362 auio.uio_td = curthread;
365 error = fo_write(fp, &auio, fp->f_cred, 0);
367 if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
368 error == EWOULDBLOCK)
373 count -= auio.uio_resid;
380 fp_stat(file_t fp, struct stat *ub)
384 error = fo_stat(fp, ub, fp->f_cred);
389 * non-anonymous, non-stack descriptor mappings only!
391 * This routine mostly snarfed from vm/vm_mmap.c
394 fp_mmap(void *addr_arg, size_t size, int prot, int flags, struct file *fp,
395 off_t pos, void **resp)
397 struct thread *td = curthread;
398 struct proc *p = td->td_proc;
405 struct vmspace *vms = p->p_vmspace;
410 if ((ssize_t)size < 0 || (flags & MAP_ANON))
413 pageoff = (pos & PAGE_MASK);
416 /* Adjust size for rounding (on both ends). */
417 size += pageoff; /* low end... */
418 size = (vm_size_t)round_page(size); /* hi end */
419 addr = (vm_offset_t)addr_arg;
422 * Check for illegal addresses. Watch out for address wrap... Note
423 * that VM_*_ADDRESS are not constants due to casts (argh).
425 if (flags & MAP_FIXED) {
427 * The specified address must have the same remainder
428 * as the file offset taken modulo PAGE_SIZE, so it
429 * should be aligned after adjustment by pageoff.
432 if (addr & PAGE_MASK)
434 /* Address range must be all in user VM space. */
435 if (VM_MAX_USER_ADDRESS > 0 && addr + size > VM_MAX_USER_ADDRESS)
437 if (VM_MIN_USER_ADDRESS > 0 && addr < VM_MIN_USER_ADDRESS)
439 if (addr + size < addr)
441 } else if (addr == 0 ||
442 (addr >= round_page((vm_offset_t)vms->vm_taddr) &&
443 addr < round_page((vm_offset_t)vms->vm_daddr + maxdsiz))
446 * XXX for non-fixed mappings where no hint is provided or
447 * the hint would fall in the potential heap space,
448 * place it after the end of the largest possible heap.
450 * There should really be a pmap call to determine a reasonable
453 addr = round_page((vm_offset_t)vms->vm_daddr + maxdsiz);
457 * Mapping file, get fp for validation. Obtain vnode and make
458 * sure it is of appropriate type.
460 if (fp->f_type != DTYPE_VNODE)
464 * POSIX shared-memory objects are defined to have
465 * kernel persistence, and are not defined to support
466 * read(2)/write(2) -- or even open(2). Thus, we can
467 * use MAP_ASYNC to trade on-disk coherence for speed.
468 * The shm_open(3) library routine turns on the FPOSIXSHM
469 * flag to request this behavior.
471 if (fp->f_flag & FPOSIXSHM)
473 vp = (struct vnode *) fp->f_data;
474 if (vp->v_type != VREG && vp->v_type != VCHR)
478 * Get the proper underlying object
480 if (vp->v_type == VREG) {
481 if ((obj = vp->v_object) == NULL)
483 KKASSERT(vp == (struct vnode *)obj->handle);
487 * XXX hack to handle use of /dev/zero to map anon memory (ala
490 if (vp->v_type == VCHR && iszerodev(vp->v_rdev)) {
492 maxprot = VM_PROT_ALL;
497 * cdevs does not provide private mappings of any kind.
499 if (vp->v_type == VCHR &&
500 (flags & (MAP_PRIVATE|MAP_COPY))) {
505 * Ensure that file and memory protections are
506 * compatible. Note that we only worry about
507 * writability if mapping is shared; in this case,
508 * current and max prot are dictated by the open file.
509 * XXX use the vnode instead? Problem is: what
510 * credentials do we use for determination? What if
511 * proc does a setuid?
513 maxprot = VM_PROT_EXECUTE; /* ??? */
514 if (fp->f_flag & FREAD) {
515 maxprot |= VM_PROT_READ;
516 } else if (prot & PROT_READ) {
521 * If we are sharing potential changes (either via
522 * MAP_SHARED or via the implicit sharing of character
523 * device mappings), and we are trying to get write
524 * permission although we opened it without asking
528 if ((flags & MAP_SHARED) != 0 ||
531 if ((fp->f_flag & FWRITE) != 0) {
533 if ((error = VOP_GETATTR(vp, &va))) {
536 if ((va.va_flags & (IMMUTABLE|APPEND)) == 0) {
537 maxprot |= VM_PROT_WRITE;
538 } else if (prot & PROT_WRITE) {
542 } else if ((prot & PROT_WRITE) != 0) {
547 maxprot |= VM_PROT_WRITE;
551 error = vm_mmap(&vms->vm_map, &addr, size, prot,
552 maxprot, flags, handle, pos);
553 if (error == 0 && addr_arg)
554 *resp = (void *)addr;
566 fp_shutdown(file_t fp, int how)
568 return(fo_shutdown(fp, how));