Enhance the fp_*() API. Reorganize the ELF dump code using the fp_*()
[dragonfly.git] / sys / kern / kern_fp.c
1 /*
2  * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com>
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  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $DragonFly: src/sys/kern/kern_fp.c,v 1.3 2003/10/19 19:24:18 dillon Exp $
27  */
28
29 /*
30  * Direct file pointer API functions for in-kernel operations on files.  These
31  * functions provide a open/read/write/close like interface within the kernel
32  * for operating on files that are not necessarily associated with processes
33  * and which do not (typically) have descriptors.
34  *
35  * FUTURE: file handle conversion routines to support checkpointing, 
36  * and additional file operations (ioctl, fcntl).
37  */
38
39 #include <sys/param.h>
40 #include <sys/kernel.h>
41 #include <sys/systm.h>
42 #include <sys/malloc.h>
43 #include <sys/sysproto.h>
44 #include <sys/conf.h>
45 #include <sys/filedesc.h>
46 #include <sys/sysctl.h>
47 #include <sys/vnode.h>
48 #include <sys/proc.h>
49 #include <sys/namei.h>
50 #include <sys/file.h>
51 #include <sys/stat.h>
52 #include <sys/filio.h>
53 #include <sys/fcntl.h>
54 #include <sys/unistd.h>
55 #include <sys/resourcevar.h>
56 #include <sys/event.h>
57 #include <sys/mman.h>
58
59 #include <vm/vm.h>
60 #include <vm/vm_param.h>
61 #include <sys/lock.h>
62 #include <vm/pmap.h>
63 #include <vm/vm_map.h>
64 #include <vm/vm_object.h>
65 #include <vm/vm_page.h>
66 #include <vm/vm_pager.h>
67 #include <vm/vm_pageout.h>
68 #include <vm/vm_extern.h>
69 #include <vm/vm_page.h>
70 #include <vm/vm_kern.h>
71
72 #include <sys/file2.h>
73 #include <machine/limits.h>
74
75 typedef struct file *file_t;
76
77 /*
78  * fp_open:
79  *
80  *      Open a file as specified.  Use O_* flags for flags.
81  *
82  *      NOTE! O_ROOTCRED not quite working yet, vn_open() asserts that the
83  *      cred must match the process's cred.
84  */
85 int
86 fp_open(const char *path, int flags, int mode, file_t *fpp)
87 {
88     struct nameidata nd;
89     struct thread *td;
90     struct file *fp;
91     int error;
92
93     if ((error = falloc(NULL, fpp, NULL)) != 0)
94         return (error);
95     fp = *fpp;
96     td = curthread;
97     if ((flags & O_ROOTCRED) == 0 && td->td_proc)
98         fsetcred(fp, td->td_proc->p_ucred);
99
100     NDINIT(&nd, NAMEI_LOOKUP, 0, UIO_SYSSPACE, path, td);
101     flags = FFLAGS(flags);
102     printf("%08x\n", flags);
103     if ((error = vn_open(&nd, flags, mode)) == 0) {
104         NDFREE(&nd, NDF_ONLY_PNBUF);
105         fp->f_data = (caddr_t)nd.ni_vp;
106         fp->f_flag = flags;
107         fp->f_ops = &vnops;
108         fp->f_type = DTYPE_VNODE;
109         VOP_UNLOCK(nd.ni_vp, 0, td);
110     } else {
111         fdrop(fp, td);
112         *fpp = NULL;
113     }
114     return(error);
115 }
116
117 /*
118  * fp_*read() is meant to operate like the normal descriptor based syscalls
119  * would.  Note that if 'buf' points to user memory a UIO_USERSPACE
120  * transfer will be used.
121  */
122 int
123 fp_pread(file_t fp, void *buf, size_t nbytes, off_t offset, ssize_t *res)
124 {
125     struct uio auio;
126     struct iovec aiov;
127     size_t count;
128     int error;
129
130     if (res)
131         *res = 0;
132     if (nbytes > INT_MAX)
133         return (EINVAL);
134     bzero(&auio, sizeof(auio));
135     aiov.iov_base = (caddr_t)buf;
136     aiov.iov_len = nbytes;
137     auio.uio_iov = &aiov;
138     auio.uio_iovcnt = 1;
139     auio.uio_offset = offset;
140     auio.uio_resid = nbytes;
141     auio.uio_rw = UIO_READ;
142     if ((vm_offset_t)buf < VM_MAXUSER_ADDRESS)
143         auio.uio_segflg = UIO_USERSPACE;
144     else
145         auio.uio_segflg = UIO_SYSSPACE;
146     auio.uio_td = curthread;
147
148     count = nbytes;
149     error = fo_read(fp, &auio, fp->f_cred, FOF_OFFSET, auio.uio_td);
150     if (error) {
151         if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
152             error == EWOULDBLOCK)
153         ) {
154             error = 0;
155         }
156     }
157     count -= auio.uio_resid;
158     if (res)
159         *res = count;
160     return(error);
161 }
162
163 int
164 fp_read(file_t fp, void *buf, size_t nbytes, ssize_t *res)
165 {
166     struct uio auio;
167     struct iovec aiov;
168     size_t count;
169     int error;
170
171     if (res)
172         *res = 0;
173     if (nbytes > INT_MAX)
174         return (EINVAL);
175     bzero(&auio, sizeof(auio));
176     aiov.iov_base = (caddr_t)buf;
177     aiov.iov_len = nbytes;
178     auio.uio_iov = &aiov;
179     auio.uio_iovcnt = 1;
180     auio.uio_offset = 0;
181     auio.uio_resid = nbytes;
182     auio.uio_rw = UIO_READ;
183     if ((vm_offset_t)buf < VM_MAXUSER_ADDRESS)
184         auio.uio_segflg = UIO_USERSPACE;
185     else
186         auio.uio_segflg = UIO_SYSSPACE;
187     auio.uio_td = curthread;
188
189     count = nbytes;
190     error = fo_read(fp, &auio, fp->f_cred, 0, auio.uio_td);
191     if (error) {
192         if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
193             error == EWOULDBLOCK)
194         ) {
195             error = 0;
196         }
197     }
198     count -= auio.uio_resid;
199     if (res)
200         *res = count;
201     return(error);
202 }
203
204 int
205 fp_pwrite(file_t fp, void *buf, size_t nbytes, off_t offset, ssize_t *res)
206 {
207     struct uio auio;
208     struct iovec aiov;
209     size_t count;
210     int error;
211
212     if (res)
213         *res = 0;
214     if (nbytes > INT_MAX)
215         return (EINVAL);
216     bzero(&auio, sizeof(auio));
217     aiov.iov_base = (caddr_t)buf;
218     aiov.iov_len = nbytes;
219     auio.uio_iov = &aiov;
220     auio.uio_iovcnt = 1;
221     auio.uio_offset = offset;
222     auio.uio_resid = nbytes;
223     auio.uio_rw = UIO_WRITE;
224     if ((vm_offset_t)buf < VM_MAXUSER_ADDRESS)
225         auio.uio_segflg = UIO_USERSPACE;
226     else
227         auio.uio_segflg = UIO_SYSSPACE;
228     auio.uio_td = curthread;
229
230     count = nbytes;
231     error = fo_write(fp, &auio, fp->f_cred, FOF_OFFSET, auio.uio_td);
232     if (error) {
233         if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
234             error == EWOULDBLOCK)
235         ) {
236             error = 0;
237         }
238     }
239     count -= auio.uio_resid;
240     if (res)
241         *res = count;
242     return(error);
243 }
244
245
246 int
247 fp_write(file_t fp, void *buf, size_t nbytes, ssize_t *res)
248 {
249     struct uio auio;
250     struct iovec aiov;
251     size_t count;
252     int error;
253
254     if (res)
255         *res = 0;
256     if (nbytes > INT_MAX)
257         return (EINVAL);
258     bzero(&auio, sizeof(auio));
259     aiov.iov_base = (caddr_t)buf;
260     aiov.iov_len = nbytes;
261     auio.uio_iov = &aiov;
262     auio.uio_iovcnt = 1;
263     auio.uio_offset = 0;
264     auio.uio_resid = nbytes;
265     auio.uio_rw = UIO_WRITE;
266     if ((vm_offset_t)buf < VM_MAXUSER_ADDRESS)
267         auio.uio_segflg = UIO_USERSPACE;
268     else
269         auio.uio_segflg = UIO_SYSSPACE;
270     auio.uio_td = curthread;
271
272     count = nbytes;
273     error = fo_write(fp, &auio, fp->f_cred, 0, auio.uio_td);
274     if (error) {
275         if (auio.uio_resid != nbytes && (error == ERESTART || error == EINTR ||
276             error == EWOULDBLOCK)
277         ) {
278             error = 0;
279         }
280     }
281     count -= auio.uio_resid;
282     if (res)
283         *res = count;
284     return(error);
285 }
286
287 int
288 fp_stat(file_t fp, struct stat *ub)
289 {
290     int error;
291
292     error = fo_stat(fp, ub, curthread);
293     return(error);
294 }
295
296 /*
297  * non-anonymous, non-stack descriptor mappings only!
298  *
299  * This routine mostly snarfed from vm/vm_mmap.c
300  */
301 int
302 fp_mmap(void *addr_arg, size_t size, int prot, int flags, struct file *fp,
303     off_t pos, void **resp)
304 {
305     struct thread *td = curthread;
306     struct proc *p = td->td_proc;
307     vm_size_t pageoff;
308     vm_prot_t maxprot;
309     vm_offset_t addr;
310     void *handle;
311     int error;
312     vm_object_t obj;
313     struct vmspace *vms = p->p_vmspace;
314     struct vnode *vp;
315     int disablexworkaround;
316
317     prot &= VM_PROT_ALL;
318
319     if ((ssize_t)size < 0 || (flags & MAP_ANON))
320         return(EINVAL);
321
322     pageoff = (pos & PAGE_MASK);
323     pos -= pageoff;
324
325     /* Adjust size for rounding (on both ends). */
326     size += pageoff;                            /* low end... */
327     size = (vm_size_t)round_page(size);         /* hi end */
328     addr = (vm_offset_t)addr_arg;
329
330     /*
331      * Check for illegal addresses.  Watch out for address wrap... Note
332      * that VM_*_ADDRESS are not constants due to casts (argh).
333      */
334     if (flags & MAP_FIXED) {
335         /*
336          * The specified address must have the same remainder
337          * as the file offset taken modulo PAGE_SIZE, so it
338          * should be aligned after adjustment by pageoff.
339          */
340         addr -= pageoff;
341         if (addr & PAGE_MASK)
342             return (EINVAL);
343         /* Address range must be all in user VM space. */
344         if (VM_MAXUSER_ADDRESS > 0 && addr + size > VM_MAXUSER_ADDRESS)
345             return (EINVAL);
346 #ifndef i386
347         if (VM_MIN_ADDRESS > 0 && addr < VM_MIN_ADDRESS)
348             return (EINVAL);
349 #endif
350         if (addr + size < addr)
351             return (EINVAL);
352     } else if (addr == 0 ||
353         (addr >= round_page((vm_offset_t)vms->vm_taddr) &&
354          addr < round_page((vm_offset_t)vms->vm_daddr + maxdsiz))
355     ) {
356         /*
357          * XXX for non-fixed mappings where no hint is provided or
358          * the hint would fall in the potential heap space,
359          * place it after the end of the largest possible heap.
360          *
361          * There should really be a pmap call to determine a reasonable
362          * location.
363          */
364         addr = round_page((vm_offset_t)vms->vm_daddr + maxdsiz);
365     }
366
367     /*
368      * Mapping file, get fp for validation. Obtain vnode and make
369      * sure it is of appropriate type.
370      */
371     if (fp->f_type != DTYPE_VNODE)
372         return (EINVAL);
373
374     /*
375      * POSIX shared-memory objects are defined to have
376      * kernel persistence, and are not defined to support
377      * read(2)/write(2) -- or even open(2).  Thus, we can
378      * use MAP_ASYNC to trade on-disk coherence for speed.
379      * The shm_open(3) library routine turns on the FPOSIXSHM
380      * flag to request this behavior.
381      */
382     if (fp->f_flag & FPOSIXSHM)
383         flags |= MAP_NOSYNC;
384     vp = (struct vnode *) fp->f_data;
385     if (vp->v_type != VREG && vp->v_type != VCHR)
386         return (EINVAL);
387
388     /*
389      * Get the proper underlying object
390      */
391     if (vp->v_type == VREG) {
392         if (VOP_GETVOBJECT(vp, &obj) != 0)
393             return (EINVAL);
394         vp = (struct vnode*)obj->handle;
395     }
396
397     /*
398      * XXX hack to handle use of /dev/zero to map anon memory (ala
399      * SunOS).
400      */
401     if (vp->v_type == VCHR && iszerodev(vp->v_rdev)) {
402         handle = NULL;
403         maxprot = VM_PROT_ALL;
404         flags |= MAP_ANON;
405         pos = 0;
406     } else {
407         /*
408          * cdevs does not provide private mappings of any kind.
409          */
410         /*
411          * However, for XIG X server to continue to work,
412          * we should allow the superuser to do it anyway.
413          * We only allow it at securelevel < 1.
414          * (Because the XIG X server writes directly to video
415          * memory via /dev/mem, it should never work at any
416          * other securelevel.
417          * XXX this will have to go
418          */
419         if (securelevel >= 1)
420             disablexworkaround = 1;
421         else
422             disablexworkaround = suser(td);
423         if (vp->v_type == VCHR && disablexworkaround &&
424             (flags & (MAP_PRIVATE|MAP_COPY))) {
425                 error = EINVAL;
426                 goto done;
427         }
428         /*
429          * Ensure that file and memory protections are
430          * compatible.  Note that we only worry about
431          * writability if mapping is shared; in this case,
432          * current and max prot are dictated by the open file.
433          * XXX use the vnode instead?  Problem is: what
434          * credentials do we use for determination? What if
435          * proc does a setuid?
436          */
437         maxprot = VM_PROT_EXECUTE;      /* ??? */
438         if (fp->f_flag & FREAD) {
439             maxprot |= VM_PROT_READ;
440         } else if (prot & PROT_READ) {
441             error = EACCES;
442             goto done;
443         }
444         /*
445          * If we are sharing potential changes (either via
446          * MAP_SHARED or via the implicit sharing of character
447          * device mappings), and we are trying to get write
448          * permission although we opened it without asking
449          * for it, bail out.  Check for superuser, only if
450          * we're at securelevel < 1, to allow the XIG X server
451          * to continue to work.
452          */
453
454         if ((flags & MAP_SHARED) != 0 ||
455             (vp->v_type == VCHR && disablexworkaround)
456         ) {
457             if ((fp->f_flag & FWRITE) != 0) {
458                 struct vattr va;
459                 if ((error = VOP_GETATTR(vp, &va, td))) {
460                     goto done;
461                 }
462                 if ((va.va_flags & (IMMUTABLE|APPEND)) == 0) {
463                     maxprot |= VM_PROT_WRITE;
464                 } else if (prot & PROT_WRITE) {
465                     error = EPERM;
466                     goto done;
467                 }
468             } else if ((prot & PROT_WRITE) != 0) {
469                 error = EACCES;
470                 goto done;
471             }
472         } else {
473             maxprot |= VM_PROT_WRITE;
474         }
475         handle = (void *)vp;
476     }
477     error = vm_mmap(&vms->vm_map, &addr, size, prot, 
478                     maxprot, flags, handle, pos);
479     if (error == 0 && addr_arg)
480         *resp = (void *)addr;
481 done:
482     return (error);
483 }
484
485 int
486 fp_close(file_t fp)
487 {
488     return(fdrop(fp, curthread));
489 }
490