From nobody@FreeBSD.org  Wed May 29 20:17:08 2013
Return-Path: <nobody@FreeBSD.org>
Received: from mx1.freebsd.org (mx1.FreeBSD.org [8.8.178.115])
	by hub.freebsd.org (Postfix) with ESMTP id C4F88402
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 29 May 2013 20:17:08 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from oldred.FreeBSD.org (oldred.freebsd.org [8.8.178.121])
	by mx1.freebsd.org (Postfix) with ESMTP id B6C3F6B9
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 29 May 2013 20:17:08 +0000 (UTC)
Received: from oldred.FreeBSD.org ([127.0.1.6])
	by oldred.FreeBSD.org (8.14.5/8.14.5) with ESMTP id r4TKH7wC003794
	for <freebsd-gnats-submit@FreeBSD.org>; Wed, 29 May 2013 20:17:07 GMT
	(envelope-from nobody@oldred.FreeBSD.org)
Received: (from nobody@localhost)
	by oldred.FreeBSD.org (8.14.5/8.14.5/Submit) id r4TKH7G0003793;
	Wed, 29 May 2013 20:17:07 GMT
	(envelope-from nobody)
Message-Id: <201305292017.r4TKH7G0003793@oldred.FreeBSD.org>
Date: Wed, 29 May 2013 20:17:07 GMT
From: Olivier Cochard-Labbe <olivier@cochard.me>
To: freebsd-gnats-submit@FreeBSD.org
Subject: pthread patch for netblast
X-Send-Pr-Version: www-3.1
X-GNATS-Notify:

>Number:         179085
>Category:       bin
>Synopsis:       [tools] [patch] pthread patch for netblast
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    freebsd-bugs
>State:          open
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          sw-bug
>Submitter-Id:   current-users
>Arrival-Date:   Wed May 29 20:20:00 UTC 2013
>Closed-Date:    
>Last-Modified:  Sat Jun 22 08:00:00 UTC 2013
>Originator:     Olivier Cochard-Labbe
>Release:        current
>Organization:
BSD Router Project
>Environment:
FreeBSD laptop.bsdrp.net 10.0-CURRENT FreeBSD 10.0-CURRENT #2 r250925: Thu May 23 21:49:14 CEST 2013     root@laptop.bsdrp.net:/usr/obj/usr/local/BSDRP/BSDRPcur/FreeBSD/src/sys/LAPTOP  amd64
>Description:
Here is a patch that add multithread support to tools/tools/netrate/netblast (I've used the netreceive code).
WARNING:It need full review because it's my first try with pthread.
>How-To-Repeat:

>Fix:


Patch attached with submission follows:

Index: tools/tools/netrate/netblast/Makefile
===================================================================
--- tools/tools/netrate/netblast/Makefile	(revision 250926)
+++ tools/tools/netrate/netblast/Makefile	(working copy)
@@ -4,5 +4,8 @@
 
 PROG=	netblast
 NO_MAN=
+LDFLAGS += -lpthread
 
+WARNS?= 3
+
 .include <bsd.prog.mk>
Index: tools/tools/netrate/netblast/netblast.c
===================================================================
--- tools/tools/netrate/netblast/netblast.c	(revision 250926)
+++ tools/tools/netrate/netblast/netblast.c	(working copy)
@@ -40,15 +40,24 @@
 #include <string.h>
 #include <unistd.h>			/* close */
 
+#include <pthread.h>
+#include <fcntl.h>
+#include <time.h>   /* clock_getres() */
+
+static int round_to(int n, int l)
+{
+    return ((n + l - 1)/l)*l;
+}
+
 static void
 usage(void)
 {
 
-	fprintf(stderr, "netblast [ip] [port] [payloadsize] [duration]\n");
+	fprintf(stderr, "netblast [ip] [port] [payloadsize] [duration] [nthreads]\n");
 	exit(-1);
 }
 
-static int	global_stop_flag;
+static int	global_stop_flag=0;
 
 static void
 signal_handler(int signum __unused)
@@ -57,48 +66,28 @@
 	global_stop_flag = 1;
 }
 
+
 /*
- * Loop that blasts packets: begin by recording time information, resetting
- * stats.  Set the interval timer for when we want to wake up.  Then go.
- * SIGALRM will set a flag indicating it's time to stop.  Note that there's
- * some overhead to the signal and timer setup, so the smaller the duration,
- * the higher the relative overhead.
+ * Each socket uses multiple threads so the receiver is
+ * more efficient. A collector thread runs the stats.
  */
