存储今日谈?D?D硬盘固件(Firmware)

    /* External Functions prototypes */
extern void setbuf(FILE * stream, char *buf);
extern int errno;
extern char fdebugsub; /* used in sgsub.c */
extern FILE *dbgout; /* used in sgsub.c */

    #define EBUFF_LEN 80
#define MAX_ERRORS 4

    /* Global data definitions */
char progver[] = "1.6"; /* program version */
char *progname = "sgdskfl"; /* program name */
char logfile[] = "/var/log/sgdskfl.log"; /* log filename */
char fwsufx[] = ".lod"; /* suffix for firmware image filenames */
char model[20] = ""; /* default model string */
char fsetfile = 0;
char fwfile[20] = "default"; /* default firmware filename (8.lod) */
char defdir[30] = "/usr/share/scsirastools/"; /*default directory for fw files*/
char devname[80] = "/dev/sda"; /* UNIX device name (w path) */
char svfile[20] = "default"; /* default servo filename (8.tms) */
int sdelay = 10; /* num sec to delay before TUR */
FILE *fdlog = NULL; /* log file descriptor */
FILE *fdmsg; /* file descriptor for messages */
char fautomodel = 0; /* =1 to automatically do all of a model */
char filesok = 1; /* =1 if ok to write to files */
char fdebug = 0; /* =1 for debug messages */
char fdoreset = 0; /* =1 if need to do reset for this drive */
char flogopen = 0; /* =1 if log file is open */
char fnotur = 0; /* =1 to not try TUR */
char fdevname = 0; /* =1 if device name specified */
int do_numeric = 1; /* NUMERIC_SCAN_DEF; */
uchar sense_buffer[80]; /* buffer for sense data */
char output[132]; /* message output buffer */
char output2[80]; /* extra message output buffer */
uchar devstat[80]; /* used for inquiry & device status */
uchar devstat2[120]; /* used for Seagate inquiry2 & Mylex stat */
uchar disk_buffer[0x200]; /* 512 bytes, used for misc scsi data */
uchar *image_buffer; /* malloc'd firmware image buffer */
uchar *servo_buffer; /* malloc'd servo buffer */
int idev = 0;
int ndev = 0;
DEVLIST_TYPE devlist[32];
char *devtype_array[11] = {
"Disk ",
"Tape ",
"Printer",
"Procesr",
"WORM ",
"CD-ROM ",
"Scanner",
"Optical",
"Med Chg",
"Comm ",
"Unknown"
};

    /* Local subroutines */
