sys/kern/kern_jail.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999 Poul-Henning Kamp.
   5  * Copyright (c) 2008 Bjoern A. Zeeb.
   6  * Copyright (c) 2009 James Gritton.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  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 the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include "opt_ddb.h"
  35 #include "opt_inet.h"
  36 #include "opt_inet6.h"
  37
  38 #include <sys/param.h>
  39 #include <sys/types.h>
  40 #include <sys/kernel.h>
  41 #include <sys/systm.h>
  42 #include <sys/errno.h>
  43 #include <sys/sysproto.h>
  44 #include <sys/malloc.h>
  45 #include <sys/osd.h>
  46 #include <sys/priv.h>
  47 #include <sys/proc.h>
  48 #include <sys/taskqueue.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/jail.h>
  51 #include <sys/lock.h>
  52 #include <sys/mutex.h>
  53 #include <sys/racct.h>
  54 #include <sys/rctl.h>
  55 #include <sys/refcount.h>
  56 #include <sys/sx.h>
  57 #include <sys/sysent.h>
  58 #include <sys/namei.h>
  59 #include <sys/mount.h>
  60 #include <sys/queue.h>
  61 #include <sys/socket.h>
  62 #include <sys/syscallsubr.h>
  63 #include <sys/sysctl.h>
  64 #include <sys/vnode.h>
  65
  66 #include <net/if.h>
  67 #include <net/vnet.h>
  68
  69 #include <netinet/in.h>
  70
  71 #ifdef DDB
  72 #include <ddb/ddb.h>
  73 #endif /* DDB */
  74
  75 #include <security/mac/mac_framework.h>
  76
  77 #define DEFAULT_HOSTUUID        "00000000-0000-0000-0000-000000000000"
  78
  79 MALLOC_DEFINE(M_PRISON, "prison", "Prison structures");
  80 static MALLOC_DEFINE(M_PRISON_RACCT, "prison_racct", "Prison racct structures");
  81
  82 /* Keep struct prison prison0 and some code in kern_jail_set() readable. */
  83 #ifdef INET
  84 #ifdef INET6
  85 #define _PR_IP_SADDRSEL PR_IP4_SADDRSEL|PR_IP6_SADDRSEL
  86 #else
  87 #define _PR_IP_SADDRSEL PR_IP4_SADDRSEL
  88 #endif
  89 #else /* !INET */
  90 #ifdef INET6
  91 #define _PR_IP_SADDRSEL PR_IP6_SADDRSEL
  92 #else
  93 #define _PR_IP_SADDRSEL 0
  94 #endif
  95 #endif
  96
  97 /* prison0 describes what is "real" about the system. */
  98 struct prison prison0 = {
  99         .pr_id          = 0,
 100         .pr_name        = "0",
 101         .pr_ref         = 1,
 102         .pr_uref        = 1,
 103         .pr_path        = "/",
 104         .pr_securelevel = -1,
 105         .pr_devfs_rsnum = 0,
 106         .pr_childmax    = JAIL_MAX,
 107         .pr_hostuuid    = DEFAULT_HOSTUUID,
 108         .pr_children    = LIST_HEAD_INITIALIZER(prison0.pr_children),
 109 #ifdef VIMAGE
 110         .pr_flags       = PR_HOST|PR_VNET|_PR_IP_SADDRSEL,
 111 #else
 112         .pr_flags       = PR_HOST|_PR_IP_SADDRSEL,
 113 #endif
 114         .pr_allow       = PR_ALLOW_ALL_STATIC,
 115 };
 116 MTX_SYSINIT(prison0, &prison0.pr_mtx, "jail mutex", MTX_DEF);
 117
 118 struct bool_flags {
 119         const char      *name;
 120         const char      *noname;
 121         unsigned         flag;
 122 };
 123 struct jailsys_flags {
 124         const char      *name;
 125         unsigned         disable;
 126         unsigned         new;
 127 };
 128
 129 /* allprison, allprison_racct and lastprid are protected by allprison_lock. */
 130 struct  sx allprison_lock;
 131 SX_SYSINIT(allprison_lock, &allprison_lock, "allprison");
 132 struct  prisonlist allprison = TAILQ_HEAD_INITIALIZER(allprison);
 133 LIST_HEAD(, prison_racct) allprison_racct;
 134 int     lastprid = 0;
 135
 136 static int do_jail_attach(struct thread *td, struct prison *pr);
 137 static void prison_complete(void *context, int pending);
 138 static void prison_deref(struct prison *pr, int flags);
 139 static char *prison_path(struct prison *pr1, struct prison *pr2);
 140 static void prison_remove_one(struct prison *pr);
 141 #ifdef RACCT
 142 static void prison_racct_attach(struct prison *pr);
 143 static void prison_racct_modify(struct prison *pr);
 144 static void prison_racct_detach(struct prison *pr);
 145 #endif
 146
 147 /* Flags for prison_deref */
 148 #define PD_DEREF        0x01
 149 #define PD_DEUREF       0x02
 150 #define PD_LOCKED       0x04
 151 #define PD_LIST_SLOCKED 0x08
 152 #define PD_LIST_XLOCKED 0x10
 153
 154 /*
 155  * Parameter names corresponding to PR_* flag values.  Size values are for kvm
 156  * as we cannot figure out the size of a sparse array, or an array without a
 157  * terminating entry.
 158  */
 159 static struct bool_flags pr_flag_bool[] = {
 160         {"persist", "nopersist", PR_PERSIST},
 161 #ifdef INET
 162         {"ip4.saddrsel", "ip4.nosaddrsel", PR_IP4_SADDRSEL},
 163 #endif
 164 #ifdef INET6
 165         {"ip6.saddrsel", "ip6.nosaddrsel", PR_IP6_SADDRSEL},
 166 #endif
 167 };
 168 const size_t pr_flag_bool_size = sizeof(pr_flag_bool);
 169
 170 static struct jailsys_flags pr_flag_jailsys[] = {
 171         {"host", 0, PR_HOST},
 172 #ifdef VIMAGE
 173         {"vnet", 0, PR_VNET},
 174 #endif
 175 #ifdef INET
 176         {"ip4", PR_IP4_USER, PR_IP4_USER},
 177 #endif
 178 #ifdef INET6
 179         {"ip6", PR_IP6_USER, PR_IP6_USER},
 180 #endif
 181 };
 182 const size_t pr_flag_jailsys_size = sizeof(pr_flag_jailsys);
 183
 184 /* Make this array full-size so dynamic parameters can be added. */
 185 static struct bool_flags pr_flag_allow[NBBY * NBPW] = {
 186         {"allow.set_hostname", "allow.noset_hostname", PR_ALLOW_SET_HOSTNAME},
 187         {"allow.sysvipc", "allow.nosysvipc", PR_ALLOW_SYSVIPC},
 188         {"allow.raw_sockets", "allow.noraw_sockets", PR_ALLOW_RAW_SOCKETS},
 189         {"allow.chflags", "allow.nochflags", PR_ALLOW_CHFLAGS},
 190         {"allow.mount", "allow.nomount", PR_ALLOW_MOUNT},
 191         {"allow.quotas", "allow.noquotas", PR_ALLOW_QUOTAS},
 192         {"allow.socket_af", "allow.nosocket_af", PR_ALLOW_SOCKET_AF},
 193         {"allow.reserved_ports", "allow.noreserved_ports",
 194          PR_ALLOW_RESERVED_PORTS},
 195 };
 196 const size_t pr_flag_allow_size = sizeof(pr_flag_allow);
 197
 198 #define JAIL_DEFAULT_ALLOW              (PR_ALLOW_SET_HOSTNAME | PR_ALLOW_RESERVED_PORTS)
 199 #define JAIL_DEFAULT_ENFORCE_STATFS     2
 200 #define JAIL_DEFAULT_DEVFS_RSNUM        0
 201 static unsigned jail_default_allow = JAIL_DEFAULT_ALLOW;
 202 static int jail_default_enforce_statfs = JAIL_DEFAULT_ENFORCE_STATFS;
 203 static int jail_default_devfs_rsnum = JAIL_DEFAULT_DEVFS_RSNUM;
 204 #if defined(INET) || defined(INET6)
 205 static unsigned jail_max_af_ips = 255;
 206 #endif
 207
 208 /*
 209  * Initialize the parts of prison0 that can't be static-initialized with
 210  * constants.  This is called from proc0_init() after creating thread0 cpuset.
 211  */
 212 void
 213 prison0_init(void)
 214 {
 215
 216         prison0.pr_cpuset = cpuset_ref(thread0.td_cpuset);
 217         prison0.pr_osreldate = osreldate;
 218         strlcpy(prison0.pr_osrelease, osrelease, sizeof(prison0.pr_osrelease));
 219 }
 220
 221 /*
 222  * struct jail_args {
 223  *      struct jail *jail;
 224  * };
 225  */
 226 int
 227 sys_jail(struct thread *td, struct jail_args *uap)
 228 {
 229         uint32_t version;
 230         int error;
 231         struct jail j;
 232
 233         error = copyin(uap->jail, &version, sizeof(uint32_t));
 234         if (error)
 235                 return (error);
 236
 237         switch (version) {
 238         case 0:
 239         {
 240                 struct jail_v0 j0;
 241
 242                 /* FreeBSD single IPv4 jails. */
 243                 bzero(&j, sizeof(struct jail));
 244                 error = copyin(uap->jail, &j0, sizeof(struct jail_v0));
 245                 if (error)
 246                         return (error);
 247                 j.version = j0.version;
 248                 j.path = j0.path;
 249                 j.hostname = j0.hostname;
 250                 j.ip4s = htonl(j0.ip_number);   /* jail_v0 is host order */
 251                 break;
 252         }
 253
 254         case 1:
 255                 /*
 256                  * Version 1 was used by multi-IPv4 jail implementations
 257                  * that never made it into the official kernel.
 258                  */
 259                 return (EINVAL);
 260
 261         case 2: /* JAIL_API_VERSION */
 262                 /* FreeBSD multi-IPv4/IPv6,noIP jails. */
 263                 error = copyin(uap->jail, &j, sizeof(struct jail));
 264                 if (error)
 265                         return (error);
 266                 break;
 267
 268         default:
 269                 /* Sci-Fi jails are not supported, sorry. */
 270                 return (EINVAL);
 271         }
 272         return (kern_jail(td, &j));
 273 }
 274
 275 int
 276 kern_jail(struct thread *td, struct jail *j)
 277 {
 278         struct iovec optiov[2 * (4 + nitems(pr_flag_allow)
 279 #ifdef INET
 280                             + 1
 281 #endif
 282 #ifdef INET6
 283                             + 1
 284 #endif
 285                             )];
 286         struct uio opt;
 287         char *u_path, *u_hostname, *u_name;
 288         struct bool_flags *bf;
 289 #ifdef INET
 290         uint32_t ip4s;
 291         struct in_addr *u_ip4;
 292 #endif
 293 #ifdef INET6
 294         struct in6_addr *u_ip6;
 295 #endif
 296         size_t tmplen;
 297         int error, enforce_statfs;
 298
 299         bzero(&optiov, sizeof(optiov));
 300         opt.uio_iov = optiov;
 301         opt.uio_iovcnt = 0;
 302         opt.uio_offset = -1;
 303         opt.uio_resid = -1;
 304         opt.uio_segflg = UIO_SYSSPACE;
 305         opt.uio_rw = UIO_READ;
 306         opt.uio_td = td;
 307
 308         /* Set permissions for top-level jails from sysctls. */
 309         if (!jailed(td->td_ucred)) {
 310                 for (bf = pr_flag_allow;
 311                      bf < pr_flag_allow + nitems(pr_flag_allow) &&
 312                         bf->flag != 0;
 313                      bf++) {
 314                         optiov[opt.uio_iovcnt].iov_base = __DECONST(char *,
 315                             (jail_default_allow & bf->flag)
 316                             ? bf->name : bf->noname);
 317                         optiov[opt.uio_iovcnt].iov_len =
 318                             strlen(optiov[opt.uio_iovcnt].iov_base) + 1;
 319                         opt.uio_iovcnt += 2;
 320                 }
 321                 optiov[opt.uio_iovcnt].iov_base = "enforce_statfs";
 322                 optiov[opt.uio_iovcnt].iov_len = sizeof("enforce_statfs");
 323                 opt.uio_iovcnt++;
 324                 enforce_statfs = jail_default_enforce_statfs;
 325                 optiov[opt.uio_iovcnt].iov_base = &enforce_statfs;
 326                 optiov[opt.uio_iovcnt].iov_len = sizeof(enforce_statfs);
 327                 opt.uio_iovcnt++;
 328         }
 329
 330         tmplen = MAXPATHLEN + MAXHOSTNAMELEN + MAXHOSTNAMELEN;
 331 #ifdef INET
 332         ip4s = (j->version == 0) ? 1 : j->ip4s;
 333         if (ip4s > jail_max_af_ips)
 334                 return (EINVAL);
 335         tmplen += ip4s * sizeof(struct in_addr);
 336 #else
 337         if (j->ip4s > 0)
 338                 return (EINVAL);
 339 #endif
 340 #ifdef INET6
 341         if (j->ip6s > jail_max_af_ips)
 342                 return (EINVAL);
 343         tmplen += j->ip6s * sizeof(struct in6_addr);
 344 #else
 345         if (j->ip6s > 0)
 346                 return (EINVAL);
 347 #endif
 348         u_path = malloc(tmplen, M_TEMP, M_WAITOK);
 349         u_hostname = u_path + MAXPATHLEN;
 350         u_name = u_hostname + MAXHOSTNAMELEN;
 351 #ifdef INET
 352         u_ip4 = (struct in_addr *)(u_name + MAXHOSTNAMELEN);
 353 #endif
 354 #ifdef INET6
 355 #ifdef INET
 356         u_ip6 = (struct in6_addr *)(u_ip4 + ip4s);
 357 #else
 358         u_ip6 = (struct in6_addr *)(u_name + MAXHOSTNAMELEN);
 359 #endif
 360 #endif
 361         optiov[opt.uio_iovcnt].iov_base = "path";
 362         optiov[opt.uio_iovcnt].iov_len = sizeof("path");
 363         opt.uio_iovcnt++;
 364         optiov[opt.uio_iovcnt].iov_base = u_path;
 365         error = copyinstr(j->path, u_path, MAXPATHLEN,
 366             &optiov[opt.uio_iovcnt].iov_len);
 367         if (error) {
 368                 free(u_path, M_TEMP);
 369                 return (error);
 370         }
 371         opt.uio_iovcnt++;
 372         optiov[opt.uio_iovcnt].iov_base = "host.hostname";
 373         optiov[opt.uio_iovcnt].iov_len = sizeof("host.hostname");
 374         opt.uio_iovcnt++;
 375         optiov[opt.uio_iovcnt].iov_base = u_hostname;
 376         error = copyinstr(j->hostname, u_hostname, MAXHOSTNAMELEN,
 377             &optiov[opt.uio_iovcnt].iov_len);
 378         if (error) {
 379                 free(u_path, M_TEMP);
 380                 return (error);
 381         }
 382         opt.uio_iovcnt++;
 383         if (j->jailname != NULL) {
 384                 optiov[opt.uio_iovcnt].iov_base = "name";
 385                 optiov[opt.uio_iovcnt].iov_len = sizeof("name");
 386                 opt.uio_iovcnt++;
 387                 optiov[opt.uio_iovcnt].iov_base = u_name;
 388                 error = copyinstr(j->jailname, u_name, MAXHOSTNAMELEN,
 389                     &optiov[opt.uio_iovcnt].iov_len);
 390                 if (error) {
 391                         free(u_path, M_TEMP);
 392                         return (error);
 393                 }
 394                 opt.uio_iovcnt++;
 395         }
 396 #ifdef INET
 397         optiov[opt.uio_iovcnt].iov_base = "ip4.addr";
 398         optiov[opt.uio_iovcnt].iov_len = sizeof("ip4.addr");
 399         opt.uio_iovcnt++;
 400         optiov[opt.uio_iovcnt].iov_base = u_ip4;
 401         optiov[opt.uio_iovcnt].iov_len = ip4s * sizeof(struct in_addr);
 402         if (j->version == 0)
 403                 u_ip4->s_addr = j->ip4s;
 404         else {
 405                 error = copyin(j->ip4, u_ip4, optiov[opt.uio_iovcnt].iov_len);
 406                 if (error) {
 407                         free(u_path, M_TEMP);
 408                         return (error);
 409                 }
 410         }
 411         opt.uio_iovcnt++;
 412 #endif
 413 #ifdef INET6
 414         optiov[opt.uio_iovcnt].iov_base = "ip6.addr";
 415         optiov[opt.uio_iovcnt].iov_len = sizeof("ip6.addr");
 416         opt.uio_iovcnt++;
 417         optiov[opt.uio_iovcnt].iov_base = u_ip6;
 418         optiov[opt.uio_iovcnt].iov_len = j->ip6s * sizeof(struct in6_addr);
 419         error = copyin(j->ip6, u_ip6, optiov[opt.uio_iovcnt].iov_len);
 420         if (error) {
 421                 free(u_path, M_TEMP);
 422                 return (error);
 423         }
 424         opt.uio_iovcnt++;
 425 #endif
 426         KASSERT(opt.uio_iovcnt <= nitems(optiov),
 427                 ("kern_jail: too many iovecs (%d)", opt.uio_iovcnt));
 428         error = kern_jail_set(td, &opt, JAIL_CREATE | JAIL_ATTACH);
 429         free(u_path, M_TEMP);
 430         return (error);
 431 }
 432
 433
 434 /*
 435  * struct jail_set_args {
 436  *      struct iovec *iovp;
 437  *      unsigned int iovcnt;
 438  *      int flags;
 439  * };
 440  */
 441 int
 442 sys_jail_set(struct thread *td, struct jail_set_args *uap)
 443 {
 444         struct uio *auio;
 445         int error;
 446
 447         /* Check that we have an even number of iovecs. */
 448         if (uap->iovcnt & 1)
 449                 return (EINVAL);
 450
 451         error = copyinuio(uap->iovp, uap->iovcnt, &auio);
 452         if (error)
 453                 return (error);
 454         error = kern_jail_set(td, auio, uap->flags);
 455         free(auio, M_IOV);
 456         return (error);
 457 }
 458
 459 int
 460 kern_jail_set(struct thread *td, struct uio *optuio, int flags)
 461 {
 462         struct nameidata nd;
 463 #ifdef INET
 464         struct in_addr *ip4;
 465 #endif
 466 #ifdef INET6
 467         struct in6_addr *ip6;
 468 #endif
 469         struct vfsopt *opt;
 470         struct vfsoptlist *opts;
 471         struct prison *pr, *deadpr, *mypr, *ppr, *tpr;
 472         struct vnode *root;
 473         char *domain, *errmsg, *host, *name, *namelc, *p, *path, *uuid;
 474         char *g_path, *osrelstr;
 475         struct bool_flags *bf;
 476         struct jailsys_flags *jsf;
 477 #if defined(INET) || defined(INET6)
 478         struct prison *tppr;
 479         void *op;
 480 #endif
 481         unsigned long hid;
 482         size_t namelen, onamelen, pnamelen;
 483         int born, created, cuflags, descend, enforce;
 484         int error, errmsg_len, errmsg_pos;
 485         int gotchildmax, gotenforce, gothid, gotrsnum, gotslevel;
 486         int jid, jsys, len, level;
 487         int childmax, osreldt, rsnum, slevel;
 488         int fullpath_disabled;
 489 #if defined(INET) || defined(INET6)
 490         int ii, ij;
 491 #endif
 492 #ifdef INET
 493         int ip4s, redo_ip4;
 494 #endif
 495 #ifdef INET6
 496         int ip6s, redo_ip6;
 497 #endif
 498         uint64_t pr_allow, ch_allow, pr_flags, ch_flags;
 499         unsigned tallow;
 500         char numbuf[12];
 501
 502         error = priv_check(td, PRIV_JAIL_SET);
 503         if (!error && (flags & JAIL_ATTACH))
 504                 error = priv_check(td, PRIV_JAIL_ATTACH);
 505         if (error)
 506                 return (error);
 507         mypr = td->td_ucred->cr_prison;
 508         if ((flags & JAIL_CREATE) && mypr->pr_childmax == 0)
 509                 return (EPERM);
 510         if (flags & ~JAIL_SET_MASK)
 511                 return (EINVAL);
 512
 513         /*
 514          * Check all the parameters before committing to anything.  Not all
 515          * errors can be caught early, but we may as well try.  Also, this
 516          * takes care of some expensive stuff (path lookup) before getting
 517          * the allprison lock.
 518          *
 519          * XXX Jails are not filesystems, and jail parameters are not mount
 520          *     options.  But it makes more sense to re-use the vfsopt code
 521          *     than duplicate it under a different name.
 522          */
 523         error = vfs_buildopts(optuio, &opts);
 524         if (error)
 525                 return (error);
 526 #ifdef INET
 527         ip4 = NULL;
 528 #endif
 529 #ifdef INET6
 530         ip6 = NULL;
 531 #endif
 532         g_path = NULL;
 533
 534         cuflags = flags & (JAIL_CREATE | JAIL_UPDATE);
 535         if (!cuflags) {
 536                 error = EINVAL;
 537                 vfs_opterror(opts, "no valid operation (create or update)");
 538                 goto done_errmsg;
 539         }
 540
 541         error = vfs_copyopt(opts, "jid", &jid, sizeof(jid));
 542         if (error == ENOENT)
 543                 jid = 0;
 544         else if (error != 0)
 545                 goto done_free;
 546
 547         error = vfs_copyopt(opts, "securelevel", &slevel, sizeof(slevel));
 548         if (error == ENOENT)
 549                 gotslevel = 0;
 550         else if (error != 0)
 551                 goto done_free;
 552         else
 553                 gotslevel = 1;
 554
 555         error =
 556             vfs_copyopt(opts, "children.max", &childmax, sizeof(childmax));
 557         if (error == ENOENT)
 558                 gotchildmax = 0;
 559         else if (error != 0)
 560                 goto done_free;
 561         else
 562                 gotchildmax = 1;
 563
 564         error = vfs_copyopt(opts, "enforce_statfs", &enforce, sizeof(enforce));
 565         if (error == ENOENT)
 566                 gotenforce = 0;
 567         else if (error != 0)
 568                 goto done_free;
 569         else if (enforce < 0 || enforce > 2) {
 570                 error = EINVAL;
 571                 goto done_free;
 572         } else
 573                 gotenforce = 1;
 574
 575         error = vfs_copyopt(opts, "devfs_ruleset", &rsnum, sizeof(rsnum));
 576         if (error == ENOENT)
 577                 gotrsnum = 0;
 578         else if (error != 0)
 579                 goto done_free;
 580         else
 581                 gotrsnum = 1;
 582
 583         pr_flags = ch_flags = 0;
 584         for (bf = pr_flag_bool;
 585              bf < pr_flag_bool + nitems(pr_flag_bool);
 586              bf++) {
 587                 vfs_flagopt(opts, bf->name, &pr_flags, bf->flag);
 588                 vfs_flagopt(opts, bf->noname, &ch_flags, bf->flag);
 589         }
 590         ch_flags |= pr_flags;
 591         for (jsf = pr_flag_jailsys;
 592              jsf < pr_flag_jailsys + nitems(pr_flag_jailsys);
 593              jsf++) {
 594                 error = vfs_copyopt(opts, jsf->name, &jsys, sizeof(jsys));
 595                 if (error == ENOENT)
 596                         continue;
 597                 if (error != 0)
 598                         goto done_free;
 599                 switch (jsys) {
 600                 case JAIL_SYS_DISABLE:
 601                         if (!jsf->disable) {
 602                                 error = EINVAL;
 603                                 goto done_free;
 604                         }
 605                         pr_flags |= jsf->disable;
 606                         break;
 607                 case JAIL_SYS_NEW:
 608                         pr_flags |= jsf->new;
 609                         break;
 610                 case JAIL_SYS_INHERIT:
 611                         break;
 612                 default:
 613                         error = EINVAL;
 614                         goto done_free;
 615                 }
 616                 ch_flags |= jsf->new | jsf->disable;
 617         }
 618         if ((flags & (JAIL_CREATE | JAIL_UPDATE | JAIL_ATTACH)) == JAIL_CREATE
 619             && !(pr_flags & PR_PERSIST)) {
 620                 error = EINVAL;
 621                 vfs_opterror(opts, "new jail must persist or attach");
 622                 goto done_errmsg;
 623         }
 624 #ifdef VIMAGE
 625         if ((flags & JAIL_UPDATE) && (ch_flags & PR_VNET)) {
 626                 error = EINVAL;
 627                 vfs_opterror(opts, "vnet cannot be changed after creation");
 628                 goto done_errmsg;
 629         }
 630 #endif
 631 #ifdef INET
 632         if ((flags & JAIL_UPDATE) && (ch_flags & PR_IP4_USER)) {
 633                 error = EINVAL;
 634                 vfs_opterror(opts, "ip4 cannot be changed after creation");
 635                 goto done_errmsg;
 636         }
 637 #endif
 638 #ifdef INET6
 639         if ((flags & JAIL_UPDATE) && (ch_flags & PR_IP6_USER)) {
 640                 error = EINVAL;
 641                 vfs_opterror(opts, "ip6 cannot be changed after creation");
 642                 goto done_errmsg;
 643         }
 644 #endif
 645
 646         pr_allow = ch_allow = 0;
 647         for (bf = pr_flag_allow;
 648              bf < pr_flag_allow + nitems(pr_flag_allow) && bf->flag != 0;
 649              bf++) {
 650                 vfs_flagopt(opts, bf->name, &pr_allow, bf->flag);
 651                 vfs_flagopt(opts, bf->noname, &ch_allow, bf->flag);
 652         }
 653         ch_allow |= pr_allow;
 654
 655         error = vfs_getopt(opts, "name", (void **)&name, &len);
 656         if (error == ENOENT)
 657                 name = NULL;
 658         else if (error != 0)
 659                 goto done_free;
 660         else {
 661                 if (len == 0 || name[len - 1] != '\0') {
 662                         error = EINVAL;
 663                         goto done_free;
 664                 }
 665                 if (len > MAXHOSTNAMELEN) {
 666                         error = ENAMETOOLONG;
 667                         goto done_free;
 668                 }
 669         }
 670
 671         error = vfs_getopt(opts, "host.hostname", (void **)&host, &len);
 672         if (error == ENOENT)
 673                 host = NULL;
 674         else if (error != 0)
 675                 goto done_free;
 676         else {
 677                 ch_flags |= PR_HOST;
 678                 pr_flags |= PR_HOST;
 679                 if (len == 0 || host[len - 1] != '\0') {
 680                         error = EINVAL;
 681                         goto done_free;
 682                 }
 683                 if (len > MAXHOSTNAMELEN) {
 684                         error = ENAMETOOLONG;
 685                         goto done_free;
 686                 }
 687         }
 688
 689         error = vfs_getopt(opts, "host.domainname", (void **)&domain, &len);
 690         if (error == ENOENT)
 691                 domain = NULL;
 692         else if (error != 0)
 693                 goto done_free;
 694         else {
 695                 ch_flags |= PR_HOST;
 696                 pr_flags |= PR_HOST;
 697                 if (len == 0 || domain[len - 1] != '\0') {
 698                         error = EINVAL;
 699                         goto done_free;
 700                 }
 701                 if (len > MAXHOSTNAMELEN) {
 702                         error = ENAMETOOLONG;
 703                         goto done_free;
 704                 }
 705         }
 706
 707         error = vfs_getopt(opts, "host.hostuuid", (void **)&uuid, &len);
 708         if (error == ENOENT)
 709                 uuid = NULL;
 710         else if (error != 0)
 711                 goto done_free;
 712         else {
 713                 ch_flags |= PR_HOST;
 714                 pr_flags |= PR_HOST;
 715                 if (len == 0 || uuid[len - 1] != '\0') {
 716                         error = EINVAL;
 717                         goto done_free;
 718                 }
 719                 if (len > HOSTUUIDLEN) {
 720                         error = ENAMETOOLONG;
 721                         goto done_free;
 722                 }
 723         }
 724
 725 #ifdef COMPAT_FREEBSD32
 726         if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
 727                 uint32_t hid32;
 728
 729                 error = vfs_copyopt(opts, "host.hostid", &hid32, sizeof(hid32));
 730                 hid = hid32;
 731         } else
 732 #endif
 733                 error = vfs_copyopt(opts, "host.hostid", &hid, sizeof(hid));
 734         if (error == ENOENT)
 735                 gothid = 0;
 736         else if (error != 0)
 737                 goto done_free;
 738         else {
 739                 gothid = 1;
 740                 ch_flags |= PR_HOST;
 741                 pr_flags |= PR_HOST;
 742         }
 743
 744 #ifdef INET
 745         error = vfs_getopt(opts, "ip4.addr", &op, &ip4s);
 746         if (error == ENOENT)
 747                 ip4s = 0;
 748         else if (error != 0)
 749                 goto done_free;
 750         else if (ip4s & (sizeof(*ip4) - 1)) {
 751                 error = EINVAL;
 752                 goto done_free;
 753         } else {
 754                 ch_flags |= PR_IP4_USER;
 755                 pr_flags |= PR_IP4_USER;
 756                 if (ip4s > 0) {
 757                         ip4s /= sizeof(*ip4);
 758                         if (ip4s > jail_max_af_ips) {
 759                                 error = EINVAL;
 760                                 vfs_opterror(opts, "too many IPv4 addresses");
 761                                 goto done_errmsg;
 762                         }
 763                         ip4 = malloc(ip4s * sizeof(*ip4), M_PRISON, M_WAITOK);
 764                         bcopy(op, ip4, ip4s * sizeof(*ip4));
 765                         /*
 766                          * IP addresses are all sorted but ip[0] to preserve
 767                          * the primary IP address as given from userland.
 768                          * This special IP is used for unbound outgoing
 769                          * connections as well for "loopback" traffic in case
 770                          * source address selection cannot find any more fitting
 771                          * address to connect from.
 772                          */
 773                         if (ip4s > 1)
 774                                 qsort(ip4 + 1, ip4s - 1, sizeof(*ip4),
 775                                     prison_qcmp_v4);
 776                         /*
 777                          * Check for duplicate addresses and do some simple
 778                          * zero and broadcast checks. If users give other bogus
 779                          * addresses it is their problem.
 780                          *
 781                          * We do not have to care about byte order for these
 782                          * checks so we will do them in NBO.
 783                          */
 784                         for (ii = 0; ii < ip4s; ii++) {
 785                                 if (ip4[ii].s_addr == INADDR_ANY ||
 786                                     ip4[ii].s_addr == INADDR_BROADCAST) {
 787                                         error = EINVAL;
 788                                         goto done_free;
 789                                 }
 790                                 if ((ii+1) < ip4s &&
 791                                     (ip4[0].s_addr == ip4[ii+1].s_addr ||
 792                                      ip4[ii].s_addr == ip4[ii+1].s_addr)) {
 793                                         error = EINVAL;
 794                                         goto done_free;
 795                                 }
 796                         }
 797                 }
 798         }
 799 #endif
 800
 801 #ifdef INET6
 802         error = vfs_getopt(opts, "ip6.addr", &op, &ip6s);
 803         if (error == ENOENT)
 804                 ip6s = 0;
 805         else if (error != 0)
 806                 goto done_free;
 807         else if (ip6s & (sizeof(*ip6) - 1)) {
 808                 error = EINVAL;
 809                 goto done_free;
 810         } else {
 811                 ch_flags |= PR_IP6_USER;
 812                 pr_flags |= PR_IP6_USER;
 813                 if (ip6s > 0) {
 814                         ip6s /= sizeof(*ip6);
 815                         if (ip6s > jail_max_af_ips) {
 816                                 error = EINVAL;
 817                                 vfs_opterror(opts, "too many IPv6 addresses");
 818                                 goto done_errmsg;
 819                         }
 820                         ip6 = malloc(ip6s * sizeof(*ip6), M_PRISON, M_WAITOK);
 821                         bcopy(op, ip6, ip6s * sizeof(*ip6));
 822                         if (ip6s > 1)
 823                                 qsort(ip6 + 1, ip6s - 1, sizeof(*ip6),
 824                                     prison_qcmp_v6);
 825                         for (ii = 0; ii < ip6s; ii++) {
 826                                 if (IN6_IS_ADDR_UNSPECIFIED(&ip6[ii])) {
 827                                         error = EINVAL;
 828                                         goto done_free;
 829                                 }
 830                                 if ((ii+1) < ip6s &&
 831                                     (IN6_ARE_ADDR_EQUAL(&ip6[0], &ip6[ii+1]) ||
 832                                      IN6_ARE_ADDR_EQUAL(&ip6[ii], &ip6[ii+1])))
 833                                 {
 834                                         error = EINVAL;
 835                                         goto done_free;
 836                                 }
 837                         }
 838                 }
 839         }
 840 #endif
 841
 842 #if defined(VIMAGE) && (defined(INET) || defined(INET6))
 843         if ((ch_flags & PR_VNET) && (ch_flags & (PR_IP4_USER | PR_IP6_USER))) {
 844                 error = EINVAL;
 845                 vfs_opterror(opts,
 846                     "vnet jails cannot have IP address restrictions");
 847                 goto done_errmsg;
 848         }
 849 #endif
 850
 851         error = vfs_getopt(opts, "osrelease", (void **)&osrelstr, &len);
 852         if (error == ENOENT)
 853                 osrelstr = NULL;
 854         else if (error != 0)
 855                 goto done_free;
 856         else {
 857                 if (flags & JAIL_UPDATE) {
 858                         error = EINVAL;
 859                         vfs_opterror(opts,
 860                             "osrelease cannot be changed after creation");
 861                         goto done_errmsg;
 862                 }
 863                 if (len == 0 || len >= OSRELEASELEN) {
 864                         error = EINVAL;
 865                         vfs_opterror(opts,
 866                             "osrelease string must be 1-%d bytes long",
 867                             OSRELEASELEN - 1);
 868                         goto done_errmsg;
 869                 }
 870         }
 871
 872         error = vfs_copyopt(opts, "osreldate", &osreldt, sizeof(osreldt));
 873         if (error == ENOENT)
 874                 osreldt = 0;
 875         else if (error != 0)
 876                 goto done_free;
 877         else {
 878                 if (flags & JAIL_UPDATE) {
 879                         error = EINVAL;
 880                         vfs_opterror(opts,
 881                             "osreldate cannot be changed after creation");
 882                         goto done_errmsg;
 883                 }
 884                 if (osreldt == 0) {
 885                         error = EINVAL;
 886                         vfs_opterror(opts, "osreldate cannot be 0");
 887                         goto done_errmsg;
 888                 }
 889         }
 890
 891         fullpath_disabled = 0;
 892         root = NULL;
 893         error = vfs_getopt(opts, "path", (void **)&path, &len);
 894         if (error == ENOENT)
 895                 path = NULL;
 896         else if (error != 0)
 897                 goto done_free;
 898         else {
 899                 if (flags & JAIL_UPDATE) {
 900                         error = EINVAL;
 901                         vfs_opterror(opts,
 902                             "path cannot be changed after creation");
 903                         goto done_errmsg;
 904                 }
 905                 if (len == 0 || path[len - 1] != '\0') {
 906                         error = EINVAL;
 907                         goto done_free;
 908                 }
 909                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
 910                     path, td);
 911                 error = namei(&nd);
 912                 if (error)
 913                         goto done_free;
 914                 root = nd.ni_vp;
 915                 NDFREE(&nd, NDF_ONLY_PNBUF);
 916                 g_path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 917                 strlcpy(g_path, path, MAXPATHLEN);
 918                 error = vn_path_to_global_path(td, root, g_path, MAXPATHLEN);
 919                 if (error == 0)
 920                         path = g_path;
 921                 else if (error == ENODEV) {
 922                         /* proceed if sysctl debug.disablefullpath == 1 */
 923                         fullpath_disabled = 1;
 924                         if (len < 2 || (len == 2 && path[0] == '/'))
 925                                 path = NULL;
 926                 } else {
 927                         /* exit on other errors */
 928                         goto done_free;
 929                 }
 930                 if (root->v_type != VDIR) {
 931                         error = ENOTDIR;
 932                         vput(root);
 933                         goto done_free;
 934                 }
 935                 VOP_UNLOCK(root, 0);
 936                 if (fullpath_disabled) {
 937                         /* Leave room for a real-root full pathname. */
 938                         if (len + (path[0] == '/' && strcmp(mypr->pr_path, "/")
 939                             ? strlen(mypr->pr_path) : 0) > MAXPATHLEN) {
 940                                 error = ENAMETOOLONG;
 941                                 vrele(root);
 942                                 goto done_free;
 943                         }
 944                 }
 945         }
 946
 947         /*
 948          * Find the specified jail, or at least its parent.
 949          * This abuses the file error codes ENOENT and EEXIST.
 950          */
 951         pr = NULL;
 952         ppr = mypr;
 953         if (cuflags == JAIL_CREATE && jid == 0 && name != NULL) {
 954                 namelc = strrchr(name, '.');
 955                 jid = strtoul(namelc != NULL ? namelc + 1 : name, &p, 10);
 956                 if (*p != '\0')
 957                         jid = 0;
 958         }
 959         sx_xlock(&allprison_lock);
 960         if (jid != 0) {
 961                 /*
 962                  * See if a requested jid already exists.  There is an
 963                  * information leak here if the jid exists but is not within
 964                  * the caller's jail hierarchy.  Jail creators will get EEXIST
 965                  * even though they cannot see the jail, and CREATE | UPDATE
 966                  * will return ENOENT which is not normally a valid error.
 967                  */
 968                 if (jid < 0) {
 969                         error = EINVAL;
 970                         vfs_opterror(opts, "negative jid");
 971                         goto done_unlock_list;
 972                 }
 973                 pr = prison_find(jid);
 974                 if (pr != NULL) {
 975                         ppr = pr->pr_parent;
 976                         /* Create: jid must not exist. */
 977                         if (cuflags == JAIL_CREATE) {
 978                                 mtx_unlock(&pr->pr_mtx);
 979                                 error = EEXIST;
 980                                 vfs_opterror(opts, "jail %d already exists",
 981                                     jid);
 982                                 goto done_unlock_list;
 983                         }
 984                         if (!prison_ischild(mypr, pr)) {
 985                                 mtx_unlock(&pr->pr_mtx);
 986                                 pr = NULL;
 987                         } else if (pr->pr_uref == 0) {
 988                                 if (!(flags & JAIL_DYING)) {
 989                                         mtx_unlock(&pr->pr_mtx);
 990                                         error = ENOENT;
 991                                         vfs_opterror(opts, "jail %d is dying",
 992                                             jid);
 993                                         goto done_unlock_list;
 994                                 } else if ((flags & JAIL_ATTACH) ||
 995                                     (pr_flags & PR_PERSIST)) {
 996                                         /*
 997                                          * A dying jail might be resurrected
 998                                          * (via attach or persist), but first
 999                                          * it must determine if another jail
1000                                          * has claimed its name.  Accomplish
1001                                          * this by implicitly re-setting the
1002                                          * name.
1003                                          */
1004                                         if (name == NULL)
1005                                                 name = prison_name(mypr, pr);
1006                                 }
1007                         }
1008                 }
1009                 if (pr == NULL) {
1010                         /* Update: jid must exist. */
1011                         if (cuflags == JAIL_UPDATE) {
1012                                 error = ENOENT;
1013                                 vfs_opterror(opts, "jail %d not found", jid);
1014                                 goto done_unlock_list;
1015                         }
1016                 }
1017         }
1018         /*
1019          * If the caller provided a name, look for a jail by that name.
1020          * This has different semantics for creates and updates keyed by jid
1021          * (where the name must not already exist in a different jail),
1022          * and updates keyed by the name itself (where the name must exist
1023          * because that is the jail being updated).
1024          */
1025         namelc = NULL;
1026         if (name != NULL) {
1027                 namelc = strrchr(name, '.');
1028                 if (namelc == NULL)
1029                         namelc = name;
1030                 else {
1031                         /*
1032                          * This is a hierarchical name.  Split it into the
1033                          * parent and child names, and make sure the parent
1034                          * exists or matches an already found jail.
1035                          */
1036                         if (pr != NULL) {
1037                                 if (strncmp(name, ppr->pr_name, namelc - name)
1038                                     || ppr->pr_name[namelc - name] != '\0') {
1039                                         mtx_unlock(&pr->pr_mtx);
1040                                         error = EINVAL;
1041                                         vfs_opterror(opts,
1042                                             "cannot change jail's parent");
1043                                         goto done_unlock_list;
1044                                 }
1045                         } else {
1046                                 *namelc = '\0';
1047                                 ppr = prison_find_name(mypr, name);
1048                                 if (ppr == NULL) {
1049                                         error = ENOENT;
1050                                         vfs_opterror(opts,
1051                                             "jail \"%s\" not found", name);
1052                                         goto done_unlock_list;
1053                                 }
1054                                 mtx_unlock(&ppr->pr_mtx);
1055                                 *namelc = '.';
1056                         }
1057                         namelc++;
1058                 }
1059                 if (namelc[0] != '\0') {
1060                         pnamelen =
1061                             (ppr == &prison0) ? 0 : strlen(ppr->pr_name) + 1;
1062  name_again:
1063                         deadpr = NULL;
1064                         FOREACH_PRISON_CHILD(ppr, tpr) {
1065                                 if (tpr != pr && tpr->pr_ref > 0 &&
1066                                     !strcmp(tpr->pr_name + pnamelen, namelc)) {
1067                                         if (pr == NULL &&
1068                                             cuflags != JAIL_CREATE) {
1069                                                 mtx_lock(&tpr->pr_mtx);
1070                                                 if (tpr->pr_ref > 0) {
1071                                                         /*
1072                                                          * Use this jail
1073                                                          * for updates.
1074                                                          */
1075                                                         if (tpr->pr_uref > 0) {
1076                                                                 pr = tpr;
1077                                                                 break;
1078                                                         }
1079                                                         deadpr = tpr;
1080                                                 }
1081                                                 mtx_unlock(&tpr->pr_mtx);
1082                                         } else if (tpr->pr_uref > 0) {
1083                                                 /*
1084                                                  * Create, or update(jid):
1085                                                  * name must not exist in an
1086                                                  * active sibling jail.
1087                                                  */
1088                                                 error = EEXIST;
1089                                                 if (pr != NULL)
1090                                                         mtx_unlock(&pr->pr_mtx);
1091                                                 vfs_opterror(opts,
1092                                                    "jail \"%s\" already exists",
1093                                                    name);
1094                                                 goto done_unlock_list;
1095                                         }
1096                                 }
1097                         }
1098                         /* If no active jail is found, use a dying one. */
1099                         if (deadpr != NULL && pr == NULL) {
1100                                 if (flags & JAIL_DYING) {
1101                                         mtx_lock(&deadpr->pr_mtx);
1102                                         if (deadpr->pr_ref == 0) {
1103                                                 mtx_unlock(&deadpr->pr_mtx);
1104                                                 goto name_again;
1105                                         }
1106                                         pr = deadpr;
1107                                 } else if (cuflags == JAIL_UPDATE) {
1108                                         error = ENOENT;
1109                                         vfs_opterror(opts,
1110                                             "jail \"%s\" is dying", name);
1111                                         goto done_unlock_list;
1112                                 }
1113                         }
1114                         /* Update: name must exist if no jid. */
1115                         else if (cuflags == JAIL_UPDATE && pr == NULL) {
1116                                 error = ENOENT;
1117                                 vfs_opterror(opts, "jail \"%s\" not found",
1118                                     name);
1119                                 goto done_unlock_list;
1120                         }
1121                 }
1122         }
1123         /* Update: must provide a jid or name. */
1124         else if (cuflags == JAIL_UPDATE && pr == NULL) {
1125                 error = ENOENT;
1126                 vfs_opterror(opts, "update specified no jail");
1127                 goto done_unlock_list;
1128         }
1129
1130         /* If there's no prison to update, create a new one and link it in. */
1131         if (pr == NULL) {
1132                 for (tpr = mypr; tpr != NULL; tpr = tpr->pr_parent)
1133                         if (tpr->pr_childcount >= tpr->pr_childmax) {
1134                                 error = EPERM;
1135                                 vfs_opterror(opts, "prison limit exceeded");
1136                                 goto done_unlock_list;
1137                         }
1138                 created = 1;
1139                 mtx_lock(&ppr->pr_mtx);
1140                 if (ppr->pr_ref == 0) {
1141                         mtx_unlock(&ppr->pr_mtx);
1142                         error = ENOENT;
1143                         vfs_opterror(opts, "jail \"%s\" not found",
1144                             prison_name(mypr, ppr));
1145                         goto done_unlock_list;
1146                 }
1147                 ppr->pr_ref++;
1148                 ppr->pr_uref++;
1149                 mtx_unlock(&ppr->pr_mtx);
1150                 pr = malloc(sizeof(*pr), M_PRISON, M_WAITOK | M_ZERO);
1151                 if (jid == 0) {
1152                         /* Find the next free jid. */
1153                         jid = lastprid + 1;
1154  findnext:
1155                         if (jid == JAIL_MAX)
1156                                 jid = 1;
1157                         TAILQ_FOREACH(tpr, &allprison, pr_list) {
1158                                 if (tpr->pr_id < jid)
1159                                         continue;
1160                                 if (tpr->pr_id > jid || tpr->pr_ref == 0) {
1161                                         TAILQ_INSERT_BEFORE(tpr, pr, pr_list);
1162                                         break;
1163                                 }
1164                                 if (jid == lastprid) {
1165                                         error = EAGAIN;
1166                                         vfs_opterror(opts,
1167                                             "no available jail IDs");
1168                                         free(pr, M_PRISON);
1169                                         prison_deref(ppr, PD_DEREF |
1170                                             PD_DEUREF | PD_LIST_XLOCKED);
1171                                         goto done_releroot;
1172                                 }
1173                                 jid++;
1174                                 goto findnext;
1175                         }
1176                         lastprid = jid;
1177                 } else {
1178                         /*
1179                          * The jail already has a jid (that did not yet exist),
1180                          * so just find where to insert it.
1181                          */
1182                         TAILQ_FOREACH(tpr, &allprison, pr_list)
1183                                 if (tpr->pr_id >= jid) {
1184                                         TAILQ_INSERT_BEFORE(tpr, pr, pr_list);
1185                                         break;
1186                                 }
1187                 }
1188                 if (tpr == NULL)
1189                         TAILQ_INSERT_TAIL(&allprison, pr, pr_list);
1190                 LIST_INSERT_HEAD(&ppr->pr_children, pr, pr_sibling);
1191                 for (tpr = ppr; tpr != NULL; tpr = tpr->pr_parent)
1192                         tpr->pr_childcount++;
1193
1194                 pr->pr_parent = ppr;
1195                 pr->pr_id = jid;
1196
1197                 /* Set some default values, and inherit some from the parent. */
1198                 if (namelc == NULL)
1199                         namelc = "";
1200                 if (path == NULL) {
1201                         path = "/";
1202                         root = mypr->pr_root;
1203                         vref(root);
1204                 }
1205                 strlcpy(pr->pr_hostuuid, DEFAULT_HOSTUUID, HOSTUUIDLEN);
1206                 pr->pr_flags |= PR_HOST;
1207 #if defined(INET) || defined(INET6)
1208 #ifdef VIMAGE
1209                 if (!(pr_flags & PR_VNET))
1210 #endif
1211                 {
1212 #ifdef INET
1213                         if (!(ch_flags & PR_IP4_USER))
1214                                 pr->pr_flags |= PR_IP4 | PR_IP4_USER;
1215                         else if (!(pr_flags & PR_IP4_USER)) {
1216                                 pr->pr_flags |= ppr->pr_flags & PR_IP4;
1217                                 if (ppr->pr_ip4 != NULL) {
1218                                         pr->pr_ip4s = ppr->pr_ip4s;
1219                                         pr->pr_ip4 = malloc(pr->pr_ip4s *
1220                                             sizeof(struct in_addr), M_PRISON,
1221                                             M_WAITOK);
1222                                         bcopy(ppr->pr_ip4, pr->pr_ip4,
1223                                             pr->pr_ip4s * sizeof(*pr->pr_ip4));
1224                                 }
1225                         }
1226 #endif
1227 #ifdef INET6
1228                         if (!(ch_flags & PR_IP6_USER))
1229                                 pr->pr_flags |= PR_IP6 | PR_IP6_USER;
1230                         else if (!(pr_flags & PR_IP6_USER)) {
1231                                 pr->pr_flags |= ppr->pr_flags & PR_IP6;
1232                                 if (ppr->pr_ip6 != NULL) {
1233                                         pr->pr_ip6s = ppr->pr_ip6s;
1234                                         pr->pr_ip6 = malloc(pr->pr_ip6s *
1235                                             sizeof(struct in6_addr), M_PRISON,
1236                                             M_WAITOK);
1237                                         bcopy(ppr->pr_ip6, pr->pr_ip6,
1238                                             pr->pr_ip6s * sizeof(*pr->pr_ip6));
1239                                 }
1240                         }
1241 #endif
1242                 }
1243 #endif
1244                 /* Source address selection is always on by default. */
1245                 pr->pr_flags |= _PR_IP_SADDRSEL;
1246
1247                 pr->pr_securelevel = ppr->pr_securelevel;
1248                 pr->pr_allow = JAIL_DEFAULT_ALLOW & ppr->pr_allow;
1249                 pr->pr_enforce_statfs = jail_default_enforce_statfs;
1250                 pr->pr_devfs_rsnum = ppr->pr_devfs_rsnum;
1251
1252                 pr->pr_osreldate = osreldt ? osreldt : ppr->pr_osreldate;
1253                 if (osrelstr == NULL)
1254                     strcpy(pr->pr_osrelease, ppr->pr_osrelease);
1255                 else
1256                     strcpy(pr->pr_osrelease, osrelstr);
1257
1258                 LIST_INIT(&pr->pr_children);
1259                 mtx_init(&pr->pr_mtx, "jail mutex", NULL, MTX_DEF | MTX_DUPOK);
1260                 TASK_INIT(&pr->pr_task, 0, prison_complete, pr);
1261
1262 #ifdef VIMAGE
1263                 /* Allocate a new vnet if specified. */
1264                 pr->pr_vnet = (pr_flags & PR_VNET)
1265                     ? vnet_alloc() : ppr->pr_vnet;
1266 #endif
1267                 /*
1268                  * Allocate a dedicated cpuset for each jail.
1269                  * Unlike other initial settings, this may return an erorr.
1270                  */
1271                 error = cpuset_create_root(ppr, &pr->pr_cpuset);
1272                 if (error) {
1273                         prison_deref(pr, PD_LIST_XLOCKED);
1274                         goto done_releroot;
1275                 }
1276
1277                 mtx_lock(&pr->pr_mtx);
1278                 /*
1279                  * New prisons do not yet have a reference, because we do not
1280                  * want others to see the incomplete prison once the
1281                  * allprison_lock is downgraded.
1282                  */
1283         } else {
1284                 created = 0;
1285                 /*
1286                  * Grab a reference for existing prisons, to ensure they
1287                  * continue to exist for the duration of the call.
1288                  */
1289                 pr->pr_ref++;
1290 #if defined(VIMAGE) && (defined(INET) || defined(INET6))
1291                 if ((pr->pr_flags & PR_VNET) &&
1292                     (ch_flags & (PR_IP4_USER | PR_IP6_USER))) {
1293                         error = EINVAL;
1294                         vfs_opterror(opts,
1295                             "vnet jails cannot have IP address restrictions");
1296                         goto done_deref_locked;
1297                 }
1298 #endif
1299 #ifdef INET
1300                 if (PR_IP4_USER & ch_flags & (pr_flags ^ pr->pr_flags)) {
1301                         error = EINVAL;
1302                         vfs_opterror(opts,
1303                             "ip4 cannot be changed after creation");
1304                         goto done_deref_locked;
1305                 }
1306 #endif
1307 #ifdef INET6
1308                 if (PR_IP6_USER & ch_flags & (pr_flags ^ pr->pr_flags)) {
1309                         error = EINVAL;
1310                         vfs_opterror(opts,
1311                             "ip6 cannot be changed after creation");
1312                         goto done_deref_locked;
1313                 }
1314 #endif
1315         }
1316
1317         /* Do final error checking before setting anything. */
1318         if (gotslevel) {
1319                 if (slevel < ppr->pr_securelevel) {
1320                         error = EPERM;
1321                         goto done_deref_locked;
1322                 }
1323         }
1324         if (gotchildmax) {
1325                 if (childmax >= ppr->pr_childmax) {
1326                         error = EPERM;
1327                         goto done_deref_locked;
1328                 }
1329         }
1330         if (gotenforce) {
1331                 if (enforce < ppr->pr_enforce_statfs) {
1332                         error = EPERM;
1333                         goto done_deref_locked;
1334                 }
1335         }
1336         if (gotrsnum) {
1337                 /*
1338                  * devfs_rsnum is a uint16_t
1339                  */
1340                 if (rsnum < 0 || rsnum > 65535) {
1341                         error = EINVAL;
1342                         goto done_deref_locked;
1343                 }
1344                 /*
1345                  * Nested jails always inherit parent's devfs ruleset
1346                  */
1347                 if (jailed(td->td_ucred)) {
1348                         if (rsnum > 0 && rsnum != ppr->pr_devfs_rsnum) {
1349                                 error = EPERM;
1350                                 goto done_deref_locked;
1351                         } else
1352                                 rsnum = ppr->pr_devfs_rsnum;
1353                 }
1354         }
1355 #ifdef INET
1356         if (ip4s > 0) {
1357                 if (ppr->pr_flags & PR_IP4) {
1358                         /*
1359                          * Make sure the new set of IP addresses is a
1360                          * subset of the parent's list.  Don't worry
1361                          * about the parent being unlocked, as any
1362                          * setting is done with allprison_lock held.
1363                          */
1364                         for (ij = 0; ij < ppr->pr_ip4s; ij++)
1365                                 if (ip4[0].s_addr == ppr->pr_ip4[ij].s_addr)
1366                                         break;
1367                         if (ij == ppr->pr_ip4s) {
1368                                 error = EPERM;
1369                                 goto done_deref_locked;
1370                         }
1371                         if (ip4s > 1) {
1372                                 for (ii = ij = 1; ii < ip4s; ii++) {
1373                                         if (ip4[ii].s_addr ==
1374                                             ppr->pr_ip4[0].s_addr)
1375                                                 continue;
1376                                         for (; ij < ppr->pr_ip4s; ij++)
1377                                                 if (ip4[ii].s_addr ==
1378                                                     ppr->pr_ip4[ij].s_addr)
1379                                                         break;
1380                                         if (ij == ppr->pr_ip4s)
1381                                                 break;
1382                                 }
1383                                 if (ij == ppr->pr_ip4s) {
1384                                         error = EPERM;
1385                                         goto done_deref_locked;
1386                                 }
1387                         }
1388                 }
1389                 /*
1390                  * Check for conflicting IP addresses.  We permit them
1391                  * if there is no more than one IP on each jail.  If
1392                  * there is a duplicate on a jail with more than one
1393                  * IP stop checking and return error.
1394                  */
1395                 tppr = ppr;
1396 #ifdef VIMAGE
1397                 for (; tppr != &prison0; tppr = tppr->pr_parent)
1398                         if (tppr->pr_flags & PR_VNET)
1399                                 break;
1400 #endif
1401                 FOREACH_PRISON_DESCENDANT(tppr, tpr, descend) {
1402                         if (tpr == pr ||
1403 #ifdef VIMAGE
1404                             (tpr != tppr && (tpr->pr_flags & PR_VNET)) ||
1405 #endif
1406                             tpr->pr_uref == 0) {
1407                                 descend = 0;
1408                                 continue;
1409                         }
1410                         if (!(tpr->pr_flags & PR_IP4_USER))
1411                                 continue;
1412                         descend = 0;
1413                         if (tpr->pr_ip4 == NULL ||
1414                             (ip4s == 1 && tpr->pr_ip4s == 1))
1415                                 continue;
1416                         for (ii = 0; ii < ip4s; ii++) {
1417                                 if (prison_check_ip4_locked(tpr, &ip4[ii]) ==
1418                                     0) {
1419                                         error = EADDRINUSE;
1420                                         vfs_opterror(opts,
1421                                             "IPv4 addresses clash");
1422                                         goto done_deref_locked;
1423                                 }
1424                         }
1425                 }
1426         }
1427 #endif
1428 #ifdef INET6
1429         if (ip6s > 0) {
1430                 if (ppr->pr_flags & PR_IP6) {
1431                         /*
1432                          * Make sure the new set of IP addresses is a
1433                          * subset of the parent's list.
1434                          */
1435                         for (ij = 0; ij < ppr->pr_ip6s; ij++)
1436                                 if (IN6_ARE_ADDR_EQUAL(&ip6[0],
1437                                     &ppr->pr_ip6[ij]))
1438                                         break;
1439                         if (ij == ppr->pr_ip6s) {
1440                                 error = EPERM;
1441                                 goto done_deref_locked;
1442                         }
1443                         if (ip6s > 1) {
1444                                 for (ii = ij = 1; ii < ip6s; ii++) {
1445                                         if (IN6_ARE_ADDR_EQUAL(&ip6[ii],
1446                                              &ppr->pr_ip6[0]))
1447                                                 continue;
1448                                         for (; ij < ppr->pr_ip6s; ij++)
1449                                                 if (IN6_ARE_ADDR_EQUAL(
1450                                                     &ip6[ii], &ppr->pr_ip6[ij]))
1451                                                         break;
1452                                         if (ij == ppr->pr_ip6s)
1453                                                 break;
1454                                 }
1455                                 if (ij == ppr->pr_ip6s) {
1456                                         error = EPERM;
1457                                         goto done_deref_locked;
1458                                 }
1459                         }
1460                 }
1461                 /* Check for conflicting IP addresses. */
1462                 tppr = ppr;
1463 #ifdef VIMAGE
1464                 for (; tppr != &prison0; tppr = tppr->pr_parent)
1465                         if (tppr->pr_flags & PR_VNET)
1466                                 break;
1467 #endif
1468                 FOREACH_PRISON_DESCENDANT(tppr, tpr, descend) {
1469                         if (tpr == pr ||
1470 #ifdef VIMAGE
1471                             (tpr != tppr && (tpr->pr_flags & PR_VNET)) ||
1472 #endif
1473                             tpr->pr_uref == 0) {
1474                                 descend = 0;
1475                                 continue;
1476                         }
1477                         if (!(tpr->pr_flags & PR_IP6_USER))
1478                                 continue;
1479                         descend = 0;
1480                         if (tpr->pr_ip6 == NULL ||
1481                             (ip6s == 1 && tpr->pr_ip6s == 1))
1482                                 continue;
1483                         for (ii = 0; ii < ip6s; ii++) {
1484                                 if (prison_check_ip6_locked(tpr, &ip6[ii]) ==
1485                                     0) {
1486                                         error = EADDRINUSE;
1487                                         vfs_opterror(opts,
1488                                             "IPv6 addresses clash");
1489                                         goto done_deref_locked;
1490                                 }
1491                         }
1492                 }
1493         }
1494 #endif
1495         onamelen = namelen = 0;
1496         if (namelc != NULL) {
1497                 /* Give a default name of the jid.  Also allow the name to be
1498                  * explicitly the jid - but not any other number, and only in
1499                  * normal form (no leading zero/etc).
1500                  */
1501                 if (namelc[0] == '\0')
1502                         snprintf(namelc = numbuf, sizeof(numbuf), "%d", jid);
1503                 else if ((strtoul(namelc, &p, 10) != jid ||
1504                           namelc[0] < '1' || namelc[0] > '9') && *p == '\0') {
1505                         error = EINVAL;
1506                         vfs_opterror(opts,
1507                             "name cannot be numeric (unless it is the jid)");
1508                         goto done_deref_locked;
1509                 }
1510                 /*
1511                  * Make sure the name isn't too long for the prison or its
1512                  * children.
1513                  */
1514                 pnamelen = (ppr == &prison0) ? 0 : strlen(ppr->pr_name) + 1;
1515                 onamelen = strlen(pr->pr_name + pnamelen);
1516                 namelen = strlen(namelc);
1517                 if (pnamelen + namelen + 1 > sizeof(pr->pr_name)) {
1518                         error = ENAMETOOLONG;
1519                         goto done_deref_locked;
1520                 }
1521                 FOREACH_PRISON_DESCENDANT(pr, tpr, descend) {
1522                         if (strlen(tpr->pr_name) + (namelen - onamelen) >=
1523                             sizeof(pr->pr_name)) {
1524                                 error = ENAMETOOLONG;
1525                                 goto done_deref_locked;
1526                         }
1527                 }
1528         }
1529         if (pr_allow & ~ppr->pr_allow) {
1530                 error = EPERM;
1531                 goto done_deref_locked;
1532         }
1533
1534         /*
1535          * Let modules check their parameters.  This requires unlocking and
1536          * then re-locking the prison, but this is still a valid state as long
1537          * as allprison_lock remains xlocked.
1538          */
1539         mtx_unlock(&pr->pr_mtx);
1540         error = osd_jail_call(pr, PR_METHOD_CHECK, opts);
1541         if (error != 0) {
1542                 prison_deref(pr, created
1543                     ? PD_LIST_XLOCKED
1544                     : PD_DEREF | PD_LIST_XLOCKED);
1545                 goto done_releroot;
1546         }
1547         mtx_lock(&pr->pr_mtx);
1548
1549         /* At this point, all valid parameters should have been noted. */
1550         TAILQ_FOREACH(opt, opts, link) {
1551                 if (!opt->seen && strcmp(opt->name, "errmsg")) {
1552                         error = EINVAL;
1553                         vfs_opterror(opts, "unknown parameter: %s", opt->name);
1554                         goto done_deref_locked;
1555                 }
1556         }
1557
1558         /* Set the parameters of the prison. */
1559 #ifdef INET
1560         redo_ip4 = 0;
1561         if (pr_flags & PR_IP4_USER) {
1562                 pr->pr_flags |= PR_IP4;
1563                 free(pr->pr_ip4, M_PRISON);
1564                 pr->pr_ip4s = ip4s;
1565                 pr->pr_ip4 = ip4;
1566                 ip4 = NULL;
1567                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1568 #ifdef VIMAGE
1569                         if (tpr->pr_flags & PR_VNET) {
1570                                 descend = 0;
1571                                 continue;
1572                         }
1573 #endif
1574                         if (prison_restrict_ip4(tpr, NULL)) {
1575                                 redo_ip4 = 1;
1576                                 descend = 0;
1577                         }
1578                 }
1579         }
1580 #endif
1581 #ifdef INET6
1582         redo_ip6 = 0;
1583         if (pr_flags & PR_IP6_USER) {
1584                 pr->pr_flags |= PR_IP6;
1585                 free(pr->pr_ip6, M_PRISON);
1586                 pr->pr_ip6s = ip6s;
1587                 pr->pr_ip6 = ip6;
1588                 ip6 = NULL;
1589                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1590 #ifdef VIMAGE
1591                         if (tpr->pr_flags & PR_VNET) {
1592                                 descend = 0;
1593                                 continue;
1594                         }
1595 #endif
1596                         if (prison_restrict_ip6(tpr, NULL)) {
1597                                 redo_ip6 = 1;
1598                                 descend = 0;
1599                         }
1600                 }
1601         }
1602 #endif
1603         if (gotslevel) {
1604                 pr->pr_securelevel = slevel;
1605                 /* Set all child jails to be at least this level. */
1606                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend)
1607                         if (tpr->pr_securelevel < slevel)
1608                                 tpr->pr_securelevel = slevel;
1609         }
1610         if (gotchildmax) {
1611                 pr->pr_childmax = childmax;
1612                 /* Set all child jails to under this limit. */
1613                 FOREACH_PRISON_DESCENDANT_LOCKED_LEVEL(pr, tpr, descend, level)
1614                         if (tpr->pr_childmax > childmax - level)
1615                                 tpr->pr_childmax = childmax > level
1616                                     ? childmax - level : 0;
1617         }
1618         if (gotenforce) {
1619                 pr->pr_enforce_statfs = enforce;
1620                 /* Pass this restriction on to the children. */
1621                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend)
1622                         if (tpr->pr_enforce_statfs < enforce)
1623                                 tpr->pr_enforce_statfs = enforce;
1624         }
1625         if (gotrsnum) {
1626                 pr->pr_devfs_rsnum = rsnum;
1627                 /* Pass this restriction on to the children. */
1628                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend)
1629                         tpr->pr_devfs_rsnum = rsnum;
1630         }
1631         if (namelc != NULL) {
1632                 if (ppr == &prison0)
1633                         strlcpy(pr->pr_name, namelc, sizeof(pr->pr_name));
1634                 else
1635                         snprintf(pr->pr_name, sizeof(pr->pr_name), "%s.%s",
1636                             ppr->pr_name, namelc);
1637                 /* Change this component of child names. */
1638                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1639                         bcopy(tpr->pr_name + onamelen, tpr->pr_name + namelen,
1640                             strlen(tpr->pr_name + onamelen) + 1);
1641                         bcopy(pr->pr_name, tpr->pr_name, namelen);
1642                 }
1643         }
1644         if (path != NULL) {
1645                 /* Try to keep a real-rooted full pathname. */
1646                 if (fullpath_disabled && path[0] == '/' &&
1647                     strcmp(mypr->pr_path, "/"))
1648                         snprintf(pr->pr_path, sizeof(pr->pr_path), "%s%s",
1649                             mypr->pr_path, path);
1650                 else
1651                         strlcpy(pr->pr_path, path, sizeof(pr->pr_path));
1652                 pr->pr_root = root;
1653         }
1654         if (PR_HOST & ch_flags & ~pr_flags) {
1655                 if (pr->pr_flags & PR_HOST) {
1656                         /*
1657                          * Copy the parent's host info.  As with pr_ip4 above,
1658                          * the lack of a lock on the parent is not a problem;
1659                          * it is always set with allprison_lock at least
1660                          * shared, and is held exclusively here.
1661                          */
1662                         strlcpy(pr->pr_hostname, pr->pr_parent->pr_hostname,
1663                             sizeof(pr->pr_hostname));
1664                         strlcpy(pr->pr_domainname, pr->pr_parent->pr_domainname,
1665                             sizeof(pr->pr_domainname));
1666                         strlcpy(pr->pr_hostuuid, pr->pr_parent->pr_hostuuid,
1667                             sizeof(pr->pr_hostuuid));
1668                         pr->pr_hostid = pr->pr_parent->pr_hostid;
1669                 }
1670         } else if (host != NULL || domain != NULL || uuid != NULL || gothid) {
1671                 /* Set this prison, and any descendants without PR_HOST. */
1672                 if (host != NULL)
1673                         strlcpy(pr->pr_hostname, host, sizeof(pr->pr_hostname));
1674                 if (domain != NULL)
1675                         strlcpy(pr->pr_domainname, domain,
1676                             sizeof(pr->pr_domainname));
1677                 if (uuid != NULL)
1678                         strlcpy(pr->pr_hostuuid, uuid, sizeof(pr->pr_hostuuid));
1679                 if (gothid)
1680                         pr->pr_hostid = hid;
1681                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1682                         if (tpr->pr_flags & PR_HOST)
1683                                 descend = 0;
1684                         else {
1685                                 if (host != NULL)
1686                                         strlcpy(tpr->pr_hostname,
1687                                             pr->pr_hostname,
1688                                             sizeof(tpr->pr_hostname));
1689                                 if (domain != NULL)
1690                                         strlcpy(tpr->pr_domainname,
1691                                             pr->pr_domainname,
1692                                             sizeof(tpr->pr_domainname));
1693                                 if (uuid != NULL)
1694                                         strlcpy(tpr->pr_hostuuid,
1695                                             pr->pr_hostuuid,
1696                                             sizeof(tpr->pr_hostuuid));
1697                                 if (gothid)
1698                                         tpr->pr_hostid = hid;
1699                         }
1700                 }
1701         }
1702         if ((tallow = ch_allow & ~pr_allow)) {
1703                 /* Clear allow bits in all children. */
1704                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend)
1705                         tpr->pr_allow &= ~tallow;
1706         }
1707         pr->pr_allow = (pr->pr_allow & ~ch_allow) | pr_allow;
1708         /*
1709          * Persistent prisons get an extra reference, and prisons losing their
1710          * persist flag lose that reference.  Only do this for existing prisons
1711          * for now, so new ones will remain unseen until after the module
1712          * handlers have completed.
1713          */
1714         born = pr->pr_uref == 0;
1715         if (!created && (ch_flags & PR_PERSIST & (pr_flags ^ pr->pr_flags))) {
1716                 if (pr_flags & PR_PERSIST) {
1717                         pr->pr_ref++;
1718                         pr->pr_uref++;
1719                 } else {
1720                         pr->pr_ref--;
1721                         pr->pr_uref--;
1722                 }
1723         }
1724         pr->pr_flags = (pr->pr_flags & ~ch_flags) | pr_flags;
1725         mtx_unlock(&pr->pr_mtx);
1726
1727 #ifdef RACCT
1728         if (racct_enable && created)
1729                 prison_racct_attach(pr);
1730 #endif
1731
1732         /* Locks may have prevented a complete restriction of child IP
1733          * addresses.  If so, allocate some more memory and try again.
1734          */
1735 #ifdef INET
1736         while (redo_ip4) {
1737                 ip4s = pr->pr_ip4s;
1738                 ip4 = malloc(ip4s * sizeof(*ip4), M_PRISON, M_WAITOK);
1739                 mtx_lock(&pr->pr_mtx);
1740                 redo_ip4 = 0;
1741                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1742 #ifdef VIMAGE
1743                         if (tpr->pr_flags & PR_VNET) {
1744                                 descend = 0;
1745                                 continue;
1746                         }
1747 #endif
1748                         if (prison_restrict_ip4(tpr, ip4)) {
1749                                 if (ip4 != NULL)
1750                                         ip4 = NULL;
1751                                 else
1752                                         redo_ip4 = 1;
1753                         }
1754                 }
1755                 mtx_unlock(&pr->pr_mtx);
1756         }
1757 #endif
1758 #ifdef INET6
1759         while (redo_ip6) {
1760                 ip6s = pr->pr_ip6s;
1761                 ip6 = malloc(ip6s * sizeof(*ip6), M_PRISON, M_WAITOK);
1762                 mtx_lock(&pr->pr_mtx);
1763                 redo_ip6 = 0;
1764                 FOREACH_PRISON_DESCENDANT_LOCKED(pr, tpr, descend) {
1765 #ifdef VIMAGE
1766                         if (tpr->pr_flags & PR_VNET) {
1767                                 descend = 0;
1768                                 continue;
1769                         }
1770 #endif
1771                         if (prison_restrict_ip6(tpr, ip6)) {
1772                                 if (ip6 != NULL)
1773                                         ip6 = NULL;
1774                                 else
1775                                         redo_ip6 = 1;
1776                         }
1777                 }
1778                 mtx_unlock(&pr->pr_mtx);
1779         }
1780 #endif
1781
1782         /* Let the modules do their work. */
1783         sx_downgrade(&allprison_lock);
1784         if (born) {
1785                 error = osd_jail_call(pr, PR_METHOD_CREATE, opts);
1786                 if (error) {
1787                         (void)osd_jail_call(pr, PR_METHOD_REMOVE, NULL);
1788                         prison_deref(pr, created
1789                             ? PD_LIST_SLOCKED
1790                             : PD_DEREF | PD_LIST_SLOCKED);
1791                         goto done_errmsg;
1792                 }
1793         }
1794         error = osd_jail_call(pr, PR_METHOD_SET, opts);
1795         if (error) {
1796                 if (born)
1797                         (void)osd_jail_call(pr, PR_METHOD_REMOVE, NULL);
1798                 prison_deref(pr, created
1799                     ? PD_LIST_SLOCKED
1800                     : PD_DEREF | PD_LIST_SLOCKED);
1801                 goto done_errmsg;
1802         }
1803
1804         /* Attach this process to the prison if requested. */
1805         if (flags & JAIL_ATTACH) {
1806                 mtx_lock(&pr->pr_mtx);
1807                 error = do_jail_attach(td, pr);
1808                 if (error) {
1809                         vfs_opterror(opts, "attach failed");
1810                         if (!created)
1811                                 prison_deref(pr, PD_DEREF);
1812                         goto done_errmsg;
1813                 }
1814         }
1815
1816 #ifdef RACCT
1817         if (racct_enable && !created) {
1818                 if (!(flags & JAIL_ATTACH))
1819                         sx_sunlock(&allprison_lock);
1820                 prison_racct_modify(pr);
1821                 if (!(flags & JAIL_ATTACH))
1822                         sx_slock(&allprison_lock);
1823         }
1824 #endif
1825
1826         td->td_retval[0] = pr->pr_id;
1827
1828         /*
1829          * Now that it is all there, drop the temporary reference from existing
1830          * prisons.  Or add a reference to newly created persistent prisons
1831          * (which was not done earlier so that the prison would not be publicly
1832          * visible).
1833          */
1834         if (!created) {
1835                 prison_deref(pr, (flags & JAIL_ATTACH)
1836                     ? PD_DEREF
1837                     : PD_DEREF | PD_LIST_SLOCKED);
1838         } else {
1839                 if (pr_flags & PR_PERSIST) {
1840                         mtx_lock(&pr->pr_mtx);
1841                         pr->pr_ref++;
1842                         pr->pr_uref++;
1843                         mtx_unlock(&pr->pr_mtx);
1844                 }
1845                 if (!(flags & JAIL_ATTACH))
1846                         sx_sunlock(&allprison_lock);
1847         }
1848
1849         goto done_free;
1850
1851  done_deref_locked:
1852         prison_deref(pr, created
1853             ? PD_LOCKED | PD_LIST_XLOCKED
1854             : PD_DEREF | PD_LOCKED | PD_LIST_XLOCKED);
1855         goto done_releroot;
1856  done_unlock_list:
1857         sx_xunlock(&allprison_lock);
1858  done_releroot:
1859         if (root != NULL)
1860                 vrele(root);
1861  done_errmsg:
1862         if (error) {
1863                 if (vfs_getopt(opts, "errmsg", (void **)&errmsg,
1864                     &errmsg_len) == 0 && errmsg_len > 0) {
1865                         errmsg_pos = 2 * vfs_getopt_pos(opts, "errmsg") + 1;
1866                         if (optuio->uio_segflg == UIO_SYSSPACE)
1867                                 bcopy(errmsg,
1868                                     optuio->uio_iov[errmsg_pos].iov_base,
1869                                     errmsg_len);
1870                         else
1871                                 copyout(errmsg,
1872                                     optuio->uio_iov[errmsg_pos].iov_base,
1873                                     errmsg_len);
1874                 }
1875         }
1876  done_free:
1877 #ifdef INET
1878         free(ip4, M_PRISON);
1879 #endif
1880 #ifdef INET6
1881         free(ip6, M_PRISON);
1882 #endif
1883         if (g_path != NULL)
1884                 free(g_path, M_TEMP);
1885         vfs_freeopts(opts);
1886         return (error);
1887 }
1888
1889
1890 /*
1891  * struct jail_get_args {
1892  *      struct iovec *iovp;
1893  *      unsigned int iovcnt;
1894  *      int flags;
1895  * };
1896  */
1897 int
1898 sys_jail_get(struct thread *td, struct jail_get_args *uap)
1899 {
1900         struct uio *auio;
1901         int error;
1902
1903         /* Check that we have an even number of iovecs. */
1904         if (uap->iovcnt & 1)
1905                 return (EINVAL);
1906
1907         error = copyinuio(uap->iovp, uap->iovcnt, &auio);
1908         if (error)
1909                 return (error);
1910         error = kern_jail_get(td, auio, uap->flags);
1911         if (error == 0)
1912                 error = copyout(auio->uio_iov, uap->iovp,
1913                     uap->iovcnt * sizeof (struct iovec));
1914         free(auio, M_IOV);
1915         return (error);
1916 }
1917
1918 int
1919 kern_jail_get(struct thread *td, struct uio *optuio, int flags)
1920 {
1921         struct bool_flags *bf;
1922         struct jailsys_flags *jsf;
1923         struct prison *pr, *mypr;
1924         struct vfsopt *opt;
1925         struct vfsoptlist *opts;
1926         char *errmsg, *name;
1927         int error, errmsg_len, errmsg_pos, i, jid, len, locked, pos;
1928         unsigned f;
1929
1930         if (flags & ~JAIL_GET_MASK)
1931                 return (EINVAL);
1932
1933         /* Get the parameter list. */
1934         error = vfs_buildopts(optuio, &opts);
1935         if (error)
1936                 return (error);
1937         errmsg_pos = vfs_getopt_pos(opts, "errmsg");
1938         mypr = td->td_ucred->cr_prison;
1939
1940         /*
1941          * Find the prison specified by one of: lastjid, jid, name.
1942          */
1943         sx_slock(&allprison_lock);
1944         error = vfs_copyopt(opts, "lastjid", &jid, sizeof(jid));
1945         if (error == 0) {
1946                 TAILQ_FOREACH(pr, &allprison, pr_list) {
1947                         if (pr->pr_id > jid && prison_ischild(mypr, pr)) {
1948                                 mtx_lock(&pr->pr_mtx);
1949                                 if (pr->pr_ref > 0 &&
1950                                     (pr->pr_uref > 0 || (flags & JAIL_DYING)))
1951                                         break;
1952                                 mtx_unlock(&pr->pr_mtx);
1953                         }
1954                 }
1955                 if (pr != NULL)
1956                         goto found_prison;
1957                 error = ENOENT;
1958                 vfs_opterror(opts, "no jail after %d", jid);
1959                 goto done_unlock_list;
1960         } else if (error != ENOENT)
1961                 goto done_unlock_list;
1962
1963         error = vfs_copyopt(opts, "jid", &jid, sizeof(jid));
1964         if (error == 0) {
1965                 if (jid != 0) {
1966                         pr = prison_find_child(mypr, jid);
1967                         if (pr != NULL) {
1968                                 if (pr->pr_uref == 0 && !(flags & JAIL_DYING)) {
1969                                         mtx_unlock(&pr->pr_mtx);
1970                                         error = ENOENT;
1971                                         vfs_opterror(opts, "jail %d is dying",
1972                                             jid);
1973                                         goto done_unlock_list;
1974                                 }
1975                                 goto found_prison;
1976                         }
1977                         error = ENOENT;
1978                         vfs_opterror(opts, "jail %d not found", jid);
1979                         goto done_unlock_list;
1980                 }
1981         } else if (error != ENOENT)
1982                 goto done_unlock_list;
1983
1984         error = vfs_getopt(opts, "name", (void **)&name, &len);
1985         if (error == 0) {
1986                 if (len == 0 || name[len - 1] != '\0') {
1987                         error = EINVAL;
1988                         goto done_unlock_list;
1989                 }
1990                 pr = prison_find_name(mypr, name);
1991                 if (pr != NULL) {
1992                         if (pr->pr_uref == 0 && !(flags & JAIL_DYING)) {
1993                                 mtx_unlock(&pr->pr_mtx);
1994                                 error = ENOENT;
1995                                 vfs_opterror(opts, "jail \"%s\" is dying",
1996                                     name);
1997                                 goto done_unlock_list;
1998                         }
1999                         goto found_prison;
2000                 }
2001                 error = ENOENT;
2002                 vfs_opterror(opts, "jail \"%s\" not found", name);
2003                 goto done_unlock_list;
2004         } else if (error != ENOENT)
2005                 goto done_unlock_list;
2006
2007         vfs_opterror(opts, "no jail specified");
2008         error = ENOENT;
2009         goto done_unlock_list;
2010
2011  found_prison:
2012         /* Get the parameters of the prison. */
2013         pr->pr_ref++;
2014         locked = PD_LOCKED;
2015         td->td_retval[0] = pr->pr_id;
2016         error = vfs_setopt(opts, "jid", &pr->pr_id, sizeof(pr->pr_id));
2017         if (error != 0 && error != ENOENT)
2018                 goto done_deref;
2019         i = (pr->pr_parent == mypr) ? 0 : pr->pr_parent->pr_id;
2020         error = vfs_setopt(opts, "parent", &i, sizeof(i));
2021         if (error != 0 && error != ENOENT)
2022                 goto done_deref;
2023         error = vfs_setopts(opts, "name", prison_name(mypr, pr));
2024         if (error != 0 && error != ENOENT)
2025                 goto done_deref;
2026         error = vfs_setopt(opts, "cpuset.id", &pr->pr_cpuset->cs_id,
2027             sizeof(pr->pr_cpuset->cs_id));
2028         if (error != 0 && error != ENOENT)
2029                 goto done_deref;
2030         error = vfs_setopts(opts, "path", prison_path(mypr, pr));
2031         if (error != 0 && error != ENOENT)
2032                 goto done_deref;
2033 #ifdef INET
2034         error = vfs_setopt_part(opts, "ip4.addr", pr->pr_ip4,
2035             pr->pr_ip4s * sizeof(*pr->pr_ip4));
2036         if (error != 0 && error != ENOENT)
2037                 goto done_deref;
2038 #endif
2039 #ifdef INET6
2040         error = vfs_setopt_part(opts, "ip6.addr", pr->pr_ip6,
2041             pr->pr_ip6s * sizeof(*pr->pr_ip6));
2042         if (error != 0 && error != ENOENT)
2043                 goto done_deref;
2044 #endif
2045         error = vfs_setopt(opts, "securelevel", &pr->pr_securelevel,
2046             sizeof(pr->pr_securelevel));
2047         if (error != 0 && error != ENOENT)
2048                 goto done_deref;
2049         error = vfs_setopt(opts, "children.cur", &pr->pr_childcount,
2050             sizeof(pr->pr_childcount));
2051         if (error != 0 && error != ENOENT)
2052                 goto done_deref;
2053         error = vfs_setopt(opts, "children.max", &pr->pr_childmax,
2054             sizeof(pr->pr_childmax));
2055         if (error != 0 && error != ENOENT)
2056                 goto done_deref;
2057         error = vfs_setopts(opts, "host.hostname", pr->pr_hostname);
2058         if (error != 0 && error != ENOENT)
2059                 goto done_deref;
2060         error = vfs_setopts(opts, "host.domainname", pr->pr_domainname);
2061         if (error != 0 && error != ENOENT)
2062                 goto done_deref;
2063         error = vfs_setopts(opts, "host.hostuuid", pr->pr_hostuuid);
2064         if (error != 0 && error != ENOENT)
2065                 goto done_deref;
2066 #ifdef COMPAT_FREEBSD32
2067         if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
2068                 uint32_t hid32 = pr->pr_hostid;
2069
2070                 error = vfs_setopt(opts, "host.hostid", &hid32, sizeof(hid32));
2071         } else
2072 #endif
2073         error = vfs_setopt(opts, "host.hostid", &pr->pr_hostid,
2074             sizeof(pr->pr_hostid));
2075         if (error != 0 && error != ENOENT)
2076                 goto done_deref;
2077         error = vfs_setopt(opts, "enforce_statfs", &pr->pr_enforce_statfs,
2078             sizeof(pr->pr_enforce_statfs));
2079         if (error != 0 && error != ENOENT)
2080                 goto done_deref;
2081         error = vfs_setopt(opts, "devfs_ruleset", &pr->pr_devfs_rsnum,
2082             sizeof(pr->pr_devfs_rsnum));
2083         if (error != 0 && error != ENOENT)
2084                 goto done_deref;
2085         for (bf = pr_flag_bool;
2086              bf < pr_flag_bool + nitems(pr_flag_bool);
2087              bf++) {
2088                 i = (pr->pr_flags & bf->flag) ? 1 : 0;
2089                 error = vfs_setopt(opts, bf->name, &i, sizeof(i));
2090                 if (error != 0 && error != ENOENT)
2091                         goto done_deref;
2092                 i = !i;
2093                 error = vfs_setopt(opts, bf->noname, &i, sizeof(i));
2094                 if (error != 0 && error != ENOENT)
2095                         goto done_deref;
2096         }
2097         for (jsf = pr_flag_jailsys;
2098              jsf < pr_flag_jailsys + nitems(pr_flag_jailsys);
2099              jsf++) {
2100                 f = pr->pr_flags & (jsf->disable | jsf->new);
2101                 i = (f != 0 && f == jsf->disable) ? JAIL_SYS_DISABLE
2102                     : (f == jsf->new) ? JAIL_SYS_NEW
2103                     : JAIL_SYS_INHERIT;
2104                 error = vfs_setopt(opts, jsf->name, &i, sizeof(i));
2105                 if (error != 0 && error != ENOENT)
2106                         goto done_deref;
2107         }
2108         for (bf = pr_flag_allow;
2109              bf < pr_flag_allow + nitems(pr_flag_allow) && bf->flag != 0;
2110              bf++) {
2111                 i = (pr->pr_allow & bf->flag) ? 1 : 0;
2112                 error = vfs_setopt(opts, bf->name, &i, sizeof(i));
2113                 if (error != 0 && error != ENOENT)
2114                         goto done_deref;
2115                 i = !i;
2116                 error = vfs_setopt(opts, bf->noname, &i, sizeof(i));
2117                 if (error != 0 && error != ENOENT)
2118                         goto done_deref;
2119         }
2120         i = (pr->pr_uref == 0);
2121         error = vfs_setopt(opts, "dying", &i, sizeof(i));
2122         if (error != 0 && error != ENOENT)
2123                 goto done_deref;
2124         i = !i;
2125         error = vfs_setopt(opts, "nodying", &i, sizeof(i));
2126         if (error != 0 && error != ENOENT)
2127                 goto done_deref;
2128         error = vfs_setopt(opts, "osreldate", &pr->pr_osreldate,
2129             sizeof(pr->pr_osreldate));
2130         if (error != 0 && error != ENOENT)
2131                 goto done_deref;
2132         error = vfs_setopts(opts, "osrelease", pr->pr_osrelease);
2133         if (error != 0 && error != ENOENT)
2134                 goto done_deref;
2135
2136         /* Get the module parameters. */
2137         mtx_unlock(&pr->pr_mtx);
2138         locked = 0;
2139         error = osd_jail_call(pr, PR_METHOD_GET, opts);
2140         if (error)
2141                 goto done_deref;
2142         prison_deref(pr, PD_DEREF | PD_LIST_SLOCKED);
2143
2144         /* By now, all parameters should have been noted. */
2145         TAILQ_FOREACH(opt, opts, link) {
2146                 if (!opt->seen && strcmp(opt->name, "errmsg")) {
2147                         error = EINVAL;
2148                         vfs_opterror(opts, "unknown parameter: %s", opt->name);
2149                         goto done_errmsg;
2150                 }
2151         }
2152
2153         /* Write the fetched parameters back to userspace. */
2154         error = 0;
2155         TAILQ_FOREACH(opt, opts, link) {
2156                 if (opt->pos >= 0 && opt->pos != errmsg_pos) {
2157                         pos = 2 * opt->pos + 1;
2158                         optuio->uio_iov[pos].iov_len = opt->len;
2159                         if (opt->value != NULL) {
2160                                 if (optuio->uio_segflg == UIO_SYSSPACE) {
2161                                         bcopy(opt->value,
2162                                             optuio->uio_iov[pos].iov_base,
2163                                             opt->len);
2164                                 } else {
2165                                         error = copyout(opt->value,
2166                                             optuio->uio_iov[pos].iov_base,
2167                                             opt->len);
2168                                         if (error)
2169                                                 break;
2170                                 }
2171                         }
2172                 }
2173         }
2174         goto done_errmsg;
2175
2176  done_deref:
2177         prison_deref(pr, locked | PD_DEREF | PD_LIST_SLOCKED);
2178         goto done_errmsg;
2179
2180  done_unlock_list:
2181         sx_sunlock(&allprison_lock);
2182  done_errmsg:
2183         if (error && errmsg_pos >= 0) {
2184                 vfs_getopt(opts, "errmsg", (void **)&errmsg, &errmsg_len);
2185                 errmsg_pos = 2 * errmsg_pos + 1;
2186                 if (errmsg_len > 0) {
2187                         if (optuio->uio_segflg == UIO_SYSSPACE)
2188                                 bcopy(errmsg,
2189                                     optuio->uio_iov[errmsg_pos].iov_base,
2190                                     errmsg_len);
2191                         else
2192                                 copyout(errmsg,
2193                                     optuio->uio_iov[errmsg_pos].iov_base,
2194                                     errmsg_len);
2195                 }
2196         }
2197         vfs_freeopts(opts);
2198         return (error);
2199 }
2200
2201
2202 /*
2203  * struct jail_remove_args {
2204  *      int jid;
2205  * };
2206  */
2207 int
2208 sys_jail_remove(struct thread *td, struct jail_remove_args *uap)
2209 {
2210         struct prison *pr, *cpr, *lpr, *tpr;
2211         int descend, error;
2212
2213         error = priv_check(td, PRIV_JAIL_REMOVE);
2214         if (error)
2215                 return (error);
2216
2217         sx_xlock(&allprison_lock);
2218         pr = prison_find_child(td->td_ucred->cr_prison, uap->jid);
2219         if (pr == NULL) {
2220                 sx_xunlock(&allprison_lock);
2221                 return (EINVAL);
2222         }
2223
2224         /* Remove all descendants of this prison, then remove this prison. */
2225         pr->pr_ref++;
2226         if (!LIST_EMPTY(&pr->pr_children)) {
2227                 mtx_unlock(&pr->pr_mtx);
2228                 lpr = NULL;
2229                 FOREACH_PRISON_DESCENDANT(pr, cpr, descend) {
2230                         mtx_lock(&cpr->pr_mtx);
2231                         if (cpr->pr_ref > 0) {
2232                                 tpr = cpr;
2233                                 cpr->pr_ref++;
2234                         } else {
2235                                 /* Already removed - do not do it again. */
2236                                 tpr = NULL;
2237                         }
2238                         mtx_unlock(&cpr->pr_mtx);
2239                         if (lpr != NULL) {
2240                                 mtx_lock(&lpr->pr_mtx);
2241                                 prison_remove_one(lpr);
2242                                 sx_xlock(&allprison_lock);
2243                         }
2244                         lpr = tpr;
2245                 }
2246                 if (lpr != NULL) {
2247                         mtx_lock(&lpr->pr_mtx);
2248                         prison_remove_one(lpr);
2249                         sx_xlock(&allprison_lock);
2250                 }
2251                 mtx_lock(&pr->pr_mtx);
2252         }
2253         prison_remove_one(pr);
2254         return (0);
2255 }
2256
2257 static void
2258 prison_remove_one(struct prison *pr)
2259 {
2260         struct proc *p;
2261         int deuref;
2262
2263         /* If the prison was persistent, it is not anymore. */
2264         deuref = 0;
2265         if (pr->pr_flags & PR_PERSIST) {
2266                 pr->pr_ref--;
2267                 deuref = PD_DEUREF;
2268                 pr->pr_flags &= ~PR_PERSIST;
2269         }
2270
2271         /*
2272          * jail_remove added a reference.  If that's the only one, remove
2273          * the prison now.
2274          */
2275         KASSERT(pr->pr_ref > 0,
2276             ("prison_remove_one removing a dead prison (jid=%d)", pr->pr_id));
2277         if (pr->pr_ref == 1) {
2278                 prison_deref(pr,
2279                     deuref | PD_DEREF | PD_LOCKED | PD_LIST_XLOCKED);
2280                 return;
2281         }
2282
2283         mtx_unlock(&pr->pr_mtx);
2284         sx_xunlock(&allprison_lock);
2285         /*
2286          * Kill all processes unfortunate enough to be attached to this prison.
2287          */
2288         sx_slock(&allproc_lock);
2289         LIST_FOREACH(p, &allproc, p_list) {
2290                 PROC_LOCK(p);
2291                 if (p->p_state != PRS_NEW && p->p_ucred &&
2292                     p->p_ucred->cr_prison == pr)
2293                         kern_psignal(p, SIGKILL);
2294                 PROC_UNLOCK(p);
2295         }
2296         sx_sunlock(&allproc_lock);
2297         /* Remove the temporary reference added by jail_remove. */
2298         prison_deref(pr, deuref | PD_DEREF);
2299 }
2300
2301
2302 /*
2303  * struct jail_attach_args {
2304  *      int jid;
2305  * };
2306  */
2307 int
2308 sys_jail_attach(struct thread *td, struct jail_attach_args *uap)
2309 {
2310         struct prison *pr;
2311         int error;
2312
2313         error = priv_check(td, PRIV_JAIL_ATTACH);
2314         if (error)
2315                 return (error);
2316
2317         /*
2318          * Start with exclusive hold on allprison_lock to ensure that a possible
2319          * PR_METHOD_REMOVE call isn't concurrent with jail_set or jail_remove.
2320          * But then immediately downgrade it since we don't need to stop
2321          * readers.
2322          */
2323         sx_xlock(&allprison_lock);
2324         sx_downgrade(&allprison_lock);
2325         pr = prison_find_child(td->td_ucred->cr_prison, uap->jid);
2326         if (pr == NULL) {
2327                 sx_sunlock(&allprison_lock);
2328                 return (EINVAL);
2329         }
2330
2331         /*
2332          * Do not allow a process to attach to a prison that is not
2333          * considered to be "alive".
2334          */
2335         if (pr->pr_uref == 0) {
2336                 mtx_unlock(&pr->pr_mtx);
2337                 sx_sunlock(&allprison_lock);
2338                 return (EINVAL);
2339         }
2340
2341         return (do_jail_attach(td, pr));
2342 }
2343
2344 static int
2345 do_jail_attach(struct thread *td, struct prison *pr)
2346 {
2347         struct proc *p;
2348         struct ucred *newcred, *oldcred;
2349         int error;
2350
2351         /*
2352          * XXX: Note that there is a slight race here if two threads
2353          * in the same privileged process attempt to attach to two
2354          * different jails at the same time.  It is important for
2355          * user processes not to do this, or they might end up with
2356          * a process root from one prison, but attached to the jail
2357          * of another.
2358          */
2359         pr->pr_ref++;
2360         pr->pr_uref++;
2361         mtx_unlock(&pr->pr_mtx);
2362
2363         /* Let modules do whatever they need to prepare for attaching. */
2364         error = osd_jail_call(pr, PR_METHOD_ATTACH, td);
2365         if (error) {
2366                 prison_deref(pr, PD_DEREF | PD_DEUREF | PD_LIST_SLOCKED);
2367                 return (error);
2368         }
2369         sx_sunlock(&allprison_lock);
2370
2371         /*
2372          * Reparent the newly attached process to this jail.
2373          */
2374         p = td->td_proc;
2375         error = cpuset_setproc_update_set(p, pr->pr_cpuset);
2376         if (error)
2377                 goto e_revert_osd;
2378
2379         vn_lock(pr->pr_root, LK_EXCLUSIVE | LK_RETRY);
2380         if ((error = change_dir(pr->pr_root, td)) != 0)
2381                 goto e_unlock;
2382 #ifdef MAC
2383         if ((error = mac_vnode_check_chroot(td->td_ucred, pr->pr_root)))
2384                 goto e_unlock;
2385 #endif
2386         VOP_UNLOCK(pr->pr_root, 0);
2387         if ((error = pwd_chroot(td, pr->pr_root)))
2388                 goto e_revert_osd;
2389
2390         newcred = crget();
2391         PROC_LOCK(p);
2392         oldcred = crcopysafe(p, newcred);
2393         newcred->cr_prison = pr;
2394         proc_set_cred(p, newcred);
2395         setsugid(p);
2396 #ifdef RACCT
2397         racct_proc_ucred_changed(p, oldcred, newcred);
2398         crhold(newcred);
2399 #endif
2400         PROC_UNLOCK(p);
2401 #ifdef RCTL
2402         rctl_proc_ucred_changed(p, newcred);
2403         crfree(newcred);
2404 #endif
2405         prison_deref(oldcred->cr_prison, PD_DEREF | PD_DEUREF);
2406         crfree(oldcred);
2407         return (0);
2408
2409  e_unlock:
2410         VOP_UNLOCK(pr->pr_root, 0);
2411  e_revert_osd:
2412         /* Tell modules this thread is still in its old jail after all. */
2413         (void)osd_jail_call(td->td_ucred->cr_prison, PR_METHOD_ATTACH, td);
2414         prison_deref(pr, PD_DEREF | PD_DEUREF);
2415         return (error);
2416 }
2417
2418
2419 /*
2420  * Returns a locked prison instance, or NULL on failure.
2421  */
2422 struct prison *
2423 prison_find(int prid)
2424 {
2425         struct prison *pr;
2426
2427         sx_assert(&allprison_lock, SX_LOCKED);
2428         TAILQ_FOREACH(pr, &allprison, pr_list) {
2429                 if (pr->pr_id == prid) {
2430                         mtx_lock(&pr->pr_mtx);
2431                         if (pr->pr_ref > 0)
2432                                 return (pr);
2433                         mtx_unlock(&pr->pr_mtx);
2434                 }
2435         }
2436         return (NULL);
2437 }
2438
2439 /*
2440  * Find a prison that is a descendant of mypr.  Returns a locked prison or NULL.
2441  */
2442 struct prison *
2443 prison_find_child(struct prison *mypr, int prid)
2444 {
2445         struct prison *pr;
2446         int descend;
2447
2448         sx_assert(&allprison_lock, SX_LOCKED);
2449         FOREACH_PRISON_DESCENDANT(mypr, pr, descend) {
2450                 if (pr->pr_id == prid) {
2451                         mtx_lock(&pr->pr_mtx);
2452                         if (pr->pr_ref > 0)
2453                                 return (pr);
2454                         mtx_unlock(&pr->pr_mtx);
2455                 }
2456         }
2457         return (NULL);
2458 }
2459
2460 /*
2461  * Look for the name relative to mypr.  Returns a locked prison or NULL.
2462  */
2463 struct prison *
2464 prison_find_name(struct prison *mypr, const char *name)
2465 {
2466         struct prison *pr, *deadpr;
2467         size_t mylen;
2468         int descend;
2469
2470         sx_assert(&allprison_lock, SX_LOCKED);
2471         mylen = (mypr == &prison0) ? 0 : strlen(mypr->pr_name) + 1;
2472  again:
2473         deadpr = NULL;
2474         FOREACH_PRISON_DESCENDANT(mypr, pr, descend) {
2475                 if (!strcmp(pr->pr_name + mylen, name)) {
2476                         mtx_lock(&pr->pr_mtx);
2477                         if (pr->pr_ref > 0) {
2478                                 if (pr->pr_uref > 0)
2479                                         return (pr);
2480                                 deadpr = pr;
2481                         }
2482                         mtx_unlock(&pr->pr_mtx);
2483                 }
2484         }
2485         /* There was no valid prison - perhaps there was a dying one. */
2486         if (deadpr != NULL) {
2487                 mtx_lock(&deadpr->pr_mtx);
2488                 if (deadpr->pr_ref == 0) {
2489                         mtx_unlock(&deadpr->pr_mtx);
2490                         goto again;
2491                 }
2492         }
2493         return (deadpr);
2494 }
2495
2496 /*
2497  * See if a prison has the specific flag set.
2498  */
2499 int
2500 prison_flag(struct ucred *cred, unsigned flag)
2501 {
2502
2503         /* This is an atomic read, so no locking is necessary. */
2504         return (cred->cr_prison->pr_flags & flag);
2505 }
2506
2507 int
2508 prison_allow(struct ucred *cred, unsigned flag)
2509 {
2510
2511         /* This is an atomic read, so no locking is necessary. */
2512         return (cred->cr_prison->pr_allow & flag);
2513 }
2514
2515 /*
2516  * Remove a prison reference.  If that was the last reference, remove the
2517  * prison itself - but not in this context in case there are locks held.
2518  */
2519 void
2520 prison_free_locked(struct prison *pr)
2521 {
2522         int ref;
2523
2524         mtx_assert(&pr->pr_mtx, MA_OWNED);
2525         ref = --pr->pr_ref;
2526         mtx_unlock(&pr->pr_mtx);
2527         if (ref == 0)
2528                 taskqueue_enqueue(taskqueue_thread, &pr->pr_task);
2529 }
2530
2531 void
2532 prison_free(struct prison *pr)
2533 {
2534
2535         mtx_lock(&pr->pr_mtx);
2536         prison_free_locked(pr);
2537 }
2538
2539 /*
2540  * Complete a call to either prison_free or prison_proc_free.
2541  */
2542 static void
2543 prison_complete(void *context, int pending)
2544 {
2545         struct prison *pr = context;
2546
2547         sx_xlock(&allprison_lock);
2548         mtx_lock(&pr->pr_mtx);
2549         prison_deref(pr, pr->pr_uref
2550             ? PD_DEREF | PD_DEUREF | PD_LOCKED | PD_LIST_XLOCKED
2551             : PD_LOCKED | PD_LIST_XLOCKED);
2552 }
2553
2554 /*
2555  * Remove a prison reference (usually).  This internal version assumes no
2556  * mutexes are held, except perhaps the prison itself.  If there are no more
2557  * references, release and delist the prison.  On completion, the prison lock
2558  * and the allprison lock are both unlocked.
2559  */
2560 static void
2561 prison_deref(struct prison *pr, int flags)
2562 {
2563         struct prison *ppr, *tpr;
2564         int ref, lasturef;
2565
2566         if (!(flags & PD_LOCKED))
2567                 mtx_lock(&pr->pr_mtx);
2568         for (;;) {
2569                 if (flags & PD_DEUREF) {
2570                         KASSERT(pr->pr_uref > 0,
2571                             ("prison_deref PD_DEUREF on a dead prison (jid=%d)",
2572                              pr->pr_id));
2573                         pr->pr_uref--;
2574                         lasturef = pr->pr_uref == 0;
2575                         if (lasturef)
2576                                 pr->pr_ref++;
2577                         KASSERT(prison0.pr_uref != 0, ("prison0 pr_uref=0"));
2578                 } else
2579                         lasturef = 0;
2580                 if (flags & PD_DEREF) {
2581                         KASSERT(pr->pr_ref > 0,
2582                             ("prison_deref PD_DEREF on a dead prison (jid=%d)",
2583                              pr->pr_id));
2584                         pr->pr_ref--;
2585                 }
2586                 ref = pr->pr_ref;
2587                 mtx_unlock(&pr->pr_mtx);
2588
2589                 /*
2590                  * Tell the modules if the last user reference was removed
2591                  * (even it sticks around in dying state).
2592                  */
2593                 if (lasturef) {
2594                         if (!(flags & (PD_LIST_SLOCKED | PD_LIST_XLOCKED))) {
2595                                 sx_xlock(&allprison_lock);
2596                                 flags |= PD_LIST_XLOCKED;
2597                         }
2598                         (void)osd_jail_call(pr, PR_METHOD_REMOVE, NULL);
2599                         mtx_lock(&pr->pr_mtx);
2600                         ref = --pr->pr_ref;
2601                         mtx_unlock(&pr->pr_mtx);
2602                 }
2603
2604                 /* If the prison still has references, nothing else to do. */
2605                 if (ref > 0) {
2606                         if (flags & PD_LIST_SLOCKED)
2607                                 sx_sunlock(&allprison_lock);
2608                         else if (flags & PD_LIST_XLOCKED)
2609                                 sx_xunlock(&allprison_lock);
2610                         return;
2611                 }
2612
2613                 if (flags & PD_LIST_SLOCKED) {
2614                         if (!sx_try_upgrade(&allprison_lock)) {
2615                                 sx_sunlock(&allprison_lock);
2616                                 sx_xlock(&allprison_lock);
2617                         }
2618                 } else if (!(flags & PD_LIST_XLOCKED))
2619                         sx_xlock(&allprison_lock);
2620
2621                 TAILQ_REMOVE(&allprison, pr, pr_list);
2622                 LIST_REMOVE(pr, pr_sibling);
2623                 ppr = pr->pr_parent;
2624                 for (tpr = ppr; tpr != NULL; tpr = tpr->pr_parent)
2625                         tpr->pr_childcount--;
2626                 sx_xunlock(&allprison_lock);
2627
2628 #ifdef VIMAGE
2629                 if (pr->pr_vnet != ppr->pr_vnet)
2630                         vnet_destroy(pr->pr_vnet);
2631 #endif
2632                 if (pr->pr_root != NULL)
2633                         vrele(pr->pr_root);
2634                 mtx_destroy(&pr->pr_mtx);
2635 #ifdef INET
2636                 free(pr->pr_ip4, M_PRISON);
2637 #endif
2638 #ifdef INET6
2639                 free(pr->pr_ip6, M_PRISON);
2640 #endif
2641                 if (pr->pr_cpuset != NULL)
2642                         cpuset_rel(pr->pr_cpuset);
2643                 osd_jail_exit(pr);
2644 #ifdef RACCT
2645                 if (racct_enable)
2646                         prison_racct_detach(pr);
2647 #endif
2648                 free(pr, M_PRISON);
2649
2650                 /* Removing a prison frees a reference on its parent. */
2651                 pr = ppr;
2652                 mtx_lock(&pr->pr_mtx);
2653                 flags = PD_DEREF | PD_DEUREF;
2654         }
2655 }
2656
2657 void
2658 prison_hold_locked(struct prison *pr)
2659 {
2660
2661         mtx_assert(&pr->pr_mtx, MA_OWNED);
2662         KASSERT(pr->pr_ref > 0,
2663             ("Trying to hold dead prison (jid=%d).", pr->pr_id));
2664         pr->pr_ref++;
2665 }
2666
2667 void
2668 prison_hold(struct prison *pr)
2669 {
2670
2671         mtx_lock(&pr->pr_mtx);
2672         prison_hold_locked(pr);
2673         mtx_unlock(&pr->pr_mtx);
2674 }
2675
2676 void
2677 prison_proc_hold(struct prison *pr)
2678 {
2679
2680         mtx_lock(&pr->pr_mtx);
2681         KASSERT(pr->pr_uref > 0,
2682             ("Cannot add a process to a non-alive prison (jid=%d)", pr->pr_id));
2683         pr->pr_uref++;
2684         mtx_unlock(&pr->pr_mtx);
2685 }
2686
2687 void
2688 prison_proc_free(struct prison *pr)
2689 {
2690
2691         mtx_lock(&pr->pr_mtx);
2692         KASSERT(pr->pr_uref > 0,
2693             ("Trying to kill a process in a dead prison (jid=%d)", pr->pr_id));
2694         if (pr->pr_uref > 1)
2695                 pr->pr_uref--;
2696         else {
2697                 /*
2698                  * Don't remove the last user reference in this context, which
2699                  * is expected to be a process that is not only locked, but
2700                  * also half dead.
2701                  */
2702                 pr->pr_ref++;
2703                 mtx_unlock(&pr->pr_mtx);
2704                 taskqueue_enqueue(taskqueue_thread, &pr->pr_task);
2705                 return;
2706         }
2707         mtx_unlock(&pr->pr_mtx);
2708 }
2709
2710 /*
2711  * Check if a jail supports the given address family.
2712  *
2713  * Returns 0 if not jailed or the address family is supported, EAFNOSUPPORT
2714  * if not.
2715  */
2716 int
2717 prison_check_af(struct ucred *cred, int af)
2718 {
2719         struct prison *pr;
2720         int error;
2721
2722         KASSERT(cred != NULL, ("%s: cred is NULL", __func__));
2723
2724         pr = cred->cr_prison;
2725 #ifdef VIMAGE
2726         /* Prisons with their own network stack are not limited. */
2727         if (prison_owns_vnet(cred))
2728                 return (0);
2729 #endif
2730
2731         error = 0;
2732         switch (af)
2733         {
2734 #ifdef INET
2735         case AF_INET:
2736                 if (pr->pr_flags & PR_IP4)
2737                 {
2738                         mtx_lock(&pr->pr_mtx);
2739                         if ((pr->pr_flags & PR_IP4) && pr->pr_ip4 == NULL)
2740                                 error = EAFNOSUPPORT;
2741                         mtx_unlock(&pr->pr_mtx);
2742                 }
2743                 break;
2744 #endif
2745 #ifdef INET6
2746         case AF_INET6:
2747                 if (pr->pr_flags & PR_IP6)
2748                 {
2749                         mtx_lock(&pr->pr_mtx);
2750                         if ((pr->pr_flags & PR_IP6) && pr->pr_ip6 == NULL)
2751                                 error = EAFNOSUPPORT;
2752                         mtx_unlock(&pr->pr_mtx);
2753                 }
2754                 break;
2755 #endif
2756         case AF_LOCAL:
2757         case AF_ROUTE:
2758                 break;
2759         default:
2760                 if (!(pr->pr_allow & PR_ALLOW_SOCKET_AF))
2761                         error = EAFNOSUPPORT;
2762         }
2763         return (error);
2764 }
2765
2766 /*
2767  * Check if given address belongs to the jail referenced by cred (wrapper to
2768  * prison_check_ip[46]).
2769  *
2770  * Returns 0 if jail doesn't restrict the address family or if address belongs
2771  * to jail, EADDRNOTAVAIL if the address doesn't belong, or EAFNOSUPPORT if
2772  * the jail doesn't allow the address family.  IPv4 Address passed in in NBO.
2773  */
2774 int
2775 prison_if(struct ucred *cred, struct sockaddr *sa)
2776 {
2777 #ifdef INET
2778         struct sockaddr_in *sai;
2779 #endif
2780 #ifdef INET6
2781         struct sockaddr_in6 *sai6;
2782 #endif
2783         int error;
2784
2785         KASSERT(cred != NULL, ("%s: cred is NULL", __func__));
2786         KASSERT(sa != NULL, ("%s: sa is NULL", __func__));
2787
2788 #ifdef VIMAGE
2789         if (prison_owns_vnet(cred))
2790                 return (0);
2791 #endif
2792
2793         error = 0;
2794         switch (sa->sa_family)
2795         {
2796 #ifdef INET
2797         case AF_INET:
2798                 sai = (struct sockaddr_in *)sa;
2799                 error = prison_check_ip4(cred, &sai->sin_addr);
2800                 break;
2801 #endif
2802 #ifdef INET6
2803         case AF_INET6:
2804                 sai6 = (struct sockaddr_in6 *)sa;
2805                 error = prison_check_ip6(cred, &sai6->sin6_addr);
2806                 break;
2807 #endif
2808         default:
2809                 if (!(cred->cr_prison->pr_allow & PR_ALLOW_SOCKET_AF))
2810                         error = EAFNOSUPPORT;
2811         }
2812         return (error);
2813 }
2814
2815 /*
2816  * Return 0 if jails permit p1 to frob p2, otherwise ESRCH.
2817  */
2818 int
2819 prison_check(struct ucred *cred1, struct ucred *cred2)
2820 {
2821
2822         return ((cred1->cr_prison == cred2->cr_prison ||
2823             prison_ischild(cred1->cr_prison, cred2->cr_prison)) ? 0 : ESRCH);
2824 }
2825
2826 /*
2827  * Return 1 if p2 is a child of p1, otherwise 0.
2828  */
2829 int
2830 prison_ischild(struct prison *pr1, struct prison *pr2)
2831 {
2832
2833         for (pr2 = pr2->pr_parent; pr2 != NULL; pr2 = pr2->pr_parent)
2834                 if (pr1 == pr2)
2835                         return (1);
2836         return (0);
2837 }
2838
2839 /*
2840  * Return 1 if the passed credential is in a jail, otherwise 0.
2841  */
2842 int
2843 jailed(struct ucred *cred)
2844 {
2845
2846         return (cred->cr_prison != &prison0);
2847 }
2848
2849 /*
2850  * Return 1 if the passed credential is in a jail and that jail does not
2851  * have its own virtual network stack, otherwise 0.
2852  */
2853 int
2854 jailed_without_vnet(struct ucred *cred)
2855 {
2856
2857         if (!jailed(cred))
2858                 return (0);
2859 #ifdef VIMAGE
2860         if (prison_owns_vnet(cred))
2861                 return (0);
2862 #endif
2863
2864         return (1);
2865 }
2866
2867 /*
2868  * Return the correct hostname (domainname, et al) for the passed credential.
2869  */
2870 void
2871 getcredhostname(struct ucred *cred, char *buf, size_t size)
2872 {
2873         struct prison *pr;
2874
2875         /*
2876          * A NULL credential can be used to shortcut to the physical
2877          * system's hostname.
2878          */
2879         pr = (cred != NULL) ? cred->cr_prison : &prison0;
2880         mtx_lock(&pr->pr_mtx);
2881         strlcpy(buf, pr->pr_hostname, size);
2882         mtx_unlock(&pr->pr_mtx);
2883 }
2884
2885 void
2886 getcreddomainname(struct ucred *cred, char *buf, size_t size)
2887 {
2888
2889         mtx_lock(&cred->cr_prison->pr_mtx);
2890         strlcpy(buf, cred->cr_prison->pr_domainname, size);
2891         mtx_unlock(&cred->cr_prison->pr_mtx);
2892 }
2893
2894 void
2895 getcredhostuuid(struct ucred *cred, char *buf, size_t size)
2896 {
2897
2898         mtx_lock(&cred->cr_prison->pr_mtx);
2899         strlcpy(buf, cred->cr_prison->pr_hostuuid, size);
2900         mtx_unlock(&cred->cr_prison->pr_mtx);
2901 }
2902
2903 void
2904 getcredhostid(struct ucred *cred, unsigned long *hostid)
2905 {
2906
2907         mtx_lock(&cred->cr_prison->pr_mtx);
2908         *hostid = cred->cr_prison->pr_hostid;
2909         mtx_unlock(&cred->cr_prison->pr_mtx);
2910 }
2911
2912 #ifdef VIMAGE
2913 /*
2914  * Determine whether the prison represented by cred owns
2915  * its vnet rather than having it inherited.
2916  *
2917  * Returns 1 in case the prison owns the vnet, 0 otherwise.
2918  */
2919 int
2920 prison_owns_vnet(struct ucred *cred)
2921 {
2922
2923         /*
2924          * vnets cannot be added/removed after jail creation,
2925          * so no need to lock here.
2926          */
2927         return (cred->cr_prison->pr_flags & PR_VNET ? 1 : 0);
2928 }
2929 #endif
2930
2931 /*
2932  * Determine whether the subject represented by cred can "see"
2933  * status of a mount point.
2934  * Returns: 0 for permitted, ENOENT otherwise.
2935  * XXX: This function should be called cr_canseemount() and should be
2936  *      placed in kern_prot.c.
2937  */
2938 int
2939 prison_canseemount(struct ucred *cred, struct mount *mp)
2940 {
2941         struct prison *pr;
2942         struct statfs *sp;
2943         size_t len;
2944
2945         pr = cred->cr_prison;
2946         if (pr->pr_enforce_statfs == 0)
2947                 return (0);
2948         if (pr->pr_root->v_mount == mp)
2949                 return (0);
2950         if (pr->pr_enforce_statfs == 2)
2951                 return (ENOENT);
2952         /*
2953          * If jail's chroot directory is set to "/" we should be able to see
2954          * all mount-points from inside a jail.
2955          * This is ugly check, but this is the only situation when jail's
2956          * directory ends with '/'.
2957          */
2958         if (strcmp(pr->pr_path, "/") == 0)
2959                 return (0);
2960         len = strlen(pr->pr_path);
2961         sp = &mp->mnt_stat;
2962         if (strncmp(pr->pr_path, sp->f_mntonname, len) != 0)
2963                 return (ENOENT);
2964         /*
2965          * Be sure that we don't have situation where jail's root directory
2966          * is "/some/path" and mount point is "/some/pathpath".
2967          */
2968         if (sp->f_mntonname[len] != '\0' && sp->f_mntonname[len] != '/')
2969                 return (ENOENT);
2970         return (0);
2971 }
2972
2973 void
2974 prison_enforce_statfs(struct ucred *cred, struct mount *mp, struct statfs *sp)
2975 {
2976         char jpath[MAXPATHLEN];
2977         struct prison *pr;
2978         size_t len;
2979
2980         pr = cred->cr_prison;
2981         if (pr->pr_enforce_statfs == 0)
2982                 return;
2983         if (prison_canseemount(cred, mp) != 0) {
2984                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
2985                 strlcpy(sp->f_mntonname, "[restricted]",
2986                     sizeof(sp->f_mntonname));
2987                 return;
2988         }
2989         if (pr->pr_root->v_mount == mp) {
2990                 /*
2991                  * Clear current buffer data, so we are sure nothing from
2992                  * the valid path left there.
2993                  */
2994                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
2995                 *sp->f_mntonname = '/';
2996                 return;
2997         }
2998         /*
2999          * If jail's chroot directory is set to "/" we should be able to see
3000          * all mount-points from inside a jail.
3001          */
3002         if (strcmp(pr->pr_path, "/") == 0)
3003                 return;
3004         len = strlen(pr->pr_path);
3005         strlcpy(jpath, sp->f_mntonname + len, sizeof(jpath));
3006         /*
3007          * Clear current buffer data, so we are sure nothing from
3008          * the valid path left there.
3009          */
3010         bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
3011         if (*jpath == '\0') {
3012                 /* Should never happen. */
3013                 *sp->f_mntonname = '/';
3014         } else {
3015                 strlcpy(sp->f_mntonname, jpath, sizeof(sp->f_mntonname));
3016         }
3017 }
3018
3019 /*
3020  * Check with permission for a specific privilege is granted within jail.  We
3021  * have a specific list of accepted privileges; the rest are denied.
3022  */
3023 int
3024 prison_priv_check(struct ucred *cred, int priv)
3025 {
3026
3027         if (!jailed(cred))
3028                 return (0);
3029
3030 #ifdef VIMAGE
3031         /*
3032          * Privileges specific to prisons with a virtual network stack.
3033          * There might be a duplicate entry here in case the privilege
3034          * is only granted conditionally in the legacy jail case.
3035          */
3036         switch (priv) {
3037 #ifdef notyet
3038                 /*
3039                  * NFS-specific privileges.
3040                  */
3041         case PRIV_NFS_DAEMON:
3042         case PRIV_NFS_LOCKD:
3043 #endif
3044                 /*
3045                  * Network stack privileges.
3046                  */
3047         case PRIV_NET_BRIDGE:
3048         case PRIV_NET_GRE:
3049         case PRIV_NET_BPF:
3050         case PRIV_NET_RAW:              /* Dup, cond. in legacy jail case. */
3051         case PRIV_NET_ROUTE:
3052         case PRIV_NET_TAP:
3053         case PRIV_NET_SETIFMTU:
3054         case PRIV_NET_SETIFFLAGS:
3055         case PRIV_NET_SETIFCAP:
3056         case PRIV_NET_SETIFDESCR:
3057         case PRIV_NET_SETIFNAME :
3058         case PRIV_NET_SETIFMETRIC:
3059         case PRIV_NET_SETIFPHYS:
3060         case PRIV_NET_SETIFMAC:
3061         case PRIV_NET_ADDMULTI:
3062         case PRIV_NET_DELMULTI:
3063         case PRIV_NET_HWIOCTL:
3064         case PRIV_NET_SETLLADDR:
3065         case PRIV_NET_ADDIFGROUP:
3066         case PRIV_NET_DELIFGROUP:
3067         case PRIV_NET_IFCREATE:
3068         case PRIV_NET_IFDESTROY:
3069         case PRIV_NET_ADDIFADDR:
3070         case PRIV_NET_DELIFADDR:
3071         case PRIV_NET_LAGG:
3072         case PRIV_NET_GIF:
3073         case PRIV_NET_SETIFVNET:
3074         case PRIV_NET_SETIFFIB:
3075
3076                 /*
3077                  * 802.11-related privileges.
3078                  */
3079         case PRIV_NET80211_GETKEY:
3080 #ifdef notyet
3081         case PRIV_NET80211_MANAGE:              /* XXX-BZ discuss with sam@ */
3082 #endif
3083
3084 #ifdef notyet
3085                 /*
3086                  * ATM privileges.
3087                  */
3088         case PRIV_NETATM_CFG:
3089         case PRIV_NETATM_ADD:
3090         case PRIV_NETATM_DEL:
3091         case PRIV_NETATM_SET:
3092
3093                 /*
3094                  * Bluetooth privileges.
3095                  */
3096         case PRIV_NETBLUETOOTH_RAW:
3097 #endif
3098
3099                 /*
3100                  * Netgraph and netgraph module privileges.
3101                  */
3102         case PRIV_NETGRAPH_CONTROL:
3103 #ifdef notyet
3104         case PRIV_NETGRAPH_TTY:
3105 #endif
3106
3107                 /*
3108                  * IPv4 and IPv6 privileges.
3109                  */
3110         case PRIV_NETINET_IPFW:
3111         case PRIV_NETINET_DIVERT:
3112         case PRIV_NETINET_PF:
3113         case PRIV_NETINET_DUMMYNET:
3114         case PRIV_NETINET_CARP:
3115         case PRIV_NETINET_MROUTE:
3116         case PRIV_NETINET_RAW:
3117         case PRIV_NETINET_ADDRCTRL6:
3118         case PRIV_NETINET_ND6:
3119         case PRIV_NETINET_SCOPE6:
3120         case PRIV_NETINET_ALIFETIME6:
3121         case PRIV_NETINET_IPSEC:
3122         case PRIV_NETINET_BINDANY:
3123
3124 #ifdef notyet
3125                 /*
3126                  * NCP privileges.
3127                  */
3128         case PRIV_NETNCP:
3129
3130                 /*
3131                  * SMB privileges.
3132                  */
3133         case PRIV_NETSMB:
3134 #endif
3135
3136         /*
3137          * No default: or deny here.
3138          * In case of no permit fall through to next switch().
3139          */
3140                 if (cred->cr_prison->pr_flags & PR_VNET)
3141                         return (0);
3142         }
3143 #endif /* VIMAGE */
3144
3145         switch (priv) {
3146
3147                 /*
3148                  * Allow ktrace privileges for root in jail.
3149                  */
3150         case PRIV_KTRACE:
3151
3152 #if 0
3153                 /*
3154                  * Allow jailed processes to configure audit identity and
3155                  * submit audit records (login, etc).  In the future we may
3156                  * want to further refine the relationship between audit and
3157                  * jail.
3158                  */
3159         case PRIV_AUDIT_GETAUDIT:
3160         case PRIV_AUDIT_SETAUDIT:
3161         case PRIV_AUDIT_SUBMIT:
3162 #endif
3163
3164                 /*
3165                  * Allow jailed processes to manipulate process UNIX
3166                  * credentials in any way they see fit.
3167                  */
3168         case PRIV_CRED_SETUID:
3169         case PRIV_CRED_SETEUID:
3170         case PRIV_CRED_SETGID:
3171         case PRIV_CRED_SETEGID:
3172         case PRIV_CRED_SETGROUPS:
3173         case PRIV_CRED_SETREUID:
3174         case PRIV_CRED_SETREGID:
3175         case PRIV_CRED_SETRESUID:
3176         case PRIV_CRED_SETRESGID:
3177
3178                 /*
3179                  * Jail implements visibility constraints already, so allow
3180                  * jailed root to override uid/gid-based constraints.
3181                  */
3182         case PRIV_SEEOTHERGIDS:
3183         case PRIV_SEEOTHERUIDS:
3184
3185                 /*
3186                  * Jail implements inter-process debugging limits already, so
3187                  * allow jailed root various debugging privileges.
3188                  */
3189         case PRIV_DEBUG_DIFFCRED:
3190         case PRIV_DEBUG_SUGID:
3191         case PRIV_DEBUG_UNPRIV:
3192
3193                 /*
3194                  * Allow jail to set various resource limits and login
3195                  * properties, and for now, exceed process resource limits.
3196                  */
3197         case PRIV_PROC_LIMIT:
3198         case PRIV_PROC_SETLOGIN:
3199         case PRIV_PROC_SETRLIMIT:
3200
3201                 /*
3202                  * System V and POSIX IPC privileges are granted in jail.
3203                  */
3204         case PRIV_IPC_READ:
3205         case PRIV_IPC_WRITE:
3206         case PRIV_IPC_ADMIN:
3207         case PRIV_IPC_MSGSIZE:
3208         case PRIV_MQ_ADMIN:
3209
3210                 /*
3211                  * Jail operations within a jail work on child jails.
3212                  */
3213         case PRIV_JAIL_ATTACH:
3214         case PRIV_JAIL_SET:
3215         case PRIV_JAIL_REMOVE:
3216
3217                 /*
3218                  * Jail implements its own inter-process limits, so allow
3219                  * root processes in jail to change scheduling on other
3220                  * processes in the same jail.  Likewise for signalling.
3221                  */
3222         case PRIV_SCHED_DIFFCRED:
3223         case PRIV_SCHED_CPUSET:
3224         case PRIV_SIGNAL_DIFFCRED:
3225         case PRIV_SIGNAL_SUGID:
3226
3227                 /*
3228                  * Allow jailed processes to write to sysctls marked as jail
3229                  * writable.
3230                  */
3231         case PRIV_SYSCTL_WRITEJAIL:
3232
3233                 /*
3234                  * Allow root in jail to manage a variety of quota
3235                  * properties.  These should likely be conditional on a
3236                  * configuration option.
3237                  */
3238         case PRIV_VFS_GETQUOTA:
3239         case PRIV_VFS_SETQUOTA:
3240
3241                 /*
3242                  * Since Jail relies on chroot() to implement file system
3243                  * protections, grant many VFS privileges to root in jail.
3244                  * Be careful to exclude mount-related and NFS-related
3245                  * privileges.
3246                  */
3247         case PRIV_VFS_READ:
3248         case PRIV_VFS_WRITE:
3249         case PRIV_VFS_ADMIN:
3250         case PRIV_VFS_EXEC:
3251         case PRIV_VFS_LOOKUP:
3252         case PRIV_VFS_BLOCKRESERVE:     /* XXXRW: Slightly surprising. */
3253         case PRIV_VFS_CHFLAGS_DEV:
3254         case PRIV_VFS_CHOWN:
3255         case PRIV_VFS_CHROOT:
3256         case PRIV_VFS_RETAINSUGID:
3257         case PRIV_VFS_FCHROOT:
3258         case PRIV_VFS_LINK:
3259         case PRIV_VFS_SETGID:
3260         case PRIV_VFS_STAT:
3261         case PRIV_VFS_STICKYFILE:
3262
3263                 /*
3264                  * As in the non-jail case, non-root users are expected to be
3265                  * able to read kernel/phyiscal memory (provided /dev/[k]mem
3266                  * exists in the jail and they have permission to access it).
3267                  */
3268         case PRIV_KMEM_READ:
3269                 return (0);
3270
3271                 /*
3272                  * Depending on the global setting, allow privilege of
3273                  * setting system flags.
3274                  */
3275         case PRIV_VFS_SYSFLAGS:
3276                 if (cred->cr_prison->pr_allow & PR_ALLOW_CHFLAGS)
3277                         return (0);
3278                 else
3279                         return (EPERM);
3280
3281                 /*
3282                  * Depending on the global setting, allow privilege of
3283                  * mounting/unmounting file systems.
3284                  */
3285         case PRIV_VFS_MOUNT:
3286         case PRIV_VFS_UNMOUNT:
3287         case PRIV_VFS_MOUNT_NONUSER:
3288         case PRIV_VFS_MOUNT_OWNER:
3289                 if (cred->cr_prison->pr_allow & PR_ALLOW_MOUNT &&
3290                     cred->cr_prison->pr_enforce_statfs < 2)
3291                         return (0);
3292                 else
3293                         return (EPERM);
3294
3295                 /*
3296                  * Conditionally allow jailed root to bind reserved ports.
3297                  */
3298         case PRIV_NETINET_RESERVEDPORT:
3299                 if (cred->cr_prison->pr_allow & PR_ALLOW_RESERVED_PORTS)
3300                         return (0);
3301                 else
3302                         return (EPERM);
3303
3304                 /*
3305                  * Allow jailed root to reuse in-use ports.
3306                  */
3307         case PRIV_NETINET_REUSEPORT:
3308                 return (0);
3309
3310                 /*
3311                  * Allow jailed root to set certain IPv4/6 (option) headers.
3312                  */
3313         case PRIV_NETINET_SETHDROPTS:
3314                 return (0);
3315
3316                 /*
3317                  * Conditionally allow creating raw sockets in jail.
3318                  */
3319         case PRIV_NETINET_RAW:
3320                 if (cred->cr_prison->pr_allow & PR_ALLOW_RAW_SOCKETS)
3321                         return (0);
3322                 else
3323                         return (EPERM);
3324
3325                 /*
3326                  * Since jail implements its own visibility limits on netstat
3327                  * sysctls, allow getcred.  This allows identd to work in
3328                  * jail.
3329                  */
3330         case PRIV_NETINET_GETCRED:
3331                 return (0);
3332
3333                 /*
3334                  * Allow jailed root to set loginclass.
3335                  */
3336         case PRIV_PROC_SETLOGINCLASS:
3337                 return (0);
3338
3339         default:
3340                 /*
3341                  * In all remaining cases, deny the privilege request.  This
3342                  * includes almost all network privileges, many system
3343                  * configuration privileges.
3344                  */
3345                 return (EPERM);
3346         }
3347 }
3348
3349 /*
3350  * Return the part of pr2's name that is relative to pr1, or the whole name
3351  * if it does not directly follow.
3352  */
3353
3354 char *
3355 prison_name(struct prison *pr1, struct prison *pr2)
3356 {
3357         char *name;
3358
3359         /* Jails see themselves as "0" (if they see themselves at all). */
3360         if (pr1 == pr2)
3361                 return "0";
3362         name = pr2->pr_name;
3363         if (prison_ischild(pr1, pr2)) {
3364                 /*
3365                  * pr1 isn't locked (and allprison_lock may not be either)
3366                  * so its length can't be counted on.  But the number of dots
3367                  * can be counted on - and counted.
3368                  */
3369                 for (; pr1 != &prison0; pr1 = pr1->pr_parent)
3370                         name = strchr(name, '.') + 1;
3371         }
3372         return (name);
3373 }
3374
3375 /*
3376  * Return the part of pr2's path that is relative to pr1, or the whole path
3377  * if it does not directly follow.
3378  */
3379 static char *
3380 prison_path(struct prison *pr1, struct prison *pr2)
3381 {
3382         char *path1, *path2;
3383         int len1;
3384
3385         path1 = pr1->pr_path;
3386         path2 = pr2->pr_path;
3387         if (!strcmp(path1, "/"))
3388                 return (path2);
3389         len1 = strlen(path1);
3390         if (strncmp(path1, path2, len1))
3391                 return (path2);
3392         if (path2[len1] == '\0')
3393                 return "/";
3394         if (path2[len1] == '/')
3395                 return (path2 + len1);
3396         return (path2);
3397 }
3398
3399
3400 /*
3401  * Jail-related sysctls.
3402  */
3403 static SYSCTL_NODE(_security, OID_AUTO, jail, CTLFLAG_RW, 0,
3404     "Jails");
3405
3406 static int
3407 sysctl_jail_list(SYSCTL_HANDLER_ARGS)
3408 {
3409         struct xprison *xp;
3410         struct prison *pr, *cpr;
3411 #ifdef INET
3412         struct in_addr *ip4 = NULL;
3413         int ip4s = 0;
3414 #endif
3415 #ifdef INET6
3416         struct in6_addr *ip6 = NULL;
3417         int ip6s = 0;
3418 #endif
3419         int descend, error;
3420
3421         xp = malloc(sizeof(*xp), M_TEMP, M_WAITOK);
3422         pr = req->td->td_ucred->cr_prison;
3423         error = 0;
3424         sx_slock(&allprison_lock);
3425         FOREACH_PRISON_DESCENDANT(pr, cpr, descend) {
3426 #if defined(INET) || defined(INET6)
3427  again:
3428 #endif
3429                 mtx_lock(&cpr->pr_mtx);
3430 #ifdef INET
3431                 if (cpr->pr_ip4s > 0) {
3432                         if (ip4s < cpr->pr_ip4s) {
3433                                 ip4s = cpr->pr_ip4s;
3434                                 mtx_unlock(&cpr->pr_mtx);
3435                                 ip4 = realloc(ip4, ip4s *
3436                                     sizeof(struct in_addr), M_TEMP, M_WAITOK);
3437                                 goto again;
3438                         }
3439                         bcopy(cpr->pr_ip4, ip4,
3440                             cpr->pr_ip4s * sizeof(struct in_addr));
3441                 }
3442 #endif
3443 #ifdef INET6
3444                 if (cpr->pr_ip6s > 0) {
3445                         if (ip6s < cpr->pr_ip6s) {
3446                                 ip6s = cpr->pr_ip6s;
3447                                 mtx_unlock(&cpr->pr_mtx);
3448                                 ip6 = realloc(ip6, ip6s *
3449                                     sizeof(struct in6_addr), M_TEMP, M_WAITOK);
3450                                 goto again;
3451                         }
3452                         bcopy(cpr->pr_ip6, ip6,
3453                             cpr->pr_ip6s * sizeof(struct in6_addr));
3454                 }
3455 #endif
3456                 if (cpr->pr_ref == 0) {
3457                         mtx_unlock(&cpr->pr_mtx);
3458                         continue;
3459                 }
3460                 bzero(xp, sizeof(*xp));
3461                 xp->pr_version = XPRISON_VERSION;
3462                 xp->pr_id = cpr->pr_id;
3463                 xp->pr_state = cpr->pr_uref > 0
3464                     ? PRISON_STATE_ALIVE : PRISON_STATE_DYING;
3465                 strlcpy(xp->pr_path, prison_path(pr, cpr), sizeof(xp->pr_path));
3466                 strlcpy(xp->pr_host, cpr->pr_hostname, sizeof(xp->pr_host));
3467                 strlcpy(xp->pr_name, prison_name(pr, cpr), sizeof(xp->pr_name));
3468 #ifdef INET
3469                 xp->pr_ip4s = cpr->pr_ip4s;
3470 #endif
3471 #ifdef INET6
3472                 xp->pr_ip6s = cpr->pr_ip6s;
3473 #endif
3474                 mtx_unlock(&cpr->pr_mtx);
3475                 error = SYSCTL_OUT(req, xp, sizeof(*xp));
3476                 if (error)
3477                         break;
3478 #ifdef INET
3479                 if (xp->pr_ip4s > 0) {
3480                         error = SYSCTL_OUT(req, ip4,
3481                             xp->pr_ip4s * sizeof(struct in_addr));
3482                         if (error)
3483                                 break;
3484                 }
3485 #endif
3486 #ifdef INET6
3487                 if (xp->pr_ip6s > 0) {
3488                         error = SYSCTL_OUT(req, ip6,
3489                             xp->pr_ip6s * sizeof(struct in6_addr));
3490                         if (error)
3491                                 break;
3492                 }
3493 #endif
3494         }
3495         sx_sunlock(&allprison_lock);
3496         free(xp, M_TEMP);
3497 #ifdef INET
3498         free(ip4, M_TEMP);
3499 #endif
3500 #ifdef INET6
3501         free(ip6, M_TEMP);
3502 #endif
3503         return (error);
3504 }
3505
3506 SYSCTL_OID(_security_jail, OID_AUTO, list,
3507     CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
3508     sysctl_jail_list, "S", "List of active jails");
3509
3510 static int
3511 sysctl_jail_jailed(SYSCTL_HANDLER_ARGS)
3512 {
3513         int error, injail;
3514
3515         injail = jailed(req->td->td_ucred);
3516         error = SYSCTL_OUT(req, &injail, sizeof(injail));
3517
3518         return (error);
3519 }
3520
3521 SYSCTL_PROC(_security_jail, OID_AUTO, jailed,
3522     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
3523     sysctl_jail_jailed, "I", "Process in jail?");
3524
3525 static int
3526 sysctl_jail_vnet(SYSCTL_HANDLER_ARGS)
3527 {
3528         int error, havevnet;
3529 #ifdef VIMAGE
3530         struct ucred *cred = req->td->td_ucred;
3531
3532         havevnet = jailed(cred) && prison_owns_vnet(cred);
3533 #else
3534         havevnet = 0;
3535 #endif
3536         error = SYSCTL_OUT(req, &havevnet, sizeof(havevnet));
3537
3538         return (error);
3539 }
3540
3541 SYSCTL_PROC(_security_jail, OID_AUTO, vnet,
3542     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
3543     sysctl_jail_vnet, "I", "Jail owns VNET?");
3544
3545 #if defined(INET) || defined(INET6)
3546 SYSCTL_UINT(_security_jail, OID_AUTO, jail_max_af_ips, CTLFLAG_RW,
3547     &jail_max_af_ips, 0,
3548     "Number of IP addresses a jail may have at most per address family (deprecated)");
3549 #endif
3550
3551 /*
3552  * Default parameters for jail(2) compatibility.  For historical reasons,
3553  * the sysctl names have varying similarity to the parameter names.  Prisons
3554  * just see their own parameters, and can't change them.
3555  */
3556 static int
3557 sysctl_jail_default_allow(SYSCTL_HANDLER_ARGS)
3558 {
3559         struct prison *pr;
3560         int allow, error, i;
3561
3562         pr = req->td->td_ucred->cr_prison;
3563         allow = (pr == &prison0) ? jail_default_allow : pr->pr_allow;
3564
3565         /* Get the current flag value, and convert it to a boolean. */
3566         i = (allow & arg2) ? 1 : 0;
3567         if (arg1 != NULL)
3568                 i = !i;
3569         error = sysctl_handle_int(oidp, &i, 0, req);
3570         if (error || !req->newptr)
3571                 return (error);
3572         i = i ? arg2 : 0;
3573         if (arg1 != NULL)
3574                 i ^= arg2;
3575         /*
3576          * The sysctls don't have CTLFLAGS_PRISON, so assume prison0
3577          * for writing.
3578          */
3579         mtx_lock(&prison0.pr_mtx);
3580         jail_default_allow = (jail_default_allow & ~arg2) | i;
3581         mtx_unlock(&prison0.pr_mtx);
3582         return (0);
3583 }
3584
3585 SYSCTL_PROC(_security_jail, OID_AUTO, set_hostname_allowed,
3586     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3587     NULL, PR_ALLOW_SET_HOSTNAME, sysctl_jail_default_allow, "I",
3588     "Processes in jail can set their hostnames (deprecated)");
3589 SYSCTL_PROC(_security_jail, OID_AUTO, socket_unixiproute_only,
3590     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3591     (void *)1, PR_ALLOW_SOCKET_AF, sysctl_jail_default_allow, "I",
3592     "Processes in jail are limited to creating UNIX/IP/route sockets only (deprecated)");
3593 SYSCTL_PROC(_security_jail, OID_AUTO, sysvipc_allowed,
3594     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3595     NULL, PR_ALLOW_SYSVIPC, sysctl_jail_default_allow, "I",
3596     "Processes in jail can use System V IPC primitives (deprecated)");
3597 SYSCTL_PROC(_security_jail, OID_AUTO, allow_raw_sockets,
3598     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3599     NULL, PR_ALLOW_RAW_SOCKETS, sysctl_jail_default_allow, "I",
3600     "Prison root can create raw sockets (deprecated)");
3601 SYSCTL_PROC(_security_jail, OID_AUTO, chflags_allowed,
3602     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3603     NULL, PR_ALLOW_CHFLAGS, sysctl_jail_default_allow, "I",
3604     "Processes in jail can alter system file flags (deprecated)");
3605 SYSCTL_PROC(_security_jail, OID_AUTO, mount_allowed,
3606     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3607     NULL, PR_ALLOW_MOUNT, sysctl_jail_default_allow, "I",
3608     "Processes in jail can mount/unmount jail-friendly file systems (deprecated)");
3609
3610 static int
3611 sysctl_jail_default_level(SYSCTL_HANDLER_ARGS)
3612 {
3613         struct prison *pr;
3614         int level, error;
3615
3616         pr = req->td->td_ucred->cr_prison;
3617         level = (pr == &prison0) ? *(int *)arg1 : *(int *)((char *)pr + arg2);
3618         error = sysctl_handle_int(oidp, &level, 0, req);
3619         if (error || !req->newptr)
3620                 return (error);
3621         *(int *)arg1 = level;
3622         return (0);
3623 }
3624
3625 SYSCTL_PROC(_security_jail, OID_AUTO, enforce_statfs,
3626     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3627     &jail_default_enforce_statfs, offsetof(struct prison, pr_enforce_statfs),
3628     sysctl_jail_default_level, "I",
3629     "Processes in jail cannot see all mounted file systems (deprecated)");
3630
3631 SYSCTL_PROC(_security_jail, OID_AUTO, devfs_ruleset,
3632     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
3633     &jail_default_devfs_rsnum, offsetof(struct prison, pr_devfs_rsnum),
3634     sysctl_jail_default_level, "I",
3635     "Ruleset for the devfs filesystem in jail (deprecated)");
3636
3637 /*
3638  * Nodes to describe jail parameters.  Maximum length of string parameters
3639  * is returned in the string itself, and the other parameters exist merely
3640  * to make themselves and their types known.
3641  */
3642 SYSCTL_NODE(_security_jail, OID_AUTO, param, CTLFLAG_RW, 0,
3643     "Jail parameters");
3644
3645 int
3646 sysctl_jail_param(SYSCTL_HANDLER_ARGS)
3647 {
3648         int i;
3649         long l;
3650         size_t s;
3651         char numbuf[12];
3652
3653         switch (oidp->oid_kind & CTLTYPE)
3654         {
3655         case CTLTYPE_LONG:
3656         case CTLTYPE_ULONG:
3657                 l = 0;
3658 #ifdef SCTL_MASK32
3659                 if (!(req->flags & SCTL_MASK32))
3660 #endif
3661                         return (SYSCTL_OUT(req, &l, sizeof(l)));
3662         case CTLTYPE_INT:
3663         case CTLTYPE_UINT:
3664                 i = 0;
3665                 return (SYSCTL_OUT(req, &i, sizeof(i)));
3666         case CTLTYPE_STRING:
3667                 snprintf(numbuf, sizeof(numbuf), "%jd", (intmax_t)arg2);
3668                 return
3669                     (sysctl_handle_string(oidp, numbuf, sizeof(numbuf), req));
3670         case CTLTYPE_STRUCT:
3671                 s = (size_t)arg2;
3672                 return (SYSCTL_OUT(req, &s, sizeof(s)));
3673         }
3674         return (0);
3675 }
3676
3677 /*
3678  * CTLFLAG_RDTUN in the following indicates jail parameters that can be set at
3679  * jail creation time but cannot be changed in an existing jail.
3680  */
3681 SYSCTL_JAIL_PARAM(, jid, CTLTYPE_INT | CTLFLAG_RDTUN, "I", "Jail ID");
3682 SYSCTL_JAIL_PARAM(, parent, CTLTYPE_INT | CTLFLAG_RD, "I", "Jail parent ID");
3683 SYSCTL_JAIL_PARAM_STRING(, name, CTLFLAG_RW, MAXHOSTNAMELEN, "Jail name");
3684 SYSCTL_JAIL_PARAM_STRING(, path, CTLFLAG_RDTUN, MAXPATHLEN, "Jail root path");
3685 SYSCTL_JAIL_PARAM(, securelevel, CTLTYPE_INT | CTLFLAG_RW,
3686     "I", "Jail secure level");
3687 SYSCTL_JAIL_PARAM(, osreldate, CTLTYPE_INT | CTLFLAG_RDTUN, "I",
3688     "Jail value for kern.osreldate and uname -K");
3689 SYSCTL_JAIL_PARAM_STRING(, osrelease, CTLFLAG_RDTUN, OSRELEASELEN,
3690     "Jail value for kern.osrelease and uname -r");
3691 SYSCTL_JAIL_PARAM(, enforce_statfs, CTLTYPE_INT | CTLFLAG_RW,
3692     "I", "Jail cannot see all mounted file systems");
3693 SYSCTL_JAIL_PARAM(, devfs_ruleset, CTLTYPE_INT | CTLFLAG_RW,
3694     "I", "Ruleset for in-jail devfs mounts");
3695 SYSCTL_JAIL_PARAM(, persist, CTLTYPE_INT | CTLFLAG_RW,
3696     "B", "Jail persistence");
3697 #ifdef VIMAGE
3698 SYSCTL_JAIL_PARAM(, vnet, CTLTYPE_INT | CTLFLAG_RDTUN,
3699     "E,jailsys", "Virtual network stack");
3700 #endif
3701 SYSCTL_JAIL_PARAM(, dying, CTLTYPE_INT | CTLFLAG_RD,
3702     "B", "Jail is in the process of shutting down");
3703
3704 SYSCTL_JAIL_PARAM_NODE(children, "Number of child jails");
3705 SYSCTL_JAIL_PARAM(_children, cur, CTLTYPE_INT | CTLFLAG_RD,
3706     "I", "Current number of child jails");
3707 SYSCTL_JAIL_PARAM(_children, max, CTLTYPE_INT | CTLFLAG_RW,
3708     "I", "Maximum number of child jails");
3709
3710 SYSCTL_JAIL_PARAM_SYS_NODE(host, CTLFLAG_RW, "Jail host info");
3711 SYSCTL_JAIL_PARAM_STRING(_host, hostname, CTLFLAG_RW, MAXHOSTNAMELEN,
3712     "Jail hostname");
3713 SYSCTL_JAIL_PARAM_STRING(_host, domainname, CTLFLAG_RW, MAXHOSTNAMELEN,
3714     "Jail NIS domainname");
3715 SYSCTL_JAIL_PARAM_STRING(_host, hostuuid, CTLFLAG_RW, HOSTUUIDLEN,
3716     "Jail host UUID");
3717 SYSCTL_JAIL_PARAM(_host, hostid, CTLTYPE_ULONG | CTLFLAG_RW,
3718     "LU", "Jail host ID");
3719
3720 SYSCTL_JAIL_PARAM_NODE(cpuset, "Jail cpuset");
3721 SYSCTL_JAIL_PARAM(_cpuset, id, CTLTYPE_INT | CTLFLAG_RD, "I", "Jail cpuset ID");
3722
3723 #ifdef INET
3724 SYSCTL_JAIL_PARAM_SYS_NODE(ip4, CTLFLAG_RDTUN,
3725     "Jail IPv4 address virtualization");
3726 SYSCTL_JAIL_PARAM_STRUCT(_ip4, addr, CTLFLAG_RW, sizeof(struct in_addr),
3727     "S,in_addr,a", "Jail IPv4 addresses");
3728 SYSCTL_JAIL_PARAM(_ip4, saddrsel, CTLTYPE_INT | CTLFLAG_RW,
3729     "B", "Do (not) use IPv4 source address selection rather than the "
3730     "primary jail IPv4 address.");
3731 #endif
3732 #ifdef INET6
3733 SYSCTL_JAIL_PARAM_SYS_NODE(ip6, CTLFLAG_RDTUN,
3734     "Jail IPv6 address virtualization");
3735 SYSCTL_JAIL_PARAM_STRUCT(_ip6, addr, CTLFLAG_RW, sizeof(struct in6_addr),
3736     "S,in6_addr,a", "Jail IPv6 addresses");
3737 SYSCTL_JAIL_PARAM(_ip6, saddrsel, CTLTYPE_INT | CTLFLAG_RW,
3738     "B", "Do (not) use IPv6 source address selection rather than the "
3739     "primary jail IPv6 address.");
3740 #endif
3741
3742 SYSCTL_JAIL_PARAM_NODE(allow, "Jail permission flags");
3743 SYSCTL_JAIL_PARAM(_allow, set_hostname, CTLTYPE_INT | CTLFLAG_RW,
3744     "B", "Jail may set hostname");
3745 SYSCTL_JAIL_PARAM(_allow, sysvipc, CTLTYPE_INT | CTLFLAG_RW,
3746     "B", "Jail may use SYSV IPC");
3747 SYSCTL_JAIL_PARAM(_allow, raw_sockets, CTLTYPE_INT | CTLFLAG_RW,
3748     "B", "Jail may create raw sockets");
3749 SYSCTL_JAIL_PARAM(_allow, chflags, CTLTYPE_INT | CTLFLAG_RW,
3750     "B", "Jail may alter system file flags");
3751 SYSCTL_JAIL_PARAM(_allow, quotas, CTLTYPE_INT | CTLFLAG_RW,
3752     "B", "Jail may set file quotas");
3753 SYSCTL_JAIL_PARAM(_allow, socket_af, CTLTYPE_INT | CTLFLAG_RW,
3754     "B", "Jail may create sockets other than just UNIX/IPv4/IPv6/route");
3755 SYSCTL_JAIL_PARAM(_allow, reserved_ports, CTLTYPE_INT | CTLFLAG_RW,
3756     "B", "Jail may bind sockets to reserved ports");
3757
3758 SYSCTL_JAIL_PARAM_SUBNODE(allow, mount, "Jail mount/unmount permission flags");
3759 SYSCTL_JAIL_PARAM(_allow_mount, , CTLTYPE_INT | CTLFLAG_RW,
3760     "B", "Jail may mount/unmount jail-friendly file systems in general");
3761
3762 /*
3763  * The VFS system will register jail-aware filesystems here.  They each get
3764  * a parameter allow.mount.xxxfs and a flag to check when a jailed user
3765  * attempts to mount.
3766  */
3767 void
3768 prison_add_vfs(struct vfsconf *vfsp)
3769 {
3770         char *allow_name, *allow_noname, *mount_allowed;
3771         struct bool_flags *bf;
3772 #ifndef NO_SYSCTL_DESCR
3773         char *descr;
3774 #endif
3775         unsigned allow_flag;
3776
3777         if (asprintf(&allow_name, M_PRISON, "allow.mount.%s", vfsp->vfc_name) <
3778             0 || asprintf(&allow_noname, M_PRISON, "allow.mount.no%s",
3779             vfsp->vfc_name) < 0) {
3780                 free(allow_name, M_PRISON);
3781                 return;
3782         }
3783
3784         /*
3785          * See if this parameter has already beed added, i.e. if the filesystem
3786          * was previously loaded/unloaded.
3787          */
3788         mtx_lock(&prison0.pr_mtx);
3789         for (bf = pr_flag_allow;
3790              bf < pr_flag_allow + nitems(pr_flag_allow) && bf->flag != 0;
3791              bf++) {
3792                 if (strcmp(bf->name, allow_name) == 0) {
3793                         vfsp->vfc_prison_flag = bf->flag;
3794                         goto no_add;
3795                 }
3796         }
3797
3798         /*
3799          * Find a free bit in prison0's pr_allow, failing if there are none
3800          * (which shouldn't happen as long as we keep track of how many
3801          * filesystems are jail-aware).
3802          */
3803         for (allow_flag = 1;; allow_flag <<= 1) {
3804                 if (allow_flag == 0)
3805                         goto no_add;
3806                 if ((prison0.pr_allow & allow_flag) == 0)
3807                         break;
3808         }
3809
3810         /*
3811          * Note the parameter in the next open slot in pr_flag_allow.
3812          * Set the flag last so code that checks pr_flag_allow can do so
3813          * without locking.
3814          */
3815         for (bf = pr_flag_allow; bf->flag != 0; bf++)
3816                 if (bf == pr_flag_allow + nitems(pr_flag_allow)) {
3817                         /* This should never happen, but is not fatal. */
3818                         goto no_add;
3819                 }
3820         prison0.pr_allow |= allow_flag;
3821         bf->name = allow_name;
3822         bf->noname = allow_noname;
3823         bf->flag = allow_flag;
3824         vfsp->vfc_prison_flag = allow_flag;
3825         mtx_unlock(&prison0.pr_mtx);
3826
3827         /*
3828          * Create sysctls for the paramter, and the back-compat global
3829          * permission.
3830          */
3831 #ifndef NO_SYSCTL_DESCR
3832         (void)asprintf(&descr, M_TEMP, "Jail may mount the %s file system",
3833             vfsp->vfc_name);
3834 #endif
3835         (void)SYSCTL_ADD_PROC(NULL,
3836             SYSCTL_CHILDREN(&sysctl___security_jail_param_allow_mount),
3837             OID_AUTO, vfsp->vfc_name, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3838             NULL, 0, sysctl_jail_param, "B", descr);
3839 #ifndef NO_SYSCTL_DESCR
3840         free(descr, M_TEMP);
3841 #endif
3842         if (asprintf(&mount_allowed, M_TEMP, "mount_%s_allowed",
3843                 vfsp->vfc_name) >= 0) {
3844 #ifndef NO_SYSCTL_DESCR
3845                 (void)asprintf(&descr, M_TEMP,
3846                   "Processes in jail can mount the %s file system (deprecated)",
3847                   vfsp->vfc_name);
3848 #endif
3849                 (void)SYSCTL_ADD_PROC(NULL,
3850                     SYSCTL_CHILDREN(&sysctl___security_jail), OID_AUTO,
3851                     mount_allowed, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
3852                     NULL, allow_flag, sysctl_jail_default_allow, "I", descr);
3853 #ifndef NO_SYSCTL_DESCR
3854                 free(descr, M_TEMP);
3855 #endif
3856                 free(mount_allowed, M_TEMP);
3857         }
3858         return;
3859
3860  no_add:
3861         mtx_unlock(&prison0.pr_mtx);
3862         free(allow_name, M_PRISON);
3863         free(allow_noname, M_PRISON);
3864 }
3865
3866 #ifdef RACCT
3867 void
3868 prison_racct_foreach(void (*callback)(struct racct *racct,
3869     void *arg2, void *arg3), void (*pre)(void), void (*post)(void),
3870     void *arg2, void *arg3)
3871 {
3872         struct prison_racct *prr;
3873
3874         ASSERT_RACCT_ENABLED();
3875
3876         sx_slock(&allprison_lock);
3877         if (pre != NULL)
3878                 (pre)();
3879         LIST_FOREACH(prr, &allprison_racct, prr_next)
3880                 (callback)(prr->prr_racct, arg2, arg3);
3881         if (post != NULL)
3882                 (post)();
3883         sx_sunlock(&allprison_lock);
3884 }
3885
3886 static struct prison_racct *
3887 prison_racct_find_locked(const char *name)
3888 {
3889         struct prison_racct *prr;
3890
3891         ASSERT_RACCT_ENABLED();
3892         sx_assert(&allprison_lock, SA_XLOCKED);
3893
3894         if (name[0] == '\0' || strlen(name) >= MAXHOSTNAMELEN)
3895                 return (NULL);
3896
3897         LIST_FOREACH(prr, &allprison_racct, prr_next) {
3898                 if (strcmp(name, prr->prr_name) != 0)
3899                         continue;
3900
3901                 /* Found prison_racct with a matching name? */
3902                 prison_racct_hold(prr);
3903                 return (prr);
3904         }
3905
3906         /* Add new prison_racct. */
3907         prr = malloc(sizeof(*prr), M_PRISON_RACCT, M_ZERO | M_WAITOK);
3908         racct_create(&prr->prr_racct);
3909
3910         strcpy(prr->prr_name, name);
3911         refcount_init(&prr->prr_refcount, 1);
3912         LIST_INSERT_HEAD(&allprison_racct, prr, prr_next);
3913
3914         return (prr);
3915 }
3916
3917 struct prison_racct *
3918 prison_racct_find(const char *name)
3919 {
3920         struct prison_racct *prr;
3921
3922         ASSERT_RACCT_ENABLED();
3923
3924         sx_xlock(&allprison_lock);
3925         prr = prison_racct_find_locked(name);
3926         sx_xunlock(&allprison_lock);
3927         return (prr);
3928 }
3929
3930 void
3931 prison_racct_hold(struct prison_racct *prr)
3932 {
3933
3934         ASSERT_RACCT_ENABLED();
3935
3936         refcount_acquire(&prr->prr_refcount);
3937 }
3938
3939 static void
3940 prison_racct_free_locked(struct prison_racct *prr)
3941 {
3942
3943         ASSERT_RACCT_ENABLED();
3944         sx_assert(&allprison_lock, SA_XLOCKED);
3945
3946         if (refcount_release(&prr->prr_refcount)) {
3947                 racct_destroy(&prr->prr_racct);
3948                 LIST_REMOVE(prr, prr_next);
3949                 free(prr, M_PRISON_RACCT);
3950         }
3951 }
3952
3953 void
3954 prison_racct_free(struct prison_racct *prr)
3955 {
3956         int old;
3957
3958         ASSERT_RACCT_ENABLED();
3959         sx_assert(&allprison_lock, SA_UNLOCKED);
3960
3961         old = prr->prr_refcount;
3962         if (old > 1 && atomic_cmpset_int(&prr->prr_refcount, old, old - 1))
3963                 return;
3964
3965         sx_xlock(&allprison_lock);
3966         prison_racct_free_locked(prr);
3967         sx_xunlock(&allprison_lock);
3968 }
3969
3970 static void
3971 prison_racct_attach(struct prison *pr)
3972 {
3973         struct prison_racct *prr;
3974
3975         ASSERT_RACCT_ENABLED();
3976         sx_assert(&allprison_lock, SA_XLOCKED);
3977
3978         prr = prison_racct_find_locked(pr->pr_name);
3979         KASSERT(prr != NULL, ("cannot find prison_racct"));
3980
3981         pr->pr_prison_racct = prr;
3982 }
3983
3984 /*
3985  * Handle jail renaming.  From the racct point of view, renaming means
3986  * moving from one prison_racct to another.
3987  */
3988 static void
3989 prison_racct_modify(struct prison *pr)
3990 {
3991         struct proc *p;
3992         struct ucred *cred;
3993         struct prison_racct *oldprr;
3994
3995         ASSERT_RACCT_ENABLED();
3996
3997         sx_slock(&allproc_lock);
3998         sx_xlock(&allprison_lock);
3999
4000         if (strcmp(pr->pr_name, pr->pr_prison_racct->prr_name) == 0) {
4001                 sx_xunlock(&allprison_lock);
4002                 sx_sunlock(&allproc_lock);
4003                 return;
4004         }
4005
4006         oldprr = pr->pr_prison_racct;
4007         pr->pr_prison_racct = NULL;
4008
4009         prison_racct_attach(pr);
4010
4011         /*
4012          * Move resource utilisation records.
4013          */
4014         racct_move(pr->pr_prison_racct->prr_racct, oldprr->prr_racct);
4015
4016 #ifdef RCTL
4017         /*
4018          * Force rctl to reattach rules to processes.
4019          */
4020         FOREACH_PROC_IN_SYSTEM(p) {
4021                 PROC_LOCK(p);
4022                 cred = crhold(p->p_ucred);
4023                 PROC_UNLOCK(p);
4024                 rctl_proc_ucred_changed(p, cred);
4025                 crfree(cred);
4026         }
4027 #endif
4028
4029         sx_sunlock(&allproc_lock);
4030         prison_racct_free_locked(oldprr);
4031         sx_xunlock(&allprison_lock);
4032 }
4033
4034 static void
4035 prison_racct_detach(struct prison *pr)
4036 {
4037
4038         ASSERT_RACCT_ENABLED();
4039         sx_assert(&allprison_lock, SA_UNLOCKED);
4040
4041         if (pr->pr_prison_racct == NULL)
4042                 return;
4043         prison_racct_free(pr->pr_prison_racct);
4044         pr->pr_prison_racct = NULL;
4045 }
4046 #endif /* RACCT */
4047
4048 #ifdef DDB
4049
4050 static void
4051 db_show_prison(struct prison *pr)
4052 {
4053         struct bool_flags *bf;
4054         struct jailsys_flags *jsf;
4055 #if defined(INET) || defined(INET6)
4056         int ii;
4057 #endif
4058         unsigned f;
4059 #ifdef INET
4060         char ip4buf[INET_ADDRSTRLEN];
4061 #endif
4062 #ifdef INET6
4063         char ip6buf[INET6_ADDRSTRLEN];
4064 #endif
4065
4066         db_printf("prison %p:\n", pr);
4067         db_printf(" jid             = %d\n", pr->pr_id);
4068         db_printf(" name            = %s\n", pr->pr_name);
4069         db_printf(" parent          = %p\n", pr->pr_parent);
4070         db_printf(" ref             = %d\n", pr->pr_ref);
4071         db_printf(" uref            = %d\n", pr->pr_uref);
4072         db_printf(" path            = %s\n", pr->pr_path);
4073         db_printf(" cpuset          = %d\n", pr->pr_cpuset
4074             ? pr->pr_cpuset->cs_id : -1);
4075 #ifdef VIMAGE
4076         db_printf(" vnet            = %p\n", pr->pr_vnet);
4077 #endif
4078         db_printf(" root            = %p\n", pr->pr_root);
4079         db_printf(" securelevel     = %d\n", pr->pr_securelevel);
4080         db_printf(" devfs_rsnum     = %d\n", pr->pr_devfs_rsnum);
4081         db_printf(" children.max    = %d\n", pr->pr_childmax);
4082         db_printf(" children.cur    = %d\n", pr->pr_childcount);
4083         db_printf(" child           = %p\n", LIST_FIRST(&pr->pr_children));
4084         db_printf(" sibling         = %p\n", LIST_NEXT(pr, pr_sibling));
4085         db_printf(" flags           = 0x%x", pr->pr_flags);
4086         for (bf = pr_flag_bool; bf < pr_flag_bool + nitems(pr_flag_bool); bf++)
4087                 if (pr->pr_flags & bf->flag)
4088                         db_printf(" %s", bf->name);
4089         for (jsf = pr_flag_jailsys;
4090              jsf < pr_flag_jailsys + nitems(pr_flag_jailsys);
4091              jsf++) {
4092                 f = pr->pr_flags & (jsf->disable | jsf->new);
4093                 db_printf(" %-16s= %s\n", jsf->name,
4094                     (f != 0 && f == jsf->disable) ? "disable"
4095                     : (f == jsf->new) ? "new"
4096                     : "inherit");
4097         }
4098         db_printf(" allow           = 0x%x", pr->pr_allow);
4099         for (bf = pr_flag_allow;
4100              bf < pr_flag_allow + nitems(pr_flag_allow) && bf->flag != 0;
4101              bf++)
4102                 if (pr->pr_allow & bf->flag)
4103                         db_printf(" %s", bf->name);
4104         db_printf("\n");
4105         db_printf(" enforce_statfs  = %d\n", pr->pr_enforce_statfs);
4106         db_printf(" host.hostname   = %s\n", pr->pr_hostname);
4107         db_printf(" host.domainname = %s\n", pr->pr_domainname);
4108         db_printf(" host.hostuuid   = %s\n", pr->pr_hostuuid);
4109         db_printf(" host.hostid     = %lu\n", pr->pr_hostid);
4110 #ifdef INET
4111         db_printf(" ip4s            = %d\n", pr->pr_ip4s);
4112         for (ii = 0; ii < pr->pr_ip4s; ii++)
4113                 db_printf(" %s %s\n",
4114                     ii == 0 ? "ip4.addr        =" : "                 ",
4115                     inet_ntoa_r(pr->pr_ip4[ii], ip4buf));
4116 #endif
4117 #ifdef INET6
4118         db_printf(" ip6s            = %d\n", pr->pr_ip6s);
4119         for (ii = 0; ii < pr->pr_ip6s; ii++)
4120                 db_printf(" %s %s\n",
4121                     ii == 0 ? "ip6.addr        =" : "                 ",
4122                     ip6_sprintf(ip6buf, &pr->pr_ip6[ii]));
4123 #endif
4124 }
4125
4126 DB_SHOW_COMMAND(prison, db_show_prison_command)
4127 {
4128         struct prison *pr;
4129
4130         if (!have_addr) {
4131                 /*
4132                  * Show all prisons in the list, and prison0 which is not
4133                  * listed.
4134                  */
4135                 db_show_prison(&prison0);
4136                 if (!db_pager_quit) {
4137                         TAILQ_FOREACH(pr, &allprison, pr_list) {
4138                                 db_show_prison(pr);
4139                                 if (db_pager_quit)
4140                                         break;
4141                         }
4142                 }
4143                 return;
4144         }
4145
4146         if (addr == 0)
4147                 pr = &prison0;
4148         else {
4149                 /* Look for a prison with the ID and with references. */
4150                 TAILQ_FOREACH(pr, &allprison, pr_list)
4151                         if (pr->pr_id == addr && pr->pr_ref > 0)
4152                                 break;
4153                 if (pr == NULL)
4154                         /* Look again, without requiring a reference. */
4155                         TAILQ_FOREACH(pr, &allprison, pr_list)
4156                                 if (pr->pr_id == addr)
4157                                         break;
4158                 if (pr == NULL)
4159                         /* Assume address points to a valid prison. */
4160                         pr = (struct prison *)addr;
4161         }
4162         db_show_prison(pr);
4163 }
4164
4165 #endif /* DDB */