xref: /freebsd/sys/sys/jail.h (revision f7bda491ef05717fb4fe6c89083485599db951b8)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 1999 Poul-Henning Kamp.
5  * Copyright (c) 2009 James Gritton.
6  * All rights reserved.
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  * 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 the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 
30 #ifndef _SYS_JAIL_H_
31 #define _SYS_JAIL_H_
32 
33 #ifdef _KERNEL
34 struct jail_v0 {
35 	u_int32_t	version;
36 	char		*path;
37 	char		*hostname;
38 	u_int32_t	ip_number;
39 };
40 #endif
41 
42 struct jail {
43 	uint32_t	version;
44 	char		*path;
45 	char		*hostname;
46 	char		*jailname;
47 	uint32_t	ip4s;
48 	uint32_t	ip6s;
49 	struct in_addr	*ip4;
50 	struct in6_addr	*ip6;
51 };
52 #define	JAIL_API_VERSION	2
53 
54 /*
55  * For all xprison structs, always keep the pr_version an int and
56  * the first variable so userspace can easily distinguish them.
57  */
58 #ifndef _KERNEL
59 struct xprison_v1 {
60 	int		 pr_version;
61 	int		 pr_id;
62 	char		 pr_path[MAXPATHLEN];
63 	char		 pr_host[MAXHOSTNAMELEN];
64 	u_int32_t	 pr_ip;
65 };
66 #endif
67 
68 struct xprison {
69 	int		 pr_version;
70 	int		 pr_id;
71 	int		 pr_state;
72 	cpusetid_t	 pr_cpusetid;
73 	char		 pr_path[MAXPATHLEN];
74 	char		 pr_host[MAXHOSTNAMELEN];
75 	char		 pr_name[MAXHOSTNAMELEN];
76 	uint32_t	 pr_ip4s;
77 	uint32_t	 pr_ip6s;
78 #if 0
79 	/*
80 	 * sizeof(xprison) will be malloced + size needed for all
81 	 * IPv4 and IPv6 addesses. Offsets are based numbers of addresses.
82 	 */
83 	struct in_addr	 pr_ip4[];
84 	struct in6_addr	 pr_ip6[];
85 #endif
86 };
87 #define	XPRISON_VERSION		3
88 
89 enum prison_state {
90     PRISON_STATE_INVALID = 0,	/* New prison, not ready to be seen */
91     PRISON_STATE_ALIVE,		/* Current prison, visible to all */
92     PRISON_STATE_DYING		/* Removed but holding resources, */
93 };				/* optionally visible. */
94 
95 /*
96  * Flags for jail_set and jail_get.
97  */
98 #define	JAIL_CREATE	0x01	/* Create jail if it doesn't exist */
99 #define	JAIL_UPDATE	0x02	/* Update parameters of existing jail */
100 #define	JAIL_ATTACH	0x04	/* Attach to jail upon creation */
101 #define	JAIL_DYING	0x08	/* Allow getting a dying jail */
102 #define	JAIL_SET_MASK	0x0f	/* JAIL_DYING is deprecated/ignored here */
103 #define	JAIL_GET_MASK	0x08
104 
105 #define	JAIL_SYS_DISABLE	0
106 #define	JAIL_SYS_NEW		1
107 #define	JAIL_SYS_INHERIT	2
108 
109 #ifndef _KERNEL
110 
111 struct iovec;
112 
113 __BEGIN_DECLS
114 int jail(struct jail *);
115 int jail_set(struct iovec *, unsigned int, int);
116 int jail_get(struct iovec *, unsigned int, int);
117 int jail_attach(int);
118 int jail_remove(int);
119 __END_DECLS
120 
121 #else /* _KERNEL */
122 
123 #include <sys/queue.h>
124 #include <sys/sysctl.h>
125 #include <sys/lock.h>
126 #include <sys/mutex.h>
127 #include <sys/_task.h>
128 
129 #define JAIL_MAX	999999
130 
131 #ifdef MALLOC_DECLARE
132 MALLOC_DECLARE(M_PRISON);
133 #endif
134 #endif /* _KERNEL */
135 
136 #if defined(_KERNEL) || defined(_WANT_PRISON)
137 
138 #include <sys/osd.h>
139 
140 #define	HOSTUUIDLEN	64
141 #define	DEFAULT_HOSTUUID	"00000000-0000-0000-0000-000000000000"
142 #define	OSRELEASELEN	32
143 
144 struct racct;
145 struct prison_racct;
146 
147 typedef enum {
148 	PR_INET		= 0,
149 	PR_INET6	= 1,
150 	PR_FAMILY_MAX	= 2,
151 } pr_family_t;
152 
153 /*
154  * This structure describes a prison.  It is pointed to by all struct
155  * ucreds's of the inmates.  pr_ref keeps track of them and is used to
156  * delete the structure when the last inmate is dead.
157  *
158  * Lock key:
159  *   (a) allprison_lock
160  *   (A) allproc_lock
161  *   (c) set only during creation before the structure is shared, no mutex
162  *       required to read
163  *   (m) locked by pr_mtx
164  *   (p) locked by pr_mtx, and also at least shared allprison_lock required
165  *       to update
166  *   (q) locked by both pr_mtx and allprison_lock
167  *   (r) atomic via refcount(9), pr_mtx and allprison_lock required to
168  *       decrement to zero
169  *   (n) read access granted with the network epoch
170  */
171 struct prison {
172 	TAILQ_ENTRY(prison) pr_list;			/* (a) all prisons */
173 	int		 pr_id;				/* (c) prison id */
174 	volatile u_int	 pr_ref;			/* (r) refcount */
175 	volatile u_int	 pr_uref;			/* (r) user (alive) refcount */
176 	unsigned	 pr_flags;			/* (p) PR_* flags */
177 	LIST_HEAD(, prison) pr_children;		/* (a) list of child jails */
178 	LIST_HEAD(, proc) pr_proclist;			/* (A) list of jailed processes */
179 	LIST_ENTRY(prison) pr_sibling;			/* (a) next in parent's list */
180 	struct prison	*pr_parent;			/* (c) containing jail */
181 	struct mtx	 pr_mtx;
182 	struct task	 pr_task;			/* (c) destroy task */
183 	struct osd	 pr_osd;			/* (p) additional data */
184 	struct cpuset	*pr_cpuset;			/* (p) cpuset */
185 	struct vnet	*pr_vnet;			/* (c) network stack */
186 	struct vnode	*pr_root;			/* (c) vnode to rdir */
187 	struct prison_ip  *pr_addrs[PR_FAMILY_MAX];	/* (p,n) IPs of jail */
188 	struct prison_racct *pr_prison_racct;		/* (c) racct jail proxy */
189 	void		*pr_sparep[3];
190 	int		 pr_childcount;			/* (a) number of child jails */
191 	int		 pr_childmax;			/* (p) maximum child jails */
192 	unsigned	 pr_allow;			/* (p) PR_ALLOW_* flags */
193 	int		 pr_securelevel;		/* (p) securelevel */
194 	int		 pr_enforce_statfs;		/* (p) statfs permission */
195 	int		 pr_devfs_rsnum;		/* (p) devfs ruleset */
196 	enum prison_state pr_state;			/* (q) state in life cycle */
197 	volatile int	 pr_exportcnt;			/* (r) count of mount exports */
198 	int		 pr_spare;
199 	int		 pr_osreldate;			/* (c) kern.osreldate value */
200 	unsigned long	 pr_hostid;			/* (p) jail hostid */
201 	char		 pr_name[MAXHOSTNAMELEN];	/* (p) admin jail name */
202 	char		 pr_path[MAXPATHLEN];		/* (c) chroot path */
203 	char		 pr_hostname[MAXHOSTNAMELEN];	/* (p) jail hostname */
204 	char		 pr_domainname[MAXHOSTNAMELEN];	/* (p) jail domainname */
205 	char		 pr_hostuuid[HOSTUUIDLEN];	/* (p) jail hostuuid */
206 	char		 pr_osrelease[OSRELEASELEN];	/* (c) kern.osrelease value */
207 };
208 
209 struct prison_racct {
210 	LIST_ENTRY(prison_racct) prr_next;
211 	char		prr_name[MAXHOSTNAMELEN];
212 	u_int		prr_refcount;
213 	struct racct	*prr_racct;
214 };
215 #endif /* _KERNEL || _WANT_PRISON */
216 
217 #ifdef _KERNEL
218 /* Flag bits set via options */
219 #define	PR_PERSIST	0x00000001	/* Can exist without processes */
220 #define	PR_HOST		0x00000002	/* Virtualize hostname et al */
221 #define	PR_IP4_USER	0x00000004	/* Restrict IPv4 addresses */
222 #define	PR_IP6_USER	0x00000008	/* Restrict IPv6 addresses */
223 #define	PR_VNET		0x00000010	/* Virtual network stack */
224 #define	PR_IP4_SADDRSEL	0x00000080	/* Do IPv4 src addr sel. or use the */
225 					/* primary jail address. */
226 #define	PR_IP6_SADDRSEL	0x00000100	/* Do IPv6 src addr sel. or use the */
227 					/* primary jail address. */
228 
229 /* Internal flag bits */
230 #define	PR_REMOVE	0x01000000	/* In process of being removed */
231 #define	PR_IP4		0x02000000	/* IPv4 restricted or disabled */
232 					/* by this jail or an ancestor */
233 #define	PR_IP6		0x04000000	/* IPv6 restricted or disabled */
234 					/* by this jail or an ancestor */
235 #define PR_COMPLETE_PROC 0x08000000	/* prison_complete called from */
236 					/* prison_proc_free, releases uref */
237 
238 /*
239  * Flags for pr_allow
240  * Bits not noted here may be used for dynamic allow.mount.xxxfs.
241  */
242 #define	PR_ALLOW_SET_HOSTNAME		0x00000001
243 #define	PR_ALLOW_SYSVIPC		0x00000002
244 #define	PR_ALLOW_RAW_SOCKETS		0x00000004
245 #define	PR_ALLOW_CHFLAGS		0x00000008
246 #define	PR_ALLOW_MOUNT			0x00000010
247 #define	PR_ALLOW_QUOTAS			0x00000020
248 #define	PR_ALLOW_SOCKET_AF		0x00000040
249 #define	PR_ALLOW_MLOCK			0x00000080
250 #define	PR_ALLOW_READ_MSGBUF		0x00000100
251 #define	PR_ALLOW_UNPRIV_DEBUG		0x00000200
252 #define	PR_ALLOW_SUSER			0x00000400
253 #define	PR_ALLOW_RESERVED_PORTS		0x00008000
254 #define	PR_ALLOW_KMEM_ACCESS		0x00010000	/* reserved, not used yet */
255 #define	PR_ALLOW_NFSD			0x00020000
256 #define	PR_ALLOW_EXTATTR		0x00040000
257 #define	PR_ALLOW_ADJTIME		0x00080000
258 #define	PR_ALLOW_SETTIME		0x00100000
259 #define	PR_ALLOW_ALL_STATIC		0x001f87ff
260 
261 /*
262  * PR_ALLOW_DIFFERENCES determines which flags are able to be
263  * different between the parent and child jail upon creation.
264  */
265 #define	PR_ALLOW_DIFFERENCES		(PR_ALLOW_UNPRIV_DEBUG)
266 
267 /*
268  * OSD methods
269  */
270 #define	PR_METHOD_CREATE	0
271 #define	PR_METHOD_GET		1
272 #define	PR_METHOD_SET		2
273 #define	PR_METHOD_CHECK		3
274 #define	PR_METHOD_ATTACH	4
275 #define	PR_METHOD_REMOVE	5
276 #define	PR_MAXMETHOD		6
277 
278 /*
279  * Lock/unlock a prison.
280  * XXX These exist not so much for general convenience, but to be useable in
281  *     the FOREACH_PRISON_DESCENDANT_LOCKED macro which can't handle them in
282  *     non-function form as currently defined.
283  */
284 static __inline void
prison_lock(struct prison * pr)285 prison_lock(struct prison *pr)
286 {
287 
288 	mtx_lock(&pr->pr_mtx);
289 }
290 
291 static __inline void
prison_unlock(struct prison * pr)292 prison_unlock(struct prison *pr)
293 {
294 
295 	mtx_unlock(&pr->pr_mtx);
296 }
297 
298 /* Traverse a prison's immediate children. */
299 #define	FOREACH_PRISON_CHILD(ppr, cpr)					\
300 	LIST_FOREACH(cpr, &(ppr)->pr_children, pr_sibling)
301 
302 /*
303  * Preorder traversal of all of a prison's descendants.
304  * This ugly loop allows the macro to be followed by a single block
305  * as expected in a looping primitive.
306  */
307 #define	FOREACH_PRISON_DESCENDANT(ppr, cpr, descend)			\
308 	for ((cpr) = (ppr), (descend) = 1;				\
309 	    ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))	\
310 	      ? LIST_FIRST(&(cpr)->pr_children)				\
311 	      : ((cpr) == (ppr)						\
312 		 ? NULL							\
313 		 : (((descend) = LIST_NEXT(cpr, pr_sibling) != NULL)	\
314 		    ? LIST_NEXT(cpr, pr_sibling)			\
315 		    : (cpr)->pr_parent))));)				\
316 		if (!(descend))						\
317 			;						\
318 		else
319 
320 /*
321  * As above, but lock descendants on the way down and unlock on the way up.
322  */
323 #define	FOREACH_PRISON_DESCENDANT_LOCKED(ppr, cpr, descend)		\
324 	for ((cpr) = (ppr), (descend) = 1;				\
325 	    ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))	\
326 	      ? LIST_FIRST(&(cpr)->pr_children)				\
327 	      : ((cpr) == (ppr)						\
328 		 ? NULL							\
329 		 : ((prison_unlock(cpr),				\
330 		    (descend) = LIST_NEXT(cpr, pr_sibling) != NULL)	\
331 		    ? LIST_NEXT(cpr, pr_sibling)			\
332 		    : (cpr)->pr_parent))));)				\
333 		if ((descend) ? (prison_lock(cpr), 0) : 1)		\
334 			;						\
335 		else
336 
337 /*
338  * As above, but also keep track of the level descended to.
339  */
340 #define	FOREACH_PRISON_DESCENDANT_LOCKED_LEVEL(ppr, cpr, descend, level)\
341 	for ((cpr) = (ppr), (descend) = 1, (level) = 0;			\
342 	    ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))	\
343 	      ? (level++, LIST_FIRST(&(cpr)->pr_children))		\
344 	      : ((cpr) == (ppr)						\
345 		 ? NULL							\
346 		 : ((prison_unlock(cpr),				\
347 		    (descend) = LIST_NEXT(cpr, pr_sibling) != NULL)	\
348 		    ? LIST_NEXT(cpr, pr_sibling)			\
349 		    : (level--, (cpr)->pr_parent)))));)			\
350 		if ((descend) ? (prison_lock(cpr), 0) : 1)		\
351 			;						\
352 		else
353 
354 /*
355  * Traverse a prison's descendants, visiting both preorder and postorder.
356  */
357 #define FOREACH_PRISON_DESCENDANT_PRE_POST(ppr, cpr, descend)		\
358 	for ((cpr) = (ppr), (descend) = 1;				\
359 	     ((cpr) = (descend)						\
360 	      ? ((descend) = !LIST_EMPTY(&(cpr)->pr_children))		\
361 		? LIST_FIRST(&(cpr)->pr_children)			\
362 		: (cpr)							\
363 	      : ((descend) = LIST_NEXT(cpr, pr_sibling) != NULL)	\
364 		? LIST_NEXT(cpr, pr_sibling)				\
365 		: cpr->pr_parent) != (ppr);)
366 
367 /*
368  * Attributes of the physical system, and the root of the jail tree.
369  */
370 extern struct	prison prison0;
371 
372 TAILQ_HEAD(prisonlist, prison);
373 extern struct	prisonlist allprison;
374 extern struct	sx allprison_lock;
375 
376 /*
377  * Sysctls to describe jail parameters.
378  */
379 SYSCTL_DECL(_security_jail_param);
380 
381 #define SYSCTL_JAIL_PARAM_DECL(name)					\
382 	SYSCTL_DECL(_security_jail_param_##name)
383 #define	SYSCTL_JAIL_PARAM(module, param, type, fmt, descr)		\
384 	SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,	\
385 	    (type) | CTLFLAG_MPSAFE, NULL, 0, sysctl_jail_param, fmt, descr)
386 #define	SYSCTL_JAIL_PARAM_STRING(module, param, access, len, descr)	\
387 	SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,	\
388 	    CTLTYPE_STRING | CTLFLAG_MPSAFE | (access), NULL, len,	\
389 	    sysctl_jail_param, "A", descr)
390 #define	SYSCTL_JAIL_PARAM_STRUCT(module, param, access, len, fmt, descr) \
391 	SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,	\
392 	    CTLTYPE_STRUCT | CTLFLAG_MPSAFE | (access), NULL, len,	\
393 	    sysctl_jail_param, fmt, descr)
394 #define	SYSCTL_JAIL_PARAM_NODE(module, descr)				\
395 	SYSCTL_NODE(_security_jail_param, OID_AUTO, module, CTLFLAG_MPSAFE, \
396 	    0, descr)
397 #define	SYSCTL_JAIL_PARAM_SUBNODE(parent, module, descr)		\
398 	SYSCTL_NODE(_security_jail_param_##parent, OID_AUTO, module,	\
399 	    CTLFLAG_MPSAFE, 0, descr)
400 #define	SYSCTL_JAIL_PARAM_SYS_NODE(module, access, descr)		\
401 	SYSCTL_JAIL_PARAM_NODE(module, descr);				\
402 	SYSCTL_JAIL_PARAM(_##module, , CTLTYPE_INT | (access), "E,jailsys", \
403 	    descr)
404 #define	SYSCTL_JAIL_PARAM_SYS_SUBNODE(parent, module, access, descr)	\
405 	SYSCTL_JAIL_PARAM_SUBNODE(parent, module, descr);		\
406 	SYSCTL_JAIL_PARAM(_##parent##_##module, , CTLTYPE_INT | (access), \
407 	    "E,jailsys", descr)
408 
409 /*
410  * Kernel support functions for jail().
411  */
412 struct ucred;
413 struct mount;
414 struct sockaddr;
415 struct statfs;
416 struct vfsconf;
417 
418 /*
419  * Return 1 if the passed credential is in a jail, otherwise 0.
420  */
421 #define jailed(cred)	(cred->cr_prison != &prison0)
422 
423 bool jailed_without_vnet(struct ucred *);
424 void getcredhostname(struct ucred *, char *, size_t);
425 void getcreddomainname(struct ucred *, char *, size_t);
426 void getcredhostuuid(struct ucred *, char *, size_t);
427 void getcredhostid(struct ucred *, unsigned long *);
428 void getjailname(struct ucred *cred, char *name, size_t len);
429 void prison0_init(void);
430 bool prison_allow(struct ucred *, unsigned);
431 int prison_check(struct ucred *cred1, struct ucred *cred2);
432 bool prison_check_nfsd(struct ucred *cred);
433 bool prison_owns_vnet(struct ucred *);
434 int prison_canseemount(struct ucred *cred, struct mount *mp);
435 void prison_enforce_statfs(struct ucred *cred, struct mount *mp,
436     struct statfs *sp);
437 struct prison *prison_find(int prid);
438 struct prison *prison_find_child(struct prison *, int);
439 struct prison *prison_find_name(struct prison *, const char *);
440 bool prison_flag(struct ucred *, unsigned);
441 void prison_free(struct prison *pr);
442 void prison_free_locked(struct prison *pr);
443 void prison_hold(struct prison *pr);
444 void prison_hold_locked(struct prison *pr);
445 void prison_proc_hold(struct prison *);
446 void prison_proc_free(struct prison *);
447 void prison_proc_link(struct prison *, struct proc *);
448 void prison_proc_unlink(struct prison *, struct proc *);
449 void prison_proc_iterate(struct prison *, void (*)(struct proc *, void *), void *);
450 void prison_set_allow(struct ucred *cred, unsigned flag, int enable);
451 bool prison_ischild(struct prison *, struct prison *);
452 bool prison_isalive(const struct prison *);
453 bool prison_isvalid(struct prison *);
454 #if defined(INET) || defined(INET6)
455 int prison_ip_check(const struct prison *, const pr_family_t, const void *);
456 const void *prison_ip_get0(const struct prison *, const pr_family_t);
457 u_int prison_ip_cnt(const struct prison *, const pr_family_t);
458 #endif
459 #ifdef INET
460 bool prison_equal_ip4(struct prison *, struct prison *);
461 int prison_get_ip4(struct ucred *cred, struct in_addr *ia);
462 int prison_local_ip4(struct ucred *cred, struct in_addr *ia);
463 int prison_remote_ip4(struct ucred *cred, struct in_addr *ia);
464 int prison_check_ip4(const struct ucred *, const struct in_addr *);
465 int prison_check_ip4_locked(const struct prison *, const struct in_addr *);
466 bool prison_saddrsel_ip4(struct ucred *, struct in_addr *);
467 int prison_qcmp_v4(const void *, const void *);
468 bool prison_valid_v4(const void *);
469 #endif
470 #ifdef INET6
471 bool prison_equal_ip6(struct prison *, struct prison *);
472 int prison_get_ip6(struct ucred *, struct in6_addr *);
473 int prison_local_ip6(struct ucred *, struct in6_addr *, int);
474 int prison_remote_ip6(struct ucred *, struct in6_addr *);
475 int prison_check_ip6(const struct ucred *, const struct in6_addr *);
476 int prison_check_ip6_locked(const struct prison *, const struct in6_addr *);
477 bool prison_saddrsel_ip6(struct ucred *, struct in6_addr *);
478 int prison_qcmp_v6(const void *, const void *);
479 bool prison_valid_v6(const void *);
480 #endif
481 int prison_check_af(struct ucred *cred, int af);
482 int prison_if(struct ucred *cred, const struct sockaddr *sa);
483 char *prison_name(struct prison *, struct prison *);
484 int prison_priv_check(struct ucred *cred, int priv);
485 int sysctl_jail_param(SYSCTL_HANDLER_ARGS);
486 unsigned prison_add_allow(const char *prefix, const char *name,
487     const char *prefix_descr, const char *descr);
488 void prison_add_vfs(struct vfsconf *vfsp);
489 void prison_racct_foreach(void (*callback)(struct racct *racct,
490     void *arg2, void *arg3), void (*pre)(void), void (*post)(void),
491     void *arg2, void *arg3);
492 struct prison_racct *prison_racct_find(const char *name);
493 void prison_racct_hold(struct prison_racct *prr);
494 void prison_racct_free(struct prison_racct *prr);
495 
496 #endif /* _KERNEL */
497 #endif /* !_SYS_JAIL_H_ */
498