path: root/usr/src/cmd/ramdiskadm/main.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2002-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ramdiskadm - administer ramdisk(7d). Allows creation and deletion of
 * ramdisks, and display status. All the ioctls are private between
 * ramdisk and ramdiskadm, and so are very simple - device information is
 * communicated via a name or a minor number.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/ramdisk.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <sys/sunddi.h>
#include <libdevinfo.h>
#include <stdio.h>
#include <fcntl.h>
#include <locale.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <stropts.h>
#include <ctype.h>
#include "utils.h"

#define	RD_BLOCK_DEV_PFX	"/dev/" RD_BLOCK_NAME "/"
#define	RD_CHAR_DEV_PFX		"/dev/" RD_CHAR_NAME "/"

#define	HEADING	"%-*.*s %20s  %-10s\n"
#define	FORMAT	"%-*.*s %20llu    %s\n"
#define	FW	(sizeof (RD_BLOCK_DEV_PFX) - 1 + RD_NAME_LEN)

static char *pname;

static void
usage(void)
{
	(void) fprintf(stderr,
	    gettext("Usage: %s [ -a <name> <size>[g|m|k|b] | -d <name> ]\n"),
	    pname);
	exit(E_USAGE);
}

/*
 * This might be the first time we've used this minor device. If so,
 * it might also be that the /dev links are in the process of being created
 * by devfsadmd (or that they'll be created "soon"). We cannot return
 * until they're there or the invoker of ramdiskadm might try to use them
 * and not find them. This can happen if a shell script is running on
 * an MP.
 */
static void
wait_until_dev_complete(char *name)
{
	di_devlink_handle_t hdl;

	hdl = di_devlink_init(RD_DRIVER_NAME, DI_MAKE_LINK);
	if (hdl == NULL) {
		die(gettext("couldn't create device link for\"%s\""), name);
	}
	(void) di_devlink_fini(&hdl);
}

/*
 * Create a named ramdisk.
 */
static void
alloc_ramdisk(int ctl_fd, char *name, uint64_t size)
{
	struct rd_ioctl	ri;

	(void) strlcpy(ri.ri_name, name, sizeof (ri.ri_name));
	ri.ri_size = size;

	if (ioctl(ctl_fd, RD_CREATE_DISK, &ri) == -1) {
		die(gettext("couldn't create ramdisk \"%s\""), name);
	}
	wait_until_dev_complete(name);

	(void) printf(RD_BLOCK_DEV_PFX "%s\n", name);
}

/*
 * Delete a named ramdisk.
 */
static void
delete_ramdisk(int ctl_fd, char *name)
{
	struct rd_ioctl	ri;

	(void) strlcpy(ri.ri_name, name, sizeof (ri.ri_name));

	if (ioctl(ctl_fd, RD_DELETE_DISK, &ri) == -1) {
		die(gettext("couldn't delete ramdisk \"%s\""), name);
	}
}

/*ARGSUSED*/
static int
di_callback(di_node_t node, di_minor_t minor, void *arg)
{
	static boolean_t	heading_done = B_FALSE;
	boolean_t		obp_ramdisk;
	char			*name;
	char			devnm[MAXNAMELEN];
	uint64_t		*sizep;
	char			blkpath[MAXPATHLEN];

	/*
	 * Only consider block nodes bound to the ramdisk driver.
	 */
	if (strcmp(di_driver_name(node), RD_DRIVER_NAME) == 0 &&
	    di_minor_spectype(minor) == S_IFBLK) {
		/*
		 * Determine whether this ramdisk is pseudo or OBP-created.
		 */
		obp_ramdisk = (di_nodeid(node) == DI_PROM_NODEID);

		/*
		 * If this is an OBP-created ramdisk use the node name, having
		 * first stripped the "ramdisk-" prefix.  For pseudo ramdisks
		 * use the minor name, having first stripped any ",raw" suffix.
		 */
		if (obp_ramdisk) {
			RD_STRIP_PREFIX(name, di_node_name(node));
			(void) strlcpy(devnm, name, sizeof (devnm));
		} else {
			(void) strlcpy(devnm, di_minor_name(minor),
			    sizeof (devnm));
			RD_STRIP_SUFFIX(devnm);
		}

		/*
		 * Get the size of the ramdisk.
		 */
		if (di_prop_lookup_int64(di_minor_devt(minor), node,
		    "Size", (int64_t **)&sizep) == -1) {
			die(gettext("couldn't obtain size of ramdisk"));
		}

		/*
		 * Print information about the ramdisk.  Prepend a heading
		 * if this is the first/only one.
		 */
		if (!heading_done) {
			(void) printf(HEADING, FW, FW, gettext("Block Device"),
			    gettext("Size"), gettext("Removable"));
			heading_done = B_TRUE;
		}
		(void) snprintf(blkpath, sizeof (blkpath),
		    RD_BLOCK_DEV_PFX "%s", devnm);
		(void) printf(FORMAT, FW, FW, blkpath, *sizep,
		    obp_ramdisk ? gettext("No") : gettext("Yes"));
	}

	return (DI_WALK_CONTINUE);
}

