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