From nobody@FreeBSD.org  Wed Aug 25 18:28:50 2010
Return-Path: <nobody@FreeBSD.org>
Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34])
	by hub.freebsd.org (Postfix) with ESMTP id F18BB106566C
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 25 Aug 2010 18:28:49 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from www.freebsd.org (www.freebsd.org [IPv6:2001:4f8:fff6::21])
	by mx1.freebsd.org (Postfix) with ESMTP id DF39B8FC12
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 25 Aug 2010 18:28:49 +0000 (UTC)
Received: from www.freebsd.org (localhost [127.0.0.1])
	by www.freebsd.org (8.14.3/8.14.3) with ESMTP id o7PISnKs062451
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 25 Aug 2010 18:28:49 GMT
	(envelope-from nobody@www.freebsd.org)
Received: (from nobody@localhost)
	by www.freebsd.org (8.14.3/8.14.3/Submit) id o7PISnUL062450;
	Wed, 25 Aug 2010 18:28:49 GMT
	(envelope-from nobody)
Message-Id: <201008251828.o7PISnUL062450@www.freebsd.org>
Date: Wed, 25 Aug 2010 18:28:49 GMT
From: Tom Couch <tom.couch@lsi.com>
To: freebsd-gnats-submit@FreeBSD.org
Subject: Kernel panic with ZFS and twa version 3.80.06.002
X-Send-Pr-Version: www-3.1
X-GNATS-Notify:

>Number:         149968
>Category:       kern
>Synopsis:       [twa] [patch] Kernel panic with ZFS and twa version 3.80.06.002
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    delphij
>State:          closed
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          sw-bug
>Submitter-Id:   current-users
>Arrival-Date:   Wed Aug 25 18:30:06 UTC 2010
>Closed-Date:    Thu Oct 14 22:31:02 UTC 2010
>Last-Modified:  Wed Feb  5 09:50:00 UTC 2014
>Originator:     Tom Couch
>Release:        8.1-RELEASE-amd64-all
>Organization:
LSI Corporation
>Environment:
FreeBSD MacSolaris4 8.1-RELEASE FreeBSD 8.1-RELEASE #14: Thu Jul 29 17:28:47 PDT 2010     tcouch@MacSolaris4:/usr/obj/usr/src/sys/MACSOLARIS4  amd64
>Description:
Kernel panic on ZFS using twa driver 3.80.06.002 under heavy IO.
>How-To-Repeat:
  Create a unit (single drive is OK) with the CLI tool:
  % tw_cli /c0 add type=single drive=3

  Create a zpool on the unit:
  % zpool create my_zpool /dev/da0

  Trigger the kernel panic:
  % dd if=/dev/urandom of=/my_zpool/testfile bs=1M count=3000; sync

  Kernel panic happens at this point.
  The system may need a hard reboot to recover.
>Fix:
For FreeBSD HEAD, use twa driver version 3.80.06.003
For FreeBSD 8.x,  use twa driver version 3.80.06.003
For FreeBSD 7.x,  use twa driver version 3.70.05.010
                -OR-
Apply the attached driver patch.

Patch attached with submission follows:

diff -u FreeBSD_HEAD_twa_cvs/tw_cl.h FreeBSD_HEAD_twa_3_80_06_003/tw_cl.h
--- FreeBSD_HEAD_twa_cvs/tw_cl.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl.h	2010-08-24 18:02:12.000000000 -0700
@@ -88,7 +88,8 @@
 #define TW_CLI_BUSY_Q		1	/* q of reqs submitted to fw */
 #define TW_CLI_PENDING_Q	2	/* q of reqs deferred due to 'q full' */
 #define TW_CLI_COMPLETE_Q	3	/* q of reqs completed by fw */
-#define TW_CLI_Q_COUNT		4	/* total number of queues */
+#define TW_CLI_RESET_Q		4	/* q of reqs reset by timeout */
+#define TW_CLI_Q_COUNT		5	/* total number of queues */
 
 
 /* CL's internal request context. */
@@ -133,6 +134,7 @@
 	TW_UINT8 		interrupts_enabled;	  /* Interrupts on controller enabled. */
 	TW_UINT8 		internal_req_busy;	  /* Data buffer for internal requests in use. */
 	TW_UINT8 		get_more_aens;		  /* More AEN's need to be retrieved. */
+	TW_UINT8 		reset_needed;		  /* Controller needs a soft reset. */
 	TW_UINT8 		reset_in_progress;	  /* Controller is being reset. */
 	TW_UINT8 		reset_phase1_in_progress; /* In 'phase 1' of reset. */
 	TW_UINT32		flags;		/* controller settings */
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_externs.h FreeBSD_HEAD_twa_3_80_06_003/tw_cl_externs.h
--- FreeBSD_HEAD_twa_cvs/tw_cl_externs.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_externs.h	2010-08-24 18:02:12.000000000 -0700
@@ -86,6 +86,8 @@
 
 /* Soft reset the controller. */
 extern TW_INT32	tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr);
+extern int twa_setup_intr(struct twa_softc *sc);
+extern int twa_teardown_intr(struct twa_softc *sc);
 
 /* Send down a SCSI command to the firmware (usually, an internal Req Sense. */
 extern TW_INT32	tw_cli_send_scsi_cmd(struct tw_cli_req_context *req,
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_fwif.h FreeBSD_HEAD_twa_3_80_06_003/tw_cl_fwif.h
--- FreeBSD_HEAD_twa_cvs/tw_cl_fwif.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_fwif.h	2010-08-24 18:02:12.000000000 -0700
@@ -89,7 +89,7 @@
 #define TWA_STATUS_MINOR_VERSION_MASK		0x0F000000
 #define TWA_STATUS_MAJOR_VERSION_MASK		0xF0000000
 
-#define TWA_STATUS_UNEXPECTED_BITS		0x00F00000
+#define TWA_STATUS_UNEXPECTED_BITS		0x00D00000
 
 
 /* PCI related defines. */
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_init.c FreeBSD_HEAD_twa_3_80_06_003/tw_cl_init.c
--- FreeBSD_HEAD_twa_cvs/tw_cl_init.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_init.c	2010-08-24 18:02:12.000000000 -0700
@@ -315,6 +315,7 @@
 	tw_cli_req_q_init(ctlr, TW_CLI_BUSY_Q);
 	tw_cli_req_q_init(ctlr, TW_CLI_PENDING_Q);
 	tw_cli_req_q_init(ctlr, TW_CLI_COMPLETE_Q);
+	tw_cli_req_q_init(ctlr, TW_CLI_RESET_Q);
 
 	/* Initialize all locks used by CL. */
 	ctlr->gen_lock = &(ctlr->gen_lock_handle);
@@ -675,15 +676,14 @@
 	/* Submit the command, and wait for it to complete. */
 	error = tw_cli_submit_and_poll_request(req,
 		TW_CLI_REQUEST_TIMEOUT_PERIOD);
-	if (error == TW_OSL_ETIMEDOUT)
-		/* Clean-up done by tw_cli_submit_and_poll_request. */
-		return(error);
 	if (error)
 		goto out;
 	if ((error = init_connect->status)) {
+#if       0
 		tw_cli_create_ctlr_event(ctlr,
 			TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 			&(req->cmd_pkt->cmd_hdr));
+#endif // 0
 		goto out;
 	}
 	if (set_features & TWA_EXTENDED_INIT_CONNECT) {
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_intr.c FreeBSD_HEAD_twa_3_80_06_003/tw_cl_intr.c
--- FreeBSD_HEAD_twa_cvs/tw_cl_intr.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_intr.c	2010-08-24 18:02:12.000000000 -0700
@@ -248,8 +248,7 @@
 #ifdef TW_OSL_DEBUG
 			tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
 #endif /* TW_OSL_DEBUG */
-			tw_cl_reset_ctlr(ctlr->ctlr_handle);
-			return(TW_OSL_EIO);
+			continue;
 		}
 
 		/*
@@ -402,9 +401,7 @@
 #ifdef TW_OSL_DEBUG
 		tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
 #endif /* TW_OSL_DEBUG */
-		tw_cl_reset_ctlr(ctlr->ctlr_handle);
-		req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
-		goto out;
+		return;
 	}
 
 	if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
@@ -483,6 +480,7 @@
 			cdb[8], cdb[9], cdb[10], cdb[11],
 			cdb[12], cdb[13], cdb[14], cdb[15]);
 
+#if       0
 		/* 
 		 * Print the error. Firmware doesn't yet support
 		 * the 'Mode Sense' cmd.  Don't print if the cmd
@@ -493,6 +491,7 @@
 			tw_cli_create_ctlr_event(req->ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				cmd_hdr);
+#endif // 0
 	}
 
 	if (scsi_req->sense_data) {
@@ -530,9 +529,11 @@
 	 */
 	if (! req->error_code)
 		if (cmd->param.status) {
+#if       0
 			tw_cli_create_ctlr_event(ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				&(req->cmd_pkt->cmd_hdr));
+#endif // 0
 			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 				0x1204, 0x1, TW_CL_SEVERITY_ERROR_STRING,
@@ -590,9 +591,11 @@
 		if ((error = cmd->status)) {
 			cmd_hdr = (struct tw_cl_command_header *)
 				(&(req->cmd_pkt->cmd_hdr));
+#if       0
 			tw_cli_create_ctlr_event(ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				cmd_hdr);
+#endif // 0
 			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 				0x1206, 0x1, TW_CL_SEVERITY_ERROR_STRING,
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_io.c FreeBSD_HEAD_twa_3_80_06_003/tw_cl_io.c
--- FreeBSD_HEAD_twa_cvs/tw_cl_io.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_io.c	2010-08-24 18:02:12.000000000 -0700
@@ -74,18 +74,12 @@
 	struct tw_cli_req_context		*req;
 	struct tw_cl_command_9k			*cmd;
 	struct tw_cl_scsi_req_packet		*scsi_req;
-	TW_INT32				error;
+	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
 
 	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
 
 	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 
-	if (ctlr->reset_in_progress) {
-		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
-			"I/O during reset: returning busy.");
-		return(TW_OSL_EBUSY);
-	}
-
 	/*
 	 * If working with a firmware version that does not support multiple
 	 * luns, and this request is directed at a non-zero lun, error it
@@ -145,7 +139,12 @@
 			cmd->sg_list, scsi_req->sgl_entries);
 	}
 
-	if ((error = tw_cli_submit_cmd(req))) {
+	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
+		(ctlr->reset_in_progress)) {
+		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
+		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
+			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
+	} else if ((error = tw_cli_submit_cmd(req))) {
 		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 			"Could not start request. request = %p, error = %d",
 			req, error);
@@ -171,7 +170,7 @@
 	struct tw_cli_ctlr_context	*ctlr = req->ctlr;
 	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
 	TW_UINT32			status_reg;
-	TW_INT32			error;
+	TW_INT32			error = 0;
 
 	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
 
@@ -185,11 +184,7 @@
 				 TWA_COMMAND_QUEUE_OFFSET_LOW,
 				 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
 
-	/* Check to see if we can post a command. */
 	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
-	if ((error = tw_cli_check_ctlr_state(ctlr, status_reg)))
-		goto out;
-
 	if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
 		struct tw_cl_req_packet	*req_pkt =
 			(struct tw_cl_req_packet *)(req->orig_req);
@@ -207,14 +202,12 @@
 					"pending internal/ioctl request");
 				req->state = TW_CLI_REQ_STATE_PENDING;
 				tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
-				error = 0;
 				/* Unmask command interrupt. */
 				TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 					TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 			} else
 				error = TW_OSL_EBUSY;
 		} else {
-			tw_osl_ctlr_busy(ctlr_handle, req->req_handle);
 			error = TW_OSL_EBUSY;
 		}
 	} else {
@@ -246,7 +239,7 @@
 						 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
 		}
 	}
-out:
+
 	tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
 
 	return(error);
@@ -277,18 +270,12 @@
 	TW_UINT8				opcode;
 	TW_UINT8				sgl_offset;
 	TW_VOID					*sgl = TW_CL_NULL;
-	TW_INT32				error;
+	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
 
 	tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered");
 
 	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 
-	if (ctlr->reset_in_progress) {
-		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
-			"Passthru request during reset: returning busy.");
-		return(TW_OSL_EBUSY);
-	}
-
 	if ((req = tw_cli_get_request(ctlr
 		)) == TW_CL_NULL) {
 		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
@@ -301,7 +288,7 @@
 	req->orig_req = req_pkt;
 	req->tw_cli_callback = tw_cli_complete_io;
 
-	req->flags |= (TW_CLI_REQ_FLAGS_EXTERNAL | TW_CLI_REQ_FLAGS_PASSTHRU);
+	req->flags |= TW_CLI_REQ_FLAGS_PASSTHRU;
 
 	pt_req = &(req_pkt->gen_req_pkt.pt_req);
 
@@ -348,7 +335,12 @@
 		tw_cli_fill_sg_list(ctlr, pt_req->sg_list,
 			sgl, pt_req->sgl_entries);
 
-	if ((error = tw_cli_submit_cmd(req))) {
+	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
+		(ctlr->reset_in_progress)) {
+		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
+		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
+			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
+	} else if ((error = tw_cli_submit_cmd(req))) {
 		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 			0x1100, 0x1, TW_CL_SEVERITY_ERROR_STRING,
@@ -760,8 +752,7 @@
 
 	cmd->param.sgl_off__opcode =
 		BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_GET_PARAM);
-	cmd->param.request_id =
-		(TW_UINT8)(TW_CL_SWAP16(req->request_id));
+	cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id));
 	cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0);
 	cmd->param.param_count = TW_CL_SWAP16(1);
 
@@ -789,15 +780,14 @@
 		/* There's no call back; wait till the command completes. */
 		error = tw_cli_submit_and_poll_request(req,
 				TW_CLI_REQUEST_TIMEOUT_PERIOD);
-		if (error == TW_OSL_ETIMEDOUT)
-			/* Clean-up done by tw_cli_submit_and_poll_request. */
-			return(error);
 		if (error)
 			goto out;
 		if ((error = cmd->param.status)) {
+#if       0
 			tw_cli_create_ctlr_event(ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				&(req->cmd_pkt->cmd_hdr));
+#endif // 0
 			goto out;
 		}
 		tw_osl_memcpy(param_data, param->data, param_size);
@@ -905,18 +895,17 @@
 
 	/* Submit the command. */
 	if (callback == TW_CL_NULL) {
-		/* There's no call back;  wait till the command completes. */
+		/* There's no call back; wait till the command completes. */
 		error = tw_cli_submit_and_poll_request(req,
-			TW_CLI_REQUEST_TIMEOUT_PERIOD);
-		if (error == TW_OSL_ETIMEDOUT)
-			/* Clean-up done by tw_cli_submit_and_poll_request. */
-			return(error);
+				TW_CLI_REQUEST_TIMEOUT_PERIOD);
 		if (error)
 			goto out;
 		if ((error = cmd->param.status)) {
+#if       0
 			tw_cli_create_ctlr_event(ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				&(req->cmd_pkt->cmd_hdr));
+#endif // 0
 			goto out;
 		}
 		ctlr->internal_req_busy = TW_CL_FALSE;
@@ -1022,9 +1011,7 @@
 	 * tw_cli_submit_pending_queue.  There could be a race in that case.
 	 * Need to revisit.
 	 */
-	if (req->state != TW_CLI_REQ_STATE_PENDING)
-		tw_cl_reset_ctlr(ctlr->ctlr_handle);
-	else {
+	if (req->state == TW_CLI_REQ_STATE_PENDING) {
 		tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(),
 			"Removing request from pending queue");
 		/*
@@ -1053,6 +1040,7 @@
  *			drains any incomplete requests.
  *
  * Input:		ctlr	-- ptr to per ctlr structure
+ * 			req_handle	-- ptr to request handle
  * Output:		None
  * Return value:	0	-- success
  *			non-zero-- failure
@@ -1063,15 +1051,15 @@
 	struct tw_cli_ctlr_context	*ctlr =
 		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 	struct twa_softc		*sc = ctlr_handle->osl_ctlr_ctxt;
+	struct tw_cli_req_context	*req;
 	TW_INT32			reset_attempt = 1;
-	TW_INT32			error;
+	TW_INT32			error = 0;
 
 	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "entered");
 
 	ctlr->reset_in_progress = TW_CL_TRUE;
-	xpt_freeze_simq(sc->sim, 1);
+	twa_teardown_intr(sc);
 
-	tw_cli_disable_interrupts(ctlr);
 
 	/*
 	 * Error back all requests in the complete, busy, and pending queues.
@@ -1080,8 +1068,6 @@
 	 * will continue its course and get submitted to the controller after
 	 * the reset is done (and io_lock is released).
 	 */
-	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
-		"Draining all queues following reset");
 	tw_cli_drain_complete_queue(ctlr);
 	tw_cli_drain_busy_queue(ctlr);
 	tw_cli_drain_pending_queue(ctlr);
@@ -1089,53 +1075,88 @@
 	ctlr->get_more_aens     = TW_CL_FALSE;
 
 	/* Soft reset the controller. */
-try_reset:
-	if ((error = tw_cli_soft_reset(ctlr))) {
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
-			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
-			0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-			"Controller reset failed",
-			"error = %d; attempt %d", error, reset_attempt++);
-		if (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS)
-			goto try_reset;
-		else
-			goto out;
-	}
+	while (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS) {
+		if ((error = tw_cli_soft_reset(ctlr))) {
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
+				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
+				0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
+				"Controller reset failed",
+				"error = %d; attempt %d", error, reset_attempt++);
+			reset_attempt++;
+			continue;
+		}
 
-	/* Re-establish logical connection with the controller. */
-	if ((error = tw_cli_init_connection(ctlr,
-			(TW_UINT16)(ctlr->max_simult_reqs),
-			0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
-			TW_CL_NULL, TW_CL_NULL))) {
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+		/* Re-establish logical connection with the controller. */
+		if ((error = tw_cli_init_connection(ctlr,
+				(TW_UINT16)(ctlr->max_simult_reqs),
+				0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
+				TW_CL_NULL, TW_CL_NULL))) {
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
+				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
+				0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
+				"Can't initialize connection after reset",
+				"error = %d", error);
+			reset_attempt++;
+			continue;
+		}
+
+#ifdef    TW_OSL_DEBUG
+		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
-			0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-			"Can't initialize connection after reset",
-			"error = %d", error);
-		goto out;
-	}
+			0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
+			"Controller reset done!", " ");
+#endif /* TW_OSL_DEBUG */
+		break;
+	} /* End of while */
 
-	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
-		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
-		0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
-		"Controller reset done!",
-		" ");
+	/* Move commands from the reset queue to the pending queue. */
+	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_RESET_Q)) != TW_CL_NULL) {
+		tw_osl_timeout(req->req_handle);
+		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
+	}
 
-out:
+	twa_setup_intr(sc);
+	tw_cli_enable_interrupts(ctlr);
+	if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL)
+		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
+			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 	ctlr->reset_in_progress = TW_CL_FALSE;
-	xpt_release_simq(sc->sim, 1);
+	ctlr->reset_needed = TW_CL_FALSE;
 
-	/*
-	 * Enable interrupts, and also clear attention and response interrupts.
-	 */
-	tw_cli_enable_interrupts(ctlr);
-	
 	/* Request for a bus re-scan. */
-	if (!error)
-		tw_osl_scan_bus(ctlr_handle);
+	tw_osl_scan_bus(ctlr_handle);
+
 	return(error);
 }
 
+TW_VOID
+tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
+{
+	struct tw_cli_ctlr_context	*ctlr =
+		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
+
+	ctlr->reset_needed = TW_CL_TRUE;
+}
+
+TW_INT32
+tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
+{
+	struct tw_cli_ctlr_context	*ctlr =
+		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
+
+	return(ctlr->reset_needed);
+}
+
+TW_INT32
+tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle)
+{
+	struct tw_cli_ctlr_context	*ctlr =
+		(struct tw_cli_ctlr_context *)
+		(ctlr_handle->cl_ctlr_ctxt);
+
+		return(ctlr->active);
+}
+
 
 
 /*
@@ -1151,14 +1172,13 @@
 tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr)
 {
 	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
-	TW_UINT32			status_reg;
 	int				found;
 	int				loop_count;
 	TW_UINT32			error;
 
 	tw_cli_dbg_printf(1, ctlr_handle, tw_osl_cur_func(), "entered");
 
-	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+	tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 		0x1108, 0x3, TW_CL_SEVERITY_INFO_STRING,
 		"Resetting controller...",
@@ -1193,7 +1213,7 @@
 		} while (!found && (loop_count < 6000000)); /* Loop for no more than 60 seconds */
 
 		if (!found) {
-			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 				0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 				"Missed firmware handshake after soft-reset",
@@ -1210,7 +1230,7 @@
 			TWA_STATUS_MICROCONTROLLER_READY |
 			TWA_STATUS_ATTENTION_INTERRUPT,
 			TW_CLI_RESET_TIMEOUT_PERIOD))) {
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 			0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 			"Micro-ctlr not ready/No attn intr after reset",
@@ -1244,26 +1264,14 @@
 	}
 	
 	if ((error = tw_cli_find_aen(ctlr, TWA_AEN_SOFT_RESET))) {
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 			0x110C, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 			"Reset not reported by controller",
 			"error = %d", error);
 		return(error);
 	}
-	
-	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
-	
-	if ((error = TW_CLI_STATUS_ERRORS(status_reg)) ||
-			(error = tw_cli_check_ctlr_state(ctlr, status_reg))) {
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
-			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
-			0x110D, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-			"Controller errors detected after reset",
-			"error = %d", error);
-		return(error);
-	}
-	
+
 	return(TW_OSL_ESUCCESS);
 }
 
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_misc.c FreeBSD_HEAD_twa_3_80_06_003/tw_cl_misc.c
--- FreeBSD_HEAD_twa_cvs/tw_cl_misc.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_misc.c	2010-08-24 18:02:12.000000000 -0700
@@ -83,7 +83,8 @@
 	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 
 	/* Walk the busy queue. */
-	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q))) {
+	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q)) !=
+		TW_CL_NULL) {
 		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
 			/*
 			 * It's an internal request.  Set the appropriate
@@ -97,20 +98,21 @@
 			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
 			if (req->tw_cli_callback)
 				req->tw_cli_callback(req);
-		} else {
-			if ((req_pkt = req->orig_req)) {
-				/* It's a SCSI request.  Complete it. */
-				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
-					tw_osl_cur_func(),
-					"Completing complete request %p "
-					"on reset",
-					req);
+		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
+			/* It's a passthru request.  Complete it. */
+			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
 				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
-				req_pkt->tw_osl_callback(req->req_handle);
+
+				if (req_pkt->tw_osl_callback)
+					req_pkt->tw_osl_callback(req->req_handle);
 			}
 			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
+		} else {
+			/* It's an external (SCSI) request.  Add it to the reset queue. */
+			tw_osl_untimeout(req->req_handle);
+			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
 		}
-	}
+	} /* End of while loop */
 }
 
 
@@ -135,7 +137,8 @@
 	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 
 	/* Walk the busy queue. */
-	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q))) {
+	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q)) !=
+		TW_CL_NULL) {
 		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
 			/*
 			 * It's an internal request.  Set the appropriate
@@ -149,19 +152,21 @@
 			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
 			if (req->tw_cli_callback)
 				req->tw_cli_callback(req);
-		} else {
-			if ((req_pkt = req->orig_req)) {
-				/* It's a SCSI request.  Complete it. */
-				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
-					tw_osl_cur_func(),
-					"Completing busy request %p on reset",
-					req);
+		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
+			/* It's a passthru request.  Complete it. */
+			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
 				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
-				req_pkt->tw_osl_callback(req->req_handle);
+
+				if (req_pkt->tw_osl_callback)
+					req_pkt->tw_osl_callback(req->req_handle);
 			}
 			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
+		} else {
+			/* It's an external (SCSI) request.  Add it to the reset queue. */
+			tw_osl_untimeout(req->req_handle);
+			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
 		}
-	}
+	} /* End of while loop */
 }
 
 
@@ -188,7 +193,8 @@
 	/*
 	 * Pull requests off the pending queue, and complete them.
 	 */
-	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q))) {
+	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q)) !=
+		TW_CL_NULL) {
 		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
 			/*
 			 * It's an internal request.  Set the appropriate
@@ -202,19 +208,21 @@
 			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
 			if (req->tw_cli_callback)
 				req->tw_cli_callback(req);
-		} else {
-			if ((req_pkt = req->orig_req)) {
-				/* It's an external request.  Complete it. */
-				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
-					tw_osl_cur_func(),
-					"Completing pending request %p "
-					"on reset", req);
+		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
+			/* It's a passthru request.  Complete it. */
+			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
 				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
-				req_pkt->tw_osl_callback(req->req_handle);
+
+				if (req_pkt->tw_osl_callback)
+					req_pkt->tw_osl_callback(req->req_handle);
 			}
 			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
+		} else {
+			/* It's an external (SCSI) request.  Add it to the reset queue. */
+			tw_osl_untimeout(req->req_handle);
+			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
 		}
-	}
+	} /* End of while loop */
 }
 
 
@@ -239,9 +247,6 @@
 	for (;;) {
 		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
 
-		if (tw_cli_check_ctlr_state(ctlr, status_reg))
-			return(TW_OSL_EGENFAILURE);
-
 		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
 			return(TW_OSL_ESUCCESS); /* no more response queue entries */
 
@@ -273,9 +278,6 @@
 	for (;;) {
 		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
 
-		if (tw_cli_check_ctlr_state(ctlr, status_reg))
-			return(TW_OSL_EGENFAILURE);
-
 		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
 			return(TW_OSL_ENOTTY); /* no more response queue entries */
 
@@ -356,9 +358,11 @@
 
 		if ((error = req->cmd_pkt->command.cmd_pkt_9k.status)) {
 			cmd_hdr = &req->cmd_pkt->cmd_hdr;
+#if       0
 			tw_cli_create_ctlr_event(ctlr,
 				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 				cmd_hdr);
+#endif // 0
 			break;
 		}
 
@@ -714,7 +718,7 @@
 
 		tw_osl_memzero(desc, 200);
 		if (!(ctlr->reset_phase1_in_progress)) {
-			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 				0x1301, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 				"Missing expected status bit(s)",
@@ -738,7 +742,7 @@
 		     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
 		    (!(ctlr->reset_in_progress)) ||
 		    ((status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) == 0))
-		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 			0x1302, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 			"Unexpected status bit(s)",
@@ -748,7 +752,7 @@
 				TWA_STATUS_UNEXPECTED_BITS, desc));
 
 		if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
-			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 				0x1303, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 				"PCI parity error: clearing... "
@@ -768,7 +772,7 @@
 		}
 
 		if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
-			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 				0x1304, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 				"PCI abort: clearing... ",
@@ -791,7 +795,7 @@
 			if (((ctlr->device_id != TW_CL_DEVICE_ID_9K_E) &&
 			     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
 			    (!(ctlr->reset_in_progress)))
-				tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
+				tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 						   TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 						   0x1305, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 						   "Controller queue error: clearing... ",
@@ -801,17 +805,6 @@
 			TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
 				TWA_CONTROL_CLEAR_QUEUE_ERROR);
 		}
-
-		if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
-			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
-				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
-				0x1307, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-				"Micro-controller error! ",
-				"status reg = 0x%x %s",
-				status_reg,
-				tw_cli_describe_bits(status_reg, desc));
-			error = TW_OSL_EGENFAILURE;
-		}
 	}
 	return(error);
 }	
@@ -850,8 +843,6 @@
 		tw_osl_strcpy(&str[tw_osl_strlen(str)], "HOST_INTR,");
 	if (reg & TWA_STATUS_PCI_ABORT_INTERRUPT)
 		tw_osl_strcpy(&str[tw_osl_strlen(str)], "PCI_ABRT,");
-	if (reg & TWA_STATUS_MICROCONTROLLER_ERROR)
-		tw_osl_strcpy(&str[tw_osl_strlen(str)], "MC_ERR,");
 	if (reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT)
 		tw_osl_strcpy(&str[tw_osl_strlen(str)], "Q_ERR,");
 	if (reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT)
diff -u FreeBSD_HEAD_twa_cvs/tw_cl_share.h FreeBSD_HEAD_twa_3_80_06_003/tw_cl_share.h
--- FreeBSD_HEAD_twa_cvs/tw_cl_share.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_cl_share.h	2010-08-24 18:02:12.000000000 -0700
@@ -349,10 +349,14 @@
 #endif
 
 
-#ifndef tw_osl_ctlr_busy
-/* Called when CL is too busy to accept new requests. */
-extern TW_VOID	tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
-	struct tw_cl_req_handle *req_handle);
+#ifndef tw_osl_timeout
+/* Start OS timeout() routine after controller reset sequence */
+extern TW_VOID	tw_osl_timeout(struct tw_cl_req_handle *req_handle);
+#endif
+
+#ifndef tw_osl_untimeout
+/* Stop OS timeout() routine during controller reset sequence */
+extern TW_VOID	tw_osl_untimeout(struct tw_cl_req_handle *req_handle);
 #endif
 
 
@@ -552,6 +556,10 @@
 	);
 
 
+extern TW_VOID  tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
+extern TW_INT32 tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
+extern TW_INT32 tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle);
+
 /* CL's interrupt handler. */
 extern TW_INT32	tw_cl_interrupt(struct tw_cl_ctlr_handle *ctlr_handle);
 
diff -u FreeBSD_HEAD_twa_cvs/tw_osl.h FreeBSD_HEAD_twa_3_80_06_003/tw_osl.h
--- FreeBSD_HEAD_twa_cvs/tw_osl.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_osl.h	2010-08-24 18:02:12.000000000 -0700
@@ -77,6 +77,7 @@
 						EINPROGRESS */
 #define TW_OSLI_REQ_FLAGS_PASSTHRU	(1<<5)	/* pass through request */
 #define TW_OSLI_REQ_FLAGS_SLEEPING	(1<<6)	/* owner sleeping on this cmd */
+#define TW_OSLI_REQ_FLAGS_FAILED	(1<<7)	/* bus_dmamap_load() failed */
 
 
 #ifdef TW_OSL_DEBUG
@@ -100,6 +101,7 @@
 	struct twa_softc	*ctlr;	/* ptr to OSL's controller context */
 	TW_VOID			*data;	/* ptr to data being passed to CL */
 	TW_UINT32		length;	/* length of buf being passed to CL */
+	TW_UINT64		deadline;/* request timeout (in absolute time) */
 
 	/*
 	 * ptr to, and length of data passed to us from above, in case a buffer
@@ -151,6 +153,9 @@
 	struct mtx		sim_lock_handle;/* sim lock shared with cam */
 	struct mtx		*sim_lock;/* ptr to sim lock */
 
+	struct callout		watchdog_callout[2]; /* For command timout */
+	TW_UINT32		watchdog_index;
+
 #ifdef TW_OSL_DEBUG
 	struct tw_osli_q_stats	q_stats[TW_OSLI_Q_COUNT];/* queue statistics */
 #endif /* TW_OSL_DEBUG */
diff -u FreeBSD_HEAD_twa_cvs/tw_osl_cam.c FreeBSD_HEAD_twa_3_80_06_003/tw_osl_cam.c
--- FreeBSD_HEAD_twa_cvs/tw_osl_cam.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_osl_cam.c	2010-08-24 18:02:12.000000000 -0700
@@ -55,7 +55,6 @@
 
 static TW_VOID	twa_action(struct cam_sim *sim, union ccb *ccb);
 static TW_VOID	twa_poll(struct cam_sim *sim);
-static TW_VOID	twa_timeout(TW_VOID *arg);
 
 static TW_INT32	tw_osli_execute_scsi(struct tw_osli_req_context *req,
 	union ccb *ccb);
@@ -81,7 +80,7 @@
 	/*
 	 * Create the device queue for our SIM.
 	 */
-	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_REQUESTS)) == NULL) {
+	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_IOS)) == NULL) {
 		tw_osli_printf(sc, "error = %d",
 			TW_CL_SEVERITY_ERROR_STRING,
 			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
@@ -275,6 +274,7 @@
 					"I/O size too big",
 					csio->dxfer_len);
 				ccb_h->status = CAM_REQ_TOO_BIG;
+				ccb_h->status &= ~CAM_SIM_QUEUED;
 				xpt_done(ccb);
 				return(1);
 			}
@@ -290,6 +290,7 @@
 				0x2107,
 				"XPT_SCSI_IO: Got SGList");
 			ccb_h->status = CAM_REQ_INVALID;
+			ccb_h->status &= ~CAM_SIM_QUEUED;
 			xpt_done(ccb);
 			return(1);
 		}
@@ -306,13 +307,20 @@
 		return(1);
 	}
 
-	ccb_h->timeout_ch = timeout(twa_timeout, req,
-		(ccb_h->timeout * hz) / 1000);
+	req->deadline = tw_osl_get_local_time() + (ccb_h->timeout / 1000);
+
+
 	/*
 	 * twa_map_load_data_callback will fill in the SGL,
 	 * and submit the I/O.
 	 */
 	error = tw_osli_map_request(req);
+	if ((error) && (req->flags & TW_OSLI_REQ_FLAGS_FAILED)) {
+		req->deadline = 0;
+		ccb_h->status = CAM_REQ_CMP_ERR;
+		ccb_h->status &= ~CAM_SIM_QUEUED;
+		xpt_done(ccb);
+	}
 	return(error);
 }
 
@@ -345,10 +353,20 @@
 			 * Freeze the simq to maintain ccb ordering.  The next
 			 * ccb that gets completed will unfreeze the simq.
 			 */
+			ccb_h->status &= ~CAM_SIM_QUEUED;
+			ccb_h->status |= CAM_REQUEUE_REQ;
+			xpt_done(ccb);
+			break;
+		}
+
+		if ((tw_cl_is_reset_needed(&(req->ctlr->ctlr_handle)))) {
+			ccb_h->status &= ~CAM_SIM_QUEUED;
 			ccb_h->status |= CAM_REQUEUE_REQ;
 			xpt_done(ccb);
+			tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
 			break;
 		}
+
 		req->req_handle.osl_req_ctxt = req;
 		req->req_handle.is_io = TW_CL_TRUE;
 		req->orig_req = ccb;
@@ -364,25 +382,14 @@
 		break;
 
 	case XPT_RESET_BUS:
-		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
+		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_FALSE,
 			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 			0x2108, 0x3, TW_CL_SEVERITY_INFO_STRING,
 			"Received Reset Bus request from CAM",
 			" ");
 
-		mtx_unlock(sc->sim_lock);
-		if (tw_cl_reset_ctlr(&sc->ctlr_handle)) {
-			tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
-				TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
-				0x2109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-				"Failed to reset bus",
-				" ");
-			ccb_h->status = CAM_REQ_CMP_ERR;
-		}
-		else
-			ccb_h->status = CAM_REQ_CMP;
-
-		mtx_lock(sc->sim_lock);
+		tw_cl_set_reset_needed(&(sc->ctlr_handle));
+		ccb_h->status = CAM_REQ_CMP;
 		xpt_done(ccb);
 		break;
 
@@ -450,6 +457,7 @@
                 path_inq->transport_version = 2;
                 path_inq->protocol = PROTO_SCSI;
                 path_inq->protocol_version = SCSI_REV_2;
+                path_inq->maxio = TW_CL_MAX_IO_SIZE;
 		ccb_h->status = CAM_REQ_CMP;
 		xpt_done(ccb);
 		break;
@@ -487,31 +495,6 @@
 
 
 /*
- * Function name:	twa_timeout
- * Description:		Driver entry point for being alerted on a request
- *			timing out.
- *
- * Input:		arg	-- ptr to timed out request
- * Output:		None
- * Return value:	None
- */
-static TW_VOID
-twa_timeout(TW_VOID *arg)
-{
-	struct tw_osli_req_context	*req =
-		(struct tw_osli_req_context *)arg;
-
-	tw_cl_create_event(&(req->ctlr->ctlr_handle), TW_CL_TRUE,
-		TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
-		0x210B, 0x1, TW_CL_SEVERITY_ERROR_STRING,
-		"Request timed out!",
-		"request = %p", req);
-	tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle));
-}
-
-
-
-/*
  * Function name:	tw_osli_request_bus_scan
  * Description:		Requests CAM for a scan of the bus.
  *
@@ -574,20 +557,39 @@
 
 
 /*
- * Function name:	tw_osl_ctlr_busy
- * Description:		CL calls this function on cmd queue full or otherwise,
- *			when it is too busy to accept new requests.
+ * Function name:	tw_osl_timeout
+ * Description:		Call to timeout().
  *
- * Input:		ctlr_handle	-- ptr to controller handle
- *			req_handle	-- ptr to request handle sent by OSL.
+ * Input:		req_handle -- ptr to request handle sent by OSL.
  * Output:		None
  * Return value:	None
  */
 TW_VOID
-tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
-	struct tw_cl_req_handle *req_handle)
+tw_osl_timeout(struct tw_cl_req_handle *req_handle)
+{
+	struct tw_osli_req_context	*req = req_handle->osl_req_ctxt;
+	union ccb			*ccb = (union ccb *)(req->orig_req);
+	struct ccb_hdr			*ccb_h = &(ccb->ccb_h);
+
+	req->deadline = tw_osl_get_local_time() + (ccb_h->timeout / 1000);
+}
+
+
+
+/*
+ * Function name:	tw_osl_untimeout
+ * Description:		Inverse of call to timeout().
+ *
+ * Input:		req_handle -- ptr to request handle sent by OSL.
+ * Output:		None
+ * Return value:	None
+ */
+TW_VOID
+tw_osl_untimeout(struct tw_cl_req_handle *req_handle)
 {
-	tw_osli_disallow_new_requests(ctlr_handle->osl_ctlr_ctxt, req_handle);
+	struct tw_osli_req_context	*req = req_handle->osl_req_ctxt;
+
+	req->deadline = 0;
 }
 
 
@@ -655,7 +657,7 @@
 
 	tw_osli_unmap_request(req);
 
-	untimeout(twa_timeout, req, ccb->ccb_h.timeout_ch);
+	req->deadline = 0;
 	if (req->error_code) {
 		/* This request never got submitted to the firmware. */
 		if (req->error_code == EBUSY) {
@@ -682,7 +684,7 @@
 			else if (req_pkt->status & TW_CL_ERR_REQ_SCSI_ERROR)
 				ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
 			else if (req_pkt->status & TW_CL_ERR_REQ_BUS_RESET)
-				ccb->ccb_h.status |= CAM_SCSI_BUS_RESET;
+				ccb->ccb_h.status |= (CAM_REQUEUE_REQ | CAM_SCSI_BUS_RESET);
 			/*
 			 * If none of the above errors occurred, simply
 			 * mark completion error.
diff -u FreeBSD_HEAD_twa_cvs/tw_osl_freebsd.c FreeBSD_HEAD_twa_3_80_06_003/tw_osl_freebsd.c
--- FreeBSD_HEAD_twa_cvs/tw_osl_freebsd.c	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_osl_freebsd.c	2010-08-24 18:02:12.000000000 -0700
@@ -175,6 +175,9 @@
 static TW_INT32	twa_shutdown(device_t dev);
 static TW_VOID	twa_busdma_lock(TW_VOID *lock_arg, bus_dma_lock_op_t op);
 static TW_VOID	twa_pci_intr(TW_VOID *arg);
+static TW_VOID	twa_watchdog(TW_VOID *arg);
+int twa_setup_intr(struct twa_softc *sc);
+int twa_teardown_intr(struct twa_softc *sc);
 
 static TW_INT32	tw_osli_alloc_mem(struct twa_softc *sc);
 static TW_VOID	tw_osli_free_resources(struct twa_softc *sc);
@@ -238,6 +241,32 @@
 	return(ENXIO);
 }
 
+int twa_setup_intr(struct twa_softc *sc)
+{
+	int error = 0;
+
+	if (!(sc->intr_handle) && (sc->irq_res)) {
+		error = bus_setup_intr(sc->bus_dev, sc->irq_res,
+					INTR_TYPE_CAM | INTR_MPSAFE,
+					NULL, twa_pci_intr,
+					sc, &sc->intr_handle);
+	}
+	return( error );
+}
+
+
+int twa_teardown_intr(struct twa_softc *sc)
+{
+	int error = 0;
+
+	if ((sc->intr_handle) && (sc->irq_res)) {
+		error = bus_teardown_intr(sc->bus_dev,
+						sc->irq_res, sc->intr_handle);
+		sc->intr_handle = NULL;
+	}
+	return( error );
+}
+
 
 
 /*
@@ -354,10 +383,7 @@
 		tw_osli_free_resources(sc);
 		return(ENXIO);
 	}
-	if ((error = bus_setup_intr(sc->bus_dev, sc->irq_res,
-			INTR_TYPE_CAM | INTR_MPSAFE,
-			NULL, twa_pci_intr,	    
-			sc, &sc->intr_handle))) {
+	if ((error = twa_setup_intr(sc))) {
 		tw_osli_printf(sc, "error = %d",
 			TW_CL_SEVERITY_ERROR_STRING,
 			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
@@ -412,10 +438,77 @@
 		return(error);
 	}
 
+	sc->watchdog_index = 0;
+	callout_init(&(sc->watchdog_callout[0]), CALLOUT_MPSAFE);
+	callout_init(&(sc->watchdog_callout[1]), CALLOUT_MPSAFE);
+	callout_reset(&(sc->watchdog_callout[0]), 5*hz, twa_watchdog, &sc->ctlr_handle);
+
 	return(0);
 }
 
 
+static TW_VOID
+twa_watchdog(TW_VOID *arg)
+{
+	struct tw_cl_ctlr_handle *ctlr_handle =
+		(struct tw_cl_ctlr_handle *)arg;
+	struct twa_softc		*sc = ctlr_handle->osl_ctlr_ctxt;
+	int				i;
+	int				i_need_a_reset = 0;
+	int				driver_is_active = 0;
+	int				my_watchdog_was_pending = 1234;
+	TW_UINT64			current_time;
+	struct tw_osli_req_context	*my_req;
+
+
+//==============================================================================
+	current_time = (TW_UINT64) (tw_osl_get_local_time());
+
+	for (i = 0; i < TW_OSLI_MAX_NUM_REQUESTS; i++) {
+		my_req = &(sc->req_ctx_buf[i]);
+
+		if ((my_req->state == TW_OSLI_REQ_STATE_BUSY) &&
+			(my_req->deadline) &&
+			(my_req->deadline < current_time)) {
+			tw_cl_set_reset_needed(ctlr_handle);
+#ifdef    TW_OSL_DEBUG
+			device_printf((sc)->bus_dev, "Request %d timed out! d = %p, c = %p\n", i, (void*)my_req->deadline, (void*)current_time);
+#else  /* TW_OSL_DEBUG */
+			device_printf((sc)->bus_dev, "Request %d timed out!\n", i);
+#endif /* TW_OSL_DEBUG */
+			break;
+		}
+	}
+//==============================================================================
+
+	i_need_a_reset = tw_cl_is_reset_needed(ctlr_handle);
+
+	i = (int) ((sc->watchdog_index++) & 1);
+
+	driver_is_active = tw_cl_is_active(ctlr_handle);
+
+	if (i_need_a_reset) {
+#ifdef    TW_OSL_DEBUG
+		device_printf((sc)->bus_dev, "Watchdog rescheduled in 70 seconds\n");
+#endif /* TW_OSL_DEBUG */
+		my_watchdog_was_pending =
+			callout_reset(&(sc->watchdog_callout[i]), 70*hz, twa_watchdog, &sc->ctlr_handle);
+		tw_cl_reset_ctlr(ctlr_handle);
+#ifdef    TW_OSL_DEBUG
+		device_printf((sc)->bus_dev, "Watchdog reset completed!\n");
+#endif /* TW_OSL_DEBUG */
+	} else if (driver_is_active) {
+		my_watchdog_was_pending =
+			callout_reset(&(sc->watchdog_callout[i]),  5*hz, twa_watchdog, &sc->ctlr_handle);
+	}
+#ifdef    TW_OSL_DEBUG
+	if (i_need_a_reset || my_watchdog_was_pending)
+		device_printf((sc)->bus_dev, "i_need_a_reset = %d, "
+		"driver_is_active = %d, my_watchdog_was_pending = %d\n",
+		i_need_a_reset, driver_is_active, my_watchdog_was_pending);
+#endif /* TW_OSL_DEBUG */
+}
+
 
 /*
  * Function name:	tw_osli_alloc_mem
@@ -715,9 +808,7 @@
 
 
 	/* Disconnect the interrupt handler. */
-	if (sc->intr_handle)
-		if ((error = bus_teardown_intr(sc->bus_dev,
-				sc->irq_res, sc->intr_handle)))
+	if ((error = twa_teardown_intr(sc)))
 			tw_osli_dbg_dprintf(1, sc,
 				"teardown_intr returned %d", error);
 
@@ -809,6 +900,9 @@
 
 	tw_osli_dbg_dprintf(3, sc, "entered");
 
+	/* Disconnect interrupts. */
+	error = twa_teardown_intr(sc);
+
 	/* Disconnect from the controller. */
 	if ((error = tw_cl_shutdown_ctlr(&(sc->ctlr_handle), 0))) {
 		tw_osli_printf(sc, "error = %d",
@@ -997,33 +1091,35 @@
 				error = 0; /* False error */
 				break;
 			}
-			tw_osli_printf(sc, "request = %p",
-				TW_CL_SEVERITY_ERROR_STRING,
-				TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
-				0x2018,
-				"Passthru request timed out!",
-				req);
-			/*
-			 * Should I check here if the timeout happened
-			 * because of yet another reset, and not do a
-			 * second reset?
-			 */
-			tw_cl_reset_ctlr(&sc->ctlr_handle);
+			if (!(tw_cl_is_reset_needed(&(req->ctlr->ctlr_handle)))) {
+#ifdef    TW_OSL_DEBUG
+				tw_osli_printf(sc, "request = %p",
+					TW_CL_SEVERITY_ERROR_STRING,
+					TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
+					0x2018,
+					"Passthru request timed out!",
+					req);
+#else  /* TW_OSL_DEBUG */
+			device_printf((sc)->bus_dev, "Passthru request timed out!\n");
+#endif /* TW_OSL_DEBUG */
+				tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle));
+			}
+
+			error = 0;
+			end_time = tw_osl_get_local_time() + timeout;
+			continue;
 			/*
 			 * Don't touch req after a reset.  It (and any
-			 * associated data) will already have been
+			 * associated data) will be
 			 * unmapped by the callback.
 			 */
-			user_buf->driver_pkt.os_status = error;
-			error = ETIMEDOUT;
-			goto fw_passthru_err;
 		}
 		/* 
 		 * Either the request got completed, or we were woken up by a
 		 * signal.  Calculate the new timeout, in case it was the latter.
 		 */
 		timeout = (end_time - tw_osl_get_local_time());
-	}
+	} /* End of while loop */
 
 	/* If there was a payload, copy it back. */
 	if ((!error) && (req->length))
@@ -1037,19 +1133,9 @@
 				error);
 	
 fw_passthru_err:
-	/*
-	 * Print the failure message.  For some reason, on certain OS versions,
-	 * printing this error message during reset hangs the display (although
-	 * the rest of the system is running fine.  So, don't print it if the
-	 * failure was due to a reset.
-	 */
-	if ((error) && (error != TW_CL_ERR_REQ_BUS_RESET))
-		tw_osli_printf(sc, "error = %d",		
-			TW_CL_SEVERITY_ERROR_STRING,
-			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
-			0x201A,
-			"Firmware passthru failed!",
-			error);
+
+	if (req_pkt->status == TW_CL_ERR_REQ_BUS_RESET)
+		error = EBUSY;
 
 	user_buf->driver_pkt.os_status = error;
 	/* Free resources. */
@@ -1073,6 +1159,8 @@
 tw_osl_complete_passthru(struct tw_cl_req_handle *req_handle)
 {
 	struct tw_osli_req_context	*req = req_handle->osl_req_ctxt;
+	struct tw_cl_req_packet		*req_pkt =
+		(struct tw_cl_req_packet *)(&req->req_pkt);
 	struct twa_softc		*sc = req->ctlr;
 
 	tw_osli_dbg_dprintf(5, sc, "entered");
@@ -1120,6 +1208,9 @@
 			if (req->flags & TW_OSLI_REQ_FLAGS_MAPPED)
 				return;
 
+			if (req_pkt->status == TW_CL_ERR_REQ_BUS_RESET)
+				return;
+
 			tw_osli_printf(sc, "request = %p",
 				TW_CL_SEVERITY_ERROR_STRING,
 				TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
@@ -1166,6 +1257,7 @@
 		req->req_handle.is_io = 0;
 		req->data = NULL;
 		req->length = 0;
+		req->deadline = 0;
 		req->real_data = NULL;
 		req->real_length = 0;
 		req->state = TW_OSLI_REQ_STATE_INIT;/* req being initialized */
@@ -1207,6 +1299,11 @@
 
 	tw_osli_dbg_dprintf(10, sc, "entered");
 
+	if (error == EINVAL) {
+		req->error_code = error;
+		return;
+	}
+
 	/* Mark the request as currently being processed. */
 	req->state = TW_OSLI_REQ_STATE_BUSY;
 	/* Move the request into the busy queue. */
@@ -1400,6 +1497,14 @@
 				mtx_unlock_spin(sc->io_lock);
 				error = 0;
 			} else {
+				tw_osli_printf(sc, "error = %d",
+					TW_CL_SEVERITY_ERROR_STRING,
+					TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
+					0x9999,
+					"Failed to map DMA memory "
+					"for I/O request",
+					error);
+				req->flags |= TW_OSLI_REQ_FLAGS_FAILED;
 				/* Free alignment buffer if it was used. */
 				if (req->flags &
 					TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED) {
diff -u FreeBSD_HEAD_twa_cvs/tw_osl_share.h FreeBSD_HEAD_twa_3_80_06_003/tw_osl_share.h
--- FreeBSD_HEAD_twa_cvs/tw_osl_share.h	2010-08-24 18:06:24.000000000 -0700
+++ FreeBSD_HEAD_twa_3_80_06_003/tw_osl_share.h	2010-08-24 18:02:12.000000000 -0700
@@ -75,7 +75,7 @@
 #define TW_OSL_ENCLOSURE_SUPPORT
 #endif
 
-#define TW_OSL_DRIVER_VERSION_STRING	"3.80.06.002"
+#define TW_OSL_DRIVER_VERSION_STRING	"3.80.06.003"
 
 #define	TW_OSL_CAN_SLEEP
 


>Release-Note:
>Audit-Trail:
Responsible-Changed-From-To: freebsd-bugs->delphij 
Responsible-Changed-By: delphij 
Responsible-Changed-When: Wed Aug 25 18:35:20 UTC 2010 
Responsible-Changed-Why:  
Take. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=149968 

From: dfilter@FreeBSD.ORG (dfilter service)
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/149968: commit references a PR
Date: Mon, 30 Aug 2010 19:15:20 +0000 (UTC)

 Author: delphij
 Date: Mon Aug 30 19:15:04 2010
 New Revision: 212008
 URL: http://svn.freebsd.org/changeset/base/212008
 
 Log:
   Vendor update to version 3.80.06.003 to fix a panic with ZFS when under
   heavy I/O load.
   
   Many thanks to LSI for continuing to support FreeBSD.
   
   PR:		kern/149968
   Submitted by:	LSI (Tom Couch)
   Reported by:	Kai Kockro <kkockro web de>
   Tested by:	Kai Kockro, jpaetzel
   MFC after:	7 days
 
 Modified:
   head/sys/dev/twa/tw_cl.h
   head/sys/dev/twa/tw_cl_externs.h
   head/sys/dev/twa/tw_cl_fwif.h
   head/sys/dev/twa/tw_cl_init.c
   head/sys/dev/twa/tw_cl_intr.c
   head/sys/dev/twa/tw_cl_io.c
   head/sys/dev/twa/tw_cl_misc.c
   head/sys/dev/twa/tw_cl_share.h
   head/sys/dev/twa/tw_osl.h
   head/sys/dev/twa/tw_osl_cam.c
   head/sys/dev/twa/tw_osl_freebsd.c
   head/sys/dev/twa/tw_osl_share.h
 
 Modified: head/sys/dev/twa/tw_cl.h
 ==============================================================================
 --- head/sys/dev/twa/tw_cl.h	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl.h	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -88,7 +88,8 @@ struct tw_cli_q_stats {
  #define TW_CLI_BUSY_Q		1	/* q of reqs submitted to fw */
  #define TW_CLI_PENDING_Q	2	/* q of reqs deferred due to 'q full' */
  #define TW_CLI_COMPLETE_Q	3	/* q of reqs completed by fw */
 -#define TW_CLI_Q_COUNT		4	/* total number of queues */
 +#define TW_CLI_RESET_Q		4	/* q of reqs reset by timeout */
 +#define TW_CLI_Q_COUNT		5	/* total number of queues */
  
  
  /* CL's internal request context. */
 @@ -133,6 +134,7 @@ struct tw_cli_ctlr_context {
  	TW_UINT8 		interrupts_enabled;	  /* Interrupts on controller enabled. */
  	TW_UINT8 		internal_req_busy;	  /* Data buffer for internal requests in use. */
  	TW_UINT8 		get_more_aens;		  /* More AEN's need to be retrieved. */
 +	TW_UINT8 		reset_needed;		  /* Controller needs a soft reset. */
  	TW_UINT8 		reset_in_progress;	  /* Controller is being reset. */
  	TW_UINT8 		reset_phase1_in_progress; /* In 'phase 1' of reset. */
  	TW_UINT32		flags;		/* controller settings */
 
 Modified: head/sys/dev/twa/tw_cl_externs.h
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_externs.h	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_externs.h	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -86,6 +86,8 @@ extern TW_INT32	tw_cli_submit_and_poll_r
  
  /* Soft reset the controller. */
  extern TW_INT32	tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr);
 +extern int twa_setup_intr(struct twa_softc *sc);
 +extern int twa_teardown_intr(struct twa_softc *sc);
  
  /* Send down a SCSI command to the firmware (usually, an internal Req Sense. */
  extern TW_INT32	tw_cli_send_scsi_cmd(struct tw_cli_req_context *req,
 
 Modified: head/sys/dev/twa/tw_cl_fwif.h
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_fwif.h	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_fwif.h	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -89,7 +89,7 @@
  #define TWA_STATUS_MINOR_VERSION_MASK		0x0F000000
  #define TWA_STATUS_MAJOR_VERSION_MASK		0xF0000000
  
 -#define TWA_STATUS_UNEXPECTED_BITS		0x00F00000
 +#define TWA_STATUS_UNEXPECTED_BITS		0x00D00000
  
  
  /* PCI related defines. */
 
 Modified: head/sys/dev/twa/tw_cl_init.c
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_init.c	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_init.c	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -315,6 +315,7 @@ tw_cl_init_ctlr(struct tw_cl_ctlr_handle
  	tw_cli_req_q_init(ctlr, TW_CLI_BUSY_Q);
  	tw_cli_req_q_init(ctlr, TW_CLI_PENDING_Q);
  	tw_cli_req_q_init(ctlr, TW_CLI_COMPLETE_Q);
 +	tw_cli_req_q_init(ctlr, TW_CLI_RESET_Q);
  
  	/* Initialize all locks used by CL. */
  	ctlr->gen_lock = &(ctlr->gen_lock_handle);
 @@ -675,15 +676,14 @@ tw_cli_init_connection(struct tw_cli_ctl
  	/* Submit the command, and wait for it to complete. */
  	error = tw_cli_submit_and_poll_request(req,
  		TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -	if (error == TW_OSL_ETIMEDOUT)
 -		/* Clean-up done by tw_cli_submit_and_poll_request. */
 -		return(error);
  	if (error)
  		goto out;
  	if ((error = init_connect->status)) {
 +#if       0
  		tw_cli_create_ctlr_event(ctlr,
  			TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  			&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  		goto out;
  	}
  	if (set_features & TWA_EXTENDED_INIT_CONNECT) {
 
 Modified: head/sys/dev/twa/tw_cl_intr.c
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_intr.c	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_intr.c	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -248,8 +248,7 @@ tw_cli_process_resp_intr(struct tw_cli_c
  #ifdef TW_OSL_DEBUG
  			tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
  #endif /* TW_OSL_DEBUG */
 -			tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -			return(TW_OSL_EIO);
 +			continue;
  		}
  
  		/*
 @@ -402,9 +401,7 @@ tw_cli_complete_io(struct tw_cli_req_con
  #ifdef TW_OSL_DEBUG
  		tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
  #endif /* TW_OSL_DEBUG */
 -		tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -		req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -		goto out;
 +		return;
  	}
  
  	if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 @@ -483,6 +480,7 @@ tw_cli_scsi_complete(struct tw_cli_req_c
  			cdb[8], cdb[9], cdb[10], cdb[11],
  			cdb[12], cdb[13], cdb[14], cdb[15]);
  
 +#if       0
  		/* 
  		 * Print the error. Firmware doesn't yet support
  		 * the 'Mode Sense' cmd.  Don't print if the cmd
 @@ -493,6 +491,7 @@ tw_cli_scsi_complete(struct tw_cli_req_c
  			tw_cli_create_ctlr_event(req->ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  	}
  
  	if (scsi_req->sense_data) {
 @@ -530,9 +529,11 @@ tw_cli_param_callback(struct tw_cli_req_
  	 */
  	if (! req->error_code)
  		if (cmd->param.status) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  				0x1204, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 @@ -590,9 +591,11 @@ tw_cli_aen_callback(struct tw_cli_req_co
  		if ((error = cmd->status)) {
  			cmd_hdr = (struct tw_cl_command_header *)
  				(&(req->cmd_pkt->cmd_hdr));
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  				0x1206, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 
 Modified: head/sys/dev/twa/tw_cl_io.c
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_io.c	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_io.c	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -74,18 +74,12 @@ tw_cl_start_io(struct tw_cl_ctlr_handle 
  	struct tw_cli_req_context		*req;
  	struct tw_cl_command_9k			*cmd;
  	struct tw_cl_scsi_req_packet		*scsi_req;
 -	TW_INT32				error;
 +	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
  
  	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  
 -	if (ctlr->reset_in_progress) {
 -		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -			"I/O during reset: returning busy.");
 -		return(TW_OSL_EBUSY);
 -	}
 -
  	/*
  	 * If working with a firmware version that does not support multiple
  	 * luns, and this request is directed at a non-zero lun, error it
 @@ -145,7 +139,12 @@ tw_cl_start_io(struct tw_cl_ctlr_handle 
  			cmd->sg_list, scsi_req->sgl_entries);
  	}
  
 -	if ((error = tw_cli_submit_cmd(req))) {
 +	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
 +		(ctlr->reset_in_progress)) {
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 +	} else if ((error = tw_cli_submit_cmd(req))) {
  		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
  			"Could not start request. request = %p, error = %d",
  			req, error);
 @@ -171,7 +170,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  	struct tw_cli_ctlr_context	*ctlr = req->ctlr;
  	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
  	TW_UINT32			status_reg;
 -	TW_INT32			error;
 +	TW_INT32			error = 0;
  
  	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
  
 @@ -185,11 +184,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  				 TWA_COMMAND_QUEUE_OFFSET_LOW,
  				 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
  
 -	/* Check to see if we can post a command. */
  	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
 -	if ((error = tw_cli_check_ctlr_state(ctlr, status_reg)))
 -		goto out;
 -
  	if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
  		struct tw_cl_req_packet	*req_pkt =
  			(struct tw_cl_req_packet *)(req->orig_req);
 @@ -207,14 +202,12 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  					"pending internal/ioctl request");
  				req->state = TW_CLI_REQ_STATE_PENDING;
  				tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 -				error = 0;
  				/* Unmask command interrupt. */
  				TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
  					TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
  			} else
  				error = TW_OSL_EBUSY;
  		} else {
 -			tw_osl_ctlr_busy(ctlr_handle, req->req_handle);
  			error = TW_OSL_EBUSY;
  		}
  	} else {
 @@ -246,7 +239,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  						 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
  		}
  	}
 -out:
 +
  	tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
  
  	return(error);
 @@ -277,18 +270,12 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  	TW_UINT8				opcode;
  	TW_UINT8				sgl_offset;
  	TW_VOID					*sgl = TW_CL_NULL;
 -	TW_INT32				error;
 +	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
  
  	tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  
 -	if (ctlr->reset_in_progress) {
 -		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -			"Passthru request during reset: returning busy.");
 -		return(TW_OSL_EBUSY);
 -	}
 -
  	if ((req = tw_cli_get_request(ctlr
  		)) == TW_CL_NULL) {
  		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 @@ -301,7 +288,7 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  	req->orig_req = req_pkt;
  	req->tw_cli_callback = tw_cli_complete_io;
  
 -	req->flags |= (TW_CLI_REQ_FLAGS_EXTERNAL | TW_CLI_REQ_FLAGS_PASSTHRU);
 +	req->flags |= TW_CLI_REQ_FLAGS_PASSTHRU;
  
  	pt_req = &(req_pkt->gen_req_pkt.pt_req);
  
 @@ -348,7 +335,12 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  		tw_cli_fill_sg_list(ctlr, pt_req->sg_list,
  			sgl, pt_req->sgl_entries);
  
 -	if ((error = tw_cli_submit_cmd(req))) {
 +	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
 +		(ctlr->reset_in_progress)) {
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 +	} else if ((error = tw_cli_submit_cmd(req))) {
  		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  			0x1100, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 @@ -760,8 +752,7 @@ tw_cli_get_param(struct tw_cli_ctlr_cont
  
  	cmd->param.sgl_off__opcode =
  		BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_GET_PARAM);
 -	cmd->param.request_id =
 -		(TW_UINT8)(TW_CL_SWAP16(req->request_id));
 +	cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id));
  	cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0);
  	cmd->param.param_count = TW_CL_SWAP16(1);
  
 @@ -789,15 +780,14 @@ tw_cli_get_param(struct tw_cli_ctlr_cont
  		/* There's no call back; wait till the command completes. */
  		error = tw_cli_submit_and_poll_request(req,
  				TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -		if (error == TW_OSL_ETIMEDOUT)
 -			/* Clean-up done by tw_cli_submit_and_poll_request. */
 -			return(error);
  		if (error)
  			goto out;
  		if ((error = cmd->param.status)) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			goto out;
  		}
  		tw_osl_memcpy(param_data, param->data, param_size);
 @@ -905,18 +895,17 @@ tw_cli_set_param(struct tw_cli_ctlr_cont
  
  	/* Submit the command. */
  	if (callback == TW_CL_NULL) {
 -		/* There's no call back;  wait till the command completes. */
 +		/* There's no call back; wait till the command completes. */
  		error = tw_cli_submit_and_poll_request(req,
 -			TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -		if (error == TW_OSL_ETIMEDOUT)
 -			/* Clean-up done by tw_cli_submit_and_poll_request. */
 -			return(error);
 +				TW_CLI_REQUEST_TIMEOUT_PERIOD);
  		if (error)
  			goto out;
  		if ((error = cmd->param.status)) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			goto out;
  		}
  		ctlr->internal_req_busy = TW_CL_FALSE;
 @@ -1022,9 +1011,7 @@ tw_cli_submit_and_poll_request(struct tw
  	 * tw_cli_submit_pending_queue.  There could be a race in that case.
  	 * Need to revisit.
  	 */
 -	if (req->state != TW_CLI_REQ_STATE_PENDING)
 -		tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -	else {
 +	if (req->state == TW_CLI_REQ_STATE_PENDING) {
  		tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(),
  			"Removing request from pending queue");
  		/*
 @@ -1053,6 +1040,7 @@ tw_cli_submit_and_poll_request(struct tw
   *			drains any incomplete requests.
   *
   * Input:		ctlr	-- ptr to per ctlr structure
 + * 			req_handle	-- ptr to request handle
   * Output:		None
   * Return value:	0	-- success
   *			non-zero-- failure
 @@ -1063,15 +1051,15 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	struct tw_cli_ctlr_context	*ctlr =
  		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  	struct twa_softc		*sc = ctlr_handle->osl_ctlr_ctxt;
 +	struct tw_cli_req_context	*req;
  	TW_INT32			reset_attempt = 1;
 -	TW_INT32			error;
 +	TW_INT32			error = 0;
  
  	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr->reset_in_progress = TW_CL_TRUE;
 -	xpt_freeze_simq(sc->sim, 1);
 +	twa_teardown_intr(sc);
  
 -	tw_cli_disable_interrupts(ctlr);
  
  	/*
  	 * Error back all requests in the complete, busy, and pending queues.
 @@ -1080,8 +1068,6 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	 * will continue its course and get submitted to the controller after
  	 * the reset is done (and io_lock is released).
  	 */
 -	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -		"Draining all queues following reset");
  	tw_cli_drain_complete_queue(ctlr);
  	tw_cli_drain_busy_queue(ctlr);
  	tw_cli_drain_pending_queue(ctlr);
 @@ -1089,53 +1075,88 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	ctlr->get_more_aens     = TW_CL_FALSE;
  
  	/* Soft reset the controller. */
 -try_reset:
 -	if ((error = tw_cli_soft_reset(ctlr))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Controller reset failed",
 -			"error = %d; attempt %d", error, reset_attempt++);
 -		if (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS)
 -			goto try_reset;
 -		else
 -			goto out;
 -	}
 +	while (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS) {
 +		if ((error = tw_cli_soft_reset(ctlr))) {
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 +				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 +				0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 +				"Controller reset failed",
 +				"error = %d; attempt %d", error, reset_attempt++);
 +			reset_attempt++;
 +			continue;
 +		}
  
 -	/* Re-establish logical connection with the controller. */
 -	if ((error = tw_cli_init_connection(ctlr,
 -			(TW_UINT16)(ctlr->max_simult_reqs),
 -			0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
 -			TW_CL_NULL, TW_CL_NULL))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		/* Re-establish logical connection with the controller. */
 +		if ((error = tw_cli_init_connection(ctlr,
 +				(TW_UINT16)(ctlr->max_simult_reqs),
 +				0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
 +				TW_CL_NULL, TW_CL_NULL))) {
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 +				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 +				0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 +				"Can't initialize connection after reset",
 +				"error = %d", error);
 +			reset_attempt++;
 +			continue;
 +		}
 +
 +#ifdef    TW_OSL_DEBUG
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Can't initialize connection after reset",
 -			"error = %d", error);
 -		goto out;
 -	}
 +			0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
 +			"Controller reset done!", " ");
 +#endif /* TW_OSL_DEBUG */
 +		break;
 +	} /* End of while */
  
 -	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -		0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
 -		"Controller reset done!",
 -		" ");
 +	/* Move commands from the reset queue to the pending queue. */
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_RESET_Q)) != TW_CL_NULL) {
 +		tw_osl_timeout(req->req_handle);
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +	}
  
 -out:
 +	twa_setup_intr(sc);
 +	tw_cli_enable_interrupts(ctlr);
 +	if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL)
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
  	ctlr->reset_in_progress = TW_CL_FALSE;
 -	xpt_release_simq(sc->sim, 1);
 +	ctlr->reset_needed = TW_CL_FALSE;
  
 -	/*
 -	 * Enable interrupts, and also clear attention and response interrupts.
 -	 */
 -	tw_cli_enable_interrupts(ctlr);
 -	
  	/* Request for a bus re-scan. */
 -	if (!error)
 -		tw_osl_scan_bus(ctlr_handle);
 +	tw_osl_scan_bus(ctlr_handle);
 +
  	return(error);
  }
  
 +TW_VOID
 +tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 +
 +	ctlr->reset_needed = TW_CL_TRUE;
 +}
 +
 +TW_INT32
 +tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 +
 +	return(ctlr->reset_needed);
 +}
 +
 +TW_INT32
 +tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)
 +		(ctlr_handle->cl_ctlr_ctxt);
 +
 +		return(ctlr->active);
 +}
 +
  
  
  /*
 @@ -1151,14 +1172,13 @@ TW_INT32
  tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr)
  {
  	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
 -	TW_UINT32			status_reg;
  	int				found;
  	int				loop_count;
  	TW_UINT32			error;
  
  	tw_cli_dbg_printf(1, ctlr_handle, tw_osl_cur_func(), "entered");
  
 -	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +	tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  		0x1108, 0x3, TW_CL_SEVERITY_INFO_STRING,
  		"Resetting controller...",
 @@ -1193,7 +1213,7 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  		} while (!found && (loop_count < 6000000)); /* Loop for no more than 60 seconds */
  
  		if (!found) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"Missed firmware handshake after soft-reset",
 @@ -1210,7 +1230,7 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  			TWA_STATUS_MICROCONTROLLER_READY |
  			TWA_STATUS_ATTENTION_INTERRUPT,
  			TW_CLI_RESET_TIMEOUT_PERIOD))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Micro-ctlr not ready/No attn intr after reset",
 @@ -1244,26 +1264,14 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  	}
  	
  	if ((error = tw_cli_find_aen(ctlr, TWA_AEN_SOFT_RESET))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x110C, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Reset not reported by controller",
  			"error = %d", error);
  		return(error);
  	}
 -	
 -	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
 -	
 -	if ((error = TW_CLI_STATUS_ERRORS(status_reg)) ||
 -			(error = tw_cli_check_ctlr_state(ctlr, status_reg))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x110D, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Controller errors detected after reset",
 -			"error = %d", error);
 -		return(error);
 -	}
 -	
 +
  	return(TW_OSL_ESUCCESS);
  }
  
 
 Modified: head/sys/dev/twa/tw_cl_misc.c
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_misc.c	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_misc.c	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -83,7 +83,8 @@ tw_cli_drain_complete_queue(struct tw_cl
  	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
  
  	/* Walk the busy queue. */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -97,20 +98,21 @@ tw_cli_drain_complete_queue(struct tw_cl
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's a SCSI request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing complete request %p "
 -					"on reset",
 -					req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -135,7 +137,8 @@ tw_cli_drain_busy_queue(struct tw_cli_ct
  	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
  
  	/* Walk the busy queue. */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -149,19 +152,21 @@ tw_cli_drain_busy_queue(struct tw_cli_ct
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's a SCSI request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing busy request %p on reset",
 -					req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -188,7 +193,8 @@ tw_cli_drain_pending_queue(struct tw_cli
  	/*
  	 * Pull requests off the pending queue, and complete them.
  	 */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -202,19 +208,21 @@ tw_cli_drain_pending_queue(struct tw_cli
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's an external request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing pending request %p "
 -					"on reset", req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -239,9 +247,6 @@ tw_cli_drain_response_queue(struct tw_cl
  	for (;;) {
  		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
  
 -		if (tw_cli_check_ctlr_state(ctlr, status_reg))
 -			return(TW_OSL_EGENFAILURE);
 -
  		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
  			return(TW_OSL_ESUCCESS); /* no more response queue entries */
  
 @@ -273,9 +278,6 @@ tw_cli_find_response(struct tw_cli_ctlr_
  	for (;;) {
  		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
  
 -		if (tw_cli_check_ctlr_state(ctlr, status_reg))
 -			return(TW_OSL_EGENFAILURE);
 -
  		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
  			return(TW_OSL_ENOTTY); /* no more response queue entries */
  
 @@ -356,9 +358,11 @@ tw_cli_drain_aen_queue(struct tw_cli_ctl
  
  		if ((error = req->cmd_pkt->command.cmd_pkt_9k.status)) {
  			cmd_hdr = &req->cmd_pkt->cmd_hdr;
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  			break;
  		}
  
 @@ -714,7 +718,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  
  		tw_osl_memzero(desc, 200);
  		if (!(ctlr->reset_phase1_in_progress)) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1301, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"Missing expected status bit(s)",
 @@ -738,7 +742,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  		     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
  		    (!(ctlr->reset_in_progress)) ||
  		    ((status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) == 0))
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x1302, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Unexpected status bit(s)",
 @@ -748,7 +752,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  				TWA_STATUS_UNEXPECTED_BITS, desc));
  
  		if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1303, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"PCI parity error: clearing... "
 @@ -768,7 +772,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  		}
  
  		if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1304, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"PCI abort: clearing... ",
 @@ -791,7 +795,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  			if (((ctlr->device_id != TW_CL_DEVICE_ID_9K_E) &&
  			     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
  			    (!(ctlr->reset_in_progress)))
 -				tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +				tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  						   TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  						   0x1305, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  						   "Controller queue error: clearing... ",
 @@ -801,17 +805,6 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  			TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
  				TWA_CONTROL_CLEAR_QUEUE_ERROR);
  		}
 -
 -		if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -				0x1307, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -				"Micro-controller error! ",
 -				"status reg = 0x%x %s",
 -				status_reg,
 -				tw_cli_describe_bits(status_reg, desc));
 -			error = TW_OSL_EGENFAILURE;
 -		}
  	}
  	return(error);
  }	
 @@ -850,8 +843,6 @@ tw_cli_describe_bits(TW_UINT32 reg, TW_I
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "HOST_INTR,");
  	if (reg & TWA_STATUS_PCI_ABORT_INTERRUPT)
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "PCI_ABRT,");
 -	if (reg & TWA_STATUS_MICROCONTROLLER_ERROR)
 -		tw_osl_strcpy(&str[tw_osl_strlen(str)], "MC_ERR,");
  	if (reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT)
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "Q_ERR,");
  	if (reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT)
 
 Modified: head/sys/dev/twa/tw_cl_share.h
 ==============================================================================
 --- head/sys/dev/twa/tw_cl_share.h	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_cl_share.h	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -349,10 +349,14 @@ extern TW_VOID	tw_osl_breakpoint(TW_VOID
  #endif
  
  
 -#ifndef tw_osl_ctlr_busy
 -/* Called when CL is too busy to accept new requests. */
 -extern TW_VOID	tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
 -	struct tw_cl_req_handle *req_handle);
 +#ifndef tw_osl_timeout
 +/* Start OS timeout() routine after controller reset sequence */
 +extern TW_VOID	tw_osl_timeout(struct tw_cl_req_handle *req_handle);
 +#endif
 +
 +#ifndef tw_osl_untimeout
 +/* Stop OS timeout() routine during controller reset sequence */
 +extern TW_VOID	tw_osl_untimeout(struct tw_cl_req_handle *req_handle);
  #endif
  
  
 @@ -552,6 +556,10 @@ extern TW_INT32	tw_cl_init_ctlr(struct t
  	);
  
  
 +extern TW_VOID  tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
 +extern TW_INT32 tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
 +extern TW_INT32 tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle);
 +
  /* CL's interrupt handler. */
  extern TW_INT32	tw_cl_interrupt(struct tw_cl_ctlr_handle *ctlr_handle);
  
 
 Modified: head/sys/dev/twa/tw_osl.h
 ==============================================================================
 --- head/sys/dev/twa/tw_osl.h	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_osl.h	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -77,6 +77,7 @@
  						EINPROGRESS */
  #define TW_OSLI_REQ_FLAGS_PASSTHRU	(1<<5)	/* pass through request */
  #define TW_OSLI_REQ_FLAGS_SLEEPING	(1<<6)	/* owner sleeping on this cmd */
 +#define TW_OSLI_REQ_FLAGS_FAILED	(1<<7)	/* bus_dmamap_load() failed */
  
  
  #ifdef TW_OSL_DEBUG
 @@ -100,6 +101,7 @@ struct tw_osli_req_context {
  	struct twa_softc	*ctlr;	/* ptr to OSL's controller context */
  	TW_VOID			*data;	/* ptr to data being passed to CL */
  	TW_UINT32		length;	/* length of buf being passed to CL */
 +	TW_UINT64		deadline;/* request timeout (in absolute time) */
  
  	/*
  	 * ptr to, and length of data passed to us from above, in case a buffer
 @@ -151,6 +153,9 @@ struct twa_softc {
  	struct mtx		sim_lock_handle;/* sim lock shared with cam */
  	struct mtx		*sim_lock;/* ptr to sim lock */
  
 +	struct callout		watchdog_callout[2]; /* For command timout */
 +	TW_UINT32		watchdog_index;
 +
  #ifdef TW_OSL_DEBUG
  	struct tw_osli_q_stats	q_stats[TW_OSLI_Q_COUNT];/* queue statistics */
  #endif /* TW_OSL_DEBUG */
 
 Modified: head/sys/dev/twa/tw_osl_cam.c
 ==============================================================================
 --- head/sys/dev/twa/tw_osl_cam.c	Mon Aug 30 18:53:12 2010	(r212007)
 +++ head/sys/dev/twa/tw_osl_cam.c	Mon Aug 30 19:15:04 2010	(r212008)
 @@ -55,7 +55,6 @@
  
  static TW_VOID	twa_action(struct cam_sim *sim, union ccb *ccb);
  static TW_VOID	twa_poll(struct cam_sim *sim);
 -static TW_VOID	twa_timeout(TW_VOID *arg);
  
  static TW_INT32	tw_osli_execute_scsi(struct tw_osli_req_context *req,
  	union ccb *ccb);
 @@ -81,7 +80,7 @@ tw_osli_cam_attach(struct twa_softc *sc)
  	/*
  	 * Create the device queue for our SIM.
  	 */
 -	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_REQUESTS)) == NULL) {
 +	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_IOS)) == NULL) {
  		tw_osli_printf(sc, "error = %d",
  			TW_CL_SEVERITY_ERROR_STRING,
  			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 @@ -275,6 +274,7 @@ tw_osli_execute_scsi(struct tw_osli_req_
  					"I/O size too big",
  					csio->dxfer_len);
  				ccb_h->status = CAM_REQ_TOO_BIG;
 +				ccb_h->status &= ~CAM_SIM_QUEUED;
  				xpt_done(ccb);
  				return(1);
  			}
 @@ -290,6 +290,7 @@ tw_osli_execute_scsi(struct tw_osli_req_
  				0x2107,
  				"XPT_SCSI_IO: Got SGList");
  			ccb_h->status = CAM_REQ_INVALID;
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
  			xpt_done(ccb);
  			return(1);
  		}
 @@ -306,13 +307,20 @@ tw_osli_execute_scsi(struct tw_osli_req_
  		return(1);
  	}
  
 -	ccb_h->timeout_ch = timeout(twa_timeout, req,
 -		(ccb_h->timeout * hz) / 1000);
 +	req->deadline = tw_osl_get_local_time() + (ccb_h->timeout / 1000);
 +
 +
  	/*
  	 * twa_map_load_data_callback will fill in the SGL,
  	 * and submit the I/O.
  	 */
  	error = tw_osli_map_request(req);
 +	if ((error) && (req->flags & TW_OSLI_REQ_FLAGS_FAILED)) {
 +		req->deadline = 0;
 +		ccb_h->status = CAM_REQ_CMP_ERR;
 +		ccb_h->status &= ~CAM_SIM_QUEUED;
 +		xpt_done(ccb);
 +	}
  	return(error);
  }
  
 @@ -345,10 +353,20 @@ twa_action(struct cam_sim *sim, union cc
  			 * Freeze the simq to maintain ccb ordering.  The next
  			 * ccb that gets completed will unfreeze the simq.
  			 */
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
 +			ccb_h->status |= CAM_REQUEUE_REQ;
 +			xpt_done(ccb);
 +			break;
 +		}
 +
 +		if ((tw_cl_is_reset_needed(&(req->ctlr->ctlr_handle)))) {
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
  			ccb_h->status |= CAM_REQUEUE_REQ;
  			xpt_done(ccb);
 +			tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
  			break;
  		}
 +
  		req->req_handle.osl_req_ctxt = req;
  		req->req_handle.is_io = TW_CL_TRUE;
  		req->orig_req = ccb;
 @@ -364,25 +382,14 @@ twa_action(struct cam_sim *sim, union cc
  		break;
  
  	case XPT_RESET_BUS:
 -		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
 +		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  			0x2108, 0x3, TW_CL_SEVERITY_INFO_STRING,
  			"Received Reset Bus request from CAM",
  			" ");
  
 -		mtx_unlock(sc->sim_lock);
 -		if (tw_cl_reset_ctlr(&sc->ctlr_handle)) {
 -			tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
 -				TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 -				0x2109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -				"Failed to reset bus",
 -				" ");
 -			ccb_h->status = CAM_REQ_CMP_ERR;
 -		}
 -		else
 -			ccb_h->status = CAM_REQ_CMP;
 -
 -		mtx_lock(sc->sim_lock);
 +		tw_cl_set_reset_needed(&(sc->ctlr_handle));
 +		ccb_h->status = CAM_REQ_CMP;
  		xpt_done(ccb);
  		break;
  
 @@ -450,6 +457,7 @@ twa_action(struct cam_sim *sim, union cc
                  path_inq->transport_version = 2;
                  path_inq->protocol = PROTO_SCSI;
                  path_inq->protocol_version = SCSI_REV_2;
 +                path_inq->maxio = TW_CL_MAX_IO_SIZE;
  		ccb_h->status = CAM_REQ_CMP;
  		xpt_done(ccb);
  		break;
 @@ -487,31 +495,6 @@ twa_poll(struct cam_sim *sim)
  
  
  /*
 - * Function name:	twa_timeout
 - * Description:		Driver entry point for being alerted on a request
 - *			timing out.
 - *
 - * Input:		arg	-- ptr to timed out request
 - * Output:		None
 - * Return value:	None
 - */
 -static TW_VOID
 -twa_timeout(TW_VOID *arg)
 -{
 -	struct tw_osli_req_context	*req =
 -		(struct tw_osli_req_context *)arg;
 -
 -	tw_cl_create_event(&(req->ctlr->ctlr_handle), TW_CL_TRUE,
 -		TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 -		0x210B, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -		"Request timed out!",
 -		"request = %p", req);
 -	tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle));
 -}
 -
 -
 -
 -/*
   * Function name:	tw_osli_request_bus_scan
   * Description:		Requests CAM for a scan of the bus.
   *
 @@ -574,20 +557,39 @@ tw_osli_disallow_new_requests(struct twa
  
  
  /*
 - * Function name:	tw_osl_ctlr_busy
 - * Description:		CL calls this function on cmd queue full or otherwise,
 - *			when it is too busy to accept new requests.
 + * Function name:	tw_osl_timeout
 + * Description:		Call to timeout().
   *
 - * Input:		ctlr_handle	-- ptr to controller handle
 - *			req_handle	-- ptr to request handle sent by OSL.
 + * Input:		req_handle -- ptr to request handle sent by OSL.
   * Output:		None
   * Return value:	None
   */
  TW_VOID
 -tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
 
 *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
 _______________________________________________
 svn-src-all@freebsd.org mailing list
 http://lists.freebsd.org/mailman/listinfo/svn-src-all
 To unsubscribe, send any mail to "svn-src-all-unsubscribe@freebsd.org"
 

From: "Couch, Tom" <Tom.Couch@lsi.com>
To: "FreeBSD-gnats-submit@FreeBSD.org" <FreeBSD-gnats-submit@FreeBSD.org>,
        "freebsd-bugs@FreeBSD.org" <freebsd-bugs@FreeBSD.org>
Cc:  
Subject: RE: kern/149968: Kernel panic with ZFS and twa version 3.80.06.002
Date: Mon, 30 Aug 2010 13:10:48 -0600

 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Acosmail03lsicom_
 Content-Type: text/plain; charset="us-ascii"
 Content-Transfer-Encoding: quoted-printable
 
 Attaching patch FreeBSD_HEAD_src_sys_dev_twa.txt for HEAD (MAIN).
 
 Tom Couch
 
 
 
 -----Original Message-----
 From: FreeBSD-gnats-submit@FreeBSD.org [mailto:FreeBSD-gnats-submit@FreeBSD=
 .org]=20
 Sent: Wednesday, August 25, 2010 11:30 AM
 To: Couch, Tom
 Subject: Re: kern/149968: Kernel panic with ZFS and twa version 3.80.06.002
 
 Thank you very much for your problem report.
 It has the internal identification `kern/149968'.
 The individual assigned to look at your
 report is: freebsd-bugs.=20
 
 You can access the state of your problem report at any time
 via this link:
 
 http://www.freebsd.org/cgi/query-pr.cgi?pr=3D149968
 
 >Category:       kern
 >Responsible:    freebsd-bugs
 >Synopsis:       Kernel panic with ZFS and twa version 3.80.06.002
 >Arrival-Date:   Wed Aug 25 18:30:06 UTC 2010
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Acosmail03lsicom_
 Content-Type: text/plain; name="FreeBSD_HEAD_src_sys_dev_twa.txt"
 Content-Description: FreeBSD_HEAD_src_sys_dev_twa.txt
 Content-Disposition: attachment;
 	filename="FreeBSD_HEAD_src_sys_dev_twa.txt"; size=43585;
 	creation-date="Thu, 26 Aug 2010 16:55:26 GMT";
 	modification-date="Thu, 26 Aug 2010 16:55:26 GMT"
 Content-Transfer-Encoding: base64
 
 ZGlmZiAtdSBGcmVlQlNEX0hFQURfdHdhX2N2cy90d19jbC5oIEZyZWVCU0RfSEVBRF90d2FfM184
 MF8wNl8wMDMvdHdfY2wuaAotLS0gRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfY2wuaAkyMDEwLTA4
 LTI2IDE1OjM0OjMzLjAwMDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRF9IRUFEX3R3YV8zXzgwXzA2
 XzAwMy90d19jbC5oCTIwMTAtMDgtMjQgMTg6MDI6MTIuMDAwMDAwMDAwIC0wNzAwCkBAIC04OCw3
 ICs4OCw4IEBACiAjZGVmaW5lIFRXX0NMSV9CVVNZX1EJCTEJLyogcSBvZiByZXFzIHN1Ym1pdHRl
 ZCB0byBmdyAqLwogI2RlZmluZSBUV19DTElfUEVORElOR19RCTIJLyogcSBvZiByZXFzIGRlZmVy
 cmVkIGR1ZSB0byAncSBmdWxsJyAqLwogI2RlZmluZSBUV19DTElfQ09NUExFVEVfUQkzCS8qIHEg
 b2YgcmVxcyBjb21wbGV0ZWQgYnkgZncgKi8KLSNkZWZpbmUgVFdfQ0xJX1FfQ09VTlQJCTQJLyog
 dG90YWwgbnVtYmVyIG9mIHF1ZXVlcyAqLworI2RlZmluZSBUV19DTElfUkVTRVRfUQkJNAkvKiBx
 IG9mIHJlcXMgcmVzZXQgYnkgdGltZW91dCAqLworI2RlZmluZSBUV19DTElfUV9DT1VOVAkJNQkv
 KiB0b3RhbCBudW1iZXIgb2YgcXVldWVzICovCiAKIAogLyogQ0wncyBpbnRlcm5hbCByZXF1ZXN0
 IGNvbnRleHQuICovCkBAIC0xMzMsNiArMTM0LDcgQEAKIAlUV19VSU5UOCAJCWludGVycnVwdHNf
 ZW5hYmxlZDsJICAvKiBJbnRlcnJ1cHRzIG9uIGNvbnRyb2xsZXIgZW5hYmxlZC4gKi8KIAlUV19V
 SU5UOCAJCWludGVybmFsX3JlcV9idXN5OwkgIC8qIERhdGEgYnVmZmVyIGZvciBpbnRlcm5hbCBy
 ZXF1ZXN0cyBpbiB1c2UuICovCiAJVFdfVUlOVDggCQlnZXRfbW9yZV9hZW5zOwkJICAvKiBNb3Jl
 IEFFTidzIG5lZWQgdG8gYmUgcmV0cmlldmVkLiAqLworCVRXX1VJTlQ4IAkJcmVzZXRfbmVlZGVk
 OwkJICAvKiBDb250cm9sbGVyIG5lZWRzIGEgc29mdCByZXNldC4gKi8KIAlUV19VSU5UOCAJCXJl
 c2V0X2luX3Byb2dyZXNzOwkgIC8qIENvbnRyb2xsZXIgaXMgYmVpbmcgcmVzZXQuICovCiAJVFdf
 VUlOVDggCQlyZXNldF9waGFzZTFfaW5fcHJvZ3Jlc3M7IC8qIEluICdwaGFzZSAxJyBvZiByZXNl
 dC4gKi8KIAlUV19VSU5UMzIJCWZsYWdzOwkJLyogY29udHJvbGxlciBzZXR0aW5ncyAqLwpkaWZm
 IC11IEZyZWVCU0RfSEVBRF90d2FfY3ZzL3R3X2NsX2V4dGVybnMuaCBGcmVlQlNEX0hFQURfdHdh
 XzNfODBfMDZfMDAzL3R3X2NsX2V4dGVybnMuaAotLS0gRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdf
 Y2xfZXh0ZXJucy5oCTIwMTAtMDgtMjYgMTU6MzQ6MzMuMDAwMDAwMDAwIC0wNzAwCisrKyBGcmVl
 QlNEX0hFQURfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2V4dGVybnMuaAkyMDEwLTA4LTI0IDE4OjAy
 OjEyLjAwMDAwMDAwMCAtMDcwMApAQCAtODYsNiArODYsOCBAQAogCiAvKiBTb2Z0IHJlc2V0IHRo
 ZSBjb250cm9sbGVyLiAqLwogZXh0ZXJuIFRXX0lOVDMyCXR3X2NsaV9zb2Z0X3Jlc2V0KHN0cnVj
 dCB0d19jbGlfY3Rscl9jb250ZXh0ICpjdGxyKTsKK2V4dGVybiBpbnQgdHdhX3NldHVwX2ludHIo
 c3RydWN0IHR3YV9zb2Z0YyAqc2MpOworZXh0ZXJuIGludCB0d2FfdGVhcmRvd25faW50cihzdHJ1
 Y3QgdHdhX3NvZnRjICpzYyk7CiAKIC8qIFNlbmQgZG93biBhIFNDU0kgY29tbWFuZCB0byB0aGUg
 ZmlybXdhcmUgKHVzdWFsbHksIGFuIGludGVybmFsIFJlcSBTZW5zZS4gKi8KIGV4dGVybiBUV19J
 TlQzMgl0d19jbGlfc2VuZF9zY3NpX2NtZChzdHJ1Y3QgdHdfY2xpX3JlcV9jb250ZXh0ICpyZXEs
 CmRpZmYgLXUgRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfY2xfZndpZi5oIEZyZWVCU0RfSEVBRF90
 d2FfM184MF8wNl8wMDMvdHdfY2xfZndpZi5oCi0tLSBGcmVlQlNEX0hFQURfdHdhX2N2cy90d19j
 bF9md2lmLmgJMjAxMC0wOC0yNiAxNTozNDozMy4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Rf
 SEVBRF90d2FfM184MF8wNl8wMDMvdHdfY2xfZndpZi5oCTIwMTAtMDgtMjQgMTg6MDI6MTIuMDAw
 MDAwMDAwIC0wNzAwCkBAIC04OSw3ICs4OSw3IEBACiAjZGVmaW5lIFRXQV9TVEFUVVNfTUlOT1Jf
 VkVSU0lPTl9NQVNLCQkweDBGMDAwMDAwCiAjZGVmaW5lIFRXQV9TVEFUVVNfTUFKT1JfVkVSU0lP
 Tl9NQVNLCQkweEYwMDAwMDAwCiAKLSNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJ
 CTB4MDBGMDAwMDAKKyNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJCTB4MDBEMDAw
 MDAKIAogCiAvKiBQQ0kgcmVsYXRlZCBkZWZpbmVzLiAqLwpkaWZmIC11IEZyZWVCU0RfSEVBRF90
 d2FfY3ZzL3R3X2NsX2luaXQuYyBGcmVlQlNEX0hFQURfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2lu
 aXQuYwotLS0gRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfY2xfaW5pdC5jCTIwMTAtMDgtMjYgMTU6
 MzQ6MzMuMDAwMDAwMDAwIC0wNzAwCisrKyBGcmVlQlNEX0hFQURfdHdhXzNfODBfMDZfMDAzL3R3
 X2NsX2luaXQuYwkyMDEwLTA4LTI0IDE4OjAyOjEyLjAwMDAwMDAwMCAtMDcwMApAQCAtMzE1LDYg
 KzMxNSw3IEBACiAJdHdfY2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX0JVU1lfUSk7CiAJdHdf
 Y2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX1BFTkRJTkdfUSk7CiAJdHdfY2xpX3JlcV9xX2lu
 aXQoY3RsciwgVFdfQ0xJX0NPTVBMRVRFX1EpOworCXR3X2NsaV9yZXFfcV9pbml0KGN0bHIsIFRX
 X0NMSV9SRVNFVF9RKTsKIAogCS8qIEluaXRpYWxpemUgYWxsIGxvY2tzIHVzZWQgYnkgQ0wuICov
 CiAJY3Rsci0+Z2VuX2xvY2sgPSAmKGN0bHItPmdlbl9sb2NrX2hhbmRsZSk7CkBAIC02NzUsMTUg
 KzY3NiwxNCBAQAogCS8qIFN1Ym1pdCB0aGUgY29tbWFuZCwgYW5kIHdhaXQgZm9yIGl0IHRvIGNv
 bXBsZXRlLiAqLwogCWVycm9yID0gdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwK
 IAkJVFdfQ0xJX1JFUVVFU1RfVElNRU9VVF9QRVJJT0QpOwotCWlmIChlcnJvciA9PSBUV19PU0xf
 RVRJTUVET1VUKQotCQkvKiBDbGVhbi11cCBkb25lIGJ5IHR3X2NsaV9zdWJtaXRfYW5kX3BvbGxf
 cmVxdWVzdC4gKi8KLQkJcmV0dXJuKGVycm9yKTsKIAlpZiAoZXJyb3IpCiAJCWdvdG8gb3V0Owog
 CWlmICgoZXJyb3IgPSBpbml0X2Nvbm5lY3QtPnN0YXR1cykpIHsKKyNpZiAgICAgICAwCiAJCXR3
 X2NsaV9jcmVhdGVfY3Rscl9ldmVudChjdGxyLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09O
 VFJPTExFUl9FUlJPUiwKIAkJCSYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjZW5kaWYgLy8g
 MAogCQlnb3RvIG91dDsKIAl9CiAJaWYgKHNldF9mZWF0dXJlcyAmIFRXQV9FWFRFTkRFRF9JTklU
 X0NPTk5FQ1QpIHsKZGlmZiAtdSBGcmVlQlNEX0hFQURfdHdhX2N2cy90d19jbF9pbnRyLmMgRnJl
 ZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19jbF9pbnRyLmMKLS0tIEZyZWVCU0RfSEVBRF90
 d2FfY3ZzL3R3X2NsX2ludHIuYwkyMDEwLTA4LTI2IDE1OjM0OjMzLjAwMDAwMDAwMCAtMDcwMAor
 KysgRnJlZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19jbF9pbnRyLmMJMjAxMC0wOC0yNCAx
 ODowMjoxMi4wMDAwMDAwMDAgLTA3MDAKQEAgLTI0OCw4ICsyNDgsNyBAQAogI2lmZGVmIFRXX09T
 TF9ERUJVRwogCQkJdHdfY2xfcHJpbnRfY3Rscl9zdGF0cyhjdGxyLT5jdGxyX2hhbmRsZSk7CiAj
 ZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCi0JCQl0d19jbF9yZXNldF9jdGxyKGN0bHItPmN0bHJf
 aGFuZGxlKTsKLQkJCXJldHVybihUV19PU0xfRUlPKTsKKwkJCWNvbnRpbnVlOwogCQl9CiAKIAkJ
 LyoKQEAgLTQwMiw5ICs0MDEsNyBAQAogI2lmZGVmIFRXX09TTF9ERUJVRwogCQl0d19jbF9wcmlu
 dF9jdGxyX3N0YXRzKGN0bHItPmN0bHJfaGFuZGxlKTsKICNlbmRpZiAvKiBUV19PU0xfREVCVUcg
 Ki8KLQkJdHdfY2xfcmVzZXRfY3RscihjdGxyLT5jdGxyX2hhbmRsZSk7Ci0JCXJlcV9wa3QtPnN0
 YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQlnb3RvIG91dDsKKwkJcmV0dXJuOwog
 CX0KIAogCWlmIChyZXEtPmZsYWdzICYgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSkgewpAQCAt
 NDgzLDYgKzQ4MCw3IEBACiAJCQljZGJbOF0sIGNkYls5XSwgY2RiWzEwXSwgY2RiWzExXSwKIAkJ
 CWNkYlsxMl0sIGNkYlsxM10sIGNkYlsxNF0sIGNkYlsxNV0pOwogCisjaWYgICAgICAgMAogCQkv
 KiAKIAkJICogUHJpbnQgdGhlIGVycm9yLiBGaXJtd2FyZSBkb2Vzbid0IHlldCBzdXBwb3J0CiAJ
 CSAqIHRoZSAnTW9kZSBTZW5zZScgY21kLiAgRG9uJ3QgcHJpbnQgaWYgdGhlIGNtZApAQCAtNDkz
 LDYgKzQ5MSw3IEBACiAJCQl0d19jbGlfY3JlYXRlX2N0bHJfZXZlbnQocmVxLT5jdGxyLAogCQkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1IsCiAJCQkJY21kX2hkcik7Cisj
 ZW5kaWYgLy8gMAogCX0KIAogCWlmIChzY3NpX3JlcS0+c2Vuc2VfZGF0YSkgewpAQCAtNTMwLDkg
 KzUyOSwxMSBAQAogCSAqLwogCWlmICghIHJlcS0+ZXJyb3JfY29kZSkKIAkJaWYgKGNtZC0+cGFy
 YW0uc3RhdHVzKSB7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2NyZWF0ZV9jdGxyX2V2ZW50KGN0
 bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExFUl9FUlJPUiwKIAkJCQkmKHJl
 cS0+Y21kX3BrdC0+Y21kX2hkcikpOworI2VuZGlmIC8vIDAKIAkJCXR3X2NsX2NyZWF0ZV9ldmVu
 dChjdGxyLT5jdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfQ09NTU9OX0xBWUVSX0VSUk9SLAogCQkJCTB4MTIwNCwgMHgxLCBUV19DTF9TRVZFUklUWV9F
 UlJPUl9TVFJJTkcsCkBAIC01OTAsOSArNTkxLDExIEBACiAJCWlmICgoZXJyb3IgPSBjbWQtPnN0
 YXR1cykpIHsKIAkJCWNtZF9oZHIgPSAoc3RydWN0IHR3X2NsX2NvbW1hbmRfaGVhZGVyICopCiAJ
 CQkJKCYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2Ny
 ZWF0ZV9jdGxyX2V2ZW50KGN0bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExF
 Ul9FUlJPUiwKIAkJCQljbWRfaGRyKTsKKyNlbmRpZiAvLyAwCiAJCQl0d19jbF9jcmVhdGVfZXZl
 bnQoY3Rsci0+Y3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09V
 UkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCQkweDEyMDYsIDB4MSwgVFdfQ0xfU0VWRVJJVFlf
 RVJST1JfU1RSSU5HLApkaWZmIC11IEZyZWVCU0RfSEVBRF90d2FfY3ZzL3R3X2NsX2lvLmMgRnJl
 ZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19jbF9pby5jCi0tLSBGcmVlQlNEX0hFQURfdHdh
 X2N2cy90d19jbF9pby5jCTIwMTAtMDgtMjYgMTU6MzQ6MzMuMDAwMDAwMDAwIC0wNzAwCisrKyBG
 cmVlQlNEX0hFQURfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2lvLmMJMjAxMC0wOC0yNCAxODowMjox
 Mi4wMDAwMDAwMDAgLTA3MDAKQEAgLTc0LDE4ICs3NCwxMiBAQAogCXN0cnVjdCB0d19jbGlfcmVx
 X2NvbnRleHQJCSpyZXE7CiAJc3RydWN0IHR3X2NsX2NvbW1hbmRfOWsJCQkqY21kOwogCXN0cnVj
 dCB0d19jbF9zY3NpX3JlcV9wYWNrZXQJCSpzY3NpX3JlcTsKLQlUV19JTlQzMgkJCQllcnJvcjsK
 KwlUV19JTlQzMgkJCQllcnJvciA9IFRXX0NMX0VSUl9SRVFfU1VDQ0VTUzsKIAogCXR3X2NsaV9k
 YmdfcHJpbnRmKDEwLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7
 CiAKIAljdGxyID0gKHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICopKGN0bHJfaGFuZGxlLT5j
 bF9jdGxyX2N0eHQpOwogCi0JaWYgKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSB7Ci0JCXR3X2Ns
 aV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwKLQkJCSJJL08g
 ZHVyaW5nIHJlc2V0OiByZXR1cm5pbmcgYnVzeS4iKTsKLQkJcmV0dXJuKFRXX09TTF9FQlVTWSk7
 Ci0JfQotCiAJLyoKIAkgKiBJZiB3b3JraW5nIHdpdGggYSBmaXJtd2FyZSB2ZXJzaW9uIHRoYXQg
 ZG9lcyBub3Qgc3VwcG9ydCBtdWx0aXBsZQogCSAqIGx1bnMsIGFuZCB0aGlzIHJlcXVlc3QgaXMg
 ZGlyZWN0ZWQgYXQgYSBub24temVybyBsdW4sIGVycm9yIGl0CkBAIC0xNDUsNyArMTM5LDEyIEBA
 CiAJCQljbWQtPnNnX2xpc3QsIHNjc2lfcmVxLT5zZ2xfZW50cmllcyk7CiAJfQogCi0JaWYgKChl
 cnJvciA9IHR3X2NsaV9zdWJtaXRfY21kKHJlcSkpKSB7CisJaWYgKCgoVFdfQ0xfUV9GSVJTVF9J
 VEVNKCYoY3Rsci0+cmVxX3FfaGVhZFtUV19DTElfUEVORElOR19RXSkpKSAhPSBUV19DTF9OVUxM
 KSB8fAorCQkoY3Rsci0+cmVzZXRfaW5fcHJvZ3Jlc3MpKSB7CisJCXR3X2NsaV9yZXFfcV9pbnNl
 cnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOworCQlUV19DTElfV1JJVEVfQ09OVFJPTF9S
 RUdJU1RFUihjdGxyX2hhbmRsZSwKKwkJCVRXQV9DT05UUk9MX1VOTUFTS19DT01NQU5EX0lOVEVS
 UlVQVCk7CisJfSBlbHNlIGlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgewog
 CQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksCiAJ
 CQkiQ291bGQgbm90IHN0YXJ0IHJlcXVlc3QuIHJlcXVlc3QgPSAlcCwgZXJyb3IgPSAlZCIsCiAJ
 CQlyZXEsIGVycm9yKTsKQEAgLTE3MSw3ICsxNzAsNyBAQAogCXN0cnVjdCB0d19jbGlfY3Rscl9j
 b250ZXh0CSpjdGxyID0gcmVxLT5jdGxyOwogCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZQkqY3Rs
 cl9oYW5kbGUgPSBjdGxyLT5jdGxyX2hhbmRsZTsKIAlUV19VSU5UMzIJCQlzdGF0dXNfcmVnOwot
 CVRXX0lOVDMyCQkJZXJyb3I7CisJVFdfSU5UMzIJCQllcnJvciA9IDA7CiAKIAl0d19jbGlfZGJn
 X3ByaW50ZigxMCwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLCAiZW50ZXJlZCIpOwog
 CkBAIC0xODUsMTEgKzE4NCw3IEBACiAJCQkJIFRXQV9DT01NQU5EX1FVRVVFX09GRlNFVF9MT1cs
 CiAJCQkJIChUV19VSU5UMzIpKHJlcS0+Y21kX3BrdF9waHlzICsgc2l6ZW9mKHN0cnVjdCB0d19j
 bF9jb21tYW5kX2hlYWRlcikpLCA0KTsKIAotCS8qIENoZWNrIHRvIHNlZSBpZiB3ZSBjYW4gcG9z
 dCBhIGNvbW1hbmQuICovCiAJc3RhdHVzX3JlZyA9IFRXX0NMSV9SRUFEX1NUQVRVU19SRUdJU1RF
 UihjdGxyX2hhbmRsZSk7Ci0JaWYgKChlcnJvciA9IHR3X2NsaV9jaGVja19jdGxyX3N0YXRlKGN0
 bHIsIHN0YXR1c19yZWcpKSkKLQkJZ290byBvdXQ7Ci0KIAlpZiAoc3RhdHVzX3JlZyAmIFRXQV9T
 VEFUVVNfQ09NTUFORF9RVUVVRV9GVUxMKSB7CiAJCXN0cnVjdCB0d19jbF9yZXFfcGFja2V0CSpy
 ZXFfcGt0ID0KIAkJCShzdHJ1Y3QgdHdfY2xfcmVxX3BhY2tldCAqKShyZXEtPm9yaWdfcmVxKTsK
 QEAgLTIwNywxNCArMjAyLDEyIEBACiAJCQkJCSJwZW5kaW5nIGludGVybmFsL2lvY3RsIHJlcXVl
 c3QiKTsKIAkJCQlyZXEtPnN0YXRlID0gVFdfQ0xJX1JFUV9TVEFURV9QRU5ESU5HOwogCQkJCXR3
 X2NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOwotCQkJCWVycm9y
 ID0gMDsKIAkJCQkvKiBVbm1hc2sgY29tbWFuZCBpbnRlcnJ1cHQuICovCiAJCQkJVFdfQ0xJX1dS
 SVRFX0NPTlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCiAJCQkJCVRXQV9DT05UUk9MX1VOTUFT
 S19DT01NQU5EX0lOVEVSUlVQVCk7CiAJCQl9IGVsc2UKIAkJCQllcnJvciA9IFRXX09TTF9FQlVT
 WTsKIAkJfSBlbHNlIHsKLQkJCXR3X29zbF9jdGxyX2J1c3koY3Rscl9oYW5kbGUsIHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQllcnJvciA9IFRXX09TTF9FQlVTWTsKIAkJfQogCX0gZWxzZSB7CkBAIC0y
 NDYsNyArMjM5LDcgQEAKIAkJCQkJCSAoVFdfVUlOVDMyKShyZXEtPmNtZF9wa3RfcGh5cyArIHNp
 emVvZihzdHJ1Y3QgdHdfY2xfY29tbWFuZF9oZWFkZXIpKSwgNCk7CiAJCX0KIAl9Ci1vdXQ6CisK
 IAl0d19vc2xfZnJlZV9sb2NrKGN0bHJfaGFuZGxlLCBjdGxyLT5pb19sb2NrKTsKIAogCXJldHVy
 bihlcnJvcik7CkBAIC0yNzcsMTggKzI3MCwxMiBAQAogCVRXX1VJTlQ4CQkJCW9wY29kZTsKIAlU
 V19VSU5UOAkJCQlzZ2xfb2Zmc2V0OwogCVRXX1ZPSUQJCQkJCSpzZ2wgPSBUV19DTF9OVUxMOwot
 CVRXX0lOVDMyCQkJCWVycm9yOworCVRXX0lOVDMyCQkJCWVycm9yID0gVFdfQ0xfRVJSX1JFUV9T
 VUNDRVNTOwogCiAJdHdfY2xpX2RiZ19wcmludGYoNSwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJf
 ZnVuYygpLCAiZW50ZXJlZCIpOwogCiAJY3RsciA9IChzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4
 dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKIAotCWlmIChjdGxyLT5yZXNldF9pbl9w
 cm9ncmVzcykgewotCQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1
 cl9mdW5jKCksCi0JCQkiUGFzc3RocnUgcmVxdWVzdCBkdXJpbmcgcmVzZXQ6IHJldHVybmluZyBi
 dXN5LiIpOwotCQlyZXR1cm4oVFdfT1NMX0VCVVNZKTsKLQl9Ci0KIAlpZiAoKHJlcSA9IHR3X2Ns
 aV9nZXRfcmVxdWVzdChjdGxyCiAJCSkpID09IFRXX0NMX05VTEwpIHsKIAkJdHdfY2xpX2RiZ19w
 cmludGYoMiwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLApAQCAtMzAxLDcgKzI4OCw3
 IEBACiAJcmVxLT5vcmlnX3JlcSA9IHJlcV9wa3Q7CiAJcmVxLT50d19jbGlfY2FsbGJhY2sgPSB0
 d19jbGlfY29tcGxldGVfaW87CiAKLQlyZXEtPmZsYWdzIHw9IChUV19DTElfUkVRX0ZMQUdTX0VY
 VEVSTkFMIHwgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSk7CisJcmVxLT5mbGFncyB8PSBUV19D
 TElfUkVRX0ZMQUdTX1BBU1NUSFJVOwogCiAJcHRfcmVxID0gJihyZXFfcGt0LT5nZW5fcmVxX3Br
 dC5wdF9yZXEpOwogCkBAIC0zNDgsNyArMzM1LDEyIEBACiAJCXR3X2NsaV9maWxsX3NnX2xpc3Qo
 Y3RsciwgcHRfcmVxLT5zZ19saXN0LAogCQkJc2dsLCBwdF9yZXEtPnNnbF9lbnRyaWVzKTsKIAot
 CWlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgeworCWlmICgoKFRXX0NMX1Ff
 RklSU1RfSVRFTSgmKGN0bHItPnJlcV9xX2hlYWRbVFdfQ0xJX1BFTkRJTkdfUV0pKSkgIT0gVFdf
 Q0xfTlVMTCkgfHwKKwkJKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkgeworCQl0d19jbGlfcmVx
 X3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfUEVORElOR19RKTsKKwkJVFdfQ0xJX1dSSVRFX0NP
 TlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCisJCQlUV0FfQ09OVFJPTF9VTk1BU0tfQ09NTUFO
 RF9JTlRFUlJVUFQpOworCX0gZWxzZSBpZiAoKGVycm9yID0gdHdfY2xpX3N1Ym1pdF9jbWQocmVx
 KSkpIHsKIAkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCTB4MTEwMCwgMHgx
 LCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCkBAIC03NjAsOCArNzUyLDcgQEAKIAogCWNt
 ZC0+cGFyYW0uc2dsX29mZl9fb3Bjb2RlID0KIAkJQlVJTERfU0dMX09GRl9fT1BDT0RFKDIsIFRX
 QV9GV19DTURfR0VUX1BBUkFNKTsKLQljbWQtPnBhcmFtLnJlcXVlc3RfaWQgPQotCQkoVFdfVUlO
 VDgpKFRXX0NMX1NXQVAxNihyZXEtPnJlcXVlc3RfaWQpKTsKKwljbWQtPnBhcmFtLnJlcXVlc3Rf
 aWQgPSAoVFdfVUlOVDgpKFRXX0NMX1NXQVAxNihyZXEtPnJlcXVlc3RfaWQpKTsKIAljbWQtPnBh
 cmFtLmhvc3RfaWRfX3VuaXQgPSBCVUlMRF9IT1NUX0lEX19VTklUKDAsIDApOwogCWNtZC0+cGFy
 YW0ucGFyYW1fY291bnQgPSBUV19DTF9TV0FQMTYoMSk7CiAKQEAgLTc4OSwxNSArNzgwLDE0IEBA
 CiAJCS8qIFRoZXJlJ3Mgbm8gY2FsbCBiYWNrOyB3YWl0IHRpbGwgdGhlIGNvbW1hbmQgY29tcGxl
 dGVzLiAqLwogCQllcnJvciA9IHR3X2NsaV9zdWJtaXRfYW5kX3BvbGxfcmVxdWVzdChyZXEsCiAJ
 CQkJVFdfQ0xJX1JFUVVFU1RfVElNRU9VVF9QRVJJT0QpOwotCQlpZiAoZXJyb3IgPT0gVFdfT1NM
 X0VUSU1FRE9VVCkKLQkJCS8qIENsZWFuLXVwIGRvbmUgYnkgdHdfY2xpX3N1Ym1pdF9hbmRfcG9s
 bF9yZXF1ZXN0LiAqLwotCQkJcmV0dXJuKGVycm9yKTsKIAkJaWYgKGVycm9yKQogCQkJZ290byBv
 dXQ7CiAJCWlmICgoZXJyb3IgPSBjbWQtPnBhcmFtLnN0YXR1cykpIHsKKyNpZiAgICAgICAwCiAJ
 CQl0d19jbGlfY3JlYXRlX2N0bHJfZXZlbnQoY3RsciwKIAkJCQlUV19DTF9NRVNTQUdFX1NPVVJD
 RV9DT05UUk9MTEVSX0VSUk9SLAogCQkJCSYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjZW5k
 aWYgLy8gMAogCQkJZ290byBvdXQ7CiAJCX0KIAkJdHdfb3NsX21lbWNweShwYXJhbV9kYXRhLCBw
 YXJhbS0+ZGF0YSwgcGFyYW1fc2l6ZSk7CkBAIC05MDUsMTggKzg5NSwxNyBAQAogCiAJLyogU3Vi
 bWl0IHRoZSBjb21tYW5kLiAqLwogCWlmIChjYWxsYmFjayA9PSBUV19DTF9OVUxMKSB7Ci0JCS8q
 IFRoZXJlJ3Mgbm8gY2FsbCBiYWNrOyAgd2FpdCB0aWxsIHRoZSBjb21tYW5kIGNvbXBsZXRlcy4g
 Ki8KKwkJLyogVGhlcmUncyBubyBjYWxsIGJhY2s7IHdhaXQgdGlsbCB0aGUgY29tbWFuZCBjb21w
 bGV0ZXMuICovCiAJCWVycm9yID0gdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwK
 LQkJCVRXX0NMSV9SRVFVRVNUX1RJTUVPVVRfUEVSSU9EKTsKLQkJaWYgKGVycm9yID09IFRXX09T
 TF9FVElNRURPVVQpCi0JCQkvKiBDbGVhbi11cCBkb25lIGJ5IHR3X2NsaV9zdWJtaXRfYW5kX3Bv
 bGxfcmVxdWVzdC4gKi8KLQkJCXJldHVybihlcnJvcik7CisJCQkJVFdfQ0xJX1JFUVVFU1RfVElN
 RU9VVF9QRVJJT0QpOwogCQlpZiAoZXJyb3IpCiAJCQlnb3RvIG91dDsKIAkJaWYgKChlcnJvciA9
 IGNtZC0+cGFyYW0uc3RhdHVzKSkgeworI2lmICAgICAgIDAKIAkJCXR3X2NsaV9jcmVhdGVfY3Rs
 cl9ldmVudChjdGxyLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1Is
 CiAJCQkJJihyZXEtPmNtZF9wa3QtPmNtZF9oZHIpKTsKKyNlbmRpZiAvLyAwCiAJCQlnb3RvIG91
 dDsKIAkJfQogCQljdGxyLT5pbnRlcm5hbF9yZXFfYnVzeSA9IFRXX0NMX0ZBTFNFOwpAQCAtMTAy
 Miw5ICsxMDExLDcgQEAKIAkgKiB0d19jbGlfc3VibWl0X3BlbmRpbmdfcXVldWUuICBUaGVyZSBj
 b3VsZCBiZSBhIHJhY2UgaW4gdGhhdCBjYXNlLgogCSAqIE5lZWQgdG8gcmV2aXNpdC4KIAkgKi8K
 LQlpZiAocmVxLT5zdGF0ZSAhPSBUV19DTElfUkVRX1NUQVRFX1BFTkRJTkcpCi0JCXR3X2NsX3Jl
 c2V0X2N0bHIoY3Rsci0+Y3Rscl9oYW5kbGUpOwotCWVsc2UgeworCWlmIChyZXEtPnN0YXRlID09
 IFRXX0NMSV9SRVFfU1RBVEVfUEVORElORykgewogCQl0d19jbGlfZGJnX3ByaW50ZigzLCBjdGxy
 LT5jdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksCiAJCQkiUmVtb3ZpbmcgcmVxdWVzdCBm
 cm9tIHBlbmRpbmcgcXVldWUiKTsKIAkJLyoKQEAgLTEwNTMsNiArMTA0MCw3IEBACiAgKgkJCWRy
 YWlucyBhbnkgaW5jb21wbGV0ZSByZXF1ZXN0cy4KICAqCiAgKiBJbnB1dDoJCWN0bHIJLS0gcHRy
 IHRvIHBlciBjdGxyIHN0cnVjdHVyZQorICogCQkJcmVxX2hhbmRsZQktLSBwdHIgdG8gcmVxdWVz
 dCBoYW5kbGUKICAqIE91dHB1dDoJCU5vbmUKICAqIFJldHVybiB2YWx1ZToJMAktLSBzdWNjZXNz
 CiAgKgkJCW5vbi16ZXJvLS0gZmFpbHVyZQpAQCAtMTA2MywxNSArMTA1MSwxNSBAQAogCXN0cnVj
 dCB0d19jbGlfY3Rscl9jb250ZXh0CSpjdGxyID0KIAkJKHN0cnVjdCB0d19jbGlfY3Rscl9jb250
 ZXh0ICopKGN0bHJfaGFuZGxlLT5jbF9jdGxyX2N0eHQpOwogCXN0cnVjdCB0d2Ffc29mdGMJCSpz
 YyA9IGN0bHJfaGFuZGxlLT5vc2xfY3Rscl9jdHh0OworCXN0cnVjdCB0d19jbGlfcmVxX2NvbnRl
 eHQJKnJlcTsKIAlUV19JTlQzMgkJCXJlc2V0X2F0dGVtcHQgPSAxOwotCVRXX0lOVDMyCQkJZXJy
 b3I7CisJVFdfSU5UMzIJCQllcnJvciA9IDA7CiAKIAl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxy
 X2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7CiAKIAljdGxyLT5yZXNldF9p
 bl9wcm9ncmVzcyA9IFRXX0NMX1RSVUU7Ci0JeHB0X2ZyZWV6ZV9zaW1xKHNjLT5zaW0sIDEpOwor
 CXR3YV90ZWFyZG93bl9pbnRyKHNjKTsKIAotCXR3X2NsaV9kaXNhYmxlX2ludGVycnVwdHMoY3Rs
 cik7CiAKIAkvKgogCSAqIEVycm9yIGJhY2sgYWxsIHJlcXVlc3RzIGluIHRoZSBjb21wbGV0ZSwg
 YnVzeSwgYW5kIHBlbmRpbmcgcXVldWVzLgpAQCAtMTA4MCw4ICsxMDY4LDYgQEAKIAkgKiB3aWxs
 IGNvbnRpbnVlIGl0cyBjb3Vyc2UgYW5kIGdldCBzdWJtaXR0ZWQgdG8gdGhlIGNvbnRyb2xsZXIg
 YWZ0ZXIKIAkgKiB0aGUgcmVzZXQgaXMgZG9uZSAoYW5kIGlvX2xvY2sgaXMgcmVsZWFzZWQpLgog
 CSAqLwotCXR3X2NsaV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMo
 KSwKLQkJIkRyYWluaW5nIGFsbCBxdWV1ZXMgZm9sbG93aW5nIHJlc2V0Iik7CiAJdHdfY2xpX2Ry
 YWluX2NvbXBsZXRlX3F1ZXVlKGN0bHIpOwogCXR3X2NsaV9kcmFpbl9idXN5X3F1ZXVlKGN0bHIp
 OwogCXR3X2NsaV9kcmFpbl9wZW5kaW5nX3F1ZXVlKGN0bHIpOwpAQCAtMTA4OSw1MyArMTA3NSw4
 OCBAQAogCWN0bHItPmdldF9tb3JlX2FlbnMgICAgID0gVFdfQ0xfRkFMU0U7CiAKIAkvKiBTb2Z0
 IHJlc2V0IHRoZSBjb250cm9sbGVyLiAqLwotdHJ5X3Jlc2V0OgotCWlmICgoZXJyb3IgPSB0d19j
 bGlfc29mdF9yZXNldChjdGxyKSkpIHsKLQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxl
 LCBUV19DTF9UUlVFLAotCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5U
 LAotCQkJMHgxMTA1LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCSJDb250
 cm9sbGVyIHJlc2V0IGZhaWxlZCIsCi0JCQkiZXJyb3IgPSAlZDsgYXR0ZW1wdCAlZCIsIGVycm9y
 LCByZXNldF9hdHRlbXB0KyspOwotCQlpZiAocmVzZXRfYXR0ZW1wdCA8PSBUV19DTElfTUFYX1JF
 U0VUX0FUVEVNUFRTKQotCQkJZ290byB0cnlfcmVzZXQ7Ci0JCWVsc2UKLQkJCWdvdG8gb3V0Owot
 CX0KKwl3aGlsZSAocmVzZXRfYXR0ZW1wdCA8PSBUV19DTElfTUFYX1JFU0VUX0FUVEVNUFRTKSB7
 CisJCWlmICgoZXJyb3IgPSB0d19jbGlfc29mdF9yZXNldChjdGxyKSkpIHsKKwkJCXR3X2NsX2Ny
 ZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCisJCQkJVFdfQ0xfTUVTU0FHRV9T
 T1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAorCQkJCTB4MTEwNSwgMHgxLCBUV19DTF9TRVZFUklU
 WV9FUlJPUl9TVFJJTkcsCisJCQkJIkNvbnRyb2xsZXIgcmVzZXQgZmFpbGVkIiwKKwkJCQkiZXJy
 b3IgPSAlZDsgYXR0ZW1wdCAlZCIsIGVycm9yLCByZXNldF9hdHRlbXB0KyspOworCQkJcmVzZXRf
 YXR0ZW1wdCsrOworCQkJY29udGludWU7CisJCX0KIAotCS8qIFJlLWVzdGFibGlzaCBsb2dpY2Fs
 IGNvbm5lY3Rpb24gd2l0aCB0aGUgY29udHJvbGxlci4gKi8KLQlpZiAoKGVycm9yID0gdHdfY2xp
 X2luaXRfY29ubmVjdGlvbihjdGxyLAotCQkJKFRXX1VJTlQxNikoY3Rsci0+bWF4X3NpbXVsdF9y
 ZXFzKSwKLQkJCTAsIDAsIDAsIDAsIDAsIFRXX0NMX05VTEwsIFRXX0NMX05VTEwsIFRXX0NMX05V
 TEwsCi0JCQlUV19DTF9OVUxMLCBUV19DTF9OVUxMKSkpIHsKLQkJdHdfY2xfY3JlYXRlX2V2ZW50
 KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQkvKiBSZS1lc3RhYmxpc2ggbG9naWNhbCBjb25u
 ZWN0aW9uIHdpdGggdGhlIGNvbnRyb2xsZXIuICovCisJCWlmICgoZXJyb3IgPSB0d19jbGlfaW5p
 dF9jb25uZWN0aW9uKGN0bHIsCisJCQkJKFRXX1VJTlQxNikoY3Rsci0+bWF4X3NpbXVsdF9yZXFz
 KSwKKwkJCQkwLCAwLCAwLCAwLCAwLCBUV19DTF9OVUxMLCBUV19DTF9OVUxMLCBUV19DTF9OVUxM
 LAorCQkJCVRXX0NMX05VTEwsIFRXX0NMX05VTEwpKSkgeworCQkJdHdfY2xfY3JlYXRlX2V2ZW50
 KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKKwkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01N
 T05fTEFZRVJfRVZFTlQsCisJCQkJMHgxMTA2LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NU
 UklORywKKwkJCQkiQ2FuJ3QgaW5pdGlhbGl6ZSBjb25uZWN0aW9uIGFmdGVyIHJlc2V0IiwKKwkJ
 CQkiZXJyb3IgPSAlZCIsIGVycm9yKTsKKwkJCXJlc2V0X2F0dGVtcHQrKzsKKwkJCWNvbnRpbnVl
 OworCQl9CisKKyNpZmRlZiAgICBUV19PU0xfREVCVUcKKwkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0
 bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9M
 QVlFUl9FVkVOVCwKLQkJCTB4MTEwNiwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcs
 Ci0JCQkiQ2FuJ3QgaW5pdGlhbGl6ZSBjb25uZWN0aW9uIGFmdGVyIHJlc2V0IiwKLQkJCSJlcnJv
 ciA9ICVkIiwgZXJyb3IpOwotCQlnb3RvIG91dDsKLQl9CisJCQkweDExMDcsIDB4MywgVFdfQ0xf
 U0VWRVJJVFlfSU5GT19TVFJJTkcsCisJCQkiQ29udHJvbGxlciByZXNldCBkb25lISIsICIgIik7
 CisjZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCisJCWJyZWFrOworCX0gLyogRW5kIG9mIHdoaWxl
 ICovCiAKLQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCi0JCVRX
 X0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKLQkJMHgxMTA3LCAweDMsIFRX
 X0NMX1NFVkVSSVRZX0lORk9fU1RSSU5HLAotCQkiQ29udHJvbGxlciByZXNldCBkb25lISIsCi0J
 CSIgIik7CisJLyogTW92ZSBjb21tYW5kcyBmcm9tIHRoZSByZXNldCBxdWV1ZSB0byB0aGUgcGVu
 ZGluZyBxdWV1ZS4gKi8KKwl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFfcV9yZW1vdmVfaGVhZChj
 dGxyLCBUV19DTElfUkVTRVRfUSkpICE9IFRXX0NMX05VTEwpIHsKKwkJdHdfb3NsX3RpbWVvdXQo
 cmVxLT5yZXFfaGFuZGxlKTsKKwkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X1BFTkRJTkdfUSk7CisJfQogCi1vdXQ6CisJdHdhX3NldHVwX2ludHIoc2MpOworCXR3X2NsaV9l
 bmFibGVfaW50ZXJydXB0cyhjdGxyKTsKKwlpZiAoKFRXX0NMX1FfRklSU1RfSVRFTSgmKGN0bHIt
 PnJlcV9xX2hlYWRbVFdfQ0xJX1BFTkRJTkdfUV0pKSkgIT0gVFdfQ0xfTlVMTCkKKwkJVFdfQ0xJ
 X1dSSVRFX0NPTlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCisJCQlUV0FfQ09OVFJPTF9VTk1B
 U0tfQ09NTUFORF9JTlRFUlJVUFQpOwogCWN0bHItPnJlc2V0X2luX3Byb2dyZXNzID0gVFdfQ0xf
 RkFMU0U7Ci0JeHB0X3JlbGVhc2Vfc2ltcShzYy0+c2ltLCAxKTsKKwljdGxyLT5yZXNldF9uZWVk
 ZWQgPSBUV19DTF9GQUxTRTsKIAotCS8qCi0JICogRW5hYmxlIGludGVycnVwdHMsIGFuZCBhbHNv
 IGNsZWFyIGF0dGVudGlvbiBhbmQgcmVzcG9uc2UgaW50ZXJydXB0cy4KLQkgKi8KLQl0d19jbGlf
 ZW5hYmxlX2ludGVycnVwdHMoY3Rscik7Ci0JCiAJLyogUmVxdWVzdCBmb3IgYSBidXMgcmUtc2Nh
 bi4gKi8KLQlpZiAoIWVycm9yKQotCQl0d19vc2xfc2Nhbl9idXMoY3Rscl9oYW5kbGUpOworCXR3
 X29zbF9zY2FuX2J1cyhjdGxyX2hhbmRsZSk7CisKIAlyZXR1cm4oZXJyb3IpOwogfQogCitUV19W
 T0lECit0d19jbF9zZXRfcmVzZXRfbmVlZGVkKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rs
 cl9oYW5kbGUpCit7CisJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJKmN0bHIgPQorCQkoc3Ry
 dWN0IHR3X2NsaV9jdGxyX2NvbnRleHQgKikoY3Rscl9oYW5kbGUtPmNsX2N0bHJfY3R4dCk7CisK
 KwljdGxyLT5yZXNldF9uZWVkZWQgPSBUV19DTF9UUlVFOworfQorCitUV19JTlQzMgordHdfY2xf
 aXNfcmVzZXRfbmVlZGVkKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUpCit7
 CisJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJKmN0bHIgPQorCQkoc3RydWN0IHR3X2NsaV9j
 dGxyX2NvbnRleHQgKikoY3Rscl9oYW5kbGUtPmNsX2N0bHJfY3R4dCk7CisKKwlyZXR1cm4oY3Rs
 ci0+cmVzZXRfbmVlZGVkKTsKK30KKworVFdfSU5UMzIKK3R3X2NsX2lzX2FjdGl2ZShzdHJ1Y3Qg
 dHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlKQoreworCXN0cnVjdCB0d19jbGlfY3Rscl9j
 b250ZXh0CSpjdGxyID0KKwkJKHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICopCisJCShjdGxy
 X2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKKworCQlyZXR1cm4oY3Rsci0+YWN0aXZlKTsKK30KKwog
 CiAKIC8qCkBAIC0xMTUxLDE0ICsxMTcyLDEzIEBACiB0d19jbGlfc29mdF9yZXNldChzdHJ1Y3Qg
 dHdfY2xpX2N0bHJfY29udGV4dCAqY3RscikKIHsKIAlzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5kbGUJ
 KmN0bHJfaGFuZGxlID0gY3Rsci0+Y3Rscl9oYW5kbGU7Ci0JVFdfVUlOVDMyCQkJc3RhdHVzX3Jl
 ZzsKIAlpbnQJCQkJZm91bmQ7CiAJaW50CQkJCWxvb3BfY291bnQ7CiAJVFdfVUlOVDMyCQkJZXJy
 b3I7CiAKIAl0d19jbGlfZGJnX3ByaW50ZigxLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5j
 KCksICJlbnRlcmVkIik7CiAKLQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NM
 X1RSVUUsCisJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 VFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkweDExMDgsIDB4Mywg
 VFdfQ0xfU0VWRVJJVFlfSU5GT19TVFJJTkcsCiAJCSJSZXNldHRpbmcgY29udHJvbGxlci4uLiIs
 CkBAIC0xMTkzLDcgKzEyMTMsNyBAQAogCQl9IHdoaWxlICghZm91bmQgJiYgKGxvb3BfY291bnQg
 PCA2MDAwMDAwKSk7IC8qIExvb3AgZm9yIG5vIG1vcmUgdGhhbiA2MCBzZWNvbmRzICovCiAKIAkJ
 aWYgKCFmb3VuZCkgewotCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9U
 UlVFLAorCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZFTlQsCiAJCQkJMHgxMTA5LCAw
 eDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKIAkJCQkiTWlzc2VkIGZpcm13YXJlIGhh
 bmRzaGFrZSBhZnRlciBzb2Z0LXJlc2V0IiwKQEAgLTEyMTAsNyArMTIzMCw3IEBACiAJCQlUV0Ff
 U1RBVFVTX01JQ1JPQ09OVFJPTExFUl9SRUFEWSB8CiAJCQlUV0FfU1RBVFVTX0FUVEVOVElPTl9J
 TlRFUlJVUFQsCiAJCQlUV19DTElfUkVTRVRfVElNRU9VVF9QRVJJT0QpKSkgewotCQl0d19jbF9j
 cmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCisJCXR3X2NsX2NyZWF0ZV9ldmVu
 dChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01N
 T05fTEFZRVJfRVZFTlQsCiAJCQkweDExMDksIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RS
 SU5HLAogCQkJIk1pY3JvLWN0bHIgbm90IHJlYWR5L05vIGF0dG4gaW50ciBhZnRlciByZXNldCIs
 CkBAIC0xMjQ0LDI2ICsxMjY0LDE0IEBACiAJfQogCQogCWlmICgoZXJyb3IgPSB0d19jbGlfZmlu
 ZF9hZW4oY3RsciwgVFdBX0FFTl9TT0ZUX1JFU0VUKSkpIHsKLQkJdHdfY2xfY3JlYXRlX2V2ZW50
 KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5k
 bGUsIFRXX0NMX0ZBTFNFLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VW
 RU5ULAogCQkJMHgxMTBDLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKIAkJCSJS
 ZXNldCBub3QgcmVwb3J0ZWQgYnkgY29udHJvbGxlciIsCiAJCQkiZXJyb3IgPSAlZCIsIGVycm9y
 KTsKIAkJcmV0dXJuKGVycm9yKTsKIAl9Ci0JCi0Jc3RhdHVzX3JlZyA9IFRXX0NMSV9SRUFEX1NU
 QVRVU19SRUdJU1RFUihjdGxyX2hhbmRsZSk7Ci0JCi0JaWYgKChlcnJvciA9IFRXX0NMSV9TVEFU
 VVNfRVJST1JTKHN0YXR1c19yZWcpKSB8fAotCQkJKGVycm9yID0gdHdfY2xpX2NoZWNrX2N0bHJf
 c3RhdGUoY3Rsciwgc3RhdHVzX3JlZykpKSB7Ci0JCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hh
 bmRsZSwgVFdfQ0xfVFJVRSwKLQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9F
 VkVOVCwKLQkJCTB4MTEwRCwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCi0JCQki
 Q29udHJvbGxlciBlcnJvcnMgZGV0ZWN0ZWQgYWZ0ZXIgcmVzZXQiLAotCQkJImVycm9yID0gJWQi
 LCBlcnJvcik7Ci0JCXJldHVybihlcnJvcik7Ci0JfQotCQorCiAJcmV0dXJuKFRXX09TTF9FU1VD
 Q0VTUyk7CiB9CiAKZGlmZiAtdSBGcmVlQlNEX0hFQURfdHdhX2N2cy90d19jbF9taXNjLmMgRnJl
 ZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19jbF9taXNjLmMKLS0tIEZyZWVCU0RfSEVBRF90
 d2FfY3ZzL3R3X2NsX21pc2MuYwkyMDEwLTA4LTI2IDE1OjM0OjMzLjAwMDAwMDAwMCAtMDcwMAor
 KysgRnJlZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19jbF9taXNjLmMJMjAxMC0wOC0yNCAx
 ODowMjoxMi4wMDAwMDAwMDAgLTA3MDAKQEAgLTgzLDcgKzgzLDggQEAKIAl0d19jbGlfZGJnX3By
 aW50ZigzLCBjdGxyLT5jdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7
 CiAKIAkvKiBXYWxrIHRoZSBidXN5IHF1ZXVlLiAqLwotCXdoaWxlICgocmVxID0gdHdfY2xpX3Jl
 cV9xX3JlbW92ZV9oZWFkKGN0bHIsIFRXX0NMSV9DT01QTEVURV9RKSkpIHsKKwl3aGlsZSAoKHJl
 cSA9IHR3X2NsaV9yZXFfcV9yZW1vdmVfaGVhZChjdGxyLCBUV19DTElfQ09NUExFVEVfUSkpICE9
 CisJCVRXX0NMX05VTEwpIHsKIAkJaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdTX0lO
 VEVSTkFMKSB7CiAJCQkvKgogCQkJICogSXQncyBhbiBpbnRlcm5hbCByZXF1ZXN0LiAgU2V0IHRo
 ZSBhcHByb3ByaWF0ZQpAQCAtOTcsMjAgKzk4LDIxIEBACiAJCQlyZXEtPmVycm9yX2NvZGUgPSBU
 V19DTF9FUlJfUkVRX0JVU19SRVNFVDsKIAkJCWlmIChyZXEtPnR3X2NsaV9jYWxsYmFjaykKIAkJ
 CQlyZXEtPnR3X2NsaV9jYWxsYmFjayhyZXEpOwotCQl9IGVsc2UgewotCQkJaWYgKChyZXFfcGt0
 ID0gcmVxLT5vcmlnX3JlcSkpIHsKLQkJCQkvKiBJdCdzIGEgU0NTSSByZXF1ZXN0LiAgQ29tcGxl
 dGUgaXQuICovCi0JCQkJdHdfY2xpX2RiZ19wcmludGYoMiwgY3Rsci0+Y3Rscl9oYW5kbGUsCi0J
 CQkJCXR3X29zbF9jdXJfZnVuYygpLAotCQkJCQkiQ29tcGxldGluZyBjb21wbGV0ZSByZXF1ZXN0
 ICVwICIKLQkJCQkJIm9uIHJlc2V0IiwKLQkJCQkJcmVxKTsKKwkJfSBlbHNlIGlmIChyZXEtPmZs
 YWdzICYgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSkgeworCQkJLyogSXQncyBhIHBhc3N0aHJ1
 IHJlcXVlc3QuICBDb21wbGV0ZSBpdC4gKi8KKwkJCWlmICgocmVxX3BrdCA9IHJlcS0+b3JpZ19y
 ZXEpICE9IFRXX0NMX05VTEwpIHsKIAkJCQlyZXFfcGt0LT5zdGF0dXMgPSBUV19DTF9FUlJfUkVR
 X0JVU19SRVNFVDsKLQkJCQlyZXFfcGt0LT50d19vc2xfY2FsbGJhY2socmVxLT5yZXFfaGFuZGxl
 KTsKKworCQkJCWlmIChyZXFfcGt0LT50d19vc2xfY2FsbGJhY2spCisJCQkJCXJlcV9wa3QtPnR3
 X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOwogCQkJfQogCQkJdHdfY2xpX3JlcV9xX2lu
 c2VydF90YWlsKHJlcSwgVFdfQ0xJX0ZSRUVfUSk7CisJCX0gZWxzZSB7CisJCQkvKiBJdCdzIGFu
 IGV4dGVybmFsIChTQ1NJKSByZXF1ZXN0LiAgQWRkIGl0IHRvIHRoZSByZXNldCBxdWV1ZS4gKi8K
 KwkJCXR3X29zbF91bnRpbWVvdXQocmVxLT5yZXFfaGFuZGxlKTsKKwkJCXR3X2NsaV9yZXFfcV9p
 bnNlcnRfdGFpbChyZXEsIFRXX0NMSV9SRVNFVF9RKTsKIAkJfQotCX0KKwl9IC8qIEVuZCBvZiB3
 aGlsZSBsb29wICovCiB9CiAKIApAQCAtMTM1LDcgKzEzNyw4IEBACiAJdHdfY2xpX2RiZ19wcmlu
 dGYoMywgY3Rsci0+Y3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLCAiZW50ZXJlZCIpOwog
 CiAJLyogV2FsayB0aGUgYnVzeSBxdWV1ZS4gKi8KLQl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFf
 cV9yZW1vdmVfaGVhZChjdGxyLCBUV19DTElfQlVTWV9RKSkpIHsKKwl3aGlsZSAoKHJlcSA9IHR3
 X2NsaV9yZXFfcV9yZW1vdmVfaGVhZChjdGxyLCBUV19DTElfQlVTWV9RKSkgIT0KKwkJVFdfQ0xf
 TlVMTCkgewogCQlpZiAocmVxLT5mbGFncyAmIFRXX0NMSV9SRVFfRkxBR1NfSU5URVJOQUwpIHsK
 IAkJCS8qCiAJCQkgKiBJdCdzIGFuIGludGVybmFsIHJlcXVlc3QuICBTZXQgdGhlIGFwcHJvcHJp
 YXRlCkBAIC0xNDksMTkgKzE1MiwyMSBAQAogCQkJcmVxLT5lcnJvcl9jb2RlID0gVFdfQ0xfRVJS
 X1JFUV9CVVNfUkVTRVQ7CiAJCQlpZiAocmVxLT50d19jbGlfY2FsbGJhY2spCiAJCQkJcmVxLT50
 d19jbGlfY2FsbGJhY2socmVxKTsKLQkJfSBlbHNlIHsKLQkJCWlmICgocmVxX3BrdCA9IHJlcS0+
 b3JpZ19yZXEpKSB7Ci0JCQkJLyogSXQncyBhIFNDU0kgcmVxdWVzdC4gIENvbXBsZXRlIGl0LiAq
 LwotCQkJCXR3X2NsaV9kYmdfcHJpbnRmKDIsIGN0bHItPmN0bHJfaGFuZGxlLAotCQkJCQl0d19v
 c2xfY3VyX2Z1bmMoKSwKLQkJCQkJIkNvbXBsZXRpbmcgYnVzeSByZXF1ZXN0ICVwIG9uIHJlc2V0
 IiwKLQkJCQkJcmVxKTsKKwkJfSBlbHNlIGlmIChyZXEtPmZsYWdzICYgVFdfQ0xJX1JFUV9GTEFH
 U19QQVNTVEhSVSkgeworCQkJLyogSXQncyBhIHBhc3N0aHJ1IHJlcXVlc3QuICBDb21wbGV0ZSBp
 dC4gKi8KKwkJCWlmICgocmVxX3BrdCA9IHJlcS0+b3JpZ19yZXEpICE9IFRXX0NMX05VTEwpIHsK
 IAkJCQlyZXFfcGt0LT5zdGF0dXMgPSBUV19DTF9FUlJfUkVRX0JVU19SRVNFVDsKLQkJCQlyZXFf
 cGt0LT50d19vc2xfY2FsbGJhY2socmVxLT5yZXFfaGFuZGxlKTsKKworCQkJCWlmIChyZXFfcGt0
 LT50d19vc2xfY2FsbGJhY2spCisJCQkJCXJlcV9wa3QtPnR3X29zbF9jYWxsYmFjayhyZXEtPnJl
 cV9oYW5kbGUpOwogCQkJfQogCQkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X0ZSRUVfUSk7CisJCX0gZWxzZSB7CisJCQkvKiBJdCdzIGFuIGV4dGVybmFsIChTQ1NJKSByZXF1
 ZXN0LiAgQWRkIGl0IHRvIHRoZSByZXNldCBxdWV1ZS4gKi8KKwkJCXR3X29zbF91bnRpbWVvdXQo
 cmVxLT5yZXFfaGFuZGxlKTsKKwkJCXR3X2NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX0NM
 SV9SRVNFVF9RKTsKIAkJfQotCX0KKwl9IC8qIEVuZCBvZiB3aGlsZSBsb29wICovCiB9CiAKIApA
 QCAtMTg4LDcgKzE5Myw4IEBACiAJLyoKIAkgKiBQdWxsIHJlcXVlc3RzIG9mZiB0aGUgcGVuZGlu
 ZyBxdWV1ZSwgYW5kIGNvbXBsZXRlIHRoZW0uCiAJICovCi0Jd2hpbGUgKChyZXEgPSB0d19jbGlf
 cmVxX3FfcmVtb3ZlX2hlYWQoY3RsciwgVFdfQ0xJX1BFTkRJTkdfUSkpKSB7CisJd2hpbGUgKChy
 ZXEgPSB0d19jbGlfcmVxX3FfcmVtb3ZlX2hlYWQoY3RsciwgVFdfQ0xJX1BFTkRJTkdfUSkpICE9
 CisJCVRXX0NMX05VTEwpIHsKIAkJaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdTX0lO
 VEVSTkFMKSB7CiAJCQkvKgogCQkJICogSXQncyBhbiBpbnRlcm5hbCByZXF1ZXN0LiAgU2V0IHRo
 ZSBhcHByb3ByaWF0ZQpAQCAtMjAyLDE5ICsyMDgsMjEgQEAKIAkJCXJlcS0+ZXJyb3JfY29kZSA9
 IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwogCQkJaWYgKHJlcS0+dHdfY2xpX2NhbGxiYWNrKQog
 CQkJCXJlcS0+dHdfY2xpX2NhbGxiYWNrKHJlcSk7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAoKHJlcV9w
 a3QgPSByZXEtPm9yaWdfcmVxKSkgewotCQkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgcmVxdWVzdC4g
 IENvbXBsZXRlIGl0LiAqLwotCQkJCXR3X2NsaV9kYmdfcHJpbnRmKDIsIGN0bHItPmN0bHJfaGFu
 ZGxlLAotCQkJCQl0d19vc2xfY3VyX2Z1bmMoKSwKLQkJCQkJIkNvbXBsZXRpbmcgcGVuZGluZyBy
 ZXF1ZXN0ICVwICIKLQkJCQkJIm9uIHJlc2V0IiwgcmVxKTsKKwkJfSBlbHNlIGlmIChyZXEtPmZs
 YWdzICYgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSkgeworCQkJLyogSXQncyBhIHBhc3N0aHJ1
 IHJlcXVlc3QuICBDb21wbGV0ZSBpdC4gKi8KKwkJCWlmICgocmVxX3BrdCA9IHJlcS0+b3JpZ19y
 ZXEpICE9IFRXX0NMX05VTEwpIHsKIAkJCQlyZXFfcGt0LT5zdGF0dXMgPSBUV19DTF9FUlJfUkVR
 X0JVU19SRVNFVDsKLQkJCQlyZXFfcGt0LT50d19vc2xfY2FsbGJhY2socmVxLT5yZXFfaGFuZGxl
 KTsKKworCQkJCWlmIChyZXFfcGt0LT50d19vc2xfY2FsbGJhY2spCisJCQkJCXJlcV9wa3QtPnR3
 X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOwogCQkJfQogCQkJdHdfY2xpX3JlcV9xX2lu
 c2VydF90YWlsKHJlcSwgVFdfQ0xJX0ZSRUVfUSk7CisJCX0gZWxzZSB7CisJCQkvKiBJdCdzIGFu
 IGV4dGVybmFsIChTQ1NJKSByZXF1ZXN0LiAgQWRkIGl0IHRvIHRoZSByZXNldCBxdWV1ZS4gKi8K
 KwkJCXR3X29zbF91bnRpbWVvdXQocmVxLT5yZXFfaGFuZGxlKTsKKwkJCXR3X2NsaV9yZXFfcV9p
 bnNlcnRfdGFpbChyZXEsIFRXX0NMSV9SRVNFVF9RKTsKIAkJfQotCX0KKwl9IC8qIEVuZCBvZiB3
 aGlsZSBsb29wICovCiB9CiAKIApAQCAtMjM5LDkgKzI0Nyw2IEBACiAJZm9yICg7OykgewogCQlz
 dGF0dXNfcmVnID0gVFdfQ0xJX1JFQURfU1RBVFVTX1JFR0lTVEVSKGN0bHItPmN0bHJfaGFuZGxl
 KTsKIAotCQlpZiAodHdfY2xpX2NoZWNrX2N0bHJfc3RhdGUoY3Rsciwgc3RhdHVzX3JlZykpCi0J
 CQlyZXR1cm4oVFdfT1NMX0VHRU5GQUlMVVJFKTsKLQogCQlpZiAoc3RhdHVzX3JlZyAmIFRXQV9T
 VEFUVVNfUkVTUE9OU0VfUVVFVUVfRU1QVFkpCiAJCQlyZXR1cm4oVFdfT1NMX0VTVUNDRVNTKTsg
 Lyogbm8gbW9yZSByZXNwb25zZSBxdWV1ZSBlbnRyaWVzICovCiAKQEAgLTI3Myw5ICsyNzgsNiBA
 QAogCWZvciAoOzspIHsKIAkJc3RhdHVzX3JlZyA9IFRXX0NMSV9SRUFEX1NUQVRVU19SRUdJU1RF
 UihjdGxyLT5jdGxyX2hhbmRsZSk7CiAKLQkJaWYgKHR3X2NsaV9jaGVja19jdGxyX3N0YXRlKGN0
 bHIsIHN0YXR1c19yZWcpKQotCQkJcmV0dXJuKFRXX09TTF9FR0VORkFJTFVSRSk7Ci0KIAkJaWYg
 KHN0YXR1c19yZWcgJiBUV0FfU1RBVFVTX1JFU1BPTlNFX1FVRVVFX0VNUFRZKQogCQkJcmV0dXJu
 KFRXX09TTF9FTk9UVFkpOyAvKiBubyBtb3JlIHJlc3BvbnNlIHF1ZXVlIGVudHJpZXMgKi8KIApA
 QCAtMzU2LDkgKzM1OCwxMSBAQAogCiAJCWlmICgoZXJyb3IgPSByZXEtPmNtZF9wa3QtPmNvbW1h
 bmQuY21kX3BrdF85ay5zdGF0dXMpKSB7CiAJCQljbWRfaGRyID0gJnJlcS0+Y21kX3BrdC0+Y21k
 X2hkcjsKKyNpZiAgICAgICAwCiAJCQl0d19jbGlfY3JlYXRlX2N0bHJfZXZlbnQoY3RsciwKIAkJ
 CQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT05UUk9MTEVSX0VSUk9SLAogCQkJCWNtZF9oZHIpOwor
 I2VuZGlmIC8vIDAKIAkJCWJyZWFrOwogCQl9CiAKQEAgLTcxNCw3ICs3MTgsNyBAQAogCiAJCXR3
 X29zbF9tZW16ZXJvKGRlc2MsIDIwMCk7CiAJCWlmICghKGN0bHItPnJlc2V0X3BoYXNlMV9pbl9w
 cm9ncmVzcykpIHsKLQkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJV
 RSwKKwkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJ
 VFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJCTB4MTMwMSwgMHgx
 LCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkJIk1pc3NpbmcgZXhwZWN0ZWQgc3Rh
 dHVzIGJpdChzKSIsCkBAIC03MzgsNyArNzQyLDcgQEAKIAkJICAgICAoY3Rsci0+ZGV2aWNlX2lk
 ICE9IFRXX0NMX0RFVklDRV9JRF85S19TQSkpIHx8CiAJCSAgICAoIShjdGxyLT5yZXNldF9pbl9w
 cm9ncmVzcykpIHx8CiAJCSAgICAoKHN0YXR1c19yZWcgJiBUV0FfU1RBVFVTX1FVRVVFX0VSUk9S
 X0lOVEVSUlVQVCkgPT0gMCkpCi0JCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdf
 Q0xfVFJVRSwKKwkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwK
 IAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCTB4MTMwMiwg
 MHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkiVW5leHBlY3RlZCBzdGF0dXMg
 Yml0KHMpIiwKQEAgLTc0OCw3ICs3NTIsNyBAQAogCQkJCVRXQV9TVEFUVVNfVU5FWFBFQ1RFRF9C
 SVRTLCBkZXNjKSk7CiAKIAkJaWYgKHN0YXR1c19yZWcgJiBUV0FfU1RBVFVTX1BDSV9QQVJJVFlf
 RVJST1JfSU5URVJSVVBUKSB7Ci0JCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRX
 X0NMX1RSVUUsCisJCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNF
 LAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCQkweDEz
 MDMsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAogCQkJCSJQQ0kgcGFyaXR5IGVy
 cm9yOiBjbGVhcmluZy4uLiAiCkBAIC03NjgsNyArNzcyLDcgQEAKIAkJfQogCiAJCWlmIChzdGF0
 dXNfcmVnICYgVFdBX1NUQVRVU19QQ0lfQUJPUlRfSU5URVJSVVBUKSB7Ci0JCQl0d19jbF9jcmVh
 dGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCisJCQl0d19jbF9jcmVhdGVfZXZlbnQo
 Y3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1P
 Tl9MQVlFUl9FVkVOVCwKIAkJCQkweDEzMDQsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RS
 SU5HLAogCQkJCSJQQ0kgYWJvcnQ6IGNsZWFyaW5nLi4uICIsCkBAIC03OTEsNyArNzk1LDcgQEAK
 IAkJCWlmICgoKGN0bHItPmRldmljZV9pZCAhPSBUV19DTF9ERVZJQ0VfSURfOUtfRSkgJiYKIAkJ
 CSAgICAgKGN0bHItPmRldmljZV9pZCAhPSBUV19DTF9ERVZJQ0VfSURfOUtfU0EpKSB8fAogCQkJ
 ICAgICghKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkpCi0JCQkJdHdfY2xfY3JlYXRlX2V2ZW50
 KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hh
 bmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJCQkgICBUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05f
 TEFZRVJfRVZFTlQsCiAJCQkJCQkgICAweDEzMDUsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1Jf
 U1RSSU5HLAogCQkJCQkJICAgIkNvbnRyb2xsZXIgcXVldWUgZXJyb3I6IGNsZWFyaW5nLi4uICIs
 CkBAIC04MDEsMTcgKzgwNSw2IEBACiAJCQlUV19DTElfV1JJVEVfQ09OVFJPTF9SRUdJU1RFUihj
 dGxyLT5jdGxyX2hhbmRsZSwKIAkJCQlUV0FfQ09OVFJPTF9DTEVBUl9RVUVVRV9FUlJPUik7CiAJ
 CX0KLQotCQlpZiAoc3RhdHVzX3JlZyAmIFRXQV9TVEFUVVNfTUlDUk9DT05UUk9MTEVSX0VSUk9S
 KSB7Ci0JCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCi0JCQkJ
 VFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAotCQkJCTB4MTMwNywgMHgx
 LCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCi0JCQkJIk1pY3JvLWNvbnRyb2xsZXIgZXJy
 b3IhICIsCi0JCQkJInN0YXR1cyByZWcgPSAweCV4ICVzIiwKLQkJCQlzdGF0dXNfcmVnLAotCQkJ
 CXR3X2NsaV9kZXNjcmliZV9iaXRzKHN0YXR1c19yZWcsIGRlc2MpKTsKLQkJCWVycm9yID0gVFdf
 T1NMX0VHRU5GQUlMVVJFOwotCQl9CiAJfQogCXJldHVybihlcnJvcik7CiB9CQpAQCAtODUwLDgg
 Kzg0Myw2IEBACiAJCXR3X29zbF9zdHJjcHkoJnN0clt0d19vc2xfc3RybGVuKHN0cildLCAiSE9T
 VF9JTlRSLCIpOwogCWlmIChyZWcgJiBUV0FfU1RBVFVTX1BDSV9BQk9SVF9JTlRFUlJVUFQpCiAJ
 CXR3X29zbF9zdHJjcHkoJnN0clt0d19vc2xfc3RybGVuKHN0cildLCAiUENJX0FCUlQsIik7Ci0J
 aWYgKHJlZyAmIFRXQV9TVEFUVVNfTUlDUk9DT05UUk9MTEVSX0VSUk9SKQotCQl0d19vc2xfc3Ry
 Y3B5KCZzdHJbdHdfb3NsX3N0cmxlbihzdHIpXSwgIk1DX0VSUiwiKTsKIAlpZiAocmVnICYgVFdB
 X1NUQVRVU19RVUVVRV9FUlJPUl9JTlRFUlJVUFQpCiAJCXR3X29zbF9zdHJjcHkoJnN0clt0d19v
 c2xfc3RybGVuKHN0cildLCAiUV9FUlIsIik7CiAJaWYgKHJlZyAmIFRXQV9TVEFUVVNfUENJX1BB
 UklUWV9FUlJPUl9JTlRFUlJVUFQpCmRpZmYgLXUgRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfY2xf
 c2hhcmUuaCBGcmVlQlNEX0hFQURfdHdhXzNfODBfMDZfMDAzL3R3X2NsX3NoYXJlLmgKLS0tIEZy
 ZWVCU0RfSEVBRF90d2FfY3ZzL3R3X2NsX3NoYXJlLmgJMjAxMC0wOC0yNiAxNTozNDozMy4wMDAw
 MDAwMDAgLTA3MDAKKysrIEZyZWVCU0RfSEVBRF90d2FfM184MF8wNl8wMDMvdHdfY2xfc2hhcmUu
 aAkyMDEwLTA4LTI0IDE4OjAyOjEyLjAwMDAwMDAwMCAtMDcwMApAQCAtMzQ5LDEwICszNDksMTQg
 QEAKICNlbmRpZgogCiAKLSNpZm5kZWYgdHdfb3NsX2N0bHJfYnVzeQotLyogQ2FsbGVkIHdoZW4g
 Q0wgaXMgdG9vIGJ1c3kgdG8gYWNjZXB0IG5ldyByZXF1ZXN0cy4gKi8KLWV4dGVybiBUV19WT0lE
 CXR3X29zbF9jdGxyX2J1c3koc3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSwK
 LQlzdHJ1Y3QgdHdfY2xfcmVxX2hhbmRsZSAqcmVxX2hhbmRsZSk7CisjaWZuZGVmIHR3X29zbF90
 aW1lb3V0CisvKiBTdGFydCBPUyB0aW1lb3V0KCkgcm91dGluZSBhZnRlciBjb250cm9sbGVyIHJl
 c2V0IHNlcXVlbmNlICovCitleHRlcm4gVFdfVk9JRAl0d19vc2xfdGltZW91dChzdHJ1Y3QgdHdf
 Y2xfcmVxX2hhbmRsZSAqcmVxX2hhbmRsZSk7CisjZW5kaWYKKworI2lmbmRlZiB0d19vc2xfdW50
 aW1lb3V0CisvKiBTdG9wIE9TIHRpbWVvdXQoKSByb3V0aW5lIGR1cmluZyBjb250cm9sbGVyIHJl
 c2V0IHNlcXVlbmNlICovCitleHRlcm4gVFdfVk9JRAl0d19vc2xfdW50aW1lb3V0KHN0cnVjdCB0
 d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKTsKICNlbmRpZgogCiAKQEAgLTU1Miw2ICs1NTYs
 MTAgQEAKIAkpOwogCiAKK2V4dGVybiBUV19WT0lEICB0d19jbF9zZXRfcmVzZXRfbmVlZGVkKHN0
 cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUpOworZXh0ZXJuIFRXX0lOVDMyIHR3
 X2NsX2lzX3Jlc2V0X25lZWRlZChzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxl
 KTsKK2V4dGVybiBUV19JTlQzMiB0d19jbF9pc19hY3RpdmUoc3RydWN0IHR3X2NsX2N0bHJfaGFu
 ZGxlICpjdGxyX2hhbmRsZSk7CisKIC8qIENMJ3MgaW50ZXJydXB0IGhhbmRsZXIuICovCiBleHRl
 cm4gVFdfSU5UMzIJdHdfY2xfaW50ZXJydXB0KHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rs
 cl9oYW5kbGUpOwogCmRpZmYgLXUgRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfb3NsLmggRnJlZUJT
 RF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19vc2wuaAotLS0gRnJlZUJTRF9IRUFEX3R3YV9jdnMv
 dHdfb3NsLmgJMjAxMC0wOC0yNiAxNTozNDozMy4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Rf
 SEVBRF90d2FfM184MF8wNl8wMDMvdHdfb3NsLmgJMjAxMC0wOC0yNCAxODowMjoxMi4wMDAwMDAw
 MDAgLTA3MDAKQEAgLTc3LDYgKzc3LDcgQEAKIAkJCQkJCUVJTlBST0dSRVNTICovCiAjZGVmaW5l
 IFRXX09TTElfUkVRX0ZMQUdTX1BBU1NUSFJVCSgxPDw1KQkvKiBwYXNzIHRocm91Z2ggcmVxdWVz
 dCAqLwogI2RlZmluZSBUV19PU0xJX1JFUV9GTEFHU19TTEVFUElORwkoMTw8NikJLyogb3duZXIg
 c2xlZXBpbmcgb24gdGhpcyBjbWQgKi8KKyNkZWZpbmUgVFdfT1NMSV9SRVFfRkxBR1NfRkFJTEVE
 CSgxPDw3KQkvKiBidXNfZG1hbWFwX2xvYWQoKSBmYWlsZWQgKi8KIAogCiAjaWZkZWYgVFdfT1NM
 X0RFQlVHCkBAIC0xMDAsNiArMTAxLDcgQEAKIAlzdHJ1Y3QgdHdhX3NvZnRjCSpjdGxyOwkvKiBw
 dHIgdG8gT1NMJ3MgY29udHJvbGxlciBjb250ZXh0ICovCiAJVFdfVk9JRAkJCSpkYXRhOwkvKiBw
 dHIgdG8gZGF0YSBiZWluZyBwYXNzZWQgdG8gQ0wgKi8KIAlUV19VSU5UMzIJCWxlbmd0aDsJLyog
 bGVuZ3RoIG9mIGJ1ZiBiZWluZyBwYXNzZWQgdG8gQ0wgKi8KKwlUV19VSU5UNjQJCWRlYWRsaW5l
 Oy8qIHJlcXVlc3QgdGltZW91dCAoaW4gYWJzb2x1dGUgdGltZSkgKi8KIAogCS8qCiAJICogcHRy
 IHRvLCBhbmQgbGVuZ3RoIG9mIGRhdGEgcGFzc2VkIHRvIHVzIGZyb20gYWJvdmUsIGluIGNhc2Ug
 YSBidWZmZXIKQEAgLTE1MSw2ICsxNTMsOSBAQAogCXN0cnVjdCBtdHgJCXNpbV9sb2NrX2hhbmRs
 ZTsvKiBzaW0gbG9jayBzaGFyZWQgd2l0aCBjYW0gKi8KIAlzdHJ1Y3QgbXR4CQkqc2ltX2xvY2s7
 LyogcHRyIHRvIHNpbSBsb2NrICovCiAKKwlzdHJ1Y3QgY2FsbG91dAkJd2F0Y2hkb2dfY2FsbG91
 dFsyXTsgLyogRm9yIGNvbW1hbmQgdGltb3V0ICovCisJVFdfVUlOVDMyCQl3YXRjaGRvZ19pbmRl
 eDsKKwogI2lmZGVmIFRXX09TTF9ERUJVRwogCXN0cnVjdCB0d19vc2xpX3Ffc3RhdHMJcV9zdGF0
 c1tUV19PU0xJX1FfQ09VTlRdOy8qIHF1ZXVlIHN0YXRpc3RpY3MgKi8KICNlbmRpZiAvKiBUV19P
 U0xfREVCVUcgKi8KZGlmZiAtdSBGcmVlQlNEX0hFQURfdHdhX2N2cy90d19vc2xfY2FtLmMgRnJl
 ZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19vc2xfY2FtLmMKLS0tIEZyZWVCU0RfSEVBRF90
 d2FfY3ZzL3R3X29zbF9jYW0uYwkyMDEwLTA4LTI2IDE1OjM0OjMzLjAwMDAwMDAwMCAtMDcwMAor
 KysgRnJlZUJTRF9IRUFEX3R3YV8zXzgwXzA2XzAwMy90d19vc2xfY2FtLmMJMjAxMC0wOC0yNCAx
 ODowMjoxMi4wMDAwMDAwMDAgLTA3MDAKQEAgLTU1LDcgKzU1LDYgQEAKIAogc3RhdGljIFRXX1ZP
 SUQJdHdhX2FjdGlvbihzdHJ1Y3QgY2FtX3NpbSAqc2ltLCB1bmlvbiBjY2IgKmNjYik7CiBzdGF0
 aWMgVFdfVk9JRAl0d2FfcG9sbChzdHJ1Y3QgY2FtX3NpbSAqc2ltKTsKLXN0YXRpYyBUV19WT0lE
 CXR3YV90aW1lb3V0KFRXX1ZPSUQgKmFyZyk7CiAKIHN0YXRpYyBUV19JTlQzMgl0d19vc2xpX2V4
 ZWN1dGVfc2NzaShzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dCAqcmVxLAogCXVuaW9uIGNjYiAq
 Y2NiKTsKQEAgLTgxLDcgKzgwLDcgQEAKIAkvKgogCSAqIENyZWF0ZSB0aGUgZGV2aWNlIHF1ZXVl
 IGZvciBvdXIgU0lNLgogCSAqLwotCWlmICgoZGV2cSA9IGNhbV9zaW1xX2FsbG9jKFRXX09TTElf
 TUFYX05VTV9SRVFVRVNUUykpID09IE5VTEwpIHsKKwlpZiAoKGRldnEgPSBjYW1fc2ltcV9hbGxv
 YyhUV19PU0xJX01BWF9OVU1fSU9TKSkgPT0gTlVMTCkgewogCQl0d19vc2xpX3ByaW50ZihzYywg
 ImVycm9yID0gJWQiLAogCQkJVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAogCQkJVFdfQ0xf
 TUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCkBAIC0yNzUsNiArMjc0LDcgQEAKIAkJCQkJ
 IkkvTyBzaXplIHRvbyBiaWciLAogCQkJCQljc2lvLT5keGZlcl9sZW4pOwogCQkJCWNjYl9oLT5z
 dGF0dXMgPSBDQU1fUkVRX1RPT19CSUc7CisJCQkJY2NiX2gtPnN0YXR1cyAmPSB+Q0FNX1NJTV9R
 VUVVRUQ7CiAJCQkJeHB0X2RvbmUoY2NiKTsKIAkJCQlyZXR1cm4oMSk7CiAJCQl9CkBAIC0yOTAs
 NiArMjkwLDcgQEAKIAkJCQkweDIxMDcsCiAJCQkJIlhQVF9TQ1NJX0lPOiBHb3QgU0dMaXN0Iik7
 CiAJCQljY2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9JTlZBTElEOworCQkJY2NiX2gtPnN0YXR1cyAm
 PSB+Q0FNX1NJTV9RVUVVRUQ7CiAJCQl4cHRfZG9uZShjY2IpOwogCQkJcmV0dXJuKDEpOwogCQl9
 CkBAIC0zMDYsMTMgKzMwNywyMCBAQAogCQlyZXR1cm4oMSk7CiAJfQogCi0JY2NiX2gtPnRpbWVv
 dXRfY2ggPSB0aW1lb3V0KHR3YV90aW1lb3V0LCByZXEsCi0JCShjY2JfaC0+dGltZW91dCAqIGh6
 KSAvIDEwMDApOworCXJlcS0+ZGVhZGxpbmUgPSB0d19vc2xfZ2V0X2xvY2FsX3RpbWUoKSArIChj
 Y2JfaC0+dGltZW91dCAvIDEwMDApOworCisKIAkvKgogCSAqIHR3YV9tYXBfbG9hZF9kYXRhX2Nh
 bGxiYWNrIHdpbGwgZmlsbCBpbiB0aGUgU0dMLAogCSAqIGFuZCBzdWJtaXQgdGhlIEkvTy4KIAkg
 Ki8KIAllcnJvciA9IHR3X29zbGlfbWFwX3JlcXVlc3QocmVxKTsKKwlpZiAoKGVycm9yKSAmJiAo
 cmVxLT5mbGFncyAmIFRXX09TTElfUkVRX0ZMQUdTX0ZBSUxFRCkpIHsKKwkJcmVxLT5kZWFkbGlu
 ZSA9IDA7CisJCWNjYl9oLT5zdGF0dXMgPSBDQU1fUkVRX0NNUF9FUlI7CisJCWNjYl9oLT5zdGF0
 dXMgJj0gfkNBTV9TSU1fUVVFVUVEOworCQl4cHRfZG9uZShjY2IpOworCX0KIAlyZXR1cm4oZXJy
 b3IpOwogfQogCkBAIC0zNDUsMTAgKzM1MywyMCBAQAogCQkJICogRnJlZXplIHRoZSBzaW1xIHRv
 IG1haW50YWluIGNjYiBvcmRlcmluZy4gIFRoZSBuZXh0CiAJCQkgKiBjY2IgdGhhdCBnZXRzIGNv
 bXBsZXRlZCB3aWxsIHVuZnJlZXplIHRoZSBzaW1xLgogCQkJICovCisJCQljY2JfaC0+c3RhdHVz
 ICY9IH5DQU1fU0lNX1FVRVVFRDsKKwkJCWNjYl9oLT5zdGF0dXMgfD0gQ0FNX1JFUVVFVUVfUkVR
 OworCQkJeHB0X2RvbmUoY2NiKTsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKCh0d19jbF9pc19y
 ZXNldF9uZWVkZWQoJihyZXEtPmN0bHItPmN0bHJfaGFuZGxlKSkpKSB7CisJCQljY2JfaC0+c3Rh
 dHVzICY9IH5DQU1fU0lNX1FVRVVFRDsKIAkJCWNjYl9oLT5zdGF0dXMgfD0gQ0FNX1JFUVVFVUVf
 UkVROwogCQkJeHB0X2RvbmUoY2NiKTsKKwkJCXR3X29zbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVx
 LCBUV19PU0xJX0ZSRUVfUSk7CiAJCQlicmVhazsKIAkJfQorCiAJCXJlcS0+cmVxX2hhbmRsZS5v
 c2xfcmVxX2N0eHQgPSByZXE7CiAJCXJlcS0+cmVxX2hhbmRsZS5pc19pbyA9IFRXX0NMX1RSVUU7
 CiAJCXJlcS0+b3JpZ19yZXEgPSBjY2I7CkBAIC0zNjQsMjUgKzM4MiwxNCBAQAogCQlicmVhazsK
 IAogCWNhc2UgWFBUX1JFU0VUX0JVUzoKLQkJdHdfY2xfY3JlYXRlX2V2ZW50KCYoc2MtPmN0bHJf
 aGFuZGxlKSwgVFdfQ0xfVFJVRSwKKwkJdHdfY2xfY3JlYXRlX2V2ZW50KCYoc2MtPmN0bHJfaGFu
 ZGxlKSwgVFdfQ0xfRkFMU0UsCiAJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZF
 UiwKIAkJCTB4MjEwOCwgMHgzLCBUV19DTF9TRVZFUklUWV9JTkZPX1NUUklORywKIAkJCSJSZWNl
 aXZlZCBSZXNldCBCdXMgcmVxdWVzdCBmcm9tIENBTSIsCiAJCQkiICIpOwogCi0JCW10eF91bmxv
 Y2soc2MtPnNpbV9sb2NrKTsKLQkJaWYgKHR3X2NsX3Jlc2V0X2N0bHIoJnNjLT5jdGxyX2hhbmRs
 ZSkpIHsKLQkJCXR3X2NsX2NyZWF0ZV9ldmVudCgmKHNjLT5jdGxyX2hhbmRsZSksIFRXX0NMX1RS
 VUUsCi0JCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCi0JCQkJMHgyMTA5
 LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCQkiRmFpbGVkIHRvIHJlc2V0
 IGJ1cyIsCi0JCQkJIiAiKTsKLQkJCWNjYl9oLT5zdGF0dXMgPSBDQU1fUkVRX0NNUF9FUlI7Ci0J
 CX0KLQkJZWxzZQotCQkJY2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QOwotCi0JCW10eF9sb2Nr
 KHNjLT5zaW1fbG9jayk7CisJCXR3X2NsX3NldF9yZXNldF9uZWVkZWQoJihzYy0+Y3Rscl9oYW5k
 bGUpKTsKKwkJY2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QOwogCQl4cHRfZG9uZShjY2IpOwog
 CQlicmVhazsKIApAQCAtNDUwLDYgKzQ1Nyw3IEBACiAgICAgICAgICAgICAgICAgcGF0aF9pbnEt
 PnRyYW5zcG9ydF92ZXJzaW9uID0gMjsKICAgICAgICAgICAgICAgICBwYXRoX2lucS0+cHJvdG9j
 b2wgPSBQUk9UT19TQ1NJOwogICAgICAgICAgICAgICAgIHBhdGhfaW5xLT5wcm90b2NvbF92ZXJz
 aW9uID0gU0NTSV9SRVZfMjsKKyAgICAgICAgICAgICAgICBwYXRoX2lucS0+bWF4aW8gPSBUV19D
 TF9NQVhfSU9fU0laRTsKIAkJY2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QOwogCQl4cHRfZG9u
 ZShjY2IpOwogCQlicmVhazsKQEAgLTQ4NywzMSArNDk1LDYgQEAKIAogCiAvKgotICogRnVuY3Rp
 b24gbmFtZToJdHdhX3RpbWVvdXQKLSAqIERlc2NyaXB0aW9uOgkJRHJpdmVyIGVudHJ5IHBvaW50
 IGZvciBiZWluZyBhbGVydGVkIG9uIGEgcmVxdWVzdAotICoJCQl0aW1pbmcgb3V0LgotICoKLSAq
 IElucHV0OgkJYXJnCS0tIHB0ciB0byB0aW1lZCBvdXQgcmVxdWVzdAotICogT3V0cHV0OgkJTm9u
 ZQotICogUmV0dXJuIHZhbHVlOglOb25lCi0gKi8KLXN0YXRpYyBUV19WT0lECi10d2FfdGltZW91
 dChUV19WT0lEICphcmcpCi17Ci0Jc3RydWN0IHR3X29zbGlfcmVxX2NvbnRleHQJKnJlcSA9Ci0J
 CShzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dCAqKWFyZzsKLQotCXR3X2NsX2NyZWF0ZV9ldmVu
 dCgmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpLCBUV19DTF9UUlVFLAotCQlUV19DTF9NRVNTQUdF
 X1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKLQkJMHgyMTBCLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VS
 Uk9SX1NUUklORywKLQkJIlJlcXVlc3QgdGltZWQgb3V0ISIsCi0JCSJyZXF1ZXN0ID0gJXAiLCBy
 ZXEpOwotCXR3X2NsX3Jlc2V0X2N0bHIoJihyZXEtPmN0bHItPmN0bHJfaGFuZGxlKSk7Ci19Ci0K
 LQotCi0vKgogICogRnVuY3Rpb24gbmFtZToJdHdfb3NsaV9yZXF1ZXN0X2J1c19zY2FuCiAgKiBE
 ZXNjcmlwdGlvbjoJCVJlcXVlc3RzIENBTSBmb3IgYSBzY2FuIG9mIHRoZSBidXMuCiAgKgpAQCAt
 NTc0LDIwICs1NTcsMzkgQEAKIAogCiAvKgotICogRnVuY3Rpb24gbmFtZToJdHdfb3NsX2N0bHJf
 YnVzeQotICogRGVzY3JpcHRpb246CQlDTCBjYWxscyB0aGlzIGZ1bmN0aW9uIG9uIGNtZCBxdWV1
 ZSBmdWxsIG9yIG90aGVyd2lzZSwKLSAqCQkJd2hlbiBpdCBpcyB0b28gYnVzeSB0byBhY2NlcHQg
 bmV3IHJlcXVlc3RzLgorICogRnVuY3Rpb24gbmFtZToJdHdfb3NsX3RpbWVvdXQKKyAqIERlc2Ny
 aXB0aW9uOgkJQ2FsbCB0byB0aW1lb3V0KCkuCiAgKgotICogSW5wdXQ6CQljdGxyX2hhbmRsZQkt
 LSBwdHIgdG8gY29udHJvbGxlciBoYW5kbGUKLSAqCQkJcmVxX2hhbmRsZQktLSBwdHIgdG8gcmVx
 dWVzdCBoYW5kbGUgc2VudCBieSBPU0wuCisgKiBJbnB1dDoJCXJlcV9oYW5kbGUgLS0gcHRyIHRv
 IHJlcXVlc3QgaGFuZGxlIHNlbnQgYnkgT1NMLgogICogT3V0cHV0OgkJTm9uZQogICogUmV0dXJu
 IHZhbHVlOglOb25lCiAgKi8KIFRXX1ZPSUQKLXR3X29zbF9jdGxyX2J1c3koc3RydWN0IHR3X2Ns
 X2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSwKLQlzdHJ1Y3QgdHdfY2xfcmVxX2hhbmRsZSAqcmVx
 X2hhbmRsZSkKK3R3X29zbF90aW1lb3V0KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFu
 ZGxlKQoreworCXN0cnVjdCB0d19vc2xpX3JlcV9jb250ZXh0CSpyZXEgPSByZXFfaGFuZGxlLT5v
 c2xfcmVxX2N0eHQ7CisJdW5pb24gY2NiCQkJKmNjYiA9ICh1bmlvbiBjY2IgKikocmVxLT5vcmln
 X3JlcSk7CisJc3RydWN0IGNjYl9oZHIJCQkqY2NiX2ggPSAmKGNjYi0+Y2NiX2gpOworCisJcmVx
 LT5kZWFkbGluZSA9IHR3X29zbF9nZXRfbG9jYWxfdGltZSgpICsgKGNjYl9oLT50aW1lb3V0IC8g
 MTAwMCk7Cit9CisKKworCisvKgorICogRnVuY3Rpb24gbmFtZToJdHdfb3NsX3VudGltZW91dAor
 ICogRGVzY3JpcHRpb246CQlJbnZlcnNlIG9mIGNhbGwgdG8gdGltZW91dCgpLgorICoKKyAqIElu
 cHV0OgkJcmVxX2hhbmRsZSAtLSBwdHIgdG8gcmVxdWVzdCBoYW5kbGUgc2VudCBieSBPU0wuCisg
 KiBPdXRwdXQ6CQlOb25lCisgKiBSZXR1cm4gdmFsdWU6CU5vbmUKKyAqLworVFdfVk9JRAordHdf
 b3NsX3VudGltZW91dChzdHJ1Y3QgdHdfY2xfcmVxX2hhbmRsZSAqcmVxX2hhbmRsZSkKIHsKLQl0
 d19vc2xpX2Rpc2FsbG93X25ld19yZXF1ZXN0cyhjdGxyX2hhbmRsZS0+b3NsX2N0bHJfY3R4dCwg
 cmVxX2hhbmRsZSk7CisJc3RydWN0IHR3X29zbGlfcmVxX2NvbnRleHQJKnJlcSA9IHJlcV9oYW5k
 bGUtPm9zbF9yZXFfY3R4dDsKKworCXJlcS0+ZGVhZGxpbmUgPSAwOwogfQogCiAKQEAgLTY1NSw3
 ICs2NTcsNyBAQAogCiAJdHdfb3NsaV91bm1hcF9yZXF1ZXN0KHJlcSk7CiAKLQl1bnRpbWVvdXQo
 dHdhX3RpbWVvdXQsIHJlcSwgY2NiLT5jY2JfaC50aW1lb3V0X2NoKTsKKwlyZXEtPmRlYWRsaW5l
 ID0gMDsKIAlpZiAocmVxLT5lcnJvcl9jb2RlKSB7CiAJCS8qIFRoaXMgcmVxdWVzdCBuZXZlciBn
 b3Qgc3VibWl0dGVkIHRvIHRoZSBmaXJtd2FyZS4gKi8KIAkJaWYgKHJlcS0+ZXJyb3JfY29kZSA9
 PSBFQlVTWSkgewpAQCAtNjgyLDcgKzY4NCw3IEBACiAJCQllbHNlIGlmIChyZXFfcGt0LT5zdGF0
 dXMgJiBUV19DTF9FUlJfUkVRX1NDU0lfRVJST1IpCiAJCQkJY2NiLT5jY2JfaC5zdGF0dXMgfD0g
 Q0FNX1NDU0lfU1RBVFVTX0VSUk9SOwogCQkJZWxzZSBpZiAocmVxX3BrdC0+c3RhdHVzICYgVFdf
 Q0xfRVJSX1JFUV9CVVNfUkVTRVQpCi0JCQkJY2NiLT5jY2JfaC5zdGF0dXMgfD0gQ0FNX1NDU0lf
 QlVTX1JFU0VUOworCQkJCWNjYi0+Y2NiX2guc3RhdHVzIHw9IChDQU1fUkVRVUVVRV9SRVEgfCBD
 QU1fU0NTSV9CVVNfUkVTRVQpOwogCQkJLyoKIAkJCSAqIElmIG5vbmUgb2YgdGhlIGFib3ZlIGVy
 cm9ycyBvY2N1cnJlZCwgc2ltcGx5CiAJCQkgKiBtYXJrIGNvbXBsZXRpb24gZXJyb3IuCmRpZmYg
 LXUgRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfb3NsX2ZyZWVic2QuYyBGcmVlQlNEX0hFQURfdHdh
 XzNfODBfMDZfMDAzL3R3X29zbF9mcmVlYnNkLmMKLS0tIEZyZWVCU0RfSEVBRF90d2FfY3ZzL3R3
 X29zbF9mcmVlYnNkLmMJMjAxMC0wOC0yNiAxNTozNDozMy4wMDAwMDAwMDAgLTA3MDAKKysrIEZy
 ZWVCU0RfSEVBRF90d2FfM184MF8wNl8wMDMvdHdfb3NsX2ZyZWVic2QuYwkyMDEwLTA4LTI2IDE1
 OjE0OjIyLjAwMDAwMDAwMCAtMDcwMApAQCAtMTc1LDYgKzE3NSw5IEBACiBzdGF0aWMgVFdfSU5U
 MzIJdHdhX3NodXRkb3duKGRldmljZV90IGRldik7CiBzdGF0aWMgVFdfVk9JRAl0d2FfYnVzZG1h
 X2xvY2soVFdfVk9JRCAqbG9ja19hcmcsIGJ1c19kbWFfbG9ja19vcF90IG9wKTsKIHN0YXRpYyBU
 V19WT0lECXR3YV9wY2lfaW50cihUV19WT0lEICphcmcpOworc3RhdGljIFRXX1ZPSUQJdHdhX3dh
 dGNoZG9nKFRXX1ZPSUQgKmFyZyk7CitpbnQgdHdhX3NldHVwX2ludHIoc3RydWN0IHR3YV9zb2Z0
 YyAqc2MpOworaW50IHR3YV90ZWFyZG93bl9pbnRyKHN0cnVjdCB0d2Ffc29mdGMgKnNjKTsKIAog
 c3RhdGljIFRXX0lOVDMyCXR3X29zbGlfYWxsb2NfbWVtKHN0cnVjdCB0d2Ffc29mdGMgKnNjKTsK
 IHN0YXRpYyBUV19WT0lECXR3X29zbGlfZnJlZV9yZXNvdXJjZXMoc3RydWN0IHR3YV9zb2Z0YyAq
 c2MpOwpAQCAtMjM4LDYgKzI0MSwzMiBAQAogCXJldHVybihFTlhJTyk7CiB9CiAKK2ludCB0d2Ff
 c2V0dXBfaW50cihzdHJ1Y3QgdHdhX3NvZnRjICpzYykKK3sKKwlpbnQgZXJyb3IgPSAwOworCisJ
 aWYgKCEoc2MtPmludHJfaGFuZGxlKSAmJiAoc2MtPmlycV9yZXMpKSB7CisJCWVycm9yID0gYnVz
 X3NldHVwX2ludHIoc2MtPmJ1c19kZXYsIHNjLT5pcnFfcmVzLAorCQkJCQlJTlRSX1RZUEVfQ0FN
 IHwgSU5UUl9NUFNBRkUsCisJCQkJCU5VTEwsIHR3YV9wY2lfaW50ciwKKwkJCQkJc2MsICZzYy0+
 aW50cl9oYW5kbGUpOworCX0KKwlyZXR1cm4oIGVycm9yICk7Cit9CisKKworaW50IHR3YV90ZWFy
 ZG93bl9pbnRyKHN0cnVjdCB0d2Ffc29mdGMgKnNjKQoreworCWludCBlcnJvciA9IDA7CisKKwlp
 ZiAoKHNjLT5pbnRyX2hhbmRsZSkgJiYgKHNjLT5pcnFfcmVzKSkgeworCQllcnJvciA9IGJ1c190
 ZWFyZG93bl9pbnRyKHNjLT5idXNfZGV2LAorCQkJCQkJc2MtPmlycV9yZXMsIHNjLT5pbnRyX2hh
 bmRsZSk7CisJCXNjLT5pbnRyX2hhbmRsZSA9IE5VTEw7CisJfQorCXJldHVybiggZXJyb3IgKTsK
 K30KKwogCiAKIC8qCkBAIC0zNTQsMTAgKzM4Myw3IEBACiAJCXR3X29zbGlfZnJlZV9yZXNvdXJj
 ZXMoc2MpOwogCQlyZXR1cm4oRU5YSU8pOwogCX0KLQlpZiAoKGVycm9yID0gYnVzX3NldHVwX2lu
 dHIoc2MtPmJ1c19kZXYsIHNjLT5pcnFfcmVzLAotCQkJSU5UUl9UWVBFX0NBTSB8IElOVFJfTVBT
 QUZFLAotCQkJTlVMTCwgdHdhX3BjaV9pbnRyLAkgICAgCi0JCQlzYywgJnNjLT5pbnRyX2hhbmRs
 ZSkpKSB7CisJaWYgKChlcnJvciA9IHR3YV9zZXR1cF9pbnRyKHNjKSkpIHsKIAkJdHdfb3NsaV9w
 cmludGYoc2MsICJlcnJvciA9ICVkIiwKIAkJCVRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywK
 IAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0RfRFJJVkVSLApAQCAtNDEyLDEwICs0Mzgs
 NzcgQEAKIAkJcmV0dXJuKGVycm9yKTsKIAl9CiAKKwlzYy0+d2F0Y2hkb2dfaW5kZXggPSAwOwor
 CWNhbGxvdXRfaW5pdCgmKHNjLT53YXRjaGRvZ19jYWxsb3V0WzBdKSwgQ0FMTE9VVF9NUFNBRkUp
 OworCWNhbGxvdXRfaW5pdCgmKHNjLT53YXRjaGRvZ19jYWxsb3V0WzFdKSwgQ0FMTE9VVF9NUFNB
 RkUpOworCWNhbGxvdXRfcmVzZXQoJihzYy0+d2F0Y2hkb2dfY2FsbG91dFswXSksIDUqaHosIHR3
 YV93YXRjaGRvZywgJnNjLT5jdGxyX2hhbmRsZSk7CisKIAlyZXR1cm4oMCk7CiB9CiAKIAorc3Rh
 dGljIFRXX1ZPSUQKK3R3YV93YXRjaGRvZyhUV19WT0lEICphcmcpCit7CisJc3RydWN0IHR3X2Ns
 X2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSA9CisJCShzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5kbGUg
 Kilhcmc7CisJc3RydWN0IHR3YV9zb2Z0YwkJKnNjID0gY3Rscl9oYW5kbGUtPm9zbF9jdGxyX2N0
 eHQ7CisJaW50CQkJCWk7CisJaW50CQkJCWlfbmVlZF9hX3Jlc2V0ID0gMDsKKwlpbnQJCQkJZHJp
 dmVyX2lzX2FjdGl2ZSA9IDA7CisJaW50CQkJCW15X3dhdGNoZG9nX3dhc19wZW5kaW5nID0gMTIz
 NDsKKwlUV19VSU5UNjQJCQljdXJyZW50X3RpbWU7CisJc3RydWN0IHR3X29zbGlfcmVxX2NvbnRl
 eHQJKm15X3JlcTsKKworCisvLz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCWN1cnJlbnRfdGltZSA9
 IChUV19VSU5UNjQpICh0d19vc2xfZ2V0X2xvY2FsX3RpbWUoKSk7CisKKwlmb3IgKGkgPSAwOyBp
 IDwgVFdfT1NMSV9NQVhfTlVNX1JFUVVFU1RTOyBpKyspIHsKKwkJbXlfcmVxID0gJihzYy0+cmVx
 X2N0eF9idWZbaV0pOworCisJCWlmICgobXlfcmVxLT5zdGF0ZSA9PSBUV19PU0xJX1JFUV9TVEFU
 RV9CVVNZKSAmJgorCQkJKG15X3JlcS0+ZGVhZGxpbmUpICYmCisJCQkobXlfcmVxLT5kZWFkbGlu
 ZSA8IGN1cnJlbnRfdGltZSkpIHsKKwkJCXR3X2NsX3NldF9yZXNldF9uZWVkZWQoY3Rscl9oYW5k
 bGUpOworI2lmZGVmICAgIFRXX09TTF9ERUJVRworCQkJZGV2aWNlX3ByaW50Zigoc2MpLT5idXNf
 ZGV2LCAiUmVxdWVzdCAlZCB0aW1lZCBvdXQhIGQgPSAlcCwgYyA9ICVwXG4iLCBpLCAodm9pZCop
 bXlfcmVxLT5kZWFkbGluZSwgKHZvaWQqKWN1cnJlbnRfdGltZSk7CisjZWxzZSAgLyogVFdfT1NM
 X0RFQlVHICovCisJCQlkZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJSZXF1ZXN0ICVkIHRp
 bWVkIG91dCFcbiIsIGkpOworI2VuZGlmIC8qIFRXX09TTF9ERUJVRyAqLworCQkJYnJlYWs7CisJ
 CX0KKwl9CisvLz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCisJaV9uZWVkX2FfcmVzZXQgPSB0d19j
 bF9pc19yZXNldF9uZWVkZWQoY3Rscl9oYW5kbGUpOworCisJaSA9IChpbnQpICgoc2MtPndhdGNo
 ZG9nX2luZGV4KyspICYgMSk7CisKKwlkcml2ZXJfaXNfYWN0aXZlID0gdHdfY2xfaXNfYWN0aXZl
 KGN0bHJfaGFuZGxlKTsKKworCWlmIChpX25lZWRfYV9yZXNldCkgeworI2lmZGVmICAgIFRXX09T
 TF9ERUJVRworCQlkZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJXYXRjaGRvZyByZXNjaGVk
 dWxlZCBpbiA3MCBzZWNvbmRzXG4iKTsKKyNlbmRpZiAvKiBUV19PU0xfREVCVUcgKi8KKwkJbXlf
 d2F0Y2hkb2dfd2FzX3BlbmRpbmcgPQorCQkJY2FsbG91dF9yZXNldCgmKHNjLT53YXRjaGRvZ19j
 YWxsb3V0W2ldKSwgNzAqaHosIHR3YV93YXRjaGRvZywgJnNjLT5jdGxyX2hhbmRsZSk7CisJCXR3
 X2NsX3Jlc2V0X2N0bHIoY3Rscl9oYW5kbGUpOworI2lmZGVmICAgIFRXX09TTF9ERUJVRworCQlk
 ZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJXYXRjaGRvZyByZXNldCBjb21wbGV0ZWQhXG4i
 KTsKKyNlbmRpZiAvKiBUV19PU0xfREVCVUcgKi8KKwl9IGVsc2UgaWYgKGRyaXZlcl9pc19hY3Rp
 dmUpIHsKKwkJbXlfd2F0Y2hkb2dfd2FzX3BlbmRpbmcgPQorCQkJY2FsbG91dF9yZXNldCgmKHNj
 LT53YXRjaGRvZ19jYWxsb3V0W2ldKSwgIDUqaHosIHR3YV93YXRjaGRvZywgJnNjLT5jdGxyX2hh
 bmRsZSk7CisJfQorI2lmZGVmICAgIFRXX09TTF9ERUJVRworCWlmIChpX25lZWRfYV9yZXNldCB8
 fCBteV93YXRjaGRvZ193YXNfcGVuZGluZykKKwkJZGV2aWNlX3ByaW50Zigoc2MpLT5idXNfZGV2
 LCAiaV9uZWVkX2FfcmVzZXQgPSAlZCwgIgorCQkiZHJpdmVyX2lzX2FjdGl2ZSA9ICVkLCBteV93
 YXRjaGRvZ193YXNfcGVuZGluZyA9ICVkXG4iLAorCQlpX25lZWRfYV9yZXNldCwgZHJpdmVyX2lz
 X2FjdGl2ZSwgbXlfd2F0Y2hkb2dfd2FzX3BlbmRpbmcpOworI2VuZGlmIC8qIFRXX09TTF9ERUJV
 RyAqLworfQorCiAKIC8qCiAgKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xpX2FsbG9jX21lbQpAQCAt
 NzE1LDkgKzgwOCw3IEBACiAKIAogCS8qIERpc2Nvbm5lY3QgdGhlIGludGVycnVwdCBoYW5kbGVy
 LiAqLwotCWlmIChzYy0+aW50cl9oYW5kbGUpCi0JCWlmICgoZXJyb3IgPSBidXNfdGVhcmRvd25f
 aW50cihzYy0+YnVzX2RldiwKLQkJCQlzYy0+aXJxX3Jlcywgc2MtPmludHJfaGFuZGxlKSkpCisJ
 aWYgKChlcnJvciA9IHR3YV90ZWFyZG93bl9pbnRyKHNjKSkpCiAJCQl0d19vc2xpX2RiZ19kcHJp
 bnRmKDEsIHNjLAogCQkJCSJ0ZWFyZG93bl9pbnRyIHJldHVybmVkICVkIiwgZXJyb3IpOwogCkBA
 IC04MDksNiArOTAwLDEzIEBACiAKIAl0d19vc2xpX2RiZ19kcHJpbnRmKDMsIHNjLCAiZW50ZXJl
 ZCIpOwogCisJLyogRGlzY29ubmVjdCBpbnRlcnJ1cHRzLiAqLworCWVycm9yID0gdHdhX3RlYXJk
 b3duX2ludHIoc2MpOworCisJLyogU3RvcCB3YXRjaGRvZyB0YXNrLiAqLworCWNhbGxvdXRfZHJh
 aW4oJihzYy0+d2F0Y2hkb2dfY2FsbG91dFswXSkpOworCWNhbGxvdXRfZHJhaW4oJihzYy0+d2F0
 Y2hkb2dfY2FsbG91dFsxXSkpOworCiAJLyogRGlzY29ubmVjdCBmcm9tIHRoZSBjb250cm9sbGVy
 LiAqLwogCWlmICgoZXJyb3IgPSB0d19jbF9zaHV0ZG93bl9jdGxyKCYoc2MtPmN0bHJfaGFuZGxl
 KSwgMCkpKSB7CiAJCXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAlZCIsCkBAIC05OTcsMzMg
 KzEwOTUsMzUgQEAKIAkJCQllcnJvciA9IDA7IC8qIEZhbHNlIGVycm9yICovCiAJCQkJYnJlYWs7
 CiAJCQl9Ci0JCQl0d19vc2xpX3ByaW50ZihzYywgInJlcXVlc3QgPSAlcCIsCi0JCQkJVFdfQ0xf
 U0VWRVJJVFlfRVJST1JfU1RSSU5HLAotCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0Rf
 RFJJVkVSLAotCQkJCTB4MjAxOCwKLQkJCQkiUGFzc3RocnUgcmVxdWVzdCB0aW1lZCBvdXQhIiwK
 LQkJCQlyZXEpOwotCQkJLyoKLQkJCSAqIFNob3VsZCBJIGNoZWNrIGhlcmUgaWYgdGhlIHRpbWVv
 dXQgaGFwcGVuZWQKLQkJCSAqIGJlY2F1c2Ugb2YgeWV0IGFub3RoZXIgcmVzZXQsIGFuZCBub3Qg
 ZG8gYQotCQkJICogc2Vjb25kIHJlc2V0PwotCQkJICovCi0JCQl0d19jbF9yZXNldF9jdGxyKCZz
 Yy0+Y3Rscl9oYW5kbGUpOworCQkJaWYgKCEodHdfY2xfaXNfcmVzZXRfbmVlZGVkKCYocmVxLT5j
 dGxyLT5jdGxyX2hhbmRsZSkpKSkgeworI2lmZGVmICAgIFRXX09TTF9ERUJVRworCQkJCXR3X29z
 bGlfcHJpbnRmKHNjLCAicmVxdWVzdCA9ICVwIiwKKwkJCQkJVFdfQ0xfU0VWRVJJVFlfRVJST1Jf
 U1RSSU5HLAorCQkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKKwkJCQkJ
 MHgyMDE4LAorCQkJCQkiUGFzc3RocnUgcmVxdWVzdCB0aW1lZCBvdXQhIiwKKwkJCQkJcmVxKTsK
 KyNlbHNlICAvKiBUV19PU0xfREVCVUcgKi8KKwkJCWRldmljZV9wcmludGYoKHNjKS0+YnVzX2Rl
 diwgIlBhc3N0aHJ1IHJlcXVlc3QgdGltZWQgb3V0IVxuIik7CisjZW5kaWYgLyogVFdfT1NMX0RF
 QlVHICovCisJCQkJdHdfY2xfcmVzZXRfY3RscigmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKTsK
 KwkJCX0KKworCQkJZXJyb3IgPSAwOworCQkJZW5kX3RpbWUgPSB0d19vc2xfZ2V0X2xvY2FsX3Rp
 bWUoKSArIHRpbWVvdXQ7CisJCQljb250aW51ZTsKIAkJCS8qCiAJCQkgKiBEb24ndCB0b3VjaCBy
 ZXEgYWZ0ZXIgYSByZXNldC4gIEl0IChhbmQgYW55Ci0JCQkgKiBhc3NvY2lhdGVkIGRhdGEpIHdp
 bGwgYWxyZWFkeSBoYXZlIGJlZW4KKwkJCSAqIGFzc29jaWF0ZWQgZGF0YSkgd2lsbCBiZQogCQkJ
 ICogdW5tYXBwZWQgYnkgdGhlIGNhbGxiYWNrLgogCQkJICovCi0JCQl1c2VyX2J1Zi0+ZHJpdmVy
 X3BrdC5vc19zdGF0dXMgPSBlcnJvcjsKLQkJCWVycm9yID0gRVRJTUVET1VUOwotCQkJZ290byBm
 d19wYXNzdGhydV9lcnI7CiAJCX0KIAkJLyogCiAJCSAqIEVpdGhlciB0aGUgcmVxdWVzdCBnb3Qg
 Y29tcGxldGVkLCBvciB3ZSB3ZXJlIHdva2VuIHVwIGJ5IGEKIAkJICogc2lnbmFsLiAgQ2FsY3Vs
 YXRlIHRoZSBuZXcgdGltZW91dCwgaW4gY2FzZSBpdCB3YXMgdGhlIGxhdHRlci4KIAkJICovCiAJ
 CXRpbWVvdXQgPSAoZW5kX3RpbWUgLSB0d19vc2xfZ2V0X2xvY2FsX3RpbWUoKSk7Ci0JfQorCX0g
 LyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIAogCS8qIElmIHRoZXJlIHdhcyBhIHBheWxvYWQsIGNv
 cHkgaXQgYmFjay4gKi8KIAlpZiAoKCFlcnJvcikgJiYgKHJlcS0+bGVuZ3RoKSkKQEAgLTEwMzcs
 MTkgKzExMzcsOSBAQAogCQkJCWVycm9yKTsKIAkKIGZ3X3Bhc3N0aHJ1X2VycjoKLQkvKgotCSAq
 IFByaW50IHRoZSBmYWlsdXJlIG1lc3NhZ2UuICBGb3Igc29tZSByZWFzb24sIG9uIGNlcnRhaW4g
 T1MgdmVyc2lvbnMsCi0JICogcHJpbnRpbmcgdGhpcyBlcnJvciBtZXNzYWdlIGR1cmluZyByZXNl
 dCBoYW5ncyB0aGUgZGlzcGxheSAoYWx0aG91Z2gKLQkgKiB0aGUgcmVzdCBvZiB0aGUgc3lzdGVt
 IGlzIHJ1bm5pbmcgZmluZS4gIFNvLCBkb24ndCBwcmludCBpdCBpZiB0aGUKLQkgKiBmYWlsdXJl
 IHdhcyBkdWUgdG8gYSByZXNldC4KLQkgKi8KLQlpZiAoKGVycm9yKSAmJiAoZXJyb3IgIT0gVFdf
 Q0xfRVJSX1JFUV9CVVNfUkVTRVQpKQotCQl0d19vc2xpX3ByaW50ZihzYywgImVycm9yID0gJWQi
 LAkJCi0JCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCi0JCQlUV19DTF9NRVNTQUdFX1NP
 VVJDRV9GUkVFQlNEX0RSSVZFUiwKLQkJCTB4MjAxQSwKLQkJCSJGaXJtd2FyZSBwYXNzdGhydSBm
 YWlsZWQhIiwKLQkJCWVycm9yKTsKKworCWlmIChyZXFfcGt0LT5zdGF0dXMgPT0gVFdfQ0xfRVJS
 X1JFUV9CVVNfUkVTRVQpCisJCWVycm9yID0gRUJVU1k7CiAKIAl1c2VyX2J1Zi0+ZHJpdmVyX3Br
 dC5vc19zdGF0dXMgPSBlcnJvcjsKIAkvKiBGcmVlIHJlc291cmNlcy4gKi8KQEAgLTEwNzMsNiAr
 MTE2Myw4IEBACiB0d19vc2xfY29tcGxldGVfcGFzc3RocnUoc3RydWN0IHR3X2NsX3JlcV9oYW5k
 bGUgKnJlcV9oYW5kbGUpCiB7CiAJc3RydWN0IHR3X29zbGlfcmVxX2NvbnRleHQJKnJlcSA9IHJl
 cV9oYW5kbGUtPm9zbF9yZXFfY3R4dDsKKwlzdHJ1Y3QgdHdfY2xfcmVxX3BhY2tldAkJKnJlcV9w
 a3QgPQorCQkoc3RydWN0IHR3X2NsX3JlcV9wYWNrZXQgKikoJnJlcS0+cmVxX3BrdCk7CiAJc3Ry
 dWN0IHR3YV9zb2Z0YwkJKnNjID0gcmVxLT5jdGxyOwogCiAJdHdfb3NsaV9kYmdfZHByaW50Zig1
 LCBzYywgImVudGVyZWQiKTsKQEAgLTExMjAsNiArMTIxMiw5IEBACiAJCQlpZiAocmVxLT5mbGFn
 cyAmIFRXX09TTElfUkVRX0ZMQUdTX01BUFBFRCkKIAkJCQlyZXR1cm47CiAKKwkJCWlmIChyZXFf
 cGt0LT5zdGF0dXMgPT0gVFdfQ0xfRVJSX1JFUV9CVVNfUkVTRVQpCisJCQkJcmV0dXJuOworCiAJ
 CQl0d19vc2xpX3ByaW50ZihzYywgInJlcXVlc3QgPSAlcCIsCiAJCQkJVFdfQ0xfU0VWRVJJVFlf
 RVJST1JfU1RSSU5HLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0RfRFJJVkVSLApA
 QCAtMTE2Niw2ICsxMjYxLDcgQEAKIAkJcmVxLT5yZXFfaGFuZGxlLmlzX2lvID0gMDsKIAkJcmVx
 LT5kYXRhID0gTlVMTDsKIAkJcmVxLT5sZW5ndGggPSAwOworCQlyZXEtPmRlYWRsaW5lID0gMDsK
 IAkJcmVxLT5yZWFsX2RhdGEgPSBOVUxMOwogCQlyZXEtPnJlYWxfbGVuZ3RoID0gMDsKIAkJcmVx
 LT5zdGF0ZSA9IFRXX09TTElfUkVRX1NUQVRFX0lOSVQ7LyogcmVxIGJlaW5nIGluaXRpYWxpemVk
 ICovCkBAIC0xMjA3LDYgKzEzMDMsMTEgQEAKIAogCXR3X29zbGlfZGJnX2RwcmludGYoMTAsIHNj
 LCAiZW50ZXJlZCIpOwogCisJaWYgKGVycm9yID09IEVJTlZBTCkgeworCQlyZXEtPmVycm9yX2Nv
 ZGUgPSBlcnJvcjsKKwkJcmV0dXJuOworCX0KKwogCS8qIE1hcmsgdGhlIHJlcXVlc3QgYXMgY3Vy
 cmVudGx5IGJlaW5nIHByb2Nlc3NlZC4gKi8KIAlyZXEtPnN0YXRlID0gVFdfT1NMSV9SRVFfU1RB
 VEVfQlVTWTsKIAkvKiBNb3ZlIHRoZSByZXF1ZXN0IGludG8gdGhlIGJ1c3kgcXVldWUuICovCkBA
 IC0xNDAwLDYgKzE1MDEsMTQgQEAKIAkJCQltdHhfdW5sb2NrX3NwaW4oc2MtPmlvX2xvY2spOwog
 CQkJCWVycm9yID0gMDsKIAkJCX0gZWxzZSB7CisJCQkJdHdfb3NsaV9wcmludGYoc2MsICJlcnJv
 ciA9ICVkIiwKKwkJCQkJVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAorCQkJCQlUV19DTF9N
 RVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKKwkJCQkJMHg5OTk5LAorCQkJCQkiRmFpbGVk
 IHRvIG1hcCBETUEgbWVtb3J5ICIKKwkJCQkJImZvciBJL08gcmVxdWVzdCIsCisJCQkJCWVycm9y
 KTsKKwkJCQlyZXEtPmZsYWdzIHw9IFRXX09TTElfUkVRX0ZMQUdTX0ZBSUxFRDsKIAkJCQkvKiBG
 cmVlIGFsaWdubWVudCBidWZmZXIgaWYgaXQgd2FzIHVzZWQuICovCiAJCQkJaWYgKHJlcS0+Zmxh
 Z3MgJgogCQkJCQlUV19PU0xJX1JFUV9GTEFHU19EQVRBX0NPUFlfTkVFREVEKSB7CmRpZmYgLXUg
 RnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfb3NsX3NoYXJlLmggRnJlZUJTRF9IRUFEX3R3YV8zXzgw
 XzA2XzAwMy90d19vc2xfc2hhcmUuaAotLS0gRnJlZUJTRF9IRUFEX3R3YV9jdnMvdHdfb3NsX3No
 YXJlLmgJMjAxMC0wOC0yNiAxNTozNDozMy4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0RfSEVB
 RF90d2FfM184MF8wNl8wMDMvdHdfb3NsX3NoYXJlLmgJMjAxMC0wOC0yNCAxODowMjoxMi4wMDAw
 MDAwMDAgLTA3MDAKQEAgLTc1LDcgKzc1LDcgQEAKICNkZWZpbmUgVFdfT1NMX0VOQ0xPU1VSRV9T
 VVBQT1JUCiAjZW5kaWYKIAotI2RlZmluZSBUV19PU0xfRFJJVkVSX1ZFUlNJT05fU1RSSU5HCSIz
 LjgwLjA2LjAwMiIKKyNkZWZpbmUgVFdfT1NMX0RSSVZFUl9WRVJTSU9OX1NUUklORwkiMy44MC4w
 Ni4wMDMiCiAKICNkZWZpbmUJVFdfT1NMX0NBTl9TTEVFUAogCg==
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Acosmail03lsicom_--

From: "Couch, Tom" <Tom.Couch@lsi.com>
To: "FreeBSD-gnats-submit@FreeBSD.org" <FreeBSD-gnats-submit@FreeBSD.org>,
        "freebsd-bugs@FreeBSD.org" <freebsd-bugs@FreeBSD.org>
Cc:  
Subject: RE: kern/149968: Kernel panic with ZFS and twa version 3.80.06.002
Date: Mon, 30 Aug 2010 13:10:53 -0600

 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Bcosmail03lsicom_
 Content-Type: text/plain; charset="us-ascii"
 Content-Transfer-Encoding: quoted-printable
 
 Attaching patch FreeBSD_RELENG_8_src_sys_dev_twa.txt for RELENG_8.
 
 Tom Couch
 
 
 
 -----Original Message-----
 From: FreeBSD-gnats-submit@FreeBSD.org [mailto:FreeBSD-gnats-submit@FreeBSD=
 .org]=20
 Sent: Wednesday, August 25, 2010 11:30 AM
 To: Couch, Tom
 Subject: Re: kern/149968: Kernel panic with ZFS and twa version 3.80.06.002
 
 Thank you very much for your problem report.
 It has the internal identification `kern/149968'.
 The individual assigned to look at your
 report is: freebsd-bugs.=20
 
 You can access the state of your problem report at any time
 via this link:
 
 http://www.freebsd.org/cgi/query-pr.cgi?pr=3D149968
 
 >Category:       kern
 >Responsible:    freebsd-bugs
 >Synopsis:       Kernel panic with ZFS and twa version 3.80.06.002
 >Arrival-Date:   Wed Aug 25 18:30:06 UTC 2010
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Bcosmail03lsicom_
 Content-Type: text/plain; name="FreeBSD_RELENG_8_src_sys_dev_twa.txt"
 Content-Description: FreeBSD_RELENG_8_src_sys_dev_twa.txt
 Content-Disposition: attachment;
 	filename="FreeBSD_RELENG_8_src_sys_dev_twa.txt"; size=44088;
 	creation-date="Thu, 26 Aug 2010 16:56:00 GMT";
 	modification-date="Thu, 26 Aug 2010 16:56:00 GMT"
 Content-Transfer-Encoding: base64
 
 ZGlmZiAtdSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfY2wuaCBGcmVlQlNEOF90d2FfM184
 MF8wNl8wMDMvdHdfY2wuaAotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3ZzL3R3X2NsLmgJMjAx
 MC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q4X3R3YV8zXzgwXzA2
 XzAwMy90d19jbC5oCTIwMTAtMDgtMjQgMTg6MDE6NDQuMDAwMDAwMDAwIC0wNzAwCkBAIC04OCw3
 ICs4OCw4IEBACiAjZGVmaW5lIFRXX0NMSV9CVVNZX1EJCTEJLyogcSBvZiByZXFzIHN1Ym1pdHRl
 ZCB0byBmdyAqLwogI2RlZmluZSBUV19DTElfUEVORElOR19RCTIJLyogcSBvZiByZXFzIGRlZmVy
 cmVkIGR1ZSB0byAncSBmdWxsJyAqLwogI2RlZmluZSBUV19DTElfQ09NUExFVEVfUQkzCS8qIHEg
 b2YgcmVxcyBjb21wbGV0ZWQgYnkgZncgKi8KLSNkZWZpbmUgVFdfQ0xJX1FfQ09VTlQJCTQJLyog
 dG90YWwgbnVtYmVyIG9mIHF1ZXVlcyAqLworI2RlZmluZSBUV19DTElfUkVTRVRfUQkJNAkvKiBx
 IG9mIHJlcXMgcmVzZXQgYnkgdGltZW91dCAqLworI2RlZmluZSBUV19DTElfUV9DT1VOVAkJNQkv
 KiB0b3RhbCBudW1iZXIgb2YgcXVldWVzICovCiAKIAogLyogQ0wncyBpbnRlcm5hbCByZXF1ZXN0
 IGNvbnRleHQuICovCkBAIC0xMzMsNiArMTM0LDcgQEAKIAlUV19VSU5UOCAJCWludGVycnVwdHNf
 ZW5hYmxlZDsJICAvKiBJbnRlcnJ1cHRzIG9uIGNvbnRyb2xsZXIgZW5hYmxlZC4gKi8KIAlUV19V
 SU5UOCAJCWludGVybmFsX3JlcV9idXN5OwkgIC8qIERhdGEgYnVmZmVyIGZvciBpbnRlcm5hbCBy
 ZXF1ZXN0cyBpbiB1c2UuICovCiAJVFdfVUlOVDggCQlnZXRfbW9yZV9hZW5zOwkJICAvKiBNb3Jl
 IEFFTidzIG5lZWQgdG8gYmUgcmV0cmlldmVkLiAqLworCVRXX1VJTlQ4IAkJcmVzZXRfbmVlZGVk
 OwkJICAvKiBDb250cm9sbGVyIG5lZWRzIGEgc29mdCByZXNldC4gKi8KIAlUV19VSU5UOCAJCXJl
 c2V0X2luX3Byb2dyZXNzOwkgIC8qIENvbnRyb2xsZXIgaXMgYmVpbmcgcmVzZXQuICovCiAJVFdf
 VUlOVDggCQlyZXNldF9waGFzZTFfaW5fcHJvZ3Jlc3M7IC8qIEluICdwaGFzZSAxJyBvZiByZXNl
 dC4gKi8KIAlUV19VSU5UMzIJCWZsYWdzOwkJLyogY29udHJvbGxlciBzZXR0aW5ncyAqLwpkaWZm
 IC11IEZyZWVCU0RfUkVMRU5HXzhfdHdhX2N2cy90d19jbF9leHRlcm5zLmggRnJlZUJTRDhfdHdh
 XzNfODBfMDZfMDAzL3R3X2NsX2V4dGVybnMuaAotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3Zz
 L3R3X2NsX2V4dGVybnMuaAkyMDEwLTA4LTI2IDE1OjM1OjIwLjAwMDAwMDAwMCAtMDcwMAorKysg
 RnJlZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2V4dGVybnMuaAkyMDEwLTA4LTI0IDE4OjAx
 OjQ0LjAwMDAwMDAwMCAtMDcwMApAQCAtODYsNiArODYsOCBAQAogCiAvKiBTb2Z0IHJlc2V0IHRo
 ZSBjb250cm9sbGVyLiAqLwogZXh0ZXJuIFRXX0lOVDMyCXR3X2NsaV9zb2Z0X3Jlc2V0KHN0cnVj
 dCB0d19jbGlfY3Rscl9jb250ZXh0ICpjdGxyKTsKK2V4dGVybiBpbnQgdHdhX3NldHVwX2ludHIo
 c3RydWN0IHR3YV9zb2Z0YyAqc2MpOworZXh0ZXJuIGludCB0d2FfdGVhcmRvd25faW50cihzdHJ1
 Y3QgdHdhX3NvZnRjICpzYyk7CiAKIC8qIFNlbmQgZG93biBhIFNDU0kgY29tbWFuZCB0byB0aGUg
 ZmlybXdhcmUgKHVzdWFsbHksIGFuIGludGVybmFsIFJlcSBTZW5zZS4gKi8KIGV4dGVybiBUV19J
 TlQzMgl0d19jbGlfc2VuZF9zY3NpX2NtZChzdHJ1Y3QgdHdfY2xpX3JlcV9jb250ZXh0ICpyZXEs
 CmRpZmYgLXUgRnJlZUJTRF9SRUxFTkdfOF90d2FfY3ZzL3R3X2NsX2Z3aWYuaCBGcmVlQlNEOF90
 d2FfM184MF8wNl8wMDMvdHdfY2xfZndpZi5oCi0tLSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMv
 dHdfY2xfZndpZi5oCTIwMTAtMDgtMjYgMTU6MzU6MjAuMDAwMDAwMDAwIC0wNzAwCisrKyBGcmVl
 QlNEOF90d2FfM184MF8wNl8wMDMvdHdfY2xfZndpZi5oCTIwMTAtMDgtMjQgMTg6MDE6NDQuMDAw
 MDAwMDAwIC0wNzAwCkBAIC04OSw3ICs4OSw3IEBACiAjZGVmaW5lIFRXQV9TVEFUVVNfTUlOT1Jf
 VkVSU0lPTl9NQVNLCQkweDBGMDAwMDAwCiAjZGVmaW5lIFRXQV9TVEFUVVNfTUFKT1JfVkVSU0lP
 Tl9NQVNLCQkweEYwMDAwMDAwCiAKLSNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJ
 CTB4MDBGMDAwMDAKKyNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJCTB4MDBEMDAw
 MDAKIAogCiAvKiBQQ0kgcmVsYXRlZCBkZWZpbmVzLiAqLwpkaWZmIC11IEZyZWVCU0RfUkVMRU5H
 XzhfdHdhX2N2cy90d19jbF9pbml0LmMgRnJlZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2lu
 aXQuYwotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3ZzL3R3X2NsX2luaXQuYwkyMDEwLTA4LTI2
 IDE1OjM1OjIwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3
 X2NsX2luaXQuYwkyMDEwLTA4LTI0IDE4OjAxOjQ0LjAwMDAwMDAwMCAtMDcwMApAQCAtMzE1LDYg
 KzMxNSw3IEBACiAJdHdfY2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX0JVU1lfUSk7CiAJdHdf
 Y2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX1BFTkRJTkdfUSk7CiAJdHdfY2xpX3JlcV9xX2lu
 aXQoY3RsciwgVFdfQ0xJX0NPTVBMRVRFX1EpOworCXR3X2NsaV9yZXFfcV9pbml0KGN0bHIsIFRX
 X0NMSV9SRVNFVF9RKTsKIAogCS8qIEluaXRpYWxpemUgYWxsIGxvY2tzIHVzZWQgYnkgQ0wuICov
 CiAJY3Rsci0+Z2VuX2xvY2sgPSAmKGN0bHItPmdlbl9sb2NrX2hhbmRsZSk7CkBAIC02NzUsMTUg
 KzY3NiwxNCBAQAogCS8qIFN1Ym1pdCB0aGUgY29tbWFuZCwgYW5kIHdhaXQgZm9yIGl0IHRvIGNv
 bXBsZXRlLiAqLwogCWVycm9yID0gdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwK
 IAkJVFdfQ0xJX1JFUVVFU1RfVElNRU9VVF9QRVJJT0QpOwotCWlmIChlcnJvciA9PSBUV19PU0xf
 RVRJTUVET1VUKQotCQkvKiBDbGVhbi11cCBkb25lIGJ5IHR3X2NsaV9zdWJtaXRfYW5kX3BvbGxf
 cmVxdWVzdC4gKi8KLQkJcmV0dXJuKGVycm9yKTsKIAlpZiAoZXJyb3IpCiAJCWdvdG8gb3V0Owog
 CWlmICgoZXJyb3IgPSBpbml0X2Nvbm5lY3QtPnN0YXR1cykpIHsKKyNpZiAgICAgICAwCiAJCXR3
 X2NsaV9jcmVhdGVfY3Rscl9ldmVudChjdGxyLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09O
 VFJPTExFUl9FUlJPUiwKIAkJCSYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjZW5kaWYgLy8g
 MAogCQlnb3RvIG91dDsKIAl9CiAJaWYgKHNldF9mZWF0dXJlcyAmIFRXQV9FWFRFTkRFRF9JTklU
 X0NPTk5FQ1QpIHsKZGlmZiAtdSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfY2xfaW50ci5j
 IEZyZWVCU0Q4X3R3YV8zXzgwXzA2XzAwMy90d19jbF9pbnRyLmMKLS0tIEZyZWVCU0RfUkVMRU5H
 XzhfdHdhX2N2cy90d19jbF9pbnRyLmMJMjAxMC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3
 MDAKKysrIEZyZWVCU0Q4X3R3YV8zXzgwXzA2XzAwMy90d19jbF9pbnRyLmMJMjAxMC0wOC0yNCAx
 ODowMTo0NC4wMDAwMDAwMDAgLTA3MDAKQEAgLTI0OCw4ICsyNDgsNyBAQAogI2lmZGVmIFRXX09T
 TF9ERUJVRwogCQkJdHdfY2xfcHJpbnRfY3Rscl9zdGF0cyhjdGxyLT5jdGxyX2hhbmRsZSk7CiAj
 ZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCi0JCQl0d19jbF9yZXNldF9jdGxyKGN0bHItPmN0bHJf
 aGFuZGxlKTsKLQkJCXJldHVybihUV19PU0xfRUlPKTsKKwkJCWNvbnRpbnVlOwogCQl9CiAKIAkJ
 LyoKQEAgLTQwMiw5ICs0MDEsNyBAQAogI2lmZGVmIFRXX09TTF9ERUJVRwogCQl0d19jbF9wcmlu
 dF9jdGxyX3N0YXRzKGN0bHItPmN0bHJfaGFuZGxlKTsKICNlbmRpZiAvKiBUV19PU0xfREVCVUcg
 Ki8KLQkJdHdfY2xfcmVzZXRfY3RscihjdGxyLT5jdGxyX2hhbmRsZSk7Ci0JCXJlcV9wa3QtPnN0
 YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQlnb3RvIG91dDsKKwkJcmV0dXJuOwog
 CX0KIAogCWlmIChyZXEtPmZsYWdzICYgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSkgewpAQCAt
 NDgzLDYgKzQ4MCw3IEBACiAJCQljZGJbOF0sIGNkYls5XSwgY2RiWzEwXSwgY2RiWzExXSwKIAkJ
 CWNkYlsxMl0sIGNkYlsxM10sIGNkYlsxNF0sIGNkYlsxNV0pOwogCisjaWYgICAgICAgMAogCQkv
 KiAKIAkJICogUHJpbnQgdGhlIGVycm9yLiBGaXJtd2FyZSBkb2Vzbid0IHlldCBzdXBwb3J0CiAJ
 CSAqIHRoZSAnTW9kZSBTZW5zZScgY21kLiAgRG9uJ3QgcHJpbnQgaWYgdGhlIGNtZApAQCAtNDkz
 LDYgKzQ5MSw3IEBACiAJCQl0d19jbGlfY3JlYXRlX2N0bHJfZXZlbnQocmVxLT5jdGxyLAogCQkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1IsCiAJCQkJY21kX2hkcik7Cisj
 ZW5kaWYgLy8gMAogCX0KIAogCWlmIChzY3NpX3JlcS0+c2Vuc2VfZGF0YSkgewpAQCAtNTMwLDkg
 KzUyOSwxMSBAQAogCSAqLwogCWlmICghIHJlcS0+ZXJyb3JfY29kZSkKIAkJaWYgKGNtZC0+cGFy
 YW0uc3RhdHVzKSB7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2NyZWF0ZV9jdGxyX2V2ZW50KGN0
 bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExFUl9FUlJPUiwKIAkJCQkmKHJl
 cS0+Y21kX3BrdC0+Y21kX2hkcikpOworI2VuZGlmIC8vIDAKIAkJCXR3X2NsX2NyZWF0ZV9ldmVu
 dChjdGxyLT5jdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfQ09NTU9OX0xBWUVSX0VSUk9SLAogCQkJCTB4MTIwNCwgMHgxLCBUV19DTF9TRVZFUklUWV9F
 UlJPUl9TVFJJTkcsCkBAIC01OTAsOSArNTkxLDExIEBACiAJCWlmICgoZXJyb3IgPSBjbWQtPnN0
 YXR1cykpIHsKIAkJCWNtZF9oZHIgPSAoc3RydWN0IHR3X2NsX2NvbW1hbmRfaGVhZGVyICopCiAJ
 CQkJKCYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2Ny
 ZWF0ZV9jdGxyX2V2ZW50KGN0bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExF
 Ul9FUlJPUiwKIAkJCQljbWRfaGRyKTsKKyNlbmRpZiAvLyAwCiAJCQl0d19jbF9jcmVhdGVfZXZl
 bnQoY3Rsci0+Y3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09V
 UkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCQkweDEyMDYsIDB4MSwgVFdfQ0xfU0VWRVJJVFlf
 RVJST1JfU1RSSU5HLApkaWZmIC11IEZyZWVCU0RfUkVMRU5HXzhfdHdhX2N2cy90d19jbF9pby5j
 IEZyZWVCU0Q4X3R3YV8zXzgwXzA2XzAwMy90d19jbF9pby5jCi0tLSBGcmVlQlNEX1JFTEVOR184
 X3R3YV9jdnMvdHdfY2xfaW8uYwkyMDEwLTA4LTI2IDE1OjM1OjIwLjAwMDAwMDAwMCAtMDcwMAor
 KysgRnJlZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3X2NsX2lvLmMJMjAxMC0wOC0yNCAxODowMTo0
 NC4wMDAwMDAwMDAgLTA3MDAKQEAgLTc0LDE4ICs3NCwxMiBAQAogCXN0cnVjdCB0d19jbGlfcmVx
 X2NvbnRleHQJCSpyZXE7CiAJc3RydWN0IHR3X2NsX2NvbW1hbmRfOWsJCQkqY21kOwogCXN0cnVj
 dCB0d19jbF9zY3NpX3JlcV9wYWNrZXQJCSpzY3NpX3JlcTsKLQlUV19JTlQzMgkJCQllcnJvcjsK
 KwlUV19JTlQzMgkJCQllcnJvciA9IFRXX0NMX0VSUl9SRVFfU1VDQ0VTUzsKIAogCXR3X2NsaV9k
 YmdfcHJpbnRmKDEwLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7
 CiAKIAljdGxyID0gKHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICopKGN0bHJfaGFuZGxlLT5j
 bF9jdGxyX2N0eHQpOwogCi0JaWYgKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSB7Ci0JCXR3X2Ns
 aV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwKLQkJCSJJL08g
 ZHVyaW5nIHJlc2V0OiByZXR1cm5pbmcgYnVzeS4iKTsKLQkJcmV0dXJuKFRXX09TTF9FQlVTWSk7
 Ci0JfQotCiAJLyoKIAkgKiBJZiB3b3JraW5nIHdpdGggYSBmaXJtd2FyZSB2ZXJzaW9uIHRoYXQg
 ZG9lcyBub3Qgc3VwcG9ydCBtdWx0aXBsZQogCSAqIGx1bnMsIGFuZCB0aGlzIHJlcXVlc3QgaXMg
 ZGlyZWN0ZWQgYXQgYSBub24temVybyBsdW4sIGVycm9yIGl0CkBAIC0xNDUsNyArMTM5LDEyIEBA
 CiAJCQljbWQtPnNnX2xpc3QsIHNjc2lfcmVxLT5zZ2xfZW50cmllcyk7CiAJfQogCi0JaWYgKChl
 cnJvciA9IHR3X2NsaV9zdWJtaXRfY21kKHJlcSkpKSB7CisJaWYgKCgoVFdfQ0xfUV9GSVJTVF9J
 VEVNKCYoY3Rsci0+cmVxX3FfaGVhZFtUV19DTElfUEVORElOR19RXSkpKSAhPSBUV19DTF9OVUxM
 KSB8fAorCQkoY3Rsci0+cmVzZXRfaW5fcHJvZ3Jlc3MpKSB7CisJCXR3X2NsaV9yZXFfcV9pbnNl
 cnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOworCQlUV19DTElfV1JJVEVfQ09OVFJPTF9S
 RUdJU1RFUihjdGxyX2hhbmRsZSwKKwkJCVRXQV9DT05UUk9MX1VOTUFTS19DT01NQU5EX0lOVEVS
 UlVQVCk7CisJfSBlbHNlIGlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgewog
 CQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksCiAJ
 CQkiQ291bGQgbm90IHN0YXJ0IHJlcXVlc3QuIHJlcXVlc3QgPSAlcCwgZXJyb3IgPSAlZCIsCiAJ
 CQlyZXEsIGVycm9yKTsKQEAgLTE3MSw3ICsxNzAsNyBAQAogCXN0cnVjdCB0d19jbGlfY3Rscl9j
 b250ZXh0CSpjdGxyID0gcmVxLT5jdGxyOwogCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZQkqY3Rs
 cl9oYW5kbGUgPSBjdGxyLT5jdGxyX2hhbmRsZTsKIAlUV19VSU5UMzIJCQlzdGF0dXNfcmVnOwot
 CVRXX0lOVDMyCQkJZXJyb3I7CisJVFdfSU5UMzIJCQllcnJvciA9IDA7CiAKIAl0d19jbGlfZGJn
 X3ByaW50ZigxMCwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLCAiZW50ZXJlZCIpOwog
 CkBAIC0xODUsMTEgKzE4NCw3IEBACiAJCQkJIFRXQV9DT01NQU5EX1FVRVVFX09GRlNFVF9MT1cs
 CiAJCQkJIChUV19VSU5UMzIpKHJlcS0+Y21kX3BrdF9waHlzICsgc2l6ZW9mKHN0cnVjdCB0d19j
 bF9jb21tYW5kX2hlYWRlcikpLCA0KTsKIAotCS8qIENoZWNrIHRvIHNlZSBpZiB3ZSBjYW4gcG9z
 dCBhIGNvbW1hbmQuICovCiAJc3RhdHVzX3JlZyA9IFRXX0NMSV9SRUFEX1NUQVRVU19SRUdJU1RF
 UihjdGxyX2hhbmRsZSk7Ci0JaWYgKChlcnJvciA9IHR3X2NsaV9jaGVja19jdGxyX3N0YXRlKGN0
 bHIsIHN0YXR1c19yZWcpKSkKLQkJZ290byBvdXQ7Ci0KIAlpZiAoc3RhdHVzX3JlZyAmIFRXQV9T
 VEFUVVNfQ09NTUFORF9RVUVVRV9GVUxMKSB7CiAJCXN0cnVjdCB0d19jbF9yZXFfcGFja2V0CSpy
 ZXFfcGt0ID0KIAkJCShzdHJ1Y3QgdHdfY2xfcmVxX3BhY2tldCAqKShyZXEtPm9yaWdfcmVxKTsK
 QEAgLTIwNywxNCArMjAyLDEyIEBACiAJCQkJCSJwZW5kaW5nIGludGVybmFsL2lvY3RsIHJlcXVl
 c3QiKTsKIAkJCQlyZXEtPnN0YXRlID0gVFdfQ0xJX1JFUV9TVEFURV9QRU5ESU5HOwogCQkJCXR3
 X2NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOwotCQkJCWVycm9y
 ID0gMDsKIAkJCQkvKiBVbm1hc2sgY29tbWFuZCBpbnRlcnJ1cHQuICovCiAJCQkJVFdfQ0xJX1dS
 SVRFX0NPTlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCiAJCQkJCVRXQV9DT05UUk9MX1VOTUFT
 S19DT01NQU5EX0lOVEVSUlVQVCk7CiAJCQl9IGVsc2UKIAkJCQllcnJvciA9IFRXX09TTF9FQlVT
 WTsKIAkJfSBlbHNlIHsKLQkJCXR3X29zbF9jdGxyX2J1c3koY3Rscl9oYW5kbGUsIHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQllcnJvciA9IFRXX09TTF9FQlVTWTsKIAkJfQogCX0gZWxzZSB7CkBAIC0y
 NDYsNyArMjM5LDcgQEAKIAkJCQkJCSAoVFdfVUlOVDMyKShyZXEtPmNtZF9wa3RfcGh5cyArIHNp
 emVvZihzdHJ1Y3QgdHdfY2xfY29tbWFuZF9oZWFkZXIpKSwgNCk7CiAJCX0KIAl9Ci1vdXQ6CisK
 IAl0d19vc2xfZnJlZV9sb2NrKGN0bHJfaGFuZGxlLCBjdGxyLT5pb19sb2NrKTsKIAogCXJldHVy
 bihlcnJvcik7CkBAIC0yNzcsMTggKzI3MCwxMiBAQAogCVRXX1VJTlQ4CQkJCW9wY29kZTsKIAlU
 V19VSU5UOAkJCQlzZ2xfb2Zmc2V0OwogCVRXX1ZPSUQJCQkJCSpzZ2wgPSBUV19DTF9OVUxMOwot
 CVRXX0lOVDMyCQkJCWVycm9yOworCVRXX0lOVDMyCQkJCWVycm9yID0gVFdfQ0xfRVJSX1JFUV9T
 VUNDRVNTOwogCiAJdHdfY2xpX2RiZ19wcmludGYoNSwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJf
 ZnVuYygpLCAiZW50ZXJlZCIpOwogCiAJY3RsciA9IChzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4
 dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKIAotCWlmIChjdGxyLT5yZXNldF9pbl9w
 cm9ncmVzcykgewotCQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1
 cl9mdW5jKCksCi0JCQkiUGFzc3RocnUgcmVxdWVzdCBkdXJpbmcgcmVzZXQ6IHJldHVybmluZyBi
 dXN5LiIpOwotCQlyZXR1cm4oVFdfT1NMX0VCVVNZKTsKLQl9Ci0KIAlpZiAoKHJlcSA9IHR3X2Ns
 aV9nZXRfcmVxdWVzdChjdGxyCiAJCSkpID09IFRXX0NMX05VTEwpIHsKIAkJdHdfY2xpX2RiZ19w
 cmludGYoMiwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLApAQCAtMzAxLDcgKzI4OCw3
 IEBACiAJcmVxLT5vcmlnX3JlcSA9IHJlcV9wa3Q7CiAJcmVxLT50d19jbGlfY2FsbGJhY2sgPSB0
 d19jbGlfY29tcGxldGVfaW87CiAKLQlyZXEtPmZsYWdzIHw9IChUV19DTElfUkVRX0ZMQUdTX0VY
 VEVSTkFMIHwgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSk7CisJcmVxLT5mbGFncyB8PSBUV19D
 TElfUkVRX0ZMQUdTX1BBU1NUSFJVOwogCiAJcHRfcmVxID0gJihyZXFfcGt0LT5nZW5fcmVxX3Br
 dC5wdF9yZXEpOwogCkBAIC0zNDgsNyArMzM1LDEyIEBACiAJCXR3X2NsaV9maWxsX3NnX2xpc3Qo
 Y3RsciwgcHRfcmVxLT5zZ19saXN0LAogCQkJc2dsLCBwdF9yZXEtPnNnbF9lbnRyaWVzKTsKIAot
 CWlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgeworCWlmICgoKFRXX0NMX1Ff
 RklSU1RfSVRFTSgmKGN0bHItPnJlcV9xX2hlYWRbVFdfQ0xJX1BFTkRJTkdfUV0pKSkgIT0gVFdf
 Q0xfTlVMTCkgfHwKKwkJKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkgeworCQl0d19jbGlfcmVx
 X3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfUEVORElOR19RKTsKKwkJVFdfQ0xJX1dSSVRFX0NP
 TlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCisJCQlUV0FfQ09OVFJPTF9VTk1BU0tfQ09NTUFO
 RF9JTlRFUlJVUFQpOworCX0gZWxzZSBpZiAoKGVycm9yID0gdHdfY2xpX3N1Ym1pdF9jbWQocmVx
 KSkpIHsKIAkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCTB4MTEwMCwgMHgx
 LCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCkBAIC0zNzYsNyArMzY4LDcgQEAKICAqCQkJ
 bm9uLXplcm8tLSBmYWlsdXJlCiAgKi8KIFRXX0lOVDMyCi10d19jbF9pb2N0bChzdHJ1Y3QgdHdf
 Y2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLCBUV19JTlQzMiBjbWQsIFRXX1ZPSUQgKmJ1ZikK
 K3R3X2NsX2lvY3RsKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUsIHVfbG9u
 ZyBjbWQsIFRXX1ZPSUQgKmJ1ZikKIHsKIAlzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dAkqY3Rs
 ciA9CiAJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rs
 cl9jdHh0KTsKQEAgLTc2MCw4ICs3NTIsNyBAQAogCiAJY21kLT5wYXJhbS5zZ2xfb2ZmX19vcGNv
 ZGUgPQogCQlCVUlMRF9TR0xfT0ZGX19PUENPREUoMiwgVFdBX0ZXX0NNRF9HRVRfUEFSQU0pOwot
 CWNtZC0+cGFyYW0ucmVxdWVzdF9pZCA9Ci0JCShUV19VSU5UOCkoVFdfQ0xfU1dBUDE2KHJlcS0+
 cmVxdWVzdF9pZCkpOworCWNtZC0+cGFyYW0ucmVxdWVzdF9pZCA9IChUV19VSU5UOCkoVFdfQ0xf
 U1dBUDE2KHJlcS0+cmVxdWVzdF9pZCkpOwogCWNtZC0+cGFyYW0uaG9zdF9pZF9fdW5pdCA9IEJV
 SUxEX0hPU1RfSURfX1VOSVQoMCwgMCk7CiAJY21kLT5wYXJhbS5wYXJhbV9jb3VudCA9IFRXX0NM
 X1NXQVAxNigxKTsKIApAQCAtNzg5LDE1ICs3ODAsMTQgQEAKIAkJLyogVGhlcmUncyBubyBjYWxs
 IGJhY2s7IHdhaXQgdGlsbCB0aGUgY29tbWFuZCBjb21wbGV0ZXMuICovCiAJCWVycm9yID0gdHdf
 Y2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwKIAkJCQlUV19DTElfUkVRVUVTVF9USU1F
 T1VUX1BFUklPRCk7Ci0JCWlmIChlcnJvciA9PSBUV19PU0xfRVRJTUVET1VUKQotCQkJLyogQ2xl
 YW4tdXAgZG9uZSBieSB0d19jbGlfc3VibWl0X2FuZF9wb2xsX3JlcXVlc3QuICovCi0JCQlyZXR1
 cm4oZXJyb3IpOwogCQlpZiAoZXJyb3IpCiAJCQlnb3RvIG91dDsKIAkJaWYgKChlcnJvciA9IGNt
 ZC0+cGFyYW0uc3RhdHVzKSkgeworI2lmICAgICAgIDAKIAkJCXR3X2NsaV9jcmVhdGVfY3Rscl9l
 dmVudChjdGxyLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1IsCiAJ
 CQkJJihyZXEtPmNtZF9wa3QtPmNtZF9oZHIpKTsKKyNlbmRpZiAvLyAwCiAJCQlnb3RvIG91dDsK
 IAkJfQogCQl0d19vc2xfbWVtY3B5KHBhcmFtX2RhdGEsIHBhcmFtLT5kYXRhLCBwYXJhbV9zaXpl
 KTsKQEAgLTkwNSwxOCArODk1LDE3IEBACiAKIAkvKiBTdWJtaXQgdGhlIGNvbW1hbmQuICovCiAJ
 aWYgKGNhbGxiYWNrID09IFRXX0NMX05VTEwpIHsKLQkJLyogVGhlcmUncyBubyBjYWxsIGJhY2s7
 ICB3YWl0IHRpbGwgdGhlIGNvbW1hbmQgY29tcGxldGVzLiAqLworCQkvKiBUaGVyZSdzIG5vIGNh
 bGwgYmFjazsgd2FpdCB0aWxsIHRoZSBjb21tYW5kIGNvbXBsZXRlcy4gKi8KIAkJZXJyb3IgPSB0
 d19jbGlfc3VibWl0X2FuZF9wb2xsX3JlcXVlc3QocmVxLAotCQkJVFdfQ0xJX1JFUVVFU1RfVElN
 RU9VVF9QRVJJT0QpOwotCQlpZiAoZXJyb3IgPT0gVFdfT1NMX0VUSU1FRE9VVCkKLQkJCS8qIENs
 ZWFuLXVwIGRvbmUgYnkgdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0LiAqLwotCQkJcmV0
 dXJuKGVycm9yKTsKKwkJCQlUV19DTElfUkVRVUVTVF9USU1FT1VUX1BFUklPRCk7CiAJCWlmIChl
 cnJvcikKIAkJCWdvdG8gb3V0OwogCQlpZiAoKGVycm9yID0gY21kLT5wYXJhbS5zdGF0dXMpKSB7
 CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2NyZWF0ZV9jdGxyX2V2ZW50KGN0bHIsCiAJCQkJVFdf
 Q0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExFUl9FUlJPUiwKIAkJCQkmKHJlcS0+Y21kX3BrdC0+
 Y21kX2hkcikpOworI2VuZGlmIC8vIDAKIAkJCWdvdG8gb3V0OwogCQl9CiAJCWN0bHItPmludGVy
 bmFsX3JlcV9idXN5ID0gVFdfQ0xfRkFMU0U7CkBAIC0xMDIyLDkgKzEwMTEsNyBAQAogCSAqIHR3
 X2NsaV9zdWJtaXRfcGVuZGluZ19xdWV1ZS4gIFRoZXJlIGNvdWxkIGJlIGEgcmFjZSBpbiB0aGF0
 IGNhc2UuCiAJICogTmVlZCB0byByZXZpc2l0LgogCSAqLwotCWlmIChyZXEtPnN0YXRlICE9IFRX
 X0NMSV9SRVFfU1RBVEVfUEVORElORykKLQkJdHdfY2xfcmVzZXRfY3RscihjdGxyLT5jdGxyX2hh
 bmRsZSk7Ci0JZWxzZSB7CisJaWYgKHJlcS0+c3RhdGUgPT0gVFdfQ0xJX1JFUV9TVEFURV9QRU5E
 SU5HKSB7CiAJCXR3X2NsaV9kYmdfcHJpbnRmKDMsIGN0bHItPmN0bHJfaGFuZGxlLCB0d19vc2xf
 Y3VyX2Z1bmMoKSwKIAkJCSJSZW1vdmluZyByZXF1ZXN0IGZyb20gcGVuZGluZyBxdWV1ZSIpOwog
 CQkvKgpAQCAtMTA1Myw2ICsxMDQwLDcgQEAKICAqCQkJZHJhaW5zIGFueSBpbmNvbXBsZXRlIHJl
 cXVlc3RzLgogICoKICAqIElucHV0OgkJY3RscgktLSBwdHIgdG8gcGVyIGN0bHIgc3RydWN0dXJl
 CisgKiAJCQlyZXFfaGFuZGxlCS0tIHB0ciB0byByZXF1ZXN0IGhhbmRsZQogICogT3V0cHV0OgkJ
 Tm9uZQogICogUmV0dXJuIHZhbHVlOgkwCS0tIHN1Y2Nlc3MKICAqCQkJbm9uLXplcm8tLSBmYWls
 dXJlCkBAIC0xMDYzLDE1ICsxMDUxLDE1IEBACiAJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJ
 KmN0bHIgPQogCQkoc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQgKikoY3Rscl9oYW5kbGUtPmNs
 X2N0bHJfY3R4dCk7CiAJc3RydWN0IHR3YV9zb2Z0YwkJKnNjID0gY3Rscl9oYW5kbGUtPm9zbF9j
 dGxyX2N0eHQ7CisJc3RydWN0IHR3X2NsaV9yZXFfY29udGV4dAkqcmVxOwogCVRXX0lOVDMyCQkJ
 cmVzZXRfYXR0ZW1wdCA9IDE7Ci0JVFdfSU5UMzIJCQllcnJvcjsKKwlUV19JTlQzMgkJCWVycm9y
 ID0gMDsKIAogCXR3X2NsaV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1
 bmMoKSwgImVudGVyZWQiKTsKIAogCWN0bHItPnJlc2V0X2luX3Byb2dyZXNzID0gVFdfQ0xfVFJV
 RTsKLQl4cHRfZnJlZXplX3NpbXEoc2MtPnNpbSwgMSk7CisJdHdhX3RlYXJkb3duX2ludHIoc2Mp
 OwogCi0JdHdfY2xpX2Rpc2FibGVfaW50ZXJydXB0cyhjdGxyKTsKIAogCS8qCiAJICogRXJyb3Ig
 YmFjayBhbGwgcmVxdWVzdHMgaW4gdGhlIGNvbXBsZXRlLCBidXN5LCBhbmQgcGVuZGluZyBxdWV1
 ZXMuCkBAIC0xMDgwLDggKzEwNjgsNiBAQAogCSAqIHdpbGwgY29udGludWUgaXRzIGNvdXJzZSBh
 bmQgZ2V0IHN1Ym1pdHRlZCB0byB0aGUgY29udHJvbGxlciBhZnRlcgogCSAqIHRoZSByZXNldCBp
 cyBkb25lIChhbmQgaW9fbG9jayBpcyByZWxlYXNlZCkuCiAJICovCi0JdHdfY2xpX2RiZ19wcmlu
 dGYoMiwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLAotCQkiRHJhaW5pbmcgYWxsIHF1
 ZXVlcyBmb2xsb3dpbmcgcmVzZXQiKTsKIAl0d19jbGlfZHJhaW5fY29tcGxldGVfcXVldWUoY3Rs
 cik7CiAJdHdfY2xpX2RyYWluX2J1c3lfcXVldWUoY3Rscik7CiAJdHdfY2xpX2RyYWluX3BlbmRp
 bmdfcXVldWUoY3Rscik7CkBAIC0xMDg5LDUzICsxMDc1LDg4IEBACiAJY3Rsci0+Z2V0X21vcmVf
 YWVucyAgICAgPSBUV19DTF9GQUxTRTsKIAogCS8qIFNvZnQgcmVzZXQgdGhlIGNvbnRyb2xsZXIu
 ICovCi10cnlfcmVzZXQ6Ci0JaWYgKChlcnJvciA9IHR3X2NsaV9zb2Z0X3Jlc2V0KGN0bHIpKSkg
 ewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCi0JCQlUV19D
 TF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZFTlQsCi0JCQkweDExMDUsIDB4MSwgVFdf
 Q0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAotCQkJIkNvbnRyb2xsZXIgcmVzZXQgZmFpbGVkIiwK
 LQkJCSJlcnJvciA9ICVkOyBhdHRlbXB0ICVkIiwgZXJyb3IsIHJlc2V0X2F0dGVtcHQrKyk7Ci0J
 CWlmIChyZXNldF9hdHRlbXB0IDw9IFRXX0NMSV9NQVhfUkVTRVRfQVRURU1QVFMpCi0JCQlnb3Rv
 IHRyeV9yZXNldDsKLQkJZWxzZQotCQkJZ290byBvdXQ7Ci0JfQorCXdoaWxlIChyZXNldF9hdHRl
 bXB0IDw9IFRXX0NMSV9NQVhfUkVTRVRfQVRURU1QVFMpIHsKKwkJaWYgKChlcnJvciA9IHR3X2Ns
 aV9zb2Z0X3Jlc2V0KGN0bHIpKSkgeworCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxl
 LCBUV19DTF9GQUxTRSwKKwkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZF
 TlQsCisJCQkJMHgxMTA1LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKKwkJCQki
 Q29udHJvbGxlciByZXNldCBmYWlsZWQiLAorCQkJCSJlcnJvciA9ICVkOyBhdHRlbXB0ICVkIiwg
 ZXJyb3IsIHJlc2V0X2F0dGVtcHQrKyk7CisJCQlyZXNldF9hdHRlbXB0Kys7CisJCQljb250aW51
 ZTsKKwkJfQogCi0JLyogUmUtZXN0YWJsaXNoIGxvZ2ljYWwgY29ubmVjdGlvbiB3aXRoIHRoZSBj
 b250cm9sbGVyLiAqLwotCWlmICgoZXJyb3IgPSB0d19jbGlfaW5pdF9jb25uZWN0aW9uKGN0bHIs
 Ci0JCQkoVFdfVUlOVDE2KShjdGxyLT5tYXhfc2ltdWx0X3JlcXMpLAotCQkJMCwgMCwgMCwgMCwg
 MCwgVFdfQ0xfTlVMTCwgVFdfQ0xfTlVMTCwgVFdfQ0xfTlVMTCwKLQkJCVRXX0NMX05VTEwsIFRX
 X0NMX05VTEwpKSkgewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCS8qIFJlLWVzdGFibGlzaCBsb2dpY2FsIGNvbm5lY3Rpb24gd2l0aCB0aGUgY29udHJv
 bGxlci4gKi8KKwkJaWYgKChlcnJvciA9IHR3X2NsaV9pbml0X2Nvbm5lY3Rpb24oY3RsciwKKwkJ
 CQkoVFdfVUlOVDE2KShjdGxyLT5tYXhfc2ltdWx0X3JlcXMpLAorCQkJCTAsIDAsIDAsIDAsIDAs
 IFRXX0NMX05VTEwsIFRXX0NMX05VTEwsIFRXX0NMX05VTEwsCisJCQkJVFdfQ0xfTlVMTCwgVFdf
 Q0xfTlVMTCkpKSB7CisJCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZB
 TFNFLAorCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKKwkJCQkw
 eDExMDYsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAorCQkJCSJDYW4ndCBpbml0
 aWFsaXplIGNvbm5lY3Rpb24gYWZ0ZXIgcmVzZXQiLAorCQkJCSJlcnJvciA9ICVkIiwgZXJyb3Ip
 OworCQkJcmVzZXRfYXR0ZW1wdCsrOworCQkJY29udGludWU7CisJCX0KKworI2lmZGVmICAgIFRX
 X09TTF9ERUJVRworCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNF
 LAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAotCQkJMHgxMTA2
 LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCSJDYW4ndCBpbml0aWFsaXpl
 IGNvbm5lY3Rpb24gYWZ0ZXIgcmVzZXQiLAotCQkJImVycm9yID0gJWQiLCBlcnJvcik7Ci0JCWdv
 dG8gb3V0OwotCX0KKwkJCTB4MTEwNywgMHgzLCBUV19DTF9TRVZFUklUWV9JTkZPX1NUUklORywK
 KwkJCSJDb250cm9sbGVyIHJlc2V0IGRvbmUhIiwgIiAiKTsKKyNlbmRpZiAvKiBUV19PU0xfREVC
 VUcgKi8KKwkJYnJlYWs7CisJfSAvKiBFbmQgb2Ygd2hpbGUgKi8KIAotCXR3X2NsX2NyZWF0ZV9l
 dmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKLQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09N
 TU9OX0xBWUVSX0VWRU5ULAotCQkweDExMDcsIDB4MywgVFdfQ0xfU0VWRVJJVFlfSU5GT19TVFJJ
 TkcsCi0JCSJDb250cm9sbGVyIHJlc2V0IGRvbmUhIiwKLQkJIiAiKTsKKwkvKiBNb3ZlIGNvbW1h
 bmRzIGZyb20gdGhlIHJlc2V0IHF1ZXVlIHRvIHRoZSBwZW5kaW5nIHF1ZXVlLiAqLworCXdoaWxl
 ICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFkKGN0bHIsIFRXX0NMSV9SRVNFVF9RKSkg
 IT0gVFdfQ0xfTlVMTCkgeworCQl0d19vc2xfdGltZW91dChyZXEtPnJlcV9oYW5kbGUpOworCQl0
 d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfUEVORElOR19RKTsKKwl9CiAKLW91
 dDoKKwl0d2Ffc2V0dXBfaW50cihzYyk7CisJdHdfY2xpX2VuYWJsZV9pbnRlcnJ1cHRzKGN0bHIp
 OworCWlmICgoVFdfQ0xfUV9GSVJTVF9JVEVNKCYoY3Rsci0+cmVxX3FfaGVhZFtUV19DTElfUEVO
 RElOR19RXSkpKSAhPSBUV19DTF9OVUxMKQorCQlUV19DTElfV1JJVEVfQ09OVFJPTF9SRUdJU1RF
 UihjdGxyX2hhbmRsZSwKKwkJCVRXQV9DT05UUk9MX1VOTUFTS19DT01NQU5EX0lOVEVSUlVQVCk7
 CiAJY3Rsci0+cmVzZXRfaW5fcHJvZ3Jlc3MgPSBUV19DTF9GQUxTRTsKLQl4cHRfcmVsZWFzZV9z
 aW1xKHNjLT5zaW0sIDEpOworCWN0bHItPnJlc2V0X25lZWRlZCA9IFRXX0NMX0ZBTFNFOwogCi0J
 LyoKLQkgKiBFbmFibGUgaW50ZXJydXB0cywgYW5kIGFsc28gY2xlYXIgYXR0ZW50aW9uIGFuZCBy
 ZXNwb25zZSBpbnRlcnJ1cHRzLgotCSAqLwotCXR3X2NsaV9lbmFibGVfaW50ZXJydXB0cyhjdGxy
 KTsKLQkKIAkvKiBSZXF1ZXN0IGZvciBhIGJ1cyByZS1zY2FuLiAqLwotCWlmICghZXJyb3IpCi0J
 CXR3X29zbF9zY2FuX2J1cyhjdGxyX2hhbmRsZSk7CisJdHdfb3NsX3NjYW5fYnVzKGN0bHJfaGFu
 ZGxlKTsKKwogCXJldHVybihlcnJvcik7CiB9CiAKK1RXX1ZPSUQKK3R3X2NsX3NldF9yZXNldF9u
 ZWVkZWQoc3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSkKK3sKKwlzdHJ1Y3Qg
 dHdfY2xpX2N0bHJfY29udGV4dAkqY3RsciA9CisJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4
 dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKKworCWN0bHItPnJlc2V0X25lZWRlZCA9
 IFRXX0NMX1RSVUU7Cit9CisKK1RXX0lOVDMyCit0d19jbF9pc19yZXNldF9uZWVkZWQoc3RydWN0
 IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSkKK3sKKwlzdHJ1Y3QgdHdfY2xpX2N0bHJf
 Y29udGV4dAkqY3RsciA9CisJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dCAqKShjdGxyX2hh
 bmRsZS0+Y2xfY3Rscl9jdHh0KTsKKworCXJldHVybihjdGxyLT5yZXNldF9uZWVkZWQpOworfQor
 CitUV19JTlQzMgordHdfY2xfaXNfYWN0aXZlKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rs
 cl9oYW5kbGUpCit7CisJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJKmN0bHIgPQorCQkoc3Ry
 dWN0IHR3X2NsaV9jdGxyX2NvbnRleHQgKikKKwkJKGN0bHJfaGFuZGxlLT5jbF9jdGxyX2N0eHQp
 OworCisJCXJldHVybihjdGxyLT5hY3RpdmUpOworfQorCiAKIAogLyoKQEAgLTExNTEsMTQgKzEx
 NzIsMTMgQEAKIHR3X2NsaV9zb2Z0X3Jlc2V0KHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICpj
 dGxyKQogewogCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZQkqY3Rscl9oYW5kbGUgPSBjdGxyLT5j
 dGxyX2hhbmRsZTsKLQlUV19VSU5UMzIJCQlzdGF0dXNfcmVnOwogCWludAkJCQlmb3VuZDsKIAlp
 bnQJCQkJbG9vcF9jb3VudDsKIAlUV19VSU5UMzIJCQllcnJvcjsKIAogCXR3X2NsaV9kYmdfcHJp
 bnRmKDEsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwgImVudGVyZWQiKTsKIAotCXR3
 X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKKwl0d19jbF9jcmVhdGVf
 ZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCiAJCTB4MTEwOCwgMHgzLCBUV19DTF9TRVZFUklUWV9JTkZPX1NU
 UklORywKIAkJIlJlc2V0dGluZyBjb250cm9sbGVyLi4uIiwKQEAgLTExOTMsNyArMTIxMyw3IEBA
 CiAJCX0gd2hpbGUgKCFmb3VuZCAmJiAobG9vcF9jb3VudCA8IDYwMDAwMDApKTsgLyogTG9vcCBm
 b3Igbm8gbW9yZSB0aGFuIDYwIHNlY29uZHMgKi8KIAogCQlpZiAoIWZvdW5kKSB7Ci0JCQl0d19j
 bF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCisJCQl0d19jbF9jcmVhdGVf
 ZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNF
 X0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCQkweDExMDksIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJS
 T1JfU1RSSU5HLAogCQkJCSJNaXNzZWQgZmlybXdhcmUgaGFuZHNoYWtlIGFmdGVyIHNvZnQtcmVz
 ZXQiLApAQCAtMTIxMCw3ICsxMjMwLDcgQEAKIAkJCVRXQV9TVEFUVVNfTUlDUk9DT05UUk9MTEVS
 X1JFQURZIHwKIAkJCVRXQV9TVEFUVVNfQVRURU5USU9OX0lOVEVSUlVQVCwKIAkJCVRXX0NMSV9S
 RVNFVF9USU1FT1VUX1BFUklPRCkpKSB7Ci0JCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRs
 ZSwgVFdfQ0xfVFJVRSwKKwkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9G
 QUxTRSwKIAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCTB4
 MTEwOSwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkiTWljcm8tY3RsciBu
 b3QgcmVhZHkvTm8gYXR0biBpbnRyIGFmdGVyIHJlc2V0IiwKQEAgLTEyNDQsMjYgKzEyNjQsMTQg
 QEAKIAl9CiAJCiAJaWYgKChlcnJvciA9IHR3X2NsaV9maW5kX2FlbihjdGxyLCBUV0FfQUVOX1NP
 RlRfUkVTRVQpKSkgewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQlU
 V19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZFTlQsCiAJCQkweDExMEMsIDB4MSwg
 VFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAogCQkJIlJlc2V0IG5vdCByZXBvcnRlZCBieSBj
 b250cm9sbGVyIiwKIAkJCSJlcnJvciA9ICVkIiwgZXJyb3IpOwogCQlyZXR1cm4oZXJyb3IpOwog
 CX0KLQkKLQlzdGF0dXNfcmVnID0gVFdfQ0xJX1JFQURfU1RBVFVTX1JFR0lTVEVSKGN0bHJfaGFu
 ZGxlKTsKLQkKLQlpZiAoKGVycm9yID0gVFdfQ0xJX1NUQVRVU19FUlJPUlMoc3RhdHVzX3JlZykp
 IHx8Ci0JCQkoZXJyb3IgPSB0d19jbGlfY2hlY2tfY3Rscl9zdGF0ZShjdGxyLCBzdGF0dXNfcmVn
 KSkpIHsKLQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAotCQkJ
 VFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAotCQkJMHgxMTBELCAweDEs
 IFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCSJDb250cm9sbGVyIGVycm9ycyBkZXRl
 Y3RlZCBhZnRlciByZXNldCIsCi0JCQkiZXJyb3IgPSAlZCIsIGVycm9yKTsKLQkJcmV0dXJuKGVy
 cm9yKTsKLQl9Ci0JCisKIAlyZXR1cm4oVFdfT1NMX0VTVUNDRVNTKTsKIH0KIApkaWZmIC11IEZy
 ZWVCU0RfUkVMRU5HXzhfdHdhX2N2cy90d19jbF9taXNjLmMgRnJlZUJTRDhfdHdhXzNfODBfMDZf
 MDAzL3R3X2NsX21pc2MuYwotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3ZzL3R3X2NsX21pc2Mu
 YwkyMDEwLTA4LTI2IDE1OjM1OjIwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRDhfdHdhXzNf
 ODBfMDZfMDAzL3R3X2NsX21pc2MuYwkyMDEwLTA4LTI0IDE4OjAxOjQ0LjAwMDAwMDAwMCAtMDcw
 MApAQCAtODMsNyArODMsOCBAQAogCXR3X2NsaV9kYmdfcHJpbnRmKDMsIGN0bHItPmN0bHJfaGFu
 ZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwgImVudGVyZWQiKTsKIAogCS8qIFdhbGsgdGhlIGJ1c3kg
 cXVldWUuICovCi0Jd2hpbGUgKChyZXEgPSB0d19jbGlfcmVxX3FfcmVtb3ZlX2hlYWQoY3Rsciwg
 VFdfQ0xJX0NPTVBMRVRFX1EpKSkgeworCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92
 ZV9oZWFkKGN0bHIsIFRXX0NMSV9DT01QTEVURV9RKSkgIT0KKwkJVFdfQ0xfTlVMTCkgewogCQlp
 ZiAocmVxLT5mbGFncyAmIFRXX0NMSV9SRVFfRkxBR1NfSU5URVJOQUwpIHsKIAkJCS8qCiAJCQkg
 KiBJdCdzIGFuIGludGVybmFsIHJlcXVlc3QuICBTZXQgdGhlIGFwcHJvcHJpYXRlCkBAIC05Nywy
 MCArOTgsMjEgQEAKIAkJCXJlcS0+ZXJyb3JfY29kZSA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VU
 OwogCQkJaWYgKHJlcS0+dHdfY2xpX2NhbGxiYWNrKQogCQkJCXJlcS0+dHdfY2xpX2NhbGxiYWNr
 KHJlcSk7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAoKHJlcV9wa3QgPSByZXEtPm9yaWdfcmVxKSkgewot
 CQkJCS8qIEl0J3MgYSBTQ1NJIHJlcXVlc3QuICBDb21wbGV0ZSBpdC4gKi8KLQkJCQl0d19jbGlf
 ZGJnX3ByaW50ZigyLCBjdGxyLT5jdGxyX2hhbmRsZSwKLQkJCQkJdHdfb3NsX2N1cl9mdW5jKCks
 Ci0JCQkJCSJDb21wbGV0aW5nIGNvbXBsZXRlIHJlcXVlc3QgJXAgIgotCQkJCQkib24gcmVzZXQi
 LAotCQkJCQlyZXEpOworCQl9IGVsc2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdT
 X1BBU1NUSFJVKSB7CisJCQkvKiBJdCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0
 LiAqLworCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewog
 CQkJCXJlcV9wa3QtPnN0YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9w
 a3QtPnR3X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3Qt
 PnR3X29zbF9jYWxsYmFjaykKKwkJCQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQl9CiAJCQl0d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElf
 RlJFRV9RKTsKKwkJfSBlbHNlIHsKKwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVl
 c3QuICBBZGQgaXQgdG8gdGhlIHJlc2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChy
 ZXEtPnJlcV9oYW5kbGUpOworCQkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X1JFU0VUX1EpOwogCQl9Ci0JfQorCX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBA
 IC0xMzUsNyArMTM3LDggQEAKIAl0d19jbGlfZGJnX3ByaW50ZigzLCBjdGxyLT5jdGxyX2hhbmRs
 ZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7CiAKIAkvKiBXYWxrIHRoZSBidXN5IHF1
 ZXVlLiAqLwotCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFkKGN0bHIsIFRX
 X0NMSV9CVVNZX1EpKSkgeworCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFk
 KGN0bHIsIFRXX0NMSV9CVVNZX1EpKSAhPQorCQlUV19DTF9OVUxMKSB7CiAJCWlmIChyZXEtPmZs
 YWdzICYgVFdfQ0xJX1JFUV9GTEFHU19JTlRFUk5BTCkgewogCQkJLyoKIAkJCSAqIEl0J3MgYW4g
 aW50ZXJuYWwgcmVxdWVzdC4gIFNldCB0aGUgYXBwcm9wcmlhdGUKQEAgLTE0OSwxOSArMTUyLDIx
 IEBACiAJCQlyZXEtPmVycm9yX2NvZGUgPSBUV19DTF9FUlJfUkVRX0JVU19SRVNFVDsKIAkJCWlm
 IChyZXEtPnR3X2NsaV9jYWxsYmFjaykKIAkJCQlyZXEtPnR3X2NsaV9jYWxsYmFjayhyZXEpOwot
 CQl9IGVsc2UgewotCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkpIHsKLQkJCQkvKiBJ
 dCdzIGEgU0NTSSByZXF1ZXN0LiAgQ29tcGxldGUgaXQuICovCi0JCQkJdHdfY2xpX2RiZ19wcmlu
 dGYoMiwgY3Rsci0+Y3Rscl9oYW5kbGUsCi0JCQkJCXR3X29zbF9jdXJfZnVuYygpLAotCQkJCQki
 Q29tcGxldGluZyBidXN5IHJlcXVlc3QgJXAgb24gcmVzZXQiLAotCQkJCQlyZXEpOworCQl9IGVs
 c2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdTX1BBU1NUSFJVKSB7CisJCQkvKiBJ
 dCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0LiAqLworCQkJaWYgKChyZXFfcGt0
 ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewogCQkJCXJlcV9wa3QtPnN0YXR1cyA9
 IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9wa3QtPnR3X29zbF9jYWxsYmFjayhy
 ZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3QtPnR3X29zbF9jYWxsYmFjaykKKwkJ
 CQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVxX2hhbmRsZSk7CiAJCQl9CiAJCQl0
 d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfRlJFRV9RKTsKKwkJfSBlbHNlIHsK
 KwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVlc3QuICBBZGQgaXQgdG8gdGhlIHJl
 c2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChyZXEtPnJlcV9oYW5kbGUpOworCQkJ
 dHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJX1JFU0VUX1EpOwogCQl9Ci0JfQor
 CX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBAIC0xODgsNyArMTkzLDggQEAKIAkv
 KgogCSAqIFB1bGwgcmVxdWVzdHMgb2ZmIHRoZSBwZW5kaW5nIHF1ZXVlLCBhbmQgY29tcGxldGUg
 dGhlbS4KIAkgKi8KLQl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFfcV9yZW1vdmVfaGVhZChjdGxy
 LCBUV19DTElfUEVORElOR19RKSkpIHsKKwl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFfcV9yZW1v
 dmVfaGVhZChjdGxyLCBUV19DTElfUEVORElOR19RKSkgIT0KKwkJVFdfQ0xfTlVMTCkgewogCQlp
 ZiAocmVxLT5mbGFncyAmIFRXX0NMSV9SRVFfRkxBR1NfSU5URVJOQUwpIHsKIAkJCS8qCiAJCQkg
 KiBJdCdzIGFuIGludGVybmFsIHJlcXVlc3QuICBTZXQgdGhlIGFwcHJvcHJpYXRlCkBAIC0yMDIs
 MTkgKzIwOCwyMSBAQAogCQkJcmVxLT5lcnJvcl9jb2RlID0gVFdfQ0xfRVJSX1JFUV9CVVNfUkVT
 RVQ7CiAJCQlpZiAocmVxLT50d19jbGlfY2FsbGJhY2spCiAJCQkJcmVxLT50d19jbGlfY2FsbGJh
 Y2socmVxKTsKLQkJfSBlbHNlIHsKLQkJCWlmICgocmVxX3BrdCA9IHJlcS0+b3JpZ19yZXEpKSB7
 Ci0JCQkJLyogSXQncyBhbiBleHRlcm5hbCByZXF1ZXN0LiAgQ29tcGxldGUgaXQuICovCi0JCQkJ
 dHdfY2xpX2RiZ19wcmludGYoMiwgY3Rsci0+Y3Rscl9oYW5kbGUsCi0JCQkJCXR3X29zbF9jdXJf
 ZnVuYygpLAotCQkJCQkiQ29tcGxldGluZyBwZW5kaW5nIHJlcXVlc3QgJXAgIgotCQkJCQkib24g
 cmVzZXQiLCByZXEpOworCQl9IGVsc2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdT
 X1BBU1NUSFJVKSB7CisJCQkvKiBJdCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0
 LiAqLworCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewog
 CQkJCXJlcV9wa3QtPnN0YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9w
 a3QtPnR3X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3Qt
 PnR3X29zbF9jYWxsYmFjaykKKwkJCQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQl9CiAJCQl0d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElf
 RlJFRV9RKTsKKwkJfSBlbHNlIHsKKwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVl
 c3QuICBBZGQgaXQgdG8gdGhlIHJlc2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChy
 ZXEtPnJlcV9oYW5kbGUpOworCQkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X1JFU0VUX1EpOwogCQl9Ci0JfQorCX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBA
 IC0yMzksOSArMjQ3LDYgQEAKIAlmb3IgKDs7KSB7CiAJCXN0YXR1c19yZWcgPSBUV19DTElfUkVB
 RF9TVEFUVVNfUkVHSVNURVIoY3Rsci0+Y3Rscl9oYW5kbGUpOwogCi0JCWlmICh0d19jbGlfY2hl
 Y2tfY3Rscl9zdGF0ZShjdGxyLCBzdGF0dXNfcmVnKSkKLQkJCXJldHVybihUV19PU0xfRUdFTkZB
 SUxVUkUpOwotCiAJCWlmIChzdGF0dXNfcmVnICYgVFdBX1NUQVRVU19SRVNQT05TRV9RVUVVRV9F
 TVBUWSkKIAkJCXJldHVybihUV19PU0xfRVNVQ0NFU1MpOyAvKiBubyBtb3JlIHJlc3BvbnNlIHF1
 ZXVlIGVudHJpZXMgKi8KIApAQCAtMjczLDkgKzI3OCw2IEBACiAJZm9yICg7OykgewogCQlzdGF0
 dXNfcmVnID0gVFdfQ0xJX1JFQURfU1RBVFVTX1JFR0lTVEVSKGN0bHItPmN0bHJfaGFuZGxlKTsK
 IAotCQlpZiAodHdfY2xpX2NoZWNrX2N0bHJfc3RhdGUoY3Rsciwgc3RhdHVzX3JlZykpCi0JCQly
 ZXR1cm4oVFdfT1NMX0VHRU5GQUlMVVJFKTsKLQogCQlpZiAoc3RhdHVzX3JlZyAmIFRXQV9TVEFU
 VVNfUkVTUE9OU0VfUVVFVUVfRU1QVFkpCiAJCQlyZXR1cm4oVFdfT1NMX0VOT1RUWSk7IC8qIG5v
 IG1vcmUgcmVzcG9uc2UgcXVldWUgZW50cmllcyAqLwogCkBAIC0zNTYsOSArMzU4LDExIEBACiAK
 IAkJaWYgKChlcnJvciA9IHJlcS0+Y21kX3BrdC0+Y29tbWFuZC5jbWRfcGt0XzlrLnN0YXR1cykp
 IHsKIAkJCWNtZF9oZHIgPSAmcmVxLT5jbWRfcGt0LT5jbWRfaGRyOworI2lmICAgICAgIDAKIAkJ
 CXR3X2NsaV9jcmVhdGVfY3Rscl9ldmVudChjdGxyLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNF
 X0NPTlRST0xMRVJfRVJST1IsCiAJCQkJY21kX2hkcik7CisjZW5kaWYgLy8gMAogCQkJYnJlYWs7
 CiAJCX0KIApAQCAtNzE0LDcgKzcxOCw3IEBACiAKIAkJdHdfb3NsX21lbXplcm8oZGVzYywgMjAw
 KTsKIAkJaWYgKCEoY3Rsci0+cmVzZXRfcGhhc2UxX2luX3Byb2dyZXNzKSkgewotCQkJdHdfY2xf
 Y3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQkJdHdfY2xfY3JlYXRlX2V2
 ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCiAJCQkJMHgxMzAxLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9S
 X1NUUklORywKIAkJCQkiTWlzc2luZyBleHBlY3RlZCBzdGF0dXMgYml0KHMpIiwKQEAgLTczOCw3
 ICs3NDIsNyBAQAogCQkgICAgIChjdGxyLT5kZXZpY2VfaWQgIT0gVFdfQ0xfREVWSUNFX0lEXzlL
 X1NBKSkgfHwKIAkJICAgICghKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkgfHwKIAkJICAgICgo
 c3RhdHVzX3JlZyAmIFRXQV9TVEFUVVNfUVVFVUVfRVJST1JfSU5URVJSVVBUKSA9PSAwKSkKLQkJ
 dHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQl0d19jbF9jcmVh
 dGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJMHgxMzAyLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VS
 Uk9SX1NUUklORywKIAkJCSJVbmV4cGVjdGVkIHN0YXR1cyBiaXQocykiLApAQCAtNzQ4LDcgKzc1
 Miw3IEBACiAJCQkJVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMsIGRlc2MpKTsKIAogCQlpZiAo
 c3RhdHVzX3JlZyAmIFRXQV9TVEFUVVNfUENJX1BBUklUWV9FUlJPUl9JTlRFUlJVUFQpIHsKLQkJ
 CXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKKwkJCXR3X2NsX2Ny
 ZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9T
 T1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJCTB4MTMwMywgMHgxLCBUV19DTF9TRVZFUklU
 WV9FUlJPUl9TVFJJTkcsCiAJCQkJIlBDSSBwYXJpdHkgZXJyb3I6IGNsZWFyaW5nLi4uICIKQEAg
 LTc2OCw3ICs3NzIsNyBAQAogCQl9CiAKIAkJaWYgKHN0YXR1c19yZWcgJiBUV0FfU1RBVFVTX1BD
 SV9BQk9SVF9JTlRFUlJVUFQpIHsKLQkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwg
 VFdfQ0xfVFJVRSwKKwkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFM
 U0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJCTB4
 MTMwNCwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkJIlBDSSBhYm9ydDog
 Y2xlYXJpbmcuLi4gIiwKQEAgLTc5MSw3ICs3OTUsNyBAQAogCQkJaWYgKCgoY3Rsci0+ZGV2aWNl
 X2lkICE9IFRXX0NMX0RFVklDRV9JRF85S19FKSAmJgogCQkJICAgICAoY3Rsci0+ZGV2aWNlX2lk
 ICE9IFRXX0NMX0RFVklDRV9JRF85S19TQSkpIHx8CiAJCQkgICAgKCEoY3Rsci0+cmVzZXRfaW5f
 cHJvZ3Jlc3MpKSkKLQkJCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CQkJCSAgIFRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCQkJCSAg
 IDB4MTMwNSwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkJCQkgICAiQ29u
 dHJvbGxlciBxdWV1ZSBlcnJvcjogY2xlYXJpbmcuLi4gIiwKQEAgLTgwMSwxNyArODA1LDYgQEAK
 IAkJCVRXX0NMSV9XUklURV9DT05UUk9MX1JFR0lTVEVSKGN0bHItPmN0bHJfaGFuZGxlLAogCQkJ
 CVRXQV9DT05UUk9MX0NMRUFSX1FVRVVFX0VSUk9SKTsKIAkJfQotCi0JCWlmIChzdGF0dXNfcmVn
 ICYgVFdBX1NUQVRVU19NSUNST0NPTlRST0xMRVJfRVJST1IpIHsKLQkJCXR3X2NsX2NyZWF0ZV9l
 dmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKLQkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCi0JCQkJMHgxMzA3LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9S
 X1NUUklORywKLQkJCQkiTWljcm8tY29udHJvbGxlciBlcnJvciEgIiwKLQkJCQkic3RhdHVzIHJl
 ZyA9IDB4JXggJXMiLAotCQkJCXN0YXR1c19yZWcsCi0JCQkJdHdfY2xpX2Rlc2NyaWJlX2JpdHMo
 c3RhdHVzX3JlZywgZGVzYykpOwotCQkJZXJyb3IgPSBUV19PU0xfRUdFTkZBSUxVUkU7Ci0JCX0K
 IAl9CiAJcmV0dXJuKGVycm9yKTsKIH0JCkBAIC04NTAsOCArODQzLDYgQEAKIAkJdHdfb3NsX3N0
 cmNweSgmc3RyW3R3X29zbF9zdHJsZW4oc3RyKV0sICJIT1NUX0lOVFIsIik7CiAJaWYgKHJlZyAm
 IFRXQV9TVEFUVVNfUENJX0FCT1JUX0lOVEVSUlVQVCkKIAkJdHdfb3NsX3N0cmNweSgmc3RyW3R3
 X29zbF9zdHJsZW4oc3RyKV0sICJQQ0lfQUJSVCwiKTsKLQlpZiAocmVnICYgVFdBX1NUQVRVU19N
 SUNST0NPTlRST0xMRVJfRVJST1IpCi0JCXR3X29zbF9zdHJjcHkoJnN0clt0d19vc2xfc3RybGVu
 KHN0cildLCAiTUNfRVJSLCIpOwogCWlmIChyZWcgJiBUV0FfU1RBVFVTX1FVRVVFX0VSUk9SX0lO
 VEVSUlVQVCkKIAkJdHdfb3NsX3N0cmNweSgmc3RyW3R3X29zbF9zdHJsZW4oc3RyKV0sICJRX0VS
 UiwiKTsKIAlpZiAocmVnICYgVFdBX1NUQVRVU19QQ0lfUEFSSVRZX0VSUk9SX0lOVEVSUlVQVCkK
 ZGlmZiAtdSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfY2xfc2hhcmUuaCBGcmVlQlNEOF90
 d2FfM184MF8wNl8wMDMvdHdfY2xfc2hhcmUuaAotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3Zz
 L3R3X2NsX3NoYXJlLmgJMjAxMC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZy
 ZWVCU0Q4X3R3YV8zXzgwXzA2XzAwMy90d19jbF9zaGFyZS5oCTIwMTAtMDgtMjQgMTg6MDE6NDQu
 MDAwMDAwMDAwIC0wNzAwCkBAIC0zNDksMTAgKzM0OSwxNCBAQAogI2VuZGlmCiAKIAotI2lmbmRl
 ZiB0d19vc2xfY3Rscl9idXN5Ci0vKiBDYWxsZWQgd2hlbiBDTCBpcyB0b28gYnVzeSB0byBhY2Nl
 cHQgbmV3IHJlcXVlc3RzLiAqLwotZXh0ZXJuIFRXX1ZPSUQJdHdfb3NsX2N0bHJfYnVzeShzdHJ1
 Y3QgdHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLAotCXN0cnVjdCB0d19jbF9yZXFfaGFu
 ZGxlICpyZXFfaGFuZGxlKTsKKyNpZm5kZWYgdHdfb3NsX3RpbWVvdXQKKy8qIFN0YXJ0IE9TIHRp
 bWVvdXQoKSByb3V0aW5lIGFmdGVyIGNvbnRyb2xsZXIgcmVzZXQgc2VxdWVuY2UgKi8KK2V4dGVy
 biBUV19WT0lECXR3X29zbF90aW1lb3V0KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFu
 ZGxlKTsKKyNlbmRpZgorCisjaWZuZGVmIHR3X29zbF91bnRpbWVvdXQKKy8qIFN0b3AgT1MgdGlt
 ZW91dCgpIHJvdXRpbmUgZHVyaW5nIGNvbnRyb2xsZXIgcmVzZXQgc2VxdWVuY2UgKi8KK2V4dGVy
 biBUV19WT0lECXR3X29zbF91bnRpbWVvdXQoc3RydWN0IHR3X2NsX3JlcV9oYW5kbGUgKnJlcV9o
 YW5kbGUpOwogI2VuZGlmCiAKIApAQCAtNTUyLDEzICs1NTYsMTcgQEAKIAkpOwogCiAKK2V4dGVy
 biBUV19WT0lEICB0d19jbF9zZXRfcmVzZXRfbmVlZGVkKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRs
 ZSAqY3Rscl9oYW5kbGUpOworZXh0ZXJuIFRXX0lOVDMyIHR3X2NsX2lzX3Jlc2V0X25lZWRlZChz
 dHJ1Y3QgdHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlKTsKK2V4dGVybiBUV19JTlQzMiB0
 d19jbF9pc19hY3RpdmUoc3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSk7CisK
 IC8qIENMJ3MgaW50ZXJydXB0IGhhbmRsZXIuICovCiBleHRlcm4gVFdfSU5UMzIJdHdfY2xfaW50
 ZXJydXB0KHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUpOwogCiAKIC8qIENM
 J3MgaW9jdGwgaGFuZGxlci4gKi8KIGV4dGVybiBUV19JTlQzMgl0d19jbF9pb2N0bChzdHJ1Y3Qg
 dHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLAotCVRXX0lOVDMyIGNtZCwgVFdfVk9JRCAq
 YnVmKTsKKwl1X2xvbmcgY21kLCBUV19WT0lEICpidWYpOwogCiAKICNpZmRlZiBUV19PU0xfREVC
 VUcKZGlmZiAtdSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfb3NsLmggRnJlZUJTRDhfdHdh
 XzNfODBfMDZfMDAzL3R3X29zbC5oCi0tLSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfb3Ns
 LmgJMjAxMC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q4X3R3YV8z
 XzgwXzA2XzAwMy90d19vc2wuaAkyMDEwLTA4LTI0IDE4OjAxOjQ0LjAwMDAwMDAwMCAtMDcwMApA
 QCAtNzcsNiArNzcsNyBAQAogCQkJCQkJRUlOUFJPR1JFU1MgKi8KICNkZWZpbmUgVFdfT1NMSV9S
 RVFfRkxBR1NfUEFTU1RIUlUJKDE8PDUpCS8qIHBhc3MgdGhyb3VnaCByZXF1ZXN0ICovCiAjZGVm
 aW5lIFRXX09TTElfUkVRX0ZMQUdTX1NMRUVQSU5HCSgxPDw2KQkvKiBvd25lciBzbGVlcGluZyBv
 biB0aGlzIGNtZCAqLworI2RlZmluZSBUV19PU0xJX1JFUV9GTEFHU19GQUlMRUQJKDE8PDcpCS8q
 IGJ1c19kbWFtYXBfbG9hZCgpIGZhaWxlZCAqLwogCiAKICNpZmRlZiBUV19PU0xfREVCVUcKQEAg
 LTEwMCw2ICsxMDEsNyBAQAogCXN0cnVjdCB0d2Ffc29mdGMJKmN0bHI7CS8qIHB0ciB0byBPU0wn
 cyBjb250cm9sbGVyIGNvbnRleHQgKi8KIAlUV19WT0lECQkJKmRhdGE7CS8qIHB0ciB0byBkYXRh
 IGJlaW5nIHBhc3NlZCB0byBDTCAqLwogCVRXX1VJTlQzMgkJbGVuZ3RoOwkvKiBsZW5ndGggb2Yg
 YnVmIGJlaW5nIHBhc3NlZCB0byBDTCAqLworCVRXX1VJTlQ2NAkJZGVhZGxpbmU7LyogcmVxdWVz
 dCB0aW1lb3V0IChpbiBhYnNvbHV0ZSB0aW1lKSAqLwogCiAJLyoKIAkgKiBwdHIgdG8sIGFuZCBs
 ZW5ndGggb2YgZGF0YSBwYXNzZWQgdG8gdXMgZnJvbSBhYm92ZSwgaW4gY2FzZSBhIGJ1ZmZlcgpA
 QCAtMTUxLDYgKzE1Myw5IEBACiAJc3RydWN0IG10eAkJc2ltX2xvY2tfaGFuZGxlOy8qIHNpbSBs
 b2NrIHNoYXJlZCB3aXRoIGNhbSAqLwogCXN0cnVjdCBtdHgJCSpzaW1fbG9jazsvKiBwdHIgdG8g
 c2ltIGxvY2sgKi8KIAorCXN0cnVjdCBjYWxsb3V0CQl3YXRjaGRvZ19jYWxsb3V0WzJdOyAvKiBG
 b3IgY29tbWFuZCB0aW1vdXQgKi8KKwlUV19VSU5UMzIJCXdhdGNoZG9nX2luZGV4OworCiAjaWZk
 ZWYgVFdfT1NMX0RFQlVHCiAJc3RydWN0IHR3X29zbGlfcV9zdGF0cwlxX3N0YXRzW1RXX09TTElf
 UV9DT1VOVF07LyogcXVldWUgc3RhdGlzdGljcyAqLwogI2VuZGlmIC8qIFRXX09TTF9ERUJVRyAq
 LwpkaWZmIC11IEZyZWVCU0RfUkVMRU5HXzhfdHdhX2N2cy90d19vc2xfY2FtLmMgRnJlZUJTRDhf
 dHdhXzNfODBfMDZfMDAzL3R3X29zbF9jYW0uYwotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3Zz
 L3R3X29zbF9jYW0uYwkyMDEwLTA4LTI2IDE1OjM1OjIwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJl
 ZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3X29zbF9jYW0uYwkyMDEwLTA4LTI0IDE4OjAxOjQ0LjAw
 MDAwMDAwMCAtMDcwMApAQCAtNTUsNyArNTUsNiBAQAogCiBzdGF0aWMgVFdfVk9JRAl0d2FfYWN0
 aW9uKHN0cnVjdCBjYW1fc2ltICpzaW0sIHVuaW9uIGNjYiAqY2NiKTsKIHN0YXRpYyBUV19WT0lE
 CXR3YV9wb2xsKHN0cnVjdCBjYW1fc2ltICpzaW0pOwotc3RhdGljIFRXX1ZPSUQJdHdhX3RpbWVv
 dXQoVFdfVk9JRCAqYXJnKTsKIAogc3RhdGljIFRXX0lOVDMyCXR3X29zbGlfZXhlY3V0ZV9zY3Np
 KHN0cnVjdCB0d19vc2xpX3JlcV9jb250ZXh0ICpyZXEsCiAJdW5pb24gY2NiICpjY2IpOwpAQCAt
 ODEsNyArODAsNyBAQAogCS8qCiAJICogQ3JlYXRlIHRoZSBkZXZpY2UgcXVldWUgZm9yIG91ciBT
 SU0uCiAJICovCi0JaWYgKChkZXZxID0gY2FtX3NpbXFfYWxsb2MoVFdfT1NMSV9NQVhfTlVNX1JF
 UVVFU1RTKSkgPT0gTlVMTCkgeworCWlmICgoZGV2cSA9IGNhbV9zaW1xX2FsbG9jKFRXX09TTElf
 TUFYX05VTV9JT1MpKSA9PSBOVUxMKSB7CiAJCXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAl
 ZCIsCiAJCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQlUV19DTF9NRVNTQUdFX1NP
 VVJDRV9GUkVFQlNEX0RSSVZFUiwKQEAgLTI3NSw2ICsyNzQsNyBAQAogCQkJCQkiSS9PIHNpemUg
 dG9vIGJpZyIsCiAJCQkJCWNzaW8tPmR4ZmVyX2xlbik7CiAJCQkJY2NiX2gtPnN0YXR1cyA9IENB
 TV9SRVFfVE9PX0JJRzsKKwkJCQljY2JfaC0+c3RhdHVzICY9IH5DQU1fU0lNX1FVRVVFRDsKIAkJ
 CQl4cHRfZG9uZShjY2IpOwogCQkJCXJldHVybigxKTsKIAkJCX0KQEAgLTI5MCw2ICsyOTAsNyBA
 QAogCQkJCTB4MjEwNywKIAkJCQkiWFBUX1NDU0lfSU86IEdvdCBTR0xpc3QiKTsKIAkJCWNjYl9o
 LT5zdGF0dXMgPSBDQU1fUkVRX0lOVkFMSUQ7CisJCQljY2JfaC0+c3RhdHVzICY9IH5DQU1fU0lN
 X1FVRVVFRDsKIAkJCXhwdF9kb25lKGNjYik7CiAJCQlyZXR1cm4oMSk7CiAJCX0KQEAgLTMwNiwx
 MyArMzA3LDIwIEBACiAJCXJldHVybigxKTsKIAl9CiAKLQljY2JfaC0+dGltZW91dF9jaCA9IHRp
 bWVvdXQodHdhX3RpbWVvdXQsIHJlcSwKLQkJKGNjYl9oLT50aW1lb3V0ICogaHopIC8gMTAwMCk7
 CisJcmVxLT5kZWFkbGluZSA9IHR3X29zbF9nZXRfbG9jYWxfdGltZSgpICsgKGNjYl9oLT50aW1l
 b3V0IC8gMTAwMCk7CisKKwogCS8qCiAJICogdHdhX21hcF9sb2FkX2RhdGFfY2FsbGJhY2sgd2ls
 bCBmaWxsIGluIHRoZSBTR0wsCiAJICogYW5kIHN1Ym1pdCB0aGUgSS9PLgogCSAqLwogCWVycm9y
 ID0gdHdfb3NsaV9tYXBfcmVxdWVzdChyZXEpOworCWlmICgoZXJyb3IpICYmIChyZXEtPmZsYWdz
 ICYgVFdfT1NMSV9SRVFfRkxBR1NfRkFJTEVEKSkgeworCQlyZXEtPmRlYWRsaW5lID0gMDsKKwkJ
 Y2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QX0VSUjsKKwkJY2NiX2gtPnN0YXR1cyAmPSB+Q0FN
 X1NJTV9RVUVVRUQ7CisJCXhwdF9kb25lKGNjYik7CisJfQogCXJldHVybihlcnJvcik7CiB9CiAK
 QEAgLTM0NSwxMCArMzUzLDIwIEBACiAJCQkgKiBGcmVlemUgdGhlIHNpbXEgdG8gbWFpbnRhaW4g
 Y2NiIG9yZGVyaW5nLiAgVGhlIG5leHQKIAkJCSAqIGNjYiB0aGF0IGdldHMgY29tcGxldGVkIHdp
 bGwgdW5mcmVlemUgdGhlIHNpbXEuCiAJCQkgKi8KKwkJCWNjYl9oLT5zdGF0dXMgJj0gfkNBTV9T
 SU1fUVVFVUVEOworCQkJY2NiX2gtPnN0YXR1cyB8PSBDQU1fUkVRVUVVRV9SRVE7CisJCQl4cHRf
 ZG9uZShjY2IpOworCQkJYnJlYWs7CisJCX0KKworCQlpZiAoKHR3X2NsX2lzX3Jlc2V0X25lZWRl
 ZCgmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKSkpIHsKKwkJCWNjYl9oLT5zdGF0dXMgJj0gfkNB
 TV9TSU1fUVVFVUVEOwogCQkJY2NiX2gtPnN0YXR1cyB8PSBDQU1fUkVRVUVVRV9SRVE7CiAJCQl4
 cHRfZG9uZShjY2IpOworCQkJdHdfb3NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX09TTElf
 RlJFRV9RKTsKIAkJCWJyZWFrOwogCQl9CisKIAkJcmVxLT5yZXFfaGFuZGxlLm9zbF9yZXFfY3R4
 dCA9IHJlcTsKIAkJcmVxLT5yZXFfaGFuZGxlLmlzX2lvID0gVFdfQ0xfVFJVRTsKIAkJcmVxLT5v
 cmlnX3JlcSA9IGNjYjsKQEAgLTM2NCwyNSArMzgyLDE0IEBACiAJCWJyZWFrOwogCiAJY2FzZSBY
 UFRfUkVTRVRfQlVTOgotCQl0d19jbF9jcmVhdGVfZXZlbnQoJihzYy0+Y3Rscl9oYW5kbGUpLCBU
 V19DTF9UUlVFLAorCQl0d19jbF9jcmVhdGVfZXZlbnQoJihzYy0+Y3Rscl9oYW5kbGUpLCBUV19D
 TF9GQUxTRSwKIAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0RfRFJJVkVSLAogCQkJMHgy
 MTA4LCAweDMsIFRXX0NMX1NFVkVSSVRZX0lORk9fU1RSSU5HLAogCQkJIlJlY2VpdmVkIFJlc2V0
 IEJ1cyByZXF1ZXN0IGZyb20gQ0FNIiwKIAkJCSIgIik7CiAKLQkJbXR4X3VubG9jayhzYy0+c2lt
 X2xvY2spOwotCQlpZiAodHdfY2xfcmVzZXRfY3Rscigmc2MtPmN0bHJfaGFuZGxlKSkgewotCQkJ
 dHdfY2xfY3JlYXRlX2V2ZW50KCYoc2MtPmN0bHJfaGFuZGxlKSwgVFdfQ0xfVFJVRSwKLQkJCQlU
 V19DTF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKLQkJCQkweDIxMDksIDB4MSwgVFdf
 Q0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAotCQkJCSJGYWlsZWQgdG8gcmVzZXQgYnVzIiwKLQkJ
 CQkiICIpOwotCQkJY2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QX0VSUjsKLQkJfQotCQllbHNl
 Ci0JCQljY2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7Ci0KLQkJbXR4X2xvY2soc2MtPnNpbV9s
 b2NrKTsKKwkJdHdfY2xfc2V0X3Jlc2V0X25lZWRlZCgmKHNjLT5jdGxyX2hhbmRsZSkpOworCQlj
 Y2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7CiAJCXhwdF9kb25lKGNjYik7CiAJCWJyZWFrOwog
 CkBAIC00NTAsNiArNDU3LDcgQEAKICAgICAgICAgICAgICAgICBwYXRoX2lucS0+dHJhbnNwb3J0
 X3ZlcnNpb24gPSAyOwogICAgICAgICAgICAgICAgIHBhdGhfaW5xLT5wcm90b2NvbCA9IFBST1RP
 X1NDU0k7CiAgICAgICAgICAgICAgICAgcGF0aF9pbnEtPnByb3RvY29sX3ZlcnNpb24gPSBTQ1NJ
 X1JFVl8yOworICAgICAgICAgICAgICAgIHBhdGhfaW5xLT5tYXhpbyA9IFRXX0NMX01BWF9JT19T
 SVpFOwogCQljY2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7CiAJCXhwdF9kb25lKGNjYik7CiAJ
 CWJyZWFrOwpAQCAtNDg3LDMxICs0OTUsNiBAQAogCiAKIC8qCi0gKiBGdW5jdGlvbiBuYW1lOgl0
 d2FfdGltZW91dAotICogRGVzY3JpcHRpb246CQlEcml2ZXIgZW50cnkgcG9pbnQgZm9yIGJlaW5n
 IGFsZXJ0ZWQgb24gYSByZXF1ZXN0Ci0gKgkJCXRpbWluZyBvdXQuCi0gKgotICogSW5wdXQ6CQlh
 cmcJLS0gcHRyIHRvIHRpbWVkIG91dCByZXF1ZXN0Ci0gKiBPdXRwdXQ6CQlOb25lCi0gKiBSZXR1
 cm4gdmFsdWU6CU5vbmUKLSAqLwotc3RhdGljIFRXX1ZPSUQKLXR3YV90aW1lb3V0KFRXX1ZPSUQg
 KmFyZykKLXsKLQlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqcmVxID0KLQkJKHN0cnVjdCB0
 d19vc2xpX3JlcV9jb250ZXh0ICopYXJnOwotCi0JdHdfY2xfY3JlYXRlX2V2ZW50KCYocmVxLT5j
 dGxyLT5jdGxyX2hhbmRsZSksIFRXX0NMX1RSVUUsCi0JCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZS
 RUVCU0RfRFJJVkVSLAotCQkweDIxMEIsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5H
 LAotCQkiUmVxdWVzdCB0aW1lZCBvdXQhIiwKLQkJInJlcXVlc3QgPSAlcCIsIHJlcSk7Ci0JdHdf
 Y2xfcmVzZXRfY3RscigmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKTsKLX0KLQotCi0KLS8qCiAg
 KiBGdW5jdGlvbiBuYW1lOgl0d19vc2xpX3JlcXVlc3RfYnVzX3NjYW4KICAqIERlc2NyaXB0aW9u
 OgkJUmVxdWVzdHMgQ0FNIGZvciBhIHNjYW4gb2YgdGhlIGJ1cy4KICAqCkBAIC01NzQsMjAgKzU1
 NywzOSBAQAogCiAKIC8qCi0gKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfY3Rscl9idXN5Ci0gKiBE
 ZXNjcmlwdGlvbjoJCUNMIGNhbGxzIHRoaXMgZnVuY3Rpb24gb24gY21kIHF1ZXVlIGZ1bGwgb3Ig
 b3RoZXJ3aXNlLAotICoJCQl3aGVuIGl0IGlzIHRvbyBidXN5IHRvIGFjY2VwdCBuZXcgcmVxdWVz
 dHMuCisgKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfdGltZW91dAorICogRGVzY3JpcHRpb246CQlD
 YWxsIHRvIHRpbWVvdXQoKS4KICAqCi0gKiBJbnB1dDoJCWN0bHJfaGFuZGxlCS0tIHB0ciB0byBj
 b250cm9sbGVyIGhhbmRsZQotICoJCQlyZXFfaGFuZGxlCS0tIHB0ciB0byByZXF1ZXN0IGhhbmRs
 ZSBzZW50IGJ5IE9TTC4KKyAqIElucHV0OgkJcmVxX2hhbmRsZSAtLSBwdHIgdG8gcmVxdWVzdCBo
 YW5kbGUgc2VudCBieSBPU0wuCiAgKiBPdXRwdXQ6CQlOb25lCiAgKiBSZXR1cm4gdmFsdWU6CU5v
 bmUKICAqLwogVFdfVk9JRAotdHdfb3NsX2N0bHJfYnVzeShzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5k
 bGUgKmN0bHJfaGFuZGxlLAotCXN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKQor
 dHdfb3NsX3RpbWVvdXQoc3RydWN0IHR3X2NsX3JlcV9oYW5kbGUgKnJlcV9oYW5kbGUpCit7CisJ
 c3RydWN0IHR3X29zbGlfcmVxX2NvbnRleHQJKnJlcSA9IHJlcV9oYW5kbGUtPm9zbF9yZXFfY3R4
 dDsKKwl1bmlvbiBjY2IJCQkqY2NiID0gKHVuaW9uIGNjYiAqKShyZXEtPm9yaWdfcmVxKTsKKwlz
 dHJ1Y3QgY2NiX2hkcgkJCSpjY2JfaCA9ICYoY2NiLT5jY2JfaCk7CisKKwlyZXEtPmRlYWRsaW5l
 ID0gdHdfb3NsX2dldF9sb2NhbF90aW1lKCkgKyAoY2NiX2gtPnRpbWVvdXQgLyAxMDAwKTsKK30K
 KworCisKKy8qCisgKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfdW50aW1lb3V0CisgKiBEZXNjcmlw
 dGlvbjoJCUludmVyc2Ugb2YgY2FsbCB0byB0aW1lb3V0KCkuCisgKgorICogSW5wdXQ6CQlyZXFf
 aGFuZGxlIC0tIHB0ciB0byByZXF1ZXN0IGhhbmRsZSBzZW50IGJ5IE9TTC4KKyAqIE91dHB1dDoJ
 CU5vbmUKKyAqIFJldHVybiB2YWx1ZToJTm9uZQorICovCitUV19WT0lECit0d19vc2xfdW50aW1l
 b3V0KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKQogewotCXR3X29zbGlfZGlz
 YWxsb3dfbmV3X3JlcXVlc3RzKGN0bHJfaGFuZGxlLT5vc2xfY3Rscl9jdHh0LCByZXFfaGFuZGxl
 KTsKKwlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqcmVxID0gcmVxX2hhbmRsZS0+b3NsX3Jl
 cV9jdHh0OworCisJcmVxLT5kZWFkbGluZSA9IDA7CiB9CiAKIApAQCAtNjU1LDcgKzY1Nyw3IEBA
 CiAKIAl0d19vc2xpX3VubWFwX3JlcXVlc3QocmVxKTsKIAotCXVudGltZW91dCh0d2FfdGltZW91
 dCwgcmVxLCBjY2ItPmNjYl9oLnRpbWVvdXRfY2gpOworCXJlcS0+ZGVhZGxpbmUgPSAwOwogCWlm
 IChyZXEtPmVycm9yX2NvZGUpIHsKIAkJLyogVGhpcyByZXF1ZXN0IG5ldmVyIGdvdCBzdWJtaXR0
 ZWQgdG8gdGhlIGZpcm13YXJlLiAqLwogCQlpZiAocmVxLT5lcnJvcl9jb2RlID09IEVCVVNZKSB7
 CkBAIC02ODIsNyArNjg0LDcgQEAKIAkJCWVsc2UgaWYgKHJlcV9wa3QtPnN0YXR1cyAmIFRXX0NM
 X0VSUl9SRVFfU0NTSV9FUlJPUikKIAkJCQljY2ItPmNjYl9oLnN0YXR1cyB8PSBDQU1fU0NTSV9T
 VEFUVVNfRVJST1I7CiAJCQllbHNlIGlmIChyZXFfcGt0LT5zdGF0dXMgJiBUV19DTF9FUlJfUkVR
 X0JVU19SRVNFVCkKLQkJCQljY2ItPmNjYl9oLnN0YXR1cyB8PSBDQU1fU0NTSV9CVVNfUkVTRVQ7
 CisJCQkJY2NiLT5jY2JfaC5zdGF0dXMgfD0gKENBTV9SRVFVRVVFX1JFUSB8IENBTV9TQ1NJX0JV
 U19SRVNFVCk7CiAJCQkvKgogCQkJICogSWYgbm9uZSBvZiB0aGUgYWJvdmUgZXJyb3JzIG9jY3Vy
 cmVkLCBzaW1wbHkKIAkJCSAqIG1hcmsgY29tcGxldGlvbiBlcnJvci4KZGlmZiAtdSBGcmVlQlNE
 X1JFTEVOR184X3R3YV9jdnMvdHdfb3NsX2ZyZWVic2QuYyBGcmVlQlNEOF90d2FfM184MF8wNl8w
 MDMvdHdfb3NsX2ZyZWVic2QuYwotLS0gRnJlZUJTRF9SRUxFTkdfOF90d2FfY3ZzL3R3X29zbF9m
 cmVlYnNkLmMJMjAxMC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q4
 X3R3YV8zXzgwXzA2XzAwMy90d19vc2xfZnJlZWJzZC5jCTIwMTAtMDgtMjYgMTU6MTQ6MzkuMDAw
 MDAwMDAwIC0wNzAwCkBAIC0xNzUsNiArMTc1LDkgQEAKIHN0YXRpYyBUV19JTlQzMgl0d2Ffc2h1
 dGRvd24oZGV2aWNlX3QgZGV2KTsKIHN0YXRpYyBUV19WT0lECXR3YV9idXNkbWFfbG9jayhUV19W
 T0lEICpsb2NrX2FyZywgYnVzX2RtYV9sb2NrX29wX3Qgb3ApOwogc3RhdGljIFRXX1ZPSUQJdHdh
 X3BjaV9pbnRyKFRXX1ZPSUQgKmFyZyk7CitzdGF0aWMgVFdfVk9JRAl0d2Ffd2F0Y2hkb2coVFdf
 Vk9JRCAqYXJnKTsKK2ludCB0d2Ffc2V0dXBfaW50cihzdHJ1Y3QgdHdhX3NvZnRjICpzYyk7Citp
 bnQgdHdhX3RlYXJkb3duX2ludHIoc3RydWN0IHR3YV9zb2Z0YyAqc2MpOwogCiBzdGF0aWMgVFdf
 SU5UMzIJdHdfb3NsaV9hbGxvY19tZW0oc3RydWN0IHR3YV9zb2Z0YyAqc2MpOwogc3RhdGljIFRX
 X1ZPSUQJdHdfb3NsaV9mcmVlX3Jlc291cmNlcyhzdHJ1Y3QgdHdhX3NvZnRjICpzYyk7CkBAIC0y
 MzgsNiArMjQxLDMyIEBACiAJcmV0dXJuKEVOWElPKTsKIH0KIAoraW50IHR3YV9zZXR1cF9pbnRy
 KHN0cnVjdCB0d2Ffc29mdGMgKnNjKQoreworCWludCBlcnJvciA9IDA7CisKKwlpZiAoIShzYy0+
 aW50cl9oYW5kbGUpICYmIChzYy0+aXJxX3JlcykpIHsKKwkJZXJyb3IgPSBidXNfc2V0dXBfaW50
 cihzYy0+YnVzX2Rldiwgc2MtPmlycV9yZXMsCisJCQkJCUlOVFJfVFlQRV9DQU0gfCBJTlRSX01Q
 U0FGRSwKKwkJCQkJTlVMTCwgdHdhX3BjaV9pbnRyLAorCQkJCQlzYywgJnNjLT5pbnRyX2hhbmRs
 ZSk7CisJfQorCXJldHVybiggZXJyb3IgKTsKK30KKworCitpbnQgdHdhX3RlYXJkb3duX2ludHIo
 c3RydWN0IHR3YV9zb2Z0YyAqc2MpCit7CisJaW50IGVycm9yID0gMDsKKworCWlmICgoc2MtPmlu
 dHJfaGFuZGxlKSAmJiAoc2MtPmlycV9yZXMpKSB7CisJCWVycm9yID0gYnVzX3RlYXJkb3duX2lu
 dHIoc2MtPmJ1c19kZXYsCisJCQkJCQlzYy0+aXJxX3Jlcywgc2MtPmludHJfaGFuZGxlKTsKKwkJ
 c2MtPmludHJfaGFuZGxlID0gTlVMTDsKKwl9CisJcmV0dXJuKCBlcnJvciApOworfQorCiAKIAog
 LyoKQEAgLTM1NCwxMCArMzgzLDcgQEAKIAkJdHdfb3NsaV9mcmVlX3Jlc291cmNlcyhzYyk7CiAJ
 CXJldHVybihFTlhJTyk7CiAJfQotCWlmICgoZXJyb3IgPSBidXNfc2V0dXBfaW50cihzYy0+YnVz
 X2Rldiwgc2MtPmlycV9yZXMsCi0JCQlJTlRSX1RZUEVfQ0FNIHwgSU5UUl9NUFNBRkUsCi0JCQlO
 VUxMLCB0d2FfcGNpX2ludHIsCSAgICAKLQkJCXNjLCAmc2MtPmludHJfaGFuZGxlKSkpIHsKKwlp
 ZiAoKGVycm9yID0gdHdhX3NldHVwX2ludHIoc2MpKSkgewogCQl0d19vc2xpX3ByaW50ZihzYywg
 ImVycm9yID0gJWQiLAogCQkJVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAogCQkJVFdfQ0xf
 TUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCkBAIC00MTIsMTAgKzQzOCw3NyBAQAogCQly
 ZXR1cm4oZXJyb3IpOwogCX0KIAorCXNjLT53YXRjaGRvZ19pbmRleCA9IDA7CisJY2FsbG91dF9p
 bml0KCYoc2MtPndhdGNoZG9nX2NhbGxvdXRbMF0pLCBDQUxMT1VUX01QU0FGRSk7CisJY2FsbG91
 dF9pbml0KCYoc2MtPndhdGNoZG9nX2NhbGxvdXRbMV0pLCBDQUxMT1VUX01QU0FGRSk7CisJY2Fs
 bG91dF9yZXNldCgmKHNjLT53YXRjaGRvZ19jYWxsb3V0WzBdKSwgNSpoeiwgdHdhX3dhdGNoZG9n
 LCAmc2MtPmN0bHJfaGFuZGxlKTsKKwogCXJldHVybigwKTsKIH0KIAogCitzdGF0aWMgVFdfVk9J
 RAordHdhX3dhdGNoZG9nKFRXX1ZPSUQgKmFyZykKK3sKKwlzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5k
 bGUgKmN0bHJfaGFuZGxlID0KKwkJKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqKWFyZzsKKwlz
 dHJ1Y3QgdHdhX3NvZnRjCQkqc2MgPSBjdGxyX2hhbmRsZS0+b3NsX2N0bHJfY3R4dDsKKwlpbnQJ
 CQkJaTsKKwlpbnQJCQkJaV9uZWVkX2FfcmVzZXQgPSAwOworCWludAkJCQlkcml2ZXJfaXNfYWN0
 aXZlID0gMDsKKwlpbnQJCQkJbXlfd2F0Y2hkb2dfd2FzX3BlbmRpbmcgPSAxMjM0OworCVRXX1VJ
 TlQ2NAkJCWN1cnJlbnRfdGltZTsKKwlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqbXlfcmVx
 OworCisKKy8vPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisJY3VycmVudF90aW1lID0gKFRXX1VJTlQ2
 NCkgKHR3X29zbF9nZXRfbG9jYWxfdGltZSgpKTsKKworCWZvciAoaSA9IDA7IGkgPCBUV19PU0xJ
 X01BWF9OVU1fUkVRVUVTVFM7IGkrKykgeworCQlteV9yZXEgPSAmKHNjLT5yZXFfY3R4X2J1Zltp
 XSk7CisKKwkJaWYgKChteV9yZXEtPnN0YXRlID09IFRXX09TTElfUkVRX1NUQVRFX0JVU1kpICYm
 CisJCQkobXlfcmVxLT5kZWFkbGluZSkgJiYKKwkJCShteV9yZXEtPmRlYWRsaW5lIDwgY3VycmVu
 dF90aW1lKSkgeworCQkJdHdfY2xfc2V0X3Jlc2V0X25lZWRlZChjdGxyX2hhbmRsZSk7CisjaWZk
 ZWYgICAgVFdfT1NMX0RFQlVHCisJCQlkZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJSZXF1
 ZXN0ICVkIHRpbWVkIG91dCEgZCA9ICVwLCBjID0gJXBcbiIsIGksICh2b2lkKilteV9yZXEtPmRl
 YWRsaW5lLCAodm9pZCopY3VycmVudF90aW1lKTsKKyNlbHNlICAvKiBUV19PU0xfREVCVUcgKi8K
 KwkJCWRldmljZV9wcmludGYoKHNjKS0+YnVzX2RldiwgIlJlcXVlc3QgJWQgdGltZWQgb3V0IVxu
 IiwgaSk7CisjZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCisJCQlicmVhazsKKwkJfQorCX0KKy8v
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09CisKKwlpX25lZWRfYV9yZXNldCA9IHR3X2NsX2lzX3Jlc2V0
 X25lZWRlZChjdGxyX2hhbmRsZSk7CisKKwlpID0gKGludCkgKChzYy0+d2F0Y2hkb2dfaW5kZXgr
 KykgJiAxKTsKKworCWRyaXZlcl9pc19hY3RpdmUgPSB0d19jbF9pc19hY3RpdmUoY3Rscl9oYW5k
 bGUpOworCisJaWYgKGlfbmVlZF9hX3Jlc2V0KSB7CisjaWZkZWYgICAgVFdfT1NMX0RFQlVHCisJ
 CWRldmljZV9wcmludGYoKHNjKS0+YnVzX2RldiwgIldhdGNoZG9nIHJlc2NoZWR1bGVkIGluIDcw
 IHNlY29uZHNcbiIpOworI2VuZGlmIC8qIFRXX09TTF9ERUJVRyAqLworCQlteV93YXRjaGRvZ193
 YXNfcGVuZGluZyA9CisJCQljYWxsb3V0X3Jlc2V0KCYoc2MtPndhdGNoZG9nX2NhbGxvdXRbaV0p
 LCA3MCpoeiwgdHdhX3dhdGNoZG9nLCAmc2MtPmN0bHJfaGFuZGxlKTsKKwkJdHdfY2xfcmVzZXRf
 Y3RscihjdGxyX2hhbmRsZSk7CisjaWZkZWYgICAgVFdfT1NMX0RFQlVHCisJCWRldmljZV9wcmlu
 dGYoKHNjKS0+YnVzX2RldiwgIldhdGNoZG9nIHJlc2V0IGNvbXBsZXRlZCFcbiIpOworI2VuZGlm
 IC8qIFRXX09TTF9ERUJVRyAqLworCX0gZWxzZSBpZiAoZHJpdmVyX2lzX2FjdGl2ZSkgeworCQlt
 eV93YXRjaGRvZ193YXNfcGVuZGluZyA9CisJCQljYWxsb3V0X3Jlc2V0KCYoc2MtPndhdGNoZG9n
 X2NhbGxvdXRbaV0pLCAgNSpoeiwgdHdhX3dhdGNoZG9nLCAmc2MtPmN0bHJfaGFuZGxlKTsKKwl9
 CisjaWZkZWYgICAgVFdfT1NMX0RFQlVHCisJaWYgKGlfbmVlZF9hX3Jlc2V0IHx8IG15X3dhdGNo
 ZG9nX3dhc19wZW5kaW5nKQorCQlkZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJpX25lZWRf
 YV9yZXNldCA9ICVkLCAiCisJCSJkcml2ZXJfaXNfYWN0aXZlID0gJWQsIG15X3dhdGNoZG9nX3dh
 c19wZW5kaW5nID0gJWRcbiIsCisJCWlfbmVlZF9hX3Jlc2V0LCBkcml2ZXJfaXNfYWN0aXZlLCBt
 eV93YXRjaGRvZ193YXNfcGVuZGluZyk7CisjZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCit9CisK
 IAogLyoKICAqIEZ1bmN0aW9uIG5hbWU6CXR3X29zbGlfYWxsb2NfbWVtCkBAIC03MTUsOSArODA4
 LDcgQEAKIAogCiAJLyogRGlzY29ubmVjdCB0aGUgaW50ZXJydXB0IGhhbmRsZXIuICovCi0JaWYg
 KHNjLT5pbnRyX2hhbmRsZSkKLQkJaWYgKChlcnJvciA9IGJ1c190ZWFyZG93bl9pbnRyKHNjLT5i
 dXNfZGV2LAotCQkJCXNjLT5pcnFfcmVzLCBzYy0+aW50cl9oYW5kbGUpKSkKKwlpZiAoKGVycm9y
 ID0gdHdhX3RlYXJkb3duX2ludHIoc2MpKSkKIAkJCXR3X29zbGlfZGJnX2RwcmludGYoMSwgc2Ms
 CiAJCQkJInRlYXJkb3duX2ludHIgcmV0dXJuZWQgJWQiLCBlcnJvcik7CiAKQEAgLTgwOSw2ICs5
 MDAsMTMgQEAKIAogCXR3X29zbGlfZGJnX2RwcmludGYoMywgc2MsICJlbnRlcmVkIik7CiAKKwkv
 KiBTdG9wIHdhdGNoZG9nIHRhc2suICovCisJY2FsbG91dF9kcmFpbigmKHNjLT53YXRjaGRvZ19j
 YWxsb3V0WzBdKSk7CisJY2FsbG91dF9kcmFpbigmKHNjLT53YXRjaGRvZ19jYWxsb3V0WzFdKSk7
 CisKKwkvKiBEaXNjb25uZWN0IGludGVycnVwdHMuICovCisJZXJyb3IgPSB0d2FfdGVhcmRvd25f
 aW50cihzYyk7CisKIAkvKiBEaXNjb25uZWN0IGZyb20gdGhlIGNvbnRyb2xsZXIuICovCiAJaWYg
 KChlcnJvciA9IHR3X2NsX3NodXRkb3duX2N0bHIoJihzYy0+Y3Rscl9oYW5kbGUpLCAwKSkpIHsK
 IAkJdHdfb3NsaV9wcmludGYoc2MsICJlcnJvciA9ICVkIiwKQEAgLTk5NywzMyArMTA5NSwzNSBA
 QAogCQkJCWVycm9yID0gMDsgLyogRmFsc2UgZXJyb3IgKi8KIAkJCQlicmVhazsKIAkJCX0KLQkJ
 CXR3X29zbGlfcHJpbnRmKHNjLCAicmVxdWVzdCA9ICVwIiwKLQkJCQlUV19DTF9TRVZFUklUWV9F
 UlJPUl9TVFJJTkcsCi0JCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCi0J
 CQkJMHgyMDE4LAotCQkJCSJQYXNzdGhydSByZXF1ZXN0IHRpbWVkIG91dCEiLAotCQkJCXJlcSk7
 Ci0JCQkvKgotCQkJICogU2hvdWxkIEkgY2hlY2sgaGVyZSBpZiB0aGUgdGltZW91dCBoYXBwZW5l
 ZAotCQkJICogYmVjYXVzZSBvZiB5ZXQgYW5vdGhlciByZXNldCwgYW5kIG5vdCBkbyBhCi0JCQkg
 KiBzZWNvbmQgcmVzZXQ/Ci0JCQkgKi8KLQkJCXR3X2NsX3Jlc2V0X2N0bHIoJnNjLT5jdGxyX2hh
 bmRsZSk7CisJCQlpZiAoISh0d19jbF9pc19yZXNldF9uZWVkZWQoJihyZXEtPmN0bHItPmN0bHJf
 aGFuZGxlKSkpKSB7CisjaWZkZWYgICAgVFdfT1NMX0RFQlVHCisJCQkJdHdfb3NsaV9wcmludGYo
 c2MsICJyZXF1ZXN0ID0gJXAiLAorCQkJCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCisJ
 CQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0RfRFJJVkVSLAorCQkJCQkweDIwMTgsCisJ
 CQkJCSJQYXNzdGhydSByZXF1ZXN0IHRpbWVkIG91dCEiLAorCQkJCQlyZXEpOworI2Vsc2UgIC8q
 IFRXX09TTF9ERUJVRyAqLworCQkJZGV2aWNlX3ByaW50Zigoc2MpLT5idXNfZGV2LCAiUGFzc3Ro
 cnUgcmVxdWVzdCB0aW1lZCBvdXQhXG4iKTsKKyNlbmRpZiAvKiBUV19PU0xfREVCVUcgKi8KKwkJ
 CQl0d19jbF9yZXNldF9jdGxyKCYocmVxLT5jdGxyLT5jdGxyX2hhbmRsZSkpOworCQkJfQorCisJ
 CQllcnJvciA9IDA7CisJCQllbmRfdGltZSA9IHR3X29zbF9nZXRfbG9jYWxfdGltZSgpICsgdGlt
 ZW91dDsKKwkJCWNvbnRpbnVlOwogCQkJLyoKIAkJCSAqIERvbid0IHRvdWNoIHJlcSBhZnRlciBh
 IHJlc2V0LiAgSXQgKGFuZCBhbnkKLQkJCSAqIGFzc29jaWF0ZWQgZGF0YSkgd2lsbCBhbHJlYWR5
 IGhhdmUgYmVlbgorCQkJICogYXNzb2NpYXRlZCBkYXRhKSB3aWxsIGJlCiAJCQkgKiB1bm1hcHBl
 ZCBieSB0aGUgY2FsbGJhY2suCiAJCQkgKi8KLQkJCXVzZXJfYnVmLT5kcml2ZXJfcGt0Lm9zX3N0
 YXR1cyA9IGVycm9yOwotCQkJZXJyb3IgPSBFVElNRURPVVQ7Ci0JCQlnb3RvIGZ3X3Bhc3N0aHJ1
 X2VycjsKIAkJfQogCQkvKiAKIAkJICogRWl0aGVyIHRoZSByZXF1ZXN0IGdvdCBjb21wbGV0ZWQs
 IG9yIHdlIHdlcmUgd29rZW4gdXAgYnkgYQogCQkgKiBzaWduYWwuICBDYWxjdWxhdGUgdGhlIG5l
 dyB0aW1lb3V0LCBpbiBjYXNlIGl0IHdhcyB0aGUgbGF0dGVyLgogCQkgKi8KIAkJdGltZW91dCA9
 IChlbmRfdGltZSAtIHR3X29zbF9nZXRfbG9jYWxfdGltZSgpKTsKLQl9CisJfSAvKiBFbmQgb2Yg
 d2hpbGUgbG9vcCAqLwogCiAJLyogSWYgdGhlcmUgd2FzIGEgcGF5bG9hZCwgY29weSBpdCBiYWNr
 LiAqLwogCWlmICgoIWVycm9yKSAmJiAocmVxLT5sZW5ndGgpKQpAQCAtMTAzNywxOSArMTEzNyw5
 IEBACiAJCQkJZXJyb3IpOwogCQogZndfcGFzc3RocnVfZXJyOgotCS8qCi0JICogUHJpbnQgdGhl
 IGZhaWx1cmUgbWVzc2FnZS4gIEZvciBzb21lIHJlYXNvbiwgb24gY2VydGFpbiBPUyB2ZXJzaW9u
 cywKLQkgKiBwcmludGluZyB0aGlzIGVycm9yIG1lc3NhZ2UgZHVyaW5nIHJlc2V0IGhhbmdzIHRo
 ZSBkaXNwbGF5IChhbHRob3VnaAotCSAqIHRoZSByZXN0IG9mIHRoZSBzeXN0ZW0gaXMgcnVubmlu
 ZyBmaW5lLiAgU28sIGRvbid0IHByaW50IGl0IGlmIHRoZQotCSAqIGZhaWx1cmUgd2FzIGR1ZSB0
 byBhIHJlc2V0LgotCSAqLwotCWlmICgoZXJyb3IpICYmIChlcnJvciAhPSBUV19DTF9FUlJfUkVR
 X0JVU19SRVNFVCkpCi0JCXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAlZCIsCQkKLQkJCVRX
 X0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVC
 U0RfRFJJVkVSLAotCQkJMHgyMDFBLAotCQkJIkZpcm13YXJlIHBhc3N0aHJ1IGZhaWxlZCEiLAot
 CQkJZXJyb3IpOworCisJaWYgKHJlcV9wa3QtPnN0YXR1cyA9PSBUV19DTF9FUlJfUkVRX0JVU19S
 RVNFVCkKKwkJZXJyb3IgPSBFQlVTWTsKIAogCXVzZXJfYnVmLT5kcml2ZXJfcGt0Lm9zX3N0YXR1
 cyA9IGVycm9yOwogCS8qIEZyZWUgcmVzb3VyY2VzLiAqLwpAQCAtMTA3Myw2ICsxMTYzLDggQEAK
 IHR3X29zbF9jb21wbGV0ZV9wYXNzdGhydShzdHJ1Y3QgdHdfY2xfcmVxX2hhbmRsZSAqcmVxX2hh
 bmRsZSkKIHsKIAlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqcmVxID0gcmVxX2hhbmRsZS0+
 b3NsX3JlcV9jdHh0OworCXN0cnVjdCB0d19jbF9yZXFfcGFja2V0CQkqcmVxX3BrdCA9CisJCShz
 dHJ1Y3QgdHdfY2xfcmVxX3BhY2tldCAqKSgmcmVxLT5yZXFfcGt0KTsKIAlzdHJ1Y3QgdHdhX3Nv
 ZnRjCQkqc2MgPSByZXEtPmN0bHI7CiAKIAl0d19vc2xpX2RiZ19kcHJpbnRmKDUsIHNjLCAiZW50
 ZXJlZCIpOwpAQCAtMTEyMCw2ICsxMjEyLDkgQEAKIAkJCWlmIChyZXEtPmZsYWdzICYgVFdfT1NM
 SV9SRVFfRkxBR1NfTUFQUEVEKQogCQkJCXJldHVybjsKIAorCQkJaWYgKHJlcV9wa3QtPnN0YXR1
 cyA9PSBUV19DTF9FUlJfUkVRX0JVU19SRVNFVCkKKwkJCQlyZXR1cm47CisKIAkJCXR3X29zbGlf
 cHJpbnRmKHNjLCAicmVxdWVzdCA9ICVwIiwKIAkJCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJ
 TkcsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCkBAIC0xMTY2LDYg
 KzEyNjEsNyBAQAogCQlyZXEtPnJlcV9oYW5kbGUuaXNfaW8gPSAwOwogCQlyZXEtPmRhdGEgPSBO
 VUxMOwogCQlyZXEtPmxlbmd0aCA9IDA7CisJCXJlcS0+ZGVhZGxpbmUgPSAwOwogCQlyZXEtPnJl
 YWxfZGF0YSA9IE5VTEw7CiAJCXJlcS0+cmVhbF9sZW5ndGggPSAwOwogCQlyZXEtPnN0YXRlID0g
 VFdfT1NMSV9SRVFfU1RBVEVfSU5JVDsvKiByZXEgYmVpbmcgaW5pdGlhbGl6ZWQgKi8KQEAgLTEy
 MDcsNiArMTMwMywxMSBAQAogCiAJdHdfb3NsaV9kYmdfZHByaW50ZigxMCwgc2MsICJlbnRlcmVk
 Iik7CiAKKwlpZiAoZXJyb3IgPT0gRUlOVkFMKSB7CisJCXJlcS0+ZXJyb3JfY29kZSA9IGVycm9y
 OworCQlyZXR1cm47CisJfQorCiAJLyogTWFyayB0aGUgcmVxdWVzdCBhcyBjdXJyZW50bHkgYmVp
 bmcgcHJvY2Vzc2VkLiAqLwogCXJlcS0+c3RhdGUgPSBUV19PU0xJX1JFUV9TVEFURV9CVVNZOwog
 CS8qIE1vdmUgdGhlIHJlcXVlc3QgaW50byB0aGUgYnVzeSBxdWV1ZS4gKi8KQEAgLTE0MDAsNiAr
 MTUwMSwxNCBAQAogCQkJCW10eF91bmxvY2tfc3BpbihzYy0+aW9fbG9jayk7CiAJCQkJZXJyb3Ig
 PSAwOwogCQkJfSBlbHNlIHsKKwkJCQl0d19vc2xpX3ByaW50ZihzYywgImVycm9yID0gJWQiLAor
 CQkJCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCisJCQkJCVRXX0NMX01FU1NBR0VfU09V
 UkNFX0ZSRUVCU0RfRFJJVkVSLAorCQkJCQkweDk5OTksCisJCQkJCSJGYWlsZWQgdG8gbWFwIERN
 QSBtZW1vcnkgIgorCQkJCQkiZm9yIEkvTyByZXF1ZXN0IiwKKwkJCQkJZXJyb3IpOworCQkJCXJl
 cS0+ZmxhZ3MgfD0gVFdfT1NMSV9SRVFfRkxBR1NfRkFJTEVEOwogCQkJCS8qIEZyZWUgYWxpZ25t
 ZW50IGJ1ZmZlciBpZiBpdCB3YXMgdXNlZC4gKi8KIAkJCQlpZiAocmVxLT5mbGFncyAmCiAJCQkJ
 CVRXX09TTElfUkVRX0ZMQUdTX0RBVEFfQ09QWV9ORUVERUQpIHsKZGlmZiAtdSBGcmVlQlNEX1JF
 TEVOR184X3R3YV9jdnMvdHdfb3NsX3NoYXJlLmggRnJlZUJTRDhfdHdhXzNfODBfMDZfMDAzL3R3
 X29zbF9zaGFyZS5oCi0tLSBGcmVlQlNEX1JFTEVOR184X3R3YV9jdnMvdHdfb3NsX3NoYXJlLmgJ
 MjAxMC0wOC0yNiAxNTozNToyMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q4X3R3YV8zXzgw
 XzA2XzAwMy90d19vc2xfc2hhcmUuaAkyMDEwLTA4LTI0IDE4OjAxOjQ0LjAwMDAwMDAwMCAtMDcw
 MApAQCAtNzUsNyArNzUsNyBAQAogI2RlZmluZSBUV19PU0xfRU5DTE9TVVJFX1NVUFBPUlQKICNl
 bmRpZgogCi0jZGVmaW5lIFRXX09TTF9EUklWRVJfVkVSU0lPTl9TVFJJTkcJIjMuODAuMDYuMDAy
 IgorI2RlZmluZSBUV19PU0xfRFJJVkVSX1ZFUlNJT05fU1RSSU5HCSIzLjgwLjA2LjAwMyIKIAog
 I2RlZmluZQlUV19PU0xfQ0FOX1NMRUVQCiAK
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Bcosmail03lsicom_--

From: "Couch, Tom" <Tom.Couch@lsi.com>
To: "FreeBSD-gnats-submit@FreeBSD.org" <FreeBSD-gnats-submit@FreeBSD.org>,
        "freebsd-bugs@FreeBSD.org" <freebsd-bugs@FreeBSD.org>
Cc:  
Subject: RE: kern/149968: Kernel panic with ZFS and twa version 3.80.06.002
Date: Mon, 30 Aug 2010 13:10:56 -0600

 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Ccosmail03lsicom_
 Content-Type: text/plain; charset="us-ascii"
 Content-Transfer-Encoding: quoted-printable
 
 Attaching patch FreeBSD_RELENG_7_src_sys_dev_twa.txt for RELENG_7.
 
 Tom Couch
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Ccosmail03lsicom_
 Content-Type: text/plain; name="FreeBSD_RELENG_7_src_sys_dev_twa.txt"
 Content-Description: FreeBSD_RELENG_7_src_sys_dev_twa.txt
 Content-Disposition: attachment;
 	filename="FreeBSD_RELENG_7_src_sys_dev_twa.txt"; size=45377;
 	creation-date="Thu, 26 Aug 2010 16:56:26 GMT";
 	modification-date="Thu, 26 Aug 2010 16:56:26 GMT"
 Content-Transfer-Encoding: base64
 
 ZGlmZiAtdSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMvdHdfY2wuaCBGcmVlQlNEN190d2FfM183
 MF8wNV8wMTAvdHdfY2wuaAotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3ZzL3R3X2NsLmgJMjAx
 MC0wOC0yNiAxNTozNTowMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q3X3R3YV8zXzcwXzA1
 XzAxMC90d19jbC5oCTIwMTAtMDgtMjQgMTg6MDE6MTMuMDAwMDAwMDAwIC0wNzAwCkBAIC04OCw3
 ICs4OCw4IEBACiAjZGVmaW5lIFRXX0NMSV9CVVNZX1EJCTEJLyogcSBvZiByZXFzIHN1Ym1pdHRl
 ZCB0byBmdyAqLwogI2RlZmluZSBUV19DTElfUEVORElOR19RCTIJLyogcSBvZiByZXFzIGRlZmVy
 cmVkIGR1ZSB0byAncSBmdWxsJyAqLwogI2RlZmluZSBUV19DTElfQ09NUExFVEVfUQkzCS8qIHEg
 b2YgcmVxcyBjb21wbGV0ZWQgYnkgZncgKi8KLSNkZWZpbmUgVFdfQ0xJX1FfQ09VTlQJCTQJLyog
 dG90YWwgbnVtYmVyIG9mIHF1ZXVlcyAqLworI2RlZmluZSBUV19DTElfUkVTRVRfUQkJNAkvKiBx
 IG9mIHJlcXMgcmVzZXQgYnkgdGltZW91dCAqLworI2RlZmluZSBUV19DTElfUV9DT1VOVAkJNQkv
 KiB0b3RhbCBudW1iZXIgb2YgcXVldWVzICovCiAKIAogLyogQ0wncyBpbnRlcm5hbCByZXF1ZXN0
 IGNvbnRleHQuICovCkBAIC0xMzMsNiArMTM0LDcgQEAKIAlUV19VSU5UOCAJCWludGVycnVwdHNf
 ZW5hYmxlZDsJICAvKiBJbnRlcnJ1cHRzIG9uIGNvbnRyb2xsZXIgZW5hYmxlZC4gKi8KIAlUV19V
 SU5UOCAJCWludGVybmFsX3JlcV9idXN5OwkgIC8qIERhdGEgYnVmZmVyIGZvciBpbnRlcm5hbCBy
 ZXF1ZXN0cyBpbiB1c2UuICovCiAJVFdfVUlOVDggCQlnZXRfbW9yZV9hZW5zOwkJICAvKiBNb3Jl
 IEFFTidzIG5lZWQgdG8gYmUgcmV0cmlldmVkLiAqLworCVRXX1VJTlQ4IAkJcmVzZXRfbmVlZGVk
 OwkJICAvKiBDb250cm9sbGVyIG5lZWRzIGEgc29mdCByZXNldC4gKi8KIAlUV19VSU5UOCAJCXJl
 c2V0X2luX3Byb2dyZXNzOwkgIC8qIENvbnRyb2xsZXIgaXMgYmVpbmcgcmVzZXQuICovCiAJVFdf
 VUlOVDggCQlyZXNldF9waGFzZTFfaW5fcHJvZ3Jlc3M7IC8qIEluICdwaGFzZSAxJyBvZiByZXNl
 dC4gKi8KIAlUV19VSU5UMzIJCWZsYWdzOwkJLyogY29udHJvbGxlciBzZXR0aW5ncyAqLwpkaWZm
 IC11IEZyZWVCU0RfUkVMRU5HXzdfdHdhX2N2cy90d19jbF9leHRlcm5zLmggRnJlZUJTRDdfdHdh
 XzNfNzBfMDVfMDEwL3R3X2NsX2V4dGVybnMuaAotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3Zz
 L3R3X2NsX2V4dGVybnMuaAkyMDEwLTA4LTI2IDE1OjM1OjAwLjAwMDAwMDAwMCAtMDcwMAorKysg
 RnJlZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3X2NsX2V4dGVybnMuaAkyMDEwLTA4LTI0IDE4OjAx
 OjEzLjAwMDAwMDAwMCAtMDcwMApAQCAtODYsNiArODYsOCBAQAogCiAvKiBTb2Z0IHJlc2V0IHRo
 ZSBjb250cm9sbGVyLiAqLwogZXh0ZXJuIFRXX0lOVDMyCXR3X2NsaV9zb2Z0X3Jlc2V0KHN0cnVj
 dCB0d19jbGlfY3Rscl9jb250ZXh0ICpjdGxyKTsKK2V4dGVybiBpbnQgdHdhX3NldHVwX2ludHIo
 c3RydWN0IHR3YV9zb2Z0YyAqc2MpOworZXh0ZXJuIGludCB0d2FfdGVhcmRvd25faW50cihzdHJ1
 Y3QgdHdhX3NvZnRjICpzYyk7CiAKIC8qIFNlbmQgZG93biBhIFNDU0kgY29tbWFuZCB0byB0aGUg
 ZmlybXdhcmUgKHVzdWFsbHksIGFuIGludGVybmFsIFJlcSBTZW5zZS4gKi8KIGV4dGVybiBUV19J
 TlQzMgl0d19jbGlfc2VuZF9zY3NpX2NtZChzdHJ1Y3QgdHdfY2xpX3JlcV9jb250ZXh0ICpyZXEs
 CmRpZmYgLXUgRnJlZUJTRF9SRUxFTkdfN190d2FfY3ZzL3R3X2NsX2Z3aWYuaCBGcmVlQlNEN190
 d2FfM183MF8wNV8wMTAvdHdfY2xfZndpZi5oCi0tLSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMv
 dHdfY2xfZndpZi5oCTIwMTAtMDgtMjYgMTU6MzU6MDAuMDAwMDAwMDAwIC0wNzAwCisrKyBGcmVl
 QlNEN190d2FfM183MF8wNV8wMTAvdHdfY2xfZndpZi5oCTIwMTAtMDgtMjQgMTg6MDE6MTMuMDAw
 MDAwMDAwIC0wNzAwCkBAIC04OSw3ICs4OSw3IEBACiAjZGVmaW5lIFRXQV9TVEFUVVNfTUlOT1Jf
 VkVSU0lPTl9NQVNLCQkweDBGMDAwMDAwCiAjZGVmaW5lIFRXQV9TVEFUVVNfTUFKT1JfVkVSU0lP
 Tl9NQVNLCQkweEYwMDAwMDAwCiAKLSNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJ
 CTB4MDBGMDAwMDAKKyNkZWZpbmUgVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMJCTB4MDBEMDAw
 MDAKIAogCiAvKiBQQ0kgcmVsYXRlZCBkZWZpbmVzLiAqLwpkaWZmIC11IEZyZWVCU0RfUkVMRU5H
 XzdfdHdhX2N2cy90d19jbF9pbml0LmMgRnJlZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3X2NsX2lu
 aXQuYwotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3ZzL3R3X2NsX2luaXQuYwkyMDEwLTA4LTI2
 IDE1OjM1OjAwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3
 X2NsX2luaXQuYwkyMDEwLTA4LTI0IDE4OjAxOjEzLjAwMDAwMDAwMCAtMDcwMApAQCAtMzE1LDYg
 KzMxNSw3IEBACiAJdHdfY2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX0JVU1lfUSk7CiAJdHdf
 Y2xpX3JlcV9xX2luaXQoY3RsciwgVFdfQ0xJX1BFTkRJTkdfUSk7CiAJdHdfY2xpX3JlcV9xX2lu
 aXQoY3RsciwgVFdfQ0xJX0NPTVBMRVRFX1EpOworCXR3X2NsaV9yZXFfcV9pbml0KGN0bHIsIFRX
 X0NMSV9SRVNFVF9RKTsKIAogCS8qIEluaXRpYWxpemUgYWxsIGxvY2tzIHVzZWQgYnkgQ0wuICov
 CiAJY3Rsci0+Z2VuX2xvY2sgPSAmKGN0bHItPmdlbl9sb2NrX2hhbmRsZSk7CkBAIC02NzUsMTUg
 KzY3NiwxNCBAQAogCS8qIFN1Ym1pdCB0aGUgY29tbWFuZCwgYW5kIHdhaXQgZm9yIGl0IHRvIGNv
 bXBsZXRlLiAqLwogCWVycm9yID0gdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwK
 IAkJVFdfQ0xJX1JFUVVFU1RfVElNRU9VVF9QRVJJT0QpOwotCWlmIChlcnJvciA9PSBUV19PU0xf
 RVRJTUVET1VUKQotCQkvKiBDbGVhbi11cCBkb25lIGJ5IHR3X2NsaV9zdWJtaXRfYW5kX3BvbGxf
 cmVxdWVzdC4gKi8KLQkJcmV0dXJuKGVycm9yKTsKIAlpZiAoZXJyb3IpCiAJCWdvdG8gb3V0Owog
 CWlmICgoZXJyb3IgPSBpbml0X2Nvbm5lY3QtPnN0YXR1cykpIHsKKyNpZiAgICAgICAwCiAJCXR3
 X2NsaV9jcmVhdGVfY3Rscl9ldmVudChjdGxyLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09O
 VFJPTExFUl9FUlJPUiwKIAkJCSYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjZW5kaWYgLy8g
 MAogCQlnb3RvIG91dDsKIAl9CiAJaWYgKHNldF9mZWF0dXJlcyAmIFRXQV9FWFRFTkRFRF9JTklU
 X0NPTk5FQ1QpIHsKZGlmZiAtdSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMvdHdfY2xfaW50ci5j
 IEZyZWVCU0Q3X3R3YV8zXzcwXzA1XzAxMC90d19jbF9pbnRyLmMKLS0tIEZyZWVCU0RfUkVMRU5H
 XzdfdHdhX2N2cy90d19jbF9pbnRyLmMJMjAxMC0wOC0yNiAxNTozNTowMC4wMDAwMDAwMDAgLTA3
 MDAKKysrIEZyZWVCU0Q3X3R3YV8zXzcwXzA1XzAxMC90d19jbF9pbnRyLmMJMjAxMC0wOC0yNCAx
 ODowMToxMy4wMDAwMDAwMDAgLTA3MDAKQEAgLTI0OCw4ICsyNDgsNyBAQAogI2lmZGVmIFRXX09T
 TF9ERUJVRwogCQkJdHdfY2xfcHJpbnRfY3Rscl9zdGF0cyhjdGxyLT5jdGxyX2hhbmRsZSk7CiAj
 ZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCi0JCQl0d19jbF9yZXNldF9jdGxyKGN0bHItPmN0bHJf
 aGFuZGxlKTsKLQkJCXJldHVybihUV19PU0xfRUlPKTsKKwkJCWNvbnRpbnVlOwogCQl9CiAKIAkJ
 LyoKQEAgLTQwMiw5ICs0MDEsNyBAQAogI2lmZGVmIFRXX09TTF9ERUJVRwogCQl0d19jbF9wcmlu
 dF9jdGxyX3N0YXRzKGN0bHItPmN0bHJfaGFuZGxlKTsKICNlbmRpZiAvKiBUV19PU0xfREVCVUcg
 Ki8KLQkJdHdfY2xfcmVzZXRfY3RscihjdGxyLT5jdGxyX2hhbmRsZSk7Ci0JCXJlcV9wa3QtPnN0
 YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQlnb3RvIG91dDsKKwkJcmV0dXJuOwog
 CX0KIAogCWlmIChyZXEtPmZsYWdzICYgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSkgewpAQCAt
 NDgzLDYgKzQ4MCw3IEBACiAJCQljZGJbOF0sIGNkYls5XSwgY2RiWzEwXSwgY2RiWzExXSwKIAkJ
 CWNkYlsxMl0sIGNkYlsxM10sIGNkYlsxNF0sIGNkYlsxNV0pOwogCisjaWYgICAgICAgMAogCQkv
 KiAKIAkJICogUHJpbnQgdGhlIGVycm9yLiBGaXJtd2FyZSBkb2Vzbid0IHlldCBzdXBwb3J0CiAJ
 CSAqIHRoZSAnTW9kZSBTZW5zZScgY21kLiAgRG9uJ3QgcHJpbnQgaWYgdGhlIGNtZApAQCAtNDkz
 LDYgKzQ5MSw3IEBACiAJCQl0d19jbGlfY3JlYXRlX2N0bHJfZXZlbnQocmVxLT5jdGxyLAogCQkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1IsCiAJCQkJY21kX2hkcik7Cisj
 ZW5kaWYgLy8gMAogCX0KIAogCWlmIChzY3NpX3JlcS0+c2Vuc2VfZGF0YSkgewpAQCAtNTMwLDkg
 KzUyOSwxMSBAQAogCSAqLwogCWlmICghIHJlcS0+ZXJyb3JfY29kZSkKIAkJaWYgKGNtZC0+cGFy
 YW0uc3RhdHVzKSB7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2NyZWF0ZV9jdGxyX2V2ZW50KGN0
 bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExFUl9FUlJPUiwKIAkJCQkmKHJl
 cS0+Y21kX3BrdC0+Y21kX2hkcikpOworI2VuZGlmIC8vIDAKIAkJCXR3X2NsX2NyZWF0ZV9ldmVu
 dChjdGxyLT5jdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfQ09NTU9OX0xBWUVSX0VSUk9SLAogCQkJCTB4MTIwNCwgMHgxLCBUV19DTF9TRVZFUklUWV9F
 UlJPUl9TVFJJTkcsCkBAIC01OTAsOSArNTkxLDExIEBACiAJCWlmICgoZXJyb3IgPSBjbWQtPnN0
 YXR1cykpIHsKIAkJCWNtZF9oZHIgPSAoc3RydWN0IHR3X2NsX2NvbW1hbmRfaGVhZGVyICopCiAJ
 CQkJKCYocmVxLT5jbWRfcGt0LT5jbWRfaGRyKSk7CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2Ny
 ZWF0ZV9jdGxyX2V2ZW50KGN0bHIsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExF
 Ul9FUlJPUiwKIAkJCQljbWRfaGRyKTsKKyNlbmRpZiAvLyAwCiAJCQl0d19jbF9jcmVhdGVfZXZl
 bnQoY3Rsci0+Y3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09V
 UkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCQkweDEyMDYsIDB4MSwgVFdfQ0xfU0VWRVJJVFlf
 RVJST1JfU1RSSU5HLApkaWZmIC11IEZyZWVCU0RfUkVMRU5HXzdfdHdhX2N2cy90d19jbF9pby5j
 IEZyZWVCU0Q3X3R3YV8zXzcwXzA1XzAxMC90d19jbF9pby5jCi0tLSBGcmVlQlNEX1JFTEVOR183
 X3R3YV9jdnMvdHdfY2xfaW8uYwkyMDEwLTA4LTI2IDE1OjM1OjAwLjAwMDAwMDAwMCAtMDcwMAor
 KysgRnJlZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3X2NsX2lvLmMJMjAxMC0wOC0yNCAxODowMTox
 My4wMDAwMDAwMDAgLTA3MDAKQEAgLTc0LDE4ICs3NCwxMiBAQAogCXN0cnVjdCB0d19jbGlfcmVx
 X2NvbnRleHQJCSpyZXE7CiAJc3RydWN0IHR3X2NsX2NvbW1hbmRfOWsJCQkqY21kOwogCXN0cnVj
 dCB0d19jbF9zY3NpX3JlcV9wYWNrZXQJCSpzY3NpX3JlcTsKLQlUV19JTlQzMgkJCQllcnJvcjsK
 KwlUV19JTlQzMgkJCQllcnJvciA9IFRXX0NMX0VSUl9SRVFfU1VDQ0VTUzsKIAogCXR3X2NsaV9k
 YmdfcHJpbnRmKDEwLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7
 CiAKIAljdGxyID0gKHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICopKGN0bHJfaGFuZGxlLT5j
 bF9jdGxyX2N0eHQpOwogCi0JaWYgKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSB7Ci0JCXR3X2Ns
 aV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwKLQkJCSJJL08g
 ZHVyaW5nIHJlc2V0OiByZXR1cm5pbmcgYnVzeS4iKTsKLQkJcmV0dXJuKFRXX09TTF9FQlVTWSk7
 Ci0JfQotCiAJLyoKIAkgKiBJZiB3b3JraW5nIHdpdGggYSBmaXJtd2FyZSB2ZXJzaW9uIHRoYXQg
 ZG9lcyBub3Qgc3VwcG9ydCBtdWx0aXBsZQogCSAqIGx1bnMsIGFuZCB0aGlzIHJlcXVlc3QgaXMg
 ZGlyZWN0ZWQgYXQgYSBub24temVybyBsdW4sIGVycm9yIGl0CkBAIC0xNDUsNyArMTM5LDEyIEBA
 CiAJCQljbWQtPnNnX2xpc3QsIHNjc2lfcmVxLT5zZ2xfZW50cmllcyk7CiAJfQogCi0JaWYgKChl
 cnJvciA9IHR3X2NsaV9zdWJtaXRfY21kKHJlcSkpKSB7CisJaWYgKCgoVFdfQ0xfUV9GSVJTVF9J
 VEVNKCYoY3Rsci0+cmVxX3FfaGVhZFtUV19DTElfUEVORElOR19RXSkpKSAhPSBUV19DTF9OVUxM
 KSB8fAorCQkoY3Rsci0+cmVzZXRfaW5fcHJvZ3Jlc3MpKSB7CisJCXR3X2NsaV9yZXFfcV9pbnNl
 cnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOworCQlUV19DTElfV1JJVEVfQ09OVFJPTF9S
 RUdJU1RFUihjdGxyX2hhbmRsZSwKKwkJCVRXQV9DT05UUk9MX1VOTUFTS19DT01NQU5EX0lOVEVS
 UlVQVCk7CisJfSBlbHNlIGlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgewog
 CQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1cl9mdW5jKCksCiAJ
 CQkiQ291bGQgbm90IHN0YXJ0IHJlcXVlc3QuIHJlcXVlc3QgPSAlcCwgZXJyb3IgPSAlZCIsCiAJ
 CQlyZXEsIGVycm9yKTsKQEAgLTE3MSw3ICsxNzAsNyBAQAogCXN0cnVjdCB0d19jbGlfY3Rscl9j
 b250ZXh0CSpjdGxyID0gcmVxLT5jdGxyOwogCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZQkqY3Rs
 cl9oYW5kbGUgPSBjdGxyLT5jdGxyX2hhbmRsZTsKIAlUV19VSU5UMzIJCQlzdGF0dXNfcmVnOwot
 CVRXX0lOVDMyCQkJZXJyb3I7CisJVFdfSU5UMzIJCQllcnJvciA9IDA7CiAKIAl0d19jbGlfZGJn
 X3ByaW50ZigxMCwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLCAiZW50ZXJlZCIpOwog
 CkBAIC0xODUsMTEgKzE4NCw3IEBACiAJCQkJIFRXQV9DT01NQU5EX1FVRVVFX09GRlNFVF9MT1cs
 CiAJCQkJIChUV19VSU5UMzIpKHJlcS0+Y21kX3BrdF9waHlzICsgc2l6ZW9mKHN0cnVjdCB0d19j
 bF9jb21tYW5kX2hlYWRlcikpLCA0KTsKIAotCS8qIENoZWNrIHRvIHNlZSBpZiB3ZSBjYW4gcG9z
 dCBhIGNvbW1hbmQuICovCiAJc3RhdHVzX3JlZyA9IFRXX0NMSV9SRUFEX1NUQVRVU19SRUdJU1RF
 UihjdGxyX2hhbmRsZSk7Ci0JaWYgKChlcnJvciA9IHR3X2NsaV9jaGVja19jdGxyX3N0YXRlKGN0
 bHIsIHN0YXR1c19yZWcpKSkKLQkJZ290byBvdXQ7Ci0KIAlpZiAoc3RhdHVzX3JlZyAmIFRXQV9T
 VEFUVVNfQ09NTUFORF9RVUVVRV9GVUxMKSB7CiAJCXN0cnVjdCB0d19jbF9yZXFfcGFja2V0CSpy
 ZXFfcGt0ID0KIAkJCShzdHJ1Y3QgdHdfY2xfcmVxX3BhY2tldCAqKShyZXEtPm9yaWdfcmVxKTsK
 QEAgLTIwNywxNCArMjAyLDEyIEBACiAJCQkJCSJwZW5kaW5nIGludGVybmFsL2lvY3RsIHJlcXVl
 c3QiKTsKIAkJCQlyZXEtPnN0YXRlID0gVFdfQ0xJX1JFUV9TVEFURV9QRU5ESU5HOwogCQkJCXR3
 X2NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX0NMSV9QRU5ESU5HX1EpOwotCQkJCWVycm9y
 ID0gMDsKIAkJCQkvKiBVbm1hc2sgY29tbWFuZCBpbnRlcnJ1cHQuICovCiAJCQkJVFdfQ0xJX1dS
 SVRFX0NPTlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCiAJCQkJCVRXQV9DT05UUk9MX1VOTUFT
 S19DT01NQU5EX0lOVEVSUlVQVCk7CiAJCQl9IGVsc2UKIAkJCQllcnJvciA9IFRXX09TTF9FQlVT
 WTsKIAkJfSBlbHNlIHsKLQkJCXR3X29zbF9jdGxyX2J1c3koY3Rscl9oYW5kbGUsIHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQllcnJvciA9IFRXX09TTF9FQlVTWTsKIAkJfQogCX0gZWxzZSB7CkBAIC0y
 NDYsNyArMjM5LDcgQEAKIAkJCQkJCSAoVFdfVUlOVDMyKShyZXEtPmNtZF9wa3RfcGh5cyArIHNp
 emVvZihzdHJ1Y3QgdHdfY2xfY29tbWFuZF9oZWFkZXIpKSwgNCk7CiAJCX0KIAl9Ci1vdXQ6CisK
 IAl0d19vc2xfZnJlZV9sb2NrKGN0bHJfaGFuZGxlLCBjdGxyLT5pb19sb2NrKTsKIAogCXJldHVy
 bihlcnJvcik7CkBAIC0yNzcsMTggKzI3MCwxMiBAQAogCVRXX1VJTlQ4CQkJCW9wY29kZTsKIAlU
 V19VSU5UOAkJCQlzZ2xfb2Zmc2V0OwogCVRXX1ZPSUQJCQkJCSpzZ2wgPSBUV19DTF9OVUxMOwot
 CVRXX0lOVDMyCQkJCWVycm9yOworCVRXX0lOVDMyCQkJCWVycm9yID0gVFdfQ0xfRVJSX1JFUV9T
 VUNDRVNTOwogCiAJdHdfY2xpX2RiZ19wcmludGYoNSwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJf
 ZnVuYygpLCAiZW50ZXJlZCIpOwogCiAJY3RsciA9IChzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4
 dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKIAotCWlmIChjdGxyLT5yZXNldF9pbl9w
 cm9ncmVzcykgewotCQl0d19jbGlfZGJnX3ByaW50ZigyLCBjdGxyX2hhbmRsZSwgdHdfb3NsX2N1
 cl9mdW5jKCksCi0JCQkiUGFzc3RocnUgcmVxdWVzdCBkdXJpbmcgcmVzZXQ6IHJldHVybmluZyBi
 dXN5LiIpOwotCQlyZXR1cm4oVFdfT1NMX0VCVVNZKTsKLQl9Ci0KIAlpZiAoKHJlcSA9IHR3X2Ns
 aV9nZXRfcmVxdWVzdChjdGxyCiAJCSkpID09IFRXX0NMX05VTEwpIHsKIAkJdHdfY2xpX2RiZ19w
 cmludGYoMiwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLApAQCAtMzAxLDcgKzI4OCw3
 IEBACiAJcmVxLT5vcmlnX3JlcSA9IHJlcV9wa3Q7CiAJcmVxLT50d19jbGlfY2FsbGJhY2sgPSB0
 d19jbGlfY29tcGxldGVfaW87CiAKLQlyZXEtPmZsYWdzIHw9IChUV19DTElfUkVRX0ZMQUdTX0VY
 VEVSTkFMIHwgVFdfQ0xJX1JFUV9GTEFHU19QQVNTVEhSVSk7CisJcmVxLT5mbGFncyB8PSBUV19D
 TElfUkVRX0ZMQUdTX1BBU1NUSFJVOwogCiAJcHRfcmVxID0gJihyZXFfcGt0LT5nZW5fcmVxX3Br
 dC5wdF9yZXEpOwogCkBAIC0zNDgsNyArMzM1LDEyIEBACiAJCXR3X2NsaV9maWxsX3NnX2xpc3Qo
 Y3RsciwgcHRfcmVxLT5zZ19saXN0LAogCQkJc2dsLCBwdF9yZXEtPnNnbF9lbnRyaWVzKTsKIAot
 CWlmICgoZXJyb3IgPSB0d19jbGlfc3VibWl0X2NtZChyZXEpKSkgeworCWlmICgoKFRXX0NMX1Ff
 RklSU1RfSVRFTSgmKGN0bHItPnJlcV9xX2hlYWRbVFdfQ0xJX1BFTkRJTkdfUV0pKSkgIT0gVFdf
 Q0xfTlVMTCkgfHwKKwkJKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkgeworCQl0d19jbGlfcmVx
 X3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfUEVORElOR19RKTsKKwkJVFdfQ0xJX1dSSVRFX0NP
 TlRST0xfUkVHSVNURVIoY3Rscl9oYW5kbGUsCisJCQlUV0FfQ09OVFJPTF9VTk1BU0tfQ09NTUFO
 RF9JTlRFUlJVUFQpOworCX0gZWxzZSBpZiAoKGVycm9yID0gdHdfY2xpX3N1Ym1pdF9jbWQocmVx
 KSkpIHsKIAkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FUlJPUiwKIAkJCTB4MTEwMCwgMHgx
 LCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCkBAIC0zNzYsNyArMzY4LDcgQEAKICAqCQkJ
 bm9uLXplcm8tLSBmYWlsdXJlCiAgKi8KIFRXX0lOVDMyCi10d19jbF9pb2N0bChzdHJ1Y3QgdHdf
 Y2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLCBUV19JTlQzMiBjbWQsIFRXX1ZPSUQgKmJ1ZikK
 K3R3X2NsX2lvY3RsKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUsIHVfbG9u
 ZyBjbWQsIFRXX1ZPSUQgKmJ1ZikKIHsKIAlzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dAkqY3Rs
 ciA9CiAJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rs
 cl9jdHh0KTsKQEAgLTc2MCw4ICs3NTIsNyBAQAogCiAJY21kLT5wYXJhbS5zZ2xfb2ZmX19vcGNv
 ZGUgPQogCQlCVUlMRF9TR0xfT0ZGX19PUENPREUoMiwgVFdBX0ZXX0NNRF9HRVRfUEFSQU0pOwot
 CWNtZC0+cGFyYW0ucmVxdWVzdF9pZCA9Ci0JCShUV19VSU5UOCkoVFdfQ0xfU1dBUDE2KHJlcS0+
 cmVxdWVzdF9pZCkpOworCWNtZC0+cGFyYW0ucmVxdWVzdF9pZCA9IChUV19VSU5UOCkoVFdfQ0xf
 U1dBUDE2KHJlcS0+cmVxdWVzdF9pZCkpOwogCWNtZC0+cGFyYW0uaG9zdF9pZF9fdW5pdCA9IEJV
 SUxEX0hPU1RfSURfX1VOSVQoMCwgMCk7CiAJY21kLT5wYXJhbS5wYXJhbV9jb3VudCA9IFRXX0NM
 X1NXQVAxNigxKTsKIApAQCAtNzg5LDE1ICs3ODAsMTQgQEAKIAkJLyogVGhlcmUncyBubyBjYWxs
 IGJhY2s7IHdhaXQgdGlsbCB0aGUgY29tbWFuZCBjb21wbGV0ZXMuICovCiAJCWVycm9yID0gdHdf
 Y2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0KHJlcSwKIAkJCQlUV19DTElfUkVRVUVTVF9USU1F
 T1VUX1BFUklPRCk7Ci0JCWlmIChlcnJvciA9PSBUV19PU0xfRVRJTUVET1VUKQotCQkJLyogQ2xl
 YW4tdXAgZG9uZSBieSB0d19jbGlfc3VibWl0X2FuZF9wb2xsX3JlcXVlc3QuICovCi0JCQlyZXR1
 cm4oZXJyb3IpOwogCQlpZiAoZXJyb3IpCiAJCQlnb3RvIG91dDsKIAkJaWYgKChlcnJvciA9IGNt
 ZC0+cGFyYW0uc3RhdHVzKSkgeworI2lmICAgICAgIDAKIAkJCXR3X2NsaV9jcmVhdGVfY3Rscl9l
 dmVudChjdGxyLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTlRST0xMRVJfRVJST1IsCiAJ
 CQkJJihyZXEtPmNtZF9wa3QtPmNtZF9oZHIpKTsKKyNlbmRpZiAvLyAwCiAJCQlnb3RvIG91dDsK
 IAkJfQogCQl0d19vc2xfbWVtY3B5KHBhcmFtX2RhdGEsIHBhcmFtLT5kYXRhLCBwYXJhbV9zaXpl
 KTsKQEAgLTkwNSwxOCArODk1LDE3IEBACiAKIAkvKiBTdWJtaXQgdGhlIGNvbW1hbmQuICovCiAJ
 aWYgKGNhbGxiYWNrID09IFRXX0NMX05VTEwpIHsKLQkJLyogVGhlcmUncyBubyBjYWxsIGJhY2s7
 ICB3YWl0IHRpbGwgdGhlIGNvbW1hbmQgY29tcGxldGVzLiAqLworCQkvKiBUaGVyZSdzIG5vIGNh
 bGwgYmFjazsgd2FpdCB0aWxsIHRoZSBjb21tYW5kIGNvbXBsZXRlcy4gKi8KIAkJZXJyb3IgPSB0
 d19jbGlfc3VibWl0X2FuZF9wb2xsX3JlcXVlc3QocmVxLAotCQkJVFdfQ0xJX1JFUVVFU1RfVElN
 RU9VVF9QRVJJT0QpOwotCQlpZiAoZXJyb3IgPT0gVFdfT1NMX0VUSU1FRE9VVCkKLQkJCS8qIENs
 ZWFuLXVwIGRvbmUgYnkgdHdfY2xpX3N1Ym1pdF9hbmRfcG9sbF9yZXF1ZXN0LiAqLwotCQkJcmV0
 dXJuKGVycm9yKTsKKwkJCQlUV19DTElfUkVRVUVTVF9USU1FT1VUX1BFUklPRCk7CiAJCWlmIChl
 cnJvcikKIAkJCWdvdG8gb3V0OwogCQlpZiAoKGVycm9yID0gY21kLT5wYXJhbS5zdGF0dXMpKSB7
 CisjaWYgICAgICAgMAogCQkJdHdfY2xpX2NyZWF0ZV9jdGxyX2V2ZW50KGN0bHIsCiAJCQkJVFdf
 Q0xfTUVTU0FHRV9TT1VSQ0VfQ09OVFJPTExFUl9FUlJPUiwKIAkJCQkmKHJlcS0+Y21kX3BrdC0+
 Y21kX2hkcikpOworI2VuZGlmIC8vIDAKIAkJCWdvdG8gb3V0OwogCQl9CiAJCWN0bHItPmludGVy
 bmFsX3JlcV9idXN5ID0gVFdfQ0xfRkFMU0U7CkBAIC0xMDIyLDkgKzEwMTEsNyBAQAogCSAqIHR3
 X2NsaV9zdWJtaXRfcGVuZGluZ19xdWV1ZS4gIFRoZXJlIGNvdWxkIGJlIGEgcmFjZSBpbiB0aGF0
 IGNhc2UuCiAJICogTmVlZCB0byByZXZpc2l0LgogCSAqLwotCWlmIChyZXEtPnN0YXRlICE9IFRX
 X0NMSV9SRVFfU1RBVEVfUEVORElORykKLQkJdHdfY2xfcmVzZXRfY3RscihjdGxyLT5jdGxyX2hh
 bmRsZSk7Ci0JZWxzZSB7CisJaWYgKHJlcS0+c3RhdGUgPT0gVFdfQ0xJX1JFUV9TVEFURV9QRU5E
 SU5HKSB7CiAJCXR3X2NsaV9kYmdfcHJpbnRmKDMsIGN0bHItPmN0bHJfaGFuZGxlLCB0d19vc2xf
 Y3VyX2Z1bmMoKSwKIAkJCSJSZW1vdmluZyByZXF1ZXN0IGZyb20gcGVuZGluZyBxdWV1ZSIpOwog
 CQkvKgpAQCAtMTA1Myw2ICsxMDQwLDcgQEAKICAqCQkJZHJhaW5zIGFueSBpbmNvbXBsZXRlIHJl
 cXVlc3RzLgogICoKICAqIElucHV0OgkJY3RscgktLSBwdHIgdG8gcGVyIGN0bHIgc3RydWN0dXJl
 CisgKiAJCQlyZXFfaGFuZGxlCS0tIHB0ciB0byByZXF1ZXN0IGhhbmRsZQogICogT3V0cHV0OgkJ
 Tm9uZQogICogUmV0dXJuIHZhbHVlOgkwCS0tIHN1Y2Nlc3MKICAqCQkJbm9uLXplcm8tLSBmYWls
 dXJlCkBAIC0xMDYzLDE1ICsxMDUxLDE1IEBACiAJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJ
 KmN0bHIgPQogCQkoc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQgKikoY3Rscl9oYW5kbGUtPmNs
 X2N0bHJfY3R4dCk7CiAJc3RydWN0IHR3YV9zb2Z0YwkJKnNjID0gY3Rscl9oYW5kbGUtPm9zbF9j
 dGxyX2N0eHQ7CisJc3RydWN0IHR3X2NsaV9yZXFfY29udGV4dAkqcmVxOwogCVRXX0lOVDMyCQkJ
 cmVzZXRfYXR0ZW1wdCA9IDE7Ci0JVFdfSU5UMzIJCQllcnJvcjsKKwlUV19JTlQzMgkJCWVycm9y
 ID0gMDsKIAogCXR3X2NsaV9kYmdfcHJpbnRmKDIsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1
 bmMoKSwgImVudGVyZWQiKTsKIAogCWN0bHItPnJlc2V0X2luX3Byb2dyZXNzID0gVFdfQ0xfVFJV
 RTsKLQl4cHRfZnJlZXplX3NpbXEoc2MtPnNpbSwgMSk7CisJdHdhX3RlYXJkb3duX2ludHIoc2Mp
 OwogCi0JdHdfY2xpX2Rpc2FibGVfaW50ZXJydXB0cyhjdGxyKTsKIAogCS8qCiAJICogRXJyb3Ig
 YmFjayBhbGwgcmVxdWVzdHMgaW4gdGhlIGNvbXBsZXRlLCBidXN5LCBhbmQgcGVuZGluZyBxdWV1
 ZXMuCkBAIC0xMDgwLDggKzEwNjgsNiBAQAogCSAqIHdpbGwgY29udGludWUgaXRzIGNvdXJzZSBh
 bmQgZ2V0IHN1Ym1pdHRlZCB0byB0aGUgY29udHJvbGxlciBhZnRlcgogCSAqIHRoZSByZXNldCBp
 cyBkb25lIChhbmQgaW9fbG9jayBpcyByZWxlYXNlZCkuCiAJICovCi0JdHdfY2xpX2RiZ19wcmlu
 dGYoMiwgY3Rscl9oYW5kbGUsIHR3X29zbF9jdXJfZnVuYygpLAotCQkiRHJhaW5pbmcgYWxsIHF1
 ZXVlcyBmb2xsb3dpbmcgcmVzZXQiKTsKIAl0d19jbGlfZHJhaW5fY29tcGxldGVfcXVldWUoY3Rs
 cik7CiAJdHdfY2xpX2RyYWluX2J1c3lfcXVldWUoY3Rscik7CiAJdHdfY2xpX2RyYWluX3BlbmRp
 bmdfcXVldWUoY3Rscik7CkBAIC0xMDg5LDUzICsxMDc1LDg4IEBACiAJY3Rsci0+Z2V0X21vcmVf
 YWVucyAgICAgPSBUV19DTF9GQUxTRTsKIAogCS8qIFNvZnQgcmVzZXQgdGhlIGNvbnRyb2xsZXIu
 ICovCi10cnlfcmVzZXQ6Ci0JaWYgKChlcnJvciA9IHR3X2NsaV9zb2Z0X3Jlc2V0KGN0bHIpKSkg
 ewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCi0JCQlUV19D
 TF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZFTlQsCi0JCQkweDExMDUsIDB4MSwgVFdf
 Q0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAotCQkJIkNvbnRyb2xsZXIgcmVzZXQgZmFpbGVkIiwK
 LQkJCSJlcnJvciA9ICVkOyBhdHRlbXB0ICVkIiwgZXJyb3IsIHJlc2V0X2F0dGVtcHQrKyk7Ci0J
 CWlmIChyZXNldF9hdHRlbXB0IDw9IFRXX0NMSV9NQVhfUkVTRVRfQVRURU1QVFMpCi0JCQlnb3Rv
 IHRyeV9yZXNldDsKLQkJZWxzZQotCQkJZ290byBvdXQ7Ci0JfQorCXdoaWxlIChyZXNldF9hdHRl
 bXB0IDw9IFRXX0NMSV9NQVhfUkVTRVRfQVRURU1QVFMpIHsKKwkJaWYgKChlcnJvciA9IHR3X2Ns
 aV9zb2Z0X3Jlc2V0KGN0bHIpKSkgeworCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxl
 LCBUV19DTF9GQUxTRSwKKwkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZF
 TlQsCisJCQkJMHgxMTA1LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKKwkJCQki
 Q29udHJvbGxlciByZXNldCBmYWlsZWQiLAorCQkJCSJlcnJvciA9ICVkOyBhdHRlbXB0ICVkIiwg
 ZXJyb3IsIHJlc2V0X2F0dGVtcHQrKyk7CisJCQlyZXNldF9hdHRlbXB0Kys7CisJCQljb250aW51
 ZTsKKwkJfQogCi0JLyogUmUtZXN0YWJsaXNoIGxvZ2ljYWwgY29ubmVjdGlvbiB3aXRoIHRoZSBj
 b250cm9sbGVyLiAqLwotCWlmICgoZXJyb3IgPSB0d19jbGlfaW5pdF9jb25uZWN0aW9uKGN0bHIs
 Ci0JCQkoVFdfVUlOVDE2KShjdGxyLT5tYXhfc2ltdWx0X3JlcXMpLAotCQkJMCwgMCwgMCwgMCwg
 MCwgVFdfQ0xfTlVMTCwgVFdfQ0xfTlVMTCwgVFdfQ0xfTlVMTCwKLQkJCVRXX0NMX05VTEwsIFRX
 X0NMX05VTEwpKSkgewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCS8qIFJlLWVzdGFibGlzaCBsb2dpY2FsIGNvbm5lY3Rpb24gd2l0aCB0aGUgY29udHJv
 bGxlci4gKi8KKwkJaWYgKChlcnJvciA9IHR3X2NsaV9pbml0X2Nvbm5lY3Rpb24oY3RsciwKKwkJ
 CQkoVFdfVUlOVDE2KShjdGxyLT5tYXhfc2ltdWx0X3JlcXMpLAorCQkJCTAsIDAsIDAsIDAsIDAs
 IFRXX0NMX05VTEwsIFRXX0NMX05VTEwsIFRXX0NMX05VTEwsCisJCQkJVFdfQ0xfTlVMTCwgVFdf
 Q0xfTlVMTCkpKSB7CisJCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZB
 TFNFLAorCQkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKKwkJCQkw
 eDExMDYsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAorCQkJCSJDYW4ndCBpbml0
 aWFsaXplIGNvbm5lY3Rpb24gYWZ0ZXIgcmVzZXQiLAorCQkJCSJlcnJvciA9ICVkIiwgZXJyb3Ip
 OworCQkJcmVzZXRfYXR0ZW1wdCsrOworCQkJY29udGludWU7CisJCX0KKworI2lmZGVmICAgIFRX
 X09TTF9ERUJVRworCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNF
 LAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAotCQkJMHgxMTA2
 LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCSJDYW4ndCBpbml0aWFsaXpl
 IGNvbm5lY3Rpb24gYWZ0ZXIgcmVzZXQiLAotCQkJImVycm9yID0gJWQiLCBlcnJvcik7Ci0JCWdv
 dG8gb3V0OwotCX0KKwkJCTB4MTEwNywgMHgzLCBUV19DTF9TRVZFUklUWV9JTkZPX1NUUklORywK
 KwkJCSJDb250cm9sbGVyIHJlc2V0IGRvbmUhIiwgIiAiKTsKKyNlbmRpZiAvKiBUV19PU0xfREVC
 VUcgKi8KKwkJYnJlYWs7CisJfSAvKiBFbmQgb2Ygd2hpbGUgKi8KIAotCXR3X2NsX2NyZWF0ZV9l
 dmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKLQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09N
 TU9OX0xBWUVSX0VWRU5ULAotCQkweDExMDcsIDB4MywgVFdfQ0xfU0VWRVJJVFlfSU5GT19TVFJJ
 TkcsCi0JCSJDb250cm9sbGVyIHJlc2V0IGRvbmUhIiwKLQkJIiAiKTsKKwkvKiBNb3ZlIGNvbW1h
 bmRzIGZyb20gdGhlIHJlc2V0IHF1ZXVlIHRvIHRoZSBwZW5kaW5nIHF1ZXVlLiAqLworCXdoaWxl
 ICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFkKGN0bHIsIFRXX0NMSV9SRVNFVF9RKSkg
 IT0gVFdfQ0xfTlVMTCkgeworCQl0d19vc2xfdGltZW91dChyZXEtPnJlcV9oYW5kbGUpOworCQl0
 d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfUEVORElOR19RKTsKKwl9CiAKLW91
 dDoKKwl0d2Ffc2V0dXBfaW50cihzYyk7CisJdHdfY2xpX2VuYWJsZV9pbnRlcnJ1cHRzKGN0bHIp
 OworCWlmICgoVFdfQ0xfUV9GSVJTVF9JVEVNKCYoY3Rsci0+cmVxX3FfaGVhZFtUV19DTElfUEVO
 RElOR19RXSkpKSAhPSBUV19DTF9OVUxMKQorCQlUV19DTElfV1JJVEVfQ09OVFJPTF9SRUdJU1RF
 UihjdGxyX2hhbmRsZSwKKwkJCVRXQV9DT05UUk9MX1VOTUFTS19DT01NQU5EX0lOVEVSUlVQVCk7
 CiAJY3Rsci0+cmVzZXRfaW5fcHJvZ3Jlc3MgPSBUV19DTF9GQUxTRTsKLQl4cHRfcmVsZWFzZV9z
 aW1xKHNjLT5zaW0sIDEpOworCWN0bHItPnJlc2V0X25lZWRlZCA9IFRXX0NMX0ZBTFNFOwogCi0J
 LyoKLQkgKiBFbmFibGUgaW50ZXJydXB0cywgYW5kIGFsc28gY2xlYXIgYXR0ZW50aW9uIGFuZCBy
 ZXNwb25zZSBpbnRlcnJ1cHRzLgotCSAqLwotCXR3X2NsaV9lbmFibGVfaW50ZXJydXB0cyhjdGxy
 KTsKLQkKIAkvKiBSZXF1ZXN0IGZvciBhIGJ1cyByZS1zY2FuLiAqLwotCWlmICghZXJyb3IpCi0J
 CXR3X29zbF9zY2FuX2J1cyhjdGxyX2hhbmRsZSk7CisJdHdfb3NsX3NjYW5fYnVzKGN0bHJfaGFu
 ZGxlKTsKKwogCXJldHVybihlcnJvcik7CiB9CiAKK1RXX1ZPSUQKK3R3X2NsX3NldF9yZXNldF9u
 ZWVkZWQoc3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSkKK3sKKwlzdHJ1Y3Qg
 dHdfY2xpX2N0bHJfY29udGV4dAkqY3RsciA9CisJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4
 dCAqKShjdGxyX2hhbmRsZS0+Y2xfY3Rscl9jdHh0KTsKKworCWN0bHItPnJlc2V0X25lZWRlZCA9
 IFRXX0NMX1RSVUU7Cit9CisKK1RXX0lOVDMyCit0d19jbF9pc19yZXNldF9uZWVkZWQoc3RydWN0
 IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSkKK3sKKwlzdHJ1Y3QgdHdfY2xpX2N0bHJf
 Y29udGV4dAkqY3RsciA9CisJCShzdHJ1Y3QgdHdfY2xpX2N0bHJfY29udGV4dCAqKShjdGxyX2hh
 bmRsZS0+Y2xfY3Rscl9jdHh0KTsKKworCXJldHVybihjdGxyLT5yZXNldF9uZWVkZWQpOworfQor
 CitUV19JTlQzMgordHdfY2xfaXNfYWN0aXZlKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rs
 cl9oYW5kbGUpCit7CisJc3RydWN0IHR3X2NsaV9jdGxyX2NvbnRleHQJKmN0bHIgPQorCQkoc3Ry
 dWN0IHR3X2NsaV9jdGxyX2NvbnRleHQgKikKKwkJKGN0bHJfaGFuZGxlLT5jbF9jdGxyX2N0eHQp
 OworCisJCXJldHVybihjdGxyLT5hY3RpdmUpOworfQorCiAKIAogLyoKQEAgLTExNTEsMTQgKzEx
 NzIsMTMgQEAKIHR3X2NsaV9zb2Z0X3Jlc2V0KHN0cnVjdCB0d19jbGlfY3Rscl9jb250ZXh0ICpj
 dGxyKQogewogCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZQkqY3Rscl9oYW5kbGUgPSBjdGxyLT5j
 dGxyX2hhbmRsZTsKLQlUV19VSU5UMzIJCQlzdGF0dXNfcmVnOwogCWludAkJCQlmb3VuZDsKIAlp
 bnQJCQkJbG9vcF9jb3VudDsKIAlUV19VSU5UMzIJCQllcnJvcjsKIAogCXR3X2NsaV9kYmdfcHJp
 bnRmKDEsIGN0bHJfaGFuZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwgImVudGVyZWQiKTsKIAotCXR3
 X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKKwl0d19jbF9jcmVhdGVf
 ZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCiAJCTB4MTEwOCwgMHgzLCBUV19DTF9TRVZFUklUWV9JTkZPX1NU
 UklORywKIAkJIlJlc2V0dGluZyBjb250cm9sbGVyLi4uIiwKQEAgLTExOTMsNyArMTIxMyw3IEBA
 CiAJCX0gd2hpbGUgKCFmb3VuZCAmJiAobG9vcF9jb3VudCA8IDYwMDAwMDApKTsgLyogTG9vcCBm
 b3Igbm8gbW9yZSB0aGFuIDYwIHNlY29uZHMgKi8KIAogCQlpZiAoIWZvdW5kKSB7Ci0JCQl0d19j
 bF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RSVUUsCisJCQl0d19jbF9jcmVhdGVf
 ZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNF
 X0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCQkweDExMDksIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJS
 T1JfU1RSSU5HLAogCQkJCSJNaXNzZWQgZmlybXdhcmUgaGFuZHNoYWtlIGFmdGVyIHNvZnQtcmVz
 ZXQiLApAQCAtMTIxMCw3ICsxMjMwLDcgQEAKIAkJCVRXQV9TVEFUVVNfTUlDUk9DT05UUk9MTEVS
 X1JFQURZIHwKIAkJCVRXQV9TVEFUVVNfQVRURU5USU9OX0lOVEVSUlVQVCwKIAkJCVRXX0NMSV9S
 RVNFVF9USU1FT1VUX1BFUklPRCkpKSB7Ci0JCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRs
 ZSwgVFdfQ0xfVFJVRSwKKwkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9G
 QUxTRSwKIAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCTB4
 MTEwOSwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkiTWljcm8tY3RsciBu
 b3QgcmVhZHkvTm8gYXR0biBpbnRyIGFmdGVyIHJlc2V0IiwKQEAgLTEyNDQsMjYgKzEyNjQsMTQg
 QEAKIAl9CiAJCiAJaWYgKChlcnJvciA9IHR3X2NsaV9maW5kX2FlbihjdGxyLCBUV0FfQUVOX1NP
 RlRfUkVTRVQpKSkgewotCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQlU
 V19DTF9NRVNTQUdFX1NPVVJDRV9DT01NT05fTEFZRVJfRVZFTlQsCiAJCQkweDExMEMsIDB4MSwg
 VFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAogCQkJIlJlc2V0IG5vdCByZXBvcnRlZCBieSBj
 b250cm9sbGVyIiwKIAkJCSJlcnJvciA9ICVkIiwgZXJyb3IpOwogCQlyZXR1cm4oZXJyb3IpOwog
 CX0KLQkKLQlzdGF0dXNfcmVnID0gVFdfQ0xJX1JFQURfU1RBVFVTX1JFR0lTVEVSKGN0bHJfaGFu
 ZGxlKTsKLQkKLQlpZiAoKGVycm9yID0gVFdfQ0xJX1NUQVRVU19FUlJPUlMoc3RhdHVzX3JlZykp
 IHx8Ci0JCQkoZXJyb3IgPSB0d19jbGlfY2hlY2tfY3Rscl9zdGF0ZShjdGxyLCBzdGF0dXNfcmVn
 KSkpIHsKLQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAotCQkJ
 VFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAotCQkJMHgxMTBELCAweDEs
 IFRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCSJDb250cm9sbGVyIGVycm9ycyBkZXRl
 Y3RlZCBhZnRlciByZXNldCIsCi0JCQkiZXJyb3IgPSAlZCIsIGVycm9yKTsKLQkJcmV0dXJuKGVy
 cm9yKTsKLQl9Ci0JCisKIAlyZXR1cm4oVFdfT1NMX0VTVUNDRVNTKTsKIH0KIApkaWZmIC11IEZy
 ZWVCU0RfUkVMRU5HXzdfdHdhX2N2cy90d19jbF9taXNjLmMgRnJlZUJTRDdfdHdhXzNfNzBfMDVf
 MDEwL3R3X2NsX21pc2MuYwotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3ZzL3R3X2NsX21pc2Mu
 YwkyMDEwLTA4LTI2IDE1OjM1OjAwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRDdfdHdhXzNf
 NzBfMDVfMDEwL3R3X2NsX21pc2MuYwkyMDEwLTA4LTI0IDE4OjAxOjEzLjAwMDAwMDAwMCAtMDcw
 MApAQCAtODMsNyArODMsOCBAQAogCXR3X2NsaV9kYmdfcHJpbnRmKDMsIGN0bHItPmN0bHJfaGFu
 ZGxlLCB0d19vc2xfY3VyX2Z1bmMoKSwgImVudGVyZWQiKTsKIAogCS8qIFdhbGsgdGhlIGJ1c3kg
 cXVldWUuICovCi0Jd2hpbGUgKChyZXEgPSB0d19jbGlfcmVxX3FfcmVtb3ZlX2hlYWQoY3Rsciwg
 VFdfQ0xJX0NPTVBMRVRFX1EpKSkgeworCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92
 ZV9oZWFkKGN0bHIsIFRXX0NMSV9DT01QTEVURV9RKSkgIT0KKwkJVFdfQ0xfTlVMTCkgewogCQlp
 ZiAocmVxLT5mbGFncyAmIFRXX0NMSV9SRVFfRkxBR1NfSU5URVJOQUwpIHsKIAkJCS8qCiAJCQkg
 KiBJdCdzIGFuIGludGVybmFsIHJlcXVlc3QuICBTZXQgdGhlIGFwcHJvcHJpYXRlCkBAIC05Nywy
 MCArOTgsMjEgQEAKIAkJCXJlcS0+ZXJyb3JfY29kZSA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VU
 OwogCQkJaWYgKHJlcS0+dHdfY2xpX2NhbGxiYWNrKQogCQkJCXJlcS0+dHdfY2xpX2NhbGxiYWNr
 KHJlcSk7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAoKHJlcV9wa3QgPSByZXEtPm9yaWdfcmVxKSkgewot
 CQkJCS8qIEl0J3MgYSBTQ1NJIHJlcXVlc3QuICBDb21wbGV0ZSBpdC4gKi8KLQkJCQl0d19jbGlf
 ZGJnX3ByaW50ZigyLCBjdGxyLT5jdGxyX2hhbmRsZSwKLQkJCQkJdHdfb3NsX2N1cl9mdW5jKCks
 Ci0JCQkJCSJDb21wbGV0aW5nIGNvbXBsZXRlIHJlcXVlc3QgJXAgIgotCQkJCQkib24gcmVzZXQi
 LAotCQkJCQlyZXEpOworCQl9IGVsc2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdT
 X1BBU1NUSFJVKSB7CisJCQkvKiBJdCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0
 LiAqLworCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewog
 CQkJCXJlcV9wa3QtPnN0YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9w
 a3QtPnR3X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3Qt
 PnR3X29zbF9jYWxsYmFjaykKKwkJCQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQl9CiAJCQl0d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElf
 RlJFRV9RKTsKKwkJfSBlbHNlIHsKKwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVl
 c3QuICBBZGQgaXQgdG8gdGhlIHJlc2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChy
 ZXEtPnJlcV9oYW5kbGUpOworCQkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X1JFU0VUX1EpOwogCQl9Ci0JfQorCX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBA
 IC0xMzUsNyArMTM3LDggQEAKIAl0d19jbGlfZGJnX3ByaW50ZigzLCBjdGxyLT5jdGxyX2hhbmRs
 ZSwgdHdfb3NsX2N1cl9mdW5jKCksICJlbnRlcmVkIik7CiAKIAkvKiBXYWxrIHRoZSBidXN5IHF1
 ZXVlLiAqLwotCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFkKGN0bHIsIFRX
 X0NMSV9CVVNZX1EpKSkgeworCXdoaWxlICgocmVxID0gdHdfY2xpX3JlcV9xX3JlbW92ZV9oZWFk
 KGN0bHIsIFRXX0NMSV9CVVNZX1EpKSAhPQorCQlUV19DTF9OVUxMKSB7CiAJCWlmIChyZXEtPmZs
 YWdzICYgVFdfQ0xJX1JFUV9GTEFHU19JTlRFUk5BTCkgewogCQkJLyoKIAkJCSAqIEl0J3MgYW4g
 aW50ZXJuYWwgcmVxdWVzdC4gIFNldCB0aGUgYXBwcm9wcmlhdGUKQEAgLTE0OSwxOSArMTUyLDIx
 IEBACiAJCQlyZXEtPmVycm9yX2NvZGUgPSBUV19DTF9FUlJfUkVRX0JVU19SRVNFVDsKIAkJCWlm
 IChyZXEtPnR3X2NsaV9jYWxsYmFjaykKIAkJCQlyZXEtPnR3X2NsaV9jYWxsYmFjayhyZXEpOwot
 CQl9IGVsc2UgewotCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkpIHsKLQkJCQkvKiBJ
 dCdzIGEgU0NTSSByZXF1ZXN0LiAgQ29tcGxldGUgaXQuICovCi0JCQkJdHdfY2xpX2RiZ19wcmlu
 dGYoMiwgY3Rsci0+Y3Rscl9oYW5kbGUsCi0JCQkJCXR3X29zbF9jdXJfZnVuYygpLAotCQkJCQki
 Q29tcGxldGluZyBidXN5IHJlcXVlc3QgJXAgb24gcmVzZXQiLAotCQkJCQlyZXEpOworCQl9IGVs
 c2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdTX1BBU1NUSFJVKSB7CisJCQkvKiBJ
 dCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0LiAqLworCQkJaWYgKChyZXFfcGt0
 ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewogCQkJCXJlcV9wa3QtPnN0YXR1cyA9
 IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9wa3QtPnR3X29zbF9jYWxsYmFjayhy
 ZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3QtPnR3X29zbF9jYWxsYmFjaykKKwkJ
 CQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVxX2hhbmRsZSk7CiAJCQl9CiAJCQl0
 d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElfRlJFRV9RKTsKKwkJfSBlbHNlIHsK
 KwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVlc3QuICBBZGQgaXQgdG8gdGhlIHJl
 c2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChyZXEtPnJlcV9oYW5kbGUpOworCQkJ
 dHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJX1JFU0VUX1EpOwogCQl9Ci0JfQor
 CX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBAIC0xODgsNyArMTkzLDggQEAKIAkv
 KgogCSAqIFB1bGwgcmVxdWVzdHMgb2ZmIHRoZSBwZW5kaW5nIHF1ZXVlLCBhbmQgY29tcGxldGUg
 dGhlbS4KIAkgKi8KLQl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFfcV9yZW1vdmVfaGVhZChjdGxy
 LCBUV19DTElfUEVORElOR19RKSkpIHsKKwl3aGlsZSAoKHJlcSA9IHR3X2NsaV9yZXFfcV9yZW1v
 dmVfaGVhZChjdGxyLCBUV19DTElfUEVORElOR19RKSkgIT0KKwkJVFdfQ0xfTlVMTCkgewogCQlp
 ZiAocmVxLT5mbGFncyAmIFRXX0NMSV9SRVFfRkxBR1NfSU5URVJOQUwpIHsKIAkJCS8qCiAJCQkg
 KiBJdCdzIGFuIGludGVybmFsIHJlcXVlc3QuICBTZXQgdGhlIGFwcHJvcHJpYXRlCkBAIC0yMDIs
 MTkgKzIwOCwyMSBAQAogCQkJcmVxLT5lcnJvcl9jb2RlID0gVFdfQ0xfRVJSX1JFUV9CVVNfUkVT
 RVQ7CiAJCQlpZiAocmVxLT50d19jbGlfY2FsbGJhY2spCiAJCQkJcmVxLT50d19jbGlfY2FsbGJh
 Y2socmVxKTsKLQkJfSBlbHNlIHsKLQkJCWlmICgocmVxX3BrdCA9IHJlcS0+b3JpZ19yZXEpKSB7
 Ci0JCQkJLyogSXQncyBhbiBleHRlcm5hbCByZXF1ZXN0LiAgQ29tcGxldGUgaXQuICovCi0JCQkJ
 dHdfY2xpX2RiZ19wcmludGYoMiwgY3Rsci0+Y3Rscl9oYW5kbGUsCi0JCQkJCXR3X29zbF9jdXJf
 ZnVuYygpLAotCQkJCQkiQ29tcGxldGluZyBwZW5kaW5nIHJlcXVlc3QgJXAgIgotCQkJCQkib24g
 cmVzZXQiLCByZXEpOworCQl9IGVsc2UgaWYgKHJlcS0+ZmxhZ3MgJiBUV19DTElfUkVRX0ZMQUdT
 X1BBU1NUSFJVKSB7CisJCQkvKiBJdCdzIGEgcGFzc3RocnUgcmVxdWVzdC4gIENvbXBsZXRlIGl0
 LiAqLworCQkJaWYgKChyZXFfcGt0ID0gcmVxLT5vcmlnX3JlcSkgIT0gVFdfQ0xfTlVMTCkgewog
 CQkJCXJlcV9wa3QtPnN0YXR1cyA9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUOwotCQkJCXJlcV9w
 a3QtPnR3X29zbF9jYWxsYmFjayhyZXEtPnJlcV9oYW5kbGUpOworCisJCQkJaWYgKHJlcV9wa3Qt
 PnR3X29zbF9jYWxsYmFjaykKKwkJCQkJcmVxX3BrdC0+dHdfb3NsX2NhbGxiYWNrKHJlcS0+cmVx
 X2hhbmRsZSk7CiAJCQl9CiAJCQl0d19jbGlfcmVxX3FfaW5zZXJ0X3RhaWwocmVxLCBUV19DTElf
 RlJFRV9RKTsKKwkJfSBlbHNlIHsKKwkJCS8qIEl0J3MgYW4gZXh0ZXJuYWwgKFNDU0kpIHJlcXVl
 c3QuICBBZGQgaXQgdG8gdGhlIHJlc2V0IHF1ZXVlLiAqLworCQkJdHdfb3NsX3VudGltZW91dChy
 ZXEtPnJlcV9oYW5kbGUpOworCQkJdHdfY2xpX3JlcV9xX2luc2VydF90YWlsKHJlcSwgVFdfQ0xJ
 X1JFU0VUX1EpOwogCQl9Ci0JfQorCX0gLyogRW5kIG9mIHdoaWxlIGxvb3AgKi8KIH0KIAogCkBA
 IC0yMzksOSArMjQ3LDYgQEAKIAlmb3IgKDs7KSB7CiAJCXN0YXR1c19yZWcgPSBUV19DTElfUkVB
 RF9TVEFUVVNfUkVHSVNURVIoY3Rsci0+Y3Rscl9oYW5kbGUpOwogCi0JCWlmICh0d19jbGlfY2hl
 Y2tfY3Rscl9zdGF0ZShjdGxyLCBzdGF0dXNfcmVnKSkKLQkJCXJldHVybihUV19PU0xfRUdFTkZB
 SUxVUkUpOwotCiAJCWlmIChzdGF0dXNfcmVnICYgVFdBX1NUQVRVU19SRVNQT05TRV9RVUVVRV9F
 TVBUWSkKIAkJCXJldHVybihUV19PU0xfRVNVQ0NFU1MpOyAvKiBubyBtb3JlIHJlc3BvbnNlIHF1
 ZXVlIGVudHJpZXMgKi8KIApAQCAtMjczLDkgKzI3OCw2IEBACiAJZm9yICg7OykgewogCQlzdGF0
 dXNfcmVnID0gVFdfQ0xJX1JFQURfU1RBVFVTX1JFR0lTVEVSKGN0bHItPmN0bHJfaGFuZGxlKTsK
 IAotCQlpZiAodHdfY2xpX2NoZWNrX2N0bHJfc3RhdGUoY3Rsciwgc3RhdHVzX3JlZykpCi0JCQly
 ZXR1cm4oVFdfT1NMX0VHRU5GQUlMVVJFKTsKLQogCQlpZiAoc3RhdHVzX3JlZyAmIFRXQV9TVEFU
 VVNfUkVTUE9OU0VfUVVFVUVfRU1QVFkpCiAJCQlyZXR1cm4oVFdfT1NMX0VOT1RUWSk7IC8qIG5v
 IG1vcmUgcmVzcG9uc2UgcXVldWUgZW50cmllcyAqLwogCkBAIC0zNTYsOSArMzU4LDExIEBACiAK
 IAkJaWYgKChlcnJvciA9IHJlcS0+Y21kX3BrdC0+Y29tbWFuZC5jbWRfcGt0XzlrLnN0YXR1cykp
 IHsKIAkJCWNtZF9oZHIgPSAmcmVxLT5jbWRfcGt0LT5jbWRfaGRyOworI2lmICAgICAgIDAKIAkJ
 CXR3X2NsaV9jcmVhdGVfY3Rscl9ldmVudChjdGxyLAogCQkJCVRXX0NMX01FU1NBR0VfU09VUkNF
 X0NPTlRST0xMRVJfRVJST1IsCiAJCQkJY21kX2hkcik7CisjZW5kaWYgLy8gMAogCQkJYnJlYWs7
 CiAJCX0KIApAQCAtNzE0LDcgKzcxOCw3IEBACiAKIAkJdHdfb3NsX21lbXplcm8oZGVzYywgMjAw
 KTsKIAkJaWYgKCEoY3Rsci0+cmVzZXRfcGhhc2UxX2luX3Byb2dyZXNzKSkgewotCQkJdHdfY2xf
 Y3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQkJdHdfY2xfY3JlYXRlX2V2
 ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCiAJCQkJMHgxMzAxLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9S
 X1NUUklORywKIAkJCQkiTWlzc2luZyBleHBlY3RlZCBzdGF0dXMgYml0KHMpIiwKQEAgLTczOCw3
 ICs3NDIsNyBAQAogCQkgICAgIChjdGxyLT5kZXZpY2VfaWQgIT0gVFdfQ0xfREVWSUNFX0lEXzlL
 X1NBKSkgfHwKIAkJICAgICghKGN0bHItPnJlc2V0X2luX3Byb2dyZXNzKSkgfHwKIAkJICAgICgo
 c3RhdHVzX3JlZyAmIFRXQV9TVEFUVVNfUVVFVUVfRVJST1JfSU5URVJSVVBUKSA9PSAwKSkKLQkJ
 dHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9UUlVFLAorCQl0d19jbF9jcmVh
 dGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX0ZBTFNFLAogCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJMHgxMzAyLCAweDEsIFRXX0NMX1NFVkVSSVRZX0VS
 Uk9SX1NUUklORywKIAkJCSJVbmV4cGVjdGVkIHN0YXR1cyBiaXQocykiLApAQCAtNzQ4LDcgKzc1
 Miw3IEBACiAJCQkJVFdBX1NUQVRVU19VTkVYUEVDVEVEX0JJVFMsIGRlc2MpKTsKIAogCQlpZiAo
 c3RhdHVzX3JlZyAmIFRXQV9TVEFUVVNfUENJX1BBUklUWV9FUlJPUl9JTlRFUlJVUFQpIHsKLQkJ
 CXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKKwkJCXR3X2NsX2Ny
 ZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFMU0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9T
 T1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJCTB4MTMwMywgMHgxLCBUV19DTF9TRVZFUklU
 WV9FUlJPUl9TVFJJTkcsCiAJCQkJIlBDSSBwYXJpdHkgZXJyb3I6IGNsZWFyaW5nLi4uICIKQEAg
 LTc2OCw3ICs3NzIsNyBAQAogCQl9CiAKIAkJaWYgKHN0YXR1c19yZWcgJiBUV0FfU1RBVFVTX1BD
 SV9BQk9SVF9JTlRFUlJVUFQpIHsKLQkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwg
 VFdfQ0xfVFJVRSwKKwkJCXR3X2NsX2NyZWF0ZV9ldmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfRkFM
 U0UsCiAJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfQ09NTU9OX0xBWUVSX0VWRU5ULAogCQkJCTB4
 MTMwNCwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkJIlBDSSBhYm9ydDog
 Y2xlYXJpbmcuLi4gIiwKQEAgLTc5MSw3ICs3OTUsNyBAQAogCQkJaWYgKCgoY3Rsci0+ZGV2aWNl
 X2lkICE9IFRXX0NMX0RFVklDRV9JRF85S19FKSAmJgogCQkJICAgICAoY3Rsci0+ZGV2aWNlX2lk
 ICE9IFRXX0NMX0RFVklDRV9JRF85S19TQSkpIHx8CiAJCQkgICAgKCEoY3Rsci0+cmVzZXRfaW5f
 cHJvZ3Jlc3MpKSkKLQkJCQl0d19jbF9jcmVhdGVfZXZlbnQoY3Rscl9oYW5kbGUsIFRXX0NMX1RS
 VUUsCisJCQkJdHdfY2xfY3JlYXRlX2V2ZW50KGN0bHJfaGFuZGxlLCBUV19DTF9GQUxTRSwKIAkJ
 CQkJCSAgIFRXX0NMX01FU1NBR0VfU09VUkNFX0NPTU1PTl9MQVlFUl9FVkVOVCwKIAkJCQkJCSAg
 IDB4MTMwNSwgMHgxLCBUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQkJCQkgICAiQ29u
 dHJvbGxlciBxdWV1ZSBlcnJvcjogY2xlYXJpbmcuLi4gIiwKQEAgLTgwMSwxNyArODA1LDYgQEAK
 IAkJCVRXX0NMSV9XUklURV9DT05UUk9MX1JFR0lTVEVSKGN0bHItPmN0bHJfaGFuZGxlLAogCQkJ
 CVRXQV9DT05UUk9MX0NMRUFSX1FVRVVFX0VSUk9SKTsKIAkJfQotCi0JCWlmIChzdGF0dXNfcmVn
 ICYgVFdBX1NUQVRVU19NSUNST0NPTlRST0xMRVJfRVJST1IpIHsKLQkJCXR3X2NsX2NyZWF0ZV9l
 dmVudChjdGxyX2hhbmRsZSwgVFdfQ0xfVFJVRSwKLQkJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9D
 T01NT05fTEFZRVJfRVZFTlQsCi0JCQkJMHgxMzA3LCAweDEsIFRXX0NMX1NFVkVSSVRZX0VSUk9S
 X1NUUklORywKLQkJCQkiTWljcm8tY29udHJvbGxlciBlcnJvciEgIiwKLQkJCQkic3RhdHVzIHJl
 ZyA9IDB4JXggJXMiLAotCQkJCXN0YXR1c19yZWcsCi0JCQkJdHdfY2xpX2Rlc2NyaWJlX2JpdHMo
 c3RhdHVzX3JlZywgZGVzYykpOwotCQkJZXJyb3IgPSBUV19PU0xfRUdFTkZBSUxVUkU7Ci0JCX0K
 IAl9CiAJcmV0dXJuKGVycm9yKTsKIH0JCkBAIC04NTAsOCArODQzLDYgQEAKIAkJdHdfb3NsX3N0
 cmNweSgmc3RyW3R3X29zbF9zdHJsZW4oc3RyKV0sICJIT1NUX0lOVFIsIik7CiAJaWYgKHJlZyAm
 IFRXQV9TVEFUVVNfUENJX0FCT1JUX0lOVEVSUlVQVCkKIAkJdHdfb3NsX3N0cmNweSgmc3RyW3R3
 X29zbF9zdHJsZW4oc3RyKV0sICJQQ0lfQUJSVCwiKTsKLQlpZiAocmVnICYgVFdBX1NUQVRVU19N
 SUNST0NPTlRST0xMRVJfRVJST1IpCi0JCXR3X29zbF9zdHJjcHkoJnN0clt0d19vc2xfc3RybGVu
 KHN0cildLCAiTUNfRVJSLCIpOwogCWlmIChyZWcgJiBUV0FfU1RBVFVTX1FVRVVFX0VSUk9SX0lO
 VEVSUlVQVCkKIAkJdHdfb3NsX3N0cmNweSgmc3RyW3R3X29zbF9zdHJsZW4oc3RyKV0sICJRX0VS
 UiwiKTsKIAlpZiAocmVnICYgVFdBX1NUQVRVU19QQ0lfUEFSSVRZX0VSUk9SX0lOVEVSUlVQVCkK
 ZGlmZiAtdSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMvdHdfY2xfc2hhcmUuaCBGcmVlQlNEN190
 d2FfM183MF8wNV8wMTAvdHdfY2xfc2hhcmUuaAotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3Zz
 L3R3X2NsX3NoYXJlLmgJMjAxMC0wOC0yNiAxNTozNTowMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZy
 ZWVCU0Q3X3R3YV8zXzcwXzA1XzAxMC90d19jbF9zaGFyZS5oCTIwMTAtMDgtMjQgMTg6MDE6MTMu
 MDAwMDAwMDAwIC0wNzAwCkBAIC0zNDksMTAgKzM0OSwxNCBAQAogI2VuZGlmCiAKIAotI2lmbmRl
 ZiB0d19vc2xfY3Rscl9idXN5Ci0vKiBDYWxsZWQgd2hlbiBDTCBpcyB0b28gYnVzeSB0byBhY2Nl
 cHQgbmV3IHJlcXVlc3RzLiAqLwotZXh0ZXJuIFRXX1ZPSUQJdHdfb3NsX2N0bHJfYnVzeShzdHJ1
 Y3QgdHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLAotCXN0cnVjdCB0d19jbF9yZXFfaGFu
 ZGxlICpyZXFfaGFuZGxlKTsKKyNpZm5kZWYgdHdfb3NsX3RpbWVvdXQKKy8qIFN0YXJ0IE9TIHRp
 bWVvdXQoKSByb3V0aW5lIGFmdGVyIGNvbnRyb2xsZXIgcmVzZXQgc2VxdWVuY2UgKi8KK2V4dGVy
 biBUV19WT0lECXR3X29zbF90aW1lb3V0KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFu
 ZGxlKTsKKyNlbmRpZgorCisjaWZuZGVmIHR3X29zbF91bnRpbWVvdXQKKy8qIFN0b3AgT1MgdGlt
 ZW91dCgpIHJvdXRpbmUgZHVyaW5nIGNvbnRyb2xsZXIgcmVzZXQgc2VxdWVuY2UgKi8KK2V4dGVy
 biBUV19WT0lECXR3X29zbF91bnRpbWVvdXQoc3RydWN0IHR3X2NsX3JlcV9oYW5kbGUgKnJlcV9o
 YW5kbGUpOwogI2VuZGlmCiAKIApAQCAtNTUyLDEzICs1NTYsMTcgQEAKIAkpOwogCiAKK2V4dGVy
 biBUV19WT0lEICB0d19jbF9zZXRfcmVzZXRfbmVlZGVkKHN0cnVjdCB0d19jbF9jdGxyX2hhbmRs
 ZSAqY3Rscl9oYW5kbGUpOworZXh0ZXJuIFRXX0lOVDMyIHR3X2NsX2lzX3Jlc2V0X25lZWRlZChz
 dHJ1Y3QgdHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlKTsKK2V4dGVybiBUV19JTlQzMiB0
 d19jbF9pc19hY3RpdmUoc3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICpjdGxyX2hhbmRsZSk7CisK
 IC8qIENMJ3MgaW50ZXJydXB0IGhhbmRsZXIuICovCiBleHRlcm4gVFdfSU5UMzIJdHdfY2xfaW50
 ZXJydXB0KHN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUpOwogCiAKIC8qIENM
 J3MgaW9jdGwgaGFuZGxlci4gKi8KIGV4dGVybiBUV19JTlQzMgl0d19jbF9pb2N0bChzdHJ1Y3Qg
 dHdfY2xfY3Rscl9oYW5kbGUgKmN0bHJfaGFuZGxlLAotCVRXX0lOVDMyIGNtZCwgVFdfVk9JRCAq
 YnVmKTsKKwl1X2xvbmcgY21kLCBUV19WT0lEICpidWYpOwogCiAKICNpZmRlZiBUV19PU0xfREVC
 VUcKZGlmZiAtdSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMvdHdfb3NsLmggRnJlZUJTRDdfdHdh
 XzNfNzBfMDVfMDEwL3R3X29zbC5oCi0tLSBGcmVlQlNEX1JFTEVOR183X3R3YV9jdnMvdHdfb3Ns
 LmgJMjAxMC0wOC0yNiAxNTozNTowMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q3X3R3YV8z
 XzcwXzA1XzAxMC90d19vc2wuaAkyMDEwLTA4LTI0IDE4OjAxOjEzLjAwMDAwMDAwMCAtMDcwMApA
 QCAtNzcsNiArNzcsNyBAQAogCQkJCQkJRUlOUFJPR1JFU1MgKi8KICNkZWZpbmUgVFdfT1NMSV9S
 RVFfRkxBR1NfUEFTU1RIUlUJKDE8PDUpCS8qIHBhc3MgdGhyb3VnaCByZXF1ZXN0ICovCiAjZGVm
 aW5lIFRXX09TTElfUkVRX0ZMQUdTX1NMRUVQSU5HCSgxPDw2KQkvKiBvd25lciBzbGVlcGluZyBv
 biB0aGlzIGNtZCAqLworI2RlZmluZSBUV19PU0xJX1JFUV9GTEFHU19GQUlMRUQJKDE8PDcpCS8q
 IGJ1c19kbWFtYXBfbG9hZCgpIGZhaWxlZCAqLwogCiAKICNpZmRlZiBUV19PU0xfREVCVUcKQEAg
 LTEwMCw2ICsxMDEsNyBAQAogCXN0cnVjdCB0d2Ffc29mdGMJKmN0bHI7CS8qIHB0ciB0byBPU0wn
 cyBjb250cm9sbGVyIGNvbnRleHQgKi8KIAlUV19WT0lECQkJKmRhdGE7CS8qIHB0ciB0byBkYXRh
 IGJlaW5nIHBhc3NlZCB0byBDTCAqLwogCVRXX1VJTlQzMgkJbGVuZ3RoOwkvKiBsZW5ndGggb2Yg
 YnVmIGJlaW5nIHBhc3NlZCB0byBDTCAqLworCVRXX1VJTlQ2NAkJZGVhZGxpbmU7LyogcmVxdWVz
 dCB0aW1lb3V0IChpbiBhYnNvbHV0ZSB0aW1lKSAqLwogCiAJLyoKIAkgKiBwdHIgdG8sIGFuZCBs
 ZW5ndGggb2YgZGF0YSBwYXNzZWQgdG8gdXMgZnJvbSBhYm92ZSwgaW4gY2FzZSBhIGJ1ZmZlcgpA
 QCAtMTUxLDYgKzE1Myw5IEBACiAJc3RydWN0IG10eAkJc2ltX2xvY2tfaGFuZGxlOy8qIHNpbSBs
 b2NrIHNoYXJlZCB3aXRoIGNhbSAqLwogCXN0cnVjdCBtdHgJCSpzaW1fbG9jazsvKiBwdHIgdG8g
 c2ltIGxvY2sgKi8KIAorCXN0cnVjdCBjYWxsb3V0CQl3YXRjaGRvZ19jYWxsb3V0WzJdOyAvKiBG
 b3IgY29tbWFuZCB0aW1vdXQgKi8KKwlUV19VSU5UMzIJCXdhdGNoZG9nX2luZGV4OworCiAjaWZk
 ZWYgVFdfT1NMX0RFQlVHCiAJc3RydWN0IHR3X29zbGlfcV9zdGF0cwlxX3N0YXRzW1RXX09TTElf
 UV9DT1VOVF07LyogcXVldWUgc3RhdGlzdGljcyAqLwogI2VuZGlmIC8qIFRXX09TTF9ERUJVRyAq
 LwpkaWZmIC11IEZyZWVCU0RfUkVMRU5HXzdfdHdhX2N2cy90d19vc2xfY2FtLmMgRnJlZUJTRDdf
 dHdhXzNfNzBfMDVfMDEwL3R3X29zbF9jYW0uYwotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3Zz
 L3R3X29zbF9jYW0uYwkyMDEwLTA4LTI2IDE1OjM1OjAwLjAwMDAwMDAwMCAtMDcwMAorKysgRnJl
 ZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3X29zbF9jYW0uYwkyMDEwLTA4LTI0IDE4OjAxOjEzLjAw
 MDAwMDAwMCAtMDcwMApAQCAtNTUsNyArNTUsNiBAQAogCiBzdGF0aWMgVFdfVk9JRAl0d2FfYWN0
 aW9uKHN0cnVjdCBjYW1fc2ltICpzaW0sIHVuaW9uIGNjYiAqY2NiKTsKIHN0YXRpYyBUV19WT0lE
 CXR3YV9wb2xsKHN0cnVjdCBjYW1fc2ltICpzaW0pOwotc3RhdGljIFRXX1ZPSUQJdHdhX3RpbWVv
 dXQoVFdfVk9JRCAqYXJnKTsKIHN0YXRpYyBUV19WT0lECXR3YV9idXNfc2Nhbl9jYihzdHJ1Y3Qg
 Y2FtX3BlcmlwaCAqcGVyaXBoLCB1bmlvbiBjY2IgKmNjYik7CiAKIHN0YXRpYyBUV19JTlQzMgl0
 d19vc2xpX2V4ZWN1dGVfc2NzaShzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dCAqcmVxLApAQCAt
 ODMsNyArODIsNyBAQAogCS8qCiAJICogQ3JlYXRlIHRoZSBkZXZpY2UgcXVldWUgZm9yIG91ciBT
 SU0uCiAJICovCi0JaWYgKChkZXZxID0gY2FtX3NpbXFfYWxsb2MoVFdfT1NMSV9NQVhfTlVNX1JF
 UVVFU1RTKSkgPT0gTlVMTCkgeworCWlmICgoZGV2cSA9IGNhbV9zaW1xX2FsbG9jKFRXX09TTElf
 TUFYX05VTV9JT1MpKSA9PSBOVUxMKSB7CiAJCXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAl
 ZCIsCiAJCQlUV19DTF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQlUV19DTF9NRVNTQUdFX1NP
 VVJDRV9GUkVFQlNEX0RSSVZFUiwKQEAgLTI5Miw2ICsyOTEsNyBAQAogCQkJCQkiSS9PIHNpemUg
 dG9vIGJpZyIsCiAJCQkJCWNzaW8tPmR4ZmVyX2xlbik7CiAJCQkJY2NiX2gtPnN0YXR1cyA9IENB
 TV9SRVFfVE9PX0JJRzsKKwkJCQljY2JfaC0+c3RhdHVzICY9IH5DQU1fU0lNX1FVRVVFRDsKIAkJ
 CQl4cHRfZG9uZShjY2IpOwogCQkJCXJldHVybigxKTsKIAkJCX0KQEAgLTMwNyw2ICszMDcsNyBA
 QAogCQkJCTB4MjEwNywKIAkJCQkiWFBUX1NDU0lfSU86IEdvdCBTR0xpc3QiKTsKIAkJCWNjYl9o
 LT5zdGF0dXMgPSBDQU1fUkVRX0lOVkFMSUQ7CisJCQljY2JfaC0+c3RhdHVzICY9IH5DQU1fU0lN
 X1FVRVVFRDsKIAkJCXhwdF9kb25lKGNjYik7CiAJCQlyZXR1cm4oMSk7CiAJCX0KQEAgLTMyMywx
 MyArMzI0LDIwIEBACiAJCXJldHVybigxKTsKIAl9CiAKLQljY2JfaC0+dGltZW91dF9jaCA9IHRp
 bWVvdXQodHdhX3RpbWVvdXQsIHJlcSwKLQkJKGNjYl9oLT50aW1lb3V0ICogaHopIC8gMTAwMCk7
 CisJcmVxLT5kZWFkbGluZSA9IHR3X29zbF9nZXRfbG9jYWxfdGltZSgpICsgKGNjYl9oLT50aW1l
 b3V0IC8gMTAwMCk7CisKKwogCS8qCiAJICogdHdhX21hcF9sb2FkX2RhdGFfY2FsbGJhY2sgd2ls
 bCBmaWxsIGluIHRoZSBTR0wsCiAJICogYW5kIHN1Ym1pdCB0aGUgSS9PLgogCSAqLwogCWVycm9y
 ID0gdHdfb3NsaV9tYXBfcmVxdWVzdChyZXEpOworCWlmICgoZXJyb3IpICYmIChyZXEtPmZsYWdz
 ICYgVFdfT1NMSV9SRVFfRkxBR1NfRkFJTEVEKSkgeworCQlyZXEtPmRlYWRsaW5lID0gMDsKKwkJ
 Y2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QX0VSUjsKKwkJY2NiX2gtPnN0YXR1cyAmPSB+Q0FN
 X1NJTV9RVUVVRUQ7CisJCXhwdF9kb25lKGNjYik7CisJfQogCXJldHVybihlcnJvcik7CiB9CiAK
 QEAgLTM2MiwxMCArMzcwLDIwIEBACiAJCQkgKiBGcmVlemUgdGhlIHNpbXEgdG8gbWFpbnRhaW4g
 Y2NiIG9yZGVyaW5nLiAgVGhlIG5leHQKIAkJCSAqIGNjYiB0aGF0IGdldHMgY29tcGxldGVkIHdp
 bGwgdW5mcmVlemUgdGhlIHNpbXEuCiAJCQkgKi8KKwkJCWNjYl9oLT5zdGF0dXMgJj0gfkNBTV9T
 SU1fUVVFVUVEOwogCQkJY2NiX2gtPnN0YXR1cyB8PSBDQU1fUkVRVUVVRV9SRVE7CiAJCQl4cHRf
 ZG9uZShjY2IpOwogCQkJYnJlYWs7CiAJCX0KKworCQlpZiAoKHR3X2NsX2lzX3Jlc2V0X25lZWRl
 ZCgmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKSkpIHsKKwkJCWNjYl9oLT5zdGF0dXMgJj0gfkNB
 TV9TSU1fUVVFVUVEOworCQkJY2NiX2gtPnN0YXR1cyB8PSBDQU1fUkVRVUVVRV9SRVE7CisJCQl4
 cHRfZG9uZShjY2IpOworCQkJdHdfb3NsaV9yZXFfcV9pbnNlcnRfdGFpbChyZXEsIFRXX09TTElf
 RlJFRV9RKTsKKwkJCWJyZWFrOworCQl9CisKIAkJcmVxLT5yZXFfaGFuZGxlLm9zbF9yZXFfY3R4
 dCA9IHJlcTsKIAkJcmVxLT5yZXFfaGFuZGxlLmlzX2lvID0gVFdfQ0xfVFJVRTsKIAkJcmVxLT5v
 cmlnX3JlcSA9IGNjYjsKQEAgLTM4MSwyNSArMzk5LDE0IEBACiAJCWJyZWFrOwogCiAJY2FzZSBY
 UFRfUkVTRVRfQlVTOgotCQl0d19jbF9jcmVhdGVfZXZlbnQoJihzYy0+Y3Rscl9oYW5kbGUpLCBU
 V19DTF9UUlVFLAorCQl0d19jbF9jcmVhdGVfZXZlbnQoJihzYy0+Y3Rscl9oYW5kbGUpLCBUV19D
 TF9GQUxTRSwKIAkJCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZSRUVCU0RfRFJJVkVSLAogCQkJMHgy
 MTA4LCAweDMsIFRXX0NMX1NFVkVSSVRZX0lORk9fU1RSSU5HLAogCQkJIlJlY2VpdmVkIFJlc2V0
 IEJ1cyByZXF1ZXN0IGZyb20gQ0FNIiwKIAkJCSIgIik7CiAKLQkJbXR4X3VubG9jayhzYy0+c2lt
 X2xvY2spOwotCQlpZiAodHdfY2xfcmVzZXRfY3Rscigmc2MtPmN0bHJfaGFuZGxlKSkgewotCQkJ
 dHdfY2xfY3JlYXRlX2V2ZW50KCYoc2MtPmN0bHJfaGFuZGxlKSwgVFdfQ0xfVFJVRSwKLQkJCQlU
 V19DTF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKLQkJCQkweDIxMDksIDB4MSwgVFdf
 Q0xfU0VWRVJJVFlfRVJST1JfU1RSSU5HLAotCQkJCSJGYWlsZWQgdG8gcmVzZXQgYnVzIiwKLQkJ
 CQkiICIpOwotCQkJY2NiX2gtPnN0YXR1cyA9IENBTV9SRVFfQ01QX0VSUjsKLQkJfQotCQllbHNl
 Ci0JCQljY2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7Ci0KLQkJbXR4X2xvY2soc2MtPnNpbV9s
 b2NrKTsKKwkJdHdfY2xfc2V0X3Jlc2V0X25lZWRlZCgmKHNjLT5jdGxyX2hhbmRsZSkpOworCQlj
 Y2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7CiAJCXhwdF9kb25lKGNjYik7CiAJCWJyZWFrOwog
 CkBAIC00NjcsNiArNDc0LDcgQEAKICAgICAgICAgICAgICAgICBwYXRoX2lucS0+dHJhbnNwb3J0
 X3ZlcnNpb24gPSAyOwogICAgICAgICAgICAgICAgIHBhdGhfaW5xLT5wcm90b2NvbCA9IFBST1RP
 X1NDU0k7CiAgICAgICAgICAgICAgICAgcGF0aF9pbnEtPnByb3RvY29sX3ZlcnNpb24gPSBTQ1NJ
 X1JFVl8yOworICAgICAgICAgICAgICAgIHBhdGhfaW5xLT5tYXhpbyA9IFRXX0NMX01BWF9JT19T
 SVpFOwogCQljY2JfaC0+c3RhdHVzID0gQ0FNX1JFUV9DTVA7CiAJCXhwdF9kb25lKGNjYik7CiAJ
 CWJyZWFrOwpAQCAtNTA0LDMxICs1MTIsNiBAQAogCiAKIC8qCi0gKiBGdW5jdGlvbiBuYW1lOgl0
 d2FfdGltZW91dAotICogRGVzY3JpcHRpb246CQlEcml2ZXIgZW50cnkgcG9pbnQgZm9yIGJlaW5n
 IGFsZXJ0ZWQgb24gYSByZXF1ZXN0Ci0gKgkJCXRpbWluZyBvdXQuCi0gKgotICogSW5wdXQ6CQlh
 cmcJLS0gcHRyIHRvIHRpbWVkIG91dCByZXF1ZXN0Ci0gKiBPdXRwdXQ6CQlOb25lCi0gKiBSZXR1
 cm4gdmFsdWU6CU5vbmUKLSAqLwotc3RhdGljIFRXX1ZPSUQKLXR3YV90aW1lb3V0KFRXX1ZPSUQg
 KmFyZykKLXsKLQlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqcmVxID0KLQkJKHN0cnVjdCB0
 d19vc2xpX3JlcV9jb250ZXh0ICopYXJnOwotCi0JdHdfY2xfY3JlYXRlX2V2ZW50KCYocmVxLT5j
 dGxyLT5jdGxyX2hhbmRsZSksIFRXX0NMX1RSVUUsCi0JCVRXX0NMX01FU1NBR0VfU09VUkNFX0ZS
 RUVCU0RfRFJJVkVSLAotCQkweDIxMEIsIDB4MSwgVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RSSU5H
 LAotCQkiUmVxdWVzdCB0aW1lZCBvdXQhIiwKLQkJInJlcXVlc3QgPSAlcCIsIHJlcSk7Ci0JdHdf
 Y2xfcmVzZXRfY3RscigmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKTsKLX0KLQotCi0KLS8qCiAg
 KiBGdW5jdGlvbiBuYW1lOgl0d19vc2xpX3JlcXVlc3RfYnVzX3NjYW4KICAqIERlc2NyaXB0aW9u
 OgkJUmVxdWVzdHMgQ0FNIGZvciBhIHNjYW4gb2YgdGhlIGJ1cy4KICAqCkBAIC02MjMsMjAgKzYw
 NiwzOSBAQAogCiAKIC8qCi0gKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfY3Rscl9idXN5Ci0gKiBE
 ZXNjcmlwdGlvbjoJCUNMIGNhbGxzIHRoaXMgZnVuY3Rpb24gb24gY21kIHF1ZXVlIGZ1bGwgb3Ig
 b3RoZXJ3aXNlLAotICoJCQl3aGVuIGl0IGlzIHRvbyBidXN5IHRvIGFjY2VwdCBuZXcgcmVxdWVz
 dHMuCisgKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfdGltZW91dAorICogRGVzY3JpcHRpb246CQlD
 YWxsIHRvIHRpbWVvdXQoKS4KICAqCi0gKiBJbnB1dDoJCWN0bHJfaGFuZGxlCS0tIHB0ciB0byBj
 b250cm9sbGVyIGhhbmRsZQotICoJCQlyZXFfaGFuZGxlCS0tIHB0ciB0byByZXF1ZXN0IGhhbmRs
 ZSBzZW50IGJ5IE9TTC4KKyAqIElucHV0OgkJcmVxX2hhbmRsZSAtLSBwdHIgdG8gcmVxdWVzdCBo
 YW5kbGUgc2VudCBieSBPU0wuCiAgKiBPdXRwdXQ6CQlOb25lCiAgKiBSZXR1cm4gdmFsdWU6CU5v
 bmUKICAqLwogVFdfVk9JRAotdHdfb3NsX2N0bHJfYnVzeShzdHJ1Y3QgdHdfY2xfY3Rscl9oYW5k
 bGUgKmN0bHJfaGFuZGxlLAotCXN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKQor
 dHdfb3NsX3RpbWVvdXQoc3RydWN0IHR3X2NsX3JlcV9oYW5kbGUgKnJlcV9oYW5kbGUpCit7CisJ
 c3RydWN0IHR3X29zbGlfcmVxX2NvbnRleHQJKnJlcSA9IHJlcV9oYW5kbGUtPm9zbF9yZXFfY3R4
 dDsKKwl1bmlvbiBjY2IJCQkqY2NiID0gKHVuaW9uIGNjYiAqKShyZXEtPm9yaWdfcmVxKTsKKwlz
 dHJ1Y3QgY2NiX2hkcgkJCSpjY2JfaCA9ICYoY2NiLT5jY2JfaCk7CisKKwlyZXEtPmRlYWRsaW5l
 ID0gdHdfb3NsX2dldF9sb2NhbF90aW1lKCkgKyAoY2NiX2gtPnRpbWVvdXQgLyAxMDAwKTsKK30K
 KworCisKKy8qCisgKiBGdW5jdGlvbiBuYW1lOgl0d19vc2xfdW50aW1lb3V0CisgKiBEZXNjcmlw
 dGlvbjoJCUludmVyc2Ugb2YgY2FsbCB0byB0aW1lb3V0KCkuCisgKgorICogSW5wdXQ6CQlyZXFf
 aGFuZGxlIC0tIHB0ciB0byByZXF1ZXN0IGhhbmRsZSBzZW50IGJ5IE9TTC4KKyAqIE91dHB1dDoJ
 CU5vbmUKKyAqIFJldHVybiB2YWx1ZToJTm9uZQorICovCitUV19WT0lECit0d19vc2xfdW50aW1l
 b3V0KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKQogewotCXR3X29zbGlfZGlz
 YWxsb3dfbmV3X3JlcXVlc3RzKGN0bHJfaGFuZGxlLT5vc2xfY3Rscl9jdHh0LCByZXFfaGFuZGxl
 KTsKKwlzdHJ1Y3QgdHdfb3NsaV9yZXFfY29udGV4dAkqcmVxID0gcmVxX2hhbmRsZS0+b3NsX3Jl
 cV9jdHh0OworCisJcmVxLT5kZWFkbGluZSA9IDA7CiB9CiAKIApAQCAtNzA0LDcgKzcwNiw3IEBA
 CiAKIAl0d19vc2xpX3VubWFwX3JlcXVlc3QocmVxKTsKIAotCXVudGltZW91dCh0d2FfdGltZW91
 dCwgcmVxLCBjY2ItPmNjYl9oLnRpbWVvdXRfY2gpOworCXJlcS0+ZGVhZGxpbmUgPSAwOwogCWlm
 IChyZXEtPmVycm9yX2NvZGUpIHsKIAkJLyogVGhpcyByZXF1ZXN0IG5ldmVyIGdvdCBzdWJtaXR0
 ZWQgdG8gdGhlIGZpcm13YXJlLiAqLwogCQlpZiAocmVxLT5lcnJvcl9jb2RlID09IEVCVVNZKSB7
 CkBAIC03MzEsNyArNzMzLDcgQEAKIAkJCWVsc2UgaWYgKHJlcV9wa3QtPnN0YXR1cyAmIFRXX0NM
 X0VSUl9SRVFfU0NTSV9FUlJPUikKIAkJCQljY2ItPmNjYl9oLnN0YXR1cyB8PSBDQU1fU0NTSV9T
 VEFUVVNfRVJST1I7CiAJCQllbHNlIGlmIChyZXFfcGt0LT5zdGF0dXMgJiBUV19DTF9FUlJfUkVR
 X0JVU19SRVNFVCkKLQkJCQljY2ItPmNjYl9oLnN0YXR1cyB8PSBDQU1fU0NTSV9CVVNfUkVTRVQ7
 CisJCQkJY2NiLT5jY2JfaC5zdGF0dXMgfD0gKENBTV9SRVFVRVVFX1JFUSB8IENBTV9TQ1NJX0JV
 U19SRVNFVCk7CiAJCQkvKgogCQkJICogSWYgbm9uZSBvZiB0aGUgYWJvdmUgZXJyb3JzIG9jY3Vy
 cmVkLCBzaW1wbHkKIAkJCSAqIG1hcmsgY29tcGxldGlvbiBlcnJvci4KZGlmZiAtdSBGcmVlQlNE
 X1JFTEVOR183X3R3YV9jdnMvdHdfb3NsX2ZyZWVic2QuYyBGcmVlQlNEN190d2FfM183MF8wNV8w
 MTAvdHdfb3NsX2ZyZWVic2QuYwotLS0gRnJlZUJTRF9SRUxFTkdfN190d2FfY3ZzL3R3X29zbF9m
 cmVlYnNkLmMJMjAxMC0wOC0yNiAxNTozNTowMC4wMDAwMDAwMDAgLTA3MDAKKysrIEZyZWVCU0Q3
 X3R3YV8zXzcwXzA1XzAxMC90d19vc2xfZnJlZWJzZC5jCTIwMTAtMDgtMjYgMTU6MTU6MDcuMDAw
 MDAwMDAwIC0wNzAwCkBAIC04NiwxMCArODYsOSBAQAogICoJCQlub24temVyby0tIGZhaWx1cmUK
 ICAqLwogc3RhdGljIFRXX0lOVDMyCi10d2Ffb3BlbihzdHJ1Y3QgY2RldiAqZGV2LCBUV19JTlQz
 MiBmbGFncywgVFdfSU5UMzIgZm10LCBkX3RocmVhZF90ICpwcm9jKQordHdhX29wZW4oc3RydWN0
 IGNkZXYgKmRldiwgVFdfSU5UMzIgZmxhZ3MsIFRXX0lOVDMyIGZtdCwgc3RydWN0IHRocmVhZCAq
 cHJvYykKIHsKLQlUV19JTlQzMgkJdW5pdCA9IG1pbm9yKGRldik7Ci0Jc3RydWN0IHR3YV9zb2Z0
 Ywkqc2MgPSBkZXZjbGFzc19nZXRfc29mdGModHdhX2RldmNsYXNzLCB1bml0KTsKKwlzdHJ1Y3Qg
 dHdhX3NvZnRjCSpzYyA9IChzdHJ1Y3QgdHdhX3NvZnRjICopKGRldi0+c2lfZHJ2MSk7CiAKIAl0
 d19vc2xpX2RiZ19kcHJpbnRmKDUsIHNjLCAiZW50ZXJlZCIpOwogCXNjLT5vcGVuID0gVFdfQ0xf
 VFJVRTsKQEAgLTExMiwxMCArMTExLDkgQEAKICAqCQkJbm9uLXplcm8tLSBmYWlsdXJlCiAgKi8K
 IHN0YXRpYyBUV19JTlQzMgotdHdhX2Nsb3NlKHN0cnVjdCBjZGV2ICpkZXYsIFRXX0lOVDMyIGZs
 YWdzLCBUV19JTlQzMiBmbXQsIGRfdGhyZWFkX3QgKnByb2MpCit0d2FfY2xvc2Uoc3RydWN0IGNk
 ZXYgKmRldiwgVFdfSU5UMzIgZmxhZ3MsIFRXX0lOVDMyIGZtdCwgc3RydWN0IHRocmVhZCAqcHJv
 YykKIHsKLQlUV19JTlQzMgkJdW5pdCA9IG1pbm9yKGRldik7Ci0Jc3RydWN0IHR3YV9zb2Z0Ywkq
 c2MgPSBkZXZjbGFzc19nZXRfc29mdGModHdhX2RldmNsYXNzLCB1bml0KTsKKwlzdHJ1Y3QgdHdh
 X3NvZnRjCSpzYyA9IChzdHJ1Y3QgdHdhX3NvZnRjICopKGRldi0+c2lfZHJ2MSk7CiAKIAl0d19v
 c2xpX2RiZ19kcHJpbnRmKDUsIHNjLCAiZW50ZXJlZCIpOwogCXNjLT5vcGVuID0gVFdfQ0xfRkFM
 U0U7CkBAIC0xNDIsNyArMTQwLDcgQEAKICAqCQkJbm9uLXplcm8tLSBmYWlsdXJlCiAgKi8KIHN0
 YXRpYyBUV19JTlQzMgotdHdhX2lvY3RsKHN0cnVjdCBjZGV2ICpkZXYsIHVfbG9uZyBjbWQsIGNh
 ZGRyX3QgYnVmLCBUV19JTlQzMiBmbGFncywgZF90aHJlYWRfdCAqcHJvYykKK3R3YV9pb2N0bChz
 dHJ1Y3QgY2RldiAqZGV2LCB1X2xvbmcgY21kLCBjYWRkcl90IGJ1ZiwgVFdfSU5UMzIgZmxhZ3Ms
 IHN0cnVjdCB0aHJlYWQgKnByb2MpCiB7CiAJc3RydWN0IHR3YV9zb2Z0Ywkqc2MgPSAoc3RydWN0
 IHR3YV9zb2Z0YyAqKShkZXYtPnNpX2RydjEpOwogCVRXX0lOVDMyCQllcnJvcjsKQEAgLTE3Nyw2
 ICsxNzUsOSBAQAogc3RhdGljIFRXX0lOVDMyCXR3YV9zaHV0ZG93bihkZXZpY2VfdCBkZXYpOwog
 c3RhdGljIFRXX1ZPSUQJdHdhX2J1c2RtYV9sb2NrKFRXX1ZPSUQgKmxvY2tfYXJnLCBidXNfZG1h
 X2xvY2tfb3BfdCBvcCk7CiBzdGF0aWMgVFdfVk9JRAl0d2FfcGNpX2ludHIoVFdfVk9JRCAqYXJn
 KTsKK3N0YXRpYyBUV19WT0lECXR3YV93YXRjaGRvZyhUV19WT0lEICphcmcpOworaW50IHR3YV9z
 ZXR1cF9pbnRyKHN0cnVjdCB0d2Ffc29mdGMgKnNjKTsKK2ludCB0d2FfdGVhcmRvd25faW50cihz
 dHJ1Y3QgdHdhX3NvZnRjICpzYyk7CiAKIHN0YXRpYyBUV19JTlQzMgl0d19vc2xpX2FsbG9jX21l
 bShzdHJ1Y3QgdHdhX3NvZnRjICpzYyk7CiBzdGF0aWMgVFdfVk9JRAl0d19vc2xpX2ZyZWVfcmVz
 b3VyY2VzKHN0cnVjdCB0d2Ffc29mdGMgKnNjKTsKQEAgLTI0MCw2ICsyNDEsMzIgQEAKIAlyZXR1
 cm4oRU5YSU8pOwogfQogCitpbnQgdHdhX3NldHVwX2ludHIoc3RydWN0IHR3YV9zb2Z0YyAqc2Mp
 Cit7CisJaW50IGVycm9yID0gMDsKKworCWlmICghKHNjLT5pbnRyX2hhbmRsZSkgJiYgKHNjLT5p
 cnFfcmVzKSkgeworCQllcnJvciA9IGJ1c19zZXR1cF9pbnRyKHNjLT5idXNfZGV2LCBzYy0+aXJx
 X3JlcywKKwkJCQkJSU5UUl9UWVBFX0NBTSB8IElOVFJfTVBTQUZFLAorCQkJCQlOVUxMLCB0d2Ff
 cGNpX2ludHIsCisJCQkJCXNjLCAmc2MtPmludHJfaGFuZGxlKTsKKwl9CisJcmV0dXJuKCBlcnJv
 ciApOworfQorCisKK2ludCB0d2FfdGVhcmRvd25faW50cihzdHJ1Y3QgdHdhX3NvZnRjICpzYykK
 K3sKKwlpbnQgZXJyb3IgPSAwOworCisJaWYgKChzYy0+aW50cl9oYW5kbGUpICYmIChzYy0+aXJx
 X3JlcykpIHsKKwkJZXJyb3IgPSBidXNfdGVhcmRvd25faW50cihzYy0+YnVzX2RldiwKKwkJCQkJ
 CXNjLT5pcnFfcmVzLCBzYy0+aW50cl9oYW5kbGUpOworCQlzYy0+aW50cl9oYW5kbGUgPSBOVUxM
 OworCX0KKwlyZXR1cm4oIGVycm9yICk7Cit9CisKIAogCiAvKgpAQCAtMzU2LDEwICszODMsNyBA
 QAogCQl0d19vc2xpX2ZyZWVfcmVzb3VyY2VzKHNjKTsKIAkJcmV0dXJuKEVOWElPKTsKIAl9Ci0J
 aWYgKChlcnJvciA9IGJ1c19zZXR1cF9pbnRyKHNjLT5idXNfZGV2LCBzYy0+aXJxX3JlcywKLQkJ
 CUlOVFJfVFlQRV9DQU0gfCBJTlRSX01QU0FGRSwKLQkJCU5VTEwsIHR3YV9wY2lfaW50ciwJICAg
 IAotCQkJc2MsICZzYy0+aW50cl9oYW5kbGUpKSkgeworCWlmICgoZXJyb3IgPSB0d2Ffc2V0dXBf
 aW50cihzYykpKSB7CiAJCXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAlZCIsCiAJCQlUV19D
 TF9TRVZFUklUWV9FUlJPUl9TVFJJTkcsCiAJCQlUV19DTF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNE
 X0RSSVZFUiwKQEAgLTQxNCwxMCArNDM4LDc3IEBACiAJCXJldHVybihlcnJvcik7CiAJfQogCisJ
 c2MtPndhdGNoZG9nX2luZGV4ID0gMDsKKwljYWxsb3V0X2luaXQoJihzYy0+d2F0Y2hkb2dfY2Fs
 bG91dFswXSksIENBTExPVVRfTVBTQUZFKTsKKwljYWxsb3V0X2luaXQoJihzYy0+d2F0Y2hkb2df
 Y2FsbG91dFsxXSksIENBTExPVVRfTVBTQUZFKTsKKwljYWxsb3V0X3Jlc2V0KCYoc2MtPndhdGNo
 ZG9nX2NhbGxvdXRbMF0pLCA1Kmh6LCB0d2Ffd2F0Y2hkb2csICZzYy0+Y3Rscl9oYW5kbGUpOwor
 CiAJcmV0dXJuKDApOwogfQogCiAKK3N0YXRpYyBUV19WT0lECit0d2Ffd2F0Y2hkb2coVFdfVk9J
 RCAqYXJnKQoreworCXN0cnVjdCB0d19jbF9jdGxyX2hhbmRsZSAqY3Rscl9oYW5kbGUgPQorCQko
 c3RydWN0IHR3X2NsX2N0bHJfaGFuZGxlICopYXJnOworCXN0cnVjdCB0d2Ffc29mdGMJCSpzYyA9
 IGN0bHJfaGFuZGxlLT5vc2xfY3Rscl9jdHh0OworCWludAkJCQlpOworCWludAkJCQlpX25lZWRf
 YV9yZXNldCA9IDA7CisJaW50CQkJCWRyaXZlcl9pc19hY3RpdmUgPSAwOworCWludAkJCQlteV93
 YXRjaGRvZ193YXNfcGVuZGluZyA9IDEyMzQ7CisJVFdfVUlOVDY0CQkJY3VycmVudF90aW1lOwor
 CXN0cnVjdCB0d19vc2xpX3JlcV9jb250ZXh0CSpteV9yZXE7CisKKworLy89PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT0KKwljdXJyZW50X3RpbWUgPSAoVFdfVUlOVDY0KSAodHdfb3NsX2dldF9sb2NhbF90
 aW1lKCkpOworCisJZm9yIChpID0gMDsgaSA8IFRXX09TTElfTUFYX05VTV9SRVFVRVNUUzsgaSsr
 KSB7CisJCW15X3JlcSA9ICYoc2MtPnJlcV9jdHhfYnVmW2ldKTsKKworCQlpZiAoKG15X3JlcS0+
 c3RhdGUgPT0gVFdfT1NMSV9SRVFfU1RBVEVfQlVTWSkgJiYKKwkJCShteV9yZXEtPmRlYWRsaW5l
 KSAmJgorCQkJKG15X3JlcS0+ZGVhZGxpbmUgPCBjdXJyZW50X3RpbWUpKSB7CisJCQl0d19jbF9z
 ZXRfcmVzZXRfbmVlZGVkKGN0bHJfaGFuZGxlKTsKKyNpZmRlZiAgICBUV19PU0xfREVCVUcKKwkJ
 CWRldmljZV9wcmludGYoKHNjKS0+YnVzX2RldiwgIlJlcXVlc3QgJWQgdGltZWQgb3V0ISBkID0g
 JXAsIGMgPSAlcFxuIiwgaSwgKHZvaWQqKW15X3JlcS0+ZGVhZGxpbmUsICh2b2lkKiljdXJyZW50
 X3RpbWUpOworI2Vsc2UgIC8qIFRXX09TTF9ERUJVRyAqLworCQkJZGV2aWNlX3ByaW50Zigoc2Mp
 LT5idXNfZGV2LCAiUmVxdWVzdCAlZCB0aW1lZCBvdXQhXG4iLCBpKTsKKyNlbmRpZiAvKiBUV19P
 U0xfREVCVUcgKi8KKwkJCWJyZWFrOworCQl9CisJfQorLy89PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K
 KworCWlfbmVlZF9hX3Jlc2V0ID0gdHdfY2xfaXNfcmVzZXRfbmVlZGVkKGN0bHJfaGFuZGxlKTsK
 KworCWkgPSAoaW50KSAoKHNjLT53YXRjaGRvZ19pbmRleCsrKSAmIDEpOworCisJZHJpdmVyX2lz
 X2FjdGl2ZSA9IHR3X2NsX2lzX2FjdGl2ZShjdGxyX2hhbmRsZSk7CisKKwlpZiAoaV9uZWVkX2Ff
 cmVzZXQpIHsKKyNpZmRlZiAgICBUV19PU0xfREVCVUcKKwkJZGV2aWNlX3ByaW50Zigoc2MpLT5i
 dXNfZGV2LCAiV2F0Y2hkb2cgcmVzY2hlZHVsZWQgaW4gNzAgc2Vjb25kc1xuIik7CisjZW5kaWYg
 LyogVFdfT1NMX0RFQlVHICovCisJCW15X3dhdGNoZG9nX3dhc19wZW5kaW5nID0KKwkJCWNhbGxv
 dXRfcmVzZXQoJihzYy0+d2F0Y2hkb2dfY2FsbG91dFtpXSksIDcwKmh6LCB0d2Ffd2F0Y2hkb2cs
 ICZzYy0+Y3Rscl9oYW5kbGUpOworCQl0d19jbF9yZXNldF9jdGxyKGN0bHJfaGFuZGxlKTsKKyNp
 ZmRlZiAgICBUV19PU0xfREVCVUcKKwkJZGV2aWNlX3ByaW50Zigoc2MpLT5idXNfZGV2LCAiV2F0
 Y2hkb2cgcmVzZXQgY29tcGxldGVkIVxuIik7CisjZW5kaWYgLyogVFdfT1NMX0RFQlVHICovCisJ
 fSBlbHNlIGlmIChkcml2ZXJfaXNfYWN0aXZlKSB7CisJCW15X3dhdGNoZG9nX3dhc19wZW5kaW5n
 ID0KKwkJCWNhbGxvdXRfcmVzZXQoJihzYy0+d2F0Y2hkb2dfY2FsbG91dFtpXSksICA1Kmh6LCB0
 d2Ffd2F0Y2hkb2csICZzYy0+Y3Rscl9oYW5kbGUpOworCX0KKyNpZmRlZiAgICBUV19PU0xfREVC
 VUcKKwlpZiAoaV9uZWVkX2FfcmVzZXQgfHwgbXlfd2F0Y2hkb2dfd2FzX3BlbmRpbmcpCisJCWRl
 dmljZV9wcmludGYoKHNjKS0+YnVzX2RldiwgImlfbmVlZF9hX3Jlc2V0ID0gJWQsICIKKwkJImRy
 aXZlcl9pc19hY3RpdmUgPSAlZCwgbXlfd2F0Y2hkb2dfd2FzX3BlbmRpbmcgPSAlZFxuIiwKKwkJ
 aV9uZWVkX2FfcmVzZXQsIGRyaXZlcl9pc19hY3RpdmUsIG15X3dhdGNoZG9nX3dhc19wZW5kaW5n
 KTsKKyNlbmRpZiAvKiBUV19PU0xfREVCVUcgKi8KK30KKwogCiAvKgogICogRnVuY3Rpb24gbmFt
 ZToJdHdfb3NsaV9hbGxvY19tZW0KQEAgLTcxNyw5ICs4MDgsNyBAQAogCiAKIAkvKiBEaXNjb25u
 ZWN0IHRoZSBpbnRlcnJ1cHQgaGFuZGxlci4gKi8KLQlpZiAoc2MtPmludHJfaGFuZGxlKQotCQlp
 ZiAoKGVycm9yID0gYnVzX3RlYXJkb3duX2ludHIoc2MtPmJ1c19kZXYsCi0JCQkJc2MtPmlycV9y
 ZXMsIHNjLT5pbnRyX2hhbmRsZSkpKQorCWlmICgoZXJyb3IgPSB0d2FfdGVhcmRvd25faW50cihz
 YykpKQogCQkJdHdfb3NsaV9kYmdfZHByaW50ZigxLCBzYywKIAkJCQkidGVhcmRvd25faW50ciBy
 ZXR1cm5lZCAlZCIsIGVycm9yKTsKIApAQCAtODExLDYgKzkwMCwxMyBAQAogCiAJdHdfb3NsaV9k
 YmdfZHByaW50ZigzLCBzYywgImVudGVyZWQiKTsKIAorCS8qIFN0b3Agd2F0Y2hkb2cgdGFzay4g
 Ki8KKwljYWxsb3V0X2RyYWluKCYoc2MtPndhdGNoZG9nX2NhbGxvdXRbMF0pKTsKKwljYWxsb3V0
 X2RyYWluKCYoc2MtPndhdGNoZG9nX2NhbGxvdXRbMV0pKTsKKworCS8qIERpc2Nvbm5lY3QgaW50
 ZXJydXB0cy4gKi8KKwllcnJvciA9IHR3YV90ZWFyZG93bl9pbnRyKHNjKTsKKwogCS8qIERpc2Nv
 bm5lY3QgZnJvbSB0aGUgY29udHJvbGxlci4gKi8KIAlpZiAoKGVycm9yID0gdHdfY2xfc2h1dGRv
 d25fY3RscigmKHNjLT5jdGxyX2hhbmRsZSksIDApKSkgewogCQl0d19vc2xpX3ByaW50ZihzYywg
 ImVycm9yID0gJWQiLApAQCAtOTk5LDMzICsxMDk1LDM1IEBACiAJCQkJZXJyb3IgPSAwOyAvKiBG
 YWxzZSBlcnJvciAqLwogCQkJCWJyZWFrOwogCQkJfQotCQkJdHdfb3NsaV9wcmludGYoc2MsICJy
 ZXF1ZXN0ID0gJXAiLAotCQkJCVRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKLQkJCQlUV19D
 TF9NRVNTQUdFX1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKLQkJCQkweDIwMTgsCi0JCQkJIlBhc3N0
 aHJ1IHJlcXVlc3QgdGltZWQgb3V0ISIsCi0JCQkJcmVxKTsKLQkJCS8qCi0JCQkgKiBTaG91bGQg
 SSBjaGVjayBoZXJlIGlmIHRoZSB0aW1lb3V0IGhhcHBlbmVkCi0JCQkgKiBiZWNhdXNlIG9mIHll
 dCBhbm90aGVyIHJlc2V0LCBhbmQgbm90IGRvIGEKLQkJCSAqIHNlY29uZCByZXNldD8KLQkJCSAq
 LwotCQkJdHdfY2xfcmVzZXRfY3Rscigmc2MtPmN0bHJfaGFuZGxlKTsKKwkJCWlmICghKHR3X2Ns
 X2lzX3Jlc2V0X25lZWRlZCgmKHJlcS0+Y3Rsci0+Y3Rscl9oYW5kbGUpKSkpIHsKKyNpZmRlZiAg
 ICBUV19PU0xfREVCVUcKKwkJCQl0d19vc2xpX3ByaW50ZihzYywgInJlcXVlc3QgPSAlcCIsCisJ
 CQkJCVRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKKwkJCQkJVFdfQ0xfTUVTU0FHRV9TT1VS
 Q0VfRlJFRUJTRF9EUklWRVIsCisJCQkJCTB4MjAxOCwKKwkJCQkJIlBhc3N0aHJ1IHJlcXVlc3Qg
 dGltZWQgb3V0ISIsCisJCQkJCXJlcSk7CisjZWxzZSAgLyogVFdfT1NMX0RFQlVHICovCisJCQlk
 ZXZpY2VfcHJpbnRmKChzYyktPmJ1c19kZXYsICJQYXNzdGhydSByZXF1ZXN0IHRpbWVkIG91dCFc
 biIpOworI2VuZGlmIC8qIFRXX09TTF9ERUJVRyAqLworCQkJCXR3X2NsX3Jlc2V0X2N0bHIoJihy
 ZXEtPmN0bHItPmN0bHJfaGFuZGxlKSk7CisJCQl9CisKKwkJCWVycm9yID0gMDsKKwkJCWVuZF90
 aW1lID0gdHdfb3NsX2dldF9sb2NhbF90aW1lKCkgKyB0aW1lb3V0OworCQkJY29udGludWU7CiAJ
 CQkvKgogCQkJICogRG9uJ3QgdG91Y2ggcmVxIGFmdGVyIGEgcmVzZXQuICBJdCAoYW5kIGFueQot
 CQkJICogYXNzb2NpYXRlZCBkYXRhKSB3aWxsIGFscmVhZHkgaGF2ZSBiZWVuCisJCQkgKiBhc3Nv
 Y2lhdGVkIGRhdGEpIHdpbGwgYmUKIAkJCSAqIHVubWFwcGVkIGJ5IHRoZSBjYWxsYmFjay4KIAkJ
 CSAqLwotCQkJdXNlcl9idWYtPmRyaXZlcl9wa3Qub3Nfc3RhdHVzID0gZXJyb3I7Ci0JCQllcnJv
 ciA9IEVUSU1FRE9VVDsKLQkJCWdvdG8gZndfcGFzc3RocnVfZXJyOwogCQl9CiAJCS8qIAogCQkg
 KiBFaXRoZXIgdGhlIHJlcXVlc3QgZ290IGNvbXBsZXRlZCwgb3Igd2Ugd2VyZSB3b2tlbiB1cCBi
 eSBhCiAJCSAqIHNpZ25hbC4gIENhbGN1bGF0ZSB0aGUgbmV3IHRpbWVvdXQsIGluIGNhc2UgaXQg
 d2FzIHRoZSBsYXR0ZXIuCiAJCSAqLwogCQl0aW1lb3V0ID0gKGVuZF90aW1lIC0gdHdfb3NsX2dl
 dF9sb2NhbF90aW1lKCkpOwotCX0KKwl9IC8qIEVuZCBvZiB3aGlsZSBsb29wICovCiAKIAkvKiBJ
 ZiB0aGVyZSB3YXMgYSBwYXlsb2FkLCBjb3B5IGl0IGJhY2suICovCiAJaWYgKCghZXJyb3IpICYm
 IChyZXEtPmxlbmd0aCkpCkBAIC0xMDM5LDE5ICsxMTM3LDkgQEAKIAkJCQllcnJvcik7CiAJCiBm
 d19wYXNzdGhydV9lcnI6Ci0JLyoKLQkgKiBQcmludCB0aGUgZmFpbHVyZSBtZXNzYWdlLiAgRm9y
 IHNvbWUgcmVhc29uLCBvbiBjZXJ0YWluIE9TIHZlcnNpb25zLAotCSAqIHByaW50aW5nIHRoaXMg
 ZXJyb3IgbWVzc2FnZSBkdXJpbmcgcmVzZXQgaGFuZ3MgdGhlIGRpc3BsYXkgKGFsdGhvdWdoCi0J
 ICogdGhlIHJlc3Qgb2YgdGhlIHN5c3RlbSBpcyBydW5uaW5nIGZpbmUuICBTbywgZG9uJ3QgcHJp
 bnQgaXQgaWYgdGhlCi0JICogZmFpbHVyZSB3YXMgZHVlIHRvIGEgcmVzZXQuCi0JICovCi0JaWYg
 KChlcnJvcikgJiYgKGVycm9yICE9IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUKSkKLQkJdHdfb3Ns
 aV9wcmludGYoc2MsICJlcnJvciA9ICVkIiwJCQotCQkJVFdfQ0xfU0VWRVJJVFlfRVJST1JfU1RS
 SU5HLAotCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCi0JCQkweDIwMUEs
 Ci0JCQkiRmlybXdhcmUgcGFzc3RocnUgZmFpbGVkISIsCi0JCQllcnJvcik7CisKKwlpZiAocmVx
 X3BrdC0+c3RhdHVzID09IFRXX0NMX0VSUl9SRVFfQlVTX1JFU0VUKQorCQllcnJvciA9IEVCVVNZ
 OwogCiAJdXNlcl9idWYtPmRyaXZlcl9wa3Qub3Nfc3RhdHVzID0gZXJyb3I7CiAJLyogRnJlZSBy
 ZXNvdXJjZXMuICovCkBAIC0xMDc1LDYgKzExNjMsOCBAQAogdHdfb3NsX2NvbXBsZXRlX3Bhc3N0
 aHJ1KHN0cnVjdCB0d19jbF9yZXFfaGFuZGxlICpyZXFfaGFuZGxlKQogewogCXN0cnVjdCB0d19v
 c2xpX3JlcV9jb250ZXh0CSpyZXEgPSByZXFfaGFuZGxlLT5vc2xfcmVxX2N0eHQ7CisJc3RydWN0
 IHR3X2NsX3JlcV9wYWNrZXQJCSpyZXFfcGt0ID0KKwkJKHN0cnVjdCB0d19jbF9yZXFfcGFja2V0
 ICopKCZyZXEtPnJlcV9wa3QpOwogCXN0cnVjdCB0d2Ffc29mdGMJCSpzYyA9IHJlcS0+Y3RscjsK
 IAogCXR3X29zbGlfZGJnX2RwcmludGYoNSwgc2MsICJlbnRlcmVkIik7CkBAIC0xMTIyLDYgKzEy
 MTIsOSBAQAogCQkJaWYgKHJlcS0+ZmxhZ3MgJiBUV19PU0xJX1JFUV9GTEFHU19NQVBQRUQpCiAJ
 CQkJcmV0dXJuOwogCisJCQlpZiAocmVxX3BrdC0+c3RhdHVzID09IFRXX0NMX0VSUl9SRVFfQlVT
 X1JFU0VUKQorCQkJCXJldHVybjsKKwogCQkJdHdfb3NsaV9wcmludGYoc2MsICJyZXF1ZXN0ID0g
 JXAiLAogCQkJCVRXX0NMX1NFVkVSSVRZX0VSUk9SX1NUUklORywKIAkJCQlUV19DTF9NRVNTQUdF
 X1NPVVJDRV9GUkVFQlNEX0RSSVZFUiwKQEAgLTExNjgsNiArMTI2MSw3IEBACiAJCXJlcS0+cmVx
 X2hhbmRsZS5pc19pbyA9IDA7CiAJCXJlcS0+ZGF0YSA9IE5VTEw7CiAJCXJlcS0+bGVuZ3RoID0g
 MDsKKwkJcmVxLT5kZWFkbGluZSA9IDA7CiAJCXJlcS0+cmVhbF9kYXRhID0gTlVMTDsKIAkJcmVx
 LT5yZWFsX2xlbmd0aCA9IDA7CiAJCXJlcS0+c3RhdGUgPSBUV19PU0xJX1JFUV9TVEFURV9JTklU
 Oy8qIHJlcSBiZWluZyBpbml0aWFsaXplZCAqLwpAQCAtMTIwOSw2ICsxMzAzLDExIEBACiAKIAl0
 d19vc2xpX2RiZ19kcHJpbnRmKDEwLCBzYywgImVudGVyZWQiKTsKIAorCWlmIChlcnJvciA9PSBF
 SU5WQUwpIHsKKwkJcmVxLT5lcnJvcl9jb2RlID0gZXJyb3I7CisJCXJldHVybjsKKwl9CisKIAkv
 KiBNYXJrIHRoZSByZXF1ZXN0IGFzIGN1cnJlbnRseSBiZWluZyBwcm9jZXNzZWQuICovCiAJcmVx
 LT5zdGF0ZSA9IFRXX09TTElfUkVRX1NUQVRFX0JVU1k7CiAJLyogTW92ZSB0aGUgcmVxdWVzdCBp
 bnRvIHRoZSBidXN5IHF1ZXVlLiAqLwpAQCAtMTQwMiw2ICsxNTAxLDE0IEBACiAJCQkJbXR4X3Vu
 bG9ja19zcGluKHNjLT5pb19sb2NrKTsKIAkJCQllcnJvciA9IDA7CiAJCQl9IGVsc2UgeworCQkJ
 CXR3X29zbGlfcHJpbnRmKHNjLCAiZXJyb3IgPSAlZCIsCisJCQkJCVRXX0NMX1NFVkVSSVRZX0VS
 Uk9SX1NUUklORywKKwkJCQkJVFdfQ0xfTUVTU0FHRV9TT1VSQ0VfRlJFRUJTRF9EUklWRVIsCisJ
 CQkJCTB4OTk5OSwKKwkJCQkJIkZhaWxlZCB0byBtYXAgRE1BIG1lbW9yeSAiCisJCQkJCSJmb3Ig
 SS9PIHJlcXVlc3QiLAorCQkJCQllcnJvcik7CisJCQkJcmVxLT5mbGFncyB8PSBUV19PU0xJX1JF
 UV9GTEFHU19GQUlMRUQ7CiAJCQkJLyogRnJlZSBhbGlnbm1lbnQgYnVmZmVyIGlmIGl0IHdhcyB1
 c2VkLiAqLwogCQkJCWlmIChyZXEtPmZsYWdzICYKIAkJCQkJVFdfT1NMSV9SRVFfRkxBR1NfREFU
 QV9DT1BZX05FRURFRCkgewpkaWZmIC11IEZyZWVCU0RfUkVMRU5HXzdfdHdhX2N2cy90d19vc2xf
 c2hhcmUuaCBGcmVlQlNEN190d2FfM183MF8wNV8wMTAvdHdfb3NsX3NoYXJlLmgKLS0tIEZyZWVC
 U0RfUkVMRU5HXzdfdHdhX2N2cy90d19vc2xfc2hhcmUuaAkyMDEwLTA4LTI2IDE1OjM1OjAwLjAw
 MDAwMDAwMCAtMDcwMAorKysgRnJlZUJTRDdfdHdhXzNfNzBfMDVfMDEwL3R3X29zbF9zaGFyZS5o
 CTIwMTAtMDgtMjQgMTg6MDE6MTMuMDAwMDAwMDAwIC0wNzAwCkBAIC03NSw3ICs3NSw3IEBACiAj
 ZGVmaW5lIFRXX09TTF9FTkNMT1NVUkVfU1VQUE9SVAogI2VuZGlmCiAKLSNkZWZpbmUgVFdfT1NM
 X0RSSVZFUl9WRVJTSU9OX1NUUklORwkiMy43MC4wNS4wMDgiCisjZGVmaW5lIFRXX09TTF9EUklW
 RVJfVkVSU0lPTl9TVFJJTkcJIjMuNzAuMDUuMDEwIgogCiAjZGVmaW5lCVRXX09TTF9DQU5fU0xF
 RVAKIAo=
 
 --_002_27AEC73CFDE2EA41849ACAC11A0B39D5E9B0504Ccosmail03lsicom_--
State-Changed-From-To: open->patched 
State-Changed-By: linimon 
State-Changed-When: Mon Sep 6 07:46:50 UTC 2010 
State-Changed-Why:  
Note that fix has been committed to head. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=149968 

From: dfilter@FreeBSD.ORG (dfilter service)
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/149968: commit references a PR
Date: Sun, 12 Sep 2010 06:19:45 +0000 (UTC)

 Author: delphij
 Date: Sun Sep 12 06:19:35 2010
 New Revision: 212490
 URL: http://svn.freebsd.org/changeset/base/212490
 
 Log:
   MFC r212008, 212028, 212210: Vendor update to version 3.80.06.003 to
   fix panic with ZFS under heavy I/O load.
   
   PR:             kern/149968
   Submitted by:   LSI (Tom Couch)
   Reported by:    Kai Kockro <kkockro web de>
   Tested by:      Kai Kockro, jpaetzel
 
 Modified:
   stable/8/sys/dev/twa/tw_cl.h
   stable/8/sys/dev/twa/tw_cl_externs.h
   stable/8/sys/dev/twa/tw_cl_fwif.h
   stable/8/sys/dev/twa/tw_cl_init.c
   stable/8/sys/dev/twa/tw_cl_intr.c
   stable/8/sys/dev/twa/tw_cl_io.c
   stable/8/sys/dev/twa/tw_cl_misc.c
   stable/8/sys/dev/twa/tw_cl_share.h
   stable/8/sys/dev/twa/tw_osl.h
   stable/8/sys/dev/twa/tw_osl_cam.c
   stable/8/sys/dev/twa/tw_osl_freebsd.c
   stable/8/sys/dev/twa/tw_osl_share.h
 Directory Properties:
   stable/8/sys/   (props changed)
   stable/8/sys/amd64/include/xen/   (props changed)
   stable/8/sys/cddl/contrib/opensolaris/   (props changed)
   stable/8/sys/contrib/dev/acpica/   (props changed)
   stable/8/sys/contrib/pf/   (props changed)
   stable/8/sys/dev/xen/xenpci/   (props changed)
 
 Modified: stable/8/sys/dev/twa/tw_cl.h
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl.h	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl.h	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -88,7 +88,8 @@ struct tw_cli_q_stats {
  #define TW_CLI_BUSY_Q		1	/* q of reqs submitted to fw */
  #define TW_CLI_PENDING_Q	2	/* q of reqs deferred due to 'q full' */
  #define TW_CLI_COMPLETE_Q	3	/* q of reqs completed by fw */
 -#define TW_CLI_Q_COUNT		4	/* total number of queues */
 +#define TW_CLI_RESET_Q		4	/* q of reqs reset by timeout */
 +#define TW_CLI_Q_COUNT		5	/* total number of queues */
  
  
  /* CL's internal request context. */
 @@ -133,6 +134,7 @@ struct tw_cli_ctlr_context {
  	TW_UINT8 		interrupts_enabled;	  /* Interrupts on controller enabled. */
  	TW_UINT8 		internal_req_busy;	  /* Data buffer for internal requests in use. */
  	TW_UINT8 		get_more_aens;		  /* More AEN's need to be retrieved. */
 +	TW_UINT8 		reset_needed;		  /* Controller needs a soft reset. */
  	TW_UINT8 		reset_in_progress;	  /* Controller is being reset. */
  	TW_UINT8 		reset_phase1_in_progress; /* In 'phase 1' of reset. */
  	TW_UINT32		flags;		/* controller settings */
 
 Modified: stable/8/sys/dev/twa/tw_cl_externs.h
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_externs.h	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_externs.h	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -86,6 +86,8 @@ extern TW_INT32	tw_cli_submit_and_poll_r
  
  /* Soft reset the controller. */
  extern TW_INT32	tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr);
 +extern int twa_setup_intr(struct twa_softc *sc);
 +extern int twa_teardown_intr(struct twa_softc *sc);
  
  /* Send down a SCSI command to the firmware (usually, an internal Req Sense. */
  extern TW_INT32	tw_cli_send_scsi_cmd(struct tw_cli_req_context *req,
 
 Modified: stable/8/sys/dev/twa/tw_cl_fwif.h
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_fwif.h	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_fwif.h	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -89,7 +89,7 @@
  #define TWA_STATUS_MINOR_VERSION_MASK		0x0F000000
  #define TWA_STATUS_MAJOR_VERSION_MASK		0xF0000000
  
 -#define TWA_STATUS_UNEXPECTED_BITS		0x00F00000
 +#define TWA_STATUS_UNEXPECTED_BITS		0x00D00000
  
  
  /* PCI related defines. */
 
 Modified: stable/8/sys/dev/twa/tw_cl_init.c
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_init.c	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_init.c	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -315,6 +315,7 @@ tw_cl_init_ctlr(struct tw_cl_ctlr_handle
  	tw_cli_req_q_init(ctlr, TW_CLI_BUSY_Q);
  	tw_cli_req_q_init(ctlr, TW_CLI_PENDING_Q);
  	tw_cli_req_q_init(ctlr, TW_CLI_COMPLETE_Q);
 +	tw_cli_req_q_init(ctlr, TW_CLI_RESET_Q);
  
  	/* Initialize all locks used by CL. */
  	ctlr->gen_lock = &(ctlr->gen_lock_handle);
 @@ -675,15 +676,14 @@ tw_cli_init_connection(struct tw_cli_ctl
  	/* Submit the command, and wait for it to complete. */
  	error = tw_cli_submit_and_poll_request(req,
  		TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -	if (error == TW_OSL_ETIMEDOUT)
 -		/* Clean-up done by tw_cli_submit_and_poll_request. */
 -		return(error);
  	if (error)
  		goto out;
  	if ((error = init_connect->status)) {
 +#if       0
  		tw_cli_create_ctlr_event(ctlr,
  			TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  			&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  		goto out;
  	}
  	if (set_features & TWA_EXTENDED_INIT_CONNECT) {
 
 Modified: stable/8/sys/dev/twa/tw_cl_intr.c
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_intr.c	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_intr.c	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -248,8 +248,7 @@ tw_cli_process_resp_intr(struct tw_cli_c
  #ifdef TW_OSL_DEBUG
  			tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
  #endif /* TW_OSL_DEBUG */
 -			tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -			return(TW_OSL_EIO);
 +			continue;
  		}
  
  		/*
 @@ -402,9 +401,7 @@ tw_cli_complete_io(struct tw_cli_req_con
  #ifdef TW_OSL_DEBUG
  		tw_cl_print_ctlr_stats(ctlr->ctlr_handle);
  #endif /* TW_OSL_DEBUG */
 -		tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -		req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -		goto out;
 +		return;
  	}
  
  	if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 @@ -483,6 +480,7 @@ tw_cli_scsi_complete(struct tw_cli_req_c
  			cdb[8], cdb[9], cdb[10], cdb[11],
  			cdb[12], cdb[13], cdb[14], cdb[15]);
  
 +#if       0
  		/* 
  		 * Print the error. Firmware doesn't yet support
  		 * the 'Mode Sense' cmd.  Don't print if the cmd
 @@ -493,6 +491,7 @@ tw_cli_scsi_complete(struct tw_cli_req_c
  			tw_cli_create_ctlr_event(req->ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  	}
  
  	if (scsi_req->sense_data) {
 @@ -530,9 +529,11 @@ tw_cli_param_callback(struct tw_cli_req_
  	 */
  	if (! req->error_code)
  		if (cmd->param.status) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  				0x1204, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 @@ -590,9 +591,11 @@ tw_cli_aen_callback(struct tw_cli_req_co
  		if ((error = cmd->status)) {
  			cmd_hdr = (struct tw_cl_command_header *)
  				(&(req->cmd_pkt->cmd_hdr));
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  			tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  				0x1206, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 
 Modified: stable/8/sys/dev/twa/tw_cl_io.c
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_io.c	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_io.c	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -74,18 +74,12 @@ tw_cl_start_io(struct tw_cl_ctlr_handle 
  	struct tw_cli_req_context		*req;
  	struct tw_cl_command_9k			*cmd;
  	struct tw_cl_scsi_req_packet		*scsi_req;
 -	TW_INT32				error;
 +	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
  
  	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  
 -	if (ctlr->reset_in_progress) {
 -		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -			"I/O during reset: returning busy.");
 -		return(TW_OSL_EBUSY);
 -	}
 -
  	/*
  	 * If working with a firmware version that does not support multiple
  	 * luns, and this request is directed at a non-zero lun, error it
 @@ -145,7 +139,12 @@ tw_cl_start_io(struct tw_cl_ctlr_handle 
  			cmd->sg_list, scsi_req->sgl_entries);
  	}
  
 -	if ((error = tw_cli_submit_cmd(req))) {
 +	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
 +		(ctlr->reset_in_progress)) {
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 +	} else if ((error = tw_cli_submit_cmd(req))) {
  		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
  			"Could not start request. request = %p, error = %d",
  			req, error);
 @@ -171,7 +170,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  	struct tw_cli_ctlr_context	*ctlr = req->ctlr;
  	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
  	TW_UINT32			status_reg;
 -	TW_INT32			error;
 +	TW_INT32			error = 0;
  
  	tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
  
 @@ -185,11 +184,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  				 TWA_COMMAND_QUEUE_OFFSET_LOW,
  				 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
  
 -	/* Check to see if we can post a command. */
  	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
 -	if ((error = tw_cli_check_ctlr_state(ctlr, status_reg)))
 -		goto out;
 -
  	if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
  		struct tw_cl_req_packet	*req_pkt =
  			(struct tw_cl_req_packet *)(req->orig_req);
 @@ -207,14 +202,12 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  					"pending internal/ioctl request");
  				req->state = TW_CLI_REQ_STATE_PENDING;
  				tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 -				error = 0;
  				/* Unmask command interrupt. */
  				TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
  					TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
  			} else
  				error = TW_OSL_EBUSY;
  		} else {
 -			tw_osl_ctlr_busy(ctlr_handle, req->req_handle);
  			error = TW_OSL_EBUSY;
  		}
  	} else {
 @@ -246,7 +239,7 @@ tw_cli_submit_cmd(struct tw_cli_req_cont
  						 (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
  		}
  	}
 -out:
 +
  	tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
  
  	return(error);
 @@ -277,18 +270,12 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  	TW_UINT8				opcode;
  	TW_UINT8				sgl_offset;
  	TW_VOID					*sgl = TW_CL_NULL;
 -	TW_INT32				error;
 +	TW_INT32				error = TW_CL_ERR_REQ_SUCCESS;
  
  	tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  
 -	if (ctlr->reset_in_progress) {
 -		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -			"Passthru request during reset: returning busy.");
 -		return(TW_OSL_EBUSY);
 -	}
 -
  	if ((req = tw_cli_get_request(ctlr
  		)) == TW_CL_NULL) {
  		tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 @@ -301,7 +288,7 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  	req->orig_req = req_pkt;
  	req->tw_cli_callback = tw_cli_complete_io;
  
 -	req->flags |= (TW_CLI_REQ_FLAGS_EXTERNAL | TW_CLI_REQ_FLAGS_PASSTHRU);
 +	req->flags |= TW_CLI_REQ_FLAGS_PASSTHRU;
  
  	pt_req = &(req_pkt->gen_req_pkt.pt_req);
  
 @@ -348,7 +335,12 @@ tw_cl_fw_passthru(struct tw_cl_ctlr_hand
  		tw_cli_fill_sg_list(ctlr, pt_req->sg_list,
  			sgl, pt_req->sgl_entries);
  
 -	if ((error = tw_cli_submit_cmd(req))) {
 +	if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) ||
 +		(ctlr->reset_in_progress)) {
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 +	} else if ((error = tw_cli_submit_cmd(req))) {
  		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
  			0x1100, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 @@ -760,8 +752,7 @@ tw_cli_get_param(struct tw_cli_ctlr_cont
  
  	cmd->param.sgl_off__opcode =
  		BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_GET_PARAM);
 -	cmd->param.request_id =
 -		(TW_UINT8)(TW_CL_SWAP16(req->request_id));
 +	cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id));
  	cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0);
  	cmd->param.param_count = TW_CL_SWAP16(1);
  
 @@ -789,15 +780,14 @@ tw_cli_get_param(struct tw_cli_ctlr_cont
  		/* There's no call back; wait till the command completes. */
  		error = tw_cli_submit_and_poll_request(req,
  				TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -		if (error == TW_OSL_ETIMEDOUT)
 -			/* Clean-up done by tw_cli_submit_and_poll_request. */
 -			return(error);
  		if (error)
  			goto out;
  		if ((error = cmd->param.status)) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			goto out;
  		}
  		tw_osl_memcpy(param_data, param->data, param_size);
 @@ -905,18 +895,17 @@ tw_cli_set_param(struct tw_cli_ctlr_cont
  
  	/* Submit the command. */
  	if (callback == TW_CL_NULL) {
 -		/* There's no call back;  wait till the command completes. */
 +		/* There's no call back; wait till the command completes. */
  		error = tw_cli_submit_and_poll_request(req,
 -			TW_CLI_REQUEST_TIMEOUT_PERIOD);
 -		if (error == TW_OSL_ETIMEDOUT)
 -			/* Clean-up done by tw_cli_submit_and_poll_request. */
 -			return(error);
 +				TW_CLI_REQUEST_TIMEOUT_PERIOD);
  		if (error)
  			goto out;
  		if ((error = cmd->param.status)) {
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				&(req->cmd_pkt->cmd_hdr));
 +#endif // 0
  			goto out;
  		}
  		ctlr->internal_req_busy = TW_CL_FALSE;
 @@ -1022,9 +1011,7 @@ tw_cli_submit_and_poll_request(struct tw
  	 * tw_cli_submit_pending_queue.  There could be a race in that case.
  	 * Need to revisit.
  	 */
 -	if (req->state != TW_CLI_REQ_STATE_PENDING)
 -		tw_cl_reset_ctlr(ctlr->ctlr_handle);
 -	else {
 +	if (req->state == TW_CLI_REQ_STATE_PENDING) {
  		tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(),
  			"Removing request from pending queue");
  		/*
 @@ -1053,6 +1040,7 @@ tw_cli_submit_and_poll_request(struct tw
   *			drains any incomplete requests.
   *
   * Input:		ctlr	-- ptr to per ctlr structure
 + * 			req_handle	-- ptr to request handle
   * Output:		None
   * Return value:	0	-- success
   *			non-zero-- failure
 @@ -1063,15 +1051,15 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	struct tw_cli_ctlr_context	*ctlr =
  		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  	struct twa_softc		*sc = ctlr_handle->osl_ctlr_ctxt;
 +	struct tw_cli_req_context	*req;
  	TW_INT32			reset_attempt = 1;
 -	TW_INT32			error;
 +	TW_INT32			error = 0;
  
  	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "entered");
  
  	ctlr->reset_in_progress = TW_CL_TRUE;
 -	xpt_freeze_simq(sc->sim, 1);
 +	twa_teardown_intr(sc);
  
 -	tw_cli_disable_interrupts(ctlr);
  
  	/*
  	 * Error back all requests in the complete, busy, and pending queues.
 @@ -1080,8 +1068,6 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	 * will continue its course and get submitted to the controller after
  	 * the reset is done (and io_lock is released).
  	 */
 -	tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 -		"Draining all queues following reset");
  	tw_cli_drain_complete_queue(ctlr);
  	tw_cli_drain_busy_queue(ctlr);
  	tw_cli_drain_pending_queue(ctlr);
 @@ -1089,53 +1075,88 @@ tw_cl_reset_ctlr(struct tw_cl_ctlr_handl
  	ctlr->get_more_aens     = TW_CL_FALSE;
  
  	/* Soft reset the controller. */
 -try_reset:
 -	if ((error = tw_cli_soft_reset(ctlr))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Controller reset failed",
 -			"error = %d; attempt %d", error, reset_attempt++);
 -		if (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS)
 -			goto try_reset;
 -		else
 -			goto out;
 -	}
 +	while (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS) {
 +		if ((error = tw_cli_soft_reset(ctlr))) {
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 +				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 +				0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 +				"Controller reset failed",
 +				"error = %d; attempt %d", error, reset_attempt++);
 +			reset_attempt++;
 +			continue;
 +		}
  
 -	/* Re-establish logical connection with the controller. */
 -	if ((error = tw_cli_init_connection(ctlr,
 -			(TW_UINT16)(ctlr->max_simult_reqs),
 -			0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
 -			TW_CL_NULL, TW_CL_NULL))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		/* Re-establish logical connection with the controller. */
 +		if ((error = tw_cli_init_connection(ctlr,
 +				(TW_UINT16)(ctlr->max_simult_reqs),
 +				0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
 +				TW_CL_NULL, TW_CL_NULL))) {
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 +				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 +				0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 +				"Can't initialize connection after reset",
 +				"error = %d", error);
 +			reset_attempt++;
 +			continue;
 +		}
 +
 +#ifdef    TW_OSL_DEBUG
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Can't initialize connection after reset",
 -			"error = %d", error);
 -		goto out;
 -	}
 +			0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
 +			"Controller reset done!", " ");
 +#endif /* TW_OSL_DEBUG */
 +		break;
 +	} /* End of while */
  
 -	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -		0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
 -		"Controller reset done!",
 -		" ");
 +	/* Move commands from the reset queue to the pending queue. */
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_RESET_Q)) != TW_CL_NULL) {
 +		tw_osl_timeout(req->req_handle);
 +		tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 +	}
  
 -out:
 +	twa_setup_intr(sc);
 +	tw_cli_enable_interrupts(ctlr);
 +	if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL)
 +		TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 +			TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
  	ctlr->reset_in_progress = TW_CL_FALSE;
 -	xpt_release_simq(sc->sim, 1);
 +	ctlr->reset_needed = TW_CL_FALSE;
  
 -	/*
 -	 * Enable interrupts, and also clear attention and response interrupts.
 -	 */
 -	tw_cli_enable_interrupts(ctlr);
 -	
  	/* Request for a bus re-scan. */
 -	if (!error)
 -		tw_osl_scan_bus(ctlr_handle);
 +	tw_osl_scan_bus(ctlr_handle);
 +
  	return(error);
  }
  
 +TW_VOID
 +tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 +
 +	ctlr->reset_needed = TW_CL_TRUE;
 +}
 +
 +TW_INT32
 +tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 +
 +	return(ctlr->reset_needed);
 +}
 +
 +TW_INT32
 +tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle)
 +{
 +	struct tw_cli_ctlr_context	*ctlr =
 +		(struct tw_cli_ctlr_context *)
 +		(ctlr_handle->cl_ctlr_ctxt);
 +
 +		return(ctlr->active);
 +}
 +
  
  
  /*
 @@ -1151,14 +1172,13 @@ TW_INT32
  tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr)
  {
  	struct tw_cl_ctlr_handle	*ctlr_handle = ctlr->ctlr_handle;
 -	TW_UINT32			status_reg;
  	int				found;
  	int				loop_count;
  	TW_UINT32			error;
  
  	tw_cli_dbg_printf(1, ctlr_handle, tw_osl_cur_func(), "entered");
  
 -	tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +	tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  		TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  		0x1108, 0x3, TW_CL_SEVERITY_INFO_STRING,
  		"Resetting controller...",
 @@ -1193,7 +1213,7 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  		} while (!found && (loop_count < 6000000)); /* Loop for no more than 60 seconds */
  
  		if (!found) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"Missed firmware handshake after soft-reset",
 @@ -1210,7 +1230,7 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  			TWA_STATUS_MICROCONTROLLER_READY |
  			TWA_STATUS_ATTENTION_INTERRUPT,
  			TW_CLI_RESET_TIMEOUT_PERIOD))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Micro-ctlr not ready/No attn intr after reset",
 @@ -1244,26 +1264,14 @@ tw_cli_soft_reset(struct tw_cli_ctlr_con
  	}
  	
  	if ((error = tw_cli_find_aen(ctlr, TWA_AEN_SOFT_RESET))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x110C, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Reset not reported by controller",
  			"error = %d", error);
  		return(error);
  	}
 -	
 -	status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
 -	
 -	if ((error = TW_CLI_STATUS_ERRORS(status_reg)) ||
 -			(error = tw_cli_check_ctlr_state(ctlr, status_reg))) {
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -			0x110D, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -			"Controller errors detected after reset",
 -			"error = %d", error);
 -		return(error);
 -	}
 -	
 +
  	return(TW_OSL_ESUCCESS);
  }
  
 
 Modified: stable/8/sys/dev/twa/tw_cl_misc.c
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_misc.c	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_misc.c	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -83,7 +83,8 @@ tw_cli_drain_complete_queue(struct tw_cl
  	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
  
  	/* Walk the busy queue. */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -97,20 +98,21 @@ tw_cli_drain_complete_queue(struct tw_cl
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's a SCSI request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing complete request %p "
 -					"on reset",
 -					req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -135,7 +137,8 @@ tw_cli_drain_busy_queue(struct tw_cli_ct
  	tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
  
  	/* Walk the busy queue. */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -149,19 +152,21 @@ tw_cli_drain_busy_queue(struct tw_cli_ct
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's a SCSI request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing busy request %p on reset",
 -					req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -188,7 +193,8 @@ tw_cli_drain_pending_queue(struct tw_cli
  	/*
  	 * Pull requests off the pending queue, and complete them.
  	 */
 -	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q))) {
 +	while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q)) !=
 +		TW_CL_NULL) {
  		if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
  			/*
  			 * It's an internal request.  Set the appropriate
 @@ -202,19 +208,21 @@ tw_cli_drain_pending_queue(struct tw_cli
  			req->error_code = TW_CL_ERR_REQ_BUS_RESET;
  			if (req->tw_cli_callback)
  				req->tw_cli_callback(req);
 -		} else {
 -			if ((req_pkt = req->orig_req)) {
 -				/* It's an external request.  Complete it. */
 -				tw_cli_dbg_printf(2, ctlr->ctlr_handle,
 -					tw_osl_cur_func(),
 -					"Completing pending request %p "
 -					"on reset", req);
 +		} else if (req->flags & TW_CLI_REQ_FLAGS_PASSTHRU) {
 +			/* It's a passthru request.  Complete it. */
 +			if ((req_pkt = req->orig_req) != TW_CL_NULL) {
  				req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
 -				req_pkt->tw_osl_callback(req->req_handle);
 +
 +				if (req_pkt->tw_osl_callback)
 +					req_pkt->tw_osl_callback(req->req_handle);
  			}
  			tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 +		} else {
 +			/* It's an external (SCSI) request.  Add it to the reset queue. */
 +			tw_osl_untimeout(req->req_handle);
 +			tw_cli_req_q_insert_tail(req, TW_CLI_RESET_Q);
  		}
 -	}
 +	} /* End of while loop */
  }
  
  
 @@ -239,9 +247,6 @@ tw_cli_drain_response_queue(struct tw_cl
  	for (;;) {
  		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
  
 -		if (tw_cli_check_ctlr_state(ctlr, status_reg))
 -			return(TW_OSL_EGENFAILURE);
 -
  		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
  			return(TW_OSL_ESUCCESS); /* no more response queue entries */
  
 @@ -273,9 +278,6 @@ tw_cli_find_response(struct tw_cli_ctlr_
  	for (;;) {
  		status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
  
 -		if (tw_cli_check_ctlr_state(ctlr, status_reg))
 -			return(TW_OSL_EGENFAILURE);
 -
  		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
  			return(TW_OSL_ENOTTY); /* no more response queue entries */
  
 @@ -356,9 +358,11 @@ tw_cli_drain_aen_queue(struct tw_cli_ctl
  
  		if ((error = req->cmd_pkt->command.cmd_pkt_9k.status)) {
  			cmd_hdr = &req->cmd_pkt->cmd_hdr;
 +#if       0
  			tw_cli_create_ctlr_event(ctlr,
  				TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
  				cmd_hdr);
 +#endif // 0
  			break;
  		}
  
 @@ -714,7 +718,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  
  		tw_osl_memzero(desc, 200);
  		if (!(ctlr->reset_phase1_in_progress)) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1301, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"Missing expected status bit(s)",
 @@ -738,7 +742,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  		     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
  		    (!(ctlr->reset_in_progress)) ||
  		    ((status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) == 0))
 -		tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +		tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  			0x1302, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  			"Unexpected status bit(s)",
 @@ -748,7 +752,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  				TWA_STATUS_UNEXPECTED_BITS, desc));
  
  		if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1303, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"PCI parity error: clearing... "
 @@ -768,7 +772,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  		}
  
  		if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +			tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  				0x1304, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  				"PCI abort: clearing... ",
 @@ -791,7 +795,7 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  			if (((ctlr->device_id != TW_CL_DEVICE_ID_9K_E) &&
  			     (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
  			    (!(ctlr->reset_in_progress)))
 -				tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 +				tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
  						   TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
  						   0x1305, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  						   "Controller queue error: clearing... ",
 @@ -801,17 +805,6 @@ tw_cli_check_ctlr_state(struct tw_cli_ct
  			TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
  				TWA_CONTROL_CLEAR_QUEUE_ERROR);
  		}
 -
 -		if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
 -			tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
 -				TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
 -				0x1307, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -				"Micro-controller error! ",
 -				"status reg = 0x%x %s",
 -				status_reg,
 -				tw_cli_describe_bits(status_reg, desc));
 -			error = TW_OSL_EGENFAILURE;
 -		}
  	}
  	return(error);
  }	
 @@ -850,8 +843,6 @@ tw_cli_describe_bits(TW_UINT32 reg, TW_I
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "HOST_INTR,");
  	if (reg & TWA_STATUS_PCI_ABORT_INTERRUPT)
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "PCI_ABRT,");
 -	if (reg & TWA_STATUS_MICROCONTROLLER_ERROR)
 -		tw_osl_strcpy(&str[tw_osl_strlen(str)], "MC_ERR,");
  	if (reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT)
  		tw_osl_strcpy(&str[tw_osl_strlen(str)], "Q_ERR,");
  	if (reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT)
 
 Modified: stable/8/sys/dev/twa/tw_cl_share.h
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_cl_share.h	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_cl_share.h	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -349,10 +349,14 @@ extern TW_VOID	tw_osl_breakpoint(TW_VOID
  #endif
  
  
 -#ifndef tw_osl_ctlr_busy
 -/* Called when CL is too busy to accept new requests. */
 -extern TW_VOID	tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
 -	struct tw_cl_req_handle *req_handle);
 +#ifndef tw_osl_timeout
 +/* Start OS timeout() routine after controller reset sequence */
 +extern TW_VOID	tw_osl_timeout(struct tw_cl_req_handle *req_handle);
 +#endif
 +
 +#ifndef tw_osl_untimeout
 +/* Stop OS timeout() routine during controller reset sequence */
 +extern TW_VOID	tw_osl_untimeout(struct tw_cl_req_handle *req_handle);
  #endif
  
  
 @@ -552,6 +556,10 @@ extern TW_INT32	tw_cl_init_ctlr(struct t
  	);
  
  
 +extern TW_VOID  tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
 +extern TW_INT32 tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle);
 +extern TW_INT32 tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle);
 +
  /* CL's interrupt handler. */
  extern TW_INT32	tw_cl_interrupt(struct tw_cl_ctlr_handle *ctlr_handle);
  
 
 Modified: stable/8/sys/dev/twa/tw_osl.h
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_osl.h	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_osl.h	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -77,6 +77,7 @@
  						EINPROGRESS */
  #define TW_OSLI_REQ_FLAGS_PASSTHRU	(1<<5)	/* pass through request */
  #define TW_OSLI_REQ_FLAGS_SLEEPING	(1<<6)	/* owner sleeping on this cmd */
 +#define TW_OSLI_REQ_FLAGS_FAILED	(1<<7)	/* bus_dmamap_load() failed */
  
  
  #ifdef TW_OSL_DEBUG
 @@ -100,6 +101,7 @@ struct tw_osli_req_context {
  	struct twa_softc	*ctlr;	/* ptr to OSL's controller context */
  	TW_VOID			*data;	/* ptr to data being passed to CL */
  	TW_UINT32		length;	/* length of buf being passed to CL */
 +	TW_UINT64		deadline;/* request timeout (in absolute time) */
  
  	/*
  	 * ptr to, and length of data passed to us from above, in case a buffer
 @@ -151,6 +153,9 @@ struct twa_softc {
  	struct mtx		sim_lock_handle;/* sim lock shared with cam */
  	struct mtx		*sim_lock;/* ptr to sim lock */
  
 +	struct callout		watchdog_callout[2]; /* For command timout */
 +	TW_UINT32		watchdog_index;
 +
  #ifdef TW_OSL_DEBUG
  	struct tw_osli_q_stats	q_stats[TW_OSLI_Q_COUNT];/* queue statistics */
  #endif /* TW_OSL_DEBUG */
 
 Modified: stable/8/sys/dev/twa/tw_osl_cam.c
 ==============================================================================
 --- stable/8/sys/dev/twa/tw_osl_cam.c	Sun Sep 12 00:53:10 2010	(r212489)
 +++ stable/8/sys/dev/twa/tw_osl_cam.c	Sun Sep 12 06:19:35 2010	(r212490)
 @@ -55,7 +55,6 @@
  
  static TW_VOID	twa_action(struct cam_sim *sim, union ccb *ccb);
  static TW_VOID	twa_poll(struct cam_sim *sim);
 -static TW_VOID	twa_timeout(TW_VOID *arg);
  
  static TW_INT32	tw_osli_execute_scsi(struct tw_osli_req_context *req,
  	union ccb *ccb);
 @@ -81,7 +80,7 @@ tw_osli_cam_attach(struct twa_softc *sc)
  	/*
  	 * Create the device queue for our SIM.
  	 */
 -	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_REQUESTS)) == NULL) {
 +	if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_IOS)) == NULL) {
  		tw_osli_printf(sc, "error = %d",
  			TW_CL_SEVERITY_ERROR_STRING,
  			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 @@ -275,6 +274,7 @@ tw_osli_execute_scsi(struct tw_osli_req_
  					"I/O size too big",
  					csio->dxfer_len);
  				ccb_h->status = CAM_REQ_TOO_BIG;
 +				ccb_h->status &= ~CAM_SIM_QUEUED;
  				xpt_done(ccb);
  				return(1);
  			}
 @@ -290,6 +290,7 @@ tw_osli_execute_scsi(struct tw_osli_req_
  				0x2107,
  				"XPT_SCSI_IO: Got SGList");
  			ccb_h->status = CAM_REQ_INVALID;
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
  			xpt_done(ccb);
  			return(1);
  		}
 @@ -306,13 +307,20 @@ tw_osli_execute_scsi(struct tw_osli_req_
  		return(1);
  	}
  
 -	ccb_h->timeout_ch = timeout(twa_timeout, req,
 -		(ccb_h->timeout * hz) / 1000);
 +	req->deadline = tw_osl_get_local_time() + (ccb_h->timeout / 1000);
 +
 +
  	/*
  	 * twa_map_load_data_callback will fill in the SGL,
  	 * and submit the I/O.
  	 */
  	error = tw_osli_map_request(req);
 +	if ((error) && (req->flags & TW_OSLI_REQ_FLAGS_FAILED)) {
 +		req->deadline = 0;
 +		ccb_h->status = CAM_REQ_CMP_ERR;
 +		ccb_h->status &= ~CAM_SIM_QUEUED;
 +		xpt_done(ccb);
 +	}
  	return(error);
  }
  
 @@ -345,10 +353,20 @@ twa_action(struct cam_sim *sim, union cc
  			 * Freeze the simq to maintain ccb ordering.  The next
  			 * ccb that gets completed will unfreeze the simq.
  			 */
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
 +			ccb_h->status |= CAM_REQUEUE_REQ;
 +			xpt_done(ccb);
 +			break;
 +		}
 +
 +		if ((tw_cl_is_reset_needed(&(req->ctlr->ctlr_handle)))) {
 +			ccb_h->status &= ~CAM_SIM_QUEUED;
  			ccb_h->status |= CAM_REQUEUE_REQ;
  			xpt_done(ccb);
 +			tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
  			break;
  		}
 +
  		req->req_handle.osl_req_ctxt = req;
  		req->req_handle.is_io = TW_CL_TRUE;
  		req->orig_req = ccb;
 @@ -364,25 +382,14 @@ twa_action(struct cam_sim *sim, union cc
  		break;
  
  	case XPT_RESET_BUS:
 -		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
 +		tw_cl_create_event(&(sc->ctlr_handle), TW_CL_FALSE,
  			TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  			0x2108, 0x3, TW_CL_SEVERITY_INFO_STRING,
  			"Received Reset Bus request from CAM",
  			" ");
  
 -		mtx_unlock(sc->sim_lock);
 -		if (tw_cl_reset_ctlr(&sc->ctlr_handle)) {
 -			tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
 -				TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 -				0x2109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -				"Failed to reset bus",
 -				" ");
 -			ccb_h->status = CAM_REQ_CMP_ERR;
 -		}
 -		else
 -			ccb_h->status = CAM_REQ_CMP;
 -
 -		mtx_lock(sc->sim_lock);
 +		tw_cl_set_reset_needed(&(sc->ctlr_handle));
 +		ccb_h->status = CAM_REQ_CMP;
  		xpt_done(ccb);
  		break;
  
 @@ -450,6 +457,7 @@ twa_action(struct cam_sim *sim, union cc
                  path_inq->transport_version = 2;
                  path_inq->protocol = PROTO_SCSI;
                  path_inq->protocol_version = SCSI_REV_2;
 +                path_inq->maxio = TW_CL_MAX_IO_SIZE;
  		ccb_h->status = CAM_REQ_CMP;
  		xpt_done(ccb);
  		break;
 @@ -487,31 +495,6 @@ twa_poll(struct cam_sim *sim)
  
  
  /*
 - * Function name:	twa_timeout
 - * Description:		Driver entry point for being alerted on a request
 - *			timing out.
 - *
 - * Input:		arg	-- ptr to timed out request
 - * Output:		None
 - * Return value:	None
 - */
 -static TW_VOID
 -twa_timeout(TW_VOID *arg)
 -{
 -	struct tw_osli_req_context	*req =
 -		(struct tw_osli_req_context *)arg;
 -
 -	tw_cl_create_event(&(req->ctlr->ctlr_handle), TW_CL_TRUE,
 -		TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 -		0x210B, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 -		"Request timed out!",
 -		"request = %p", req);
 -	tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle));
 -}
 -
 -
 -
 -/*
   * Function name:	tw_osli_request_bus_scan
   * Description:		Requests CAM for a scan of the bus.
   *
 @@ -574,20 +557,39 @@ tw_osli_disallow_new_requests(struct twa
  
  
  /*
 - * Function name:	tw_osl_ctlr_busy
 - * Description:		CL calls this function on cmd queue full or otherwise,
 - *			when it is too busy to accept new requests.
 + * Function name:	tw_osl_timeout
 + * Description:		Call to timeout().
   *
 - * Input:		ctlr_handle	-- ptr to controller handle
 - *			req_handle	-- ptr to request handle sent by OSL.
 + * Input:		req_handle -- ptr to request handle sent by OSL.
   * Output:		None
   * Return value:	None
   */
  TW_VOID
 -tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
 
 *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
 _______________________________________________
 svn-src-all@freebsd.org mailing list
 http://lists.freebsd.org/mailman/listinfo/svn-src-all
 To unsubscribe, send any mail to "svn-src-all-unsubscribe@freebsd.org"
 
State-Changed-From-To: patched->closed 
State-Changed-By: delphij 
State-Changed-When: Thu Oct 14 22:30:32 UTC 2010 
State-Changed-Why:  
Close old PR: the MFC have been done on Sep 12. 

Thanks for your submission! 

http://www.freebsd.org/cgi/query-pr.cgi?pr=149968 

From: Sacha Muszlak <smuszlak@gmail.com>
To: bug-followup@FreeBSD.org, tom.couch@lsi.com
Cc:  
Subject: Re: kern/149968: [twa] [patch] Kernel panic with ZFS and twa version
 3.80.06.002
Date: Fri, 17 Jan 2014 12:28:30 +0100

 Hi,
 I seem to have the same issue as bug 149968 :  with twa0 driver and zfs
 on FreeNAS.
 
 Here the infos on the driver & controller used (from dmesg):
 
 3ware device driver for 9000 series storage controllers, version:
 3.80.06.003
  twa0: <3ware 9000 series Storage Controller> port 0x4000-0x40ff mem
 0xd8000000-0xd9ffffff,0xda300000-0xda300fff irq 16 at device 0.0 on pci8
  twa0: INFO: (0x15: 0x1300): Controller details:: Model 9690SA-4I, 128
 ports, Firmware FH9X 4.06.00.004, BIOS BE9X 4.05.00.015
 
 
 And here the system msg before freezing  (from the web interface console) :
 
 kernel: twa0: ERROR: (0x16: 0x1109) Missed firmware handshake after
 soft-reset : error = 30856
 kernel: twa0: ERROR: (0x16: 0x1105) Controller reset failed: error =
 30856; attempt 1
 
 at reboot the freeze is at the twa0 driver loading : after
  twa0: <3ware 9000 series Storage Controller> port 0x4000-0x40ff mem
 0xd8000000-0xd9ffffff,0xda300000-0xda300fff irq 16 at device 0.0 on pci8
 
 
 I am happy to investigate if given pointers where/what  to look at.
 
 Regards
 
 -- Sacha Muszlak

From: "Alexey Markov" <redrat@mail.ru>
To: <bug-followup@FreeBSD.org>
Cc:  
Subject: kern/149968: [twa] [patch] Kernel panic with ZFS and twa version 3.80.06.002
Date: Wed, 5 Feb 2014 13:42:55 +0400

 Hello!
 
 This bug is closed, open a new one if you need a help.
 
 -- 
 WBR, Alexey Markov.
>Unformatted:
