OS-3280 need a way to specify the root of a native system in the lx brand
OS-3279 lx brand should allow delegated datasets
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>

          --- old/usr/src/lib/libc/port/gen/getauxv.c
          +++ new/usr/src/lib/libc/port/gen/getauxv.c

   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *
  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying

  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  
  22   22  /*
  23   23   * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24   24   * Use is subject to license terms.
  25   25   */
  26   26  
  27      -#pragma ident   "%Z%%M% %I%     %E% SMI"
  28      -
  29   27  #include "lint.h"
       28 +#include "thr_uberdata.h"
  30   29  #include <libc.h>
  31   30  #include <fcntl.h>
  32   31  #include <stdlib.h>
  33   32  #include <unistd.h>
  34   33  #include <sys/types.h>
  35   34  #include <sys/stat.h>
  36   35  #include <sys/auxv.h>
  37   36  #include <mtlib.h>
  38   37  #include <thread.h>
  39   38  #include <synch.h>
  40   39  #include <atomic.h>
       40 +#include <limits.h>
  41   41  
  42   42  static mutex_t auxlock = DEFAULTMUTEX;
  43   43  
  44   44  /*
  45   45   * Get auxiliary entry.
  46   46   * Returns pointer to entry, or 0 if entry does not exist.
  47   47   */
  48   48  static auxv_t *
  49   49  _getaux(int type)
  50   50  {

  51   51          static auxv_t *auxb = NULL;

  52   52          static size_t nauxv = 0;
  53   53          ssize_t i;
  54   54  
  55   55          /*
  56   56           * The first time through, read the initial aux vector that was
  57   57           * passed to the process at exec(2).  Only do this once.
  58   58           */
  59   59          if (auxb == NULL) {
  60   60                  lmutex_lock(&auxlock);
  61   61                  if (auxb == NULL) {
       62 +                        uberdata_t *udp = curthread->ul_uberdata;
  62   63                          struct stat statb;
  63   64                          auxv_t *buf = NULL;
       65 +                        char *path = "/proc/self/auxv";
       66 +                        char pbuf[PATH_MAX];
  64   67                          int fd;
  65   68  
  66      -                        if ((fd = open("/proc/self/auxv", O_RDONLY)) != -1 &&
       69 +                        if (udp->ub_broot != NULL) {
       70 +                                (void) snprintf(pbuf, sizeof (pbuf),
       71 +                                    "%s/proc/self/auxv", udp->ub_broot);
       72 +                                path = pbuf;
       73 +                        }
       74 +
       75 +                        if ((fd = open(path, O_RDONLY)) != -1 &&
  67   76                              fstat(fd, &statb) != -1)
  68   77                                  buf = libc_malloc(
  69   78                                      statb.st_size + sizeof (auxv_t));
  70   79  
  71   80                          if (buf != NULL) {
  72   81                                  i = read(fd, buf, statb.st_size);
  73   82                                  if (i != -1) {
  74   83                                          nauxv = i / sizeof (auxv_t);
  75   84                                          buf[nauxv].a_type = AT_NULL;
  76   85                                  } else {

  77   86                                          libc_free(buf);
  78   87                                          buf = NULL;
  79   88                                  }
  80   89                          }
  81   90  
  82   91                          if (fd != -1)
  83   92                                  (void) close(fd);
  84   93  
  85   94                          membar_producer();
  86   95                          auxb = buf;
  87   96                  }
  88   97                  lmutex_unlock(&auxlock);
  89   98          }
  90   99          membar_consumer();
  91  100  
  92  101          /*
  93  102           * Scan the auxiliary entries looking for the required type.
  94  103           */
  95  104          for (i = 0; i < nauxv; i++)
  96  105                  if (auxb[i].a_type == type)
  97  106                          return (&auxb[i]);
  98  107  
  99  108          /*
 100  109           * No auxiliary array (static executable) or entry not found.
 101  110           */
 102  111          return ((auxv_t *)0);
 103  112  }
 104  113  
 105  114  /*
 106  115   * These two routines are utilities exported to the rest of libc.
 107  116   */
 108  117  
 109  118  long
 110  119  ___getauxval(int type)
 111  120  {
 112  121          auxv_t *auxp;
 113  122  
 114  123          if ((auxp = _getaux(type)) != (auxv_t *)0)
 115  124                  return (auxp->a_un.a_val);
 116  125          return (0);
 117  126  }
 118  127  
 119  128  void *
 120  129  ___getauxptr(int type)
 121  130  {
 122  131          auxv_t *auxp;
 123  132  
 124  133          if ((auxp = _getaux(type)) != (auxv_t *)0)
 125  134                  return (auxp->a_un.a_ptr);
 126  135          return (0);
 127  136  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX