libzonecfg.c revision 4656d4747c8743290bfbe910c64cd75eb4e4af8d
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * CDDL HEADER START
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * The contents of this file are subject to the terms of the
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * Common Development and Distribution License (the "License").
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * You may not use this file except in compliance with the License.
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * See the License for the specific language governing permissions
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * and limitations under the License.
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * When distributing Covered Code, include this CDDL HEADER in each
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * If applicable, add the following below this CDDL HEADER, with the
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * fields enclosed by brackets "[]" replaced with your own identifying
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * information: Portions Copyright [yyyy] [name of copyright owner]
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * CDDL HEADER END
a192e900f6d2b0e1a822e3252c0dfd795ed49d76amaguire * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
#include <libzonecfg.h>
#include "zonecfg_impl.h"
static struct alias {
char *shortname;
char *realname;
char *priv;
char *action;
} aliases[] = {
typedef struct pr_info_handle {
struct zone_dochandle {
char *zone_dh_rootdir;
struct znotify {
void * zn_private;
int zn_failure_count;
static int zone_lock_cnt = 0;
* the return values should be from the Z_foo set defined in <libzonecfg.h>.
zonecfg_get_root(void)
return (zonecfg_root);
zonecfg_in_alt_root(void)
static boolean_t
static boolean_t
zonecfg_init_handle(void)
return (NULL);
(void) xmlKeepBlanksDefault(0);
return (handle);
return (Z_BAD_HANDLE);
return (Z_OK);
return (Z_ACCES);
return (Z_NO_ZONE);
return (Z_MISC_FS);
return (Z_OK);
return (Z_MISC_FS);
return (Z_NO_ZONE);
return (Z_ACCES);
else if (!force)
return (Z_MISC_FS);
return (Z_BAD_ZONE_STATE);
return (Z_BAD_ZONE_STATE);
if (!force)
return (err);
return (Z_OK);
return (err);
return (Z_MISC_FS);
return (Z_BAD_HANDLE);
return (Z_EMPTY_DOCUMENT);
return (Z_WRONG_DOC_TYPE);
return (Z_OK);
int err;
return (err);
return (Z_OK);
return (Z_BAD_PROPERTY);
return (Z_TOO_BIG);
return (Z_OK);
return (Z_BAD_PROPERTY);
return (Z_NOMEM);
return (Z_OK);
int err;
return (err);
char **propval)
int err;
return (err);
const char *propval)
int err;
return (err);
== NULL)
return (Z_INVAL);
return (Z_OK);
int valid;
return (Z_NO_ZONE);
return (Z_INVALID_DOCUMENT);
return (Z_NO_ZONE);
return (Z_NOMEM);
if (valid == 0)
return (Z_INVALID_DOCUMENT);
return (Z_OK);
return (Z_MISC_FS);
int err;
sizeof (migpath))
return (Z_NOMEM);
return (Z_NO_ZONE);
sizeof (migpath))
return (Z_NOMEM);
return (err);
if (!preserve_sw)
return (err);
return (Z_MISC_FS);
int err;
return (Z_MISC_FS);
return (err);
int err;
return (Z_MISC_FS);
return (err);
return (Z_OK);
int valid;
return (Z_INVALID_DOCUMENT);
return (Z_NOMEM);
if (valid == 0)
return (Z_INVALID_DOCUMENT);
return (Z_INVALID_DOCUMENT);
return (Z_NOMEM);
if (valid == 0)
return (Z_INVALID_DOCUMENT);
return (Z_OK);
static boolean_t
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
static boolean_t
static boolean_t
return (Z_BOGUS_ZONE_NAME);
return (Z_BOGUS_ZONE_NAME);
return (Z_BOGUS_ZONE_NAME);
return (Z_BOGUS_ZONE_NAME);
return (Z_OK);
int err;
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (Z_OK);
return (Z_BOGUS_ZONE_NAME);
return (err);
return (err);
return (Z_NAME_IN_USE);
sizeof (old_delname));
return (Z_BAD_ZONE_STATE);
return (err);
return (Z_BAD_ZONE_STATE);
return (err);
return (err);
return (err);
return (Z_OK);
return (Z_TOO_BIG);
char last_copied;
int ret;
return (Z_NOMEM);
copy_mp++;
copy_mp--;
return (Z_BAD_PROPERTY);
return (ret);
return (ret);
if (!default_query) {
return (Z_TOO_BIG);
return (Z_OK);
int ret;
return (ret);
return (ret);
int err;
int opcode;
char *zn;
return (err);
return (err);
return (err);
return (Z_OK);
* Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml)
* If it fails, delete foo.xml, leaving nothing behind.
* Make backup of foo.xml -> .backup
* Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml)
* If it fails, recover from .backup -> foo.xml
* Rename tmpfile to xmlfile (zonecfg.xxxxxx -> bar.xml)
return (Z_TEMP_FILE);
goto err;
return (Z_ACCES);
return (Z_MISC_FS);
* i.e.: zonecfg.XXXXXX -> myzone.xml
if (backup)
return (Z_ACCES);
return (Z_MISC_FS);
return (Z_OK);
if (backup) {
* new.xml, or we're doing a rename, so ditto.
return (Z_UPDATING_INDEX);
if (backup)
return (Z_OK);
err:
return (Z_SAVING_FILE);
return (Z_BAD_HANDLE);
return (Z_INVAL);
return (err);
return (Z_MISC_FS);
return (err);
return (Z_OK);
int valid;
return (Z_BAD_HANDLE);
return (Z_SAVING_FILE);
return (Z_OK);
int valid;
return (Z_BAD_HANDLE);
!= Z_OK)
return (err);
!= Z_OK)
return (err);
return (Z_NOMEM);
return (err);
return (Z_SAVING_FILE);
return (Z_OK);
sizeof (migpath))
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
if (forced) {
return (Z_INVAL);
return (Z_OK);
return (Z_INVAL);
return (Z_OK);
return (Z_ACCES);
return (Z_INVAL);
return (Z_MISC_FS);
return (Z_NOMEM);
goto out;
goto out;
goto out;
goto out;
goto out;
goto out;
goto out;
goto out;
out:
return (error);
int err;
return (Z_OK);
return (err);
return (Z_INVAL);
return (Z_OK);
return (Z_INVAL);
return (Z_EMPTY_DOCUMENT);
return (Z_WRONG_DOC_TYPE);
switch (iptype) {
case ZS_SHARED:
case ZS_EXCLUSIVE:
return (Z_INVAL);
return (Z_OK);
return (Z_BAD_PROPERTY);
return (Z_OK);
int err;
return (err);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
return (Z_NOMEM);
return (Z_OK);
return (Z_OK);
return (Z_NO_PROPERTY_ID);
static boolean_t
int prop_result;
return (B_FALSE);
return ((prop_result == 0));
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (Z_INSUFFICIENT_SPEC);
special) == 0) {
return (Z_INSUFFICIENT_SPEC);
return (Z_INSUFFICIENT_SPEC);
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int result;
return (B_TRUE);
return (B_FALSE);
return ((result == 0));
return (Z_IPV6_ADDR_PREFIX_LEN);
return (Z_BOGUS_ADDRESS);
sizeof (struct in_addr));
return (Z_OK);
int so;
int save_errno;
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
int err;
return (Z_INVAL);
allowed_addrspec == 0)
return (Z_INSUFFICIENT_SPEC);
return (err);
return (err);
address)))
address)))
address)))
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
return (Z_TOO_BIG);
p = cp;
if (!isalnum(*p))
return (Z_INVALID_PROPERTY);
if (p == cp)
return (Z_INVALID_PROPERTY);
return (Z_INVALID_PROPERTY);
cp = p;
return (Z_OK);
int err;
return (err);
return (Z_BAD_PROPERTY);
int err;
return (err);
char *currentp;
return (Z_INVAL);
return (Z_INVALID_PROPERTY);
return (Z_INVALID_PROPERTY);
return (Z_TOO_BIG);
return (Z_INVALID_PROPERTY);
return (Z_OK);
int err;
return (err);
return (Z_BAD_PROPERTY);
int err;
return (err);
int err;
return (Z_INVAL);
return (err);
match) == 0) {
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (Z_OK);
int err;
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int match_match;
if (match_match) {
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
char *zonename)
int err;
return (err);
return (err);
return (err);
return (Z_OK);
char *zonename)
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
char *zonename)
int err;
if (auth_match) {
return (err);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
char *zonename)
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
!= Z_OK)
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int ret;
return (ret);
return (Z_TOO_BIG);
return (Z_OK);
int ret;
return (ret);
return (Z_TOO_BIG);
return (Z_TOO_BIG);
return (Z_INVAL);
return (Z_INVAL);
return (Z_SYSTEM);
return (Z_SYSTEM);
return (Z_OK);
return (Z_SYSTEM);
errno = 0;
return (Z_SYSTEM);
return (Z_OK);
void *), void *priv) {
struct mnttab m;
size_t l;
int zfsl;
int rv = 0;
>= sizeof (zfs_path))
goto out;
rv++;
goto out;
out:
return (rv);
int err;
return (Z_INVAL);
return (err);
return (Z_INSUFFICIENT_SPEC);
return (Z_INSUFFICIENT_SPEC);
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
return (Z_INVAL);
return (Z_INVAL);
return (Z_OK);
return (Z_OK);
return (Z_INVAL);
long long result;
char *endptr;
return (Z_INVAL);
return (Z_INVAL);
errno = 0;
return (Z_INVAL);
return (Z_OK);
return (Z_INVAL);
return (Z_INVAL);
return (Z_TOO_BIG);
return (Z_OK);
unsigned long long result;
long long neg_result;
char *endptr;
return (Z_INVAL);
return (Z_INVAL);
errno = 0;
return (Z_INVAL);
errno = 0;
return (Z_INVAL);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
sizeof (struct zone_rctlvaltab));
return (Z_NOMEM);
Z_OK))
Z_OK))
Z_OK))
Z_OK)
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int name_result;
if (name_result == 0) {
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
return (Z_INVAL);
return (Z_INVAL);
return (Z_OK);
return (Z_OK);
return (Z_NO_PROPERTY_ID);
int err;
return (err);
return (err);
return (err);
return (Z_OK);
switch (errnum) {
case Z_OK:
case Z_EMPTY_DOCUMENT:
case Z_WRONG_DOC_TYPE:
case Z_BAD_PROPERTY:
case Z_TEMP_FILE:
case Z_SAVING_FILE:
case Z_NO_ENTRY:
case Z_BOGUS_ZONE_NAME:
case Z_REQD_RESOURCE_MISSING:
case Z_REQD_PROPERTY_MISSING:
case Z_BAD_HANDLE:
case Z_NOMEM:
case Z_INVAL:
case Z_ACCES:
case Z_TOO_BIG:
case Z_MISC_FS:
case Z_NO_ZONE:
case Z_NO_RESOURCE_TYPE:
case Z_NO_RESOURCE_ID:
case Z_NO_PROPERTY_TYPE:
case Z_NO_PROPERTY_ID:
case Z_BAD_ZONE_STATE:
case Z_INVALID_DOCUMENT:
case Z_NAME_IN_USE:
case Z_NO_SUCH_ID:
case Z_UPDATING_INDEX:
case Z_LOCKING_FILE:
case Z_UNLOCKING_FILE:
case Z_INSUFFICIENT_SPEC:
case Z_RESOLVED_PATH:
case Z_IPV6_ADDR_PREFIX_LEN:
case Z_BOGUS_ADDRESS:
case Z_PRIV_PROHIBITED:
case Z_PRIV_REQUIRED:
case Z_PRIV_UNKNOWN:
case Z_BRAND_ERROR:
case Z_INCOMPATIBLE:
case Z_ALIAS_DISALLOW:
case Z_CLEAR_DISALLOW:
case Z_POOL:
case Z_POOLS_NOT_ACTIVE:
case Z_POOL_ENABLE:
case Z_NO_POOL:
case Z_POOL_CREATE:
case Z_POOL_BIND:
case Z_INVALID_PROPERTY:
case Z_SYSTEM:
int err;
return (Z_INVAL);
return (err);
return (Z_OK);
return (Z_INVAL);
return (Z_OK);
int ret;
static boolean_t
int pid_self;
return (B_FALSE);
return (B_FALSE);
if (grab_process(p) != 0)
return (B_TRUE);
return (B_FALSE);
static boolean_t
return (B_FALSE);
return (B_TRUE);
return (B_TRUE);
return (B_FALSE);
int err;
return (err);
return (Z_NOMEM);
return (Z_SYSTEM);
char *rname;
goto done;
!= Z_OK) {
goto done;
goto done;
done:
return (res);
static const xmlChar *
return (DTD_ELEM_DEVICE);
return (DTD_ELEM_FS);
return (DTD_ELEM_NET);
return (DTD_ELEM_ATTR);
return (DTD_ELEM_RCTL);
return (DTD_ELEM_DATASET);
return (DTD_ELEM_ADMIN);
return (NULL);
int num = 0;
return (num);
return (num);
num++;
return (num);
int err;
return (Z_NO_RESOURCE_TYPE);
return (err);
return (Z_OK);
static boolean_t
char *endp;
return (B_FALSE);
errno = 0;
return (B_FALSE);
return (B_TRUE);
long double val;
char *unitp;
++unitp;
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
return (B_TRUE);
return (res);
return (Z_OK);
return (res);
goto done;
goto done;
goto done;
!= PO_SUCCESS) {
goto done;
goto done;
goto done;
goto done;
done:
return (res);
int nfound = 0;
!= POC_INVAL) {
nfound++;
nfound++;
nfound++;
return (PO_SUCCESS);
return (PO_FAIL);
!= PO_SUCCESS) {
return (res);
goto done;
== PO_SUCCESS &&
goto done;
goto done;
done:
return (res);
int status;
return (Z_OK);
!= PO_SUCCESS) {
return (res);
goto done;
goto done;
goto done;
done:
return (res);
int err_size)
int err;
int status;
return (Z_OK);
return (Z_POOL_ENABLE);
return (err);
if (!exists)
&pset_tab);
return (err);
return (Z_OK);
int err_size)
int status;
int error;
return (Z_OK);
return (Z_OK);
return (Z_POOLS_NOT_ACTIVE);
PO_SUCCESS) {
return (Z_NO_POOL);
return (Z_POOL_BIND);
return (Z_OK);
int err;
return (err);
return (Z_OK);
static boolean_t
return (found);
return (Z_SYSTEM);
return (Z_OK);
int err;
return (B_FALSE);
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
int status;
const char *sched_str;
return (Z_NO_POOL);
return (Z_NO_POOL);
PO_SUCCESS) {
return (Z_NO_POOL);
return (Z_NO_POOL);
POC_STRING) {
return (Z_NO_ENTRY);
return (Z_TOO_BIG);
return (Z_OK);
return (Z_OK);
return (Z_TOO_BIG);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
sizeof (struct zone_rctlvaltab));
return (Z_NOMEM);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (err);
return (Z_OK);
typedef struct priv_node {
} priv_node_t;
typedef struct priv_lists {
const char *pl_iptype;
} priv_lists_t;
const char *curr_iptype)
return (Z_BRAND_ERROR);
return (Z_BRAND_ERROR);
return (Z_NOMEM);
return (Z_BRAND_ERROR);
return (Z_OK);
return (Z_INVAL);
return (Z_OK);
int ret;
if (ret < 0)
return (Z_OK);
return (Z_NOMEM);
return (ret);
return (ret);
int ret;
return (ret);
return (ret);
return (ret);
const char *token;
return (Z_NOMEM);
return (Z_NOMEM);
return (Z_PRIV_UNKNOWN);
if (add_default) {
return (Z_NOMEM);
return (Z_NOMEM);
return (Z_PRIV_UNKNOWN);
return (Z_NOMEM);
return (Z_PRIV_PROHIBITED);
return (Z_NOMEM);
return (Z_PRIV_REQUIRED);
return (Z_OK);
char **privname)
const char *curr_iptype;
return (err);
return (err);
switch (iptype) {
case ZS_SHARED:
case ZS_EXCLUSIVE:
return (err);
return (err);
return (err);
int err;
char *cp;
return (Z_INVAL);
return (Z_OK);
if (found)
return (Z_OK);
return (Z_NOMEM);
return (err);
return (err);
int err;
return (Z_BOGUS_ZONE_NAME);
return (err);
return (Z_TOO_BIG);
return (Z_OK);
int err;
if (is_system_labeled()) {
return (Z_OK);
sizeof (myzone)) < 0)
return (Z_NO_ZONE);
return (Z_NO_ZONE);
if (err < 0)
return (Z_OK);
return (Z_NOMEM);
return (err);
int err;
char *suffix;
return (Z_BOGUS_ZONE_NAME);
return (err);
return (Z_TOO_BIG);
return (Z_OK);
static zone_state_t
switch (kernel_state) {
case ZONE_IS_UNINITIALIZED:
case ZONE_IS_INITIALIZED:
return (ZONE_STATE_READY);
case ZONE_IS_READY:
sizeof (zoneroot)) >= 0) {
return (ZONE_STATE_MOUNTED);
return (ZONE_STATE_READY);
case ZONE_IS_BOOTING:
case ZONE_IS_RUNNING:
return (ZONE_STATE_RUNNING);
case ZONE_IS_SHUTTING_DOWN:
case ZONE_IS_EMPTY:
return (ZONE_STATE_SHUTTING_DOWN);
case ZONE_IS_DOWN:
case ZONE_IS_DYING:
case ZONE_IS_DEAD:
return (ZONE_STATE_DOWN);
return (Z_INVAL);
sizeof (status)) >= 0) {
return (Z_OK);
if (found)
return (Z_INVAL);
char *cp;
int err;
errno = 0;
err = 0;
return (err);
switch (state_num) {
case ZONE_STATE_CONFIGURED:
return (ZONE_STATE_STR_CONFIGURED);
case ZONE_STATE_INCOMPLETE:
return (ZONE_STATE_STR_INCOMPLETE);
case ZONE_STATE_INSTALLED:
return (ZONE_STATE_STR_INSTALLED);
case ZONE_STATE_READY:
return (ZONE_STATE_STR_READY);
case ZONE_STATE_MOUNTED:
return (ZONE_STATE_STR_MOUNTED);
case ZONE_STATE_RUNNING:
return (ZONE_STATE_STR_RUNNING);
case ZONE_STATE_SHUTTING_DOWN:
return (ZONE_STATE_STR_SHUTTING_DOWN);
case ZONE_STATE_DOWN:
return (ZONE_STATE_STR_DOWN);
return (Z_NO_ZONE);
return (Z_NO_ZONE);
return (Z_OK);
return (Z_NO_ZONE);
return (Z_NO_ZONE);
return (Z_OK);
return (Z_NO_ZONE);
return (B_FALSE);
return (B_TRUE);
unsigned long long ull;
char *endp;
return (Z_INVAL);
return (Z_INVAL);
errno = 0;
return (Z_INVAL);
return (Z_INVAL);
return (Z_OK);
return (B_FALSE);
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
return (B_FALSE);
return (B_FALSE);
return (B_FALSE);
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
if (*in == 0)
return (NULL);
return (in);
static boolean_t
ZONE_EVENT_PING_SUBCLASS) == 0) {
return (B_TRUE);
return (B_FALSE);
static boolean_t
const char *sender;
return (B_FALSE);
return (B_FALSE);
return (B_TRUE);
nvlist_t *l;
int zid;
char *zonename;
char *newstate;
char *oldstate;
int ret;
ZONE_EVENT_STATUS_SUBCLASS) == 0) {
return (EAGAIN);
ret = 0;
nvlist_free(l);
return (ret);
int error;
return (error);
abort();
zonecfg_notify_critical_enter(void *h)
zonecfg_notify_critical_exit(void * h)
zonecfg_notify_critical_abort(void *h)
return (NULL);
goto out3;
goto out3;
goto out3;
goto out2;
goto out1;
zevtchan, 0);
return (zevtchan);
out1:
out2:
out3:
return (NULL);
int ret;
if (ret)
abort();
int err;
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
dataset) == 0)) {
return (Z_INSUFFICIENT_SPEC);
return (Z_NO_RESOURCE_ID);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (Z_OK);
int err;
return (Z_NO_PROPERTY_ID);
return (err);
if (found)
return (Z_ALIAS_DISALLOW);
if (found_val)
return (Z_ALIAS_DISALLOW);
return (Z_ALIAS_DISALLOW);
if (found) {
return (Z_OK);
return (Z_NO_ENTRY);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
case Z_OK:
case Z_NO_ENTRY:
return (B_TRUE);
return (B_FALSE);
int err;
return (Z_ALIAS_DISALLOW);
return (Z_NO_RESOURCE_ID);
return (Z_NOMEM);
return (err);
int err;
return (err);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
return (res);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (err);
return (err);
return (res);
int err;
return (err);
return (err);
int err;
!= Z_OK)
return (err);
return (Z_OK);
int err;
return (err);
return (Z_OK);
return (Z_NO_RESOURCE_ID);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
int err;
return (Z_INVAL);
return (err);
return (err);
return (Z_OK);
return (Z_NO_ENTRY);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (Z_OK);
int err;
return (err);
return (err);
int res;
return (Z_INVAL);
return (res);
goto done;
goto done;
goto done;
goto done;
goto done;
goto done;
done:
return (res);
int err;
return (Z_INVAL);
return (Z_NO_ENTRY);
return (Z_NO_ENTRY);
return (err);
return (err);
return (err);
return (err);
return (err);
return (Z_OK);
if (zone_lock_cnt > 0) {
if (--zone_lock_cnt > 0) {
if (zone_lock_cnt > 0) {
return (Z_OK);
return (Z_OK);
return (B_TRUE);
return (B_FALSE);
static boolean_t
if (lock)
goto out;
goto out;
goto out;
if (child_pid == 0) {
if (zonecfg_in_alt_root()) {
int pstatus = 0;
goto out;
out:
if (lock)
return (error);
int doorfd;
return (Z_OK);
sizeof (uniqid));
return (result);
char *right;
char *tmpauths;
char *lasts;
return (B_FALSE);
right);
return (status);
int err;
return (err);
zonename);
return (err);
return (err);
static boolean_t
char *suffix;
return (B_TRUE);
return (B_TRUE);
return (B_FALSE);
char *authlist;
char *lasts;
int err;
return (Z_ACCES);
return (Z_NO_ZONE);
return (Z_MISC_FS);
return (Z_MISC_FS);
return (Z_MISC_FS);
return (Z_MISC_FS);
return (Z_NO_ENTRY);
return (err);
char *cur_auth;
NULL)) {
if (first) {
(void) strlcat(
(void) strlcat(
if (!first) {
return (err);
char *cur_prof;
char *lasts;
if (!add) {
if (first) {
MAXPROFS);
MAXPROFS);
if (!first)
int status;
char *right;
char *lasts;
userattr_t *u;
char *current_auths;
char *current_profs;
char *type;
char *cur_auth;
char *delete_name;
delete_name)) {
if (first) {
MAXAUTHS);
MAXAUTHS);
new_auth_cnt++;
free_userattr(u);
if (!first)
if (first) {
new_auth_cnt--;
if ((new_auth_cnt != 0) ||
char *cmdbuf;
return (Z_NOMEM);
return (Z_SYSTEM);
return (Z_OK);
int err;
return (err);
!= Z_OK)
return (Z_SYSTEM);
return (Z_OK);
int err;
return (err);
return (err);
return (Z_OK);
while (next) {
ZONENAME_MAX) == 0)) {
return (Z_OK);
return (Z_NOMEM);
return (Z_OK);
while (next) {
if (deauthorize)
return (Z_OK);