sys/kern/kern_jail.c

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