int writeimage(int idx, uchar * imgbuf, ulong len, char fservo);
ulong getimage(int idx, uchar ** pbuf, char fservo);
int beforedl(int idx, int *pnumrdy);
int afterdl(void);

    int main(int argc, char **argv)
{
int i, c, idx;
char response = 0;
ulong size; /* size of fw */
ulong size_sv; /* size of servo */
int runl;
short sts, rc;
ulong ltime1;
char fname[64];
char ebuff[EBUFF_LEN];
int sg_fd;
int flags;
int res, k;
int eacces_err = 0;
int num_errors = 0;
DEVFS_LIST devfs_components = {0,0,0,0,0};

     // progname = argv[0];
fdmsg = stdout; /* set default fdmsg */
while ((c = getopt(argc, argv, "enxrf:m:t:d:?")) != EOF)
switch (c) {
case 'e':
filesok = 0;
break;
case 'x':
fdebug = 1;
break;
case 'r':
fnotur = 1;
break;
case 'n':
do_numeric = 0;
break;
case 'f':
strcpy(fwfile, optarg);
fsetfile = 1;
break;
case 'm':
fautomodel = 1; /* automatically do all of this model */
strcpy(model, optarg);
break;
case 't':
sdelay = atoi(optarg); /* time to delay */
break;
case 'd':
strcpy(devname, optarg); /* specify a unix device name */
fdevname = 1;
break;
case '?':
default:
printf("Usage: %s [-m diskmodel -f imagefile -t secdelay -enrx]\n",
progname);
printf(" -m Automatically download all drives that match this model string\n");
printf(" -f Specify filename for firmware image instead of default\n");
printf(" -t Time in seconds to delay after the firmware is written, default 10\n");
printf(" -n Turn off Numeric, use alpha device names instead\n");
printf(" -e Do not write to any files, so don't use the log file\n");
printf(" -r Recover a non-ready drive by updating its firmware\n");
printf(" -x Outputs extra debug messages\n");
exit(1);
}
/* only run this as superuser */
i = geteuid();
if (i > 1) {
printf("Not superuser (%d)\n", i);
exit(1);
}
/* check for run-level 1 */
{
runl = 1;
/* how to check this? */
if (fdebug) {
/*DEBUG*/ printf("sdelay = %d sec\n", sdelay);
printf("run-level = %d\n", runl);
}
}
if (runl != 1) { /* show warning if not run level 1 */
printf
("Warning: Make sure disks are inactive during firmware download\n");
// dont exit, just give a warning.
}
/* open log file */
if (filesok)
fdlog = fopen(logfile, "a+");
if (fdlog == NULL) {
flogopen = 0;
filesok = 0;
fdlog = stderr;
} else { /* logfile open successful */
flogopen = 1;
time((time_t *) & ltime1);
fprintf(fdlog, "\n--- %s v%s log started at %s", progname, progver,
ctime((long *) fprintf(fdlog, "model: %s\n", model);
fprintf(fdlog, "fw file: %s\n", fwfile);
}
fdebugsub = fdebug;
dbgout = fdlog;
/* loop to display disk choices and do downloads */
while (1) {
/* display header */
printf("\n");
printf(" %s utility v%s for SCSI disks\n",
progname, progver);
printf
(" ******************************************\n");
if (flogopen)
printf("Log file %s is open, debug=%d\n", logfile, fdebug);
printf
("\nNum Name [bus:ch:id:lun] Type Vendor Device_Model FW__ Serial#_ Servo___\n");
/* get SCSI Device Info */
idev = 0;
flags = O_RDWR; /* could use OPEN_FLAG if read-only. */
num_errors = 0;
for (k = 0; (k < 1000) && (num_errors < MAX_ERRORS); ++k) {
// if (fdebug) fprintf(fdlog,"k=%d, num_errors=%d\n", k, num_errors);
if (fdevname) { /* user-specified device name */
strcpy(fname, devname);
k = 1000;
} else {
make_dev_name(fname, k, do_numeric, &devfs_components);
if (devfs_components.all_leaves_searched != 0) {
devfs_components.all_leaves_searched=0;
break;
}
}
sg_fd = open(fname, flags | O_NONBLOCK);
if (fdevname && fdebug)
fprintf(fdlog, "k=%d, %s open, sg_fd = %d\n", k, fname,
sg_fd);
if (sg_fd < 0) {
if (EBUSY == errno) {
printf("%s: device busy (O_EXCL lock), skipping\n",
fname);
continue;
} else if ((ENODEV == errno) || (ENOENT == errno) ||
(ENXIO == errno)) {
++num_errors;
continue;
} else { /* open failed with other error */
if (EACCES == errno)
eacces_err = 1;
sprintf(ebuff, "Error opening %s ", fname);
perror(ebuff);
++num_errors;
continue;
}
}
sts = get_scsi_info(sg_fd, idev, fname,1);
if (sts) {
fprintf(fdlog, "device %s failed with sts = %d, skip\n",
fname, sts);
}
if (sg_fd > 0) {
res = close(sg_fd);
if (res < 0)
fprintf(fdmsg, "Error closing %s, errno = %d\n",
fname, errno);
else
devlist[idev].sgfd = 0; /* set in get_scsi_info() */
}
idev++;
} /*end loop */
ndev = idev;
if (ndev == 0 && errno == ENODEV) { /* CONFIG_CHR_DEV_SG != y ? */
sprintf(output,
"Cant open any SCSI devices.\nMake sure CONFIG_CHR_DEV_SG is set in /usr/src/linux/.config\n");
showit(output);
quit(1);
}
else if (ndev == 0) {
sprintf(output,"Cant open any sg SCSI devices, errno = %d\n",errno);
if (errno == ENOENT)
strcat(output,"Try option -n to change /dev/sg* device names\n");
showit(output);
}
printf("\nEnter Selection ('d' to download, 'q' to quit) : ");
if (fautomodel) {
response = 'd';
printf("%c\n", response);
} else {
response = get_func();
}
if (response == 'q' || response == 'Q')
quit(0);
else if (response == 'd' || response == 'D') { /* do download */
if (fautomodel)
i = get_mdev(model); // get first matching dev
else
i = get_idev(); /* get the device index that the user picks */
if (i == 0xff)
printf("Index out of range, try again.\n");
else { /*index ok */
int numrdy;
idx = i; /* first disk to download */
size = getimage(idx, &image_buffer, 0); /* read in the firmware image */
size_sv = getimage(idx, &servo_buffer, 1); /* read in the servo image */
if (fdebug) {
/*DEBUG*/ fprintf(fdlog, "size = %ld\n", size);
if (size != 0)
fprintf(fdlog, "imgbuf: %02x %02x %02x %02x \n",
image_buffer[0], image_buffer[1],
image_buffer[2], image_buffer[3]);
if (!fautomodel) {
do_pause();
}
}
if (size == 0)
idx = ndev; /* error, skip download */
else { /* image ok */
rc = beforedl(idx, &numrdy);
if (numrdy == 0)
idx = ndev;
/* download the image to each matching disk */
for (i = idx; i < ndev; i++) {
if (devlist[I.fdoit) {
struct SCSI_INQUIRY *scsi_inq;
char fservo;
/* decide which download method to use */
scsi_inq =
(struct SCSI_INQUIRY *) devlist[I.inq;
if ((devlist[I.inq[0] & 0x1F) == 1) { /* devtype == tape */
if (strncmp
((char *) scsi_inq->vendorid,
"SEAGATE", 7) != 0)
fservo = 3; /* Seagate tapes use split buffer method 3 */
/* Tecmar, Travan, Wangtek, WangDAT tapes use method 2 */
else
fservo = 2; /* use split buffer method 2 */
}
else
if (
(strncmp
((char *) scsi_inq->vendorid, "IBM",
3) == 0)
&&
(strncmp
((char *) scsi_inq->productid, "ST",
2) != 0))
/* for all IBM disks, except Seagate OEM */
fservo = 4; /* IBM disks use split buffer method X */
else
fservo = 0; /* normal, all one buffer */
if (size > 0) { /* flash firmware */
rc =
writeimage(i, image_buffer, size,
fservo);
free(image_buffer); /*allocated in getimage() */
if (fdebug && rc != 0) {
showit((char *) disk_buffer); /*writes saved messages */
quit(rc);
}
}
if (size_sv > 0) { /* flash servo */
rc =
writeimage(i, servo_buffer, size_sv,
1);
free(servo_buffer); /*allocated in getimage() */
}
}
if (!fautomodel)
i = ndev; /* only do one if interactive */
} /*endfor each disk */
rc = afterdl();
} /*endif image ok */
} /*end else index ok */
} /*end else do download */
else { /* response not d or q */
printf("Invalid input [%c], enter 'd' or 'q'.\n", response);
}
if (fautomodel) { /* then done */
if (0) { /* if root is down and likely to hang otherwise, */
printf("Rebooting ...\n");
sleep(3);
// /* do reboot without shutdown */
} else
quit(0); /* normal exit, successful */
} else { /* interactive, go to menu again */
do_pause();
}
} /*end while(1) */
} /*end main() */

    ulong getimage(int idx, uchar ** pbuf, char fservo)
{
ulong filsz;
FILE *fdimg;
struct stat statbuf;
struct SCSI_INQUIRY *scsi_inq;
char modelx[20];
char *filenm;
char fullfilenm[80];
char *buf;
int i, rc;
*pbuf = NULL;
scsi_inq = (struct SCSI_INQUIRY *) devlist[idx].inq;
if (fautomodel)
strncpy(modelx, model, strlen(model));
else
strncpy(modelx, (char *) scsi_inq->productid, 16);
for (i = 0; i < 16; i++) /* eliminate trailing spaces */
if (modelx[I == ' ')
break;
modelx[I = 0; /*stringify */
if (fdebug) {
/*DEBUG*/ fprintf(fdlog, "get image idx=%d\n", idx);
fprintf(fdlog, "fw file: %s\n", fwfile);
fprintf(fdlog,
"___________ 0....+....1....+....2....+....3....+....4\n");
fprintf(fdlog, "scsi_inq[8]: %s\n", &devlist[idx].inq[8]);
}
if (fservo != 1) {
sprintf(output, "Selected %d: [%d:%d] %s\n", idx,
devlist[idx].chn, devlist[idx].tgt, scsi_inq->vendorid);
showit(output);
}
if (!fsetfile) { /* build the default filename */
for (i = 0; i < 8; i++) { /*limit filename to 8 chars */
if (modelx[I == ' ')
break;
else
fwfile[I = tolower(modelx[I);
}
fwfile[I = 0;
strcat(fwfile, fwsufx);
}
if (fservo == 1) {
char *p;
filenm = fwfile;
strcpy(svfile, fwfile); /* servo filename */
p = strrchr(svfile, '.'); /* find last '.' in filename */
strcpy(++p, "tms"); /* skip '.', add new suffix */
filenm = svfile;
} else
filenm = fwfile;
if (fdebug)
fprintf(fdlog, "fw filename: %s\n", filenm);
/* open file */
fdimg = fopen(filenm, "r"); /* try current directory */
if (fdimg == NULL) { /* if error, set default directory */
strcpy(fullfilenm,defdir);
strcat(fullfilenm,filenm);
filenm = fullfilenm;
}
fdimg = fopen(filenm, "r"); /* try default directory */
if (fdimg == NULL) {
if (fservo == 1) {
if (fdebug)
fprintf(fdlog, "Cannot open %s, errno = %d\n", filenm,
errno);
sprintf(output, "No servo image\n");
} else
sprintf(output, "Cannot open %s, errno = %d\n", filenm, errno);
showit(output);
return (0); /* size = 0 */
}
/* get image file size */
if (fstat(fileno(fdimg), &statbuf) < 0) {
sprintf(output, "Can't get size of %s, errno = %d\n", filenm,
errno);
showit(output);
fclose(fdimg);
return (0); /* size = 0 */
}
filsz = statbuf.st_size;
buf = malloc(filsz);
if (buf == NULL) {
sprintf(output,
"Cannot allocate %ld bytes of memory, errno = %d.\n",
filsz, errno);
showit(output);
fclose(fdimg);
return (0); /* size = 0 */
}
/* read in the image file */
sprintf(output, "Reading image file %s, size = %ld\n", filenm, filsz);
showit(output);
rc = fread(buf, filsz, 1, fdimg);
if (rc == -1) {
sprintf(output, "Error reading %s, errno = %d.\n", filenm, errno);
showit(output);
fclose(fdimg);
free(buf);
return (0); /* size = 0 */
}
if (fservo != 1) {
char fscanmodel;
fscanmodel = 0;
if (strncmp((char *) scsi_inq->vendorid, "SEAGATE", 7) == 0) {
if (modelx[7] == 'W')
modelx[7] = 'N'; /*always match with narrow */
modelx[8] = 0; /* truncate to 8 chars for search */
fscanmodel = 1;
} else if (strncmp((char *) scsi_inq->vendorid, "IBM", 3) == 0)
fscanmodel = 1;
else if (strncmp((char *) scsi_inq->vendorid, "MAXTOR", 6) == 0)
fscanmodel = 1;
else if (strncmp((char *) scsi_inq->vendorid, "QUANTUM", 7) == 0)
fscanmodel = 1;
/* HITACHI and FUJITSU only have partial model strings to match */
if (fscanmodel) { /* scan image buffer for model(productid) */
/* A variable offset in the file has a list of the target models. */
rc = findmatch(buf, filsz, modelx, strlen(modelx), 1); /*also ignore case */
if (rc == -1) {
sprintf(output, "Image does not match model %s\n", modelx);
showit(output);
fclose(fdimg);
free(buf);
return (0); /* size = 0 */
}
if (fdebug) {
sprintf(output, "Image file matches model %s\n", modelx);
showit(output);
}
} /*endif scanmodel */
}
/*endif not servo */
*pbuf = buf;
fclose(fdimg);
return (filsz);
} /*end getimage() */

    int write_buffers(int sgfd, uchar * buf, ulong len, uchar fservo)
{
int sts;
ulong j, sz_left;
ulong max_chunk;
uchar save_mode;
uchar bufid;
uchar ebuf[20];
if (fservo >= 2) {
if (fservo == 3) { /* Seagate tapes */
max_chunk = 0x4000;
save_mode = 0x07;
} else if (fservo == 2) { /* other tapes */
max_chunk = 0x8000;
save_mode = 0x05;
} else // if (fservo == 4) { /* IBM disks */
{
max_chunk = 0x8000; /* get this from mode page C7, bytes 16-18 */
save_mode = 0x05;
if (fdebug)
fprintf(fdlog, "IBM split buffer mode, chunk size = %ld\n",
max_chunk);
j = 0;
sz_left = len;
bufid = 0;
while (sz_left > max_chunk) {
/* Note that it uses mode 05 for every chunk, not just last one */
sts =
write_buffer(sgfd, &buf[j], max_chunk, save_mode,
bufid);
if (sts != 0) {
unsigned int k, a, q;
int rc;
rc = get_sense(sts, ebuf);
k = ebuf[2] & 0x0f; /*Sense Key */
a = ebuf[12];
/*ASC*/ q = ebuf[13];
/*ASCQ*/
sprintf(output, "wb sense error: %x/%x/%x\n", k, a,
q);
showit(output);
if (k == 03 && a == 0x30)
printf("Overlay upload error\n");
else if ((k == 2 || k == 3 || k == 4) &&
(a == 0x40 && q <= 0x85))
printf("Microcode Load Failure\n");
return (sts);
}
sz_left -= max_chunk;
j += max_chunk;
bufid++;
}
sts = write_buffer(sgfd, &buf[j], sz_left, save_mode, bufid);
return (sts);
} /*endelse IBM disks */
/* Handle the split buffer scheme */
/* This assumes that the start address is zero for all. */
bufid = 0;
j = 0;
sz_left = len;
while (sz_left > max_chunk) {
sts = write_buffer(sgfd, &buf[j], max_chunk, 0x04, bufid);
if (sts != 0)
return (sts);
sz_left -= max_chunk;
j += max_chunk;
}
sts = write_buffer(sgfd, &buf[j], sz_left, save_mode, bufid);
}
/*endif split buffer scheme */
else { /* fservo == 0, or fservo == 1 */
/* Send it all as one big buffer */
sts = write_buffer(sgfd, buf, len, 0x05, 0L);
}
return (sts);
} /* end write_buffers() */

    
int writeimage(int idx, uchar * imgbuf, ulong len, char fservo)
{
int sts;
int devfd;
int isave;
ulong ltime, ltime1, ltime2;
ulong ltime3;
int i, rc, rcdl;
int k, a, q;
char *tag;
uchar ch, dv;
isave = idx;
rcdl = 0;
/* Download firmware to this disk */
{
rcdl = 0;
fdoreset = 0;
if (!fautomodel)
idx = isave; /* only do selected disk */
devfd = devlist[idx].sgfd;
ch = devlist[idx].chn;
dv = devlist[idx].tgt;
if (devlist[idx].fdoit == 1) {
if (fautomodel) {
/* Sometimes next device may have a unit attention/reset check
* condition pending, so clear that first before the write_buffer.
*/
sts = test_unit_ready(devfd, 0);
if (fdebug)
fprintf(fdlog, "Extra test_unit_ready sts = %x\n",
sts);
}
time((time_t *) & ltime1); // get the start time
/* start the firmware download */
if (fservo == 1)
tag = "Servo";
else
tag = "Firmware";
sprintf(output, "Downloading %s image to disk %d %s",
tag, idx, ctime((long *) // ctime outputs a '\n' at end
showit(output);
sts = write_buffers(devfd, imgbuf, len, fservo);
if (sts) {
rcdl = sts;
sprintf(output, "[%d] Error %d in writing buffer\n", idx,
sts);
showit(output); // fdlog closed
if (fdebug || !fautomodel) {
return (rcdl); // (only if debug on)
}
}
if (fautomodel && rcdl != 0) {
/* Save error for logging later */
sprintf(output, "[%d] %s download error, status = 0x%x\n",
idx, tag, rcdl);
strcat((char *) disk_buffer, output);
/* Try to restart the drive, even if the download failed. */
return (rcdl); /*skip to next one if error */
}
// Test if Unit is Ready again
sprintf(output, "Waiting for disk to come ready again ");
showit(output);
sleep(sdelay); /* wait for the drive to reset and come ready */
for (i = 0; i < 30 && sts; i++) {
// sts = restart_device(devfd,devlist[idx].dstat);
sts = test_unit_ready(devfd, 0);
if (sts == SCHECK_CND) { /* check for certain key/asc/ascq values */
rc = get_sense(sts, sense_buffer);
k = sense_buffer[2] & 0x0f; /*Sense Key */
a = sense_buffer[12];
/*ASC*/ q = sense_buffer[13];
/*ASCQ*/ if (k == 2 && a == 4 && q == 2) {
/* 02-04-02 means it needs a start command, so issue it. */
sts = start_unit(devfd);
if (fdebug) {
/*DEBUG*/
sprintf(output, "\nStart Unit: sts=%d, ",
sts);
showit(output);
}
} /*endif 02-04-02 */
} /*endif sts */
else {
k = 0;
a = 0;
q = 0;
}
if (fdebug) {
sprintf(output, "[%d: %d %d %d]", sts, k, a, q);
showit(output);
}
fprintf(fdmsg, ".");
sleep(3);
} /* end TUR for loop */
showit("\n");
// filesok = 1; /* afterdl allows files to be opened again */
if (sts < 0) { /* still not ready, needs a reset */
fdoreset = 1;
sts = scsi_reset(devfd, 3);
if (sts) {
sprintf(output,
"Error %d during SCSI reset of channel\n",
sts);
strcat((char *) disk_buffer, output);
} else {
sprintf(output,
"SCSI reset of channel %d successful\n", ch);
strcat((char *) disk_buffer, output);
}
if (fdebug)
do_pause();
sleep(1);
sts = test_unit_ready(devfd, 0); /*first may get check condition */
sts = test_unit_ready(devfd, 1);
}
if (sts) { /* TUR status reports not ready */
rcdl = 0x1000 | sts;
sprintf(output,
"[%d] Did not come ready after download, (%d)\n",
idx, sts);
showit(output); // fdlog closed, so ok
} /*endif not ready */
else { /* successful download */
sprintf(output, "[%d] Successful %s download\n", idx, tag);
showit(output); // fdlog closed, so ok
}
if (fdebug) {
time((time_t *) & ltime3); // get the interval time into ltime3
sprintf(output,
"[%d] write_buffer complete, sts = 0x%x, elapsed secs %02ld\n",
idx, rcdl, ltime3 - ltime1);
showit(output);
}
/* Set the timeout shorter. */
k = 500;
sts = ioctl(devfd, 0x2201, &k); /* SG_SET_TIMEOUT */
// if (sts < 0) just continue
// First SCSI command after this may time out, so send a dummy command.
sts = scsi_inquiry(devfd, devstat, 80); // do a dummy inquiry
if (fdebug)
fprintf(fdmsg, "dummy inq sts = %d\n", sts); // should be ok now
if (sts != 0)
rcdl = 0x3000 | sts; // use status from inquiry
/* Dont make a device online if it was offline before we started. */
sts = test_unit_ready(devfd, 0); /*first may get check condition */
if (fdebug)
fprintf(fdmsg, "dummy tur sts = %d\n", sts); // should be ok now
/* may get 06/29/04 here */
/* Set the timeout shorter. */
k = 6000;
sts = ioctl(devfd, 0x2201, &k); /* SG_SET_TIMEOUT */
// if (sts < 0) just continue
time((time_t *) & ltime2); // get the end time into ltime2
ltime = ltime2 - ltime1; // total time in seconds
ltime1 = ltime / 3600; // num hours
ltime = ltime % 3600; // remainder, minutes & seconds
sprintf(output, "\t\t elapsed time %02ld:%02ld:%02ld\n",
ltime1, ltime / 60, ltime % 60);
showit(output); // fdlog closed, so ok
/* save result for logging later */
sprintf(output,
"[%d] %s download complete, status = 0x%x, elapsed time %02ld:%02ld:%02ld\n",
idx, tag, rcdl, ltime1, ltime / 60, ltime % 60);
strcat((char *) disk_buffer, output);
if ((rcdl & 0x0FFF) == SCHECK_CND) {
sprintf(output, " Sense data: %02x %02x %02x\n",
sense_buffer[2] & 0x0f, sense_buffer[12],
sense_buffer[13]);
strcat((char *) disk_buffer, output);
}
if (fdebug && rcdl != 0) {
return (rcdl); /* return (only if debug on) */
}
if (!fautomodel)
idx = ndev; /* end loop */
} /*endif fdoit */
} /*endfor each disk */
return (rcdl);
} /*end writeimage() */

    int beforedl(int idx, int *pnumrdy)
{
struct SCSI_INQUIRY *scsi_inq;
int sts;
int sgfd;
int isave, nrdy;
char *pl;
int i, rc, rcdl;
int k, a, q;
int openflags;
char *fname;
int dbglvl;
isave = idx;
nrdy = 0;
sts = 0;
rcdl = 0;
openflags = O_RDWR; /* | O_NONBLOCK; */

     /* if fautomodel, use global model from optarg */
if (!fautomodel) {
scsi_inq = (struct SCSI_INQUIRY *) devlist[idx].inq;
strncpy(model, (char *) scsi_inq->productid, 8);
model[8] = 0; /*stringify */
}
for (idx = 0; idx < ndev; idx++) {
if (!fautomodel)
idx = isave; /* only do selected disk */
fname = devlist[idx].fname;
sgfd = open(fname, openflags); /* open blocking */
if (sgfd < 0) {
printf("%s: open error, errno = %d\n", fname, errno);
return (errno);
}
devlist[idx].sgfd = sgfd;
if (fdebug) dbglvl = 10;
else dbglvl = 5;
sts = set_sg_debug(sgfd, dbglvl);
if (sts) {
sprintf(output, "[%d] cant set debug level %d, sts = %d",
idx, dbglvl, sts);
showit(output);
}
scsi_inq = (struct SCSI_INQUIRY *) devlist[idx].inq;
if (fdebug)
/*DEBUG*/
fprintf(fdlog,
"Doing Test Unit Ready on idx = %d, model=%s\n",
idx, model);
if (strncmp(model, (char *) scsi_inq->productid, 8) == 0) { /* do only ones of the same disk product id */
sts = test_unit_ready(sgfd, 0);
if (sts == SCHECK_CND) { /* not ready initially, try to make it ready */
i = get_sense(sts, sense_buffer);
k = sense_buffer[2] & 0x0f; /*Sense Key */
a = sense_buffer[12];
/*ASC*/ q = sense_buffer[13];
/*ASCQ*/ if (k == 2 && a == 4 && q == 2) {
/* 02-04-02 means it needs a start command, so issue it. */
sts = start_unit(sgfd);
if (fdebug) {
/*DEBUG*/ printf("\nStart Unit: sts=%d, ", sts);
if (sts == SCHECK_CND) {
rc = get_sense(sts, sense_buffer);
printf("sense data: %x %x %x\n",
sense_buffer[2] & 0x0f,
sense_buffer[12], sense_buffer[13]);
}
}
} /*endif 02-04-02 */
sts = test_unit_ready(sgfd, 1); /* try again */
}
if (sts) {
sprintf(output, "[%d] Error %d from Test Unit Ready\n",
idx, sts);
showit(output);
devlist[idx].fdoit = 0;
if (fnotur) {
devlist[idx].fdoit = 1;
nrdy++;
}
} else {
devlist[idx].fdoit = 1;
sprintf(output, "Device [%d] is ready for download\n",
idx);
showit(output);
nrdy++; /* number ready to download */
}
} else
devlist[idx].fdoit = 0; /* not same product id */
if (!fautomodel)
idx = ndev; /* end loop */
} /* end for devlist TUR loop */
*pnumrdy = nrdy; /* set return value */
if (nrdy == 0) {
sprintf(output, "There are no ready devices for model %s.\n",
model);
showit(output);
return (sts);
} else {
if (nrdy > 1)
pl = "s";
else
pl = "";
sprintf(output, "Starting download process for %d disk%s.\n", nrdy,
pl);
showit(output);
}
closelog(); /* sets flogopen to false */
filesok = 0; /* allows files to be opened again */
fflush(fdmsg); /* flush stdout/stderr for messages */
setbuf(fdmsg, NULL); /* set for unbuffered writes */
sync();
sync(); /* write all UNIX buffers to disk */
sleep(2);
/* can't have any more disk IOs from here on */
if (0) { /* fumntroot) *//* unmount root by default, skip it if user says not to. */
fprintf(fdmsg, "Unmounting root ...");
// rc = uadmin(4, 128, 0); /* unmount root fs */
if (rc == 0)
fprintf(fdmsg, "done\n");
else
fprintf(fdmsg, "rc = %d\n", rc);
// frootdown = 1;
}
/* Take all drives offline first if specified. */
disk_buffer[0] = 0; /* used for messages later */
return (rcdl);
} /*end beforedl() */

    
int afterdl(void)
{
int i, sts;
sts = 0;
/* Bring all drives online again if raid */
/* done, all drives should be ready now */
filesok = 1; /* allows files to be opened again */
showit((char *) disk_buffer); /* writes saved messages */
for (i = 0; i < ndev; i++) {
if (devlist[I.sgfd > 0) {
sts = set_sg_debug(devlist[I.sgfd, 0);
if (sts && fdebug)
fprintf(fdlog, "[%d] cant clear debug flag, sts=%d errno=%d\n",
i, sts, errno);
close(devlist[I.sgfd); /*opened in beforedl() */
devlist[I.sgfd = 0;
}
}
return (sts);
} /*end afterdl() */

    /* end sgdskfl.c */