Source code upload

eoe/cmd/raid/tools/Makefile

@@ -0,0 +1,15 @@
+#
+# Makefile for the RAID administrative utility
+#
+
+include	$(ROOT)/usr/include/make/commondefs
+
+TARGETS	= startstop modepage writelong write markdown inq
+CFILES	= startstop.c modepage.c writelong.c write.c markdown.c inq.c
+LCFLAGS	= -g -DDEBUG
+LLDOPTS	= -g
+LLDLIBS = -lds
+
+default: $(TARGETS)
+
+include $(COMMONRULES)

eoe/cmd/raid/tools/inq.c

@@ -0,0 +1,60 @@
+/*	program to print the drive type, so I can determine which script to feed to
+	fx to set the drive parameters the way we want them for the Eclipse, just
+	prior to reformating.
+	Dave Olson, 7/88
+*/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/dkio.h>
+#include <sys/scsi.h>
+
+main(cnt, args)
+char **args;
+{
+	static char inqname[SCSI_DEVICE_NAME_SIZE+1];
+	int fd;
+	int verbose = 0;
+
+	security();
+	if(cnt == 3 && strcmp(args[1], "-v") == 0)
+		verbose++, args++, cnt--;
+	if(cnt != 2)
+		usage(args[0]);
+	
+	if(*args[1] != '/')
+		if(chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+			exit(1);
+		}
+
+	if((fd = open(args[1], 0)) == -1) {
+		fprintf(stderr, "inquire: couldn't open %s\n",args[1]);
+		/*perror(*args);*/
+		exit(1);
+	}
+
+	if(ioctl(fd, DIOCDRIVETYPE, inqname) == -1) {
+		perror("couldn't determine drive type");
+		exit(1);
+	}
+	if(verbose)
+		printf("%s:\t%s\n", args[1], inqname);
+	else
+		printf("%s\n", inqname);
+	exit(0);
+}
+
+usage(prog)
+{
+	printf("Usage: %s [-v] drivename\n", prog);
+	exit(2);
+}
+
+security()
+{
+	if ((getuid() != 0) || (geteuid() != 0))
+	{
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+}

eoe/cmd/raid/tools/markdown.c

@@ -0,0 +1,74 @@
+/*
+ * Program to arbitrarily mark drives attached to a RAID controller up or down.
+ */
+
+#include <stdio.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/usraid_admin.h>
+
+usage(prog)
+{
+	printf("Usage: %s [-d drivenum] -[gb] drivename\n", prog);
+	exit(2);
+}
+
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct usraid_units_down downs;
+	int drivenum, markgood, markbad;
+	int cmd, ch, fd, i;
+
+	drivenum = markgood = markbad = 0;
+	while ((ch = getopt(argc, argv, "d:gb")) != EOF) {
+		switch (ch) {
+		case 'd': drivenum = atoi(optarg);	break;
+		case 'g': markgood = 1;			break;
+		case 'b': markbad = 1;			break;
+		default:  usage(argv[0]);		break;
+		}
+	}
+	if ((!markgood && !markbad) || (markgood && markbad) ||
+	    (drivenum < 0) || (drivenum > 4))
+		usage(argv[0]);
+	if (optind != (argc-1))
+		usage(argv[0]);
+
+	if ((getuid() != 0) || (geteuid() != 0)) {
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+
+	if (*argv[optind] != '/') {
+		if (chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+		}
+	}
+	if ((fd = open(argv[optind], 0)) == -1) {
+		fprintf(stderr, "inquire: couldn't open %s\n", argv[optind]);
+		perror(argv[optind]);
+		exit(1);
+	}
+
+	/*
+	 * Fill out the control parameters.
+	 */
+	bzero(&downs, sizeof(downs));
+	downs.drive[drivenum] = 1;
+	if (markgood == 1)
+		cmd = USRAID_CLR_DOWN;
+	else
+		cmd = USRAID_SET_DOWN;
+
+	/*
+	 * Execute the operation.
+	 */
+	if (ioctl(fd, cmd, &downs) < 0) {
+		perror("couldn't perform operation");
+		exit(1);
+	}
+
+	exit(0);
+}

eoe/cmd/raid/tools/modepage.c

@@ -0,0 +1,189 @@
+/*
+ * Program to get/set mode pages on drives attached to a RAID controller.
+ */
+
+#include <stdio.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/usraid_admin.h>
+
+/*
+ * Useful twiddling stuff for SCSI commands and return values.
+ */
+#define B(v,s) ((uchar_t)((v) >> s))
+#define USR_MSB_SPLIT1(v,a)                                                (a)[0]=B(v,0)
+#define USR_MSB_SPLIT2(v,a)                                 (a)[0]=B(v,8), (a)[1]=B(v,0)
+#define USR_MSB_SPLIT3(v,a)                 (a)[0]=B(v,16), (a)[1]=B(v,8), (a)[2]=B(v,0)
+#define USR_MSB_SPLIT4(v,a) (a)[0]=B(v,24), (a)[1]=B(v,16), (a)[2]=B(v,8), (a)[3]=B(v,0)
+
+
+/*
+ * Mode Sense Command - opcode 0x1a
+ * Read mode pages from the device.
+ */
+struct mode_sense {
+	u_char	opcode;
+	u_char	rsvd1;
+	u_char	pagecontrol:2, pagecode:6;
+	u_char	rsvd2;
+	u_char	alloclen;
+	u_char	rsvd3;
+};
+
+/*
+ * Mode Select Command - opcode 0x15
+ * Write new mode pages to the device.
+ */
+struct mode_select {
+	u_char	opcode;
+	u_char	rsvd1:3, pageflag:1, rsvd2:3, savepage:1;
+	u_char	rsvd3[2];
+	u_char	paramlen;
+	u_char	rsvd4;
+};
+
+
+usage(prog)
+{
+	printf("Usage: %s [-v] -d drivenum -p pagenum -l pagelen -[gs] drivename\n", prog);
+	exit(2);
+}
+
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct usraid_passthru pt_args;
+	int drivenum, pagenum, pagelen;
+	int getflag, setflag, ch, fd, i;
+	char buffer[4096];
+
+	drivenum = pagenum = pagelen = getflag = setflag = 0;
+	while ((ch = getopt(argc, argv, "d:p:l:gs")) != EOF) {
+		switch (ch) {
+		case 'd': drivenum = atoi(optarg);	break;
+		case 'p': pagenum = atoi(optarg);	break;
+		case 'l': pagelen = atoi(optarg);	break;
+		case 'g': getflag = 1;			break;
+		case 's': setflag = 1;			break;
+		default:  usage(argv[0]);		break;
+		}
+	}
+	if ((!setflag && !getflag) || (setflag && getflag) ||
+	    (drivenum < 0) || (drivenum > 4) ||
+	    (pagelen <= 0) || (pagelen >= 4096) ||
+	    (pagenum < 0))
+		usage(argv[0]);
+	if (optind != (argc-1))
+		usage(argv[0]);
+
+	if ((getuid() != 0) || (geteuid() != 0)) {
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+
+	if (*argv[optind] != '/') {
+		if (chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+		}
+	}
+	if ((fd = open(argv[optind], 0)) == -1) {
+		fprintf(stderr, "inquire: couldn't open %s\n", argv[optind]);
+		perror(argv[optind]);
+		exit(1);
+	}
+
+	if (getflag == 1) {
+		struct mode_sense	sense_cmd;
+
+		/*
+		 * Fill out a standard SCSI mode sense command.
+		 */
+		bzero(&sense_cmd, sizeof(sense_cmd));
+		sense_cmd.opcode = 0x1a;
+		sense_cmd.pagecontrol = 0;
+		sense_cmd.pagecode = pagenum;
+		sense_cmd.alloclen = pagelen + 12;
+
+		/*
+		 * Fill in the ioctl control parameters.
+		 */
+		pt_args.drive = drivenum;
+		pt_args.todisk = 0;
+		pt_args.fromdisk = 1;
+		pt_args.xfercount = pagelen + 12;
+		pt_args.cdblen = sizeof(sense_cmd);
+		bcopy(&sense_cmd, pt_args.cdb, sizeof(sense_cmd));
+		pt_args.databuf = buffer;
+
+		/*
+		 * Execute the mode sense command.
+		 */
+		if (ioctl(fd, USRAID_PASSTHRU, &pt_args) < 0) {
+			perror("couldn't perform mode sense command");
+			exit(1);
+		}
+
+		/*
+		 * Print the results.
+		 */
+		for (i = 0; i < 12; i++) {
+			printf("0x%02x ", buffer[i]);
+		}
+		printf("\n");
+		for (i = 0; i < pagelen; i++) {
+			if ((i != 0) && ((i % 8) == 0))
+				printf("\n");
+			printf("0x%02x ", buffer[i+12]);
+		}
+		printf("\n");
+	} else {
+		struct mode_select	select_cmd;
+
+		/*
+		 * Collect the new page contents from stdin.
+		 */
+		for (i = 0; i < pagelen+12; i++) {
+			if (scanf("%x", &ch) != 1) {
+				fprintf(stderr, "error: couldn't read byte number %d\n", i);
+				exit(1);
+			}
+			buffer[i] = ch;
+		}
+
+		/*
+		 * mode select doesn't accept direct mode sense info
+		 */
+		buffer[0] = 0;
+		buffer[12] &= 0x7f;
+
+		/*
+		 * Fill out a standard SCSI mode select command.
+		 */
+		bzero(&select_cmd, sizeof(select_cmd));
+		select_cmd.opcode = 0x15;
+		select_cmd.savepage = 1;
+		select_cmd.paramlen = pagelen + 12;
+
+		/*
+		 * Fill in the ioctl control parameters.
+		 */
+		pt_args.drive = drivenum;
+		pt_args.todisk = 1;
+		pt_args.fromdisk = 0;
+		pt_args.xfercount = pagelen + 12;
+		pt_args.cdblen = sizeof(select_cmd);
+		bcopy(&select_cmd, pt_args.cdb, sizeof(select_cmd));
+		pt_args.databuf = buffer;
+
+		/*
+		 * Execute the mode select command.
+		 */
+		if (ioctl(fd, USRAID_PASSTHRU, &pt_args) < 0) {
+			perror("couldn't perform mode select command");
+			exit(1);
+		}
+	}
+
+	exit(0);
+}

eoe/cmd/raid/tools/startstop.c

@@ -0,0 +1,77 @@
+/*
+ * Program to start or stop a RAID controller.
+ */
+
+#include <stdio.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <dslib.h>
+
+/*
+ * Start Unit Command - opcode 0x1b
+ * Spin up or spin down the device.
+ */
+struct usr_startunit {
+	u_char	opcode;
+	u_char	rsvd1:7, immediate:1;
+	u_char	rsvd2[2];
+	u_char	rsvd3:7, startflag:1;
+	u_char	rsvd4;
+};
+
+
+usage(prog)
+{
+	printf("Usage: %s -[ud] /dev/scsi/drivename\n", prog);
+	exit(2);
+}
+
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	int upflag, downflag, ch, error;
+	unsigned long lba;
+	struct dsreq *dsp;
+
+	upflag = downflag = 0;
+	while ((ch = getopt(argc, argv, "ud")) != EOF) {
+		switch (ch) {
+		case 'u': upflag = 1;			break;
+		case 'd': downflag = 1;			break;
+		default:  usage(argv[0]);		break;
+		}
+	}
+	if ((!upflag && !downflag) || (upflag && downflag))
+		usage(argv[0]);
+	if (optind != (argc-1))
+		usage(argv[0]);
+
+	if ((getuid() != 0) || (geteuid() != 0)) {
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+
+	if (*argv[optind] != '/') {
+		if (chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+		}
+	}
+	dsp = dsopen(argv[optind], 0);
+
+	/* 
+	 * Fill in control stuff to send the command
+	 */
+	fillg0cmd(dsp, CMDBUF(dsp), 0x1b, 1, 0, 0, upflag, 0);
+	filldsreq(dsp, 0, 0, DSRQ_SENSE);
+	TIME(dsp) = 60 * 1000;	/* 20 seconds */
+
+	/*
+	 * Send the command.
+	 */
+	if (error = doscsireq(getfd(dsp), dsp))
+		printf("err = %d\n", error);
+
+	dsclose(dsp);
+	exit(0);
+}

eoe/cmd/raid/tools/write.c

@@ -0,0 +1,142 @@
+/*
+ * Program to write a sector on a drive attached to a RAID controller.
+ */
+
+#include <stdio.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/usraid_admin.h>
+
+/*
+ * Useful twiddling stuff for SCSI commands and return values.
+ */
+#define B(v,s) ((uchar_t)((v) >> s))
+#define USR_MSB_SPLIT1(v,a)                                                (a)[0]=B(v,0)
+#define USR_MSB_SPLIT2(v,a)                                 (a)[0]=B(v,8), (a)[1]=B(v,0)
+#define USR_MSB_SPLIT3(v,a)                 (a)[0]=B(v,16), (a)[1]=B(v,8), (a)[2]=B(v,0)
+#define USR_MSB_SPLIT4(v,a) (a)[0]=B(v,24), (a)[1]=B(v,16), (a)[2]=B(v,8), (a)[3]=B(v,0)
+
+
+/*
+ * Read Command - opcode 0x28
+ * Write Command - opcode 0x2a
+ * Read/write the specified number of blocks from/to the specified LBA.
+ */
+struct rw_cmd {
+	u_char	opcode;
+	u_char	rsvd1;
+	u_char	lba[4];
+	u_char	rsvd2;
+	u_char	length[2];
+	u_char	rsvd3;
+};
+
+usage(prog)
+{
+	printf("Usage: %s -d drivenum -b blocknum -n numblocks -[rw] drivename\n", prog);
+	exit(2);
+}
+
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct usraid_passthru pt_args;
+	int drivenum, blocknum, numblocks;
+	int getflag, setflag, ch, fd, i;
+	struct rw_cmd cmd;
+	int xferlength;
+	char *buffer;
+
+	drivenum = blocknum = numblocks = getflag = setflag = 0;
+	while ((ch = getopt(argc, argv, "d:b:n:rw")) != EOF) {
+		switch (ch) {
+		case 'd': drivenum = atoi(optarg);	break;
+		case 'b': blocknum = atoi(optarg);	break;
+		case 'n': numblocks = atoi(optarg);	break;
+		case 'r': getflag = 1;			break;
+		case 'w': setflag = 1;			break;
+		default:  usage(argv[0]);		break;
+		}
+	}
+	if ((!setflag && !getflag) || (setflag && getflag) ||
+	    (drivenum < 0) || (drivenum > 4) || (blocknum < 0) ||
+	    (numblocks < 0) || (numblocks >= 128))
+		usage(argv[0]);
+	if (optind != (argc-1))
+		usage(argv[0]);
+
+	if ((getuid() != 0) || (geteuid() != 0)) {
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+
+	if (*argv[optind] != '/') {
+		if (chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+		}
+	}
+	if ((fd = open(argv[optind], 0)) == -1) {
+		fprintf(stderr, "inquire: couldn't open %s\n", argv[optind]);
+		perror(argv[optind]);
+		exit(1);
+	}
+
+	xferlength = numblocks * 512;
+	buffer = (char *)malloc( (unsigned)xferlength );
+
+	if (getflag == 0) {
+		/*
+		 * Collect the new sector contents from stdin.
+		 */
+		for (i = 0; i < xferlength; i++) {
+			if (scanf("%x", &ch) != 1) {
+				fprintf(stderr, "error: couldn't scanf byte number %d\n", i);
+				exit(1);
+			}
+			buffer[i] = ch;
+		}
+	}
+
+	/*
+	 * Fill out a standard SCSI read or write command.
+	 */
+	bzero(&cmd, sizeof(cmd));
+	cmd.opcode = getflag ? 0x28 : 0x2a;
+	USR_MSB_SPLIT4(blocknum, cmd.lba);
+	USR_MSB_SPLIT2(numblocks, cmd.length);
+
+	/*
+	 * Fill in the ioctl control parameters.
+	 */
+	bzero(&pt_args, sizeof(pt_args));
+	pt_args.drive = drivenum;
+	pt_args.todisk = !getflag;
+	pt_args.fromdisk = getflag;
+	pt_args.xfercount = xferlength;
+	pt_args.cdblen = sizeof(cmd);
+	bcopy(&cmd, pt_args.cdb, sizeof(cmd));
+	pt_args.databuf = buffer;
+
+	/*
+	 * Execute the read long command.
+	 */
+	if (ioctl(fd, USRAID_PASSTHRU, &pt_args) < 0) {
+		perror("couldn't perform read long command");
+		exit(1);
+	}
+
+	if (getflag == 1) {
+		/*
+		 * Print the results.
+		 */
+		for (i = 0; i < xferlength; i++) {
+			if ((i != 0) && ((i % 8) == 0))
+				printf("\n");
+			printf("0x%02x ", buffer[i]);
+		}
+		printf("\n");
+	}
+
+	exit(0);
+}

eoe/cmd/raid/tools/writelong.c

@@ -0,0 +1,180 @@
+/*
+ * Program to write over ECC bytes on drives attached to a RAID controller.
+ */
+
+#include <stdio.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/usraid_admin.h>
+
+/*
+ * Useful twiddling stuff for SCSI commands and return values.
+ */
+#define B(v,s) ((uchar_t)((v) >> s))
+#define USR_MSB_SPLIT1(v,a)                                                (a)[0]=B(v,0)
+#define USR_MSB_SPLIT2(v,a)                                 (a)[0]=B(v,8), (a)[1]=B(v,0)
+#define USR_MSB_SPLIT3(v,a)                 (a)[0]=B(v,16), (a)[1]=B(v,8), (a)[2]=B(v,0)
+#define USR_MSB_SPLIT4(v,a) (a)[0]=B(v,24), (a)[1]=B(v,16), (a)[2]=B(v,8), (a)[3]=B(v,0)
+
+
+/*
+ * Read Long Command - opcode 0x3e
+ * Read data AND ecc bytes from the device.
+ */
+struct read_long {
+	u_char	opcode;
+	u_char	lun:3, rsvd1:3, correct:1, reladr:1;
+	u_char	lba[4];
+	u_char	rsvd2;
+	u_char	xferlen[2];
+	u_char	rsvd3;
+};
+
+/*
+ * Write Long Command - opcode 0x3f
+ * Write data AND ecc bytes from the device.
+ */
+struct write_long {
+	u_char	opcode;
+	u_char	lun:3, rsvd1:4, reladr:1;
+	u_char	lba[4];
+	u_char	rsvd2;
+	u_char	xferlen[2];
+	u_char	rsvd3;
+};
+
+
+usage(prog)
+{
+	printf("Usage: %s -d drivenum -b blocknum -[rw] drivename\n", prog);
+	exit(2);
+}
+
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct usraid_passthru pt_args;
+	int drivenum, blocknum;
+	int getflag, setflag, ch, fd, i;
+	int xferlength;
+	char *buffer;
+
+	drivenum = blocknum = getflag = setflag = 0;
+	while ((ch = getopt(argc, argv, "d:b:n:rw")) != EOF) {
+		switch (ch) {
+		case 'd': drivenum = atoi(optarg);	break;
+		case 'b': blocknum = atoi(optarg);	break;
+		case 'r': getflag = 1;			break;
+		case 'w': setflag = 1;			break;
+		default:  usage(argv[0]);		break;
+		}
+	}
+	if ((!setflag && !getflag) || (setflag && getflag) ||
+	    (drivenum < 0) || (drivenum > 4) || (blocknum < 0))
+		usage(argv[0]);
+	if (optind != (argc-1))
+		usage(argv[0]);
+
+	if ((getuid() != 0) || (geteuid() != 0)) {
+		fprintf(stderr,"Only root can run this program\n");
+		exit(-1);
+	}
+
+	if (*argv[optind] != '/') {
+		if (chdir("/dev/rdsk")) {
+			perror("couldn't cd to /dev/rdsk");
+		}
+	}
+	if ((fd = open(argv[optind], 0)) == -1) {
+		fprintf(stderr, "inquire: couldn't open %s\n", argv[optind]);
+		perror(argv[optind]);
+		exit(1);
+	}
+
+	xferlength = 512 + 20;	/* 20 bytes of LRC and ECC */
+	buffer = (char *)malloc( (unsigned)xferlength );
+
+	if (getflag == 1) {
+		struct read_long readlong;
+
+		/*
+		 * Fill out a standard SCSI read long command.
+		 */
+		bzero(&readlong, sizeof(readlong));
+		readlong.opcode = 0x3e;
+		USR_MSB_SPLIT4(blocknum, readlong.lba);
+		USR_MSB_SPLIT2(xferlength, readlong.xferlen);
+
+		/*
+		 * Fill in the ioctl control parameters.
+		 */
+		pt_args.drive = drivenum;
+		pt_args.todisk = 0;
+		pt_args.fromdisk = 1;
+		pt_args.xfercount = xferlength;
+		pt_args.cdblen = sizeof(readlong);
+		bcopy(&readlong, pt_args.cdb, sizeof(readlong));
+		pt_args.databuf = buffer;
+
+		/*
+		 * Execute the read long command.
+		 */
+		if (ioctl(fd, USRAID_PASSTHRU, &pt_args) < 0) {
+			perror("couldn't perform read long command");
+			exit(1);
+		}
+
+		/*
+		 * Print the results.
+		 */
+		for (i = 0; i < xferlength; i++) {
+			if ((i != 0) && ((i % 8) == 0))
+				printf("\n");
+			printf("0x%02x ", buffer[i]);
+		}
+		printf("\n");
+	} else {
+		struct write_long writelong;
+
+		/*
+		 * Collect the new sector contents from stdin.
+		 */
+		for (i = 0; i < xferlength; i++) {
+			if (scanf("%x", &ch) != 1) {
+				fprintf(stderr, "error: couldn't read byte number %d\n", i);
+				exit(1);
+			}
+			buffer[i] = ch;
+		}
+
+		/*
+		 * Fill out a standard SCSI write long command.
+		 */
+		bzero(&writelong, sizeof(writelong));
+		writelong.opcode = 0x3f;
+		USR_MSB_SPLIT4(blocknum, writelong.lba);
+		USR_MSB_SPLIT2(xferlength, writelong.xferlen);
+
+		/*
+		 * Fill in the ioctl control parameters.
+		 */
+		pt_args.drive = drivenum;
+		pt_args.todisk = 1;
+		pt_args.fromdisk = 0;
+		pt_args.xfercount = xferlength;
+		pt_args.cdblen = sizeof(writelong);
+		bcopy(&writelong, pt_args.cdb, sizeof(writelong));
+		pt_args.databuf = buffer;
+
+		/*
+		 * Execute the write long command.
+		 */
+		if (ioctl(fd, USRAID_PASSTHRU, &pt_args) < 0) {
+			perror("couldn't perform write long command");
+			exit(1);
+		}
+	}
+
+	exit(0);
+}