xref: /titanic_52/usr/src/cmd/addbadsec/addbadsec.c (revision cfcc56e0075241b5a13f04c502e961ef843de0d3)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
/*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * Copyrighted as an unpublished work.
 * (c) Copyright INTERACTIVE Systems Corporation 1986, 1988, 1990
 * All rights reserved.
 */

#include <stdio.h>
#include <fcntl.h>
#include <memory.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <sys/vtoc.h>
#include <sys/dkio.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <stropts.h>
#include <sys/scsi/generic/commands.h>
#include <sys/scsi/impl/commands.h>
#include <sys/scsi/impl/uscsi.h>
#include "badsec.h"

char    *devname;		/* name of device */
int	devfd;			/* device file descriptor */
struct	dk_geom		dkg;	/* geometry */
struct  extvtoc	vtoc;		/* table of contents */
char	*progname;

extern	struct	badsec_lst *badsl_chain;
extern	int	badsl_chain_cnt;
extern	struct	badsec_lst *gbadsl_chain;
extern	int	gbadsl_chain_cnt;
extern	int	print_altsec(struct extpartition *);
extern	int	updatebadsec(struct extpartition *, int);
extern	void	wr_altsctr(void);

int		alts_fd;

static void giveusage(void);
static void rd_gbad(FILE *badsecfd);
static void add_gbad(int badsec_entry);
static int try_hw_remap(void);
static int hardware_remap(blkaddr_t);

