xref: /dragonfly/sys/vfs/dirfs/dirfs.h (revision 7ea34faa)
1 /*
2  * Copyright (c) 2013 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Antonio Huete Jimenez <tuxillo@quantumachine.net>
6  * by Matthew Dillon <dillon@dragonflybsd.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  *
35  */
36 
37 #ifndef _SYS_VFS_DIRFS_DIRFS_H_
38 #define _SYS_VFS_DIRFS_DIRFS_H_
39 
40 #include <unistd.h>
41 
42 #include <sys/lockf.h>
43 #include <sys/stat.h>
44 #include <sys/vnode.h>
45 #include <sys/file.h>
46 
47 #ifdef MALLOC_DECLARE
48 MALLOC_DECLARE(M_DIRFS);
49 MALLOC_DECLARE(M_DIRFS_NODE);
50 MALLOC_DECLARE(M_DIRFS_MISC);
51 #endif
52 
53 #ifndef KTR_DIRFS
54 #define KTR_DIRFS KTR_ALL
55 #endif
56 
57 #define DIRFS_NOFD	-1	/* No fd present */
58 
59 #define DIRFS_ROOT	0x00000001
60 #define DIRFS_PASVFD	0x00000002
61 #define DIRFS_NODE_RD	0x00000004
62 #define DIRFS_NODE_WR	0x00000008
63 #define DIRFS_NODE_EXE	0x00000010
64 
65 #define DIRFS_TXTFLG "pasvfd"
66 
67 /* Used for buffer cache operations */
68 #define BSIZE	16384
69 #define BMASK	(BSIZE - 1)
70 
71 /*
72  * XXX This should be temporary. A semi-proper solution would be to expose
73  * below prototypes in the _KERNEL_VIRTUAL case.
74  */
75 extern int getdirentries(int, char *, int, long *);
76 extern int statfs(const char *, struct statfs *);
77 
78 /*
79  * Debugging macros.
80  *
81  * LEVEL	USED FOR
82  *
83  *     1	Calls to VFS operations (mount, umount, ...)
84  *     3	Calls to VN operations (open, close, read, ...)
85  *     5	Calls to subroutines
86  *     9	Everything
87  *
88  */
89 #define dbg(lvl, fmt, ...) do {					\
90 		debug(lvl, "%s: " fmt, __func__, ##__VA_ARGS__);	\
91 } while(0)
92 
93 #define debug_node(s) do {						\
94 		dbg(9, "mode=%u flags=%u dn_name=%s "			\
95 		    "uid=%u gid=%u objtype=%u nlinks=%d "		\
96 		    "size=%jd ctime=%ju atime=%ju mtime=%ju\n",		\
97 		    s->dn_mode, s->dn_flags, s->dn_name,		\
98 		    s->dn_uid, s->dn_gid, s->dn_type,			\
99 		    s->dn_links, s->dn_size,				\
100 		    s->dn_ctime, s->dn_atime,				\
101 		    s->dn_mtime);					\
102 } while(0)
103 
104 #define debug_node2(n) do {						\
105 		dbg(9, "dnp=%p name=%s fd=%d parent=%p vnode=%p "	\
106 		    "refcnt=%d state=%s\n",				\
107 		    n, n->dn_name, n->dn_fd, n->dn_parent, n->dn_vnode,	\
108 		    n->dn_refcnt, dirfs_flag2str(n));			\
109 } while(0)
110 
111 /*
112  * Locking macros
113  */
114 #define dirfs_node_islocked(n)	(lockstatus(&(n)->dn_lock,curthread) == LK_EXCLUSIVE)
115 #define dirfs_node_lock(n)	lockmgr(&(n)->dn_lock, LK_EXCLUSIVE|LK_RETRY)
116 #define dirfs_node_unlock(n) 	lockmgr(&(n)->dn_lock, LK_RELEASE)
117 #define dirfs_mount_lock(m)	lockmgr(&(m)->dm_lock, LK_EXCLUSIVE|LK_RETRY)
118 #define dirfs_mount_unlock(m)	lockmgr(&(m)->dm_lock, LK_RELEASE)
119 #define dirfs_mount_gettoken(m)	lwkt_gettoken(&(m)->dm_token)
120 #define dirfs_mount_reltoken(m)	lwkt_reltoken(&(m)->dm_token)
121 
122 /*
123  * Misc macros
124  */
125 #define dirfs_node_isroot(n)	(n->dn_state & DIRFS_ROOT)
126 
127 /*
128  * Main in-memory node structure which will represent a host file when active.
129  * Upon VOP_NRESOLVE() an attempt to initialize its generic fields will be made
130  * via a fstatat(2)/lstat(2) call.
131  */
132 struct dirfs_node {
133 	enum vtype		dn_type;	/* Node type. Same as vnode
134 						   type for simplicty */
135 
136 	int			dn_state;	/* Node state flags */
137 
138 	TAILQ_ENTRY(dirfs_node)	dn_fdentry;	/* Passive fd cache */
139 	RB_ENTRY(dirfs_node)	dn_rbentry;	/* Inode no. lookup */
140 
141 	int			dn_refcnt;	/* Refs from children */
142 	int			dn_fd;		/* File des. for open(2) */
143 
144 	struct dirfs_node *	dn_parent;	/* Pointer to parent node */
145 
146 	struct vnode *          dn_vnode;	/* Reference to its vnode on
147 						   the vkernel scope */
148 	char *			dn_name;
149 	int			dn_namelen;
150 
151         struct lockf            dn_advlock;
152 	struct lock		dn_lock;
153 
154 	uint32_t		dn_st_dev;	/* Device number */
155 
156 	/* Generic attributes */
157 	ino_t			dn_ino;
158 	long			dn_blocksize;
159 	uid_t			dn_uid;
160 	gid_t			dn_gid;
161 	mode_t			dn_mode;
162 	u_int			dn_flags;
163 	nlink_t			dn_links;
164 	int32_t			dn_atime;
165 	int32_t			dn_atimensec;
166 	int32_t			dn_mtime;
167 	int32_t			dn_mtimensec;
168 	int32_t			dn_ctime;
169 	int32_t			dn_ctimensec;
170 	unsigned long		dn_gen;
171 	off_t			dn_size;
172 };
173 typedef struct dirfs_node *dirfs_node_t;
174 
175 /*
176  * In-memory dirfs mount structure. It corresponds to a mounted
177  * dirfs filesystem.
178  */
179 struct dirfs_mount {
180 	RB_HEAD(, dn_rbentry) dm_inotree;
181 	TAILQ_HEAD(, dirfs_node) dm_fdlist;
182 
183 	struct lock	 	dm_lock;
184 	struct lwkt_token	dm_token;
185 	dirfs_node_t		dm_root;	/* Root dirfs node */
186 	struct mount *		dm_mount;
187 	int			dm_rdonly;
188 
189 	int			dm_fd_used;	/* Opened file descriptors */
190 
191 	uid_t			dm_uid;	/* User running the vkernel */
192 	gid_t			dm_gid;
193 
194 	char			dm_path[MAXPATHLEN];
195 };
196 typedef struct dirfs_mount *dirfs_mount_t;
197 
198 /*
199  * VFS <-> DIRFS conversion macros
200  */
201 #define VFS_TO_DIRFS(mp)	((dirfs_mount_t)((mp)->mnt_data))
202 #define DIRFS_TO_VFS(dmp)	((struct mount *)((dmp)->dm_mount))
203 #define VP_TO_NODE(vp)		((dirfs_node_t)((vp)->v_data))
204 #define NODE_TO_VP(dnp)		((dnp)->dn_vnode)
205 
206 /* Misc stuff */
207 extern int debuglvl;
208 extern int dirfs_fd_limit;
209 extern int dirfs_fd_used;
210 extern long passive_fd_list_miss;
211 extern long passive_fd_list_hits;
212 
213 extern struct vop_ops dirfs_vnode_vops;
214 
215 #ifdef _KERNEL
216 /*
217  * Misc functions for node operations
218  */
219 static __inline void
dirfs_node_ref(dirfs_node_t dnp)220 dirfs_node_ref(dirfs_node_t dnp)
221 {
222 	atomic_add_int(&dnp->dn_refcnt, 1);
223 }
224 
225 static __inline int
dirfs_node_unref(dirfs_node_t dnp)226 dirfs_node_unref(dirfs_node_t dnp)
227 {
228 	/*
229 	 * Returns non-zero on last unref.
230 	 */
231 	KKASSERT(dnp->dn_refcnt > 0);
232 	return (atomic_fetchadd_int(&dnp->dn_refcnt, -1) == 1);
233 }
234 
235 static __inline void
dirfs_node_setflags(dirfs_node_t dnp,int flags)236 dirfs_node_setflags(dirfs_node_t dnp, int flags)
237 {
238 	atomic_set_int(&dnp->dn_state, flags);
239 }
240 
241 static __inline void
dirfs_node_clrflags(dirfs_node_t dnp,int flags)242 dirfs_node_clrflags(dirfs_node_t dnp, int flags)
243 {
244 	atomic_clear_int(&dnp->dn_state, flags);
245 }
246 
247 #endif
248 
249 /*
250  * Prototypes
251  */
252 dirfs_node_t dirfs_node_alloc(struct mount *);
253 int dirfs_node_stat(int, const char *, dirfs_node_t);
254 int dirfs_nodetype(struct stat *);
255 void dirfs_node_setname(dirfs_node_t, const char *, int);
256 char *dirfs_node_fullpath(dirfs_mount_t, const char *);
257 int dirfs_node_free(dirfs_mount_t, dirfs_node_t);
258 void dirfs_node_drop(dirfs_mount_t dmp, dirfs_node_t dnp);
259 void dirfs_node_setpassive(dirfs_mount_t dmp, dirfs_node_t dnp, int state);
260 void dirfs_alloc_vp(struct mount *, struct vnode **, int, dirfs_node_t);
261 void dirfs_free_vp(dirfs_mount_t, dirfs_node_t);
262 int dirfs_alloc_file(dirfs_mount_t, dirfs_node_t *, dirfs_node_t,
263     struct namecache *, struct vnode **, struct vattr *, int);
264 dirfs_node_t dirfs_findfd(dirfs_mount_t dmp, dirfs_node_t cur,
265 			char **pathto, char **pathfree);
266 void dirfs_dropfd(dirfs_mount_t dmp, dirfs_node_t dnp1, char *pathfree);
267 char *dirfs_node_absolute_path(dirfs_mount_t, dirfs_node_t, char **);
268 char *dirfs_node_absolute_path_plus(dirfs_mount_t, dirfs_node_t,
269 			char *, char **);
270 int dirfs_open_helper(dirfs_mount_t, dirfs_node_t, int, char *);
271 int dirfs_close_helper(dirfs_node_t);
272 int dirfs_node_refcnt(dirfs_node_t);
273 char *dirfs_flag2str(dirfs_node_t);
274 int dirfs_node_getperms(dirfs_node_t, int *);
275 int dirfs_node_chflags(dirfs_node_t, u_long, struct ucred *);
276 int dirfs_node_chtimes(dirfs_node_t);
277 int dirfs_node_chmod(dirfs_mount_t, dirfs_node_t, mode_t cur_mode);
278 int dirfs_node_chown(dirfs_mount_t, dirfs_node_t,
279 			uid_t cur_uid, uid_t cur_gid, mode_t cur_mode);
280 int dirfs_node_chsize(dirfs_node_t, off_t);
281 void debug(int, const char *, ...);
282 
283 #endif /* _SYS_VFS_DIRFS_DIRFS_H_ */
284