Date: Wed, 4 Sep 2013 17:04:23 +0900 From: Takuya ASADA <syuu@dokukino.com> To: Luigi Rizzo <rizzo@iet.unipi.it> Cc: FreeBSD Net <freebsd-net@freebsd.org> Subject: Re: Multiqueue support for bpf Message-ID: <CALG4x-UVgT9aXSBzrjDxeCD-f6Yo_TBeRsqjXapz2iyr_=tCLw@mail.gmail.com> In-Reply-To: <CA%2BhQ2%2Bi_qu7RouPW%2Bihfb5nL_1SQWMpFxTpoHfhaCvhtS8-EHQ@mail.gmail.com> References: <CALG4x-V-OLoqMXQarSNy5Lv3kNVu01AiN4A49Nv7t-Ysfr1DBg@mail.gmail.com> <CA%2BhQ2%2BgwW6FOQS79xmWVLSWWHrZMFnhaUM98Kp6aDVaUePNfTA@mail.gmail.com> <CALG4x-UYBFsMttpZx1-c_wtVf5MST8%2B_t1psY2HQskTiOZDFLA@mail.gmail.com> <CA%2BhQ2%2Bi_qu7RouPW%2Bihfb5nL_1SQWMpFxTpoHfhaCvhtS8-EHQ@mail.gmail.com>
next in thread | previous in thread | raw e-mail | index | archive | help
--047d7b6d82dc41494f04e58a43ab Content-Type: text/plain; charset=UTF-8 Hi, This is 2nd version of multiqueue bpf patch, I think I fixed things what you commented on previous mail. Here's a change list of the patch: - Drop added functions on struct ifnet(if_get_[rt]xqueue_len/if_get_[rt]xqueue_affinity). HW queue number and queue affinity informations are maybe useful for some applications, but it's not really directly related to multiqueue bpf. I think we should discuss them separately. - Use BITSET for queue mask. It seems better to use BITSET for queue mask structure, instead of boolean array. - Drop tcpdump/libpcap changes. It also should discuss separately. - M_QUEUEID/IFCAP_QUEUEID M_QUEUEID is the flag for mbuf which contains hw queue id. IFCAP_QUEUEID is the flag which means the driver has ability to set queue id on mbuf. 2013/7/3 Luigi Rizzo <rizzo@iet.unipi.it> > > > > On Tue, Jul 2, 2013 at 5:56 PM, Takuya ASADA <syuu@dokukino.com> wrote: > >> Hi, >> >> Do you have an updated URL for the diffs ? The link below from your >>> original message >>> seems not working now (NXDOMAIN) >>> >>> http://www.dokukino.com/mq_bpf_20110813.diff >>> >> >> Changes with recent head is on my repository: >> http://svnweb.freebsd.org/base/user/syuu/mq_bpf/ >> And I attached a diff file on this mail. >> >> > thanks for the diffs (the URL to the repo is useful too, > but a URL to generate diffs is more convenient for reviewing changes). > > I believe it still needs a bit of work before being merged. > > My comments (in order of the patch): > > === ifnet.9 (and related code in if.c, sockio.h) === > - if_get_rxqueue_len()/if_get_rxqueue_len() is not a good name, > as to me at least it suggests that it returns the size of the > individual queue, rather than the number of queues. > > - cpu affinity (in userspace) is a bitmask, whereas in the BSD kernel > we almost never use the term "affinity", and favour "couid" or "oncpu" > (i.e. an individual CPU id). > I think you should either rename if_get_txqueue_affinity(), or make > the return type a cpuset (which seems more sensible as the return > value is passed to userspace) > > === bpf.4 (and related code) === > > - the ioctl() to attach/detach/report queues attached to a specific > bpf descriptor talk about "mask bit" but neither the internal nor > the external implementation deal with bits. > I'd rather document those ioctl as "attaching queue to file descriptor". > > - the BPF ioctl names are generally inconsistent (using either S or SET > and G or GET for the setter and getter methods). > But you should pick one of the patterns and stick with it, > not introduce a third variant (GT/ST). > Given we are in 2013 we might go for the long form GET and SET > so i suggest the following (spaces for clarity) > > +#define BIOC ENA QMASK _IO('B', 133) > +#define BIOC DIS QMASK _IO('B', 134) > +#define BIOC SET RXQMASK _IOWR('B', 135, uint32_t) > +#define BIOC CLR RXQMASK _IOWR('B', 136, uint32_t) > +#define BIOC GET RXQMASK _IOR('B', 137, uint32_t) > +#define BIOC SET TXQMASK _IOWR('B', 138, uint32_t) > +#define BIOC CLR TXQMASK _IOWR('B', 139, uint32_t) > +#define BIOC GET TXQMASK _IOR('B', 140, uint32_t) > +#define BIOC SET OTHERMASK _IO('B', 141) > +#define BIOC CLR OTHERMASK _IO('B', 142) > +#define BIOC GET OTHERMASK _IOR('B', 143, uint32_t) > > Also related: the existing ioctls() use u_int as argumnts, rather > than uint32_t. I personally prefer the uint32_t form, but you > should at least add a comment to indicate that the choice is > deliberate. > > === if.c === > > > - you have a KASSERT to report if ifp->if_get_*xqueue_affinity() is not > set, but i'd rather run the function only if is set, so you can > have a multiqueue interface which does not bind queues to specific cores > (which i am not sure is always a great idea; too many processes > statically bound to the same queue mean you lose opportunity to > parallelize work.) > > === mbuf.h === > > as mentioned earlier, the modification to struct mbuf should > be avoided if possible at all. It seems that you need just one > direction bit (which maybe is available already from the context) > and one queue identifier, which in the rx path, at least in your > implementation is always a replica of the 'flowid' field. > Can you see if perhaps the flowid field can be (ab)used on the > tx path as well ? > > > === if.h === > > - in if.h, can you use individual variables instead of arrays > for ifr_queue_affinity_index and friends ? > The macros to map the fields of ifr_ifru one > level up are a necessary evil, > but there is no point in using the arrays. > > - SIOCGIFTXQAFFINITY seems to use the receive function (copy&paste typo) > talks about > Also, this function is probably something that should be coordinated > with work on generic multiqueue support > > > === bpf.c === > > - in linux (and hopefully in FreeBSD at some point) the number of queues > can be changed at runtime. > So i suggest that you cache the current number of queues when > you allocate the arrays (qm_*xq_qmask[] ) rather than invoking > ifp->if_get_*xqueue_len() everytime you need to do a boundary check. > This will save us from all sort of problems later. > > - in terms of code, the six BIOC*XQMASK are very similar, you are probably > better off having one single case in the switch > > - can you some comments in the code for the chunk at @@ -2117,6 +2391,42 @@ > I do not completely understand why you are returning if the *queue tag > in the mbuf is out of range (my impression is that you should > just continue, or if you think the packet is incorrect it should > be filtered out before entering the LIST_FOREACH() ). > Secondly, you should use the cached value of *queue_len > > > > cheers > luigi > > > -- > -----------------------------------------+------------------------------- > Prof. Luigi RIZZO, rizzo@iet.unipi.it . Dip. di Ing. dell'Informazione > http://www.iet.unipi.it/~luigi/ . Universita` di Pisa > TEL +39-050-2211611 . via Diotisalvi 2 > Mobile +39-338-6809875 . 56122 PISA (Italy) > > -----------------------------------------+------------------------------- > > --047d7b6d82dc41494f04e58a43ab Content-Type: application/octet-stream; name="mq_bpf_201309041611.diff" Content-Disposition: attachment; filename="mq_bpf_201309041611.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hl691xcn0 SW5kZXg6IHNoYXJlL21hbi9tYW40L2JwZi40Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHNoYXJlL21hbi9tYW40 L2JwZi40CSguLi4vaGVhZCkJKHJldmlzaW9uIDI1NTE4MCkKKysrIHNoYXJlL21hbi9tYW40L2Jw Zi40CSguLi4vdXNlci9zeXV1L21xX2JwZikJKHJldmlzaW9uIDI1NTIwMCkKQEAgLTYzMSw2ICs2 MzEsMzYgQEAKIC5WdCBiemhfa2VybmVsX2dlbgogYWdhaW5zdAogLlZ0IGJ6aF91c2VyX2dlbiAu CisuSXQgRHYgQklPQ1FNQVNLRU5BQkxFCitFbmFibGVzIG11bHRpcXVldWUgZmlsdGVyIG9uIHRo ZSBkZXNjcmlwdG9yLgorCisuSXQgRHYgQklPQ1FNQVNLRElTQUJMRQorRGlzYWJsZXMgbXVsdGlx dWV1ZSBmaWx0ZXIgb24gdGhlIGRlc2NyaXB0b3IuCisKKy5JdCBEdiBCSU9DR1JYUU1BU0sKKy5Q cSBMaSBzdHJ1Y3QgYnBmX3FtYXNrX2JpdHMKK1NldCBSWCBxdWV1ZSBtYXNrIGJpdHMuCisKKy5J dCBEdiBCSU9DU1JYUU1BU0sKKy5QcSBMaSBzdHJ1Y3QgYnBmX3FtYXNrX2JpdHMKK0dldCBSWCBx dWV1ZSBtYXNrIGJpdHMuCisKKy5JdCBEdiBCSU9DR1RYUU1BU0sKKy5QcSBMaSBzdHJ1Y3QgYnBm X3FtYXNrX2JpdHMKK1NldCBUWCBxdWV1ZSBtYXNrIGJpdHMuCisKKy5JdCBEdiBCSU9DU1RYUU1B U0sKKy5QcSBMaSBzdHJ1Y3QgYnBmX3FtYXNrX2JpdHMKK0dldCBUWCBxdWV1ZSBtYXNrIGJpdHMu CisKKy5JdCBEdiBCSU9DR05PUU1BU0sKKy5QcSBMaSBpbnQKK1NldCBtYXNrIGJpdCBmb3IgdGhl IHBhY2tldHMgd2hpY2ggbm90IHRpZWQgd2l0aCBhbnkgcXVldWVzLgorCisuSXQgRHYgQklPQ1NO T1FNQVNLCisuUHEgTGkgaW50CitHZXQgbWFzayBiaXQgZm9yIHRoZSBwYWNrZXRzIHdoaWNoIG5v dCB0aWVkIHdpdGggYW55IHF1ZXVlcy4KKwogLkVsCiAuU2ggQlBGIEhFQURFUgogT25lIG9mIHRo ZSBmb2xsb3dpbmcgc3RydWN0dXJlcyBpcyBwcmVwZW5kZWQgdG8gZWFjaCBwYWNrZXQgcmV0dXJu ZWQgYnkKQEAgLTEwMzcsNiArMTA2NywyMyBAQAogCUJQRl9TVE1UKEJQRl9SRVQrQlBGX0ssIDAp LAogfTsKIC5FZAorLlNoIE1VTFRJUVVFVUUgU1VQUE9SVAorTXVsdGlxdWV1ZSBuZXR3b3JrIGlu dGVyZmFjZSBzdXBwb3J0IGZ1bmN0aW9uIHByb3ZpZGVzIGludGVyZmFjZXMgZm9yIAorbXVsdGl0 aHJlYWRlZCBwYWNrZXQgcHJvY2Vzc2luZyB1c2luZyBicGYuCisKK05vcm1hbCBicGYgY2FuIHJl Y2VpdmUgcGFja2V0cyBmcm9tIHNwZWNpZmllZCBpbnRlcmZhY2UsIG11bHRpcXVldWUgc3VwcG9y dCAKK2Z1bmN0aW9uIGNhbiByZWNlaXZlIHBhY2tldHMgZnJvbSBzcGVjaWZpZWQgaGFyZHdhcmUg cXVldWUuCisKK1RoaXMgZGlzdHJpYnV0ZXMgYnBmIHdvcmtsb2FkIG9uIG11bHRpcGxlIHRocmVh ZHMsIGFsc28gcmVkdWNlcyBsb2NrIAorY29udGVudGlvbiBvbiBicGYuCisKK1RvIG1ha2UgeW91 ciBwcm9ncmFtIG11bHRpdGhyZWFkZWQsIHlvdSdsbCBuZWVkIHRvIG9wZW4gYnBmIGRlc2NyaXB0 b3Igb24gZWFjaCAKK3RocmVhZCwgZW5hYmxlIG11bHRpcXVldWUgc3VwcG9ydCBieSBCSU9DUU1B U0tFTkFCTEUgaW9jdGwsIGFuZCBzZXQgcXVldWUgbWFzayBieSBCSU9DU1JYUU1BU0sgLyBCSU9D U1RYUU1BU0sgLyBCSU9DU05PUU1BU0sgaW9jdGxzLgorCitRdWV1ZSBsZW5ndGggYW5kIHF1ZXVl IGFmZmluaXR5IGluZm9ybWF0aW9uIG1heSB1c2VmdWwgdG8gb3B0aW1pemUgc2V0dGluZyAKK3F1 ZXVlIG1hc2sgb24gYnBmIGRlc2NyaXB0b3IsIHNlZQorLlhyIG5ldGludHJvIDQgLgorCiAuU2gg U0VFIEFMU08KIC5YciB0Y3BkdW1wIDEgLAogLlhyIGlvY3RsIDIgLApJbmRleDogc3lzL2Rldi9p eGdiZS9peGdiZS5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9kZXYvaXhnYmUvaXhnYmUuYwkoLi4uL2hl YWQpCShyZXZpc2lvbiAyNTUxODApCisrKyBzeXMvZGV2L2l4Z2JlL2l4Z2JlLmMJKC4uLi91c2Vy L3N5dXUvbXFfYnBmKQkocmV2aXNpb24gMjU1MjAwKQpAQCAtNzUxLDYgKzc1MSwxMSBAQAogCQkJ CUlGUV9EUlZfUFJFUEVORCgmaWZwLT5pZl9zbmQsIG1faGVhZCk7CiAJCQlicmVhazsKIAkJfQor CisJCW1faGVhZC0+bV9mbGFncyB8PSBNX1FVRVVFSUQ7CisJCW1faGVhZC0+bV9wa3RoZHIucXVl dWVpZCA9IHR4ci0+bWU7CisJCW1faGVhZC0+bV9wa3RoZHIucXVldWV0eXBlID0gUVVFVUVUWVBF X1RYOworCiAJCS8qIFNlbmQgYSBjb3B5IG9mIHRoZSBmcmFtZSB0byB0aGUgQlBGIGxpc3RlbmVy ICovCiAJCUVUSEVSX0JQRl9NVEFQKGlmcCwgbV9oZWFkKTsKIApAQCAtODQ5LDYgKzg1NCwxMSBA QAogCQlkcmJyX2FkdmFuY2UoaWZwLCB0eHItPmJyKTsKICNlbmRpZgogCQllbnF1ZXVlZCsrOwor IAorCQluZXh0LT5tX2ZsYWdzIHw9IE1fUVVFVUVJRDsKKyAJCW5leHQtPm1fcGt0aGRyLnF1ZXVl aWQgPSB0eHItPm1lOworCQluZXh0LT5tX3BrdGhkci5xdWV1ZXR5cGUgPSBRVUVVRVRZUEVfVFg7 CisKIAkJLyogU2VuZCBhIGNvcHkgb2YgdGhlIGZyYW1lIHRvIHRoZSBCUEYgbGlzdGVuZXIgKi8K IAkJRVRIRVJfQlBGX01UQVAoaWZwLCBuZXh0KTsKIAkJaWYgKChpZnAtPmlmX2Rydl9mbGFncyAm IElGRl9EUlZfUlVOTklORykgPT0gMCkKQEAgLTI2MzcsNiArMjY0Nyw3IEBACiAJaWZwLT5pZl9j YXBhYmlsaXRpZXMgfD0gSUZDQVBfVkxBTl9IV1RBR0dJTkcKIAkJCSAgICAgfCAgSUZDQVBfVkxB Tl9IV1RTTwogCQkJICAgICB8ICBJRkNBUF9WTEFOX01UVTsKKwlpZnAtPmlmX2NhcGFiaWxpdGll cyB8PSBJRkNBUF9RVUVVRUlEOwogCWlmcC0+aWZfY2FwZW5hYmxlID0gaWZwLT5pZl9jYXBhYmls aXRpZXM7CiAKIAkvKgpAQCAtNDU0Niw4ICs0NTU3LDEwIEBACiAJCQkJaXhnYmVfcnhfY2hlY2tz dW0oc3RhdGVyciwgc2VuZG1wLCBwdHlwZSk7CiAjaWYgX19GcmVlQlNEX3ZlcnNpb24gPj0gODAw MDAwCiAJCQlzZW5kbXAtPm1fcGt0aGRyLmZsb3dpZCA9IHF1ZS0+bXNpeDsKLQkJCXNlbmRtcC0+ bV9mbGFncyB8PSBNX0ZMT1dJRDsKKwkJCXNlbmRtcC0+bV9mbGFncyB8PSAoTV9GTE9XSUQgfCBN X1FVRVVFSUQpOwogI2VuZGlmCisJCQlzZW5kbXAtPm1fcGt0aGRyLnF1ZXVlaWQgPSBxdWUtPm1z aXg7CisJCQlzZW5kbXAtPm1fcGt0aGRyLnF1ZXVldHlwZSA9IFFVRVVFVFlQRV9SWDsKIAkJfQog bmV4dF9kZXNjOgogCQlidXNfZG1hbWFwX3N5bmMocnhyLT5yeGRtYS5kbWFfdGFnLCByeHItPnJ4 ZG1hLmRtYV9tYXAsCkluZGV4OiBzeXMvZGV2L2UxMDAwL2lmX2lnYi5jCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IHN5cy9kZXYvZTEwMDAvaWZfaWdiLmMJKC4uLi9oZWFkKQkocmV2aXNpb24gMjU1MTgwKQorKysg c3lzL2Rldi9lMTAwMC9pZl9pZ2IuYwkoLi4uL3VzZXIvc3l1dS9tcV9icGYpCShyZXZpc2lvbiAy NTUyMDApCkBAIC05MjAsNiArOTIwLDEwIEBACiAJCQlicmVhazsKIAkJfQogCisJCW1faGVhZC0+ bV9mbGFncyB8PSBNX1FVRVVFSUQ7CisJCW1faGVhZC0+bV9wa3RoZHIucXVldWVpZCA9IHR4ci0+ bWU7CisJCW1faGVhZC0+bV9wa3RoZHIucXVldWV0eXBlID0gUVVFVUVUWVBFX1RYOworCiAJCS8q IFNlbmQgYSBjb3B5IG9mIHRoZSBmcmFtZSB0byB0aGUgQlBGIGxpc3RlbmVyICovCiAJCUVUSEVS X0JQRl9NVEFQKGlmcCwgbV9oZWFkKTsKIApAQCAtMTAxOSw2ICsxMDIzLDkgQEAKIAkJaWZwLT5p Zl9vYnl0ZXMgKz0gbmV4dC0+bV9wa3RoZHIubGVuOwogCQlpZiAobmV4dC0+bV9mbGFncyAmIE1f TUNBU1QpCiAJCQlpZnAtPmlmX29tY2FzdHMrKzsKKwkJbmV4dC0+bV9mbGFncyB8PSBNX1FVRVVF SUQ7CisJCW5leHQtPm1fcGt0aGRyLnF1ZXVlaWQgPSB0eHItPm1lOworCQluZXh0LT5tX3BrdGhk ci5xdWV1ZXR5cGUgPSBRVUVVRVRZUEVfVFg7CiAJCUVUSEVSX0JQRl9NVEFQKGlmcCwgbmV4dCk7 CiAJCWlmICgoaWZwLT5pZl9kcnZfZmxhZ3MgJiBJRkZfRFJWX1JVTk5JTkcpID09IDApCiAJCQli cmVhazsKQEAgLTMxNjksNiArMzE3Niw3IEBACiAJKiogZW5hYmxlIHRoaXMgYW5kIGdldCBmdWxs IGhhcmR3YXJlIHRhZyBmaWx0ZXJpbmcuCiAJKi8KIAlpZnAtPmlmX2NhcGFiaWxpdGllcyB8PSBJ RkNBUF9WTEFOX0hXRklMVEVSOworCWlmcC0+aWZfY2FwYWJpbGl0aWVzIHw9IElGQ0FQX1FVRVVF SUQ7CiAKIAkvKgogCSAqIFNwZWNpZnkgdGhlIG1lZGlhIHR5cGVzIHN1cHBvcnRlZCBieSB0aGlz IGFkYXB0ZXIgYW5kIHJlZ2lzdGVyCkBAIC00ODkxLDggKzQ4OTksMTEgQEAKIAkJCX0KICNpZm5k ZWYgSUdCX0xFR0FDWV9UWAogCQkJcnhyLT5mbXAtPm1fcGt0aGRyLmZsb3dpZCA9IHF1ZS0+bXNp eDsKLQkJCXJ4ci0+Zm1wLT5tX2ZsYWdzIHw9IE1fRkxPV0lEOworCQkJcnhyLT5mbXAtPm1fZmxh Z3MgfD0gKE1fRkxPV0lEIHwgTV9RVUVVRUlEKTsKICNlbmRpZgorCQkJcnhyLT5mbXAtPm1fcGt0 aGRyLnF1ZXVlaWQgPSBxdWUtPm1zaXg7CisJCQlyeHItPmZtcC0+bV9wa3RoZHIucXVldWV0eXBl ID0gUVVFVUVUWVBFX1RYOworCiAJCQlzZW5kbXAgPSByeHItPmZtcDsKIAkJCS8qIE1ha2Ugc3Vy ZSB0byBzZXQgTV9QS1RIRFIuICovCiAJCQlzZW5kbXAtPm1fZmxhZ3MgfD0gTV9QS1RIRFI7Cklu ZGV4OiBzeXMvZGV2L214Z2UvaWZfbXhnZS5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9kZXYvbXhnZS9p Zl9teGdlLmMJKC4uLi9oZWFkKQkocmV2aXNpb24gMjU1MTgwKQorKysgc3lzL2Rldi9teGdlL2lm X214Z2UuYwkoLi4uL3VzZXIvc3l1dS9tcV9icGYpCShyZXZpc2lvbiAyNTUyMDApCkBAIC0yMjcy LDYgKzIyNzIsMTAgQEAKIAkJaWYgKG0gPT0gTlVMTCkgewogCQkJcmV0dXJuOwogCQl9CisJCW0t Pm1fZmxhZ3MgfD0gTV9RVUVVRUlEOworCQltLT5tX3BrdGhkci5xdWV1ZWlkID0gKHNzIC0gc2Mt PnNzKTsKKwkJbS0+bV9wa3RoZHIucXVldWV0eXBlID0gUVVFVUVUWVBFX1RYOworCiAJCS8qIGxl dCBCUEYgc2VlIGl0ICovCiAJCUJQRl9NVEFQKGlmcCwgbSk7CiAKQEAgLTIzMDYsNiArMjMxMCwx MCBAQAogCiAJaWYgKCFkcmJyX25lZWRzX2VucXVldWUoaWZwLCB0eC0+YnIpICYmCiAJICAgICgo dHgtPm1hc2sgLSAodHgtPnJlcSAtIHR4LT5kb25lKSkgPiB0eC0+bWF4X2Rlc2MpKSB7CisJCW0t Pm1fZmxhZ3MgfD0gTV9RVUVVRUlEOworCQltLT5tX3BrdGhkci5xdWV1ZWlkID0gKHNzIC0gc2Mt PnNzKTsKKwkJbS0+bV9wa3RoZHIucXVldWV0eXBlID0gUVVFVUVUWVBFX1RYOworCiAJCS8qIGxl dCBCUEYgc2VlIGl0ICovCiAJCUJQRl9NVEFQKGlmcCwgbSk7CiAJCS8qIGdpdmUgaXQgdG8gdGhl IG5pYyAqLwpAQCAtMjcxOCw3ICsyNzI2LDkgQEAKIAkvKiBmbG93aWQgb25seSB2YWxpZCBpZiBS U1MgaGFzaGluZyBpcyBlbmFibGVkICovCiAJaWYgKHNjLT5udW1fc2xpY2VzID4gMSkgewogCQlt LT5tX3BrdGhkci5mbG93aWQgPSAoc3MgLSBzYy0+c3MpOwotCQltLT5tX2ZsYWdzIHw9IE1fRkxP V0lEOworCQltLT5tX2ZsYWdzIHw9IChNX0ZMT1dJRCB8IE1fUVVFVUVJRCk7CisJCW0tPm1fcGt0 aGRyLnF1ZXVlaWQgPSAoc3MgLSBzYy0+c3MpOworCQltLT5tX3BrdGhkci5xdWV1ZXR5cGUgPSBR VUVVRVRZUEVfUlg7CiAJfQogCS8qIHBhc3MgdGhlIGZyYW1lIHVwIHRoZSBzdGFjayAqLwogCSgq aWZwLT5pZl9pbnB1dCkoaWZwLCBtKTsKQEAgLTQ4OTMsNiArNDkwMyw3IEBACiAjaWYgZGVmaW5l ZChJTkVUKSB8fCBkZWZpbmVkKElORVQ2KQogCWlmcC0+aWZfY2FwYWJpbGl0aWVzIHw9IElGQ0FQ X0xSTzsKICNlbmRpZgorCWlmcC0+aWZfY2FwYWJpbGl0aWVzIHw9IElGQ0FQX1FVRVVFSUQ7CiAK ICNpZmRlZiBNWEdFX05FV19WTEFOX0FQSQogCWlmcC0+aWZfY2FwYWJpbGl0aWVzIHw9IElGQ0FQ X1ZMQU5fSFdUQUdHSU5HIHwgSUZDQVBfVkxBTl9IV0NTVU07CkluZGV4OiBzeXMvbmV0L2JwZnEu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBzeXMvbmV0L2JwZnEuaAkoLi4uL2hlYWQpCShyZXZpc2lvbiAwKQor Kysgc3lzL25ldC9icGZxLmgJKC4uLi91c2VyL3N5dXUvbXFfYnBmKQkocmV2aXNpb24gMjU1MjAw KQpAQCAtMCwwICsxLDMyIEBACisjaWZuZGVmIF9ORVRfQlBGUV9IXworI2RlZmluZSBfTkVUX0JQ RlFfSF8KKworI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgorI2luY2x1ZGUgPHN5cy9iaXRzZXQuaD4K KyNpbmNsdWRlIDxzeXMvX2JpdHNldC5oPgorCisjZGVmaW5lIEJQRlFfQklUUwkJCTI1NgorQklU U0VUX0RFRklORShicGZfcW1hc2tfYml0cywgQlBGUV9CSVRTKTsKKworI2RlZmluZQlCUEZRX0NM UihuLCBwKQkJCUJJVF9DTFIoQlBGUV9CSVRTLCBuLCBwKQorI2RlZmluZQlCUEZRX0NPUFkoZiwg dCkJCQlCSVRfQ09QWShCUEZRX0JJVFMsIGYsIHQpCisjZGVmaW5lCUJQRlFfSVNTRVQobiwgcCkJ CUJJVF9JU1NFVChCUEZRX0JJVFMsIG4sIHApCisjZGVmaW5lCUJQRlFfU0VUKG4sIHApCQkJQklU X1NFVChCUEZRX0JJVFMsIG4sIHApCisjZGVmaW5lCUJQRlFfWkVSTyhwKSAJCQlCSVRfWkVSTyhC UEZRX0JJVFMsIHApCisjZGVmaW5lCUJQRlFfRklMTChwKSAJCQlCSVRfRklMTChCUEZRX0JJVFMs IHApCisjZGVmaW5lCUJQRlFfU0VUT0YobiwgcCkJCUJJVF9TRVRPRihCUEZRX0JJVFMsIG4sIHAp CisjZGVmaW5lCUJQRlFfRU1QVFkocCkJCQlCSVRfRU1QVFkoQlBGUV9CSVRTLCBwKQorI2RlZmlu ZQlCUEZRX0lTRlVMTFNFVChwKQkJQklUX0lTRlVMTFNFVChCUEZRX0JJVFMsIHApCisjZGVmaW5l CUJQRlFfU1VCU0VUKHAsIGMpCQlCSVRfU1VCU0VUKEJQRlFfQklUUywgcCwgYykKKyNkZWZpbmUJ QlBGUV9PVkVSTEFQKHAsIGMpCQlCSVRfT1ZFUkxBUChCUEZRX0JJVFMsIHAsIGMpCisjZGVmaW5l CUJQRlFfQ01QKHAsIGMpCQkJQklUX0NNUChCUEZRX0JJVFMsIHAsIGMpCisjZGVmaW5lCUJQRlFf T1IoZCwgcykJCQlCSVRfT1IoQlBGUV9CSVRTLCBkLCBzKQorI2RlZmluZQlCUEZRX0FORChkLCBz KQkJCUJJVF9BTkQoQlBGUV9CSVRTLCBkLCBzKQorI2RlZmluZQlCUEZRX05BTkQoZCwgcykJCQlC SVRfTkFORChCUEZRX0JJVFMsIGQsIHMpCisjZGVmaW5lCUJQRlFfQ0xSX0FUT01JQyhuLCBwKQkJ QklUX0NMUl9BVE9NSUMoQlBGUV9CSVRTLCBuLCBwKQorI2RlZmluZQlCUEZRX1NFVF9BVE9NSUMo biwgcCkJCUJJVF9TRVRfQVRPTUlDKEJQRlFfQklUUywgbiwgcCkKKyNkZWZpbmUJQlBGUV9PUl9B VE9NSUMoZCwgcykJCUJJVF9PUl9BVE9NSUMoQlBGUV9CSVRTLCBkLCBzKQorI2RlZmluZQlCUEZR X0NPUFlfU1RPUkVfUkVMKGYsIHQpCUJJVF9DT1BZX1NUT1JFX1JFTChCUEZRX0JJVFMsIGYsIHQp CisjZGVmaW5lCUJQRlFfRkZTKHApCQkJQklUX0ZGUyhCUEZRX0JJVFMsIHApCisKKyNlbmRpZgpJ bmRleDogc3lzL25ldC9pZi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9uZXQvaWYuaAkoLi4uL2hlYWQp CShyZXZpc2lvbiAyNTUxODApCisrKyBzeXMvbmV0L2lmLmgJKC4uLi91c2VyL3N5dXUvbXFfYnBm KQkocmV2aXNpb24gMjU1MjAwKQpAQCAtMjMxLDYgKzIzMSw3IEBACiAjZGVmaW5lCUlGQ0FQX05F VE1BUAkJMHgxMDAwMDAgLyogbmV0bWFwIG1vZGUgc3VwcG9ydGVkL2VuYWJsZWQgKi8KICNkZWZp bmUJSUZDQVBfUlhDU1VNX0lQVjYJMHgyMDAwMDAgIC8qIGNhbiBvZmZsb2FkIGNoZWNrc3VtIG9u IElQdjYgUlggKi8KICNkZWZpbmUJSUZDQVBfVFhDU1VNX0lQVjYJMHg0MDAwMDAgIC8qIGNhbiBv ZmZsb2FkIGNoZWNrc3VtIG9uIElQdjYgVFggKi8KKyNkZWZpbmUJSUZDQVBfUVVFVUVJRAkJMHg4 MDAwMDAgIC8qIGRyaXZlciBzdXBwb3J0cyBxdWV1ZWlkIG5vdGlmeSAqLwogCiAjZGVmaW5lIElG Q0FQX0hXQ1NVTV9JUFY2CShJRkNBUF9SWENTVU1fSVBWNiB8IElGQ0FQX1RYQ1NVTV9JUFY2KQog CkluZGV4OiBzeXMvbmV0L2JwZi5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9uZXQvYnBmLmMJKC4uLi9o ZWFkKQkocmV2aXNpb24gMjU1MTgwKQorKysgc3lzL25ldC9icGYuYwkoLi4uL3VzZXIvc3l1dS9t cV9icGYpCShyZXZpc2lvbiAyNTUyMDApCkBAIC04MTksNiArODE5LDkgQEAKIAlzaXplID0gZC0+ YmRfYnVmc2l6ZTsKIAlicGZfYnVmZmVyX2lvY3RsX3NibGVuKGQsICZzaXplKTsKIAorIAlkLT5i ZF9xbWFzay5xbV9lbmFibGVkID0gRkFMU0U7CisJQlBGUV9MT0NLX0lOSVQoJmQtPmJkX3FtYXNr KTsKKwogCXJldHVybiAoMCk7CiB9CiAKQEAgLTE2OTcsNyArMTcwMCwxOTEgQEAKIAljYXNlIEJJ T0NST1RaQlVGOgogCQllcnJvciA9IGJwZl9pb2N0bF9yb3R6YnVmKHRkLCBkLCAoc3RydWN0IGJw Zl96YnVmICopYWRkcik7CiAJCWJyZWFrOworCisJY2FzZSBCSU9DUU1BU0tFTkFCTEU6CisJCXsK KwkJCXN0cnVjdCBpZm5ldCAqaWZwOworCisJCQlpZiAoZC0+YmRfYmlmID09IE5VTEwpIHsKKwkJ CQkvKgorCQkJCSAqIE5vIGludGVyZmFjZSBhdHRhY2hlZCB5ZXQuCisJCQkJICovCisJCQkJZXJy b3IgPSBFSU5WQUw7CisJCQkJYnJlYWs7CisJCQl9CisJCQlCUEZRX1dMT0NLKCZkLT5iZF9xbWFz ayk7CisJCQlpZiAoZC0+YmRfcW1hc2sucW1fZW5hYmxlZCkgeworCQkJCUJQRlFfV1VOTE9DSygm ZC0+YmRfcW1hc2spOworCQkJCWVycm9yID0gRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJ aWZwID0gZC0+YmRfYmlmLT5iaWZfaWZwOworCQkJaWYgKCEoaWZwLT5pZl9jYXBhYmlsaXRpZXMg JiBJRkNBUF9RVUVVRUlEKSkgeworCQkJCUJQRlFfV1VOTE9DSygmZC0+YmRfcW1hc2spOworCQkJ CWVycm9yID0gRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJQlBGUV9aRVJPKCZkLT5iZF9x bWFzay5xbV9yeHFtYXNrKTsKKwkJCUJQRlFfWkVSTygmZC0+YmRfcW1hc2sucW1fdHhxbWFzayk7 CisJCQlkLT5iZF9xbWFzay5xbV9ub3FtYXNrID0gRkFMU0U7CisJCQlkLT5iZF9xbWFzay5xbV9l bmFibGVkID0gVFJVRTsKKwkJCUJQRlFfV1VOTE9DSygmZC0+YmRfcW1hc2spOworCQkJYnJlYWs7 CisJCX0KKworCWNhc2UgQklPQ1FNQVNLRElTQUJMRToKKwkJeworCQkJaWYgKGQtPmJkX2JpZiA9 PSBOVUxMKSB7CisJCQkJLyoKKwkJCQkgKiBObyBpbnRlcmZhY2UgYXR0YWNoZWQgeWV0LgorCQkJ CSAqLworCQkJCWVycm9yID0gRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJQlBGUV9XTE9D SygmZC0+YmRfcW1hc2spOworCQkJaWYgKCFkLT5iZF9xbWFzay5xbV9lbmFibGVkKSB7CisJCQkJ QlBGUV9XVU5MT0NLKCZkLT5iZF9xbWFzayk7CisJCQkJZXJyb3IgPSBFSU5WQUw7CisJCQkJYnJl YWs7CisJCQl9CisJCQlkLT5iZF9xbWFzay5xbV9lbmFibGVkID0gRkFMU0U7CisJCQlCUEZRX1dV TkxPQ0soJmQtPmJkX3FtYXNrKTsKKwkJCWJyZWFrOworCQl9CisKKwljYXNlIEJJT0NHUlhRTUFT SzoKKwkJeworCQkJc3RydWN0IGJwZl9xbWFza19iaXRzICpxbWFzayA9IChzdHJ1Y3QgYnBmX3Ft YXNrX2JpdHMgKilhZGRyOworCisJCQlpZiAoZC0+YmRfYmlmID09IE5VTEwpIHsKKwkJCQkvKgor CQkJCSAqIE5vIGludGVyZmFjZSBhdHRhY2hlZCB5ZXQuCisJCQkJICovCisJCQkJZXJyb3IgPSBF SU5WQUw7CisJCQkJYnJlYWs7CisJCQl9CisJCQlCUEZRX1dMT0NLKCZkLT5iZF9xbWFzayk7CisJ CQlpZiAoIWQtPmJkX3FtYXNrLnFtX2VuYWJsZWQpIHsKKwkJCQlCUEZRX1dVTkxPQ0soJmQtPmJk X3FtYXNrKTsKKwkJCQllcnJvciA9IEVJTlZBTDsKKwkJCQlicmVhazsKKwkJCX0KKwkJCUJQRlFf Q09QWSgmZC0+YmRfcW1hc2sucW1fcnhxbWFzaywgcW1hc2spOworCQkJQlBGUV9XVU5MT0NLKCZk LT5iZF9xbWFzayk7CisJCQlicmVhazsKKworCQl9CisKKwljYXNlIEJJT0NTUlhRTUFTSzoKKwkJ eworCQkJc3RydWN0IGJwZl9xbWFza19iaXRzICpxbWFzayA9IChzdHJ1Y3QgYnBmX3FtYXNrX2Jp dHMgKilhZGRyOworCisJCQlpZiAoZC0+YmRfYmlmID09IE5VTEwpIHsKKwkJCQkvKgorCQkJCSAq IE5vIGludGVyZmFjZSBhdHRhY2hlZCB5ZXQuCisJCQkJICovCisJCQkJZXJyb3IgPSBFSU5WQUw7 CQorCQkJCWJyZWFrOworCQkJfQorCQkJQlBGUV9XTE9DSygmZC0+YmRfcW1hc2spOworCQkJaWYg KCFkLT5iZF9xbWFzay5xbV9lbmFibGVkKSB7CisJCQkJQlBGUV9XVU5MT0NLKCZkLT5iZF9xbWFz ayk7CisJCQkJZXJyb3IgPSBFSU5WQUw7CisJCQkJYnJlYWs7CisJCQl9CisJCQlCUEZRX0NPUFko cW1hc2ssICZkLT5iZF9xbWFzay5xbV9yeHFtYXNrKTsKKwkJCUJQRlFfV1VOTE9DSygmZC0+YmRf cW1hc2spOworCQkJYnJlYWs7CisJCX0KKworCWNhc2UgQklPQ0dUWFFNQVNLOgorCQl7CisJCQlz dHJ1Y3QgYnBmX3FtYXNrX2JpdHMgKnFtYXNrID0gKHN0cnVjdCBicGZfcW1hc2tfYml0cyAqKWFk ZHI7CisKKwkJCWlmIChkLT5iZF9iaWYgPT0gTlVMTCkgeworCQkJCS8qCisJCQkJICogTm8gaW50 ZXJmYWNlIGF0dGFjaGVkIHlldC4KKwkJCQkgKi8KKwkJCQllcnJvciA9IEVJTlZBTDsKKwkJCQli cmVhazsKKwkJCX0KKwkJCUJQRlFfV0xPQ0soJmQtPmJkX3FtYXNrKTsKKwkJCWlmICghZC0+YmRf cW1hc2sucW1fZW5hYmxlZCkgeworCQkJCUJQRlFfV1VOTE9DSygmZC0+YmRfcW1hc2spOworCQkJ CWVycm9yID0gRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJQlBGUV9DT1BZKCZkLT5iZF9x bWFzay5xbV90eHFtYXNrLCBxbWFzayk7CisJCQlCUEZRX1dVTkxPQ0soJmQtPmJkX3FtYXNrKTsK KwkJCWJyZWFrOworCQl9CisKKwljYXNlIEJJT0NTVFhRTUFTSzoKKwkJeworCQkJc3RydWN0IGJw Zl9xbWFza19iaXRzICpxbWFzayA9IChzdHJ1Y3QgYnBmX3FtYXNrX2JpdHMgKilhZGRyOworCisJ CQlpZiAoZC0+YmRfYmlmID09IE5VTEwpIHsKKwkJCQkvKgorCQkJCSAqIE5vIGludGVyZmFjZSBh dHRhY2hlZCB5ZXQuCisJCQkJICovCisJCQkJZXJyb3IgPSBFSU5WQUw7CQorCQkJCWJyZWFrOwor CQkJfQorCQkJQlBGUV9XTE9DSygmZC0+YmRfcW1hc2spOworCQkJaWYgKCFkLT5iZF9xbWFzay5x bV9lbmFibGVkKSB7CisJCQkJQlBGUV9XVU5MT0NLKCZkLT5iZF9xbWFzayk7CisJCQkJZXJyb3Ig PSBFSU5WQUw7CisJCQkJYnJlYWs7CisJCQl9CisJCQlCUEZRX0NPUFkocW1hc2ssICZkLT5iZF9x bWFzay5xbV90eHFtYXNrKTsKKwkJCUJQRlFfV1VOTE9DSygmZC0+YmRfcW1hc2spOworCQkJYnJl YWs7CisJCX0KKworCWNhc2UgQklPQ0dOT1FNQVNLOgorCQl7CisJCQlib29sZWFuX3QgKm5vcW1h c2sgPSAoYm9vbGVhbl90ICopYWRkcjsKKwkJCWlmIChkLT5iZF9iaWYgPT0gTlVMTCkgeworCQkJ CS8qCisJCQkJICogTm8gaW50ZXJmYWNlIGF0dGFjaGVkIHlldC4KKwkJCQkgKi8KKwkJCQllcnJv ciA9IEVJTlZBTDsKKwkJCQlicmVhazsKKwkJCX0KKwkJCUJQRlFfV0xPQ0soJmQtPmJkX3FtYXNr KTsKKwkJCWlmICghZC0+YmRfcW1hc2sucW1fZW5hYmxlZCkgeworCQkJCUJQRlFfV1VOTE9DSygm ZC0+YmRfcW1hc2spOworCQkJCWVycm9yID0gRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJ Km5vcW1hc2sgPSBkLT5iZF9xbWFzay5xbV9ub3FtYXNrOworCQkJQlBGUV9XVU5MT0NLKCZkLT5i ZF9xbWFzayk7CisJCQlicmVhazsKKwkJfQorCisJY2FzZSBCSU9DU05PUU1BU0s6CisJCXsKKwkJ CWJvb2xlYW5fdCAqbm9xbWFzayA9IChib29sZWFuX3QgKilhZGRyOworCisJCQlpZiAoZC0+YmRf YmlmID09IE5VTEwpIHsKKwkJCQkvKgorCQkJCSAqIE5vIGludGVyZmFjZSBhdHRhY2hlZCB5ZXQu CisJCQkJICovCisJCQkJZXJyb3IgPSBFSU5WQUw7CQorCQkJCWJyZWFrOworCQkJfQorCQkJQlBG UV9XTE9DSygmZC0+YmRfcW1hc2spOworCQkJaWYgKCFkLT5iZF9xbWFzay5xbV9lbmFibGVkKSB7 CisJCQkJQlBGUV9XVU5MT0NLKCZkLT5iZF9xbWFzayk7CisJCQkJZXJyb3IgPSBFSU5WQUw7CisJ CQkJYnJlYWs7CisJCQl9CisJCQlkLT5iZF9xbWFzay5xbV9ub3FtYXNrID0gKm5vcW1hc2s7CisJ CQlCUEZRX1dVTkxPQ0soJmQtPmJkX3FtYXNrKTsKKwkJCWJyZWFrOworCQl9CiAJfQorCiAJQ1VS Vk5FVF9SRVNUT1JFKCk7CiAJcmV0dXJuIChlcnJvcik7CiB9CkBAIC0yMDQzLDYgKzIyMzAsMTUg QEAKIAlCUEZJRl9STE9DSyhicCk7CiAKIAlMSVNUX0ZPUkVBQ0goZCwgJmJwLT5iaWZfZGxpc3Qs IGJkX25leHQpIHsKKyAJCUJQRlFfUkxPQ0soJmQtPmJkX3FtYXNrKTsKKyAJCWlmIChkLT5iZF9x bWFzay5xbV9lbmFibGVkKSB7CisgCQkJaWYgKCFkLT5iZF9xbWFzay5xbV9ub3FtYXNrKSB7CisJ CQkJQlBGUV9SVU5MT0NLKCZkLT5iZF9xbWFzayk7CisgCQkJCWNvbnRpbnVlOworIAkJCX0KKyAJ CX0KKwkJQlBGUV9SVU5MT0NLKCZkLT5iZF9xbWFzayk7CisKIAkJLyoKIAkJICogV2UgYXJlIG5v dCB1c2luZyBhbnkgbG9ja3MgZm9yIGQgaGVyZSBiZWNhdXNlOgogCQkgKiAxKSBhbnkgZmlsdGVy IGNoYW5nZSBpcyBwcm90ZWN0ZWQgYnkgaW50ZXJmYWNlCkBAIC0yMTE3LDYgKzIzMTMsNDAgQEAK IAlCUEZJRl9STE9DSyhicCk7CiAKIAlMSVNUX0ZPUkVBQ0goZCwgJmJwLT5iaWZfZGxpc3QsIGJk X25leHQpIHsKKyAJCUJQRlFfUkxPQ0soJmQtPmJkX3FtYXNrKTsKKyAJCWlmIChkLT5iZF9xbWFz ay5xbV9lbmFibGVkKSB7CisgCQkJTV9BU1NFUlRQS1RIRFIobSk7CisgCQkJaWYgKG0tPm1fZmxh Z3MgJiBNX1FVRVVFSUQpIHsKKwkJCQlzd2l0Y2ggKG0tPm1fcGt0aGRyLnF1ZXVldHlwZSkgewor CQkJCWNhc2UgUVVFVUVUWVBFX1JYOgorCQkJCQlpZiAoIUJQRlFfSVNTRVQobS0+bV9wa3RoZHIu cXVldWVpZCwKKwkJCQkJCSAmZC0+YmRfcW1hc2sucW1fcnhxbWFzaykpIHsKKyAJCQkJCQlCUEZR X1JVTkxPQ0soJmQtPmJkX3FtYXNrKTsKKyAJCQkJCQljb250aW51ZTsKKyAJCQkJCX0KKwkJCQkJ YnJlYWs7CisJCQkJY2FzZSBRVUVVRVRZUEVfVFg6CisJCQkJCWlmICghQlBGUV9JU1NFVChtLT5t X3BrdGhkci5xdWV1ZWlkLCAKKwkJCQkJCSZkLT5iZF9xbWFzay5xbV9yeHFtYXNrKSkgeworIAkJ CQkJCUJQRlFfUlVOTE9DSygmZC0+YmRfcW1hc2spOworIAkJCQkJCWNvbnRpbnVlOworIAkJCQkJ fQorCQkJCQlicmVhazsKKwkJCQlkZWZhdWx0OgorCQkJCQlpZiAoIWQtPmJkX3FtYXNrLnFtX25v cW1hc2spIHsKKwkJCQkJCUJQRlFfUlVOTE9DSygmZC0+YmRfcW1hc2spOworCQkJCQkJY29udGlu dWU7CisJCQkJCX0KKyAJCQkJfQorIAkJCX1lbHNleworCQkJCWlmICghZC0+YmRfcW1hc2sucW1f bm9xbWFzaykgeworCQkJCQlCUEZRX1JVTkxPQ0soJmQtPmJkX3FtYXNrKTsKKwkJCQkJY29udGlu dWU7CisJCQkJfQorCQkJfQorIAkJfQorIAkJQlBGUV9SVU5MT0NLKCZkLT5iZF9xbWFzayk7Cisg CiAJCWlmIChCUEZfQ0hFQ0tfRElSRUNUSU9OKGQsIG0tPm1fcGt0aGRyLnJjdmlmLCBicC0+Ymlm X2lmcCkpCiAJCQljb250aW51ZTsKIAkJKytkLT5iZF9yY291bnQ7CkBAIC0yMTgwLDYgKzI0MTAs NDAgQEAKIAlCUEZJRl9STE9DSyhicCk7CiAKIAlMSVNUX0ZPUkVBQ0goZCwgJmJwLT5iaWZfZGxp c3QsIGJkX25leHQpIHsKKyAgCQlCUEZRX1JMT0NLKCZkLT5iZF9xbWFzayk7CisgCQlpZiAoZC0+ YmRfcW1hc2sucW1fZW5hYmxlZCkgeworIAkJCU1fQVNTRVJUUEtUSERSKG0pOworIAkJCWlmICht LT5tX2ZsYWdzICYgTV9RVUVVRUlEKSB7CisJCQkJc3dpdGNoIChtLT5tX3BrdGhkci5xdWV1ZXR5 cGUpIHsKKwkJCQljYXNlIFFVRVVFVFlQRV9SWDoKKwkJCQkJaWYgKCFCUEZRX0lTU0VUKG0tPm1f cGt0aGRyLnF1ZXVlaWQsCisJCQkJCQkgJmQtPmJkX3FtYXNrLnFtX3J4cW1hc2spKSB7CisgCQkJ CQkJQlBGUV9SVU5MT0NLKCZkLT5iZF9xbWFzayk7CisgCQkJCQkJY29udGludWU7CisgCQkJCQl9 CisJCQkJCWJyZWFrOworCQkJCWNhc2UgUVVFVUVUWVBFX1RYOgorCQkJCQlpZiAoIUJQRlFfSVNT RVQobS0+bV9wa3RoZHIucXVldWVpZCwgCisJCQkJCQkmZC0+YmRfcW1hc2sucW1fcnhxbWFzaykp IHsKKyAJCQkJCQlCUEZRX1JVTkxPQ0soJmQtPmJkX3FtYXNrKTsKKyAJCQkJCQljb250aW51ZTsK KyAJCQkJCX0KKwkJCQkJYnJlYWs7CisJCQkJZGVmYXVsdDoKKwkJCQkJaWYgKCFkLT5iZF9xbWFz ay5xbV9ub3FtYXNrKSB7CisJCQkJCQlCUEZRX1JVTkxPQ0soJmQtPmJkX3FtYXNrKTsKKwkJCQkJ CWNvbnRpbnVlOworCQkJCQl9CisgCQkJCX0KKyAJCQl9ZWxzZXsKKwkJCQlpZiAoIWQtPmJkX3Ft YXNrLnFtX25vcW1hc2spIHsKKwkJCQkJQlBGUV9SVU5MT0NLKCZkLT5iZF9xbWFzayk7CisJCQkJ CWNvbnRpbnVlOworCQkJCX0KKwkJCX0KKyAJCX0KKyAJCUJQRlFfUlVOTE9DSygmZC0+YmRfcW1h c2spOworCiAJCWlmIChCUEZfQ0hFQ0tfRElSRUNUSU9OKGQsIG0tPm1fcGt0aGRyLnJjdmlmLCBi cC0+YmlmX2lmcCkpCiAJCQljb250aW51ZTsKIAkJKytkLT5iZF9yY291bnQ7CkluZGV4OiBzeXMv bmV0L2JwZmRlc2MuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvbmV0L2JwZmRlc2MuaAkoLi4uL2hlYWQp CShyZXZpc2lvbiAyNTUxODApCisrKyBzeXMvbmV0L2JwZmRlc2MuaAkoLi4uL3VzZXIvc3l1dS9t cV9icGYpCShyZXZpc2lvbiAyNTUyMDApCkBAIC00NCw3ICs0NCwyMyBAQAogI2luY2x1ZGUgPHN5 cy9xdWV1ZS5oPgogI2luY2x1ZGUgPHN5cy9jb25mLmg+CiAjaW5jbHVkZSA8bmV0L2lmLmg+Cisj aW5jbHVkZSA8bmV0L2JwZnEuaD4KIAorc3RydWN0IGJwZl9xbWFzayB7CisJaW50CQlxbV9lbmFi bGVkOworCXN0cnVjdCBicGZfcW1hc2tfYml0cyBxbV9yeHFtYXNrOworCXN0cnVjdCBicGZfcW1h c2tfYml0cyBxbV90eHFtYXNrOworCWludAkJcW1fbm9xbWFzazsKKwlzdHJ1Y3Qgcndsb2NrCXFt X2xvY2s7Cit9OworCisjZGVmaW5lIEJQRlFfTE9DS19JTklUKHFtKQlyd19pbml0KCYocW0pLT5x bV9sb2NrLCAicW1hc2sgbG9jayIpCisjZGVmaW5lIEJQRlFfTE9DS19ERVNUUk9ZKHFtKQlyd19k ZXN0cm95KCYocW0pLT5xbV9sb2NrKQorI2RlZmluZSBCUEZRX1JMT0NLKHFtKQkJcndfcmxvY2so JihxbSktPnFtX2xvY2spCisjZGVmaW5lIEJQRlFfUlVOTE9DSyhxbSkJcndfcnVubG9jaygmKHFt KS0+cW1fbG9jaykKKyNkZWZpbmUgQlBGUV9XTE9DSyhxbSkJCXJ3X3dsb2NrKCYocW0pLT5xbV9s b2NrKQorI2RlZmluZSBCUEZRX1dVTkxPQ0socW0pCXJ3X3d1bmxvY2soJihxbSktPnFtX2xvY2sp CisKIC8qCiAgKiBEZXNjcmlwdG9yIGFzc29jaWF0ZWQgd2l0aCBlYWNoIG9wZW4gYnBmIGZpbGUu CiAgKi8KQEAgLTEwMSw2ICsxMTcsNyBAQAogCXVfaW50NjRfdAliZF93ZGNvdW50OwkvKiBudW1i ZXIgb2YgcGFja2V0cyBkcm9wcGVkIGR1cmluZyBhIHdyaXRlICovCiAJdV9pbnQ2NF90CWJkX3pj b3B5OwkvKiBudW1iZXIgb2YgemVybyBjb3B5IG9wZXJhdGlvbnMgKi8KIAl1X2NoYXIJCWJkX2Nv bXBhdDMyOwkvKiAzMi1iaXQgc3RyZWFtIG9uIExQNjQgc3lzdGVtICovCisJc3RydWN0IGJwZl9x bWFzayBiZF9xbWFzazsKIH07CiAKIC8qIFZhbHVlcyBmb3IgYmRfc3RhdGUgKi8KSW5kZXg6IHN5 cy9uZXQvYnBmLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL25ldC9icGYuaAkoLi4uL2hlYWQpCShyZXZp c2lvbiAyNTUxODApCisrKyBzeXMvbmV0L2JwZi5oCSguLi4vdXNlci9zeXV1L21xX2JwZikJKHJl dmlzaW9uIDI1NTIwMCkKQEAgLTQwLDYgKzQwLDggQEAKICNpZm5kZWYgX05FVF9CUEZfSF8KICNk ZWZpbmUgX05FVF9CUEZfSF8KIAorI2luY2x1ZGUgPG5ldC9icGZxLmg+CisKIC8qIEJTRCBzdHls ZSByZWxlYXNlIGRhdGUgKi8KICNkZWZpbmUJQlBGX1JFTEVBU0UgMTk5NjA2CiAKQEAgLTE0Nyw2 ICsxNDksMTQgQEAKICNkZWZpbmUJQklPQ1NFVEZOUglfSU9XKCdCJywgMTMwLCBzdHJ1Y3QgYnBm X3Byb2dyYW0pCiAjZGVmaW5lCUJJT0NHVFNUQU1QCV9JT1IoJ0InLCAxMzEsIHVfaW50KQogI2Rl ZmluZQlCSU9DU1RTVEFNUAlfSU9XKCdCJywgMTMyLCB1X2ludCkKKyNkZWZpbmUJQklPQ1FNQVNL RU5BQkxFCV9JTygnQicsIDEzMykKKyNkZWZpbmUJQklPQ1FNQVNLRElTQUJMRSBfSU8oJ0InLCAx MzQpCisjZGVmaW5lCUJJT0NHUlhRTUFTSwlfSU9SKCdCJywgMTM1LCBzdHJ1Y3QgYnBmX3FtYXNr X2JpdHMpCisjZGVmaW5lCUJJT0NTUlhRTUFTSwlfSU9XKCdCJywgMTM1LCBzdHJ1Y3QgYnBmX3Ft YXNrX2JpdHMpCisjZGVmaW5lCUJJT0NHVFhRTUFTSwlfSU9SKCdCJywgMTM2LCBzdHJ1Y3QgYnBm X3FtYXNrX2JpdHMpCisjZGVmaW5lCUJJT0NTVFhRTUFTSwlfSU9XKCdCJywgMTM3LCBzdHJ1Y3Qg YnBmX3FtYXNrX2JpdHMpCisjZGVmaW5lCUJJT0NHTk9RTUFTSwlfSU9SKCdCJywgMTM4LCBpbnQp CisjZGVmaW5lCUJJT0NTTk9RTUFTSwlfSU9XKCdCJywgMTM5LCBpbnQpCiAKIC8qIE9ic29sZXRl ICovCiAjZGVmaW5lCUJJT0NHU0VFU0VOVAlCSU9DR0RJUkVDVElPTgpJbmRleDogc3lzL3N5cy9t YnVmLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gc3lzL3N5cy9tYnVmLmgJKC4uLi9oZWFkKQkocmV2aXNpb24g MjU1MTgwKQorKysgc3lzL3N5cy9tYnVmLmgJKC4uLi91c2VyL3N5dXUvbXFfYnBmKQkocmV2aXNp b24gMjU1MjAwKQpAQCAtMTE0LDYgKzExNCwxMSBAQAogCXZvaWQJCQkoKm1fdGFnX2ZyZWUpKHN0 cnVjdCBtX3RhZyAqKTsKIH07CiAKK2VudW0gcXVldWV0eXBlIHsKKwlRVUVVRVRZUEVfUlgsCisJ UVVFVUVUWVBFX1RYCit9OworCiAvKgogICogUmVjb3JkL3BhY2tldCBoZWFkZXIgaW4gZmlyc3Qg bWJ1ZiBvZiBjaGFpbjsgdmFsaWQgb25seSBpZiBNX1BLVEhEUiBpcyBzZXQuCiAgKiBTaXplIElM UDMyOiA0OApAQCAtMTI2LDYgKzEzMSw4IEBACiAKIAkvKiBMYXllciBjcm9zc2luZyBwZXJzaXN0 ZW50IGluZm9ybWF0aW9uLiAqLwogCXVpbnQzMl90CSBmbG93aWQ7CS8qIHBhY2tldCdzIDQtdHVw bGUgc3lzdGVtICovCisJdWludDMyX3QJIHF1ZXVlaWQ7CS8qIGh3IHF1ZXVlIGlkICovCisJdWlu dDMyX3QJIHF1ZXVldHlwZTsJLyogaHcgcXVldWUgdHlwZSAqLwogCXVpbnQ2NF90CSBjc3VtX2Zs YWdzOwkvKiBjaGVja3N1bSBhbmQgb2ZmbG9hZCBmZWF0dXJlcyAqLwogCXVpbnQxNl90CSBmaWJu dW07CS8qIHRoaXMgcGFja2V0IHNob3VsZCB1c2UgdGhpcyBmaWIgKi8KIAl1aW50OF90CQkgY29z cW9zOwkvKiBjbGFzcy9xdWFsaXR5IG9mIHNlcnZpY2UgKi8KQEAgLTIyMyw2ICsyMzAsNyBAQAog I2RlZmluZQlNX1ZMQU5UQUcJMHgwMDAwMDA4MCAvKiBldGhlcl92dGFnIGlzIHZhbGlkICovCiAj ZGVmaW5lCU1fRkxPV0lECTB4MDAwMDAxMDAgLyogZGVwcmVjYXRlZDogZmxvd2lkIGlzIHZhbGlk ICovCiAjZGVmaW5lCU1fTk9GUkVFCTB4MDAwMDAyMDAgLyogZG8gbm90IGZyZWUgbWJ1ZiwgZW1i ZWRkZWQgaW4gY2x1c3RlciAqLworI2RlZmluZQlNX1FVRVVFSUQJMHgwMDAwMDQwMCAvKiBwYWNr ZXQgaGFzIGh3IHF1ZXVlIGlkICovCiAKICNkZWZpbmUJTV9QUk9UTzEJMHgwMDAwMTAwMCAvKiBw cm90b2NvbC1zcGVjaWZpYyAqLwogI2RlZmluZQlNX1BST1RPMgkweDAwMDAyMDAwIC8qIHByb3Rv Y29sLXNwZWNpZmljICovCkluZGV4OiBzYmluL2lmY29uZmlnL2lmY29uZmlnLmMKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gc2Jpbi9pZmNvbmZpZy9pZmNvbmZpZy5jCSguLi4vaGVhZCkJKHJldmlzaW9uIDI1NTE4 MCkKKysrIHNiaW4vaWZjb25maWcvaWZjb25maWcuYwkoLi4uL3VzZXIvc3l1dS9tcV9icGYpCShy ZXZpc2lvbiAyNTUyMDApCkBAIC05MTcsNyArOTE3LDcgQEAKICJcMDIwXDFSWENTVU1cMlRYQ1NV TVwzTkVUQ09OU1w0VkxBTl9NVFVcNVZMQU5fSFdUQUdHSU5HXDZKVU1CT19NVFVcN1BPTExJTkci IFwKICJcMTBWTEFOX0hXQ1NVTVwxMVRTTzRcMTJUU082XDEzTFJPXDE0V09MX1VDQVNUXDE1V09M X01DQVNUXDE2V09MX01BR0lDIiBcCiAiXDE3VE9FNFwyMFRPRTZcMjFWTEFOX0hXRklMVEVSXDIz VkxBTl9IV1RTT1wyNExJTktTVEFURVwyNU5FVE1BUCIgXAotIlwyNlJYQ1NVTV9JUFY2XDI3VFhD U1VNX0lQVjYiCisiXDI2UlhDU1VNX0lQVjZcMjdUWENTVU1fSVBWNlwyOFFVRVVFSUQiCiAKIC8q CiAgKiBQcmludCB0aGUgc3RhdHVzIG9mIHRoZSBpbnRlcmZhY2UuICBJZiBhbiBhZGRyZXNzIGZh bWlseSB3YXMK --047d7b6d82dc41494f04e58a43ab--
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?CALG4x-UVgT9aXSBzrjDxeCD-f6Yo_TBeRsqjXapz2iyr_=tCLw>