int
main(int argc, char *argv[])
{
	extern int	optind;
	extern char	*optarg;

	static char	options[] = "Ipa:f:";
	char		numbuf[100];
	char		*nxtarg;
	char		*alts_name;
	minor_t 	minor_val;
	struct stat 	statbuf;
	struct extpartition	*part = NULL;
	int		alts_slice = -1;
	int		l;
	int		p;
	int		init_flag = 0;
	int		print_flag = 0;
	int 		c;
	int 		i;
	FILE		*badsecfd = NULL;

	progname = argv[0];
	while ((c = getopt(argc, argv, options)) != EOF) {
		switch (c) {
		case 'I':
			init_flag = 1;
			break;
		case 'p':
			print_flag = 1;
			break;
		case 'a':
			nxtarg = optarg;
			for (; *nxtarg != '\0'; )
				add_gbad(strtol(nxtarg, &nxtarg, 0));
			break;
		case 'f':
			if ((badsecfd = fopen(optarg, "r")) == NULL) {
				(void) fprintf(stderr,
				    "%s: unable to open %s file\n",
				    progname, optarg);
				exit(1);
			}
			break;
		default:
			giveusage();
			exit(2);
		}
	}

		/* get the last argument -- device stanza */
	if (argc != optind+1) {
		(void) fprintf(stderr, "Missing disk device name\n");
		giveusage();
		exit(3);
	}
	devname = argv[optind];

	if (stat(devname, &statbuf)) {
		(void) fprintf(stderr, "%s: invalid device %s, stat failed\n",
		    progname, devname);
		giveusage();
		exit(4);
	}
	if ((statbuf.st_mode & S_IFMT) != S_IFCHR) {
		(void) fprintf(stderr, "%s: device %s is not character"
		    " special\n", progname, devname);
		giveusage();
		exit(5);
	}
	minor_val = minor(statbuf.st_rdev);
	/*
	 * NEED A DEFINE FOR THE PHYSICAL BIT (0x10)
	 */
	if ((minor_val & 0x10) == 0) {
		(void) fprintf(stderr, "%s: device %s is not a physical"
		    " slice\n", progname, devname);
		giveusage();
		exit(6);
	}
	if ((minor_val % V_NUMPAR) != 0) {
		(void) fprintf(stderr, "%s: device %s is not a slice 0"
		    " device\n", progname, devname);
		giveusage();
		exit(7);
	}
	if ((devfd = open(devname, O_RDWR)) == -1) {
		(void) fprintf(stderr, "%s: open of %s failed\n",
		    progname, devname);
		perror("");
		exit(8);
	}
	if ((ioctl(devfd, DKIOCGGEOM, &dkg)) == -1) {
		(void) fprintf(stderr, "%s: unable to get disk geometry.\n",
		    progname);
		perror("");
		exit(9);
	}

	if (ioctl(devfd, DKIOCGEXTVTOC, &vtoc) == -1) {
		(void) fprintf(stderr, "%s: could not get VTOC.\n", progname);
		giveusage();
		exit(14);
	}

	if ((vtoc.v_sanity != VTOC_SANE) || (vtoc.v_version != V_VERSION)) {
		(void) fprintf(stderr, "%s: invalid VTOC found.\n", progname);
		giveusage();
		exit(15);
	}
	if (badsecfd)
		rd_gbad(badsecfd);

#ifdef ADDBAD_DEBUG
{
	struct badsec_lst *blc_p;
	printf("\n main: Total bad sectors found= %d\n", gbadsl_chain_cnt);
	for (blc_p = gbadsl_chain; blc_p; blc_p = blc_p->bl_nxt) {
		for (i = 0; i < blc_p->bl_cnt; i++)
			printf(" badsec=%d ", blc_p->bl_sec[i]);
	}
	printf("\n");
}
#endif
#ifdef PPP
	/*
	 * If init_flag is set, run to completion.
	 */
	if (gbadsl_chain_cnt == 0 && init_flag == 0)
		/*
		 * No defects and not initializing
		 */
		exit(0);
#endif
	if (gbadsl_chain_cnt != 0)
	{
		if (try_hw_remap() == SUCCESS)
			exit(0);
	}
	/*
	 * get ALTS slice
	 */
	for (i = 0; i < V_NUMPAR && alts_slice == -1; i++)
	{
		if (vtoc.v_part[i].p_tag == V_ALTSCTR)
		{
			alts_slice = i;
			part = &vtoc.v_part[i];
		}
	}
	if (alts_slice == -1)
	{
		(void) fprintf(stderr, "%s: No alternates slice.\n", progname);
		exit(16);
	}
	l = strlen(devname);
	(void) sprintf(numbuf, "%d", alts_slice);
	p = strlen(numbuf);
	alts_name = (char *)malloc(l + p);
	(void) strcpy(alts_name, devname);
	alts_name[l - 2] = 's';
	(void) strcpy(&alts_name[l - 1], numbuf);
	alts_name[l + p - 1] = '\0';
	if ((alts_fd = open(alts_name, O_RDWR)) == -1) {
		(void) fprintf(stderr, "%s: open of %s failed\n",
		    progname, alts_name);
		perror("");
		exit(9);
	}
	if (print_flag)
	{
		(void) print_altsec(part);
		exit(0);
	}
	(void) updatebadsec(part, init_flag);
	wr_altsctr();

	if (ioctl(devfd, DKIOCADDBAD, NULL) == -1) {
		(void) fprintf(stderr,  "Warning: DKIOCADDBAD io control"
		    " failed. System must be re-booted\n");
		(void) fprintf(stderr, "for alternate sectors to be usable.\n");
		exit(17);
	}
	sync();

	(void) fclose(badsecfd);
	(void) close(alts_fd);
	(void) close(devfd);
	return (0);
}

/*
 * Giveusage ()
 * Give a (not so) concise message on how to use this program.
 */
static void
giveusage(void)
{
	(void) fprintf(stderr, "%s [-p] [-a sector] [-f filename]"
	    " raw-device\n", progname);
	(void) fprintf(stderr, "	p - Print existing bad block map\n");
	(void) fprintf(stderr, "	a - Add the given sectors to the"
	    " bad block list\n");
	(void) fprintf(stderr, "	f - Add the sectors from <filename>"
	    " to the bad block list\n");
	if (devfd)
		(void) close(devfd);
}


/*
 *	read in the additional growing bad sectors
 */
static void
rd_gbad(FILE *badsecfd)
{
	int	badsec_entry;
	int	status;

	status = fscanf(badsecfd, "%d", &badsec_entry);
	while (status != EOF) {
		add_gbad(badsec_entry);
		status = fscanf(badsecfd, "%d", &badsec_entry);
	}
}