-static int
-blast_loop(int s, long duration, u_char *packet, u_int packet_len)
+struct td_desc {
+    pthread_t td_id;
+    uint64_t counter; /* tx counter */
+	uint64_t send_errors; /* tx send errors */
+    uint64_t send_calls;    /* tx send calls */
+	int s;
+	u_char *packet;
+	u_int packet_len;
+};
+
+static void *
+blast(void *data)
 {
-	struct timespec starttime, tmptime;
-	struct itimerval it;
-	u_int32_t counter;
-	int send_errors, send_calls;
-
-	if (signal(SIGALRM, signal_handler) == SIG_ERR) {
-		perror("signal");
-		return (-1);
-	}
-
-	if (clock_getres(CLOCK_REALTIME, &tmptime) == -1) {
-		perror("clock_getres");
-		return (-1);
-	}
-
-	if (clock_gettime(CLOCK_REALTIME, &starttime) == -1) {
-		perror("clock_gettime");
-		return (-1);
-	}
-
-	it.it_interval.tv_sec = 0;
-	it.it_interval.tv_usec = 0;
-	it.it_value.tv_sec = duration;
-	it.it_value.tv_usec = 0;
-
-	if (setitimer(ITIMER_REAL, &it, NULL) < 0) {
-		perror("setitimer");
-		return (-1);
-	}
-
-	send_errors = send_calls = 0;
-	counter = 0;
+    struct td_desc *t = data;
+	t->counter=0;
+	t->send_errors=0;
+	t->send_calls=0;
 	while (global_stop_flag == 0) {
 		/*
 		 * We maintain and, if there's room, send a counter.  Note
@@ -110,32 +99,74 @@
 		 * operation, causing the current sequence number also to be
 		 * skipped.
 		 */
-		if (packet_len >= 4) {
-			be32enc(packet, counter);
-			counter++;
+		if (t->packet_len >= 4) {
+			be32enc(t->packet, t->counter);
+			t->counter++;
 		}
-		if (send(s, packet, packet_len, 0) < 0)
-			send_errors++;
-		send_calls++;
+		if (send(t->s, t->packet, t->packet_len, 0) < 0)
+			t->send_errors++;
+		t->send_calls++;
 	}
+    return NULL;
+}
 
+static struct td_desc **
+make_threads(int s, u_char *packet, u_int packet_len, int nthreads)
+{
+    int i;
+    int lb = round_to(nthreads * sizeof (struct td_desc *), 64);
+    int td_len = round_to(sizeof(struct td_desc), 64); // cache align
+    char *m = calloc(1, lb + td_len * nthreads);
+    struct td_desc **tp;
+
+    /* pointers plus the structs */
+    if (m == NULL) {
+        perror("no room for pointers!");
+        exit(1);
+    }
+    tp = (struct td_desc **)m;
+    m += lb;    /* skip the pointers */
+    for (i = 0; i < nthreads; i++, m += td_len) {
+        tp[i] = (struct td_desc *)m;
+        tp[i]->s = s;
+        tp[i]->packet = packet;
+        tp[i]->packet_len = packet_len;
+        if (pthread_create(&tp[i]->td_id, NULL, blast, tp[i])) {
+            perror("unable to create thread");
+            exit(1);
+        }
+    }
+    return tp;
+}
+
+
+static void
+main_thread(struct td_desc **tp, long duration, struct timespec starttime, struct timespec tmptime, int nthreads)
+{
+	uint64_t send_errors=0, send_calls=0;
+	int i;
 	if (clock_gettime(CLOCK_REALTIME, &tmptime) == -1) {
 		perror("clock_gettime");
-		return (-1);
 	}
 
+	for (i = 0; i < nthreads; i++) {
+		/* Wait for thread end */
+		pthread_join( tp[i]->td_id, NULL);
+		send_calls+=tp[i]->send_calls;
+		send_errors+=tp[i]->send_errors;
+    }
+
 	printf("\n");
 	printf("start:             %zd.%09lu\n", starttime.tv_sec,
 	    starttime.tv_nsec);
 	printf("finish:            %zd.%09lu\n", tmptime.tv_sec,
 	    tmptime.tv_nsec);
-	printf("send calls:        %d\n", send_calls);
-	printf("send errors:       %d\n", send_errors);
-	printf("approx send rate:  %ld\n", (send_calls - send_errors) /
+	printf("send calls:        %lu\n", send_calls);
+	printf("send errors:       %lu\n", send_errors);
+	printf("approx send rate:  %lu\n", (send_calls - send_errors) /
 	    duration);
-	printf("approx error rate: %d\n", (send_errors / send_calls));
+	printf("approx error rate: %lu\n", (send_errors / send_calls));
 
-	return (0);
 }
 
 int
@@ -143,11 +174,15 @@
 {
 	long payloadsize, duration;
 	struct addrinfo hints, *res, *res0;
-	char *dummy, *packet;
-	int port, s, error;
+	char *dummy;
+	u_char *packet;
+	int port, s, error, nthreads = 1;
+	struct td_desc **tp;	
 	const char *cause = NULL;
+	struct timespec starttime, tmptime;
+	struct itimerval it;
 
-	if (argc != 5)
+	if (argc < 5)
 		usage();
 
 	memset(&hints, 0, sizeof(hints));
@@ -177,6 +212,11 @@
 		/*NOTREACHED*/
 	}
 
+	if (argc > 5)
+        nthreads = strtoul(argv[5], &dummy, 10);
+    if (nthreads < 1 || nthreads > 64)
+        usage();
+
 	packet = malloc(payloadsize);
 	if (packet == NULL) {
 		perror("malloc");
@@ -216,6 +256,43 @@
 
 	freeaddrinfo(res0);
 
-	return (blast_loop(s, duration, packet, payloadsize));
+	printf("netblast %d threads sending on UDP port %d\n",
+    nthreads, (u_short)port);
 
+	/*
+	 * Begin by recording time information stats.
+	 * Set the interval timer for when we want to wake up.
+	 * SIGALRM will set a flag indicating it's time to stop.  Note that there's
+	 * some overhead to the signal and timer setup, so the smaller the duration,
+	 * the higher the relative overhead.
+	 */
+
+	if (signal(SIGALRM, signal_handler) == SIG_ERR) {
+		perror("signal");
+		return (-1);
+	}
+
+	if (clock_getres(CLOCK_REALTIME, &tmptime) == -1) {
+		perror("clock_getres");
+		return (-1);
+	}
+
+	if (clock_gettime(CLOCK_REALTIME, &starttime) == -1) {
+		perror("clock_gettime");
+		return (-1);
+	}
+
+	it.it_interval.tv_sec = 0;
+	it.it_interval.tv_usec = 0;
+	it.it_value.tv_sec = duration;
+	it.it_value.tv_usec = 0;
+
+	if (setitimer(ITIMER_REAL, &it, NULL) < 0) {
+		perror("setitimer");
+		return (-1);
+	}
+
+    tp = make_threads(s, packet, payloadsize, nthreads);
+    main_thread(tp, duration, starttime,  tmptime, nthreads);
+
 }


>Release-Note:
>Audit-Trail:

From: =?ISO-8859-1?Q?Olivier_Cochard=2DLabb=E9?= <olivier@cochard.me>
To: bug-followup@freebsd.org
Cc:  
Subject: Re: bin/179085: [tools] [patch] pthread patch for netblast
Date: Sat, 22 Jun 2013 09:54:07 +0200

 --089e0153688c167ce704dfb97d89
 Content-Type: text/plain; charset=ISO-8859-1
 
 I've updated my patch for displaying approx througput (ethernet and payload):
 Network admin want ethernet throughput but system admin want payload
 throughput :-)
 
 Here are an output example:
 
 netblast 1.1.1.2 4121 10 30 `sysctl -n hw.ncpu`
 netblast 4 threads sending on UDP port 4121
 
 start:                      1371890360.734221251
 finish:                     1371890360.734307388
 send calls:                 37678622
 send errors:                5996263
 send success:               31682359
 approx send rate:           1056078
 approx error rate:          0
 approx Ethernet throughput: 439 Mib/s
 approx payload throughput:  84 Mib/s
 
 I've attached the patch for 9-stable and -current to this mail, but
 you can found it here too (if gmail mangle the attached file):
 9-stable: http://sourceforge.net/p/bsdrp/code/HEAD/tree/trunk/BSDRP/patches/freebsd.netblast.patch?format=raw
 -current: http://sourceforge.net/p/bsdrp/code/HEAD/tree/trunk/BSDRPcur/patches/freebsd.netblast.patch?format=raw
 
 Regards,
 
 Olivier
 
 --089e0153688c167ce704dfb97d89
 Content-Type: text/plain; charset=US-ASCII; 
 	name="freebsd-current.pthread-netblast.patch.txt"
 Content-Disposition: attachment; 
 	filename="freebsd-current.pthread-netblast.patch.txt"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_hi8iglj10
 
 ZGlmZiAtcnVOIHRvb2xzL3Rvb2xzL25ldHJhdGUvbmV0Ymxhc3Qub3JpZy9NYWtlZmlsZSB0b29s
 cy90b29scy9uZXRyYXRlL25ldGJsYXN0L01ha2VmaWxlCi0tLSB0b29scy90b29scy9uZXRyYXRl
 L25ldGJsYXN0Lm9yaWcvTWFrZWZpbGUJMjAxMy0wNi0yMiAwMTo0NzozOC43NzMyNzY1NDEgKzAy
 MDAKKysrIHRvb2xzL3Rvb2xzL25ldHJhdGUvbmV0Ymxhc3QvTWFrZWZpbGUJMjAxMy0wNi0yMCAx
 MjozNDowMi42NzkzMzM3NDEgKzAyMDAKQEAgLTQsNSArNCw4IEBACiAKIFBST0c9CW5ldGJsYXN0
 CiBOT19NQU49CitMREZMQUdTICs9IC1scHRocmVhZAorCitXQVJOUz89IDMKIAogLmluY2x1ZGUg
 PGJzZC5wcm9nLm1rPgpkaWZmIC1ydU4gdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC5vcmln
 L25ldGJsYXN0LmMgdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC9uZXRibGFzdC5jCi0tLSB0
 b29scy90b29scy9uZXRyYXRlL25ldGJsYXN0Lm9yaWcvbmV0Ymxhc3QuYwkyMDEzLTA2LTIyIDAx
 OjQ3OjM4Ljc3MzI3NjU0MSArMDIwMAorKysgdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC9u
 ZXRibGFzdC5jCTIwMTMtMDYtMjIgMDA6NTc6MzUuMzk5NDgyNzYzICswMjAwCkBAIC00MCwxNSAr
 NDAsMjQgQEAKICNpbmNsdWRlIDxzdHJpbmcuaD4KICNpbmNsdWRlIDx1bmlzdGQuaD4JCQkvKiBj
 bG9zZSAqLwogCisjaW5jbHVkZSA8cHRocmVhZC5oPgorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5j
 bHVkZSA8dGltZS5oPiAgIC8qIGNsb2NrX2dldHJlcygpICovCisKK3N0YXRpYyBpbnQgcm91bmRf
 dG8oaW50IG4sIGludCBsKQoreworICAgIHJldHVybiAoKG4gKyBsIC0gMSkvbCkqbDsKK30KKwog
 c3RhdGljIHZvaWQKIHVzYWdlKHZvaWQpCiB7CiAKLQlmcHJpbnRmKHN0ZGVyciwgIm5ldGJsYXN0
 IFtpcF0gW3BvcnRdIFtwYXlsb2Fkc2l6ZV0gW2R1cmF0aW9uXVxuIik7CisJZnByaW50ZihzdGRl
 cnIsICJuZXRibGFzdCBbaXBdIFtwb3J0XSBbcGF5bG9hZHNpemVdIFtkdXJhdGlvbl0gW250aHJl
 YWRzXVxuIik7CiAJZXhpdCgtMSk7CiB9CiAKLXN0YXRpYyBpbnQJZ2xvYmFsX3N0b3BfZmxhZzsK
 K3N0YXRpYyBpbnQJZ2xvYmFsX3N0b3BfZmxhZz0wOwogCiBzdGF0aWMgdm9pZAogc2lnbmFsX2hh
 bmRsZXIoaW50IHNpZ251bSBfX3VudXNlZCkKQEAgLTU3LDQ4ICs2NiwyOCBAQAogCWdsb2JhbF9z
 dG9wX2ZsYWcgPSAxOwogfQogCisKIC8qCi0gKiBMb29wIHRoYXQgYmxhc3RzIHBhY2tldHM6IGJl
 Z2luIGJ5IHJlY29yZGluZyB0aW1lIGluZm9ybWF0aW9uLCByZXNldHRpbmcKLSAqIHN0YXRzLiAg
 U2V0IHRoZSBpbnRlcnZhbCB0aW1lciBmb3Igd2hlbiB3ZSB3YW50IHRvIHdha2UgdXAuICBUaGVu
 IGdvLgotICogU0lHQUxSTSB3aWxsIHNldCBhIGZsYWcgaW5kaWNhdGluZyBpdCdzIHRpbWUgdG8g
 c3RvcC4gIE5vdGUgdGhhdCB0aGVyZSdzCi0gKiBzb21lIG92ZXJoZWFkIHRvIHRoZSBzaWduYWwg
 YW5kIHRpbWVyIHNldHVwLCBzbyB0aGUgc21hbGxlciB0aGUgZHVyYXRpb24sCi0gKiB0aGUgaGln
 aGVyIHRoZSByZWxhdGl2ZSBvdmVyaGVhZC4KKyAqIEVhY2ggc29ja2V0IHVzZXMgbXVsdGlwbGUg
 dGhyZWFkcyBzbyB0aGUgZ2VuZXJhdG9yIGlzCisgKiBtb3JlIGVmZmljaWVudC4gQSBjb2xsZWN0
 b3IgdGhyZWFkIHJ1bnMgdGhlIHN0YXRzLgogICovCi1zdGF0aWMgaW50Ci1ibGFzdF9sb29wKGlu
 dCBzLCBsb25nIGR1cmF0aW9uLCB1X2NoYXIgKnBhY2tldCwgdV9pbnQgcGFja2V0X2xlbikKLXsK
 LQlzdHJ1Y3QgdGltZXNwZWMgc3RhcnR0aW1lLCB0bXB0aW1lOwotCXN0cnVjdCBpdGltZXJ2YWwg
 aXQ7Ci0JdV9pbnQzMl90IGNvdW50ZXI7Ci0JaW50IHNlbmRfZXJyb3JzLCBzZW5kX2NhbGxzOwot
 Ci0JaWYgKHNpZ25hbChTSUdBTFJNLCBzaWduYWxfaGFuZGxlcikgPT0gU0lHX0VSUikgewotCQlw
 ZXJyb3IoInNpZ25hbCIpOwotCQlyZXR1cm4gKC0xKTsKLQl9Ci0KLQlpZiAoY2xvY2tfZ2V0cmVz
 KENMT0NLX1JFQUxUSU1FLCAmdG1wdGltZSkgPT0gLTEpIHsKLQkJcGVycm9yKCJjbG9ja19nZXRy
 ZXMiKTsKLQkJcmV0dXJuICgtMSk7Ci0JfQotCi0JaWYgKGNsb2NrX2dldHRpbWUoQ0xPQ0tfUkVB
 TFRJTUUsICZzdGFydHRpbWUpID09IC0xKSB7Ci0JCXBlcnJvcigiY2xvY2tfZ2V0dGltZSIpOwot
 CQlyZXR1cm4gKC0xKTsKLQl9Ci0KLQlpdC5pdF9pbnRlcnZhbC50dl9zZWMgPSAwOwotCWl0Lml0
 X2ludGVydmFsLnR2X3VzZWMgPSAwOwotCWl0Lml0X3ZhbHVlLnR2X3NlYyA9IGR1cmF0aW9uOwot
 CWl0Lml0X3ZhbHVlLnR2X3VzZWMgPSAwOworc3RydWN0IHRkX2Rlc2MgeworCXB0aHJlYWRfdCB0
 ZF9pZDsKKwl1aW50NjRfdCBjb3VudGVyOyAvKiB0eCBjb3VudGVyICovCisJdWludDY0X3Qgc2Vu
 ZF9lcnJvcnM7IC8qIHR4IHNlbmQgZXJyb3JzICovCisJdWludDY0X3Qgc2VuZF9jYWxsczsgICAg
 LyogdHggc2VuZCBjYWxscyAqLworCWludCBzOworCXVfY2hhciAqcGFja2V0OworCXVfaW50IHBh
 Y2tldF9sZW47Cit9OwogCi0JaWYgKHNldGl0aW1lcihJVElNRVJfUkVBTCwgJml0LCBOVUxMKSA8
 IDApIHsKLQkJcGVycm9yKCJzZXRpdGltZXIiKTsKLQkJcmV0dXJuICgtMSk7Ci0JfQotCi0Jc2Vu
 ZF9lcnJvcnMgPSBzZW5kX2NhbGxzID0gMDsKLQljb3VudGVyID0gMDsKK3N0YXRpYyB2b2lkICoK
 K2JsYXN0KHZvaWQgKmRhdGEpCit7CisgICAgc3RydWN0IHRkX2Rlc2MgKnQgPSBkYXRhOworCXQt
 PmNvdW50ZXI9MDsKKwl0LT5zZW5kX2Vycm9ycz0wOworCXQtPnNlbmRfY2FsbHM9MDsKIAl3aGls
 ZSAoZ2xvYmFsX3N0b3BfZmxhZyA9PSAwKSB7CiAJCS8qCiAJCSAqIFdlIG1haW50YWluIGFuZCwg
 aWYgdGhlcmUncyByb29tLCBzZW5kIGEgY291bnRlci4gIE5vdGUKQEAgLTExMCwzMiArOTksODQg
 QEAKIAkJICogb3BlcmF0aW9uLCBjYXVzaW5nIHRoZSBjdXJyZW50IHNlcXVlbmNlIG51bWJlciBh
 bHNvIHRvIGJlCiAJCSAqIHNraXBwZWQuCiAJCSAqLwotCQlpZiAocGFja2V0X2xlbiA+PSA0KSB7
 Ci0JCQliZTMyZW5jKHBhY2tldCwgY291bnRlcik7Ci0JCQljb3VudGVyKys7CisJCWlmICh0LT5w
 YWNrZXRfbGVuID49IDQpIHsKKwkJCWJlMzJlbmModC0+cGFja2V0LCB0LT5jb3VudGVyKTsKKwkJ
 CXQtPmNvdW50ZXIrKzsKIAkJfQotCQlpZiAoc2VuZChzLCBwYWNrZXQsIHBhY2tldF9sZW4sIDAp
 IDwgMCkKLQkJCXNlbmRfZXJyb3JzKys7Ci0JCXNlbmRfY2FsbHMrKzsKKwkJaWYgKHNlbmQodC0+
 cywgdC0+cGFja2V0LCB0LT5wYWNrZXRfbGVuLCAwKSA8IDApCisJCQl0LT5zZW5kX2Vycm9ycysr
 OworCQl0LT5zZW5kX2NhbGxzKys7CiAJfQorICAgIHJldHVybiBOVUxMOworfQorCitzdGF0aWMg
 c3RydWN0IHRkX2Rlc2MgKioKK21ha2VfdGhyZWFkcyhpbnQgcywgdV9jaGFyICpwYWNrZXQsIHVf
 aW50IHBhY2tldF9sZW4sIGludCBudGhyZWFkcykKK3sKKyAgICBpbnQgaTsKKyAgICBpbnQgbGIg
 PSByb3VuZF90byhudGhyZWFkcyAqIHNpemVvZiAoc3RydWN0IHRkX2Rlc2MgKiksIDY0KTsKKyAg
 ICBpbnQgdGRfbGVuID0gcm91bmRfdG8oc2l6ZW9mKHN0cnVjdCB0ZF9kZXNjKSwgNjQpOyAvLyBj
 YWNoZSBhbGlnbgorICAgIGNoYXIgKm0gPSBjYWxsb2MoMSwgbGIgKyB0ZF9sZW4gKiBudGhyZWFk
 cyk7CisgICAgc3RydWN0IHRkX2Rlc2MgKip0cDsKKworICAgIC8qIHBvaW50ZXJzIHBsdXMgdGhl
 IHN0cnVjdHMgKi8KKyAgICBpZiAobSA9PSBOVUxMKSB7CisgICAgICAgIHBlcnJvcigibm8gcm9v
 bSBmb3IgcG9pbnRlcnMhIik7CisgICAgICAgIGV4aXQoMSk7CisgICAgfQorICAgIHRwID0gKHN0
 cnVjdCB0ZF9kZXNjICoqKW07CisgICAgbSArPSBsYjsgICAgLyogc2tpcCB0aGUgcG9pbnRlcnMg
 Ki8KKyAgICBmb3IgKGkgPSAwOyBpIDwgbnRocmVhZHM7IGkrKywgbSArPSB0ZF9sZW4pIHsKKyAg
 ICAgICAgdHBbaV0gPSAoc3RydWN0IHRkX2Rlc2MgKiltOworICAgICAgICB0cFtpXS0+cyA9IHM7
 CisgICAgICAgIHRwW2ldLT5wYWNrZXQgPSBwYWNrZXQ7CisgICAgICAgIHRwW2ldLT5wYWNrZXRf
 bGVuID0gcGFja2V0X2xlbjsKKyAgICAgICAgaWYgKHB0aHJlYWRfY3JlYXRlKCZ0cFtpXS0+dGRf
 aWQsIE5VTEwsIGJsYXN0LCB0cFtpXSkpIHsKKyAgICAgICAgICAgIHBlcnJvcigidW5hYmxlIHRv
 IGNyZWF0ZSB0aHJlYWQiKTsKKyAgICAgICAgICAgIGV4aXQoMSk7CisgICAgICAgIH0KKyAgICB9
 CisgICAgcmV0dXJuIHRwOworfQogCisKK3N0YXRpYyB2b2lkCittYWluX3RocmVhZChzdHJ1Y3Qg
 dGRfZGVzYyAqKnRwLCBsb25nIGR1cmF0aW9uLCBzdHJ1Y3QgdGltZXNwZWMgc3RhcnR0aW1lLCBz
 dHJ1Y3QgdGltZXNwZWMgdG1wdGltZSwgbG9uZyBwYXlsb2Fkc2l6ZSwgaW50IGZhbWlseSwgaW50
 IG50aHJlYWRzKQoreworCXVpbnQ2NF90IHNlbmRfZXJyb3JzPTAsIHNlbmRfY2FsbHM9MDsKKwlp
 bnQgaTsKIAlpZiAoY2xvY2tfZ2V0dGltZShDTE9DS19SRUFMVElNRSwgJnRtcHRpbWUpID09IC0x
 KSB7CiAJCXBlcnJvcigiY2xvY2tfZ2V0dGltZSIpOwotCQlyZXR1cm4gKC0xKTsKIAl9CiAKKwlm
 b3IgKGkgPSAwOyBpIDwgbnRocmVhZHM7IGkrKykgeworCQkvKiBXYWl0IGZvciB0aHJlYWQgZW5k
 ICovCisJCXB0aHJlYWRfam9pbiggdHBbaV0tPnRkX2lkLCBOVUxMKTsKKwkJc2VuZF9jYWxscys9
 dHBbaV0tPnNlbmRfY2FsbHM7CisJCXNlbmRfZXJyb3JzKz10cFtpXS0+c2VuZF9lcnJvcnM7Cisg
 ICAgfQorCiAJcHJpbnRmKCJcbiIpOwotCXByaW50Zigic3RhcnQ6ICAgICAgICAgICAgICV6ZC4l
 MDlsdVxuIiwgc3RhcnR0aW1lLnR2X3NlYywKKwlwcmludGYoInN0YXJ0OiAgICAgICAgICAgICAg
 ICAgICAgICAlemQuJTA5bHVcbiIsIHN0YXJ0dGltZS50dl9zZWMsCiAJICAgIHN0YXJ0dGltZS50
 dl9uc2VjKTsKLQlwcmludGYoImZpbmlzaDogICAgICAgICAgICAlemQuJTA5bHVcbiIsIHRtcHRp
 bWUudHZfc2VjLAorCXByaW50ZigiZmluaXNoOiAgICAgICAgICAgICAgICAgICAgICV6ZC4lMDls
 dVxuIiwgdG1wdGltZS50dl9zZWMsCiAJICAgIHRtcHRpbWUudHZfbnNlYyk7Ci0JcHJpbnRmKCJz
 ZW5kIGNhbGxzOiAgICAgICAgJWRcbiIsIHNlbmRfY2FsbHMpOwotCXByaW50Zigic2VuZCBlcnJv
 cnM6ICAgICAgICVkXG4iLCBzZW5kX2Vycm9ycyk7Ci0JcHJpbnRmKCJhcHByb3ggc2VuZCByYXRl
 OiAgJWxkXG4iLCAoc2VuZF9jYWxscyAtIHNlbmRfZXJyb3JzKSAvCisJcHJpbnRmKCJzZW5kIGNh
 bGxzOiAgICAgICAgICAgICAgICAgJWx1XG4iLCBzZW5kX2NhbGxzKTsKKwlwcmludGYoInNlbmQg
 ZXJyb3JzOiAgICAgICAgICAgICAgICAlbHVcbiIsIHNlbmRfZXJyb3JzKTsKKwlwcmludGYoInNl
 bmQgc3VjY2VzczogICAgICAgICAgICAgICAlbHVcbiIsIHNlbmRfY2FsbHMgLSBzZW5kX2Vycm9y
 cyk7CisJcHJpbnRmKCJhcHByb3ggc2VuZCByYXRlOiAgICAgICAgICAgJWx1XG4iLCAoc2VuZF9j
 YWxscyAtIHNlbmRfZXJyb3JzKSAvCiAJICAgIGR1cmF0aW9uKTsKLQlwcmludGYoImFwcHJveCBl
 cnJvciByYXRlOiAlZFxuIiwgKHNlbmRfZXJyb3JzIC8gc2VuZF9jYWxscykpOwotCi0JcmV0dXJu
 ICgwKTsKKwlwcmludGYoImFwcHJveCBlcnJvciByYXRlOiAgICAgICAgICAlbHVcbiIsIChzZW5k
 X2Vycm9ycyAvIHNlbmRfY2FsbHMpKTsKKwlwcmludGYoImFwcHJveCBFdGhlcm5ldCB0aHJvdWdo
 cHV0OiAiKTsKKwlpZiAoZmFtaWx5ID09IEFGX0lORVQpCisJCXByaW50ZigiJWxkIE1pYi9zXG4i
 LCAoKHNlbmRfY2FsbHMgLSBzZW5kX2Vycm9ycykgLyBkdXJhdGlvbiApICoKKwkJKHBheWxvYWRz
 aXplICsgOCArIDIwICsgMTQgKSAqIDggLyAxMDAwIC8gMTAwMCk7ICAgICAgICAgICAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorCWVsc2Ug
 aWYgKGZhbWlseSA9PSBBRl9JTkVUNikKKwkJcHJpbnRmKCIlbGQgTWliL3NcbiIsICgoc2VuZF9j
 YWxscyAtIHNlbmRfZXJyb3JzKSAvIGR1cmF0aW9uICkgKgorCQkocGF5bG9hZHNpemUgKyA4ICsg
 NDAgKyAxNCApICogOCAvIDEwMDAgLyAxMDAwKTsKKwllbHNlIHByaW50ZigiQ0FOICdUIERFVEVS
 TUlORSBmYW1pbHkgdHlwZSAlaVxuIixmYW1pbHkpOworCXByaW50ZigiYXBwcm94IHBheWxvYWQg
 dGhyb3VnaHB1dDogICVsZCBNaWIvc1xuIiwgKChzZW5kX2NhbGxzIC0gc2VuZF9lcnJvcnMpIC8g
 CisJCWR1cmF0aW9uICkgKiBwYXlsb2Fkc2l6ZSAqIDggLyAxMDAwIC8gMTAwMCk7CiB9CiAKIGlu
 dApAQCAtMTQzLDExICsxODQsMTUgQEAKIHsKIAlsb25nIHBheWxvYWRzaXplLCBkdXJhdGlvbjsK
 IAlzdHJ1Y3QgYWRkcmluZm8gaGludHMsICpyZXMsICpyZXMwOwotCWNoYXIgKmR1bW15LCAqcGFj
 a2V0OwotCWludCBwb3J0LCBzLCBlcnJvcjsKKwljaGFyICpkdW1teTsKKwl1X2NoYXIgKnBhY2tl
 dDsKKwlpbnQgZmFtaWx5LCBwb3J0LCBzLCBlcnJvciwgbnRocmVhZHMgPSAxOworCXN0cnVjdCB0
 ZF9kZXNjICoqdHA7CQogCWNvbnN0IGNoYXIgKmNhdXNlID0gTlVMTDsKKwlzdHJ1Y3QgdGltZXNw
 ZWMgc3RhcnR0aW1lLCB0bXB0aW1lOworCXN0cnVjdCBpdGltZXJ2YWwgaXQ7CiAKLQlpZiAoYXJn
 YyAhPSA1KQorCWlmIChhcmdjIDwgNSkKIAkJdXNhZ2UoKTsKIAogCW1lbXNldCgmaGludHMsIDAs
 IHNpemVvZihoaW50cykpOwpAQCAtMTc3LDYgKzIyMiwxMSBAQAogCQkvKk5PVFJFQUNIRUQqLwog
 CX0KIAorCWlmIChhcmdjID4gNSkKKyAgICAgICAgbnRocmVhZHMgPSBzdHJ0b3VsKGFyZ3ZbNV0s
 ICZkdW1teSwgMTApOworICAgIGlmIChudGhyZWFkcyA8IDEgfHwgbnRocmVhZHMgPiA2NCkKKyAg
 ICAgICAgdXNhZ2UoKTsKKwogCXBhY2tldCA9IG1hbGxvYyhwYXlsb2Fkc2l6ZSk7CiAJaWYgKHBh
 Y2tldCA9PSBOVUxMKSB7CiAJCXBlcnJvcigibWFsbG9jIik7CkBAIC0yMTMsOSArMjYzLDQ2IEBA
 CiAJCXJldHVybiAoLTEpOwogCQkvKk5PVFJFQUNIRUQqLwogCX0KLQorCWZhbWlseT1yZXMtPmFp
 X2ZhbWlseTsKIAlmcmVlYWRkcmluZm8ocmVzMCk7CiAKLQlyZXR1cm4gKGJsYXN0X2xvb3Aocywg
 ZHVyYXRpb24sIHBhY2tldCwgcGF5bG9hZHNpemUpKTsKKwlwcmludGYoIm5ldGJsYXN0ICVkIHRo
 cmVhZHMgc2VuZGluZyBvbiBVRFAgcG9ydCAlZFxuIiwKKyAgICBudGhyZWFkcywgKHVfc2hvcnQp
 cG9ydCk7CisKKwkvKgorCSAqIEJlZ2luIGJ5IHJlY29yZGluZyB0aW1lIGluZm9ybWF0aW9uIHN0
 YXRzLgorCSAqIFNldCB0aGUgaW50ZXJ2YWwgdGltZXIgZm9yIHdoZW4gd2Ugd2FudCB0byB3YWtl
 IHVwLgorCSAqIFNJR0FMUk0gd2lsbCBzZXQgYSBmbGFnIGluZGljYXRpbmcgaXQncyB0aW1lIHRv
 IHN0b3AuICBOb3RlIHRoYXQgdGhlcmUncworCSAqIHNvbWUgb3ZlcmhlYWQgdG8gdGhlIHNpZ25h
 bCBhbmQgdGltZXIgc2V0dXAsIHNvIHRoZSBzbWFsbGVyIHRoZSBkdXJhdGlvbiwKKwkgKiB0aGUg
 aGlnaGVyIHRoZSByZWxhdGl2ZSBvdmVyaGVhZC4KKwkgKi8KKworCWlmIChzaWduYWwoU0lHQUxS
 TSwgc2lnbmFsX2hhbmRsZXIpID09IFNJR19FUlIpIHsKKwkJcGVycm9yKCJzaWduYWwiKTsKKwkJ
 cmV0dXJuICgtMSk7CisJfQorCisJaWYgKGNsb2NrX2dldHJlcyhDTE9DS19SRUFMVElNRSwgJnRt
 cHRpbWUpID09IC0xKSB7CisJCXBlcnJvcigiY2xvY2tfZ2V0cmVzIik7CisJCXJldHVybiAoLTEp
 OworCX0KKworCWlmIChjbG9ja19nZXR0aW1lKENMT0NLX1JFQUxUSU1FLCAmc3RhcnR0aW1lKSA9
 PSAtMSkgeworCQlwZXJyb3IoImNsb2NrX2dldHRpbWUiKTsKKwkJcmV0dXJuICgtMSk7CisJfQor
 CisJaXQuaXRfaW50ZXJ2YWwudHZfc2VjID0gMDsKKwlpdC5pdF9pbnRlcnZhbC50dl91c2VjID0g
 MDsKKwlpdC5pdF92YWx1ZS50dl9zZWMgPSBkdXJhdGlvbjsKKwlpdC5pdF92YWx1ZS50dl91c2Vj
 ID0gMDsKKworCWlmIChzZXRpdGltZXIoSVRJTUVSX1JFQUwsICZpdCwgTlVMTCkgPCAwKSB7CisJ
 CXBlcnJvcigic2V0aXRpbWVyIik7CisJCXJldHVybiAoLTEpOworCX0KKworICAgIHRwID0gbWFr
 ZV90aHJlYWRzKHMsIHBhY2tldCwgcGF5bG9hZHNpemUsIG50aHJlYWRzKTsKKyAgICBtYWluX3Ro
 cmVhZCh0cCwgZHVyYXRpb24sIHN0YXJ0dGltZSwgIHRtcHRpbWUsIHBheWxvYWRzaXplLCBmYW1p
 bHksIG50aHJlYWRzKTsKIAogfQo=
 --089e0153688c167ce704dfb97d89
 Content-Type: text/plain; charset=US-ASCII; 
 	name="freebsd-stable.pthread-netblast.patch.txt"
 Content-Disposition: attachment; 
 	filename="freebsd-stable.pthread-netblast.patch.txt"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_hi8iglmv1
 
 ZGlmZiAtcnVOIHRvb2xzL3Rvb2xzL25ldHJhdGUvbmV0Ymxhc3Qub3JpZy9NYWtlZmlsZSB0b29s
 cy90b29scy9uZXRyYXRlL25ldGJsYXN0L01ha2VmaWxlCi0tLSB0b29scy90b29scy9uZXRyYXRl
 L25ldGJsYXN0Lm9yaWcvTWFrZWZpbGUJMjAxMy0wNi0yMiAwMTo0NDoyNS4wMzUyODg5MzkgKzAy
 MDAKKysrIHRvb2xzL3Rvb2xzL25ldHJhdGUvbmV0Ymxhc3QvTWFrZWZpbGUJMjAxMy0wNi0yMiAw
 MTo0NDowOC41MjIyOTAxODEgKzAyMDAKQEAgLTQsNSArNCw4IEBACiAKIFBST0c9CW5ldGJsYXN0
 CiBOT19NQU49CitMREZMQUdTICs9IC1scHRocmVhZAorCitXQVJOUz89IDMKIAogLmluY2x1ZGUg
 PGJzZC5wcm9nLm1rPgpkaWZmIC1ydU4gdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC5vcmln
 L25ldGJsYXN0LmMgdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC9uZXRibGFzdC5jCi0tLSB0
 b29scy90b29scy9uZXRyYXRlL25ldGJsYXN0Lm9yaWcvbmV0Ymxhc3QuYwkyMDEzLTA2LTIyIDAx
 OjQ0OjI1LjAzNTI4ODkzOSArMDIwMAorKysgdG9vbHMvdG9vbHMvbmV0cmF0ZS9uZXRibGFzdC9u
 ZXRibGFzdC5jCTIwMTMtMDYtMjIgMDE6MDI6NDguMjQyNDYwNjY4ICswMjAwCkBAIC0zMiwyMyAr
 MzIsMzIgQEAKICNpbmNsdWRlIDxzeXMvdGltZS5oPgogCiAjaW5jbHVkZSA8bmV0aW5ldC9pbi5o
 PgotCi0jaW5jbHVkZSA8YXJwYS9pbmV0Lmg+CisjaW5jbHVkZSA8bmV0ZGIuaD4JCQkvKiBnZXRh
 ZGRyaW5mbyAqLwogCiAjaW5jbHVkZSA8c2lnbmFsLmg+CiAjaW5jbHVkZSA8c3RkaW8uaD4KICNp
 bmNsdWRlIDxzdGRsaWIuaD4KICNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDx1bmlzdGQu
 aD4JCQkvKiBjbG9zZSAqLworCisjaW5jbHVkZSA8cHRocmVhZC5oPgorI2luY2x1ZGUgPGZjbnRs
 Lmg+CisjaW5jbHVkZSA8dGltZS5oPiAgIC8qIGNsb2NrX2dldHJlcygpICovCisKK3N0YXRpYyBp
 bnQgcm91bmRfdG8oaW50IG4sIGludCBsKQoreworICAgIHJldHVybiAoKG4gKyBsIC0gMSkvbCkq
 bDsKK30KIAogc3RhdGljIHZvaWQKIHVzYWdlKHZvaWQpCiB7CiAKLQlmcHJpbnRmKHN0ZGVyciwg
 Im5ldGJsYXN0IFtpcF0gW3BvcnRdIFtwYXlsb2Fkc2l6ZV0gW2R1cmF0aW9uXVxuIik7CisJZnBy
 aW50ZihzdGRlcnIsICJuZXRibGFzdCBbaXBdIFtwb3J0XSBbcGF5bG9hZHNpemVdIFtkdXJhdGlv
 bl0gW250aHJlYWRzXVxuIik7CiAJZXhpdCgtMSk7CiB9CiAKLXN0YXRpYyBpbnQJZ2xvYmFsX3N0
 b3BfZmxhZzsKK3N0YXRpYyBpbnQJZ2xvYmFsX3N0b3BfZmxhZz0wOwogCiBzdGF0aWMgdm9pZAog
 c2lnbmFsX2hhbmRsZXIoaW50IHNpZ251bSBfX3VudXNlZCkKQEAgLTU3LDQ4ICs2NiwyOCBAQAog
 CWdsb2JhbF9zdG9wX2ZsYWcgPSAxOwogfQogCisKIC8qCi0gKiBMb29wIHRoYXQgYmxhc3RzIHBh
 Y2tldHM6IGJlZ2luIGJ5IHJlY29yZGluZyB0aW1lIGluZm9ybWF0aW9uLCByZXNldHRpbmcKLSAq
 IHN0YXRzLiAgU2V0IHRoZSBpbnRlcnZhbCB0aW1lciBmb3Igd2hlbiB3ZSB3YW50IHRvIHdha2Ug
 dXAuICBUaGVuIGdvLgotICogU0lHQUxSTSB3aWxsIHNldCBhIGZsYWcgaW5kaWNhdGluZyBpdCdz
 IHRpbWUgdG8gc3RvcC4gIE5vdGUgdGhhdCB0aGVyZSdzCi0gKiBzb21lIG92ZXJoZWFkIHRvIHRo
 ZSBzaWduYWwgYW5kIHRpbWVyIHNldHVwLCBzbyB0aGUgc21hbGxlciB0aGUgZHVyYXRpb24sCi0g
 KiB0aGUgaGlnaGVyIHRoZSByZWxhdGl2ZSBvdmVyaGVhZC4KKyAqIEVhY2ggc29ja2V0IHVzZXMg
 bXVsdGlwbGUgdGhyZWFkcyBzbyB0aGUgZ2VuZXJhdG9yIGlzCisgKiBtb3JlIGVmZmljaWVudC4g
 QSBjb2xsZWN0b3IgdGhyZWFkIHJ1bnMgdGhlIHN0YXRzLgogICovCi1zdGF0aWMgaW50Ci1ibGFz
 dF9sb29wKGludCBzLCBsb25nIGR1cmF0aW9uLCB1X2NoYXIgKnBhY2tldCwgdV9pbnQgcGFja2V0
 X2xlbikKLXsKLQlzdHJ1Y3QgdGltZXNwZWMgc3RhcnR0aW1lLCB0bXB0aW1lOwotCXN0cnVjdCBp
 dGltZXJ2YWwgaXQ7Ci0JdV9pbnQzMl90IGNvdW50ZXI7Ci0JaW50IHNlbmRfZXJyb3JzLCBzZW5k
 X2NhbGxzOwotCi0JaWYgKHNpZ25hbChTSUdBTFJNLCBzaWduYWxfaGFuZGxlcikgPT0gU0lHX0VS
 UikgewotCQlwZXJyb3IoInNpZ25hbCIpOwotCQlyZXR1cm4gKC0xKTsKLQl9Ci0KLQlpZiAoY2xv
 Y2tfZ2V0cmVzKENMT0NLX1JFQUxUSU1FLCAmdG1wdGltZSkgPT0gLTEpIHsKLQkJcGVycm9yKCJj
 bG9ja19nZXRyZXMiKTsKLQkJcmV0dXJuICgtMSk7Ci0JfQotCi0JaWYgKGNsb2NrX2dldHRpbWUo
 Q0xPQ0tfUkVBTFRJTUUsICZzdGFydHRpbWUpID09IC0xKSB7Ci0JCXBlcnJvcigiY2xvY2tfZ2V0
 dGltZSIpOwotCQlyZXR1cm4gKC0xKTsKLQl9Ci0KLQlpdC5pdF9pbnRlcnZhbC50dl9zZWMgPSAw
 OwotCWl0Lml0X2ludGVydmFsLnR2X3VzZWMgPSAwOwotCWl0Lml0X3ZhbHVlLnR2X3NlYyA9IGR1
 cmF0aW9uOwotCWl0Lml0X3ZhbHVlLnR2X3VzZWMgPSAwOwotCi0JaWYgKHNldGl0aW1lcihJVElN
 RVJfUkVBTCwgJml0LCBOVUxMKSA8IDApIHsKLQkJcGVycm9yKCJzZXRpdGltZXIiKTsKLQkJcmV0
 dXJuICgtMSk7Ci0JfQorc3RydWN0IHRkX2Rlc2MgeworCXB0aHJlYWRfdCB0ZF9pZDsKKwl1aW50
 NjRfdCBjb3VudGVyOyAvKiB0eCBjb3VudGVyICovCisJdWludDY0X3Qgc2VuZF9lcnJvcnM7IC8q
 IHR4IHNlbmQgZXJyb3JzICovCisJdWludDY0X3Qgc2VuZF9jYWxsczsgICAgLyogdHggc2VuZCBj
 YWxscyAqLworCWludCBzOworCXVfY2hhciAqcGFja2V0OworCXVfaW50IHBhY2tldF9sZW47Cit9
 OwogCi0Jc2VuZF9lcnJvcnMgPSBzZW5kX2NhbGxzID0gMDsKLQljb3VudGVyID0gMDsKK3N0YXRp
 YyB2b2lkICoKK2JsYXN0KHZvaWQgKmRhdGEpCit7CisgICAgc3RydWN0IHRkX2Rlc2MgKnQgPSBk
 YXRhOworCXQtPmNvdW50ZXI9MDsKKwl0LT5zZW5kX2Vycm9ycz0wOworCXQtPnNlbmRfY2FsbHM9
 MDsKIAl3aGlsZSAoZ2xvYmFsX3N0b3BfZmxhZyA9PSAwKSB7CiAJCS8qCiAJCSAqIFdlIG1haW50
 YWluIGFuZCwgaWYgdGhlcmUncyByb29tLCBzZW5kIGEgY291bnRlci4gIE5vdGUKQEAgLTExMCw1
 NyArOTksMTEyIEBACiAJCSAqIG9wZXJhdGlvbiwgY2F1c2luZyB0aGUgY3VycmVudCBzZXF1ZW5j
 ZSBudW1iZXIgYWxzbyB0byBiZQogCQkgKiBza2lwcGVkLgogCQkgKi8KLQkJaWYgKHBhY2tldF9s
 ZW4gPj0gNCkgewotCQkJYmUzMmVuYyhwYWNrZXQsIGNvdW50ZXIpOwotCQkJY291bnRlcisrOwor
 CQlpZiAodC0+cGFja2V0X2xlbiA+PSA0KSB7CisJCQliZTMyZW5jKHQtPnBhY2tldCwgdC0+Y291
 bnRlcik7CisJCQl0LT5jb3VudGVyKys7CiAJCX0KLQkJaWYgKHNlbmQocywgcGFja2V0LCBwYWNr
 ZXRfbGVuLCAwKSA8IDApCi0JCQlzZW5kX2Vycm9ycysrOwotCQlzZW5kX2NhbGxzKys7CisJCWlm
 IChzZW5kKHQtPnMsIHQtPnBhY2tldCwgdC0+cGFja2V0X2xlbiwgMCkgPCAwKQorCQkJdC0+c2Vu
 ZF9lcnJvcnMrKzsKKwkJdC0+c2VuZF9jYWxscysrOwogCX0KKyAgICByZXR1cm4gTlVMTDsKK30K
 Kworc3RhdGljIHN0cnVjdCB0ZF9kZXNjICoqCittYWtlX3RocmVhZHMoaW50IHMsIHVfY2hhciAq
 cGFja2V0LCB1X2ludCBwYWNrZXRfbGVuLCBpbnQgbnRocmVhZHMpCit7CisgICAgaW50IGk7Cisg
 ICAgaW50IGxiID0gcm91bmRfdG8obnRocmVhZHMgKiBzaXplb2YgKHN0cnVjdCB0ZF9kZXNjICop
 LCA2NCk7CisgICAgaW50IHRkX2xlbiA9IHJvdW5kX3RvKHNpemVvZihzdHJ1Y3QgdGRfZGVzYyks
 IDY0KTsgLy8gY2FjaGUgYWxpZ24KKyAgICBjaGFyICptID0gY2FsbG9jKDEsIGxiICsgdGRfbGVu
 ICogbnRocmVhZHMpOworICAgIHN0cnVjdCB0ZF9kZXNjICoqdHA7CisKKyAgICAvKiBwb2ludGVy
 cyBwbHVzIHRoZSBzdHJ1Y3RzICovCisgICAgaWYgKG0gPT0gTlVMTCkgeworICAgICAgICBwZXJy
 b3IoIm5vIHJvb20gZm9yIHBvaW50ZXJzISIpOworICAgICAgICBleGl0KDEpOworICAgIH0KKyAg
 ICB0cCA9IChzdHJ1Y3QgdGRfZGVzYyAqKiltOworICAgIG0gKz0gbGI7ICAgIC8qIHNraXAgdGhl
 IHBvaW50ZXJzICovCisgICAgZm9yIChpID0gMDsgaSA8IG50aHJlYWRzOyBpKyssIG0gKz0gdGRf
 bGVuKSB7CisgICAgICAgIHRwW2ldID0gKHN0cnVjdCB0ZF9kZXNjICopbTsKKyAgICAgICAgdHBb
 aV0tPnMgPSBzOworICAgICAgICB0cFtpXS0+cGFja2V0ID0gcGFja2V0OworICAgICAgICB0cFtp
 XS0+cGFja2V0X2xlbiA9IHBhY2tldF9sZW47CisgICAgICAgIGlmIChwdGhyZWFkX2NyZWF0ZSgm
 dHBbaV0tPnRkX2lkLCBOVUxMLCBibGFzdCwgdHBbaV0pKSB7CisgICAgICAgICAgICBwZXJyb3Io
 InVuYWJsZSB0byBjcmVhdGUgdGhyZWFkIik7CisgICAgICAgICAgICBleGl0KDEpOworICAgICAg
 ICB9CisgICAgfQorICAgIHJldHVybiB0cDsKK30KKwogCitzdGF0aWMgdm9pZAorbWFpbl90aHJl
 YWQoc3RydWN0IHRkX2Rlc2MgKip0cCwgbG9uZyBkdXJhdGlvbiwgc3RydWN0IHRpbWVzcGVjIHN0
 YXJ0dGltZSwgc3RydWN0IHRpbWVzcGVjIHRtcHRpbWUsIGxvbmcgcGF5bG9hZHNpemUsIGludCBm
 YW1pbHksIGludCBudGhyZWFkcykKK3sKKwl1aW50NjRfdCBzZW5kX2Vycm9ycz0wLCBzZW5kX2Nh
 bGxzPTA7CisJaW50IGk7CiAJaWYgKGNsb2NrX2dldHRpbWUoQ0xPQ0tfUkVBTFRJTUUsICZ0bXB0
 aW1lKSA9PSAtMSkgewogCQlwZXJyb3IoImNsb2NrX2dldHRpbWUiKTsKLQkJcmV0dXJuICgtMSk7
 CiAJfQogCisJZm9yIChpID0gMDsgaSA8IG50aHJlYWRzOyBpKyspIHsKKwkJLyogV2FpdCBmb3Ig
 dGhyZWFkIGVuZCAqLworCQlwdGhyZWFkX2pvaW4oIHRwW2ldLT50ZF9pZCwgTlVMTCk7CisJCXNl
 bmRfY2FsbHMrPXRwW2ldLT5zZW5kX2NhbGxzOworCQlzZW5kX2Vycm9ycys9dHBbaV0tPnNlbmRf
 ZXJyb3JzOworICAgIH0KKwogCXByaW50ZigiXG4iKTsKLQlwcmludGYoInN0YXJ0OiAgICAgICAg
 ICAgICAlemQuJTA5bHVcbiIsIHN0YXJ0dGltZS50dl9zZWMsCisJcHJpbnRmKCJzdGFydDogICAg
 ICAgICAgICAgICAgICAgICAgJXpkLiUwOWx1XG4iLCBzdGFydHRpbWUudHZfc2VjLAogCSAgICBz
 dGFydHRpbWUudHZfbnNlYyk7Ci0JcHJpbnRmKCJmaW5pc2g6ICAgICAgICAgICAgJXpkLiUwOWx1
 XG4iLCB0bXB0aW1lLnR2X3NlYywKKwlwcmludGYoImZpbmlzaDogICAgICAgICAgICAgICAgICAg
 ICAlemQuJTA5bHVcbiIsIHRtcHRpbWUudHZfc2VjLAogCSAgICB0bXB0aW1lLnR2X25zZWMpOwot
 CXByaW50Zigic2VuZCBjYWxsczogICAgICAgICVkXG4iLCBzZW5kX2NhbGxzKTsKLQlwcmludGYo
 InNlbmQgZXJyb3JzOiAgICAgICAlZFxuIiwgc2VuZF9lcnJvcnMpOwotCXByaW50ZigiYXBwcm94
 IHNlbmQgcmF0ZTogICVsZFxuIiwgKHNlbmRfY2FsbHMgLSBzZW5kX2Vycm9ycykgLworCXByaW50
 Zigic2VuZCBjYWxsczogICAgICAgICAgICAgICAgICVsdVxuIiwgc2VuZF9jYWxscyk7CisJcHJp
 bnRmKCJzZW5kIGVycm9yczogICAgICAgICAgICAgICAgJWx1XG4iLCBzZW5kX2Vycm9ycyk7CisJ
 cHJpbnRmKCJzZW5kIHN1Y2Nlc3M6ICAgICAgICAgICAgICAgJWx1XG4iLCBzZW5kX2NhbGxzIC0g
 c2VuZF9lcnJvcnMpOworCXByaW50ZigiYXBwcm94IHNlbmQgcmF0ZTogICAgICAgICAgICVsdVxu
 IiwgKHNlbmRfY2FsbHMgLSBzZW5kX2Vycm9ycykgLwogCSAgICBkdXJhdGlvbik7Ci0JcHJpbnRm
 KCJhcHByb3ggZXJyb3IgcmF0ZTogJWRcbiIsIChzZW5kX2Vycm9ycyAvIHNlbmRfY2FsbHMpKTsK
 LQotCXJldHVybiAoMCk7CisJcHJpbnRmKCJhcHByb3ggZXJyb3IgcmF0ZTogICAgICAgICAgJWx1
 XG4iLCAoc2VuZF9lcnJvcnMgLyBzZW5kX2NhbGxzKSk7CisJcHJpbnRmKCJhcHByb3ggRXRoZXJu
 ZXQgdGhyb3VnaHB1dDogIik7CisJaWYgKGZhbWlseSA9PSBBRl9JTkVUKQorCQlwcmludGYoIiVs
 ZCBNaWIvc1xuIiwgKChzZW5kX2NhbGxzIC0gc2VuZF9lcnJvcnMpIC8gZHVyYXRpb24gKSAqCisJ
 CShwYXlsb2Fkc2l6ZSArIDggKyAyMCArIDE0ICkgKiA4IC8gMTAwMCAvIDEwMDApOyAgICAgICAg
 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
 ICAKKwllbHNlIGlmIChmYW1pbHkgPT0gQUZfSU5FVDYpCisJCXByaW50ZigiJWxkIE1pYi9zXG4i
 LCAoKHNlbmRfY2FsbHMgLSBzZW5kX2Vycm9ycykgLyBkdXJhdGlvbiApICoKKwkJKHBheWxvYWRz
 aXplICsgOCArIDQwICsgMTQgKSAqIDggLyAxMDAwIC8gMTAwMCk7CisJZWxzZSBwcmludGYoIkNB
 TiAnVCBERVRFUk1JTkUgZmFtaWx5IHR5cGUgJWlcbiIsZmFtaWx5KTsKKwlwcmludGYoImFwcHJv
 eCBwYXlsb2FkIHRocm91Z2hwdXQ6ICAlbGQgTWliL3NcbiIsICgoc2VuZF9jYWxscyAtIHNlbmRf
 ZXJyb3JzKSAvIAorCQlkdXJhdGlvbiApICogcGF5bG9hZHNpemUgKiA4IC8gMTAwMCAvIDEwMDAp
 OwogfQogCiBpbnQKIG1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKLQlsb25nIHBheWxv
 YWRzaXplLCBwb3J0LCBkdXJhdGlvbjsKLQlzdHJ1Y3Qgc29ja2FkZHJfaW4gc2luOwotCWNoYXIg
 KmR1bW15LCAqcGFja2V0OwotCWludCBzOworCWxvbmcgcGF5bG9hZHNpemUsIGR1cmF0aW9uOwor
 CXN0cnVjdCBhZGRyaW5mbyBoaW50cywgKnJlcywgKnJlczA7CisJY2hhciAqZHVtbXk7CisJdV9j
 aGFyICpwYWNrZXQ7CisJaW50IGZhbWlseSwgcG9ydCwgcywgZXJyb3IsIG50aHJlYWRzID0gMTsK
 KwlzdHJ1Y3QgdGRfZGVzYyAqKnRwOwkKKwljb25zdCBjaGFyICpjYXVzZSA9IE5VTEw7CisJc3Ry
 dWN0IHRpbWVzcGVjIHN0YXJ0dGltZSwgdG1wdGltZTsKKwlzdHJ1Y3QgaXRpbWVydmFsIGl0Owog
 Ci0JaWYgKGFyZ2MgIT0gNSkKKwlpZiAoYXJnYyA8IDUpCiAJCXVzYWdlKCk7CiAKLQliemVybygm
 c2luLCBzaXplb2Yoc2luKSk7Ci0Jc2luLnNpbl9sZW4gPSBzaXplb2Yoc2luKTsKLQlzaW4uc2lu
 X2ZhbWlseSA9IEFGX0lORVQ7Ci0JaWYgKGluZXRfYXRvbihhcmd2WzFdLCAmc2luLnNpbl9hZGRy
 KSA9PSAwKSB7Ci0JCXBlcnJvcihhcmd2WzFdKTsKLQkJcmV0dXJuICgtMSk7Ci0JfQorCW1lbXNl
 dCgmaGludHMsIDAsIHNpemVvZihoaW50cykpOworCWhpbnRzLmFpX2ZhbWlseSA9IFBGX1VOU1BF
 QzsKKwloaW50cy5haV9zb2NrdHlwZSA9IFNPQ0tfREdSQU07CiAKIAlwb3J0ID0gc3RydG91bChh
 cmd2WzJdLCAmZHVtbXksIDEwKTsKLQlpZiAocG9ydCA8IDEgfHwgcG9ydCA+IDY1NTM1IHx8ICpk
 dW1teSAhPSAnXDAnKQorCWlmIChwb3J0IDwgMSB8fCBwb3J0ID4gNjU1MzUgfHwgKmR1bW15ICE9
 ICdcMCcpIHsKKwkJZnByaW50ZihzdGRlcnIsICJJbnZhbGlkIHBvcnQgbnVtYmVyOiAlc1xuIiwg
 YXJndlsyXSk7CiAJCXVzYWdlKCk7Ci0Jc2luLnNpbl9wb3J0ID0gaHRvbnMocG9ydCk7CisJCS8q
 Tk9UUkVBQ0hFRCovCisJfQogCiAJcGF5bG9hZHNpemUgPSBzdHJ0b3VsKGFyZ3ZbM10sICZkdW1t
 eSwgMTApOwogCWlmIChwYXlsb2Fkc2l6ZSA8IDAgfHwgKmR1bW15ICE9ICdcMCcpCkBAIC0xNjgs
 MjkgKzIxMiw5NyBAQAogCWlmIChwYXlsb2Fkc2l6ZSA+IDMyNzY4KSB7CiAJCWZwcmludGYoc3Rk
 ZXJyLCAicGF5bG9hZHNpemUgPiAzMjc2OFxuIik7CiAJCXJldHVybiAoLTEpOworCQkvKk5PVFJF
 QUNIRUQqLwogCX0KIAogCWR1cmF0aW9uID0gc3RydG91bChhcmd2WzRdLCAmZHVtbXksIDEwKTsK
 LQlpZiAoZHVyYXRpb24gPCAwIHx8ICpkdW1teSAhPSAnXDAnKQorCWlmIChkdXJhdGlvbiA8IDAg
 fHwgKmR1bW15ICE9ICdcMCcpIHsKKwkJZnByaW50ZihzdGRlcnIsICJJbnZhbGlkIGR1cmF0aW9u
 IHRpbWU6ICVzXG4iLCBhcmd2WzRdKTsKIAkJdXNhZ2UoKTsKKwkJLypOT1RSRUFDSEVEKi8KKwl9
 CisKKwlpZiAoYXJnYyA+IDUpCisgICAgICAgIG50aHJlYWRzID0gc3RydG91bChhcmd2WzVdLCAm
 ZHVtbXksIDEwKTsKKyAgICBpZiAobnRocmVhZHMgPCAxIHx8IG50aHJlYWRzID4gNjQpCisgICAg
 ICAgIHVzYWdlKCk7CiAKIAlwYWNrZXQgPSBtYWxsb2MocGF5bG9hZHNpemUpOwogCWlmIChwYWNr
 ZXQgPT0gTlVMTCkgewogCQlwZXJyb3IoIm1hbGxvYyIpOwogCQlyZXR1cm4gKC0xKTsKKwkJLypO
 T1RSRUFDSEVEKi8KIAl9CisKIAliemVybyhwYWNrZXQsIHBheWxvYWRzaXplKTsKKwllcnJvciA9
 IGdldGFkZHJpbmZvKGFyZ3ZbMV0sYXJndlsyXSwgJmhpbnRzLCAmcmVzMCk7CisJaWYgKGVycm9y
 KSB7CisJCXBlcnJvcihnYWlfc3RyZXJyb3IoZXJyb3IpKTsKKwkJcmV0dXJuICgtMSk7CisJCS8q
 Tk9UUkVBQ0hFRCovCisJfQorCXMgPSAtMTsKKwlmb3IgKHJlcyA9IHJlczA7IHJlczsgcmVzID0g
 cmVzLT5haV9uZXh0KSB7CisJCXMgPSBzb2NrZXQocmVzLT5haV9mYW1pbHksIHJlcy0+YWlfc29j
 a3R5cGUsIDApOworCQlpZiAocyA8IDApIHsKKwkJCWNhdXNlID0gInNvY2tldCI7CisJCQljb250
 aW51ZTsKKwkJfQorCisJCWlmIChjb25uZWN0KHMsIHJlcy0+YWlfYWRkciwgcmVzLT5haV9hZGRy
 bGVuKSA8IDApIHsKKwkJCWNhdXNlID0gImNvbm5lY3QiOworCQkJY2xvc2Uocyk7CisJCQlzID0g
 LTE7CisJCQljb250aW51ZTsKKwkJfQogCi0JcyA9IHNvY2tldChQRl9JTkVULCBTT0NLX0RHUkFN
 LCAwKTsKLQlpZiAocyA9PSAtMSkgewotCQlwZXJyb3IoInNvY2tldCIpOworCQlicmVhazsgIC8q
 IG9rYXkgd2UgZ290IG9uZSAqLworCX0KKwlpZiAocyA8IDApIHsKKwkJcGVycm9yKGNhdXNlKTsK
 IAkJcmV0dXJuICgtMSk7CisJCS8qTk9UUkVBQ0hFRCovCiAJfQorCWZhbWlseT1yZXMtPmFpX2Zh
 bWlseTsKKwlmcmVlYWRkcmluZm8ocmVzMCk7CisKKwlwcmludGYoIm5ldGJsYXN0ICVkIHRocmVh
 ZHMgc2VuZGluZyBvbiBVRFAgcG9ydCAlZFxuIiwKKyAgICBudGhyZWFkcywgKHVfc2hvcnQpcG9y
 dCk7CisKKwkvKgorCSAqIEJlZ2luIGJ5IHJlY29yZGluZyB0aW1lIGluZm9ybWF0aW9uIHN0YXRz
 LgorCSAqIFNldCB0aGUgaW50ZXJ2YWwgdGltZXIgZm9yIHdoZW4gd2Ugd2FudCB0byB3YWtlIHVw
 LgorCSAqIFNJR0FMUk0gd2lsbCBzZXQgYSBmbGFnIGluZGljYXRpbmcgaXQncyB0aW1lIHRvIHN0
 b3AuICBOb3RlIHRoYXQgdGhlcmUncworCSAqIHNvbWUgb3ZlcmhlYWQgdG8gdGhlIHNpZ25hbCBh
 bmQgdGltZXIgc2V0dXAsIHNvIHRoZSBzbWFsbGVyIHRoZSBkdXJhdGlvbiwKKwkgKiB0aGUgaGln
 aGVyIHRoZSByZWxhdGl2ZSBvdmVyaGVhZC4KKwkgKi8KIAotCWlmIChjb25uZWN0KHMsIChzdHJ1
 Y3Qgc29ja2FkZHIgKikmc2luLCBzaXplb2Yoc2luKSkgPCAwKSB7Ci0JCXBlcnJvcigiY29ubmVj
 dCIpOworCWlmIChzaWduYWwoU0lHQUxSTSwgc2lnbmFsX2hhbmRsZXIpID09IFNJR19FUlIpIHsK
 KwkJcGVycm9yKCJzaWduYWwiKTsKIAkJcmV0dXJuICgtMSk7CiAJfQogCi0JcmV0dXJuIChibGFz
 dF9sb29wKHMsIGR1cmF0aW9uLCBwYWNrZXQsIHBheWxvYWRzaXplKSk7CisJaWYgKGNsb2NrX2dl
 dHJlcyhDTE9DS19SRUFMVElNRSwgJnRtcHRpbWUpID09IC0xKSB7CisJCXBlcnJvcigiY2xvY2tf
 Z2V0cmVzIik7CisJCXJldHVybiAoLTEpOworCX0KKworCWlmIChjbG9ja19nZXR0aW1lKENMT0NL
 X1JFQUxUSU1FLCAmc3RhcnR0aW1lKSA9PSAtMSkgeworCQlwZXJyb3IoImNsb2NrX2dldHRpbWUi
 KTsKKwkJcmV0dXJuICgtMSk7CisJfQorCisJaXQuaXRfaW50ZXJ2YWwudHZfc2VjID0gMDsKKwlp
 dC5pdF9pbnRlcnZhbC50dl91c2VjID0gMDsKKwlpdC5pdF92YWx1ZS50dl9zZWMgPSBkdXJhdGlv
 bjsKKwlpdC5pdF92YWx1ZS50dl91c2VjID0gMDsKKworCWlmIChzZXRpdGltZXIoSVRJTUVSX1JF
 QUwsICZpdCwgTlVMTCkgPCAwKSB7CisJCXBlcnJvcigic2V0aXRpbWVyIik7CisJCXJldHVybiAo
 LTEpOworCX0KKworICAgIHRwID0gbWFrZV90aHJlYWRzKHMsIHBhY2tldCwgcGF5bG9hZHNpemUs
 IG50aHJlYWRzKTsKKyAgICBtYWluX3RocmVhZCh0cCwgZHVyYXRpb24sIHN0YXJ0dGltZSwgIHRt
 cHRpbWUsIHBheWxvYWRzaXplLCBmYW1pbHksIG50aHJlYWRzKTsKKwogfQo=
 --089e0153688c167ce704dfb97d89--
>Unformatted:
