Home | History | Annotate | Line # | Download | only in dkctl
dkctl.c revision 1.3 
      1 /*	$NetBSD: dkctl.c,v 1.3 2003/04/15 18:27:28 darrenr Exp $	*/
      2 
      3 /*
      4  * Copyright 2001 Wasabi Systems, Inc.
      5  * All rights reserved.
      6  *
      7  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted provided that the following conditions
     11  * are met:
     12  * 1. Redistributions of source code must retain the above copyright
     13  *    notice, this list of conditions and the following disclaimer.
     14  * 2. Redistributions in binary form must reproduce the above copyright
     15  *    notice, this list of conditions and the following disclaimer in the
     16  *    documentation and/or other materials provided with the distribution.
     17  * 3. All advertising materials mentioning features or use of this software
     18  *    must display the following acknowledgement:
     19  *	This product includes software developed for the NetBSD Project by
     20  *	Wasabi Systems, Inc.
     21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
     22  *    or promote products derived from this software without specific prior
     23  *    written permission.
     24  *
     25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
     26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
     29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     35  * POSSIBILITY OF SUCH DAMAGE.
     36  */
     37 
     38 /*
     39  * dkctl(8) -- a program to manipulate disks.
     40  */
     41 
     42 #include <sys/param.h>
     43 #include <sys/ioctl.h>
     44 #include <sys/dkio.h>
     45 #include <sys/disk.h>
     46 #include <sys/queue.h>
     47 #include <err.h>
     48 #include <errno.h>
     49 #include <fcntl.h>
     50 #include <stdio.h>
     51 #include <stdlib.h>
     52 #include <string.h>
     53 #include <unistd.h>
     54 #include <util.h>
     55 
     56 #define	YES	1
     57 #define	NO	0
     58 
     59 /* I don't think nl_langinfo is suitable in this case */
     60 #define	YES_STR	"yes"
     61 #define	NO_STR	"no"
     62 #define YESNO_ARG	YES_STR " | " NO_STR
     63 
     64 #ifndef PRIdaddr
     65 #define PRIdaddr PRId64
     66 #endif
     67 
     68 struct command {
     69 	const char *cmd_name;
     70 	const char *arg_names;
     71 	void (*cmd_func)(int, char *[]);
     72 	int open_flags;
     73 };
     74 
     75 int	main(int, char *[]);
     76 void	usage(void);
     77 
     78 int	fd;				/* file descriptor for device */
     79 const	char *dvname;			/* device name */
     80 char	dvname_store[MAXPATHLEN];	/* for opendisk(3) */
     81 const	char *cmdname;			/* command user issued */
     82 const	char *argnames;			/* helpstring; expected arguments */
     83 
     84 int yesno(const char *);
     85 
     86 void	disk_getcache(int, char *[]);
     87 void	disk_setcache(int, char *[]);
     88 void	disk_synccache(int, char *[]);
     89 void	disk_keeplabel(int, char *[]);
     90 void	disk_badsectors(int, char *[]);
     91 
     92 struct command commands[] = {
     93 	{ "getcache",
     94 	  "",
     95 	  disk_getcache,
     96 	  O_RDONLY },
     97 
     98 	{ "setcache",
     99 	  "none | r | w | rw [save]",
    100 	  disk_setcache,
    101 	  O_RDWR },
    102 
    103 	{ "synccache",
    104 	  "[force]",
    105 	  disk_synccache,
    106 	  O_RDWR },
    107 
    108 	{ "keeplabel",
    109 	  YESNO_ARG,
    110 	  disk_keeplabel,
    111 	  O_RDWR },
    112 
    113 	{ "badsector",
    114 	  "flush | list | retry",
    115 	   disk_badsectors,
    116 	   O_RDWR },
    117 
    118 	{ NULL,
    119 	  NULL,
    120 	  NULL,
    121 	  0 },
    122 };
    123 
    124 int
    125 main(int argc, char *argv[])
    126 {
    127 	int i;
    128 
    129 	/* Must have at least: device command */
    130 	if (argc < 3)
    131 		usage();
    132 
    133 	/* Skip program name, get and skip device name and command. */
    134 	dvname = argv[1];
    135 	cmdname = argv[2];
    136 	argv += 3;
    137 	argc -= 3;
    138 
    139 	/* Look up and call the command. */
    140 	for (i = 0; commands[i].cmd_name != NULL; i++)
    141 		if (strcmp(cmdname, commands[i].cmd_name) == 0)
    142 			break;
    143 	if (commands[i].cmd_name == NULL)
    144 		errx(1, "unknown command: %s", cmdname);
    145 
    146 	argnames = commands[i].arg_names;
    147 
    148 	/* Open the device. */
    149 	fd = opendisk(dvname, commands[i].open_flags, dvname_store,
    150 	    sizeof(dvname_store), 0);
    151 	if (fd == -1)
    152 		err(1, "%s", dvname);
    153 
    154 	dvname = dvname_store;
    155 
    156 	(*commands[i].cmd_func)(argc, argv);
    157 	exit(0);
    158 }
    159 
    160 void
    161 usage()
    162 {
    163 	int i;
    164 
    165 	fprintf(stderr, "Usage: %s device command [arg [...]]\n",
    166 	    getprogname());
    167 
    168 	fprintf(stderr, "   Available commands:\n");
    169 	for (i = 0; commands[i].cmd_name != NULL; i++)
    170 		fprintf(stderr, "\t%s %s\n", commands[i].cmd_name,
    171 		    commands[i].arg_names);
    172 
    173 	exit(1);
    174 }
    175 
    176 void
    177 disk_getcache(int argc, char *argv[])
    178 {
    179 	int bits;
    180 
    181 	if (ioctl(fd, DIOCGCACHE, &bits) == -1)
    182 		err(1, "%s: getcache", dvname);
    183 
    184 	if ((bits & (DKCACHE_READ|DKCACHE_WRITE)) == 0)
    185 		printf("%s: No caches enabled\n", dvname);
    186 	else {
    187 		if (bits & DKCACHE_READ)
    188 			printf("%s: read cache enabled\n", dvname);
    189 		if (bits & DKCACHE_WRITE)
    190 			printf("%s: write-back cache enabled\n", dvname);
    191 	}
    192 
    193 	printf("%s: read cache enable is %schangeable\n", dvname,
    194 	    (bits & DKCACHE_RCHANGE) ? "" : "not ");
    195 	printf("%s: write cache enable is %schangeable\n", dvname,
    196 	    (bits & DKCACHE_WCHANGE) ? "" : "not ");
    197 
    198 	printf("%s: cache parameters are %ssavable\n", dvname,
    199 	    (bits & DKCACHE_SAVE) ? "" : "not ");
    200 }
    201 
    202 void
    203 disk_setcache(int argc, char *argv[])
    204 {
    205 	int bits;
    206 
    207 	if (argc > 2 || argc == 0)
    208 		usage();
    209 
    210 	if (strcmp(argv[0], "none") == 0)
    211 		bits = 0;
    212 	else if (strcmp(argv[0], "r") == 0)
    213 		bits = DKCACHE_READ;
    214 	else if (strcmp(argv[0], "w") == 0)
    215 		bits = DKCACHE_WRITE;
    216 	else if (strcmp(argv[0], "rw") == 0)
    217 		bits = DKCACHE_READ|DKCACHE_WRITE;
    218 	else
    219 		usage();
    220 
    221 	if (argc == 2) {
    222 		if (strcmp(argv[1], "save") == 0)
    223 			bits |= DKCACHE_SAVE;
    224 		else
    225 			usage();
    226 	}
    227 
    228 	if (ioctl(fd, DIOCSCACHE, &bits) == -1)
    229 		err(1, "%s: setcache", dvname);
    230 }
    231 
    232 void
    233 disk_synccache(int argc, char *argv[])
    234 {
    235 	int force;
    236 
    237 	switch (argc) {
    238 	case 0:
    239 		force = 0;
    240 		break;
    241 
    242 	case 1:
    243 		if (strcmp(argv[0], "force") == 0)
    244 			force = 1;
    245 		else
    246 			usage();
    247 		break;
    248 
    249 	default:
    250 		usage();
    251 	}
    252 
    253 	if (ioctl(fd, DIOCCACHESYNC, &force) == -1)
    254 		err(1, "%s: sync cache", dvname);
    255 }
    256 
    257 void
    258 disk_keeplabel(int argc, char *argv[])
    259 {
    260 	int keep;
    261 	int yn;
    262 
    263 	if (argc != 1)
    264 		usage();
    265 
    266 	yn = yesno(argv[0]);
    267 	if (yn < 0)
    268 		usage();
    269 
    270 	keep = yn == YES;
    271 
    272 	if (ioctl(fd, DIOCKLABEL, &keep) == -1)
    273 		err(1, "%s: keep label", dvname);
    274 }
    275 
    276 
    277 void
    278 disk_badsectors(int argc, char *argv[])
    279 {
    280 	struct disk_badsectors *dbs, *dbs2, buffer[200];
    281 	SLIST_HEAD(, disk_badsectors) dbstop;
    282 	struct disk_badsecinfo dbsi;
    283 	daddr_t blk, totbad, bad;
    284 	u_int32_t count, size;
    285 	struct stat sb;
    286 	u_char *block;
    287 
    288 	if (argc != 1)
    289 		usage();
    290 
    291 	if (strcmp(argv[0], "list") == 0) {
    292 		/*
    293 		 * Copy the list of kernel bad sectors out in chunks that fit
    294 		 * into buffer[].  Updating dbsi_skip means we don't sit here
    295 		 * forever only getting the first chunk that fit in buffer[].
    296 		 */
    297 		dbsi.dbsi_buffer = (caddr_t)buffer;
    298 		dbsi.dbsi_bufsize = sizeof(buffer);
    299 		dbsi.dbsi_skip = 0;
    300 		dbsi.dbsi_copied = 0;
    301 		dbsi.dbsi_left = 0;
    302 
    303 		do {
    304 			if (ioctl(fd, DIOCBSLIST, (caddr_t)&dbsi) == -1)
    305 				err(1, "%s: badsectors list", dvname);
    306 
    307 			dbs = (struct disk_badsectors *)dbsi.dbsi_buffer;
    308 			for (count = dbsi.dbsi_copied; count > 0; count--) {
    309 				printf("%s: blocks %d - %d failed at %s",
    310 					dvname, dbs->dbs_min, dbs->dbs_max,
    311 					ctime(&dbs->dbs_failedat.tv_sec));
    312 			}
    313 			dbsi.dbsi_skip += dbsi.dbsi_copied;
    314 		} while (dbsi.dbsi_left != 0);
    315 
    316 	} else if (strcmp(argv[0], "flush") == 0) {
    317 		if (ioctl(fd, DIOCBSFLUSH) == -1)
    318 			err(1, "%s: badsectors flush", dvname);
    319 
    320 	} else if (strcmp(argv[0], "retry") == 0) {
    321 		/*
    322 		 * Enforce use of raw device here because the block device
    323 		 * causes access to blocks to be clustered in a larger group,
    324 		 * making it impossible to determine which individual sectors
    325 		 * are the cause of a problem.
    326 		 */
    327 		if (fstat(fd, &sb) == -1)
    328 			err(1, "fstat");
    329 
    330 		if (!S_ISCHR(sb.st_mode)) {
    331 			fprintf(stderr, "'badsector retry' must be used %s\n",
    332 				"with character device");
    333 			exit(1);
    334 		}
    335 
    336 		SLIST_INIT(&dbstop);
    337 
    338 		/*
    339 		 * Build up a copy of the in-kernel list in a number of stages.
    340 		 * That the list we build up here is in the reverse order to
    341 		 * the kernel's is of no concern.
    342 		 */
    343 		dbsi.dbsi_buffer = (caddr_t)buffer;
    344 		dbsi.dbsi_bufsize = sizeof(buffer);
    345 		dbsi.dbsi_skip = 0;
    346 		dbsi.dbsi_copied = 0;
    347 		dbsi.dbsi_left = 0;
    348 
    349 		do {
    350 			if (ioctl(fd, DIOCBSLIST, (caddr_t)&dbsi) == -1)
    351 				err(1, "%s: badsectors list", dvname);
    352 
    353 			dbs = (struct disk_badsectors *)dbsi.dbsi_buffer;
    354 			for (count = dbsi.dbsi_copied; count > 0; count--) {
    355 				dbs2 = malloc(sizeof(*dbs2));
    356 				*dbs2 = *dbs;
    357 				SLIST_INSERT_HEAD(&dbstop, dbs2, dbs_next);
    358 			}
    359 			dbsi.dbsi_skip += dbsi.dbsi_copied;
    360 		} while (dbsi.dbsi_left != 0);
    361 
    362 		/*
    363 		 * Just calculate and print out something that will hopefully
    364 		 * provide some useful information about what's going to take
    365 		 * place next (if anything.)
    366 		 */
    367 		bad = 0;
    368 		totbad = 0;
    369 		block = calloc(1, DEV_BSIZE);
    370 		SLIST_FOREACH(dbs, &dbstop, dbs_next) {
    371 			bad++;
    372 			totbad += dbs->dbs_max - dbs->dbs_min + 1;
    373 		}
    374 
    375 		printf("%s: bad sector clusters %"PRIdaddr
    376 		    " total sectors %"PRIdaddr"\n", dvname, bad, totbad);
    377 
    378 		/*
    379 		 * Clear out the kernel's list of bad sectors, ready for us
    380 		 * to test all those it thought were bad.
    381 		 */
    382 		if (ioctl(fd, DIOCBSFLUSH) == -1)
    383 			err(1, "%s: badsectors flush", dvname);
    384 
    385 		printf("%s: bad sectors flushed\n", dvname);
    386 
    387 		/*
    388 		 * For each entry we obtained from the kernel, retry each
    389 		 * individual sector recorded as bad by seeking to it and
    390 		 * attempting to read it in.  Print out a line item for each
    391 		 * bad block we verify.
    392 		 *
    393 		 * PRIdaddr is used here because the type of dbs_max is daddr_t
    394 		 * and that may be either a 32bit or 64bit number(!)
    395 		 */
    396 		SLIST_FOREACH(dbs, &dbstop, dbs_next) {
    397 			printf("%s: Retrying %"PRIdaddr" - %"
    398 			    PRIdaddr"\n", dvname, dbs->dbs_min, dbs->dbs_max);
    399 
    400 			for (blk = dbs->dbs_min; blk <= dbs->dbs_max; blk++) {
    401 				if (lseek(fd, (off_t)blk * DEV_BSIZE,
    402 				    SEEK_SET) == -1) {
    403 					warn("%s: lseek block %d", dvname,
    404 					     blk);
    405 					continue;
    406 				}
    407 				printf("%s: block %"PRIdaddr" - ", dvname, blk);
    408 				if (read(fd, block, DEV_BSIZE) != DEV_BSIZE)
    409 					printf("failed\n");
    410 				else
    411 					printf("ok\n");
    412 				fflush(stdout);
    413 			}
    414 		}
    415 	}
    416 }
    417 
    418 /*
    419  * return YES, NO or -1.
    420  */
    421 int
    422 yesno(const char *p)
    423 {
    424 
    425 	if (!strcmp(p, YES_STR))
    426 		return YES;
    427 	if (!strcmp(p, NO_STR))
    428 		return NO;
    429 	return -1;
    430 }
    431