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
usage(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
wait_until_dev_complete(char * name)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
alloc_ramdisk(int ctl_fd,char * name,uint64_t size)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
delete_ramdisk(int ctl_fd,char * name)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
di_callback(di_node_t node,di_minor_t minor,void * arg)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
print_ramdisk(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
main(int argc,char * argv[])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 }
341