usr/src/lib/libc/amd64/sys/uadmin.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27
  28 /*
  29  * Wrapper function to implement reboot w/ arguments on x86
  30  * platforms. Extract reboot arguments and place them in
  31  * in a transient entry. All other commands are passed through.
  32  */
  33
  34 #include "lint.h"
  35 #include "mtlib.h"
  36 #include <fcntl.h>
  37 #include <ctype.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/uadmin.h>
  43 #include <unistd.h>
  44 #include <strings.h>
  45 #include <pthread.h>
  46 #include <zone.h>
  47 #include <libscf.h>
  48 #include <thread.h>
  49 #include <dlfcn.h>
  50 #include <atomic.h>
  51
  52 /*
  53  * Pull in the following three interfaces from libscf without introducing
  54  * a dependency on it, which since libscf depends on libc would be circular:
  55  *
  56  * scf_simple_prop_get
  57  * scf_simple_prop_next_boolean
  58  * scf_simple_prop_free
  59  */
  60 typedef scf_simple_prop_t *(*scf_simple_prop_get_t)(scf_handle_t *,
  61     const char *, const char *, const char *);
  62 static scf_simple_prop_get_t real_scf_simple_prop_get = NULL;
  63 typedef uint8_t *(*scf_simple_prop_next_boolean_t)(scf_simple_prop_t *);
  64 static scf_simple_prop_next_boolean_t real_scf_simple_prop_next_boolean = NULL;
  65 typedef void (*scf_simple_prop_free_t)(scf_simple_prop_t *);
  66 static scf_simple_prop_free_t real_scf_simple_prop_free = NULL;
  67 static mutex_t scf_lock = DEFAULTMUTEX;
  68
  69 static void
  70 load_scf(void)
  71 {
  72         void *scf_handle = dlopen("libscf.so.1", RTLD_LAZY);
  73         scf_simple_prop_get_t scf_simple_prop_get = (scf_handle == NULL)? NULL :
  74             (scf_simple_prop_get_t)dlsym(scf_handle, "scf_simple_prop_get");
  75         scf_simple_prop_next_boolean_t scf_simple_prop_next_boolean =
  76             (scf_handle == NULL)? NULL :
  77             (scf_simple_prop_next_boolean_t)dlsym(scf_handle,
  78             "scf_simple_prop_next_boolean");
  79         scf_simple_prop_free_t scf_simple_prop_free =
  80             (scf_handle == NULL)? NULL :
  81             (scf_simple_prop_free_t)dlsym(scf_handle, "scf_simple_prop_free");
  82
  83         lmutex_lock(&scf_lock);
  84         if (real_scf_simple_prop_get == NULL ||
  85             real_scf_simple_prop_next_boolean == NULL ||
  86             real_scf_simple_prop_free == NULL) {
  87                 if (scf_simple_prop_get == NULL)
  88                         real_scf_simple_prop_get = (scf_simple_prop_get_t)(-1);
  89                 else {
  90                         real_scf_simple_prop_get = scf_simple_prop_get;
  91                         scf_handle = NULL;      /* don't dlclose it */
  92                 }
  93                 if (scf_simple_prop_next_boolean == NULL)
  94                         real_scf_simple_prop_next_boolean =
  95                             (scf_simple_prop_next_boolean_t)(-1);
  96                 else {
  97                         real_scf_simple_prop_next_boolean =
  98                             scf_simple_prop_next_boolean;
  99                         scf_handle = NULL;      /* don't dlclose it */
 100                 }
 101                 if (scf_simple_prop_free == NULL)
 102                         real_scf_simple_prop_free =
 103                             (scf_simple_prop_free_t)(-1);
 104                 else {
 105                         real_scf_simple_prop_free = scf_simple_prop_free;
 106                         scf_handle = NULL;      /* don't dlclose it */
 107                 }
 108                 membar_producer();
 109         }
 110         lmutex_unlock(&scf_lock);
 111
 112         if (scf_handle)
 113                 (void) dlclose(scf_handle);
 114 }
 115
 116 static void
 117 check_archive_update(void)
 118 {
 119         scf_simple_prop_t *prop = NULL;
 120         boolean_t update_flag = B_FALSE;
 121         char *fmri = "svc:/system/boot-config:default";
 122         uint8_t *ret_val = NULL;
 123
 124         if (real_scf_simple_prop_get == NULL ||
 125             real_scf_simple_prop_next_boolean == NULL ||
 126             real_scf_simple_prop_free == NULL) {
 127                 load_scf();
 128         }
 129         if (real_scf_simple_prop_get == (scf_simple_prop_get_t)(-1) ||
 130             real_scf_simple_prop_next_boolean ==
 131             (scf_simple_prop_next_boolean_t)(-1) ||
 132             real_scf_simple_prop_free == (scf_simple_prop_free_t)(-1)) {
 133                 return;
 134         }
 135
 136         prop = real_scf_simple_prop_get(NULL, fmri, "config",
 137             "uadmin_boot_archive_sync");
 138         if (prop) {
 139                 if ((ret_val = real_scf_simple_prop_next_boolean(prop)) !=
 140                     NULL)
 141                         update_flag = (*ret_val == 0) ? B_FALSE :
 142                             B_TRUE;
 143                 real_scf_simple_prop_free(prop);
 144         }
 145
 146         if (update_flag == B_TRUE)
 147                 (void) system("/sbin/bootadm update-archive");
 148 }
 149 static int
 150 legal_arg(char *bargs)
 151 {
 152         int i;
 153
 154         for (i = 0; i < BOOTARGS_MAX; i++, bargs++) {
 155                 if (*bargs == 0 && i > 0)
 156                         return (i);
 157                 if (!isprint(*bargs))
 158                         break;
 159         }
 160         return (-1);
 161 }
 162
 163 static char quote[] = "\'";
 164
 165 int
 166 uadmin(int cmd, int fcn, uintptr_t mdep)
 167 {
 168         extern int __uadmin(int cmd, int fcn, uintptr_t mdep);
 169         char *bargs, cmdbuf[256];
 170         struct stat sbuf;
 171         char *altroot;
 172
 173         bargs = (char *)mdep;
 174
 175         if (geteuid() == 0 && getzoneid() == GLOBAL_ZONEID &&
 176             (cmd == A_SHUTDOWN || cmd == A_REBOOT)) {
 177                 int off = 0;
 178
 179                 switch (fcn) {
 180                 case AD_IBOOT:
 181                 case AD_SBOOT:
 182                 case AD_SIBOOT:
 183                         /*
 184                          * These functions fabricate appropriate bootargs.
 185                          * If bootargs are passed in, map these functions
 186                          * to AD_BOOT.
 187                          */
 188                         if (bargs == 0) {
 189                                 switch (fcn) {
 190                                 case AD_IBOOT:
 191                                         bargs = "-a";
 192                                         break;
 193                                 case AD_SBOOT:
 194                                         bargs = "-s";
 195                                         break;
 196                                 case AD_SIBOOT:
 197                                         bargs = "-sa";
 198                                         break;
 199                                 }
 200                         }
 201                         /*FALLTHROUGH*/
 202                 case AD_BOOT:
 203                 case AD_FASTREBOOT:
 204                         if (bargs == 0)
 205                                 break;  /* no args */
 206                         if (legal_arg(bargs) < 0)
 207                                 break;  /* bad args */
 208
 209                         /* avoid cancellation in system() */
 210                         (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
 211                             NULL);
 212
 213                         altroot = "";
 214
 215                         if (fcn == AD_FASTREBOOT) {
 216                                 char *newarg, *head;
 217                                 char bargs_scratch[BOOTARGS_MAX];
 218
 219                                 bzero(bargs_scratch, BOOTARGS_MAX);
 220
 221                                 bcopy(bargs, bargs_scratch, strlen(bargs));
 222                                 head = bargs_scratch;
 223                                 newarg = strtok(bargs_scratch, " ");
 224
 225                                 if (newarg == NULL || newarg[0] == '-')
 226                                         break;
 227
 228                                 /* First argument is rootdir */
 229                                 if (strncmp(&newarg[strlen(newarg)-4],
 230                                     "unix", 4) != 0) {
 231                                         newarg = strtok(NULL, " ");
 232                                         off = newarg - head;
 233                                 }
 234
 235                                 /*
 236                                  * If we are using alternate root via
 237                                  * mountpoint or a different BE, don't
 238                                  * bother to update the temp menu entry.
 239                                  */
 240                                 if (off > 0)
 241                                         break;
 242                         }
 243
 244                         /* are we rebooting to a boot menu entry? */
 245                         if (isdigit(bargs[0])) {
 246                                 int entry = strtol(bargs, NULL, 10);
 247                                 (void) snprintf(cmdbuf, sizeof (cmdbuf),
 248                                     "/sbin/bootadm set-menu %sdefault=%d",
 249                                     altroot, entry);
 250                         } else {
 251                                 (void) snprintf(cmdbuf, sizeof (cmdbuf),
 252                                     "/sbin/bootadm -m update_temp %s"
 253                                     "-o %s%s%s", altroot, quote,
 254                                     &bargs[off], quote);
 255                         }
 256                         (void) system(cmdbuf);
 257                 }
 258                 check_archive_update();
 259         }
 260
 261         return (__uadmin(cmd, fcn, mdep));
 262 }