source: rtems-libbsd/freebsd/sys/sys/file.h @ 4a8f953

55-freebsd-126-freebsd-12
Last change on this file since 4a8f953 was 4a8f953, checked in by Kevin Kirspel <kevin-kirspel@…>, on 05/04/17 at 12:27:58

Updating FREEBSD for tty support

  • Property mode set to 100644
File size: 16.0 KB
Line 
1/*-
2 * Copyright (c) 1982, 1986, 1989, 1993
3 *      The Regents of the University of California.  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 * 3. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 *      @(#)file.h      8.3 (Berkeley) 1/9/95
30 * $FreeBSD$
31 */
32
33#ifndef _SYS_FILE_H_
34#define _SYS_FILE_H_
35
36#ifndef _KERNEL
37#include <sys/types.h> /* XXX */
38#include <sys/fcntl.h>
39#include <rtems/bsd/sys/unistd.h>
40#else
41#include <sys/queue.h>
42#include <sys/refcount.h>
43#include <sys/_lock.h>
44#include <sys/_mutex.h>
45#include <vm/vm.h>
46
47struct filedesc;
48struct stat;
49struct thread;
50struct uio;
51struct knote;
52struct vnode;
53
54#endif /* _KERNEL */
55
56#define DTYPE_NONE      0       /* not yet initialized */
57#define DTYPE_VNODE     1       /* file */
58#define DTYPE_SOCKET    2       /* communications endpoint */
59#define DTYPE_PIPE      3       /* pipe */
60#define DTYPE_FIFO      4       /* fifo (named pipe) */
61#define DTYPE_KQUEUE    5       /* event queue */
62#define DTYPE_CRYPTO    6       /* crypto */
63#define DTYPE_MQUEUE    7       /* posix message queue */
64#define DTYPE_SHM       8       /* swap-backed shared memory */
65#define DTYPE_SEM       9       /* posix semaphore */
66#define DTYPE_PTS       10      /* pseudo teletype master device */
67#define DTYPE_DEV       11      /* Device specific fd type */
68#define DTYPE_PROCDESC  12      /* process descriptor */
69#define DTYPE_LINUXEFD  13      /* emulation eventfd type */
70#define DTYPE_LINUXTFD  14      /* emulation timerfd type */
71
72#ifdef _KERNEL
73
74struct file;
75struct filecaps;
76struct kaiocb;
77struct kinfo_file;
78struct ucred;
79
80#define FOF_OFFSET      0x01    /* Use the offset in uio argument */
81#define FOF_NOLOCK      0x02    /* Do not take FOFFSET_LOCK */
82#define FOF_NEXTOFF     0x04    /* Also update f_nextoff */
83#define FOF_NOUPDATE    0x10    /* Do not update f_offset */
84off_t foffset_lock(struct file *fp, int flags);
85void foffset_lock_uio(struct file *fp, struct uio *uio, int flags);
86void foffset_unlock(struct file *fp, off_t val, int flags);
87void foffset_unlock_uio(struct file *fp, struct uio *uio, int flags);
88
89static inline off_t
90foffset_get(struct file *fp)
91{
92
93        return (foffset_lock(fp, FOF_NOLOCK));
94}
95
96typedef int fo_rdwr_t(struct file *fp, struct uio *uio,
97                    struct ucred *active_cred, int flags,
98                    struct thread *td);
99typedef int fo_truncate_t(struct file *fp, off_t length,
100                    struct ucred *active_cred, struct thread *td);
101typedef int fo_ioctl_t(struct file *fp, u_long com, void *data,
102                    struct ucred *active_cred, struct thread *td);
103typedef int fo_poll_t(struct file *fp, int events,
104                    struct ucred *active_cred, struct thread *td);
105typedef int fo_kqfilter_t(struct file *fp, struct knote *kn);
106typedef int fo_stat_t(struct file *fp, struct stat *sb,
107                    struct ucred *active_cred, struct thread *td);
108typedef int fo_close_t(struct file *fp, struct thread *td);
109typedef int fo_chmod_t(struct file *fp, mode_t mode,
110                    struct ucred *active_cred, struct thread *td);
111typedef int fo_chown_t(struct file *fp, uid_t uid, gid_t gid,
112                    struct ucred *active_cred, struct thread *td);
113typedef int fo_sendfile_t(struct file *fp, int sockfd, struct uio *hdr_uio,
114                    struct uio *trl_uio, off_t offset, size_t nbytes,
115                    off_t *sent, int flags, struct thread *td);
116typedef int fo_seek_t(struct file *fp, off_t offset, int whence,
117                    struct thread *td);
118typedef int fo_fill_kinfo_t(struct file *fp, struct kinfo_file *kif,
119                    struct filedesc *fdp);
120typedef int fo_mmap_t(struct file *fp, vm_map_t map, vm_offset_t *addr,
121                    vm_size_t size, vm_prot_t prot, vm_prot_t cap_maxprot,
122                    int flags, vm_ooffset_t foff, struct thread *td);
123typedef int fo_aio_queue_t(struct file *fp, struct kaiocb *job);
124typedef int fo_flags_t;
125
126struct fileops {
127        fo_rdwr_t       *fo_read;
128        fo_rdwr_t       *fo_write;
129        fo_truncate_t   *fo_truncate;
130        fo_ioctl_t      *fo_ioctl;
131        fo_poll_t       *fo_poll;
132        fo_kqfilter_t   *fo_kqfilter;
133        fo_stat_t       *fo_stat;
134        fo_close_t      *fo_close;
135        fo_chmod_t      *fo_chmod;
136        fo_chown_t      *fo_chown;
137        fo_sendfile_t   *fo_sendfile;
138        fo_seek_t       *fo_seek;
139        fo_fill_kinfo_t *fo_fill_kinfo;
140        fo_mmap_t       *fo_mmap;
141        fo_aio_queue_t  *fo_aio_queue;
142        fo_flags_t      fo_flags;       /* DFLAG_* below */
143};
144
145#define DFLAG_PASSABLE  0x01    /* may be passed via unix sockets. */
146#define DFLAG_SEEKABLE  0x02    /* seekable / nonsequential */
147#endif /* _KERNEL */
148
149#if defined(_KERNEL) || defined(_WANT_FILE)
150#ifdef __rtems__
151#include <rtems/libio_.h>
152#include <sys/fcntl.h>
153#endif /* __rtems__ */
154/*
155 * Kernel descriptor table.
156 * One entry for each open kernel vnode and socket.
157 *
158 * Below is the list of locks that protects members in struct file.
159 *
160 * (a) f_vnode lock required (shared allows both reads and writes)
161 * (f) protected with mtx_lock(mtx_pool_find(fp))
162 * (d) cdevpriv_mtx
163 * none not locked
164 */
165
166struct fadvise_info {
167        int             fa_advice;      /* (f) FADV_* type. */
168        off_t           fa_start;       /* (f) Region start. */
169        off_t           fa_end;         /* (f) Region end. */
170};
171
172struct file {
173#ifndef __rtems__
174        void            *f_data;        /* file descriptor specific data */
175        struct fileops  *f_ops;         /* File operations */
176        struct ucred    *f_cred;        /* associated credentials. */
177        struct vnode    *f_vnode;       /* NULL or applicable vnode */
178        short           f_type;         /* descriptor type */
179        short           f_vnread_flags; /* (f) Sleep lock for f_offset */
180        volatile u_int  f_flag;         /* see fcntl.h */
181        volatile u_int  f_count;        /* reference count */
182        /*
183         *  DTYPE_VNODE specific fields.
184         */
185        int             f_seqcount;     /* (a) Count of sequential accesses. */
186        off_t           f_nextoff;      /* next expected read/write offset. */
187        union {
188                struct cdev_privdata *fvn_cdevpriv;
189                                        /* (d) Private data for the cdev. */
190                struct fadvise_info *fvn_advice;
191        } f_vnun;
192        /*
193         *  DFLAG_SEEKABLE specific fields
194         */
195        off_t           f_offset;
196        /*
197         * Mandatory Access control information.
198         */
199        void            *f_label;       /* Place-holder for MAC label. */
200#else /* __rtems__ */
201        rtems_libio_t   f_io;
202        union {
203                struct cdev_privdata *fvn_cdevpriv;
204                                        /* (d) Private data for the cdev. */
205        } f_vnun;
206#endif /* __rtems__ */
207};
208#ifdef __rtems__
209#define f_data f_io.pathinfo.node_access_2
210
211static inline struct file *
212rtems_bsd_iop_to_fp(rtems_libio_t *iop)
213{
214        return (struct file *) iop;
215}
216
217static inline struct file *
218rtems_bsd_fd_to_fp(int fd)
219{
220        return rtems_bsd_iop_to_fp(&rtems_libio_iops[fd]);
221}
222
223static inline int
224rtems_bsd_fp_to_fd(struct file *fp)
225{
226        return fp - rtems_bsd_iop_to_fp(&rtems_libio_iops[0]);
227}
228
229static inline void *
230rtems_bsd_loc_to_f_data(const rtems_filesystem_location_info_t *loc)
231{
232        return loc->node_access_2;
233}
234
235static inline uint32_t
236rtems_bsd_fflag_to_libio_flags(u_int fflag)
237{
238        uint32_t libio_flags = 0;
239
240        if ((fflag & FREAD) == FREAD) {
241                libio_flags |= LIBIO_FLAGS_READ;
242        }
243
244        if ((fflag & FWRITE) == FWRITE) {
245                libio_flags |= LIBIO_FLAGS_WRITE;
246        }
247
248        if ((fflag & FNONBLOCK) == FNONBLOCK) {
249                libio_flags |= LIBIO_FLAGS_NO_DELAY;
250        }
251
252        return (libio_flags);
253}
254
255static inline u_int
256rtems_bsd_libio_flags_to_fflag(uint32_t libio_flags)
257{
258        u_int fflag = 0;
259
260        if ((libio_flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
261                fflag |= FREAD;
262        }
263
264        if ((libio_flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
265                fflag |= FWRITE;
266        }
267
268        if ((libio_flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY) {
269                fflag |= FNONBLOCK;
270        }
271
272        return (fflag);
273}
274
275static int inline
276rtems_bsd_error_to_status_and_errno(int error)
277{
278        if (error == 0) {
279                return 0;
280        } else {
281                rtems_set_errno_and_return_minus_one(error);
282        }
283}
284#endif /* __rtems__ */
285
286#define f_cdevpriv      f_vnun.fvn_cdevpriv
287#define f_advice        f_vnun.fvn_advice
288
289#define FOFFSET_LOCKED       0x1
290#define FOFFSET_LOCK_WAITING 0x2
291#define FDEVFS_VNODE         0x4
292
293#endif /* _KERNEL || _WANT_FILE */
294
295/*
296 * Userland version of struct file, for sysctl
297 */
298struct xfile {
299        size_t  xf_size;        /* size of struct xfile */
300        pid_t   xf_pid;         /* owning process */
301        uid_t   xf_uid;         /* effective uid of owning process */
302        int     xf_fd;          /* descriptor number */
303        void    *xf_file;       /* address of struct file */
304        short   xf_type;        /* descriptor type */
305        int     xf_count;       /* reference count */
306        int     xf_msgcount;    /* references from message queue */
307        off_t   xf_offset;      /* file offset */
308        void    *xf_data;       /* file descriptor specific data */
309        void    *xf_vnode;      /* vnode pointer */
310        u_int   xf_flag;        /* flags (see fcntl.h) */
311};
312
313#ifdef _KERNEL
314
315extern struct fileops vnops;
316extern struct fileops badfileops;
317#ifndef __rtems__
318extern struct fileops socketops;
319#else /* __rtems__ */
320extern const rtems_filesystem_file_handlers_r socketops;
321#endif /* __rtems__ */
322extern int maxfiles;            /* kernel limit on number of open files */
323extern int maxfilesperproc;     /* per process limit on number of open files */
324extern volatile int openfiles;  /* actual number of open files */
325
326#ifndef __rtems__
327int fget(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp);
328#else /* __rtems__ */
329struct file *rtems_bsd_get_file(int fd);
330
331static inline int
332rtems_bsd_do_fget(int fd, struct file **fpp)
333{
334        struct file *fp = rtems_bsd_get_file(fd);
335
336        *fpp = fp;
337
338        return fp != NULL ? 0 : EBADF;
339}
340
341#define fget(td, fd, rights, fpp)       rtems_bsd_do_fget(fd, fpp)
342#endif /* __rtems__ */
343int fget_mmap(struct thread *td, int fd, cap_rights_t *rightsp,
344    u_char *maxprotp, struct file **fpp);
345int fget_read(struct thread *td, int fd, cap_rights_t *rightsp,
346    struct file **fpp);
347int fget_write(struct thread *td, int fd, cap_rights_t *rightsp,
348    struct file **fpp);
349int fget_fcntl(struct thread *td, int fd, cap_rights_t *rightsp,
350    int needfcntl, struct file **fpp);
351int _fdrop(struct file *fp, struct thread *td);
352
353#ifndef __rtems__
354fo_rdwr_t       invfo_rdwr;
355fo_truncate_t   invfo_truncate;
356fo_ioctl_t      invfo_ioctl;
357fo_poll_t       invfo_poll;
358fo_kqfilter_t   invfo_kqfilter;
359fo_chmod_t      invfo_chmod;
360fo_chown_t      invfo_chown;
361fo_sendfile_t   invfo_sendfile;
362
363fo_sendfile_t   vn_sendfile;
364fo_seek_t       vn_seek;
365fo_fill_kinfo_t vn_fill_kinfo;
366int vn_fill_kinfo_vnode(struct vnode *vp, struct kinfo_file *kif);
367#else /* __rtems__ */
368int rtems_bsd_soo_kqfilter(rtems_libio_t *iop, struct knote *kn);
369#endif /* __rtems__ */
370
371#ifndef __rtems__
372void finit(struct file *, u_int, short, void *, struct fileops *);
373#else /* __rtems__ */
374static inline void
375finit(struct file *fp, u_int fflag, short type, void *data,
376    const rtems_filesystem_file_handlers_r *ops)
377{
378        rtems_filesystem_location_info_t *pathinfo = &fp->f_io.pathinfo;
379
380        (void) type;
381
382        fp->f_data = data;
383        fp->f_io.flags |= rtems_bsd_fflag_to_libio_flags(fflag);
384
385        pathinfo->handlers = ops;
386}
387#endif /* __rtems__ */
388int fgetvp(struct thread *td, int fd, cap_rights_t *rightsp,
389    struct vnode **vpp);
390int fgetvp_exec(struct thread *td, int fd, cap_rights_t *rightsp,
391    struct vnode **vpp);
392int fgetvp_rights(struct thread *td, int fd, cap_rights_t *needrightsp,
393    struct filecaps *havecaps, struct vnode **vpp);
394int fgetvp_read(struct thread *td, int fd, cap_rights_t *rightsp,
395    struct vnode **vpp);
396int fgetvp_write(struct thread *td, int fd, cap_rights_t *rightsp,
397    struct vnode **vpp);
398
399static __inline int
400_fnoop(void)
401{
402
403        return (0);
404}
405
406#define fhold(fp)                                                       \
407        (refcount_acquire(&(fp)->f_count))
408#ifndef __rtems__
409#define fdrop(fp, td)                                                   \
410        (refcount_release(&(fp)->f_count) ? _fdrop((fp), (td)) : _fnoop())
411#else /* __rtems__ */
412#define fdrop(fp, td) do { } while (0)
413#endif /* __rtems__ */
414
415#ifndef __rtems__
416static __inline fo_rdwr_t       fo_read;
417static __inline fo_rdwr_t       fo_write;
418static __inline fo_truncate_t   fo_truncate;
419static __inline fo_ioctl_t      fo_ioctl;
420static __inline fo_poll_t       fo_poll;
421static __inline fo_kqfilter_t   fo_kqfilter;
422static __inline fo_stat_t       fo_stat;
423static __inline fo_close_t      fo_close;
424static __inline fo_chmod_t      fo_chmod;
425static __inline fo_chown_t      fo_chown;
426static __inline fo_sendfile_t   fo_sendfile;
427
428static __inline int
429fo_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
430    int flags, struct thread *td)
431{
432
433        return ((*fp->f_ops->fo_read)(fp, uio, active_cred, flags, td));
434}
435
436static __inline int
437fo_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
438    int flags, struct thread *td)
439{
440
441        return ((*fp->f_ops->fo_write)(fp, uio, active_cred, flags, td));
442}
443
444static __inline int
445fo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
446    struct thread *td)
447{
448
449        return ((*fp->f_ops->fo_truncate)(fp, length, active_cred, td));
450}
451#endif /* __rtems__ */
452
453static __inline int
454fo_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
455    struct thread *td)
456{
457
458#ifndef __rtems__
459        return ((*fp->f_ops->fo_ioctl)(fp, com, data, active_cred, td));
460#else /* __rtems__ */
461        int rv;
462
463        (void) active_cred;
464        (void) td;
465
466        errno = 0;
467        rv = ((*fp->f_io.pathinfo.handlers->ioctl_h)(&fp->f_io, com, data));
468        if (rv == 0) {
469                return (0);
470        } else {
471                return (errno);
472        }
473#endif /* __rtems__ */
474}
475
476static __inline int
477fo_poll(struct file *fp, int events, struct ucred *active_cred,
478    struct thread *td)
479{
480
481#ifndef __rtems__
482        return ((*fp->f_ops->fo_poll)(fp, events, active_cred, td));
483#else /* __rtems__ */
484        (void) active_cred;
485        (void) td;
486
487        return ((*fp->f_io.pathinfo.handlers->poll_h)(&fp->f_io, events));
488#endif /* __rtems__ */
489}
490
491#ifndef __rtems__
492static __inline int
493fo_stat(struct file *fp, struct stat *sb, struct ucred *active_cred,
494    struct thread *td)
495{
496
497        return ((*fp->f_ops->fo_stat)(fp, sb, active_cred, td));
498}
499
500static __inline int
501fo_close(struct file *fp, struct thread *td)
502{
503
504        return ((*fp->f_ops->fo_close)(fp, td));
505}
506#endif /* __rtems__ */
507
508static __inline int
509fo_kqfilter(struct file *fp, struct knote *kn)
510{
511
512#ifndef __rtems__
513        return ((*fp->f_ops->fo_kqfilter)(fp, kn));
514#else /* __rtems__ */
515        return ((*fp->f_io.pathinfo.handlers->kqfilter_h)(&fp->f_io, kn));
516#endif /* __rtems__ */
517}
518
519#ifndef __rtems__
520static __inline int
521fo_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
522    struct thread *td)
523{
524
525        return ((*fp->f_ops->fo_chmod)(fp, mode, active_cred, td));
526}
527
528static __inline int
529fo_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
530    struct thread *td)
531{
532
533        return ((*fp->f_ops->fo_chown)(fp, uid, gid, active_cred, td));
534}
535
536static __inline int
537fo_sendfile(struct file *fp, int sockfd, struct uio *hdr_uio,
538    struct uio *trl_uio, off_t offset, size_t nbytes, off_t *sent, int flags,
539    struct thread *td)
540{
541
542        return ((*fp->f_ops->fo_sendfile)(fp, sockfd, hdr_uio, trl_uio, offset,
543            nbytes, sent, flags, td));
544}
545
546static __inline int
547fo_seek(struct file *fp, off_t offset, int whence, struct thread *td)
548{
549
550        return ((*fp->f_ops->fo_seek)(fp, offset, whence, td));
551}
552
553static __inline int
554fo_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
555{
556
557        return ((*fp->f_ops->fo_fill_kinfo)(fp, kif, fdp));
558}
559
560static __inline int
561fo_mmap(struct file *fp, vm_map_t map, vm_offset_t *addr, vm_size_t size,
562    vm_prot_t prot, vm_prot_t cap_maxprot, int flags, vm_ooffset_t foff,
563    struct thread *td)
564{
565
566        if (fp->f_ops->fo_mmap == NULL)
567                return (ENODEV);
568        return ((*fp->f_ops->fo_mmap)(fp, map, addr, size, prot, cap_maxprot,
569            flags, foff, td));
570}
571
572static __inline int
573fo_aio_queue(struct file *fp, struct kaiocb *job)
574{
575
576        return ((*fp->f_ops->fo_aio_queue)(fp, job));
577}
578#endif /* __rtems__ */
579
580#endif /* _KERNEL */
581
582#endif /* !SYS_FILE_H */
Note: See TracBrowser for help on using the repository browser.