usr/src/cmd/ramdiskadm/main.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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2002-2003 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * ramdiskadm - administer ramdisk(7d). Allows creation and deletion of
  27  * ramdisks, and display status. All the ioctls are private between
  28  * ramdisk and ramdiskadm, and so are very simple - device information is
  29  * communicated via a name or a minor number.
  30  */
  31
  32 #pragma ident   "%Z%%M% %I%     %E% SMI"
  33
  34 #include <sys/types.h>
  35 #include <sys/param.h>
  36 #include <sys/ramdisk.h>
  37 #include <sys/stat.h>
  38 #include <sys/mkdev.h>
  39 #include <sys/sunddi.h>
  40 #include <libdevinfo.h>
  41 #include <stdio.h>
  42 #include <fcntl.h>
  43 #include <locale.h>
  44 #include <string.h>
  45 #include <errno.h>
  46 #include <stdlib.h>
  47 #include <unistd.h>
  48 #include <stropts.h>
  49 #include <ctype.h>
  50 #include "utils.h"
  51
  52 #define RD_BLOCK_DEV_PFX        "/dev/" RD_BLOCK_NAME "/"
  53 #define RD_CHAR_DEV_PFX         "/dev/" RD_CHAR_NAME "/"
  54
  55 #define HEADING "%-*.*s %20s  %-10s\n"
  56 #define FORMAT  "%-*.*s %20llu    %s\n"
  57 #define FW      (sizeof (RD_BLOCK_DEV_PFX) - 1 + RD_NAME_LEN)
  58
  59 static char *pname;
  60
  61 static void
  62 usage(void)
  63 {
  64         (void) fprintf(stderr,
  65             gettext("Usage: %s [ -a <name> <size>[g|m|k|b] | -d <name> ]\n"),
  66             pname);
  67         exit(E_USAGE);
  68 }
  69
  70 /*
  71  * This might be the first time we've used this minor device. If so,
  72  * it might also be that the /dev links are in the process of being created
  73  * by devfsadmd (or that they'll be created "soon"). We cannot return
  74  * until they're there or the invoker of ramdiskadm might try to use them
  75  * and not find them. This can happen if a shell script is running on
  76  * an MP.
  77  */
  78 static void
  79 wait_until_dev_complete(char *name)
  80 {
  81         di_devlink_handle_t hdl;
  82
  83         hdl = di_devlink_init(RD_DRIVER_NAME, DI_MAKE_LINK);
  84         if (hdl == NULL) {
  85                 die(gettext("couldn't create device link for\"%s\""), name);
  86         }
  87         (void) di_devlink_fini(&hdl);
  88 }
  89
  90 /*
  91  * Create a named ramdisk.
  92  */
  93 static void
  94 alloc_ramdisk(int ctl_fd, char *name, uint64_t size)
  95 {
  96         struct rd_ioctl ri;
  97
  98         (void) strlcpy(ri.ri_name, name, sizeof (ri.ri_name));
  99         ri.ri_size = size;
 100
 101         if (ioctl(ctl_fd, RD_CREATE_DISK, &ri) == -1) {
 102                 die(gettext("couldn't create ramdisk \"%s\""), name);
 103         }
 104         wait_until_dev_complete(name);
 105
 106         (void) printf(RD_BLOCK_DEV_PFX "%s\n", name);
 107 }
 108
 109 /*
 110  * Delete a named ramdisk.
 111  */
 112 static void
 113 delete_ramdisk(int ctl_fd, char *name)
 114 {
 115         struct rd_ioctl ri;
 116
 117         (void) strlcpy(ri.ri_name, name, sizeof (ri.ri_name));
 118
 119         if (ioctl(ctl_fd, RD_DELETE_DISK, &ri) == -1) {
 120                 die(gettext("couldn't delete ramdisk \"%s\""), name);
 121         }
 122 }
 123
 124 /*ARGSUSED*/
 125 static int
 126 di_callback(di_node_t node, di_minor_t minor, void *arg)
 127 {
 128         static boolean_t        heading_done = B_FALSE;
 129         boolean_t               obp_ramdisk;
 130         char                    *name;
 131         char                    devnm[MAXNAMELEN];
 132         uint64_t                *sizep;
 133         char                    blkpath[MAXPATHLEN];
 134
 135         /*
 136          * Only consider block nodes bound to the ramdisk driver.
 137          */
 138         if (strcmp(di_driver_name(node), RD_DRIVER_NAME) == 0 &&
 139             di_minor_spectype(minor) == S_IFBLK) {
 140                 /*
 141                  * Determine whether this ramdisk is pseudo or OBP-created.
 142                  */
 143                 obp_ramdisk = (di_nodeid(node) == DI_PROM_NODEID);
 144
 145                 /*
 146                  * If this is an OBP-created ramdisk use the node name, having
 147                  * first stripped the "ramdisk-" prefix.  For pseudo ramdisks
 148                  * use the minor name, having first stripped any ",raw" suffix.
 149                  */
 150                 if (obp_ramdisk) {
 151                         RD_STRIP_PREFIX(name, di_node_name(node));
 152                         (void) strlcpy(devnm, name, sizeof (devnm));
 153                 } else {
 154                         (void) strlcpy(devnm, di_minor_name(minor),
 155                             sizeof (devnm));
 156                         RD_STRIP_SUFFIX(devnm);
 157                 }
 158
 159                 /*
 160                  * Get the size of the ramdisk.
 161                  */
 162                 if (di_prop_lookup_int64(di_minor_devt(minor), node,
 163                     "Size", (int64_t **)&sizep) == -1) {
 164                         die(gettext("couldn't obtain size of ramdisk"));
 165                 }
 166
 167                 /*
 168                  * Print information about the ramdisk.  Prepend a heading
 169                  * if this is the first/only one.
 170                  */
 171                 if (!heading_done) {
 172                         (void) printf(HEADING, FW, FW, gettext("Block Device"),
 173                             gettext("Size"), gettext("Removable"));
 174                         heading_done = B_TRUE;
 175                 }
 176                 (void) snprintf(blkpath, sizeof (blkpath),
 177                     RD_BLOCK_DEV_PFX "%s", devnm);
 178                 (void) printf(FORMAT, FW, FW, blkpath, *sizep,
 179                     obp_ramdisk ? gettext("No") : gettext("Yes"));
 180         }
 181
 182         return (DI_WALK_CONTINUE);
 183 }
 184
 185 /*
 186  * Print the list of all the ramdisks, their size, and whether they
 187  * are removeable (i.e. non-OBP ramdisks).
 188  */
 189 static void
 190 print_ramdisk(void)
 191 {
 192         di_node_t       root;
 193
 194         /*
 195          * Create a snapshot of the device tree, then walk it looking
 196          * for, and printing information about, ramdisk nodes.
 197          */
 198         if ((root = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
 199                 die(gettext("couldn't create device tree snapshot"));
 200         }
 201
 202         if (di_walk_minor(root, DDI_PSEUDO, 0, NULL, di_callback) == -1) {
 203                 di_fini(root);
 204                 die(gettext("device tree walk failure"));
 205         }
 206
 207         di_fini(root);
 208 }
 209
 210 int
 211 main(int argc, char *argv[])
 212 {
 213         int             c;
 214         char            *name = NULL;
 215         int             allocflag = 0;
 216         int             deleteflag = 0;
 217         int             errflag = 0;
 218         char            *suffix;
 219         uint64_t        size;
 220         int             openflag;
 221         int             ctl_fd = 0;
 222         static char     rd_ctl[] = "/dev/" RD_CTL_NAME;
 223
 224         pname = getpname(argv[0]);
 225
 226         (void) setlocale(LC_ALL, "");
 227         (void) textdomain(TEXT_DOMAIN);
 228
 229         while ((c = getopt(argc, argv, "a:d:")) != EOF) {
 230                 switch (c) {
 231                 case 'a':
 232                         allocflag = 1;
 233                         name = optarg;
 234
 235                         if (((argc - optind) <= 0) || (*argv[optind] == '-')) {
 236                                 warn(gettext("<size> missing\n"));
 237                                 usage();
 238                                 /*NOTREACHED*/
 239                         }
 240                         size = strtoll(argv[optind], &suffix, 0);
 241                         if (strcmp(suffix, "b") == 0) {
 242                                 size *= 512;
 243                                 ++suffix;
 244                         } else if (strcmp(suffix, "k") == 0) {
 245                                 size *= 1024;
 246                                 ++suffix;
 247                         } else if (strcmp(suffix, "m") == 0) {
 248                                 size *= (1024 * 1024);
 249                                 ++suffix;
 250                         } else if (strcmp(suffix, "g") == 0) {
 251                                 size *= (1024 * 1024 * 1024);
 252                                 ++suffix;
 253                         }
 254                         if (size == 0 || *suffix != '\0') {
 255                                 warn(gettext("Illegal <size> \"%s\"\n"),
 256                                     argv[optind]);
 257                                 usage();
 258                                 /*NOTREACHED*/
 259                         }
 260                         ++optind;
 261                         break;
 262                 case 'd':
 263                         deleteflag = 1;
 264                         name = optarg;
 265                         break;
 266                 default:
 267                         errflag = 1;
 268                         break;
 269                 }
 270         }
 271         if (errflag || (allocflag && deleteflag) || (argc - optind) > 0) {
 272                 usage();
 273                 /*NOTREACHED*/
 274         }
 275
 276         if (allocflag || deleteflag) {
 277                 boolean_t       nameok = B_TRUE;
 278                 char            *p;
 279
 280                 /*
 281                  * Strip off any leading "/dev/{r}ramdisk/" prefix.
 282                  */
 283                 if (strncmp(name, RD_BLOCK_DEV_PFX,
 284                     sizeof (RD_BLOCK_DEV_PFX)-1) == 0) {
 285                         name += sizeof (RD_BLOCK_DEV_PFX)-1;
 286                 } else if (strncmp(name, RD_CHAR_DEV_PFX,
 287                     sizeof (RD_CHAR_DEV_PFX)-1) == 0) {
 288                         name += sizeof (RD_CHAR_DEV_PFX)-1;
 289                 }
 290
 291                 /*
 292                  * Check that name isn't too long, and that it only contains
 293                  * valid characters, i.e. [a-zA-Z0-9_][a-zA-Z0-9_-]*
 294                  */
 295                 if (name[0] == '-') {           /* permit only within name */
 296                         nameok = B_FALSE;
 297                 } else {
 298                         for (p = name; *p != '\0'; p++) {
 299                                 if (!isalnum(*p) && *p != '_' && *p != '-') {
 300                                         nameok = B_FALSE;
 301                                         break;
 302                                 }
 303                         }
 304                 }
 305                 if (!nameok || (p - name) > RD_NAME_LEN) {
 306                         warn(gettext("illegal <name> \"%s\"\n"), name);
 307                         usage();
 308                         /*NOTREACHED*/
 309                 }
 310         }
 311
 312         /*
 313          * Now do the real work.
 314          */
 315         openflag = O_EXCL;
 316         if (allocflag || deleteflag)
 317                 openflag |= O_RDWR;
 318         else
 319                 openflag |= O_RDONLY;
 320         ctl_fd = open(rd_ctl, openflag);
 321         if (ctl_fd == -1) {
 322                 if ((errno == EPERM) || (errno == EACCES)) {
 323                         die(gettext("you do not have permission to perform "
 324                             "that operation.\n"));
 325                 } else {
 326                         die("%s", rd_ctl);
 327                 }
 328                 /*NOTREACHED*/
 329         }
 330
 331         if (allocflag) {
 332                 alloc_ramdisk(ctl_fd, name, size);
 333         } else if (deleteflag) {
 334                 delete_ramdisk(ctl_fd, name);
 335         } else {
 336                 print_ramdisk();
 337         }
 338
 339         return (E_SUCCESS);
 340 }