static void
add_gbad(int badsec_entry)
{
	struct badsec_lst *blc_p;

	if (!gbadsl_chain) {
		blc_p = (struct badsec_lst *)malloc(BADSLSZ);
		if (!blc_p) {
			(void) fprintf(stderr, "Unable to allocate memory"
			    " for additional bad sectors\n");
			exit(18);
		}
		gbadsl_chain = blc_p;
		blc_p->bl_cnt = 0;
		blc_p->bl_nxt = 0;
	}
	for (blc_p = gbadsl_chain; blc_p->bl_nxt; )
		blc_p = blc_p->bl_nxt;

	if (blc_p->bl_cnt == MAXBLENT) {
		blc_p->bl_nxt = (struct badsec_lst *)malloc(BADSLSZ);
		if (!blc_p->bl_nxt) {
			(void) fprintf(stderr, "Unable to allocate memory"
			    " for additional bad sectors\n");
			exit(19);
		}
		blc_p = blc_p->bl_nxt;
		blc_p->bl_cnt = 0;
		blc_p->bl_nxt = 0;
	}
	blc_p->bl_sec[blc_p->bl_cnt++] = badsec_entry;
	gbadsl_chain_cnt++;
}

/*
 * Map a block using hardware (SCSI) techniques.
 */
/*ARGSUSED*/
static int
hardware_remap(bn)
blkaddr_t	bn;
{
	uint_t		byte_swap_32(uint_t);
	ushort_t	byte_swap_16(ushort_t);

	struct uscsi_cmd		ucmd;
	union scsi_cdb			cdb;
	struct scsi_reassign_blk	defect_list;

	/*
	 * Build and execute the uscsi ioctl
	 */
	(void) memset((char *)&ucmd, 0, sizeof (ucmd));
	(void) memset((char *)&cdb, 0, sizeof (union scsi_cdb));
	(void) memset((char *)&defect_list, 0,
		sizeof (struct scsi_reassign_blk));
	cdb.scc_cmd = SCMD_REASSIGN_BLOCK;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)&defect_list;
	ucmd.uscsi_buflen = sizeof (struct scsi_reassign_blk);
	defect_list.length = byte_swap_16(sizeof (defect_list.defect));
	defect_list.defect = byte_swap_32(bn);
	/*
	 * Set function flags for driver.
	 */
	ucmd.uscsi_flags = USCSI_ISOLATE | USCSI_DIAGNOSE | USCSI_SILENT;
	ucmd.uscsi_timeout = 30;		/* 30 seconds */

	/*
	 * Execute the ioctl
	 */
	if (ioctl(devfd, USCSICMD, &ucmd) == -1)
	{
		if (errno != ENOTTY)
		{
			perror("SCSI hardware re-assign failed");
			/*
			 * It looks like a failure but by returning success
			 * the upper layer will not try to do
			 * software remapping.
			 */
			return (SUCCESS);
		}
		return (FAILURE);
	}
	return (SUCCESS);
}

uint_t
byte_swap_32(uint_t nav)
{
	uint_t	rc;
	rc = ((nav & 0xff000000) >> 24) | ((nav & 0x00ff0000) >> 8) |
	    ((nav & 0x0000ff00) << 8)  | ((nav & 0x000000ff) << 24);
	return (rc);
}

ushort_t
byte_swap_16(ushort_t niv)
{
	ushort_t	rc;
	rc = (ushort_t)((int)(niv & 0xff00) >> 8) | ((niv & 0x00ff) << 8);
	return (rc);
}

static int
try_hw_remap()
{
	struct badsec_lst *blc_p;
	int	i;

	for (blc_p = gbadsl_chain; blc_p != 0; blc_p = blc_p->bl_nxt) {
		for (i = 0; i < blc_p->bl_cnt; i++)
		if (hardware_remap(blc_p->bl_sec[i]) == FAILURE)
			return (FAILURE);
	}
	return (SUCCESS);
}