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