/*
 * Print the list of all the ramdisks, their size, and whether they
 * are removeable (i.e. non-OBP ramdisks).
 */
static void
print_ramdisk(void)
{
	di_node_t	root;

	/*
	 * Create a snapshot of the device tree, then walk it looking
	 * for, and printing information about, ramdisk nodes.
	 */
	if ((root = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
		die(gettext("couldn't create device tree snapshot"));
	}

	if (di_walk_minor(root, DDI_PSEUDO, 0, NULL, di_callback) == -1) {
		di_fini(root);
		die(gettext("device tree walk failure"));
	}

	di_fini(root);
}

int
main(int argc, char *argv[])
{
	int		c;
	char		*name = NULL;
	int		allocflag = 0;
	int		deleteflag = 0;
	int		errflag = 0;
	char		*suffix;
	uint64_t	size;
	int		openflag;
	int		ctl_fd = 0;
	static char	rd_ctl[] = "/dev/" RD_CTL_NAME;

	pname = getpname(argv[0]);

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "a:d:")) != EOF) {
		switch (c) {
		case 'a':
			allocflag = 1;
			name = optarg;

			if (((argc - optind) <= 0) || (*argv[optind] == '-')) {
				warn(gettext("<size> missing\n"));
				usage();
				/*NOTREACHED*/
			}
			size = strtoll(argv[optind], &suffix, 0);
			if (strcmp(suffix, "b") == 0) {
				size *= 512;
				++suffix;
			} else if (strcmp(suffix, "k") == 0) {
				size *= 1024;
				++suffix;
			} else if (strcmp(suffix, "m") == 0) {
				size *= (1024 * 1024);
				++suffix;
			} else if (strcmp(suffix, "g") == 0) {
				size *= (1024 * 1024 * 1024);
				++suffix;
			}
			if (size == 0 || *suffix != '\0') {
				warn(gettext("Illegal <size> \"%s\"\n"),
				    argv[optind]);
				usage();
				/*NOTREACHED*/
			}
			++optind;
			break;
		case 'd':
			deleteflag = 1;
			name = optarg;
			break;
		default:
			errflag = 1;
			break;
		}
	}
	if (errflag || (allocflag && deleteflag) || (argc - optind) > 0) {
		usage();
		/*NOTREACHED*/
	}

	if (allocflag || deleteflag) {
		boolean_t	nameok = B_TRUE;
		char		*p;

		/*
		 * Strip off any leading "/dev/{r}ramdisk/" prefix.
		 */
		if (strncmp(name, RD_BLOCK_DEV_PFX,
		    sizeof (RD_BLOCK_DEV_PFX)-1) == 0) {
			name += sizeof (RD_BLOCK_DEV_PFX)-1;
		} else if (strncmp(name, RD_CHAR_DEV_PFX,
		    sizeof (RD_CHAR_DEV_PFX)-1) == 0) {
			name += sizeof (RD_CHAR_DEV_PFX)-1;
		}

		/*
		 * Check that name isn't too long, and that it only contains
		 * valid characters, i.e. [a-zA-Z0-9_][a-zA-Z0-9_-]*
		 */
		if (name[0] == '-') {		/* permit only within name */
			nameok = B_FALSE;
		} else {
			for (p = name; *p != '\0'; p++) {
				if (!isalnum(*p) && *p != '_' && *p != '-') {
					nameok = B_FALSE;
					break;
				}
			}
		}
		if (!nameok || (p - name) > RD_NAME_LEN) {
			warn(gettext("illegal <name> \"%s\"\n"), name);
			usage();
			/*NOTREACHED*/
		}
	}

	/*
	 * Now do the real work.
	 */
	openflag = O_EXCL;
	if (allocflag || deleteflag)
		openflag |= O_RDWR;
	else
		openflag |= O_RDONLY;
	ctl_fd = open(rd_ctl, openflag);
	if (ctl_fd == -1) {
		if ((errno == EPERM) || (errno == EACCES)) {
			die(gettext("you do not have permission to perform "
			    "that operation.\n"));
		} else {
			die("%s", rd_ctl);
		}
		/*NOTREACHED*/
	}

	if (allocflag) {
		alloc_ramdisk(ctl_fd, name, size);
	} else if (deleteflag) {
		delete_ramdisk(ctl_fd, name);
	} else {
		print_ramdisk();
	}

	return (E_SUCCESS);
}