From nobody@FreeBSD.org  Mon Sep 13 06:45:36 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 9700A1065670
	for <freebsd-gnats-submit@FreeBSD.org>; Mon, 13 Sep 2010 06:45:36 +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 8644F8FC1F
	for <freebsd-gnats-submit@FreeBSD.org>; Mon, 13 Sep 2010 06:45:36 +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 o8D6jZaN032697
	for <freebsd-gnats-submit@FreeBSD.org>; Mon, 13 Sep 2010 06:45:35 GMT
	(envelope-from nobody@www.freebsd.org)
Received: (from nobody@localhost)
	by www.freebsd.org (8.14.3/8.14.3/Submit) id o8D6jZol032694;
	Mon, 13 Sep 2010 06:45:35 GMT
	(envelope-from nobody)
Message-Id: <201009130645.o8D6jZol032694@www.freebsd.org>
Date: Mon, 13 Sep 2010 06:45:35 GMT
From: Beezar Liu <beezarliu@yahoo.com.cn>
To: freebsd-gnats-submit@FreeBSD.org
Subject: e1000 receive queue handling problem
X-Send-Pr-Version: www-3.1
X-GNATS-Notify:

>Number:         150516
>Category:       kern
>Synopsis:       [em] e1000 receive queue handling problem
>Confidential:   no
>Severity:       non-critical
>Priority:       medium
>Responsible:    jfv
>State:          open
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          sw-bug
>Submitter-Id:   current-users
>Arrival-Date:   Mon Sep 13 06:50:01 UTC 2010
>Closed-Date:    
>Last-Modified:  Sat Feb 26 07:20:09 UTC 2011
>Originator:     Beezar Liu
>Release:        FreeBSD8.1
>Organization:
>Environment:
>Description:
I found em's receiving queue handling will have the following problems if system mbuf is used up.
1. NIC will hang because receive ring's tail pointer will not be updated (in em_rxeof).
2. "ifconfig up/down" may cause system panic because em_setup_receive_ring will free already-freed mbufs.
 
So I made some changes:
1. NIC's recieve ring's head/tail pointer is updated according to rxr's next_to_check/next_to_refresh.
    So, on the position of next_to_refresh, no need to fill free mbuf because datasheet says
        "When the head pointer(s) is equal to the tail pointer(s), the queue(s) is empty.
         Hardware stops storing packets in system memory until software advances the tail
         pointer(s), making more receive buffers available." 
    And (next_to_refresh + 1) % num_rx_desc == next_to_check means ring queue is full.
2. no need to reallocate the mbufs on receive queue when em re-initialize.
3. The mbufs on the queue are also freed according to these two indexs.
4. If ring queue is empty, em_refresh_mbufs is also called even if it doesn't handle any packet
>How-To-Repeat:

>Fix:


Patch attached with submission follows:

Index: if_em.c
===================================================================
--- if_em.c	(revision 212405)
+++ if_em.c	(working copy)
@@ -3671,11 +3671,13 @@
 	bus_dma_segment_t	segs[1];
 	bus_dmamap_t		map;
 	struct em_buffer	*rxbuf;
-	int			i, error, nsegs, cleaned;
+	int			i, j, error, nsegs, cleaned;
 
-	i = rxr->next_to_refresh;
+	i = j = rxr->next_to_refresh;
 	cleaned = -1;
-	while (i != limit) {
+	if (++j == adapter->num_rx_desc)
+		j = 0;
+	while (j != limit) {
 		m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
 		if (m == NULL)
 			goto update;
@@ -3711,9 +3713,10 @@
 		rxr->rx_base[i].buffer_addr = htole64(segs[0].ds_addr);
 
 		cleaned = i;
+		i = j;
 		/* Calculate next index */
-		if (++i == adapter->num_rx_desc)
-			i = 0;
+		if (++j == adapter->num_rx_desc)
+			j = 0;
 		/* This is the work marker for refresh */
 		rxr->next_to_refresh = i;
 	}
@@ -3722,7 +3725,7 @@
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	if (cleaned != -1) /* Update tail index */
 		E1000_WRITE_REG(&adapter->hw,
-		    E1000_RDT(rxr->me), cleaned);
+		    E1000_RDT(rxr->me), rxr->next_to_refresh);
 
 	return;
 }
@@ -3809,32 +3812,22 @@
 	struct	adapter 	*adapter = rxr->adapter;
 	struct em_buffer	*rxbuf;
 	bus_dma_segment_t	seg[1];
-	int			rsize, nsegs, error;
+	int			i, j, nsegs, error;
 
 
 	/* Clear the ring contents */
 	EM_RX_LOCK(rxr);
