/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (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

 */

/*

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * This file contains routines to analyze the surface of a disk.

 */

#include "global.h"

#include "analyze.h"

#include <stdlib.h>

#include <errno.h>

#include "misc.h"

#include "defect.h"

#include "label.h"

#include "param.h"

/*

 * These global variables control the surface analysis process.  They

 * are set from a command in the defect menu.

 */

int	scan_entire = 1;		/* scan whole disk flag */

diskaddr_t	scan_lower = 0;			/* lower bound */

diskaddr_t	scan_upper = 0;			/* upper bound */

int	scan_correct = 1;		/* correct errors flag */

int	scan_stop = 0;			/* stop after error flag */

int	scan_loop = 0;			/* loop forever flag */

int	scan_passes = 2;		/* number of passes */

int	scan_random = 0;		/* random patterns flag */

int	scan_size = 0;			/* sectors/scan operation */

int	scan_auto = 1;			/* scan after format flag */

int	scan_restore_defects = 1;	/* restore defect list after writing */

int	scan_restore_label = 1;		/* restore label after writing */

/*

 * These are summary variables to print out info after analysis.

 * Values less than 0 imply they are invalid.

 */

offset_t	scan_cur_block = -1;		/* current block */

int64_t		scan_blocks_fixed = -1;		/* # blocks repaired */

/*

 * This variable is used to tell whether the most recent surface

 * analysis error was caused by a media defect or some other problem.

 */

int	media_error;			/* error was caused by defect */

int	disk_error;			/* disk errors during analysis */

/*

 * These are the data patterns used if random patterns are not chosen.

 * They are designed to show pattern dependent errors.

 */

static unsigned int	scan_patterns[] = {

	0xc6dec6de,

	0x6db6db6d,

	0x00000000,

	0xffffffff,

	0xaaaaaaaa,

};

#define	NPATTERNS	5		/* number of predefined patterns */

/*

 * These are the data patterns from the SunFed requirements document.

 */

static unsigned int purge_patterns[] = {	/* patterns to be written */

	0xaaaaaaaa,		/* 10101010... */

	0x55555555,		/* 01010101...  == UUUU... */

	0xaaaaaaaa,		/* 10101010... */

	0xaaaaaaaa,		/* 10101010... */

};

static unsigned int alpha_pattern =  0x40404040;   /* 10000000...  == @@@@... */

/* Function prototypes */

#ifdef	__STDC__

static int	scan_repair(diskaddr_t bn, int mode);

static int	analyze_blocks(int flags, diskaddr_t blkno, int blkcnt,

		unsigned data, int init, int driver_flags, int *xfercntp);

static int	handle_error_conditions(void);

static int	verify_blocks(int flags, diskaddr_t blkno, int blkcnt,

		unsigned data, int driver_flags, int *xfercntp);

#else	/* __STDC__ */

static int	scan_repair();

static int	analyze_blocks();

static int	handle_error_conditions();

static int	verify_blocks();

#endif	/* __STDC__ */

/*

 * This routine performs a surface analysis based upon the global

 * parameters.  It is called from several commands in the defect menu,

 * and from the format command in the command menu (if post-format

 * analysis is enable).

 */

int

do_scan(flags, mode)

	int	flags, mode;

{

	diskaddr_t	start, end, curnt;

	int	pass, size, needinit, data;

	int	status, founderr, i, j;

	int	error = 0;

	int	pattern = 0;

	int	xfercnt;

	/*

	 * Check to be sure we aren't correcting without a defect list

	 * if the controller can correct the defect.

	 */

	if (scan_correct && !EMBEDDED_SCSI && (cur_ops->op_repair != NULL) &&

			(cur_list.list == NULL)) {

		err_print("Current Defect List must be initialized ");

		err_print("to do automatic repair.\n");

		return (-1);

	}

	/*

	 * Define the bounds of the scan.

	 */

	if (scan_entire) {

		start = 0;

	    if (cur_label == L_TYPE_SOLARIS) {

		if (cur_ctype->ctype_flags & CF_SCSI)

			end = datasects() - 1;

		else

			end = physsects() - 1;

	    } else if (cur_label == L_TYPE_EFI) {

		end = cur_parts->etoc->efi_last_lba;

	    }

	} else {

		start = scan_lower;

		end = scan_upper;

	}

	/*

	 * Make sure the user knows if we are scanning over a mounted

	 * partition.

	 */

	if ((flags & (SCAN_PATTERN | SCAN_WRITE)) &&

	    (checkmount(start, end))) {

		err_print("Cannot do analysis on a mounted partition.\n");

		return (-1);

	}

	/*

	 * Make sure the user knows if we are scanning over a

	 * partition being used for swapping.

	 */

	if ((flags & (SCAN_PATTERN | SCAN_WRITE)) &&

	    (checkswap(start, end))) {

		err_print("Cannot do analysis on a partition \

which is currently being used for swapping.\n");

		return (-1);

	}

	/*

	 * If we are scanning destructively over certain sectors,

	 * we mark the defect list and/or label dirty so it will get rewritten.

	 */

	if (flags & (SCAN_PATTERN | SCAN_WRITE)) {

	    if (cur_label == L_TYPE_SOLARIS) {

		if (start < (daddr_t)totalsects() &&

				end >= (daddr_t)datasects()) {

			if (!EMBEDDED_SCSI) {

				cur_list.flags |= LIST_DIRTY;

			}

			if (cur_disk->disk_flags & DSK_LABEL)

				cur_flags |= LABEL_DIRTY;

		}

	    }

	    if (start == 0) {

		if (cur_disk->disk_flags & DSK_LABEL)

			cur_flags |= LABEL_DIRTY;

	    }

	}

	/*

	 * Initialize the summary info on sectors repaired.

	 */

	scan_blocks_fixed = 0;

	/*

	 * Loop through the passes of the scan. If required, loop forever.

	 */

	for (pass = 0; pass < scan_passes || scan_loop; pass++) {

		/*

		 * Determine the data pattern to use if pattern testing

		 * is to be done.

		 */

		if (flags & SCAN_PATTERN) {

			if (scan_random)

				data = (int)mrand48();

			else

				data = scan_patterns[pass % NPPATTERNS];

			if (flags & SCAN_PURGE) {

				flags &= ~(SCAN_PURGE_READ_PASS

						| SCAN_PURGE_ALPHA_PASS);

				switch (pattern % (NPPATTERNS + 1)) {

				case NPPATTERNS:

					pattern = 0;

					if (!error) {

					    fmt_print(

"\nThe last %d passes were successful, running alpha pattern pass", NPPATTERNS);

					    flags |= SCAN_PURGE_ALPHA_PASS;

					    data = alpha_pattern;

					} else {

					    data = purge_patterns[pattern];

					    pattern++;

					};

					break;

				case READPATTERN:

					flags |=  SCAN_PURGE_READ_PASS;

				default:

					data = purge_patterns[pattern];

					pattern++;

					break;

				}

			}

			fmt_print("\n        pass %d", pass);

			fmt_print(" - pattern = 0x%x", data);

		} else

			fmt_print("\n        pass %d", pass);

		fmt_print("\n");

		/*

		 * Mark the pattern buffer as corrupt, since it

		 * hasn't been initialized.

		 */

		needinit = 1;

		/*

		 * Print the first block number to the log file if

		 * logging is on so there is some record of what

		 * analysis was performed.

		 */

		if (log_file) {

			pr_dblock(log_print, start);

			log_print("\n");

		}

		/*

		 * Loop through this pass, each time analyzing an amount

		 * specified by the global parameters.

		 */

		xfercnt = 0;

		for (curnt = start; curnt <= end; curnt += size) {

			if ((end - curnt) < scan_size)

				size = end - curnt + 1;

			else

				size = scan_size;

			/*

			 * Print out where we are, so we don't look dead.

			 * Also store it in summary info for logging.

			 */

			scan_cur_block = curnt;

			nolog_print("   ");

			pr_dblock(nolog_print, curnt);

			nolog_print("  \015");

			(void) fflush(stdout);

			disk_error = 0;

			/*

			 * Do the actual analysis.

			 */

			status = analyze_blocks(flags, (daddr_t)curnt, size,

			    (unsigned)data, needinit, (F_ALLERRS | F_SILENT),

			    &xfercnt);

			/*

			 * If there were no errors, the pattern buffer is

			 * still initialized, and we just loop to next chunk.

			 */

			needinit = 0;

			if (!status)

				continue;

			/*

			 * There was an error. Check if surface analysis

			 * can be continued.

			 */

			if (handle_error_conditions()) {

				scan_blocks_fixed = scan_cur_block = -1;

				return (-1);

			}

			/*

			 * There was an error. Mark the pattern buffer

			 * corrupt so it will get reinitialized.

			 */

			needinit = 1;

			/*

			 * If it was not a media error, ignore it.

			 */

			if (!media_error)

				continue;

			/*

			 * Loop 5 times through each sector of the chunk,

			 * analyzing them individually.

			 */

			nolog_print("   ");

			pr_dblock(nolog_print, curnt);

			nolog_print("  \015");

			(void) fflush(stdout);

			founderr = 0;

			for (j = 0; j < size * 5; j++) {

				i = j % size;

				disk_error = 0;

				status = analyze_blocks(flags, (daddr_t)

				    (curnt + i), 1, (unsigned)data, needinit,

				    F_ALLERRS, NULL);

				needinit = 0;

				if (!status)

					continue;

				/*

				 * There was an error. Check if surface analysis

				 * can be continued.

				 */

				if (handle_error_conditions()) {

					scan_blocks_fixed = scan_cur_block = -1;

					return (-1);

				}

				/*

				 * An error occurred.  Mark the buffer

				 * corrupt and see if it was media

				 * related.

				 */

				needinit = 1;

				if (!media_error)

					continue;

				/*

				 * We found a bad sector. Print out a message

				 * and fix it if required.

				 */

				founderr = 1;

				if (scan_correct && (flags != SCAN_VALID)) {

					if (scan_repair(curnt+i, mode)) {

						error = -1;

					}

				} else

					err_print("\n");

				/*

				 * Stop after the error if required.

				 */

				if (scan_stop)

					goto out;

			}

			/*

			 * Mark the pattern buffer corrupt to be safe.

			 */

			needinit = 1;

			/*

			 * We didn't find an individual sector that was bad.

			 * Print out a warning.

			 */

			if (!founderr) {

				err_print("Warning: unable to pinpoint ");

				err_print("defective block.\n");

			}

		}

		/*

		 * Print the end of each pass to the log file.

		 */

		enter_critical();

		if (log_file) {

			pr_dblock(log_print, scan_cur_block);

			log_print("\n");

		}

		scan_cur_block = -1;

		exit_critical();

		fmt_print("\n");

		/*

		 * alternate the read and write for SCAN_VERIFY test

		 */

		if (flags & SCAN_VERIFY) {

			flags ^= SCAN_VERIFY_READ_PASS;

		}

	}

out:

	/*

	 * We got here either by giving up after an error or falling

	 * through after all passes were completed.

	 */

	fmt_print("\n");

	enter_critical();

	/*

	 * If the defect list is dirty, write it to disk,

	 * if scan_restore_defects (the default) is true.

	 */

	if (!EMBEDDED_SCSI && (cur_list.flags & LIST_DIRTY) &&

				(scan_restore_defects)) {

		cur_list.flags = 0;

		write_deflist(&cur_list);

		}

	/*

	 * If the label is dirty, write it to disk.

	 * if scan_restore_label (the default) is true.

	 */

	if ((cur_flags & LABEL_DIRTY) && (scan_restore_label)) {

		cur_flags &= ~LABEL_DIRTY;

		(void) write_label();

	}

	/*

	 * If we dropped down to here after an error, we need to write

	 * the final block number to the log file for record keeping.

	 */

	if (log_file && scan_cur_block >= 0) {

		pr_dblock(log_print, scan_cur_block);

		log_print("\n");

	}

	fmt_print("Total of %lld defective blocks repaired.\n",

		scan_blocks_fixed);

	/*

	 * Reinitialize the logging variables so they don't get used

	 * when they are not really valid.

	 */

	scan_blocks_fixed = scan_cur_block = -1;

	exit_critical();

	return (error);

}

/*

 * This routine is called to repair a bad block discovered

 * during a scan operation.  Return 0 for success, 1 for failure.

 * (This has been extracted out of do_scan(), to simplify it.)

 */

static int

scan_repair(bn, mode)

	diskaddr_t	bn;

	int	mode;

{

	int	status;

	int	result = 1;

	char	buf[SECSIZE];

	int	buf_is_good;

	int	i;

	if (cur_ops->op_repair == NULL) {

		err_print("Warning: Controller does ");

		err_print("not support repairing.\n\n");

		return (result);

	}

	enter_critical();

	/*

	 * Determine if the error appears to be hard or soft.  We

	 * already assume there's an error.  If we can get any

	 * good data out of the sector, write that data back

	 * after the repair.

	 */

	buf_is_good = 0;

	for (i = 0; i < 5; i++) {

		status = (*cur_ops->op_rdwr)(DIR_READ, cur_file, bn, 1,

				buf, F_SILENT, NULL);

		if (status == 0) {

			buf_is_good = 1;

			break;

		}

	}

	fmt_print("Repairing %s error on %llu (",

				buf_is_good ? "soft" : "hard", bn);

	pr_dblock(fmt_print, bn);

	fmt_print(")...");

	status = (*cur_ops->op_repair)(bn, mode);

	if (status) {

		/*

		 * If the repair failed, we note it and will return the

		 * failure. However, the analysis goes on.

		 */

		fmt_print("failed.\n\n");

	} else {

		/*

		 * The repair worked.  Write the good data we could

		 * recover from the failed block, if possible.

		 * If not, zero the block.  In doing so, try to

		 * determine if the new block appears ok.

		 */

		if (!buf_is_good) {

			bzero(buf, SECSIZE);

			fmt_print("Warning: Block %llu zero-filled.\n", bn);

		} else {

			fmt_print("ok.\n");

		}

		status = (*cur_ops->op_rdwr)(DIR_WRITE, cur_file, bn,

					1, buf, (F_SILENT | F_ALLERRS), NULL);

		if (status == 0) {

			status = (*cur_ops->op_rdwr)(DIR_READ, cur_file, bn,

					1, buf, (F_SILENT | F_ALLERRS), NULL);

		}

		if (status) {

			fmt_print("The new block also appears defective.\n");

		}

		fmt_print("\n");

		/*

		 * add the defect to the list and write the list out.

		 * Also, kill the working list so it will get resynced

		 * with the current list.

		 *

		 * For embedded scsi, we don't require a defect list.

		 * However, if we have one, add the defect if the

		 * list includes the grown list.  If not, kill it

		 * to force a resync if we need the list later.

		 */

		if (EMBEDDED_SCSI) {