/*
 * 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);
}