-	rsize = roundup2(adapter->num_rx_desc *
-	    sizeof(struct e1000_rx_desc), EM_DBA_ALIGN);
-	bzero((void *)rxr->rx_base, rsize);
-
-	/*
-	** Free current RX buffer structs and their mbufs
-	*/
-	for (int i = 0; i < adapter->num_rx_desc; i++) {
-		rxbuf = &rxr->rx_buffers[i];
-		if (rxbuf->m_head != NULL) {
-			bus_dmamap_sync(rxr->rxtag, rxbuf->map,
-			    BUS_DMASYNC_POSTREAD);
-			bus_dmamap_unload(rxr->rxtag, rxbuf->map);
-			m_freem(rxbuf->m_head);
-		}
+	for (i = 0; i < adapter->num_rx_desc; i++) {
+		struct e1000_rx_desc* cur;
+		cur = &rxr->rx_base[i];
+		cur->status = 0;
 	}
 
-	/* Now replenish the mbufs */
-	for (int j = 0; j != adapter->num_rx_desc; ++j) {
-
-		rxbuf = &rxr->rx_buffers[j];
+	i = j = rxr->next_to_refresh;
+	if (++j == adapter->num_rx_desc)
+		j = 0;
+	while(j != rxr->next_to_check) {
+		rxbuf = &rxr->rx_buffers[i];
 		rxbuf->m_head = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
 		if (rxbuf->m_head == NULL)
 			panic("RX ring hdr initialization failed!\n");
@@ -3852,13 +3845,14 @@
 		    rxbuf->map, BUS_DMASYNC_PREREAD);
 
 		/* Update descriptor */
-		rxr->rx_base[j].buffer_addr = htole64(seg[0].ds_addr);
+		rxr->rx_base[i].buffer_addr = htole64(seg[0].ds_addr);
+		i = j;
+		if (++j == adapter->num_rx_desc)
+			j = 0;
 	}
 
-
 	/* Setup our descriptor indices */
-	rxr->next_to_check = 0;
-	rxr->next_to_refresh = 0;
+	rxr->next_to_refresh = i;
 
 	bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
@@ -3938,6 +3932,7 @@
 {
 	struct adapter		*adapter = rxr->adapter;
 	struct em_buffer	*rxbuf = NULL;
+	int 			i;
 
 	INIT_DEBUGOUT("free_receive_buffers: begin");
 
@@ -3947,7 +3942,8 @@
 	}
 
 	if (rxr->rx_buffers != NULL) {
-		for (int i = 0; i < adapter->num_rx_desc; i++) {
+		i = rxr->next_to_check;
+		while(i != rxr->next_to_refresh) {
 			rxbuf = &rxr->rx_buffers[i];
 			if (rxbuf->map != NULL) {
 				bus_dmamap_sync(rxr->rxtag, rxbuf->map,
@@ -3959,6 +3955,8 @@
 				m_freem(rxbuf->m_head);
 				rxbuf->m_head = NULL;
 			}
+			if (++i == adapter->num_rx_desc)
+				i = 0;			
 		}
 		free(rxr->rx_buffers, M_DEVBUF);
 		rxr->rx_buffers = NULL;
@@ -4044,8 +4042,8 @@
 		E1000_WRITE_REG(hw, E1000_RDBAH(i), (u32)(bus_addr >> 32));
 		E1000_WRITE_REG(hw, E1000_RDBAL(i), (u32)bus_addr);
 		/* Setup the Head and Tail Descriptor Pointers */
-		E1000_WRITE_REG(hw, E1000_RDH(i), 0);
-		E1000_WRITE_REG(hw, E1000_RDT(i), adapter->num_rx_desc - 1);
+		E1000_WRITE_REG(hw, E1000_RDH(i), rxr->next_to_check);
+		E1000_WRITE_REG(hw, E1000_RDT(i), rxr->next_to_refresh);
 	}
 
 	/* Setup the Receive Control Register */
@@ -4206,7 +4204,7 @@
 	}
 
 	/* Catch any remaining refresh work */
-	if (processed != 0) {
+	if (processed != 0 || i == rxr->next_to_refresh) {
 		em_refresh_mbufs(rxr, i);
 		processed = 0;
 	}


>Release-Note:
>Audit-Trail:
Responsible-Changed-From-To: freebsd-bugs->jfv 
Responsible-Changed-By: az 
Responsible-Changed-When: Sun Sep 19 19:11:15 UTC 2010 
Responsible-Changed-Why:  
Jack is em(4) maintainer 

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

From: Arnaud Lacombe <lacombar@gmail.com>
To: bug-followup@FreeBSD.org, beezarliu@yahoo.com.cn
Cc:  
Subject: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Mon, 21 Feb 2011 21:38:15 -0500

 After r215808, the last hunk no longer apply. I'll give it a try without it.

From: Arnaud Lacombe <lacombar@gmail.com>
To: bug-followup@FreeBSD.org, beezarliu@yahoo.com.cn
Cc:  
Subject: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Tue, 22 Feb 2011 14:08:52 -0500

 For the record, I can still quickly hang an em(4) with the attached patch.

From: "beezarliu" <beezarliu@yahoo.com.cn>
To: "Arnaud Lacombe" <lacombar@gmail.com>,
 "bug-followup@FreeBSD.org" <bug-followup@FreeBSD.org>
Cc: "Jack Vogel" <jfvogel@gmail.com>
Subject: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Wed, 23 Feb 2011 12:18:16 +0800

 This is a multi-part message in MIME format.
 
 --=====001_Dragon477376006734_=====
 Content-Type: text/plain;
 	charset="gb2312"
 Content-Transfer-Encoding: 7bit
 
 On 2011-02-23 03:08:53, Arnaud Lacombe wrote:
 >For the record, I can still quickly hang an em(4) with the attached patch.
 
 That patch is not complete. 
 I sent this new one to Jack, I think he is verifying if it can work.  
 If you can't wait, try the new one. It's based on stable/8.
 
 Thanks
 Beezar
 --=====001_Dragon477376006734_=====
 Content-Type: application/octet-stream;
 	name="e1000.patch"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment;
 	filename="e1000.patch"
 
 SW5kZXg6IGlmX2lnYi5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGlmX2lnYi5jCShyZXZpc2lvbiAyMTg3NjAp
 CisrKyBpZl9pZ2IuYwkod29ya2luZyBjb3B5KQpAQCAtMTkzMCw2ICsxOTMwLDggQEAKIAlzdHJ1
 Y3QgYWRhcHRlcgkJKmFkYXB0ZXIgPSBhcmc7CiAJZGV2aWNlX3QJCWRldiA9IGFkYXB0ZXItPmRl
 djsKIAlzdHJ1Y3QgdHhfcmluZwkJKnR4ciA9IGFkYXB0ZXItPnR4X3JpbmdzOworCXN0cnVjdCBy
 eF9yaW5nCQkqcnhyID0gYWRhcHRlci0+cnhfcmluZ3M7CisJc3RydWN0IGlnYl9xdWV1ZSAJKnF1
 ZSA9IGFkYXB0ZXItPnF1ZXVlczsKIAogCiAJSUdCX0NPUkVfTE9DS19BU1NFUlQoYWRhcHRlcik7
 CkBAIC0xOTM3LDYgKzE5MzksMTMgQEAKIAlpZ2JfdXBkYXRlX2xpbmtfc3RhdHVzKGFkYXB0ZXIp
 OwogCWlnYl91cGRhdGVfc3RhdHNfY291bnRlcnMoYWRhcHRlcik7CiAKKwkvKiB0cmlnZ2VyIHRx
 IHRvIHJlZmlsbCByeCByaW5nIHF1ZXVlIGlmIGl0IGlzIGVtcHR5ICovCisJZm9yIChpbnQgaSA9
 IDA7IGkgPCBhZGFwdGVyLT5udW1fcXVldWVzOyBpKyssIHJ4cisrLCBxdWUrKykgeworCQlpZiAo
 cnhyLT5uZXh0X3RvX2NoZWNrID09IHJ4ci0+bmV4dF90b19yZWZyZXNoKSB7CisJCQl0YXNrcXVl
 dWVfZW5xdWV1ZShxdWUtPnRxLCAmcXVlLT5xdWVfdGFzayk7CisJCX0KKwl9CisKIAkvKiAKIAkq
 KiBJZiBmbG93IGNvbnRyb2wgaGFzIHBhdXNlZCB1cyBzaW5jZSBsYXN0IGNoZWNraW5nCiAJKiog
 aXQgaW52YWxpZGF0ZXMgdGhlIHdhdGNoZG9nIHRpbWluZywgc28gZG9udCBydW4gaXQuCkBAIC0z
 NjE3LDExICszNjI2LDE0IEBACiAJYnVzX2RtYV9zZWdtZW50X3QJcHNlZ1sxXTsKIAlzdHJ1Y3Qg
 aWdiX3J4X2J1ZgkqcnhidWY7CiAJc3RydWN0IG1idWYJCSptaCwgKm1wOwotCWludAkJCWksIG5z
 ZWdzLCBlcnJvciwgY2xlYW5lZDsKKwlpbnQJCQlpLCBqLCBuc2VncywgZXJyb3IsIGNsZWFuZWQ7
 CiAKLQlpID0gcnhyLT5uZXh0X3RvX3JlZnJlc2g7CisJaSA9IGogPSByeHItPm5leHRfdG9fcmVm
 cmVzaDsKIAljbGVhbmVkID0gLTE7IC8qIFNpZ25pZnkgbm8gY29tcGxldGlvbnMgKi8KLQl3aGls
 ZSAoaSAhPSBsaW1pdCkgeworCWlmICgrK2ogPT0gYWRhcHRlci0+bnVtX3J4X2Rlc2MpCisJCWog
 PSAwOworCisJd2hpbGUgKGogIT0gbGltaXQpIHsKIAkJcnhidWYgPSAmcnhyLT5yeF9idWZmZXJz
 W2ldOwogCQkvKiBObyBoZHIgbWJ1ZiB1c2VkIHdpdGggaGVhZGVyIHNwbGl0IG9mZiAqLwogCQlp
 ZiAocnhyLT5oZHJfc3BsaXQgPT0gRkFMU0UpCkBAIC0zNjc5LDE1ICszNjkxLDE2IEBACiAKIAkJ
 Y2xlYW5lZCA9IGk7CiAJCS8qIENhbGN1bGF0ZSBuZXh0IGluZGV4ICovCi0JCWlmICgrK2kgPT0g
 YWRhcHRlci0+bnVtX3J4X2Rlc2MpCi0JCQlpID0gMDsKKwkJaSA9IGo7CisJCWlmICgrK2ogPT0g
 YWRhcHRlci0+bnVtX3J4X2Rlc2MpCisJCQlqID0gMDsKIAkJLyogVGhpcyBpcyB0aGUgd29yayBt
 YXJrZXIgZm9yIHJlZnJlc2ggKi8KIAkJcnhyLT5uZXh0X3RvX3JlZnJlc2ggPSBpOwogCX0KIHVw
 ZGF0ZToKIAlpZiAoY2xlYW5lZCAhPSAtMSkgLyogSWYgd2UgcmVmcmVzaGVkIHNvbWUsIGJ1bXAg
 dGFpbCAqLwogCQlFMTAwMF9XUklURV9SRUcoJmFkYXB0ZXItPmh3LAotCQkgICAgRTEwMDBfUkRU
 KHJ4ci0+bWUpLCBjbGVhbmVkKTsKKwkJICAgIEUxMDAwX1JEVChyeHItPm1lKSwgcnhyLT5uZXh0
 X3RvX3JlZnJlc2gpOwogCXJldHVybjsKIH0KIApAQCAtMzc4NCw3ICszNzk3LDggQEAKIAlpbnQg
 aTsKIAogCWFkYXB0ZXIgPSByeHItPmFkYXB0ZXI7Ci0JZm9yIChpID0gMDsgaSA8IGFkYXB0ZXIt
 Pm51bV9yeF9kZXNjOyBpKyspIHsKKwlpID0gcnhyLT5uZXh0X3RvX2NoZWNrOworCXdoaWxlKGkg
 IT0gcnhyLT5uZXh0X3RvX3JlZnJlc2gpIHsKIAkJcnhidWYgPSAmcnhyLT5yeF9idWZmZXJzW2ld
 OwogCQlpZiAocnhidWYtPm1faGVhZCAhPSBOVUxMKSB7CiAJCQlidXNfZG1hbWFwX3N5bmMocnhy
 LT5odGFnLCByeGJ1Zi0+aG1hcCwKQEAgLTM4MDIsNyArMzgxNiwxMiBAQAogCQl9CiAJCXJ4YnVm
 LT5tX2hlYWQgPSBOVUxMOwogCQlyeGJ1Zi0+bV9wYWNrID0gTlVMTDsKKworCQlpZiAoKytpID09
 IGFkYXB0ZXItPm51bV9yeF9kZXNjKQorCQkJaSA9IDA7CiAJfQorCXJ4ci0+bmV4dF90b19jaGVj
 ayA9IDA7CisJcnhyLT5uZXh0X3RvX3JlZnJlc2ggPSAwOwogfQogCiAKQEAgLTM4MjAsNyArMzgz
 OSw3IEBACiAJc3RydWN0IGlnYl9yeF9idWYJKnJ4YnVmOwogCWJ1c19kbWFfc2VnbWVudF90CXBz
 ZWdbMV0sIGhzZWdbMV07CiAJc3RydWN0IGxyb19jdHJsCQkqbHJvID0gJnJ4ci0+bHJvOwotCWlu
 dAkJCXJzaXplLCBuc2VncywgZXJyb3IgPSAwOworCWludAkJCWksIGosIG5zZWdzLCBlcnJvciA9
 IDA7CiAKIAlhZGFwdGVyID0gcnhyLT5hZGFwdGVyOwogCWRldiA9IGFkYXB0ZXItPmRldjsKQEAg
 LTM4MjgsMzAgKzM4NDcsMzQgQEAKIAogCS8qIENsZWFyIHRoZSByaW5nIGNvbnRlbnRzICovCiAJ
 SUdCX1JYX0xPQ0socnhyKTsKLQlyc2l6ZSA9IHJvdW5kdXAyKGFkYXB0ZXItPm51bV9yeF9kZXNj
 ICoKLQkgICAgc2l6ZW9mKHVuaW9uIGUxMDAwX2Fkdl9yeF9kZXNjKSwgSUdCX0RCQV9BTElHTik7
 Ci0JYnplcm8oKHZvaWQgKilyeHItPnJ4X2Jhc2UsIHJzaXplKTsKIAotCS8qCi0JKiogRnJlZSBj
 dXJyZW50IFJYIGJ1ZmZlciBzdHJ1Y3R1cmVzIGFuZCB0aGVpciBtYnVmcwotCSovCi0JaWdiX2Zy
 ZWVfcmVjZWl2ZV9yaW5nKHJ4cik7CisJLyogY2xlYXIgdXAgdGhlIHN0YXR1cyBpbiBkZXNjcmlw
 dG9yICovCisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPm51bV9yeF9kZXNjOyBpKyspIHsKKwkJ
 dW5pb24gZTEwMDBfYWR2X3J4X2Rlc2MqIGN1cjsKKwkJY3VyID0gJnJ4ci0+cnhfYmFzZVtpXTsK
 KwkJY3VyLT53Yi51cHBlci5zdGF0dXNfZXJyb3IgPSAwOworICAgICAgICB9CiAKIAkvKiBDb25m
 aWd1cmUgZm9yIGhlYWRlciBzcGxpdD8gKi8KIAlpZiAoaWdiX2hlYWRlcl9zcGxpdCkKIAkJcnhy
 LT5oZHJfc3BsaXQgPSBUUlVFOwogCiAgICAgICAgIC8qIE5vdyByZXBsZW5pc2ggdGhlIHJpbmcg
 bWJ1ZnMgKi8KLQlmb3IgKGludCBqID0gMDsgaiA8IGFkYXB0ZXItPm51bV9yeF9kZXNjOyArK2op
 IHsKKwlpID0gaiA9IHJ4ci0+bmV4dF90b19yZWZyZXNoOworCWlmICgrK2ogPT0gYWRhcHRlci0+
 bnVtX3J4X2Rlc2MpCisJCWogPSAwOworCisJd2hpbGUoaiAhPSByeHItPm5leHRfdG9fY2hlY2sp
 IHsKIAkJc3RydWN0IG1idWYJKm1oLCAqbXA7CiAKLQkJcnhidWYgPSAmcnhyLT5yeF9idWZmZXJz
 W2pdOworCQlyeGJ1ZiA9ICZyeHItPnJ4X2J1ZmZlcnNbaV07CiAJCWlmIChyeHItPmhkcl9zcGxp
 dCA9PSBGQUxTRSkKIAkJCWdvdG8gc2tpcF9oZWFkOwogCiAJCS8qIEZpcnN0IHRoZSBoZWFkZXIg
 Ki8KIAkJcnhidWYtPm1faGVhZCA9IG1fZ2V0aGRyKE1fRE9OVFdBSVQsIE1UX0RBVEEpOwogCQlp
 ZiAocnhidWYtPm1faGVhZCA9PSBOVUxMKSB7CisJCQlyeHItPm5leHRfdG9fcmVmcmVzaCA9IGk7
 CiAJCQllcnJvciA9IEVOT0JVRlM7CiAgICAgICAgICAgICAgICAgICAgICAgICBnb3RvIGZhaWw7
 CiAJCX0KQEAgLTM4NjMsMTggKzM4ODYsMjEgQEAKIAkJZXJyb3IgPSBidXNfZG1hbWFwX2xvYWRf
 bWJ1Zl9zZyhyeHItPmh0YWcsCiAJCSAgICByeGJ1Zi0+aG1hcCwgcnhidWYtPm1faGVhZCwgaHNl
 ZywKIAkJICAgICZuc2VncywgQlVTX0RNQV9OT1dBSVQpOwotCQlpZiAoZXJyb3IgIT0gMCkgLyog
 Tm90aGluZyBlbGVnYW50IHRvIGRvIGhlcmUgKi8KKwkJaWYgKGVycm9yICE9IDApIHsgLyogTm90
 aGluZyBlbGVnYW50IHRvIGRvIGhlcmUgKi8KKwkJCXJ4ci0+bmV4dF90b19yZWZyZXNoID0gaTsK
 ICAgICAgICAgICAgICAgICAgICAgICAgIGdvdG8gZmFpbDsKKwkJfQogCQlidXNfZG1hbWFwX3N5
 bmMocnhyLT5odGFnLAogCQkgICAgcnhidWYtPmhtYXAsIEJVU19ETUFTWU5DX1BSRVJFQUQpOwog
 CQkvKiBVcGRhdGUgZGVzY3JpcHRvciAqLwotCQlyeHItPnJ4X2Jhc2Vbal0ucmVhZC5oZHJfYWRk
 ciA9IGh0b2xlNjQoaHNlZ1swXS5kc19hZGRyKTsKKwkJcnhyLT5yeF9iYXNlW2ldLnJlYWQuaGRy
 X2FkZHIgPSBodG9sZTY0KGhzZWdbMF0uZHNfYWRkcik7CiAKIHNraXBfaGVhZDoKIAkJLyogTm93
 IHRoZSBwYXlsb2FkIGNsdXN0ZXIgKi8KIAkJcnhidWYtPm1fcGFjayA9IG1fZ2V0amNsKE1fRE9O
 VFdBSVQsIE1UX0RBVEEsCiAJCSAgICBNX1BLVEhEUiwgYWRhcHRlci0+cnhfbWJ1Zl9zeik7CiAJ
 CWlmIChyeGJ1Zi0+bV9wYWNrID09IE5VTEwpIHsKKwkJCXJ4ci0+bmV4dF90b19yZWZyZXNoID0g
 aTsKIAkJCWVycm9yID0gRU5PQlVGUzsKICAgICAgICAgICAgICAgICAgICAgICAgIGdvdG8gZmFp
 bDsKIAkJfQpAQCAtMzg4NCwxNyArMzkxMCwyMiBAQAogCQllcnJvciA9IGJ1c19kbWFtYXBfbG9h
 ZF9tYnVmX3NnKHJ4ci0+cHRhZywKIAkJICAgIHJ4YnVmLT5wbWFwLCBtcCwgcHNlZywKIAkJICAg
 ICZuc2VncywgQlVTX0RNQV9OT1dBSVQpOwotCQlpZiAoZXJyb3IgIT0gMCkKKwkJaWYgKGVycm9y
 ICE9IDApIHsKKwkJCXJ4ci0+bmV4dF90b19yZWZyZXNoID0gaTsKICAgICAgICAgICAgICAgICAg
 ICAgICAgIGdvdG8gZmFpbDsKKwkJfQogCQlidXNfZG1hbWFwX3N5bmMocnhyLT5wdGFnLAogCQkg
 ICAgcnhidWYtPnBtYXAsIEJVU19ETUFTWU5DX1BSRVJFQUQpOwogCQkvKiBVcGRhdGUgZGVzY3Jp
 cHRvciAqLwotCQlyeHItPnJ4X2Jhc2Vbal0ucmVhZC5wa3RfYWRkciA9IGh0b2xlNjQocHNlZ1sw
 XS5kc19hZGRyKTsKKwkJcnhyLT5yeF9iYXNlW2ldLnJlYWQucGt0X2FkZHIgPSBodG9sZTY0KHBz
 ZWdbMF0uZHNfYWRkcik7CisKKwkJaSA9IGo7CisJCWlmICgrK2ogPT0gYWRhcHRlci0+bnVtX3J4
 X2Rlc2MpCisJCQlqID0gMDsKICAgICAgICAgfQogCiAJLyogU2V0dXAgb3VyIGRlc2NyaXB0b3Ig
 aW5kaWNlcyAqLwotCXJ4ci0+bmV4dF90b19jaGVjayA9IDA7Ci0JcnhyLT5uZXh0X3RvX3JlZnJl
 c2ggPSAwOworCXJ4ci0+bmV4dF90b19yZWZyZXNoID0gaTsKIAlyeHItPmxyb19lbmFibGVkID0g
 RkFMU0U7CiAJcnhyLT5yeF9zcGxpdF9wYWNrZXRzID0gMDsKIAlyeHItPnJ4X2J5dGVzID0gMDsK
 QEAgLTQxMjcsOSArNDE1OCw4IEBACiAJICogICAtIG5lZWRzIHRvIGJlIGFmdGVyIGVuYWJsZQog
 CSAqLwogCWZvciAoaW50IGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3F1ZXVlczsgaSsrKSB7Ci0J
 CUUxMDAwX1dSSVRFX1JFRyhodywgRTEwMDBfUkRIKGkpLCAwKTsKLQkJRTEwMDBfV1JJVEVfUkVH
 KGh3LCBFMTAwMF9SRFQoaSksCi0JCSAgICAgYWRhcHRlci0+bnVtX3J4X2Rlc2MgLSAxKTsKKwkJ
 RTEwMDBfV1JJVEVfUkVHKGh3LCBFMTAwMF9SREgoaSksIHJ4ci0+bmV4dF90b19jaGVjayk7CisJ
 CUUxMDAwX1dSSVRFX1JFRyhodywgRTEwMDBfUkRUKGkpLCByeHItPm5leHRfdG9fcmVmcmVzaCk7
 CiAJfQogCXJldHVybjsKIH0KQEAgLTQ0NjEsMTAgKzQ0OTEsOCBAQAogCX0KIAogCS8qIENhdGNo
 IGFueSByZW1haW5kZXJzICovCi0JaWYgKHByb2Nlc3NlZCAhPSAwKSB7CisJaWYgKHByb2Nlc3Nl
 ZCAhPSAwIHx8IGkgPT0gcnhyLT5uZXh0X3RvX3JlZnJlc2gpCiAJCWlnYl9yZWZyZXNoX21idWZz
 KHJ4ciwgaSk7Ci0JCXByb2Nlc3NlZCA9IDA7Ci0JfQogCiAJcnhyLT5uZXh0X3RvX2NoZWNrID0g
 aTsKIApJbmRleDogaWZfZW0uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBpZl9lbS5jCShyZXZpc2lvbiAyMTg3
 NjApCisrKyBpZl9lbS5jCSh3b3JraW5nIGNvcHkpCkBAIC0yMTc5LDYgKzIxNzksNyBAQAogCXN0
 cnVjdCBhZGFwdGVyCSphZGFwdGVyID0gYXJnOwogCXN0cnVjdCBpZm5ldAkqaWZwID0gYWRhcHRl
 ci0+aWZwOwogCXN0cnVjdCB0eF9yaW5nCSp0eHIgPSBhZGFwdGVyLT50eF9yaW5nczsKKwlzdHJ1
 Y3QgcnhfcmluZwkqcnhyID0gYWRhcHRlci0+cnhfcmluZ3M7CiAKIAlFTV9DT1JFX0xPQ0tfQVNT
 RVJUKGFkYXB0ZXIpOwogCkBAIC0yMTkwLDYgKzIxOTEsMTMgQEAKIAkgICAgZTEwMDBfZ2V0X2xh
 YV9zdGF0ZV84MjU3MSgmYWRhcHRlci0+aHcpKQogCQllMTAwMF9yYXJfc2V0KCZhZGFwdGVyLT5o
 dywgYWRhcHRlci0+aHcubWFjLmFkZHIsIDApOwogCisJLyogdHJpZ2dlciB0cSB0byByZWZpbGwg
 cnggcmluZyBxdWV1ZSBpZiBpdCBpcyBlbXB0eSAqLworCWZvciAoaW50IGkgPSAwOyBpIDwgYWRh
 cHRlci0+bnVtX3F1ZXVlczsgaSsrLCByeHIrKykgeworCQlpZiAocnhyLT5uZXh0X3RvX2NoZWNr
 ID09IHJ4ci0+bmV4dF90b19yZWZyZXNoKSB7CisJCQl0YXNrcXVldWVfZW5xdWV1ZShyeHItPnRx
 LCAmcnhyLT5yeF90YXNrKTsKKwkJfQorCX0KKwogCS8qIAogCSoqIERvbid0IGRvIFRYIHdhdGNo
 ZG9nIGNoZWNrIGlmIHdlJ3ZlIGJlZW4gcGF1c2VkCiAJKi8KQEAgLTM3NTgsMTEgKzM3NjYsMTQg
 QEAKIAlzdHJ1Y3QgbWJ1ZgkJKm07CiAJYnVzX2RtYV9zZWdtZW50X3QJc2Vnc1sxXTsKIAlzdHJ1
 Y3QgZW1fYnVmZmVyCSpyeGJ1ZjsKLQlpbnQJCQlpLCBlcnJvciwgbnNlZ3MsIGNsZWFuZWQ7CisJ
 aW50CQkJaSwgaiwgZXJyb3IsIG5zZWdzLCBjbGVhbmVkOwogCi0JaSA9IHJ4ci0+bmV4dF90b19y
 ZWZyZXNoOworCWkgPSBqID0gcnhyLT5uZXh0X3RvX3JlZnJlc2g7CiAJY2xlYW5lZCA9IC0xOwot
 CXdoaWxlIChpICE9IGxpbWl0KSB7CisJaWYgKCsraiA9PSBhZGFwdGVyLT5udW1fcnhfZGVzYykK
 KwkJaiA9IDA7CisKKwl3aGlsZSAoaiAhPSBsaW1pdCkgewogCQlyeGJ1ZiA9ICZyeHItPnJ4X2J1
 ZmZlcnNbaV07CiAJCWlmIChyeGJ1Zi0+bV9oZWFkID09IE5VTEwpIHsKIAkJCW0gPSBtX2dldGpj
 bChNX0RPTlRXQUlULCBNVF9EQVRBLApAQCAtMzc5OSw4ICszODEwLDkgQEAKIAogCQljbGVhbmVk
 ID0gaTsKIAkJLyogQ2FsY3VsYXRlIG5leHQgaW5kZXggKi8KLQkJaWYgKCsraSA9PSBhZGFwdGVy
 LT5udW1fcnhfZGVzYykKLQkJCWkgPSAwOworCQlpID0gajsKKwkJaWYgKCsraiA9PSBhZGFwdGVy
 LT5udW1fcnhfZGVzYykKKwkJCWogPSAwOwogCQlyeHItPm5leHRfdG9fcmVmcmVzaCA9IGk7CiAJ
 fQogdXBkYXRlOgpAQCAtMzgxMCw3ICszODIyLDcgQEAKIAkqLwogCWlmIChjbGVhbmVkICE9IC0x
 KSAvKiBVcGRhdGUgdGFpbCBpbmRleCAqLwogCQlFMTAwMF9XUklURV9SRUcoJmFkYXB0ZXItPmh3
 LAotCQkgICAgRTEwMDBfUkRUKHJ4ci0+bWUpLCBjbGVhbmVkKTsKKwkJICAgIEUxMDAwX1JEVChy
 eHItPm1lKSwgcnhyLT5uZXh0X3RvX3JlZnJlc2gpOwogCiAJcmV0dXJuOwogfQpAQCAtMzg4OCwz
 NiArMzkwMCwzMiBAQAogCXN0cnVjdAlhZGFwdGVyIAkqYWRhcHRlciA9IHJ4ci0+YWRhcHRlcjsK
 IAlzdHJ1Y3QgZW1fYnVmZmVyCSpyeGJ1ZjsKIAlidXNfZG1hX3NlZ21lbnRfdAlzZWdbMV07Ci0J
 aW50CQkJcnNpemUsIG5zZWdzLCBlcnJvcjsKKwlpbnQJCQlpLCBqLCBuc2VncywgZXJyb3I7CiAK
 IAogCS8qIENsZWFyIHRoZSByaW5nIGNvbnRlbnRzICovCiAJRU1fUlhfTE9DSyhyeHIpOwotCXJz
 aXplID0gcm91bmR1cDIoYWRhcHRlci0+bnVtX3J4X2Rlc2MgKgotCSAgICBzaXplb2Yoc3RydWN0
 IGUxMDAwX3J4X2Rlc2MpLCBFTV9EQkFfQUxJR04pOwotCWJ6ZXJvKCh2b2lkICopcnhyLT5yeF9i
 YXNlLCByc2l6ZSk7CiAKLQkvKgotCSoqIEZyZWUgY3VycmVudCBSWCBidWZmZXIgc3RydWN0cyBh
 bmQgdGhlaXIgbWJ1ZnMKLQkqLwotCWZvciAoaW50IGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3J4
 X2Rlc2M7IGkrKykgewotCQlyeGJ1ZiA9ICZyeHItPnJ4X2J1ZmZlcnNbaV07Ci0JCWlmIChyeGJ1
 Zi0+bV9oZWFkICE9IE5VTEwpIHsKLQkJCWJ1c19kbWFtYXBfc3luYyhyeHItPnJ4dGFnLCByeGJ1
 Zi0+bWFwLAotCQkJICAgIEJVU19ETUFTWU5DX1BPU1RSRUFEKTsKLQkJCWJ1c19kbWFtYXBfdW5s
 b2FkKHJ4ci0+cnh0YWcsIHJ4YnVmLT5tYXApOwotCQkJbV9mcmVlbShyeGJ1Zi0+bV9oZWFkKTsK
 LQkJfQorCS8qIGNsZWFyIHVwIHRoZSBzdGF0dXMgaW4gZGVzY3JpcHRvciAqLworCWZvciAoaSA9
 IDA7IGkgPCBhZGFwdGVyLT5udW1fcnhfZGVzYzsgaSsrKSB7CisJCXN0cnVjdCBlMTAwMF9yeF9k
 ZXNjKiBjdXI7CisJCWN1ciA9ICZyeHItPnJ4X2Jhc2VbaV07CisJCWN1ci0+c3RhdHVzID0gMDsK
 IAl9CiAKIAkvKiBOb3cgcmVwbGVuaXNoIHRoZSBtYnVmcyAqLwotCWZvciAoaW50IGogPSAwOyBq
 ICE9IGFkYXB0ZXItPm51bV9yeF9kZXNjOyArK2opIHsKKwlpID0gaiA9IHJ4ci0+bmV4dF90b19y
 ZWZyZXNoOworCWlmICgrK2ogPT0gYWRhcHRlci0+bnVtX3J4X2Rlc2MpCisJCWogPSAwOwogCi0J
 CXJ4YnVmID0gJnJ4ci0+cnhfYnVmZmVyc1tqXTsKKwl3aGlsZShqICE9IHJ4ci0+bmV4dF90b19j
 aGVjaykgeworCQlyeGJ1ZiA9ICZyeHItPnJ4X2J1ZmZlcnNbaV07CiAJCXJ4YnVmLT5tX2hlYWQg
 PSBtX2dldGpjbChNX0RPTlRXQUlULCBNVF9EQVRBLAogCQkgICAgTV9QS1RIRFIsIGFkYXB0ZXIt
 PnJ4X21idWZfc3opOwotCQlpZiAocnhidWYtPm1faGVhZCA9PSBOVUxMKQotCQkJcmV0dXJuIChF
 Tk9CVUZTKTsKKwkJaWYgKHJ4YnVmLT5tX2hlYWQgPT0gTlVMTCkgeworCQkJZXJyb3IgPSBFTk9C
 VUZTOworCQkJZ290byBmYWlsOworCQl9CiAJCXJ4YnVmLT5tX2hlYWQtPm1fbGVuID0gYWRhcHRl
 ci0+cnhfbWJ1Zl9zejsKIAkJcnhidWYtPm1faGVhZC0+bV9mbGFncyAmPSB+TV9IQVNGQ1M7IC8q
 IHdlIHN0cmlwIGl0ICovCiAJCXJ4YnVmLT5tX2hlYWQtPm1fcGt0aGRyLmxlbiA9IGFkYXB0ZXIt
 PnJ4X21idWZfc3o7CkBAIC0zOTI5LDI1ICszOTM3LDI3IEBACiAJCWlmIChlcnJvciAhPSAwKSB7
 CiAJCQltX2ZyZWVtKHJ4YnVmLT5tX2hlYWQpOwogCQkJcnhidWYtPm1faGVhZCA9IE5VTEw7Ci0J
 CQlyZXR1cm4gKGVycm9yKTsKKwkJCWdvdG8gZmFpbDsKIAkJfQogCQlidXNfZG1hbWFwX3N5bmMo
 cnhyLT5yeHRhZywKIAkJICAgIHJ4YnVmLT5tYXAsIEJVU19ETUFTWU5DX1BSRVJFQUQpOwogCiAJ
 CS8qIFVwZGF0ZSBkZXNjcmlwdG9yICovCi0JCXJ4ci0+cnhfYmFzZVtqXS5idWZmZXJfYWRkciA9
 IGh0b2xlNjQoc2VnWzBdLmRzX2FkZHIpOworCQlyeHItPnJ4X2Jhc2VbaV0uYnVmZmVyX2FkZHIg
 PSBodG9sZTY0KHNlZ1swXS5kc19hZGRyKTsKKwkJaSA9IGo7CisJCWlmICgrK2ogPT0gYWRhcHRl
 ci0+bnVtX3J4X2Rlc2MpCisJCQlqID0gMDsKIAl9CiAKLQorZmFpbDoKIAkvKiBTZXR1cCBvdXIg
 ZGVzY3JpcHRvciBpbmRpY2VzICovCi0JcnhyLT5uZXh0X3RvX2NoZWNrID0gMDsKLQlyeHItPm5l
 eHRfdG9fcmVmcmVzaCA9IDA7CisJcnhyLT5uZXh0X3RvX3JlZnJlc2ggPSBpOwogCiAJYnVzX2Rt
 YW1hcF9zeW5jKHJ4ci0+cnhkbWEuZG1hX3RhZywgcnhyLT5yeGRtYS5kbWFfbWFwLAogCSAgICBC
 VVNfRE1BU1lOQ19QUkVSRUFEIHwgQlVTX0RNQVNZTkNfUFJFV1JJVEUpOwogCiAJRU1fUlhfVU5M
 T0NLKHJ4cik7Ci0JcmV0dXJuICgwKTsKKwlyZXR1cm4gKGVycm9yKTsKIH0KIAogLyoqKioqKioq
 KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq
 KioqKgpAQCAtMzk1OSw3ICszOTY5LDcgQEAKIGVtX3NldHVwX3JlY2VpdmVfc3RydWN0dXJlcyhz
 dHJ1Y3QgYWRhcHRlciAqYWRhcHRlcikKIHsKIAlzdHJ1Y3QgcnhfcmluZyAqcnhyID0gYWRhcHRl
 ci0+cnhfcmluZ3M7Ci0JaW50IGo7CisJaW50IGosIG47CiAKIAlmb3IgKGogPSAwOyBqIDwgYWRh
 cHRlci0+bnVtX3F1ZXVlczsgaisrLCByeHIrKykKIAkJaWYgKGVtX3NldHVwX3JlY2VpdmVfcmlu
 ZyhyeHIpKQpAQCAtMzk3NCw3ICszOTg0LDggQEAKIAkgKi8KIAlmb3IgKGludCBpID0gMDsgaSA8
 IGo7ICsraSkgewogCQlyeHIgPSAmYWRhcHRlci0+cnhfcmluZ3NbaV07Ci0JCWZvciAoaW50IG4g
 PSAwOyBuIDwgYWRhcHRlci0+bnVtX3J4X2Rlc2M7IG4rKykgeworCQluID0gcnhyLT5uZXh0X3Rv
 X2NoZWNrOworCQl3aGlsZShuICE9IHJ4ci0+bmV4dF90b19yZWZyZXNoKSB7CiAJCQlzdHJ1Y3Qg
 ZW1fYnVmZmVyICpyeGJ1ZjsKIAkJCXJ4YnVmID0gJnJ4ci0+cnhfYnVmZmVyc1tuXTsKIAkJCWlm
 IChyeGJ1Zi0+bV9oZWFkICE9IE5VTEwpIHsKQEAgLTM5ODQsNyArMzk5NSwxMSBAQAogCQkJCW1f
 ZnJlZW0ocnhidWYtPm1faGVhZCk7CiAJCQkJcnhidWYtPm1faGVhZCA9IE5VTEw7CiAJCQl9CisJ
 CQlpZiAoKytuID09IGFkYXB0ZXItPm51bV9yeF9kZXNjKQorCQkJCW4gPSAwOwogCQl9CisJCXJ4
 ci0+bmV4dF90b19jaGVjayA9IDA7CisJCXJ4ci0+bmV4dF90b19yZWZyZXNoID0gMDsKIAl9CiAK
 IAlyZXR1cm4gKEVOT0JVRlMpOwpAQCAtNDAyMSwxMSArNDAzNiwxMyBAQAogewogCXN0cnVjdCBh
 ZGFwdGVyCQkqYWRhcHRlciA9IHJ4ci0+YWRhcHRlcjsKIAlzdHJ1Y3QgZW1fYnVmZmVyCSpyeGJ1
 ZiA9IE5VTEw7CisJaW50CQkJaTsKIAogCUlOSVRfREVCVUdPVVQoImZyZWVfcmVjZWl2ZV9idWZm
 ZXJzOiBiZWdpbiIpOwogCiAJaWYgKHJ4ci0+cnhfYnVmZmVycyAhPSBOVUxMKSB7Ci0JCWZvciAo
 aW50IGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3J4X2Rlc2M7IGkrKykgeworCQlpID0gcnhyLT5u
 ZXh0X3RvX2NoZWNrOworCQl3aGlsZShpICE9IHJ4ci0+bmV4dF90b19yZWZyZXNoKSB7CiAJCQly
 eGJ1ZiA9ICZyeHItPnJ4X2J1ZmZlcnNbaV07CiAJCQlpZiAocnhidWYtPm1hcCAhPSBOVUxMKSB7
 CiAJCQkJYnVzX2RtYW1hcF9zeW5jKHJ4ci0+cnh0YWcsIHJ4YnVmLT5tYXAsCkBAIC00MDM3LDkg
 KzQwNTQsMTMgQEAKIAkJCQltX2ZyZWVtKHJ4YnVmLT5tX2hlYWQpOwogCQkJCXJ4YnVmLT5tX2hl
 YWQgPSBOVUxMOwogCQkJfQorCQkJaWYgKCsraSA9PSBhZGFwdGVyLT5udW1fcnhfZGVzYykKKwkJ
 CQlpID0gMDsKIAkJfQogCQlmcmVlKHJ4ci0+cnhfYnVmZmVycywgTV9ERVZCVUYpOwogCQlyeHIt
 PnJ4X2J1ZmZlcnMgPSBOVUxMOworCQlyeHItPm5leHRfdG9fY2hlY2sgPSAwOworCQlyeHItPm5l
 eHRfdG9fcmVmcmVzaCA9IDA7CiAJfQogCiAJaWYgKHJ4ci0+cnh0YWcgIT0gTlVMTCkgewpAQCAt
 NDEyMiw4ICs0MTQzLDggQEAKIAkJRTEwMDBfV1JJVEVfUkVHKGh3LCBFMTAwMF9SREJBSChpKSwg
 KHUzMikoYnVzX2FkZHIgPj4gMzIpKTsKIAkJRTEwMDBfV1JJVEVfUkVHKGh3LCBFMTAwMF9SREJB
 TChpKSwgKHUzMilidXNfYWRkcik7CiAJCS8qIFNldHVwIHRoZSBIZWFkIGFuZCBUYWlsIERlc2Ny
 aXB0b3IgUG9pbnRlcnMgKi8KLQkJRTEwMDBfV1JJVEVfUkVHKGh3LCBFMTAwMF9SREgoaSksIDAp
 OwotCQlFMTAwMF9XUklURV9SRUcoaHcsIEUxMDAwX1JEVChpKSwgYWRhcHRlci0+bnVtX3J4X2Rl
 c2MgLSAxKTsKKwkJRTEwMDBfV1JJVEVfUkVHKGh3LCBFMTAwMF9SREgoaSksIHJ4ci0+bmV4dF90
 b19jaGVjayk7CisJCUUxMDAwX1dSSVRFX1JFRyhodywgRTEwMDBfUkRUKGkpLCByeHItPm5leHRf
 dG9fcmVmcmVzaCk7CiAJfQogCiAJLyogU2V0IGVhcmx5IHJlY2VpdmUgdGhyZXNob2xkIG9uIGFw
 cHJvcHJpYXRlIGh3ICovCkBAIC00MzAzLDcgKzQzMjQsOCBAQAogCX0KIAogCS8qIENhdGNoIGFu
 eSByZW1haW5pbmcgcmVmcmVzaCB3b3JrICovCi0JZW1fcmVmcmVzaF9tYnVmcyhyeHIsIGkpOwor
 CWlmIChwcm9jZXNzZWQgIT0gMCB8fCBpID09IHJ4ci0+bmV4dF90b19yZWZyZXNoKQorCQllbV9y
 ZWZyZXNoX21idWZzKHJ4ciwgaSk7CiAKIAlyeHItPm5leHRfdG9fY2hlY2sgPSBpOwogCWlmIChk
 b25lICE9IE5VTEwpCg==
 
 --=====001_Dragon477376006734_=====--
 

From: Arnaud Lacombe <lacombar@gmail.com>
To: beezarliu <beezarliu@yahoo.com.cn>
Cc: "bug-followup@FreeBSD.org" <bug-followup@freebsd.org>, Jack Vogel <jfvogel@gmail.com>
Subject: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Wed, 23 Feb 2011 00:52:47 -0500

 2011/2/22 beezarliu <beezarliu@yahoo.com.cn>:
 > On 2011-02-23 03:08:53, Arnaud Lacombe wrote:
 >>For the record, I can still quickly hang an em(4) with the attached patch.
 >
 > That patch is not complete.
 > I sent this new one to Jack, I think he is verifying if it can work.
 > If you can't wait, try the new one. It's based on stable/8.
 >
 On a 7-STABLE em(4) code, after applying the patch you sent with
 patch(1), minus a small rejection manually fixed (the point of
 failure?), I am still able to hang em(4) RX. I can provide you the
 patch I used if you want to check.
 
   - Arnaud

From: Arnaud Lacombe <lacombar@gmail.com>
To: beezarliu <beezarliu@yahoo.com.cn>
Cc: "bug-followup@FreeBSD.org" <bug-followup@freebsd.org>, Jack Vogel <jfvogel@gmail.com>
Subject: Re: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Wed, 23 Feb 2011 02:52:06 -0500

 Hi,
 
 2011/2/23 beezarliu <beezarliu@yahoo.com.cn>:
 > I think you can replace sys/dev/e1000/* =A0with the files in stable/8,
 > and then uses this patch. It's much simpler.
 > :)
 >
 agree. I switched to the driver of 8-STABLE, applied your patch
 (without any conflict), fixed a bad version check (see [0]), built the
 kernel, rebooted, ran the test... and hung em(4) RX again. 141k missed
 packets (growing) and about 3k cluster allocations denied (constant)
 currently. TX is fine, but the NIC is unable to process ARP and ICMP
 reply sent back by the machine on the LAN.
 
 I did not test igb(4) as I do not have any on the path I directly
 control, but the fix in trunk survived a few day of similar testing.
 
  - Arnaud
 
 [0]:
 diff --git a/sys/dev/e1000/if_igb.h b/sys/dev/e1000/if_igb.h
 index 4388e07..adef0af 100644
 --- a/sys/dev/e1000/if_igb.h
 +++ b/sys/dev/e1000/if_igb.h
 @@ -508,7 +508,7 @@ struct igb_rx_buf {
         cur |=3D new;                             \
  }
 
 -#if __FreeBSD_version < 800504
 +#if __FreeBSD_version >=3D 800000 && __FreeBSD_version < 800504
  static __inline int
  drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br)
  {

Date: Wed, 23 Feb 2011 14:04:16 +0800
From: "beezarliu" <beezarliu@yahoo.com.cn>
To: "Arnaud Lacombe" <lacombar@gmail.com>
Subject: Re: Re: Re: kern/150516: [em] e1000 receive queue handling problem
 
 I think you can replace sys/dev/e1000/*  with the files in stable/8,
 and then uses this patch. It's much simpler. 
 :)
 
 Thanks
 
 __________________________________________________
 ϿעŻ?
 http://cn.mail.yahoo.com
 

From: Arnaud Lacombe <lacombar@gmail.com>
To: beezarliu <beezarliu@yahoo.com.cn>
Cc: "bug-followup@FreeBSD.org" <bug-followup@freebsd.org>, Jack Vogel <jfvogel@gmail.com>, freebsd-net@freebsd.org
Subject: Re: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Fri, 25 Feb 2011 18:52:52 -0500

 --0016363b8b883c06cd049d24078f
 Content-Type: text/plain; charset=ISO-8859-1
 Content-Transfer-Encoding: quoted-printable
 
 Hi,
 
 What is the point to invent a complex logic to detected a situation
 the chip warn you about ?
 
 The attached patch has currently survived longer than anything I've
 been ever tested, without dirty hack, like raising `nmbclusters'.
 
 Thanks in advance,
  - Arnaud
 
 ps: this is a temporary patch, for my 82754 based system, I am aware
 there is other user of IMS_ENABLE_MASK.
 
 On Wed, Feb 23, 2011 at 2:52 AM, Arnaud Lacombe <lacombar@gmail.com> wrote:
 > Hi,
 >
 > 2011/2/23 beezarliu <beezarliu@yahoo.com.cn>:
 >> I think you can replace sys/dev/e1000/* =A0with the files in stable/8,
 >> and then uses this patch. It's much simpler.
 >> :)
 >>
 > agree. I switched to the driver of 8-STABLE, applied your patch
 > (without any conflict), fixed a bad version check (see [0]), built the
 > kernel, rebooted, ran the test... and hung em(4) RX again. 141k missed
 > packets (growing) and about 3k cluster allocations denied (constant)
 > currently. TX is fine, but the NIC is unable to process ARP and ICMP
 > reply sent back by the machine on the LAN.
 >
 > I did not test igb(4) as I do not have any on the path I directly
 > control, but the fix in trunk survived a few day of similar testing.
 >
 > =A0- Arnaud
 >
 > [0]:
 > diff --git a/sys/dev/e1000/if_igb.h b/sys/dev/e1000/if_igb.h
 > index 4388e07..adef0af 100644
 > --- a/sys/dev/e1000/if_igb.h
 > +++ b/sys/dev/e1000/if_igb.h
 > @@ -508,7 +508,7 @@ struct igb_rx_buf {
 > =A0 =A0 =A0 =A0cur |=3D new; =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =
 =A0 =A0 =A0 \
 > =A0}
 >
 > -#if __FreeBSD_version < 800504
 > +#if __FreeBSD_version >=3D 800000 && __FreeBSD_version < 800504
 > =A0static __inline int
 > =A0drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br)
 > =A0{
 >
 
 --0016363b8b883c06cd049d24078f
 Content-Type: text/x-patch; charset=US-ASCII; name="0001-if_em-handle-RX-overrun.patch"
 Content-Disposition: attachment; 
 	filename="0001-if_em-handle-RX-overrun.patch"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_gklr8w9u0
 
 RnJvbSAyNjU3NDc1NjFhMjA2MDQ2OWZlMGMyMTA5NGU3N2Q0NGIyYzBhMzlhIE1vbiBTZXAgMTcg
 MDA6MDA6MDAgMjAwMQpGcm9tOiBBcm5hdWQgTGFjb21iZSA8bGFjb21iYXJAZ21haWwuY29tPgpE
 YXRlOiBGcmksIDI1IEZlYiAyMDExIDE4OjQ3OjQ4IC0wNTAwClN1YmplY3Q6IFtQQVRDSF0gaWZf
 ZW06IGhhbmRsZSBSWCBvdmVycnVuCgotLS0KIHN5cy9kZXYvZTEwMDAvZTEwMDBfZGVmaW5lcy5o
 IHwgICAgMSArCiBzeXMvZGV2L2UxMDAwL2lmX2VtLmMgICAgICAgICB8ICAgMjEgKysrKysrKysr
 KysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDIxIGluc2VydGlvbnMoKyksIDEgZGVsZXRp
 b25zKC0pCgpkaWZmIC0tZ2l0IGEvc3lzL2Rldi9lMTAwMC9lMTAwMF9kZWZpbmVzLmggYi9zeXMv
 ZGV2L2UxMDAwL2UxMDAwX2RlZmluZXMuaAppbmRleCA1ZDA5YWQ5Li5lMGY1MWM0IDEwMDY0NAot
 LS0gYS9zeXMvZGV2L2UxMDAwL2UxMDAwX2RlZmluZXMuaAorKysgYi9zeXMvZGV2L2UxMDAwL2Ux
 MDAwX2RlZmluZXMuaApAQCAtODY1LDYgKzg2NSw3IEBACiAjZGVmaW5lIElNU19FTkFCTEVfTUFT
 SyAoIFwKICAgICBFMTAwMF9JTVNfUlhUMCAgIHwgICAgXAogICAgIEUxMDAwX0lNU19UWERXICAg
 fCAgICBcCisgICAgRTEwMDBfSU1TX1JYTyAgICB8ICAgIFwKICAgICBFMTAwMF9JTVNfUlhETVQw
 IHwgICAgXAogICAgIEUxMDAwX0lNU19SWFNFUSAgfCAgICBcCiAgICAgRTEwMDBfSU1TX0xTQykK
 ZGlmZiAtLWdpdCBhL3N5cy9kZXYvZTEwMDAvaWZfZW0uYyBiL3N5cy9kZXYvZTEwMDAvaWZfZW0u
 YwppbmRleCBlMDA0Y2M3Li5kNWUxMThhIDEwMDY0NAotLS0gYS9zeXMvZGV2L2UxMDAwL2lmX2Vt
 LmMKKysrIGIvc3lzL2Rldi9lMTAwMC9pZl9lbS5jCkBAIC0yODMsNiArMjgzLDcgQEAgc3RhdGlj
 IHZvaWQJZW1fbXNpeF9saW5rKHZvaWQgKik7CiBzdGF0aWMgdm9pZAllbV9oYW5kbGVfdHgodm9p
 ZCAqY29udGV4dCwgaW50IHBlbmRpbmcpOwogc3RhdGljIHZvaWQJZW1faGFuZGxlX3J4KHZvaWQg
 KmNvbnRleHQsIGludCBwZW5kaW5nKTsKIHN0YXRpYyB2b2lkCWVtX2hhbmRsZV9saW5rKHZvaWQg
 KmNvbnRleHQsIGludCBwZW5kaW5nKTsKK3N0YXRpYyB2b2lkCWVtX2hhbmRsZV9yeF9vdmVycnVu
 KHZvaWQgKmNvbnRleHQpOwogCiBzdGF0aWMgdm9pZAllbV9hZGRfcnhfcHJvY2Vzc19saW1pdChz
 dHJ1Y3QgYWRhcHRlciAqLCBjb25zdCBjaGFyICosCiAJCSAgICBjb25zdCBjaGFyICosIGludCAq
 LCBpbnQpOwpAQCAtMTU2Nyw5ICsxNTY4LDEyIEBAIGVtX21zaXhfbGluayh2b2lkICphcmcpCiAJ
 aWYgKHJlZ19pY3IgJiAoRTEwMDBfSUNSX1JYU0VRIHwgRTEwMDBfSUNSX0xTQykpIHsKIAkJYWRh
 cHRlci0+aHcubWFjLmdldF9saW5rX3N0YXR1cyA9IDE7CiAJCWVtX2hhbmRsZV9saW5rKGFkYXB0
 ZXIsIDApOworCX0gZWxzZSBpZiAocmVnX2ljciAmIEUxMDAwX0lDUl9SWE8pIHsKKwkJYWRhcHRl
 ci0+cnhfb3ZlcnJ1bnMrKzsKKwkJZW1faGFuZGxlX3J4X292ZXJydW4oYWRhcHRlcik7CiAJfSBl
 bHNlCiAJCUUxMDAwX1dSSVRFX1JFRygmYWRhcHRlci0+aHcsIEUxMDAwX0lNUywKLQkJICAgIEVN
 X01TSVhfTElOSyB8IEUxMDAwX0lNU19MU0MpOworCQkgICAgRU1fTVNJWF9MSU5LIHwgRTEwMDBf
 SU1TX0xTQyB8IEUxMDAwX0lNU19SWE8pOwogCXJldHVybjsKIH0KIApAQCAtMTYyNyw2ICsxNjMx
 LDIxIEBAIGVtX2hhbmRsZV9saW5rKHZvaWQgKmNvbnRleHQsIGludCBwZW5kaW5nKQogCUVNX0NP
 UkVfVU5MT0NLKGFkYXB0ZXIpOwogfQogCitzdGF0aWMgdm9pZAorZW1faGFuZGxlX3J4X292ZXJy
 dW4odm9pZCAqY29udGV4dCkKK3sKKwlzdHJ1Y3QgYWRhcHRlcgkqYWRhcHRlciA9IGNvbnRleHQ7
 CisJc3RydWN0IGlmbmV0ICppZnAgPSBhZGFwdGVyLT5pZnA7CisJc3RydWN0IHJ4X3JpbmcgKnJ4
 ciA9IGFkYXB0ZXItPnJ4X3JpbmdzOworCisJaWYgKCEoaWZwLT5pZl9kcnZfZmxhZ3MgJiBJRkZf
 RFJWX1JVTk5JTkcpKQorCQlyZXR1cm47CisKKwlFTV9DT1JFX0xPQ0soYWRhcHRlcik7CisJZW1f
 cmVmcmVzaF9tYnVmcyhyeHIsIHJ4ci0+bmV4dF90b19jaGVjayk7CisJRTEwMDBfV1JJVEVfUkVH
 KCZhZGFwdGVyLT5odywgRTEwMDBfSU1TLCBFMTAwMF9JTVNfUlhPKTsKKwlFTV9DT1JFX1VOTE9D
 SyhhZGFwdGVyKTsKK30KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq
 KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKLS0gCjEuNy4zLjMuNDE4Lmc3MDRm
 Ni5kaXJ0eQoK
 --0016363b8b883c06cd049d24078f--

From: "beezarliu" <beezarliu@yahoo.com.cn>
To: "Arnaud Lacombe" <lacombar@gmail.com>
Cc: "bug-followup@FreeBSD.org" <bug-followup@freebsd.org>,
 "Jack Vogel" <jfvogel@gmail.com>,
 "freebsd-net@freebsd.org" <freebsd-net@freebsd.org>
Subject: Re: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Sat, 26 Feb 2011 11:59:26 +0800

 On 2011-02-26 07:52:54, Arnaud Lacombe wrote:
 >Hi,
 >
 >What is the point to invent a complex logic to detected a situation
 >the chip warn you about ?
 >
 >The attached patch has currently survived longer than anything I've
 >been ever tested, without dirty hack, like raising `nmbclusters'.
 
 Sorry, I didn't 'invent' the logic, it's just what rx ring queue
 works in hardware. You provided another way to detect the hang, which
 doesn't mean others are meaningless.
 
 Raising nmbcluster is not best way, but it can ease the memory shortage,
 and allcate more for network, which also improve system performance.
 
 Beezar
 
 

From: Arnaud Lacombe <lacombar@gmail.com>
To: beezarliu <beezarliu@yahoo.com.cn>
Cc: "bug-followup@FreeBSD.org" <bug-followup@freebsd.org>, Jack Vogel <jfvogel@gmail.com>, 
	"freebsd-net@freebsd.org" <freebsd-net@freebsd.org>
Subject: Re: Re: Re: kern/150516: [em] e1000 receive queue handling problem
Date: Sat, 26 Feb 2011 02:14:26 -0500

 Hi,
 
 2011/2/25 beezarliu <beezarliu@yahoo.com.cn>:
 > Raising nmbcluster is not best way, but it can ease the memory shortage,
 > and allcate more for network, which also improve system performance.
 >
 sure, but the driver should still be able to deals with such condition
 without stalling. :)
 
  - Arnaud
>Unformatted:
