From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([209.51.188.92]:57997) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ghb52-0005zL-4n for qemu-devel@nongnu.org; Thu, 10 Jan 2019 09:13:10 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1ghasP-00032B-N9 for qemu-devel@nongnu.org; Thu, 10 Jan 2019 09:00:10 -0500 Received: from smtp03.citrix.com ([162.221.156.55]:12098) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1ghasP-00031h-CC for qemu-devel@nongnu.org; Thu, 10 Jan 2019 09:00:05 -0500 From: Anthony PERARD Date: Thu, 10 Jan 2019 13:49:06 +0000 Message-ID: <20190110134917.16425-15-anthony.perard@citrix.com> In-Reply-To: <20190110134917.16425-1-anthony.perard@citrix.com> References: <20190110134917.16425-1-anthony.perard@citrix.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain Subject: [Qemu-devel] [PULL 14/25] xen: remove 'ioreq' struct/varable/field names from dataplane/xen-block.c List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: xen-devel@lists.xenproject.org, Paul Durrant , Anthony PERARD From: Paul Durrant This is a purely cosmetic patch that purges the name 'ioreq' from struct, variable and field names. (This name has been problematic for a long time as 'ioreq' is the name used for generic I/O requests coming from Xen). The patch replaces 'struct ioreq' with a new 'XenBlockRequest' type and 'ioreq' field/variable names with 'request', and then does necessary fix-up to adhere to coding style. Function names are not modified by this patch. They will be dealt with in a subsequent patch. No functional change. Signed-off-by: Paul Durrant Acked-by: Anthony Perard Signed-off-by: Anthony PERARD --- hw/block/dataplane/xen-block.c | 310 +++++++++++++++++---------------- 1 file changed, 156 insertions(+), 154 deletions(-) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index 1ff464973c..6788bbf338 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -28,7 +28,7 @@ #include "sysemu/iothread.h" #include "xen-block.h" -struct ioreq { +typedef struct XenBlockRequest { blkif_request_t req; int16_t status; off_t start; @@ -39,9 +39,9 @@ struct ioreq { int aio_inflight; int aio_errors; XenBlockDataPlane *dataplane; - QLIST_ENTRY(ioreq) list; + QLIST_ENTRY(XenBlockRequest) list; BlockAcctCookie acct; -}; +} XenBlockRequest; struct XenBlockDataPlane { XenDevice *xendev; @@ -54,9 +54,9 @@ struct XenBlockDataPlane { int protocol; blkif_back_rings_t rings; int more_work; - QLIST_HEAD(inflight_head, ioreq) inflight; - QLIST_HEAD(finished_head, ioreq) finished; - QLIST_HEAD(freelist_head, ioreq) freelist; + QLIST_HEAD(inflight_head, XenBlockRequest) inflight; + QLIST_HEAD(finished_head, XenBlockRequest) finished; + QLIST_HEAD(freelist_head, XenBlockRequest) freelist; int requests_total; int requests_inflight; int requests_finished; @@ -67,68 +67,68 @@ struct XenBlockDataPlane { AioContext *ctx; }; -static void ioreq_reset(struct ioreq *ioreq) +static void ioreq_reset(XenBlockRequest *request) { - memset(&ioreq->req, 0, sizeof(ioreq->req)); - ioreq->status = 0; - ioreq->start = 0; - ioreq->buf = NULL; - ioreq->size = 0; - ioreq->presync = 0; + memset(&request->req, 0, sizeof(request->req)); + request->status = 0; + request->start = 0; + request->buf = NULL; + request->size = 0; + request->presync = 0; - ioreq->aio_inflight = 0; - ioreq->aio_errors = 0; + request->aio_inflight = 0; + request->aio_errors = 0; - ioreq->dataplane = NULL; - memset(&ioreq->list, 0, sizeof(ioreq->list)); - memset(&ioreq->acct, 0, sizeof(ioreq->acct)); + request->dataplane = NULL; + memset(&request->list, 0, sizeof(request->list)); + memset(&request->acct, 0, sizeof(request->acct)); - qemu_iovec_reset(&ioreq->v); + qemu_iovec_reset(&request->v); } -static struct ioreq *ioreq_start(XenBlockDataPlane *dataplane) +static XenBlockRequest *ioreq_start(XenBlockDataPlane *dataplane) { - struct ioreq *ioreq = NULL; + XenBlockRequest *request = NULL; if (QLIST_EMPTY(&dataplane->freelist)) { if (dataplane->requests_total >= dataplane->max_requests) { goto out; } /* allocate new struct */ - ioreq = g_malloc0(sizeof(*ioreq)); - ioreq->dataplane = dataplane; + request = g_malloc0(sizeof(*request)); + request->dataplane = dataplane; dataplane->requests_total++; - qemu_iovec_init(&ioreq->v, 1); + qemu_iovec_init(&request->v, 1); } else { /* get one from freelist */ - ioreq = QLIST_FIRST(&dataplane->freelist); - QLIST_REMOVE(ioreq, list); + request = QLIST_FIRST(&dataplane->freelist); + QLIST_REMOVE(request, list); } - QLIST_INSERT_HEAD(&dataplane->inflight, ioreq, list); + QLIST_INSERT_HEAD(&dataplane->inflight, request, list); dataplane->requests_inflight++; out: - return ioreq; + return request; } -static void ioreq_finish(struct ioreq *ioreq) +static void ioreq_finish(XenBlockRequest *request) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; - QLIST_REMOVE(ioreq, list); - QLIST_INSERT_HEAD(&dataplane->finished, ioreq, list); + QLIST_REMOVE(request, list); + QLIST_INSERT_HEAD(&dataplane->finished, request, list); dataplane->requests_inflight--; dataplane->requests_finished++; } -static void ioreq_release(struct ioreq *ioreq, bool finish) +static void ioreq_release(XenBlockRequest *request, bool finish) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; - QLIST_REMOVE(ioreq, list); - ioreq_reset(ioreq); - ioreq->dataplane = dataplane; - QLIST_INSERT_HEAD(&dataplane->freelist, ioreq, list); + QLIST_REMOVE(request, list); + ioreq_reset(request); + request->dataplane = dataplane; + QLIST_INSERT_HEAD(&dataplane->freelist, request, list); if (finish) { dataplane->requests_finished--; } else { @@ -140,18 +140,18 @@ static void ioreq_release(struct ioreq *ioreq, bool finish) * translate request into iovec + start offset * do sanity checks along the way */ -static int ioreq_parse(struct ioreq *ioreq) +static int ioreq_parse(XenBlockRequest *request) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; size_t len; int i; - switch (ioreq->req.operation) { + switch (request->req.operation) { case BLKIF_OP_READ: break; case BLKIF_OP_FLUSH_DISKCACHE: - ioreq->presync = 1; - if (!ioreq->req.nr_segments) { + request->presync = 1; + if (!request->req.nr_segments) { return 0; } /* fall through */ @@ -160,77 +160,78 @@ static int ioreq_parse(struct ioreq *ioreq) case BLKIF_OP_DISCARD: return 0; default: - error_report("error: unknown operation (%d)", ioreq->req.operation); + error_report("error: unknown operation (%d)", request->req.operation); goto err; }; - if (ioreq->req.operation != BLKIF_OP_READ && + if (request->req.operation != BLKIF_OP_READ && blk_is_read_only(dataplane->blk)) { error_report("error: write req for ro device"); goto err; } - ioreq->start = ioreq->req.sector_number * dataplane->file_blk; - for (i = 0; i < ioreq->req.nr_segments; i++) { + request->start = request->req.sector_number * dataplane->file_blk; + for (i = 0; i < request->req.nr_segments; i++) { if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { error_report("error: nr_segments too big"); goto err; } - if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) { + if (request->req.seg[i].first_sect > request->req.seg[i].last_sect) { error_report("error: first > last sector"); goto err; } - if (ioreq->req.seg[i].last_sect * dataplane->file_blk >= XC_PAGE_SIZE) { + if (request->req.seg[i].last_sect * dataplane->file_blk >= + XC_PAGE_SIZE) { error_report("error: page crossing"); goto err; } - len = (ioreq->req.seg[i].last_sect - - ioreq->req.seg[i].first_sect + 1) * dataplane->file_blk; - ioreq->size += len; + len = (request->req.seg[i].last_sect - + request->req.seg[i].first_sect + 1) * dataplane->file_blk; + request->size += len; } - if (ioreq->start + ioreq->size > dataplane->file_size) { + if (request->start + request->size > dataplane->file_size) { error_report("error: access beyond end of file"); goto err; } return 0; err: - ioreq->status = BLKIF_RSP_ERROR; + request->status = BLKIF_RSP_ERROR; return -1; } -static int ioreq_grant_copy(struct ioreq *ioreq) +static int ioreq_grant_copy(XenBlockRequest *request) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; XenDevice *xendev = dataplane->xendev; XenDeviceGrantCopySegment segs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; int i, count; int64_t file_blk = dataplane->file_blk; - bool to_domain = (ioreq->req.operation == BLKIF_OP_READ); - void *virt = ioreq->buf; + bool to_domain = (request->req.operation == BLKIF_OP_READ); + void *virt = request->buf; Error *local_err = NULL; - if (ioreq->req.nr_segments == 0) { + if (request->req.nr_segments == 0) { return 0; } - count = ioreq->req.nr_segments; + count = request->req.nr_segments; for (i = 0; i < count; i++) { if (to_domain) { - segs[i].dest.foreign.ref = ioreq->req.seg[i].gref; - segs[i].dest.foreign.offset = ioreq->req.seg[i].first_sect * + segs[i].dest.foreign.ref = request->req.seg[i].gref; + segs[i].dest.foreign.offset = request->req.seg[i].first_sect * file_blk; segs[i].source.virt = virt; } else { - segs[i].source.foreign.ref = ioreq->req.seg[i].gref; - segs[i].source.foreign.offset = ioreq->req.seg[i].first_sect * + segs[i].source.foreign.ref = request->req.seg[i].gref; + segs[i].source.foreign.offset = request->req.seg[i].first_sect * file_blk; segs[i].dest.virt = virt; } - segs[i].len = (ioreq->req.seg[i].last_sect - - ioreq->req.seg[i].first_sect + 1) * file_blk; + segs[i].len = (request->req.seg[i].last_sect - + request->req.seg[i].first_sect + 1) * file_blk; virt += segs[i].len; } @@ -239,72 +240,72 @@ static int ioreq_grant_copy(struct ioreq *ioreq) if (local_err) { error_reportf_err(local_err, "failed to copy data: "); - ioreq->aio_errors++; + request->aio_errors++; return -1; } return 0; } -static int ioreq_runio_qemu_aio(struct ioreq *ioreq); +static int ioreq_runio_qemu_aio(XenBlockRequest *request); static void qemu_aio_complete(void *opaque, int ret) { - struct ioreq *ioreq = opaque; - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockRequest *request = opaque; + XenBlockDataPlane *dataplane = request->dataplane; aio_context_acquire(dataplane->ctx); if (ret != 0) { error_report("%s I/O error", - ioreq->req.operation == BLKIF_OP_READ ? + request->req.operation == BLKIF_OP_READ ? "read" : "write"); - ioreq->aio_errors++; + request->aio_errors++; } - ioreq->aio_inflight--; - if (ioreq->presync) { - ioreq->presync = 0; - ioreq_runio_qemu_aio(ioreq); + request->aio_inflight--; + if (request->presync) { + request->presync = 0; + ioreq_runio_qemu_aio(request); goto done; } - if (ioreq->aio_inflight > 0) { + if (request->aio_inflight > 0) { goto done; } - switch (ioreq->req.operation) { + switch (request->req.operation) { case BLKIF_OP_READ: - /* in case of failure ioreq->aio_errors is increased */ + /* in case of failure request->aio_errors is increased */ if (ret == 0) { - ioreq_grant_copy(ioreq); + ioreq_grant_copy(request); } - qemu_vfree(ioreq->buf); + qemu_vfree(request->buf); break; case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: - if (!ioreq->req.nr_segments) { + if (!request->req.nr_segments) { break; } - qemu_vfree(ioreq->buf); + qemu_vfree(request->buf); break; default: break; } - ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; - ioreq_finish(ioreq); + request->status = request->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; + ioreq_finish(request); - switch (ioreq->req.operation) { + switch (request->req.operation) { case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: - if (!ioreq->req.nr_segments) { + if (!request->req.nr_segments) { break; } case BLKIF_OP_READ: - if (ioreq->status == BLKIF_RSP_OKAY) { - block_acct_done(blk_get_stats(dataplane->blk), &ioreq->acct); + if (request->status == BLKIF_RSP_OKAY) { + block_acct_done(blk_get_stats(dataplane->blk), &request->acct); } else { - block_acct_failed(blk_get_stats(dataplane->blk), &ioreq->acct); + block_acct_failed(blk_get_stats(dataplane->blk), &request->acct); } break; case BLKIF_OP_DISCARD: @@ -317,10 +318,11 @@ static void qemu_aio_complete(void *opaque, int ret) aio_context_release(dataplane->ctx); } -static bool blk_split_discard(struct ioreq *ioreq, blkif_sector_t sector_number, +static bool blk_split_discard(XenBlockRequest *request, + blkif_sector_t sector_number, uint64_t nr_sectors) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; int64_t byte_offset; int byte_chunk; uint64_t byte_remaining, limit; @@ -339,9 +341,9 @@ static bool blk_split_discard(struct ioreq *ioreq, blkif_sector_t sector_number, do { byte_chunk = byte_remaining > limit ? limit : byte_remaining; - ioreq->aio_inflight++; + request->aio_inflight++; blk_aio_pdiscard(dataplane->blk, byte_offset, byte_chunk, - qemu_aio_complete, ioreq); + qemu_aio_complete, request); byte_remaining -= byte_chunk; byte_offset += byte_chunk; } while (byte_remaining > 0); @@ -349,53 +351,53 @@ static bool blk_split_discard(struct ioreq *ioreq, blkif_sector_t sector_number, return true; } -static int ioreq_runio_qemu_aio(struct ioreq *ioreq) +static int ioreq_runio_qemu_aio(XenBlockRequest *request) { - XenBlockDataPlane *dataplane = ioreq->dataplane; - - ioreq->buf = qemu_memalign(XC_PAGE_SIZE, ioreq->size); - if (ioreq->req.nr_segments && - (ioreq->req.operation == BLKIF_OP_WRITE || - ioreq->req.operation == BLKIF_OP_FLUSH_DISKCACHE) && - ioreq_grant_copy(ioreq)) { - qemu_vfree(ioreq->buf); + XenBlockDataPlane *dataplane = request->dataplane; + + request->buf = qemu_memalign(XC_PAGE_SIZE, request->size); + if (request->req.nr_segments && + (request->req.operation == BLKIF_OP_WRITE || + request->req.operation == BLKIF_OP_FLUSH_DISKCACHE) && + ioreq_grant_copy(request)) { + qemu_vfree(request->buf); goto err; } - ioreq->aio_inflight++; - if (ioreq->presync) { - blk_aio_flush(ioreq->dataplane->blk, qemu_aio_complete, ioreq); + request->aio_inflight++; + if (request->presync) { + blk_aio_flush(request->dataplane->blk, qemu_aio_complete, request); return 0; } - switch (ioreq->req.operation) { + switch (request->req.operation) { case BLKIF_OP_READ: - qemu_iovec_add(&ioreq->v, ioreq->buf, ioreq->size); - block_acct_start(blk_get_stats(dataplane->blk), &ioreq->acct, - ioreq->v.size, BLOCK_ACCT_READ); - ioreq->aio_inflight++; - blk_aio_preadv(dataplane->blk, ioreq->start, &ioreq->v, 0, - qemu_aio_complete, ioreq); + qemu_iovec_add(&request->v, request->buf, request->size); + block_acct_start(blk_get_stats(dataplane->blk), &request->acct, + request->v.size, BLOCK_ACCT_READ); + request->aio_inflight++; + blk_aio_preadv(dataplane->blk, request->start, &request->v, 0, + qemu_aio_complete, request); break; case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: - if (!ioreq->req.nr_segments) { + if (!request->req.nr_segments) { break; } - qemu_iovec_add(&ioreq->v, ioreq->buf, ioreq->size); - block_acct_start(blk_get_stats(dataplane->blk), &ioreq->acct, - ioreq->v.size, - ioreq->req.operation == BLKIF_OP_WRITE ? + qemu_iovec_add(&request->v, request->buf, request->size); + block_acct_start(blk_get_stats(dataplane->blk), &request->acct, + request->v.size, + request->req.operation == BLKIF_OP_WRITE ? BLOCK_ACCT_WRITE : BLOCK_ACCT_FLUSH); - ioreq->aio_inflight++; - blk_aio_pwritev(dataplane->blk, ioreq->start, &ioreq->v, 0, - qemu_aio_complete, ioreq); + request->aio_inflight++; + blk_aio_pwritev(dataplane->blk, request->start, &request->v, 0, + qemu_aio_complete, request); break; case BLKIF_OP_DISCARD: { - struct blkif_request_discard *req = (void *)&ioreq->req; - if (!blk_split_discard(ioreq, req->sector_number, req->nr_sectors)) { + struct blkif_request_discard *req = (void *)&request->req; + if (!blk_split_discard(request, req->sector_number, req->nr_sectors)) { goto err; } break; @@ -405,19 +407,19 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) goto err; } - qemu_aio_complete(ioreq, 0); + qemu_aio_complete(request, 0); return 0; err: - ioreq_finish(ioreq); - ioreq->status = BLKIF_RSP_ERROR; + ioreq_finish(request); + request->status = BLKIF_RSP_ERROR; return -1; } -static int blk_send_response_one(struct ioreq *ioreq) +static int blk_send_response_one(XenBlockRequest *request) { - XenBlockDataPlane *dataplane = ioreq->dataplane; + XenBlockDataPlane *dataplane = request->dataplane; int send_notify = 0; int have_requests = 0; blkif_response_t *resp; @@ -443,9 +445,9 @@ static int blk_send_response_one(struct ioreq *ioreq) return 0; } - resp->id = ioreq->req.id; - resp->operation = ioreq->req.operation; - resp->status = ioreq->status; + resp->id = request->req.id; + resp->operation = request->req.operation; + resp->status = request->status; dataplane->rings.common.rsp_prod_pvt++; @@ -473,13 +475,13 @@ static int blk_send_response_one(struct ioreq *ioreq) /* walk finished list, send outstanding responses, free requests */ static void blk_send_response_all(XenBlockDataPlane *dataplane) { - struct ioreq *ioreq; + XenBlockRequest *request; int send_notify = 0; while (!QLIST_EMPTY(&dataplane->finished)) { - ioreq = QLIST_FIRST(&dataplane->finished); - send_notify += blk_send_response_one(ioreq); - ioreq_release(ioreq, true); + request = QLIST_FIRST(&dataplane->finished); + send_notify += blk_send_response_one(request); + ioreq_release(request, true); } if (send_notify) { Error *local_err = NULL; @@ -493,29 +495,29 @@ static void blk_send_response_all(XenBlockDataPlane *dataplane) } } -static int blk_get_request(XenBlockDataPlane *dataplane, struct ioreq *ioreq, - RING_IDX rc) +static int blk_get_request(XenBlockDataPlane *dataplane, + XenBlockRequest *request, RING_IDX rc) { switch (dataplane->protocol) { case BLKIF_PROTOCOL_NATIVE: { blkif_request_t *req = RING_GET_REQUEST(&dataplane->rings.native, rc); - memcpy(&ioreq->req, req, sizeof(ioreq->req)); + memcpy(&request->req, req, sizeof(request->req)); break; } case BLKIF_PROTOCOL_X86_32: { blkif_x86_32_request_t *req = RING_GET_REQUEST(&dataplane->rings.x86_32_part, rc); - blkif_get_x86_32_req(&ioreq->req, req); + blkif_get_x86_32_req(&request->req, req); break; } case BLKIF_PROTOCOL_X86_64: { blkif_x86_64_request_t *req = RING_GET_REQUEST(&dataplane->rings.x86_64_part, rc); - blkif_get_x86_64_req(&ioreq->req, req); + blkif_get_x86_64_req(&request->req, req); break; } } @@ -527,7 +529,7 @@ static int blk_get_request(XenBlockDataPlane *dataplane, struct ioreq *ioreq, static void blk_handle_requests(XenBlockDataPlane *dataplane) { RING_IDX rc, rp; - struct ioreq *ioreq; + XenBlockRequest *request; dataplane->more_work = 0; @@ -541,18 +543,18 @@ static void blk_handle_requests(XenBlockDataPlane *dataplane) if (RING_REQUEST_CONS_OVERFLOW(&dataplane->rings.common, rc)) { break; } - ioreq = ioreq_start(dataplane); - if (ioreq == NULL) { + request = ioreq_start(dataplane); + if (request == NULL) { dataplane->more_work++; break; } - blk_get_request(dataplane, ioreq, rc); + blk_get_request(dataplane, request, rc); dataplane->rings.common.req_cons = ++rc; /* parse them */ - if (ioreq_parse(ioreq) != 0) { + if (ioreq_parse(request) != 0) { - switch (ioreq->req.operation) { + switch (request->req.operation) { case BLKIF_OP_READ: block_acct_invalid(blk_get_stats(dataplane->blk), BLOCK_ACCT_READ); @@ -568,7 +570,7 @@ static void blk_handle_requests(XenBlockDataPlane *dataplane) break; }; - if (blk_send_response_one(ioreq)) { + if (blk_send_response_one(request)) { Error *local_err = NULL; xen_device_notify_event_channel(dataplane->xendev, @@ -578,11 +580,11 @@ static void blk_handle_requests(XenBlockDataPlane *dataplane) error_report_err(local_err); } } - ioreq_release(ioreq, false); + ioreq_release(request, false); continue; } - ioreq_runio_qemu_aio(ioreq); + ioreq_runio_qemu_aio(request); } if (dataplane->more_work && @@ -636,17 +638,17 @@ XenBlockDataPlane *xen_block_dataplane_create(XenDevice *xendev, void xen_block_dataplane_destroy(XenBlockDataPlane *dataplane) { - struct ioreq *ioreq; + XenBlockRequest *request; if (!dataplane) { return; } while (!QLIST_EMPTY(&dataplane->freelist)) { - ioreq = QLIST_FIRST(&dataplane->freelist); - QLIST_REMOVE(ioreq, list); - qemu_iovec_destroy(&ioreq->v); - g_free(ioreq); + request = QLIST_FIRST(&dataplane->freelist); + QLIST_REMOVE(request, list); + qemu_iovec_destroy(&request->v); + g_free(request); } qemu_bh_delete(dataplane->bh); -- Anthony PERARD From mboxrd@z Thu Jan 1 00:00:00 1970 From: Anthony PERARD Subject: [PULL 14/25] xen: remove 'ioreq' struct/varable/field names from dataplane/xen-block.c Date: Thu, 10 Jan 2019 13:49:06 +0000 Message-ID: <20190110134917.16425-15-anthony.perard@citrix.com> References: <20190110134917.16425-1-anthony.perard@citrix.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ghasQ-0002Ck-HD for xen-devel@lists.xenproject.org; Thu, 10 Jan 2019 14:00:06 +0000 In-Reply-To: <20190110134917.16425-1-anthony.perard@citrix.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: Anthony PERARD , xen-devel@lists.xenproject.org, Paul Durrant List-Id: xen-devel@lists.xenproject.org RnJvbTogUGF1bCBEdXJyYW50IDxwYXVsLmR1cnJhbnRAY2l0cml4LmNvbT4KClRoaXMgaXMgYSBw dXJlbHkgY29zbWV0aWMgcGF0Y2ggdGhhdCBwdXJnZXMgdGhlIG5hbWUgJ2lvcmVxJyBmcm9tIHN0 cnVjdCwKdmFyaWFibGUgYW5kIGZpZWxkIG5hbWVzLiAoVGhpcyBuYW1lIGhhcyBiZWVuIHByb2Js ZW1hdGljIGZvciBhIGxvbmcgdGltZQphcyAnaW9yZXEnIGlzIHRoZSBuYW1lIHVzZWQgZm9yIGdl bmVyaWMgSS9PIHJlcXVlc3RzIGNvbWluZyBmcm9tIFhlbikuClRoZSBwYXRjaCByZXBsYWNlcyAn c3RydWN0IGlvcmVxJyB3aXRoIGEgbmV3ICdYZW5CbG9ja1JlcXVlc3QnIHR5cGUgYW5kCidpb3Jl cScgZmllbGQvdmFyaWFibGUgbmFtZXMgd2l0aCAncmVxdWVzdCcsIGFuZCB0aGVuIGRvZXMgbmVj ZXNzYXJ5CmZpeC11cCB0byBhZGhlcmUgdG8gY29kaW5nIHN0eWxlLgoKRnVuY3Rpb24gbmFtZXMg YXJlIG5vdCBtb2RpZmllZCBieSB0aGlzIHBhdGNoLiBUaGV5IHdpbGwgYmUgZGVhbHQgd2l0aCBp bgphIHN1YnNlcXVlbnQgcGF0Y2guCgpObyBmdW5jdGlvbmFsIGNoYW5nZS4KClNpZ25lZC1vZmYt Ynk6IFBhdWwgRHVycmFudCA8cGF1bC5kdXJyYW50QGNpdHJpeC5jb20+CkFja2VkLWJ5OiBBbnRo b255IFBlcmFyZCA8YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KU2lnbmVkLW9mZi1ieTogQW50 aG9ueSBQRVJBUkQgPGFudGhvbnkucGVyYXJkQGNpdHJpeC5jb20+Ci0tLQogaHcvYmxvY2svZGF0 YXBsYW5lL3hlbi1ibG9jay5jIHwgMzEwICsrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0t LQogMSBmaWxlIGNoYW5nZWQsIDE1NiBpbnNlcnRpb25zKCspLCAxNTQgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvaHcvYmxvY2svZGF0YXBsYW5lL3hlbi1ibG9jay5jIGIvaHcvYmxvY2svZGF0 YXBsYW5lL3hlbi1ibG9jay5jCmluZGV4IDFmZjQ2NDk3M2MuLjY3ODhiYmYzMzggMTAwNjQ0Ci0t LSBhL2h3L2Jsb2NrL2RhdGFwbGFuZS94ZW4tYmxvY2suYworKysgYi9ody9ibG9jay9kYXRhcGxh bmUveGVuLWJsb2NrLmMKQEAgLTI4LDcgKzI4LDcgQEAKICNpbmNsdWRlICJzeXNlbXUvaW90aHJl YWQuaCIKICNpbmNsdWRlICJ4ZW4tYmxvY2suaCIKIAotc3RydWN0IGlvcmVxIHsKK3R5cGVkZWYg c3RydWN0IFhlbkJsb2NrUmVxdWVzdCB7CiAgICAgYmxraWZfcmVxdWVzdF90IHJlcTsKICAgICBp bnQxNl90IHN0YXR1czsKICAgICBvZmZfdCBzdGFydDsKQEAgLTM5LDkgKzM5LDkgQEAgc3RydWN0 IGlvcmVxIHsKICAgICBpbnQgYWlvX2luZmxpZ2h0OwogICAgIGludCBhaW9fZXJyb3JzOwogICAg IFhlbkJsb2NrRGF0YVBsYW5lICpkYXRhcGxhbmU7Ci0gICAgUUxJU1RfRU5UUlkoaW9yZXEpIGxp c3Q7CisgICAgUUxJU1RfRU5UUlkoWGVuQmxvY2tSZXF1ZXN0KSBsaXN0OwogICAgIEJsb2NrQWNj dENvb2tpZSBhY2N0OwotfTsKK30gWGVuQmxvY2tSZXF1ZXN0OwogCiBzdHJ1Y3QgWGVuQmxvY2tE YXRhUGxhbmUgewogICAgIFhlbkRldmljZSAqeGVuZGV2OwpAQCAtNTQsOSArNTQsOSBAQCBzdHJ1 Y3QgWGVuQmxvY2tEYXRhUGxhbmUgewogICAgIGludCBwcm90b2NvbDsKICAgICBibGtpZl9iYWNr X3JpbmdzX3QgcmluZ3M7CiAgICAgaW50IG1vcmVfd29yazsKLSAgICBRTElTVF9IRUFEKGluZmxp Z2h0X2hlYWQsIGlvcmVxKSBpbmZsaWdodDsKLSAgICBRTElTVF9IRUFEKGZpbmlzaGVkX2hlYWQs IGlvcmVxKSBmaW5pc2hlZDsKLSAgICBRTElTVF9IRUFEKGZyZWVsaXN0X2hlYWQsIGlvcmVxKSBm cmVlbGlzdDsKKyAgICBRTElTVF9IRUFEKGluZmxpZ2h0X2hlYWQsIFhlbkJsb2NrUmVxdWVzdCkg aW5mbGlnaHQ7CisgICAgUUxJU1RfSEVBRChmaW5pc2hlZF9oZWFkLCBYZW5CbG9ja1JlcXVlc3Qp IGZpbmlzaGVkOworICAgIFFMSVNUX0hFQUQoZnJlZWxpc3RfaGVhZCwgWGVuQmxvY2tSZXF1ZXN0 KSBmcmVlbGlzdDsKICAgICBpbnQgcmVxdWVzdHNfdG90YWw7CiAgICAgaW50IHJlcXVlc3RzX2lu ZmxpZ2h0OwogICAgIGludCByZXF1ZXN0c19maW5pc2hlZDsKQEAgLTY3LDY4ICs2Nyw2OCBAQCBz dHJ1Y3QgWGVuQmxvY2tEYXRhUGxhbmUgewogICAgIEFpb0NvbnRleHQgKmN0eDsKIH07CiAKLXN0 YXRpYyB2b2lkIGlvcmVxX3Jlc2V0KHN0cnVjdCBpb3JlcSAqaW9yZXEpCitzdGF0aWMgdm9pZCBp b3JlcV9yZXNldChYZW5CbG9ja1JlcXVlc3QgKnJlcXVlc3QpCiB7Ci0gICAgbWVtc2V0KCZpb3Jl cS0+cmVxLCAwLCBzaXplb2YoaW9yZXEtPnJlcSkpOwotICAgIGlvcmVxLT5zdGF0dXMgPSAwOwot ICAgIGlvcmVxLT5zdGFydCA9IDA7Ci0gICAgaW9yZXEtPmJ1ZiA9IE5VTEw7Ci0gICAgaW9yZXEt PnNpemUgPSAwOwotICAgIGlvcmVxLT5wcmVzeW5jID0gMDsKKyAgICBtZW1zZXQoJnJlcXVlc3Qt PnJlcSwgMCwgc2l6ZW9mKHJlcXVlc3QtPnJlcSkpOworICAgIHJlcXVlc3QtPnN0YXR1cyA9IDA7 CisgICAgcmVxdWVzdC0+c3RhcnQgPSAwOworICAgIHJlcXVlc3QtPmJ1ZiA9IE5VTEw7CisgICAg cmVxdWVzdC0+c2l6ZSA9IDA7CisgICAgcmVxdWVzdC0+cHJlc3luYyA9IDA7CiAKLSAgICBpb3Jl cS0+YWlvX2luZmxpZ2h0ID0gMDsKLSAgICBpb3JlcS0+YWlvX2Vycm9ycyA9IDA7CisgICAgcmVx dWVzdC0+YWlvX2luZmxpZ2h0ID0gMDsKKyAgICByZXF1ZXN0LT5haW9fZXJyb3JzID0gMDsKIAot ICAgIGlvcmVxLT5kYXRhcGxhbmUgPSBOVUxMOwotICAgIG1lbXNldCgmaW9yZXEtPmxpc3QsIDAs IHNpemVvZihpb3JlcS0+bGlzdCkpOwotICAgIG1lbXNldCgmaW9yZXEtPmFjY3QsIDAsIHNpemVv Zihpb3JlcS0+YWNjdCkpOworICAgIHJlcXVlc3QtPmRhdGFwbGFuZSA9IE5VTEw7CisgICAgbWVt c2V0KCZyZXF1ZXN0LT5saXN0LCAwLCBzaXplb2YocmVxdWVzdC0+bGlzdCkpOworICAgIG1lbXNl dCgmcmVxdWVzdC0+YWNjdCwgMCwgc2l6ZW9mKHJlcXVlc3QtPmFjY3QpKTsKIAotICAgIHFlbXVf aW92ZWNfcmVzZXQoJmlvcmVxLT52KTsKKyAgICBxZW11X2lvdmVjX3Jlc2V0KCZyZXF1ZXN0LT52 KTsKIH0KIAotc3RhdGljIHN0cnVjdCBpb3JlcSAqaW9yZXFfc3RhcnQoWGVuQmxvY2tEYXRhUGxh bmUgKmRhdGFwbGFuZSkKK3N0YXRpYyBYZW5CbG9ja1JlcXVlc3QgKmlvcmVxX3N0YXJ0KFhlbkJs b2NrRGF0YVBsYW5lICpkYXRhcGxhbmUpCiB7Ci0gICAgc3RydWN0IGlvcmVxICppb3JlcSA9IE5V TEw7CisgICAgWGVuQmxvY2tSZXF1ZXN0ICpyZXF1ZXN0ID0gTlVMTDsKIAogICAgIGlmIChRTElT VF9FTVBUWSgmZGF0YXBsYW5lLT5mcmVlbGlzdCkpIHsKICAgICAgICAgaWYgKGRhdGFwbGFuZS0+ cmVxdWVzdHNfdG90YWwgPj0gZGF0YXBsYW5lLT5tYXhfcmVxdWVzdHMpIHsKICAgICAgICAgICAg IGdvdG8gb3V0OwogICAgICAgICB9CiAgICAgICAgIC8qIGFsbG9jYXRlIG5ldyBzdHJ1Y3QgKi8K LSAgICAgICAgaW9yZXEgPSBnX21hbGxvYzAoc2l6ZW9mKCppb3JlcSkpOwotICAgICAgICBpb3Jl cS0+ZGF0YXBsYW5lID0gZGF0YXBsYW5lOworICAgICAgICByZXF1ZXN0ID0gZ19tYWxsb2MwKHNp emVvZigqcmVxdWVzdCkpOworICAgICAgICByZXF1ZXN0LT5kYXRhcGxhbmUgPSBkYXRhcGxhbmU7 CiAgICAgICAgIGRhdGFwbGFuZS0+cmVxdWVzdHNfdG90YWwrKzsKLSAgICAgICAgcWVtdV9pb3Zl Y19pbml0KCZpb3JlcS0+diwgMSk7CisgICAgICAgIHFlbXVfaW92ZWNfaW5pdCgmcmVxdWVzdC0+ diwgMSk7CiAgICAgfSBlbHNlIHsKICAgICAgICAgLyogZ2V0IG9uZSBmcm9tIGZyZWVsaXN0ICov Ci0gICAgICAgIGlvcmVxID0gUUxJU1RfRklSU1QoJmRhdGFwbGFuZS0+ZnJlZWxpc3QpOwotICAg ICAgICBRTElTVF9SRU1PVkUoaW9yZXEsIGxpc3QpOworICAgICAgICByZXF1ZXN0ID0gUUxJU1Rf RklSU1QoJmRhdGFwbGFuZS0+ZnJlZWxpc3QpOworICAgICAgICBRTElTVF9SRU1PVkUocmVxdWVz dCwgbGlzdCk7CiAgICAgfQotICAgIFFMSVNUX0lOU0VSVF9IRUFEKCZkYXRhcGxhbmUtPmluZmxp Z2h0LCBpb3JlcSwgbGlzdCk7CisgICAgUUxJU1RfSU5TRVJUX0hFQUQoJmRhdGFwbGFuZS0+aW5m bGlnaHQsIHJlcXVlc3QsIGxpc3QpOwogICAgIGRhdGFwbGFuZS0+cmVxdWVzdHNfaW5mbGlnaHQr KzsKIAogb3V0OgotICAgIHJldHVybiBpb3JlcTsKKyAgICByZXR1cm4gcmVxdWVzdDsKIH0KIAot c3RhdGljIHZvaWQgaW9yZXFfZmluaXNoKHN0cnVjdCBpb3JlcSAqaW9yZXEpCitzdGF0aWMgdm9p ZCBpb3JlcV9maW5pc2goWGVuQmxvY2tSZXF1ZXN0ICpyZXF1ZXN0KQogewotICAgIFhlbkJsb2Nr RGF0YVBsYW5lICpkYXRhcGxhbmUgPSBpb3JlcS0+ZGF0YXBsYW5lOworICAgIFhlbkJsb2NrRGF0 YVBsYW5lICpkYXRhcGxhbmUgPSByZXF1ZXN0LT5kYXRhcGxhbmU7CiAKLSAgICBRTElTVF9SRU1P VkUoaW9yZXEsIGxpc3QpOwotICAgIFFMSVNUX0lOU0VSVF9IRUFEKCZkYXRhcGxhbmUtPmZpbmlz aGVkLCBpb3JlcSwgbGlzdCk7CisgICAgUUxJU1RfUkVNT1ZFKHJlcXVlc3QsIGxpc3QpOworICAg IFFMSVNUX0lOU0VSVF9IRUFEKCZkYXRhcGxhbmUtPmZpbmlzaGVkLCByZXF1ZXN0LCBsaXN0KTsK ICAgICBkYXRhcGxhbmUtPnJlcXVlc3RzX2luZmxpZ2h0LS07CiAgICAgZGF0YXBsYW5lLT5yZXF1 ZXN0c19maW5pc2hlZCsrOwogfQogCi1zdGF0aWMgdm9pZCBpb3JlcV9yZWxlYXNlKHN0cnVjdCBp b3JlcSAqaW9yZXEsIGJvb2wgZmluaXNoKQorc3RhdGljIHZvaWQgaW9yZXFfcmVsZWFzZShYZW5C bG9ja1JlcXVlc3QgKnJlcXVlc3QsIGJvb2wgZmluaXNoKQogewotICAgIFhlbkJsb2NrRGF0YVBs YW5lICpkYXRhcGxhbmUgPSBpb3JlcS0+ZGF0YXBsYW5lOworICAgIFhlbkJsb2NrRGF0YVBsYW5l ICpkYXRhcGxhbmUgPSByZXF1ZXN0LT5kYXRhcGxhbmU7CiAKLSAgICBRTElTVF9SRU1PVkUoaW9y ZXEsIGxpc3QpOwotICAgIGlvcmVxX3Jlc2V0KGlvcmVxKTsKLSAgICBpb3JlcS0+ZGF0YXBsYW5l ID0gZGF0YXBsYW5lOwotICAgIFFMSVNUX0lOU0VSVF9IRUFEKCZkYXRhcGxhbmUtPmZyZWVsaXN0 LCBpb3JlcSwgbGlzdCk7CisgICAgUUxJU1RfUkVNT1ZFKHJlcXVlc3QsIGxpc3QpOworICAgIGlv cmVxX3Jlc2V0KHJlcXVlc3QpOworICAgIHJlcXVlc3QtPmRhdGFwbGFuZSA9IGRhdGFwbGFuZTsK KyAgICBRTElTVF9JTlNFUlRfSEVBRCgmZGF0YXBsYW5lLT5mcmVlbGlzdCwgcmVxdWVzdCwgbGlz dCk7CiAgICAgaWYgKGZpbmlzaCkgewogICAgICAgICBkYXRhcGxhbmUtPnJlcXVlc3RzX2Zpbmlz aGVkLS07CiAgICAgfSBlbHNlIHsKQEAgLTE0MCwxOCArMTQwLDE4IEBAIHN0YXRpYyB2b2lkIGlv cmVxX3JlbGVhc2Uoc3RydWN0IGlvcmVxICppb3JlcSwgYm9vbCBmaW5pc2gpCiAgKiB0cmFuc2xh dGUgcmVxdWVzdCBpbnRvIGlvdmVjICsgc3RhcnQgb2Zmc2V0CiAgKiBkbyBzYW5pdHkgY2hlY2tz IGFsb25nIHRoZSB3YXkKICAqLwotc3RhdGljIGludCBpb3JlcV9wYXJzZShzdHJ1Y3QgaW9yZXEg KmlvcmVxKQorc3RhdGljIGludCBpb3JlcV9wYXJzZShYZW5CbG9ja1JlcXVlc3QgKnJlcXVlc3Qp CiB7Ci0gICAgWGVuQmxvY2tEYXRhUGxhbmUgKmRhdGFwbGFuZSA9IGlvcmVxLT5kYXRhcGxhbmU7 CisgICAgWGVuQmxvY2tEYXRhUGxhbmUgKmRhdGFwbGFuZSA9IHJlcXVlc3QtPmRhdGFwbGFuZTsK ICAgICBzaXplX3QgbGVuOwogICAgIGludCBpOwogCi0gICAgc3dpdGNoIChpb3JlcS0+cmVxLm9w ZXJhdGlvbikgeworICAgIHN3aXRjaCAocmVxdWVzdC0+cmVxLm9wZXJhdGlvbikgewogICAgIGNh c2UgQkxLSUZfT1BfUkVBRDoKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBCTEtJRl9PUF9GTFVT SF9ESVNLQ0FDSEU6Ci0gICAgICAgIGlvcmVxLT5wcmVzeW5jID0gMTsKLSAgICAgICAgaWYgKCFp b3JlcS0+cmVxLm5yX3NlZ21lbnRzKSB7CisgICAgICAgIHJlcXVlc3QtPnByZXN5bmMgPSAxOwor ICAgICAgICBpZiAoIXJlcXVlc3QtPnJlcS5ucl9zZWdtZW50cykgewogICAgICAgICAgICAgcmV0 dXJuIDA7CiAgICAgICAgIH0KICAgICAgICAgLyogZmFsbCB0aHJvdWdoICovCkBAIC0xNjAsNzcg KzE2MCw3OCBAQCBzdGF0aWMgaW50IGlvcmVxX3BhcnNlKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAg ICAgY2FzZSBCTEtJRl9PUF9ESVNDQVJEOgogICAgICAgICByZXR1cm4gMDsKICAgICBkZWZhdWx0 OgotICAgICAgICBlcnJvcl9yZXBvcnQoImVycm9yOiB1bmtub3duIG9wZXJhdGlvbiAoJWQpIiwg aW9yZXEtPnJlcS5vcGVyYXRpb24pOworICAgICAgICBlcnJvcl9yZXBvcnQoImVycm9yOiB1bmtu b3duIG9wZXJhdGlvbiAoJWQpIiwgcmVxdWVzdC0+cmVxLm9wZXJhdGlvbik7CiAgICAgICAgIGdv dG8gZXJyOwogICAgIH07CiAKLSAgICBpZiAoaW9yZXEtPnJlcS5vcGVyYXRpb24gIT0gQkxLSUZf T1BfUkVBRCAmJgorICAgIGlmIChyZXF1ZXN0LT5yZXEub3BlcmF0aW9uICE9IEJMS0lGX09QX1JF QUQgJiYKICAgICAgICAgYmxrX2lzX3JlYWRfb25seShkYXRhcGxhbmUtPmJsaykpIHsKICAgICAg ICAgZXJyb3JfcmVwb3J0KCJlcnJvcjogd3JpdGUgcmVxIGZvciBybyBkZXZpY2UiKTsKICAgICAg ICAgZ290byBlcnI7CiAgICAgfQogCi0gICAgaW9yZXEtPnN0YXJ0ID0gaW9yZXEtPnJlcS5zZWN0 b3JfbnVtYmVyICogZGF0YXBsYW5lLT5maWxlX2JsazsKLSAgICBmb3IgKGkgPSAwOyBpIDwgaW9y ZXEtPnJlcS5ucl9zZWdtZW50czsgaSsrKSB7CisgICAgcmVxdWVzdC0+c3RhcnQgPSByZXF1ZXN0 LT5yZXEuc2VjdG9yX251bWJlciAqIGRhdGFwbGFuZS0+ZmlsZV9ibGs7CisgICAgZm9yIChpID0g MDsgaSA8IHJlcXVlc3QtPnJlcS5ucl9zZWdtZW50czsgaSsrKSB7CiAgICAgICAgIGlmIChpID09 IEJMS0lGX01BWF9TRUdNRU5UU19QRVJfUkVRVUVTVCkgewogICAgICAgICAgICAgZXJyb3JfcmVw b3J0KCJlcnJvcjogbnJfc2VnbWVudHMgdG9vIGJpZyIpOwogICAgICAgICAgICAgZ290byBlcnI7 CiAgICAgICAgIH0KLSAgICAgICAgaWYgKGlvcmVxLT5yZXEuc2VnW2ldLmZpcnN0X3NlY3QgPiBp b3JlcS0+cmVxLnNlZ1tpXS5sYXN0X3NlY3QpIHsKKyAgICAgICAgaWYgKHJlcXVlc3QtPnJlcS5z ZWdbaV0uZmlyc3Rfc2VjdCA+IHJlcXVlc3QtPnJlcS5zZWdbaV0ubGFzdF9zZWN0KSB7CiAgICAg ICAgICAgICBlcnJvcl9yZXBvcnQoImVycm9yOiBmaXJzdCA+IGxhc3Qgc2VjdG9yIik7CiAgICAg ICAgICAgICBnb3RvIGVycjsKICAgICAgICAgfQotICAgICAgICBpZiAoaW9yZXEtPnJlcS5zZWdb aV0ubGFzdF9zZWN0ICogZGF0YXBsYW5lLT5maWxlX2JsayA+PSBYQ19QQUdFX1NJWkUpIHsKKyAg ICAgICAgaWYgKHJlcXVlc3QtPnJlcS5zZWdbaV0ubGFzdF9zZWN0ICogZGF0YXBsYW5lLT5maWxl X2JsayA+PQorICAgICAgICAgICAgWENfUEFHRV9TSVpFKSB7CiAgICAgICAgICAgICBlcnJvcl9y ZXBvcnQoImVycm9yOiBwYWdlIGNyb3NzaW5nIik7CiAgICAgICAgICAgICBnb3RvIGVycjsKICAg ICAgICAgfQogCi0gICAgICAgIGxlbiA9IChpb3JlcS0+cmVxLnNlZ1tpXS5sYXN0X3NlY3QgLQot ICAgICAgICAgICAgICAgaW9yZXEtPnJlcS5zZWdbaV0uZmlyc3Rfc2VjdCArIDEpICogZGF0YXBs YW5lLT5maWxlX2JsazsKLSAgICAgICAgaW9yZXEtPnNpemUgKz0gbGVuOworICAgICAgICBsZW4g PSAocmVxdWVzdC0+cmVxLnNlZ1tpXS5sYXN0X3NlY3QgLQorICAgICAgICAgICAgICAgcmVxdWVz dC0+cmVxLnNlZ1tpXS5maXJzdF9zZWN0ICsgMSkgKiBkYXRhcGxhbmUtPmZpbGVfYmxrOworICAg ICAgICByZXF1ZXN0LT5zaXplICs9IGxlbjsKICAgICB9Ci0gICAgaWYgKGlvcmVxLT5zdGFydCAr IGlvcmVxLT5zaXplID4gZGF0YXBsYW5lLT5maWxlX3NpemUpIHsKKyAgICBpZiAocmVxdWVzdC0+ c3RhcnQgKyByZXF1ZXN0LT5zaXplID4gZGF0YXBsYW5lLT5maWxlX3NpemUpIHsKICAgICAgICAg ZXJyb3JfcmVwb3J0KCJlcnJvcjogYWNjZXNzIGJleW9uZCBlbmQgb2YgZmlsZSIpOwogICAgICAg ICBnb3RvIGVycjsKICAgICB9CiAgICAgcmV0dXJuIDA7CiAKIGVycjoKLSAgICBpb3JlcS0+c3Rh dHVzID0gQkxLSUZfUlNQX0VSUk9SOworICAgIHJlcXVlc3QtPnN0YXR1cyA9IEJMS0lGX1JTUF9F UlJPUjsKICAgICByZXR1cm4gLTE7CiB9CiAKLXN0YXRpYyBpbnQgaW9yZXFfZ3JhbnRfY29weShz dHJ1Y3QgaW9yZXEgKmlvcmVxKQorc3RhdGljIGludCBpb3JlcV9ncmFudF9jb3B5KFhlbkJsb2Nr UmVxdWVzdCAqcmVxdWVzdCkKIHsKLSAgICBYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lID0g aW9yZXEtPmRhdGFwbGFuZTsKKyAgICBYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lID0gcmVx dWVzdC0+ZGF0YXBsYW5lOwogICAgIFhlbkRldmljZSAqeGVuZGV2ID0gZGF0YXBsYW5lLT54ZW5k ZXY7CiAgICAgWGVuRGV2aWNlR3JhbnRDb3B5U2VnbWVudCBzZWdzW0JMS0lGX01BWF9TRUdNRU5U U19QRVJfUkVRVUVTVF07CiAgICAgaW50IGksIGNvdW50OwogICAgIGludDY0X3QgZmlsZV9ibGsg PSBkYXRhcGxhbmUtPmZpbGVfYmxrOwotICAgIGJvb2wgdG9fZG9tYWluID0gKGlvcmVxLT5yZXEu b3BlcmF0aW9uID09IEJMS0lGX09QX1JFQUQpOwotICAgIHZvaWQgKnZpcnQgPSBpb3JlcS0+YnVm OworICAgIGJvb2wgdG9fZG9tYWluID0gKHJlcXVlc3QtPnJlcS5vcGVyYXRpb24gPT0gQkxLSUZf T1BfUkVBRCk7CisgICAgdm9pZCAqdmlydCA9IHJlcXVlc3QtPmJ1ZjsKICAgICBFcnJvciAqbG9j YWxfZXJyID0gTlVMTDsKIAotICAgIGlmIChpb3JlcS0+cmVxLm5yX3NlZ21lbnRzID09IDApIHsK KyAgICBpZiAocmVxdWVzdC0+cmVxLm5yX3NlZ21lbnRzID09IDApIHsKICAgICAgICAgcmV0dXJu IDA7CiAgICAgfQogCi0gICAgY291bnQgPSBpb3JlcS0+cmVxLm5yX3NlZ21lbnRzOworICAgIGNv dW50ID0gcmVxdWVzdC0+cmVxLm5yX3NlZ21lbnRzOwogCiAgICAgZm9yIChpID0gMDsgaSA8IGNv dW50OyBpKyspIHsKICAgICAgICAgaWYgKHRvX2RvbWFpbikgewotICAgICAgICAgICAgc2Vnc1tp XS5kZXN0LmZvcmVpZ24ucmVmID0gaW9yZXEtPnJlcS5zZWdbaV0uZ3JlZjsKLSAgICAgICAgICAg IHNlZ3NbaV0uZGVzdC5mb3JlaWduLm9mZnNldCA9IGlvcmVxLT5yZXEuc2VnW2ldLmZpcnN0X3Nl Y3QgKgorICAgICAgICAgICAgc2Vnc1tpXS5kZXN0LmZvcmVpZ24ucmVmID0gcmVxdWVzdC0+cmVx LnNlZ1tpXS5ncmVmOworICAgICAgICAgICAgc2Vnc1tpXS5kZXN0LmZvcmVpZ24ub2Zmc2V0ID0g cmVxdWVzdC0+cmVxLnNlZ1tpXS5maXJzdF9zZWN0ICoKICAgICAgICAgICAgICAgICBmaWxlX2Js azsKICAgICAgICAgICAgIHNlZ3NbaV0uc291cmNlLnZpcnQgPSB2aXJ0OwogICAgICAgICB9IGVs c2UgewotICAgICAgICAgICAgc2Vnc1tpXS5zb3VyY2UuZm9yZWlnbi5yZWYgPSBpb3JlcS0+cmVx LnNlZ1tpXS5ncmVmOwotICAgICAgICAgICAgc2Vnc1tpXS5zb3VyY2UuZm9yZWlnbi5vZmZzZXQg PSBpb3JlcS0+cmVxLnNlZ1tpXS5maXJzdF9zZWN0ICoKKyAgICAgICAgICAgIHNlZ3NbaV0uc291 cmNlLmZvcmVpZ24ucmVmID0gcmVxdWVzdC0+cmVxLnNlZ1tpXS5ncmVmOworICAgICAgICAgICAg c2Vnc1tpXS5zb3VyY2UuZm9yZWlnbi5vZmZzZXQgPSByZXF1ZXN0LT5yZXEuc2VnW2ldLmZpcnN0 X3NlY3QgKgogICAgICAgICAgICAgICAgIGZpbGVfYmxrOwogICAgICAgICAgICAgc2Vnc1tpXS5k ZXN0LnZpcnQgPSB2aXJ0OwogICAgICAgICB9Ci0gICAgICAgIHNlZ3NbaV0ubGVuID0gKGlvcmVx LT5yZXEuc2VnW2ldLmxhc3Rfc2VjdCAtCi0gICAgICAgICAgICAgICAgICAgICAgIGlvcmVxLT5y ZXEuc2VnW2ldLmZpcnN0X3NlY3QgKyAxKSAqIGZpbGVfYmxrOworICAgICAgICBzZWdzW2ldLmxl biA9IChyZXF1ZXN0LT5yZXEuc2VnW2ldLmxhc3Rfc2VjdCAtCisgICAgICAgICAgICAgICAgICAg ICAgIHJlcXVlc3QtPnJlcS5zZWdbaV0uZmlyc3Rfc2VjdCArIDEpICogZmlsZV9ibGs7CiAgICAg ICAgIHZpcnQgKz0gc2Vnc1tpXS5sZW47CiAgICAgfQogCkBAIC0yMzksNzIgKzI0MCw3MiBAQCBz dGF0aWMgaW50IGlvcmVxX2dyYW50X2NvcHkoc3RydWN0IGlvcmVxICppb3JlcSkKICAgICBpZiAo bG9jYWxfZXJyKSB7CiAgICAgICAgIGVycm9yX3JlcG9ydGZfZXJyKGxvY2FsX2VyciwgImZhaWxl ZCB0byBjb3B5IGRhdGE6ICIpOwogCi0gICAgICAgIGlvcmVxLT5haW9fZXJyb3JzKys7CisgICAg ICAgIHJlcXVlc3QtPmFpb19lcnJvcnMrKzsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KIAog ICAgIHJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGlvcmVxX3J1bmlvX3FlbXVfYWlvKHN0cnVj dCBpb3JlcSAqaW9yZXEpOworc3RhdGljIGludCBpb3JlcV9ydW5pb19xZW11X2FpbyhYZW5CbG9j a1JlcXVlc3QgKnJlcXVlc3QpOwogCiBzdGF0aWMgdm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2b2lk ICpvcGFxdWUsIGludCByZXQpCiB7Ci0gICAgc3RydWN0IGlvcmVxICppb3JlcSA9IG9wYXF1ZTsK LSAgICBYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lID0gaW9yZXEtPmRhdGFwbGFuZTsKKyAg ICBYZW5CbG9ja1JlcXVlc3QgKnJlcXVlc3QgPSBvcGFxdWU7CisgICAgWGVuQmxvY2tEYXRhUGxh bmUgKmRhdGFwbGFuZSA9IHJlcXVlc3QtPmRhdGFwbGFuZTsKIAogICAgIGFpb19jb250ZXh0X2Fj cXVpcmUoZGF0YXBsYW5lLT5jdHgpOwogCiAgICAgaWYgKHJldCAhPSAwKSB7CiAgICAgICAgIGVy cm9yX3JlcG9ydCgiJXMgSS9PIGVycm9yIiwKLSAgICAgICAgICAgICAgICAgICAgIGlvcmVxLT5y ZXEub3BlcmF0aW9uID09IEJMS0lGX09QX1JFQUQgPworICAgICAgICAgICAgICAgICAgICAgcmVx dWVzdC0+cmVxLm9wZXJhdGlvbiA9PSBCTEtJRl9PUF9SRUFEID8KICAgICAgICAgICAgICAgICAg ICAgICJyZWFkIiA6ICJ3cml0ZSIpOwotICAgICAgICBpb3JlcS0+YWlvX2Vycm9ycysrOworICAg ICAgICByZXF1ZXN0LT5haW9fZXJyb3JzKys7CiAgICAgfQogCi0gICAgaW9yZXEtPmFpb19pbmZs aWdodC0tOwotICAgIGlmIChpb3JlcS0+cHJlc3luYykgewotICAgICAgICBpb3JlcS0+cHJlc3lu YyA9IDA7Ci0gICAgICAgIGlvcmVxX3J1bmlvX3FlbXVfYWlvKGlvcmVxKTsKKyAgICByZXF1ZXN0 LT5haW9faW5mbGlnaHQtLTsKKyAgICBpZiAocmVxdWVzdC0+cHJlc3luYykgeworICAgICAgICBy ZXF1ZXN0LT5wcmVzeW5jID0gMDsKKyAgICAgICAgaW9yZXFfcnVuaW9fcWVtdV9haW8ocmVxdWVz dCk7CiAgICAgICAgIGdvdG8gZG9uZTsKICAgICB9Ci0gICAgaWYgKGlvcmVxLT5haW9faW5mbGln aHQgPiAwKSB7CisgICAgaWYgKHJlcXVlc3QtPmFpb19pbmZsaWdodCA+IDApIHsKICAgICAgICAg Z290byBkb25lOwogICAgIH0KIAotICAgIHN3aXRjaCAoaW9yZXEtPnJlcS5vcGVyYXRpb24pIHsK KyAgICBzd2l0Y2ggKHJlcXVlc3QtPnJlcS5vcGVyYXRpb24pIHsKICAgICBjYXNlIEJMS0lGX09Q X1JFQUQ6Ci0gICAgICAgIC8qIGluIGNhc2Ugb2YgZmFpbHVyZSBpb3JlcS0+YWlvX2Vycm9ycyBp cyBpbmNyZWFzZWQgKi8KKyAgICAgICAgLyogaW4gY2FzZSBvZiBmYWlsdXJlIHJlcXVlc3QtPmFp b19lcnJvcnMgaXMgaW5jcmVhc2VkICovCiAgICAgICAgIGlmIChyZXQgPT0gMCkgewotICAgICAg ICAgICAgaW9yZXFfZ3JhbnRfY29weShpb3JlcSk7CisgICAgICAgICAgICBpb3JlcV9ncmFudF9j b3B5KHJlcXVlc3QpOwogICAgICAgICB9Ci0gICAgICAgIHFlbXVfdmZyZWUoaW9yZXEtPmJ1Zik7 CisgICAgICAgIHFlbXVfdmZyZWUocmVxdWVzdC0+YnVmKTsKICAgICAgICAgYnJlYWs7CiAgICAg Y2FzZSBCTEtJRl9PUF9XUklURToKICAgICBjYXNlIEJMS0lGX09QX0ZMVVNIX0RJU0tDQUNIRToK LSAgICAgICAgaWYgKCFpb3JlcS0+cmVxLm5yX3NlZ21lbnRzKSB7CisgICAgICAgIGlmICghcmVx dWVzdC0+cmVxLm5yX3NlZ21lbnRzKSB7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQot ICAgICAgICBxZW11X3ZmcmVlKGlvcmVxLT5idWYpOworICAgICAgICBxZW11X3ZmcmVlKHJlcXVl c3QtPmJ1Zik7CiAgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIGJyZWFrOwog ICAgIH0KIAotICAgIGlvcmVxLT5zdGF0dXMgPSBpb3JlcS0+YWlvX2Vycm9ycyA/IEJMS0lGX1JT UF9FUlJPUiA6IEJMS0lGX1JTUF9PS0FZOwotICAgIGlvcmVxX2ZpbmlzaChpb3JlcSk7CisgICAg cmVxdWVzdC0+c3RhdHVzID0gcmVxdWVzdC0+YWlvX2Vycm9ycyA/IEJMS0lGX1JTUF9FUlJPUiA6 IEJMS0lGX1JTUF9PS0FZOworICAgIGlvcmVxX2ZpbmlzaChyZXF1ZXN0KTsKIAotICAgIHN3aXRj aCAoaW9yZXEtPnJlcS5vcGVyYXRpb24pIHsKKyAgICBzd2l0Y2ggKHJlcXVlc3QtPnJlcS5vcGVy YXRpb24pIHsKICAgICBjYXNlIEJMS0lGX09QX1dSSVRFOgogICAgIGNhc2UgQkxLSUZfT1BfRkxV U0hfRElTS0NBQ0hFOgotICAgICAgICBpZiAoIWlvcmVxLT5yZXEubnJfc2VnbWVudHMpIHsKKyAg ICAgICAgaWYgKCFyZXF1ZXN0LT5yZXEubnJfc2VnbWVudHMpIHsKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICB9CiAgICAgY2FzZSBCTEtJRl9PUF9SRUFEOgotICAgICAgICBpZiAoaW9yZXEt PnN0YXR1cyA9PSBCTEtJRl9SU1BfT0tBWSkgewotICAgICAgICAgICAgYmxvY2tfYWNjdF9kb25l KGJsa19nZXRfc3RhdHMoZGF0YXBsYW5lLT5ibGspLCAmaW9yZXEtPmFjY3QpOworICAgICAgICBp ZiAocmVxdWVzdC0+c3RhdHVzID09IEJMS0lGX1JTUF9PS0FZKSB7CisgICAgICAgICAgICBibG9j a19hY2N0X2RvbmUoYmxrX2dldF9zdGF0cyhkYXRhcGxhbmUtPmJsayksICZyZXF1ZXN0LT5hY2N0 KTsKICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIGJsb2NrX2FjY3RfZmFpbGVkKGJsa19n ZXRfc3RhdHMoZGF0YXBsYW5lLT5ibGspLCAmaW9yZXEtPmFjY3QpOworICAgICAgICAgICAgYmxv Y2tfYWNjdF9mYWlsZWQoYmxrX2dldF9zdGF0cyhkYXRhcGxhbmUtPmJsayksICZyZXF1ZXN0LT5h Y2N0KTsKICAgICAgICAgfQogICAgICAgICBicmVhazsKICAgICBjYXNlIEJMS0lGX09QX0RJU0NB UkQ6CkBAIC0zMTcsMTAgKzMxOCwxMSBAQCBzdGF0aWMgdm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2 b2lkICpvcGFxdWUsIGludCByZXQpCiAgICAgYWlvX2NvbnRleHRfcmVsZWFzZShkYXRhcGxhbmUt PmN0eCk7CiB9CiAKLXN0YXRpYyBib29sIGJsa19zcGxpdF9kaXNjYXJkKHN0cnVjdCBpb3JlcSAq aW9yZXEsIGJsa2lmX3NlY3Rvcl90IHNlY3Rvcl9udW1iZXIsCitzdGF0aWMgYm9vbCBibGtfc3Bs aXRfZGlzY2FyZChYZW5CbG9ja1JlcXVlc3QgKnJlcXVlc3QsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBibGtpZl9zZWN0b3JfdCBzZWN0b3JfbnVtYmVyLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdWludDY0X3QgbnJfc2VjdG9ycykKIHsKLSAgICBYZW5CbG9ja0RhdGFQ bGFuZSAqZGF0YXBsYW5lID0gaW9yZXEtPmRhdGFwbGFuZTsKKyAgICBYZW5CbG9ja0RhdGFQbGFu ZSAqZGF0YXBsYW5lID0gcmVxdWVzdC0+ZGF0YXBsYW5lOwogICAgIGludDY0X3QgYnl0ZV9vZmZz ZXQ7CiAgICAgaW50IGJ5dGVfY2h1bms7CiAgICAgdWludDY0X3QgYnl0ZV9yZW1haW5pbmcsIGxp bWl0OwpAQCAtMzM5LDkgKzM0MSw5IEBAIHN0YXRpYyBib29sIGJsa19zcGxpdF9kaXNjYXJkKHN0 cnVjdCBpb3JlcSAqaW9yZXEsIGJsa2lmX3NlY3Rvcl90IHNlY3Rvcl9udW1iZXIsCiAKICAgICBk byB7CiAgICAgICAgIGJ5dGVfY2h1bmsgPSBieXRlX3JlbWFpbmluZyA+IGxpbWl0ID8gbGltaXQg OiBieXRlX3JlbWFpbmluZzsKLSAgICAgICAgaW9yZXEtPmFpb19pbmZsaWdodCsrOworICAgICAg ICByZXF1ZXN0LT5haW9faW5mbGlnaHQrKzsKICAgICAgICAgYmxrX2Fpb19wZGlzY2FyZChkYXRh cGxhbmUtPmJsaywgYnl0ZV9vZmZzZXQsIGJ5dGVfY2h1bmssCi0gICAgICAgICAgICAgICAgICAg ICAgICAgcWVtdV9haW9fY29tcGxldGUsIGlvcmVxKTsKKyAgICAgICAgICAgICAgICAgICAgICAg ICBxZW11X2Fpb19jb21wbGV0ZSwgcmVxdWVzdCk7CiAgICAgICAgIGJ5dGVfcmVtYWluaW5nIC09 IGJ5dGVfY2h1bms7CiAgICAgICAgIGJ5dGVfb2Zmc2V0ICs9IGJ5dGVfY2h1bms7CiAgICAgfSB3 aGlsZSAoYnl0ZV9yZW1haW5pbmcgPiAwKTsKQEAgLTM0OSw1MyArMzUxLDUzIEBAIHN0YXRpYyBi b29sIGJsa19zcGxpdF9kaXNjYXJkKHN0cnVjdCBpb3JlcSAqaW9yZXEsIGJsa2lmX3NlY3Rvcl90 IHNlY3Rvcl9udW1iZXIsCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLXN0YXRpYyBpbnQgaW9yZXFf cnVuaW9fcWVtdV9haW8oc3RydWN0IGlvcmVxICppb3JlcSkKK3N0YXRpYyBpbnQgaW9yZXFfcnVu aW9fcWVtdV9haW8oWGVuQmxvY2tSZXF1ZXN0ICpyZXF1ZXN0KQogewotICAgIFhlbkJsb2NrRGF0 YVBsYW5lICpkYXRhcGxhbmUgPSBpb3JlcS0+ZGF0YXBsYW5lOwotCi0gICAgaW9yZXEtPmJ1ZiA9 IHFlbXVfbWVtYWxpZ24oWENfUEFHRV9TSVpFLCBpb3JlcS0+c2l6ZSk7Ci0gICAgaWYgKGlvcmVx LT5yZXEubnJfc2VnbWVudHMgJiYKLSAgICAgICAgKGlvcmVxLT5yZXEub3BlcmF0aW9uID09IEJM S0lGX09QX1dSSVRFIHx8Ci0gICAgICAgICBpb3JlcS0+cmVxLm9wZXJhdGlvbiA9PSBCTEtJRl9P UF9GTFVTSF9ESVNLQ0FDSEUpICYmCi0gICAgICAgIGlvcmVxX2dyYW50X2NvcHkoaW9yZXEpKSB7 Ci0gICAgICAgIHFlbXVfdmZyZWUoaW9yZXEtPmJ1Zik7CisgICAgWGVuQmxvY2tEYXRhUGxhbmUg KmRhdGFwbGFuZSA9IHJlcXVlc3QtPmRhdGFwbGFuZTsKKworICAgIHJlcXVlc3QtPmJ1ZiA9IHFl bXVfbWVtYWxpZ24oWENfUEFHRV9TSVpFLCByZXF1ZXN0LT5zaXplKTsKKyAgICBpZiAocmVxdWVz dC0+cmVxLm5yX3NlZ21lbnRzICYmCisgICAgICAgIChyZXF1ZXN0LT5yZXEub3BlcmF0aW9uID09 IEJMS0lGX09QX1dSSVRFIHx8CisgICAgICAgICByZXF1ZXN0LT5yZXEub3BlcmF0aW9uID09IEJM S0lGX09QX0ZMVVNIX0RJU0tDQUNIRSkgJiYKKyAgICAgICAgaW9yZXFfZ3JhbnRfY29weShyZXF1 ZXN0KSkgeworICAgICAgICBxZW11X3ZmcmVlKHJlcXVlc3QtPmJ1Zik7CiAgICAgICAgIGdvdG8g ZXJyOwogICAgIH0KIAotICAgIGlvcmVxLT5haW9faW5mbGlnaHQrKzsKLSAgICBpZiAoaW9yZXEt PnByZXN5bmMpIHsKLSAgICAgICAgYmxrX2Fpb19mbHVzaChpb3JlcS0+ZGF0YXBsYW5lLT5ibGss IHFlbXVfYWlvX2NvbXBsZXRlLCBpb3JlcSk7CisgICAgcmVxdWVzdC0+YWlvX2luZmxpZ2h0Kys7 CisgICAgaWYgKHJlcXVlc3QtPnByZXN5bmMpIHsKKyAgICAgICAgYmxrX2Fpb19mbHVzaChyZXF1 ZXN0LT5kYXRhcGxhbmUtPmJsaywgcWVtdV9haW9fY29tcGxldGUsIHJlcXVlc3QpOwogICAgICAg ICByZXR1cm4gMDsKICAgICB9CiAKLSAgICBzd2l0Y2ggKGlvcmVxLT5yZXEub3BlcmF0aW9uKSB7 CisgICAgc3dpdGNoIChyZXF1ZXN0LT5yZXEub3BlcmF0aW9uKSB7CiAgICAgY2FzZSBCTEtJRl9P UF9SRUFEOgotICAgICAgICBxZW11X2lvdmVjX2FkZCgmaW9yZXEtPnYsIGlvcmVxLT5idWYsIGlv cmVxLT5zaXplKTsKLSAgICAgICAgYmxvY2tfYWNjdF9zdGFydChibGtfZ2V0X3N0YXRzKGRhdGFw bGFuZS0+YmxrKSwgJmlvcmVxLT5hY2N0LAotICAgICAgICAgICAgICAgICAgICAgICAgIGlvcmVx LT52LnNpemUsIEJMT0NLX0FDQ1RfUkVBRCk7Ci0gICAgICAgIGlvcmVxLT5haW9faW5mbGlnaHQr KzsKLSAgICAgICAgYmxrX2Fpb19wcmVhZHYoZGF0YXBsYW5lLT5ibGssIGlvcmVxLT5zdGFydCwg JmlvcmVxLT52LCAwLAotICAgICAgICAgICAgICAgICAgICAgICBxZW11X2Fpb19jb21wbGV0ZSwg aW9yZXEpOworICAgICAgICBxZW11X2lvdmVjX2FkZCgmcmVxdWVzdC0+diwgcmVxdWVzdC0+YnVm LCByZXF1ZXN0LT5zaXplKTsKKyAgICAgICAgYmxvY2tfYWNjdF9zdGFydChibGtfZ2V0X3N0YXRz KGRhdGFwbGFuZS0+YmxrKSwgJnJlcXVlc3QtPmFjY3QsCisgICAgICAgICAgICAgICAgICAgICAg ICAgcmVxdWVzdC0+di5zaXplLCBCTE9DS19BQ0NUX1JFQUQpOworICAgICAgICByZXF1ZXN0LT5h aW9faW5mbGlnaHQrKzsKKyAgICAgICAgYmxrX2Fpb19wcmVhZHYoZGF0YXBsYW5lLT5ibGssIHJl cXVlc3QtPnN0YXJ0LCAmcmVxdWVzdC0+diwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgcWVt dV9haW9fY29tcGxldGUsIHJlcXVlc3QpOwogICAgICAgICBicmVhazsKICAgICBjYXNlIEJMS0lG X09QX1dSSVRFOgogICAgIGNhc2UgQkxLSUZfT1BfRkxVU0hfRElTS0NBQ0hFOgotICAgICAgICBp ZiAoIWlvcmVxLT5yZXEubnJfc2VnbWVudHMpIHsKKyAgICAgICAgaWYgKCFyZXF1ZXN0LT5yZXEu bnJfc2VnbWVudHMpIHsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAKLSAgICAgICAg cWVtdV9pb3ZlY19hZGQoJmlvcmVxLT52LCBpb3JlcS0+YnVmLCBpb3JlcS0+c2l6ZSk7Ci0gICAg ICAgIGJsb2NrX2FjY3Rfc3RhcnQoYmxrX2dldF9zdGF0cyhkYXRhcGxhbmUtPmJsayksICZpb3Jl cS0+YWNjdCwKLSAgICAgICAgICAgICAgICAgICAgICAgICBpb3JlcS0+di5zaXplLAotICAgICAg ICAgICAgICAgICAgICAgICAgIGlvcmVxLT5yZXEub3BlcmF0aW9uID09IEJMS0lGX09QX1dSSVRF ID8KKyAgICAgICAgcWVtdV9pb3ZlY19hZGQoJnJlcXVlc3QtPnYsIHJlcXVlc3QtPmJ1ZiwgcmVx dWVzdC0+c2l6ZSk7CisgICAgICAgIGJsb2NrX2FjY3Rfc3RhcnQoYmxrX2dldF9zdGF0cyhkYXRh cGxhbmUtPmJsayksICZyZXF1ZXN0LT5hY2N0LAorICAgICAgICAgICAgICAgICAgICAgICAgIHJl cXVlc3QtPnYuc2l6ZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICByZXF1ZXN0LT5yZXEub3Bl cmF0aW9uID09IEJMS0lGX09QX1dSSVRFID8KICAgICAgICAgICAgICAgICAgICAgICAgICBCTE9D S19BQ0NUX1dSSVRFIDogQkxPQ0tfQUNDVF9GTFVTSCk7Ci0gICAgICAgIGlvcmVxLT5haW9faW5m bGlnaHQrKzsKLSAgICAgICAgYmxrX2Fpb19wd3JpdGV2KGRhdGFwbGFuZS0+YmxrLCBpb3JlcS0+ c3RhcnQsICZpb3JlcS0+diwgMCwKLSAgICAgICAgICAgICAgICAgICAgICAgIHFlbXVfYWlvX2Nv bXBsZXRlLCBpb3JlcSk7CisgICAgICAgIHJlcXVlc3QtPmFpb19pbmZsaWdodCsrOworICAgICAg ICBibGtfYWlvX3B3cml0ZXYoZGF0YXBsYW5lLT5ibGssIHJlcXVlc3QtPnN0YXJ0LCAmcmVxdWVz dC0+diwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgIHFlbXVfYWlvX2NvbXBsZXRlLCByZXF1 ZXN0KTsKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBCTEtJRl9PUF9ESVNDQVJEOgogICAgIHsK LSAgICAgICAgc3RydWN0IGJsa2lmX3JlcXVlc3RfZGlzY2FyZCAqcmVxID0gKHZvaWQgKikmaW9y ZXEtPnJlcTsKLSAgICAgICAgaWYgKCFibGtfc3BsaXRfZGlzY2FyZChpb3JlcSwgcmVxLT5zZWN0 b3JfbnVtYmVyLCByZXEtPm5yX3NlY3RvcnMpKSB7CisgICAgICAgIHN0cnVjdCBibGtpZl9yZXF1 ZXN0X2Rpc2NhcmQgKnJlcSA9ICh2b2lkICopJnJlcXVlc3QtPnJlcTsKKyAgICAgICAgaWYgKCFi bGtfc3BsaXRfZGlzY2FyZChyZXF1ZXN0LCByZXEtPnNlY3Rvcl9udW1iZXIsIHJlcS0+bnJfc2Vj dG9ycykpIHsKICAgICAgICAgICAgIGdvdG8gZXJyOwogICAgICAgICB9CiAgICAgICAgIGJyZWFr OwpAQCAtNDA1LDE5ICs0MDcsMTkgQEAgc3RhdGljIGludCBpb3JlcV9ydW5pb19xZW11X2Fpbyhz dHJ1Y3QgaW9yZXEgKmlvcmVxKQogICAgICAgICBnb3RvIGVycjsKICAgICB9CiAKLSAgICBxZW11 X2Fpb19jb21wbGV0ZShpb3JlcSwgMCk7CisgICAgcWVtdV9haW9fY29tcGxldGUocmVxdWVzdCwg MCk7CiAKICAgICByZXR1cm4gMDsKIAogZXJyOgotICAgIGlvcmVxX2ZpbmlzaChpb3JlcSk7Ci0g ICAgaW9yZXEtPnN0YXR1cyA9IEJMS0lGX1JTUF9FUlJPUjsKKyAgICBpb3JlcV9maW5pc2gocmVx dWVzdCk7CisgICAgcmVxdWVzdC0+c3RhdHVzID0gQkxLSUZfUlNQX0VSUk9SOwogICAgIHJldHVy biAtMTsKIH0KIAotc3RhdGljIGludCBibGtfc2VuZF9yZXNwb25zZV9vbmUoc3RydWN0IGlvcmVx ICppb3JlcSkKK3N0YXRpYyBpbnQgYmxrX3NlbmRfcmVzcG9uc2Vfb25lKFhlbkJsb2NrUmVxdWVz dCAqcmVxdWVzdCkKIHsKLSAgICBYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lID0gaW9yZXEt PmRhdGFwbGFuZTsKKyAgICBYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lID0gcmVxdWVzdC0+ ZGF0YXBsYW5lOwogICAgIGludCBzZW5kX25vdGlmeSA9IDA7CiAgICAgaW50IGhhdmVfcmVxdWVz dHMgPSAwOwogICAgIGJsa2lmX3Jlc3BvbnNlX3QgKnJlc3A7CkBAIC00NDMsOSArNDQ1LDkgQEAg c3RhdGljIGludCBibGtfc2VuZF9yZXNwb25zZV9vbmUoc3RydWN0IGlvcmVxICppb3JlcSkKICAg ICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgcmVzcC0+aWQgPSBpb3JlcS0+cmVxLmlkOwot ICAgIHJlc3AtPm9wZXJhdGlvbiA9IGlvcmVxLT5yZXEub3BlcmF0aW9uOwotICAgIHJlc3AtPnN0 YXR1cyA9IGlvcmVxLT5zdGF0dXM7CisgICAgcmVzcC0+aWQgPSByZXF1ZXN0LT5yZXEuaWQ7Cisg ICAgcmVzcC0+b3BlcmF0aW9uID0gcmVxdWVzdC0+cmVxLm9wZXJhdGlvbjsKKyAgICByZXNwLT5z dGF0dXMgPSByZXF1ZXN0LT5zdGF0dXM7CiAKICAgICBkYXRhcGxhbmUtPnJpbmdzLmNvbW1vbi5y c3BfcHJvZF9wdnQrKzsKIApAQCAtNDczLDEzICs0NzUsMTMgQEAgc3RhdGljIGludCBibGtfc2Vu ZF9yZXNwb25zZV9vbmUoc3RydWN0IGlvcmVxICppb3JlcSkKIC8qIHdhbGsgZmluaXNoZWQgbGlz dCwgc2VuZCBvdXRzdGFuZGluZyByZXNwb25zZXMsIGZyZWUgcmVxdWVzdHMgKi8KIHN0YXRpYyB2 b2lkIGJsa19zZW5kX3Jlc3BvbnNlX2FsbChYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lKQog ewotICAgIHN0cnVjdCBpb3JlcSAqaW9yZXE7CisgICAgWGVuQmxvY2tSZXF1ZXN0ICpyZXF1ZXN0 OwogICAgIGludCBzZW5kX25vdGlmeSA9IDA7CiAKICAgICB3aGlsZSAoIVFMSVNUX0VNUFRZKCZk YXRhcGxhbmUtPmZpbmlzaGVkKSkgewotICAgICAgICBpb3JlcSA9IFFMSVNUX0ZJUlNUKCZkYXRh cGxhbmUtPmZpbmlzaGVkKTsKLSAgICAgICAgc2VuZF9ub3RpZnkgKz0gYmxrX3NlbmRfcmVzcG9u c2Vfb25lKGlvcmVxKTsKLSAgICAgICAgaW9yZXFfcmVsZWFzZShpb3JlcSwgdHJ1ZSk7CisgICAg ICAgIHJlcXVlc3QgPSBRTElTVF9GSVJTVCgmZGF0YXBsYW5lLT5maW5pc2hlZCk7CisgICAgICAg IHNlbmRfbm90aWZ5ICs9IGJsa19zZW5kX3Jlc3BvbnNlX29uZShyZXF1ZXN0KTsKKyAgICAgICAg aW9yZXFfcmVsZWFzZShyZXF1ZXN0LCB0cnVlKTsKICAgICB9CiAgICAgaWYgKHNlbmRfbm90aWZ5 KSB7CiAgICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwpAQCAtNDkzLDI5ICs0OTUsMjkg QEAgc3RhdGljIHZvaWQgYmxrX3NlbmRfcmVzcG9uc2VfYWxsKFhlbkJsb2NrRGF0YVBsYW5lICpk YXRhcGxhbmUpCiAgICAgfQogfQogCi1zdGF0aWMgaW50IGJsa19nZXRfcmVxdWVzdChYZW5CbG9j a0RhdGFQbGFuZSAqZGF0YXBsYW5lLCBzdHJ1Y3QgaW9yZXEgKmlvcmVxLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgUklOR19JRFggcmMpCitzdGF0aWMgaW50IGJsa19nZXRfcmVxdWVzdChY ZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg WGVuQmxvY2tSZXF1ZXN0ICpyZXF1ZXN0LCBSSU5HX0lEWCByYykKIHsKICAgICBzd2l0Y2ggKGRh dGFwbGFuZS0+cHJvdG9jb2wpIHsKICAgICBjYXNlIEJMS0lGX1BST1RPQ09MX05BVElWRTogewog ICAgICAgICBibGtpZl9yZXF1ZXN0X3QgKnJlcSA9CiAgICAgICAgICAgICBSSU5HX0dFVF9SRVFV RVNUKCZkYXRhcGxhbmUtPnJpbmdzLm5hdGl2ZSwgcmMpOwogCi0gICAgICAgIG1lbWNweSgmaW9y ZXEtPnJlcSwgcmVxLCBzaXplb2YoaW9yZXEtPnJlcSkpOworICAgICAgICBtZW1jcHkoJnJlcXVl c3QtPnJlcSwgcmVxLCBzaXplb2YocmVxdWVzdC0+cmVxKSk7CiAgICAgICAgIGJyZWFrOwogICAg IH0KICAgICBjYXNlIEJMS0lGX1BST1RPQ09MX1g4Nl8zMjogewogICAgICAgICBibGtpZl94ODZf MzJfcmVxdWVzdF90ICpyZXEgPQogICAgICAgICAgICAgUklOR19HRVRfUkVRVUVTVCgmZGF0YXBs YW5lLT5yaW5ncy54ODZfMzJfcGFydCwgcmMpOwogCi0gICAgICAgIGJsa2lmX2dldF94ODZfMzJf cmVxKCZpb3JlcS0+cmVxLCByZXEpOworICAgICAgICBibGtpZl9nZXRfeDg2XzMyX3JlcSgmcmVx dWVzdC0+cmVxLCByZXEpOwogICAgICAgICBicmVhazsKICAgICB9CiAgICAgY2FzZSBCTEtJRl9Q Uk9UT0NPTF9YODZfNjQ6IHsKICAgICAgICAgYmxraWZfeDg2XzY0X3JlcXVlc3RfdCAqcmVxID0K ICAgICAgICAgICAgIFJJTkdfR0VUX1JFUVVFU1QoJmRhdGFwbGFuZS0+cmluZ3MueDg2XzY0X3Bh cnQsIHJjKTsKIAotICAgICAgICBibGtpZl9nZXRfeDg2XzY0X3JlcSgmaW9yZXEtPnJlcSwgcmVx KTsKKyAgICAgICAgYmxraWZfZ2V0X3g4Nl82NF9yZXEoJnJlcXVlc3QtPnJlcSwgcmVxKTsKICAg ICAgICAgYnJlYWs7CiAgICAgfQogICAgIH0KQEAgLTUyNyw3ICs1MjksNyBAQCBzdGF0aWMgaW50 IGJsa19nZXRfcmVxdWVzdChYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lLCBzdHJ1Y3QgaW9y ZXEgKmlvcmVxLAogc3RhdGljIHZvaWQgYmxrX2hhbmRsZV9yZXF1ZXN0cyhYZW5CbG9ja0RhdGFQ bGFuZSAqZGF0YXBsYW5lKQogewogICAgIFJJTkdfSURYIHJjLCBycDsKLSAgICBzdHJ1Y3QgaW9y ZXEgKmlvcmVxOworICAgIFhlbkJsb2NrUmVxdWVzdCAqcmVxdWVzdDsKIAogICAgIGRhdGFwbGFu ZS0+bW9yZV93b3JrID0gMDsKIApAQCAtNTQxLDE4ICs1NDMsMTggQEAgc3RhdGljIHZvaWQgYmxr X2hhbmRsZV9yZXF1ZXN0cyhYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lKQogICAgICAgICBp ZiAoUklOR19SRVFVRVNUX0NPTlNfT1ZFUkZMT1coJmRhdGFwbGFuZS0+cmluZ3MuY29tbW9uLCBy YykpIHsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9Ci0gICAgICAgIGlvcmVxID0gaW9y ZXFfc3RhcnQoZGF0YXBsYW5lKTsKLSAgICAgICAgaWYgKGlvcmVxID09IE5VTEwpIHsKKyAgICAg ICAgcmVxdWVzdCA9IGlvcmVxX3N0YXJ0KGRhdGFwbGFuZSk7CisgICAgICAgIGlmIChyZXF1ZXN0 ID09IE5VTEwpIHsKICAgICAgICAgICAgIGRhdGFwbGFuZS0+bW9yZV93b3JrKys7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgfQotICAgICAgICBibGtfZ2V0X3JlcXVlc3QoZGF0YXBsYW5l LCBpb3JlcSwgcmMpOworICAgICAgICBibGtfZ2V0X3JlcXVlc3QoZGF0YXBsYW5lLCByZXF1ZXN0 LCByYyk7CiAgICAgICAgIGRhdGFwbGFuZS0+cmluZ3MuY29tbW9uLnJlcV9jb25zID0gKytyYzsK IAogICAgICAgICAvKiBwYXJzZSB0aGVtICovCi0gICAgICAgIGlmIChpb3JlcV9wYXJzZShpb3Jl cSkgIT0gMCkgeworICAgICAgICBpZiAoaW9yZXFfcGFyc2UocmVxdWVzdCkgIT0gMCkgewogCi0g ICAgICAgICAgICBzd2l0Y2ggKGlvcmVxLT5yZXEub3BlcmF0aW9uKSB7CisgICAgICAgICAgICBz d2l0Y2ggKHJlcXVlc3QtPnJlcS5vcGVyYXRpb24pIHsKICAgICAgICAgICAgIGNhc2UgQkxLSUZf T1BfUkVBRDoKICAgICAgICAgICAgICAgICBibG9ja19hY2N0X2ludmFsaWQoYmxrX2dldF9zdGF0 cyhkYXRhcGxhbmUtPmJsayksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJM T0NLX0FDQ1RfUkVBRCk7CkBAIC01NjgsNyArNTcwLDcgQEAgc3RhdGljIHZvaWQgYmxrX2hhbmRs ZV9yZXF1ZXN0cyhYZW5CbG9ja0RhdGFQbGFuZSAqZGF0YXBsYW5lKQogICAgICAgICAgICAgICAg IGJyZWFrOwogICAgICAgICAgICAgfTsKIAotICAgICAgICAgICAgaWYgKGJsa19zZW5kX3Jlc3Bv bnNlX29uZShpb3JlcSkpIHsKKyAgICAgICAgICAgIGlmIChibGtfc2VuZF9yZXNwb25zZV9vbmUo cmVxdWVzdCkpIHsKICAgICAgICAgICAgICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAog ICAgICAgICAgICAgICAgIHhlbl9kZXZpY2Vfbm90aWZ5X2V2ZW50X2NoYW5uZWwoZGF0YXBsYW5l LT54ZW5kZXYsCkBAIC01NzgsMTEgKzU4MCwxMSBAQCBzdGF0aWMgdm9pZCBibGtfaGFuZGxlX3Jl cXVlc3RzKFhlbkJsb2NrRGF0YVBsYW5lICpkYXRhcGxhbmUpCiAgICAgICAgICAgICAgICAgICAg IGVycm9yX3JlcG9ydF9lcnIobG9jYWxfZXJyKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAg ICAgICB9Ci0gICAgICAgICAgICBpb3JlcV9yZWxlYXNlKGlvcmVxLCBmYWxzZSk7CisgICAgICAg ICAgICBpb3JlcV9yZWxlYXNlKHJlcXVlc3QsIGZhbHNlKTsKICAgICAgICAgICAgIGNvbnRpbnVl OwogICAgICAgICB9CiAKLSAgICAgICAgaW9yZXFfcnVuaW9fcWVtdV9haW8oaW9yZXEpOworICAg ICAgICBpb3JlcV9ydW5pb19xZW11X2FpbyhyZXF1ZXN0KTsKICAgICB9CiAKICAgICBpZiAoZGF0 YXBsYW5lLT5tb3JlX3dvcmsgJiYKQEAgLTYzNiwxNyArNjM4LDE3IEBAIFhlbkJsb2NrRGF0YVBs YW5lICp4ZW5fYmxvY2tfZGF0YXBsYW5lX2NyZWF0ZShYZW5EZXZpY2UgKnhlbmRldiwKIAogdm9p ZCB4ZW5fYmxvY2tfZGF0YXBsYW5lX2Rlc3Ryb3koWGVuQmxvY2tEYXRhUGxhbmUgKmRhdGFwbGFu ZSkKIHsKLSAgICBzdHJ1Y3QgaW9yZXEgKmlvcmVxOworICAgIFhlbkJsb2NrUmVxdWVzdCAqcmVx dWVzdDsKIAogICAgIGlmICghZGF0YXBsYW5lKSB7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAK ICAgICB3aGlsZSAoIVFMSVNUX0VNUFRZKCZkYXRhcGxhbmUtPmZyZWVsaXN0KSkgewotICAgICAg ICBpb3JlcSA9IFFMSVNUX0ZJUlNUKCZkYXRhcGxhbmUtPmZyZWVsaXN0KTsKLSAgICAgICAgUUxJ U1RfUkVNT1ZFKGlvcmVxLCBsaXN0KTsKLSAgICAgICAgcWVtdV9pb3ZlY19kZXN0cm95KCZpb3Jl cS0+dik7Ci0gICAgICAgIGdfZnJlZShpb3JlcSk7CisgICAgICAgIHJlcXVlc3QgPSBRTElTVF9G SVJTVCgmZGF0YXBsYW5lLT5mcmVlbGlzdCk7CisgICAgICAgIFFMSVNUX1JFTU9WRShyZXF1ZXN0 LCBsaXN0KTsKKyAgICAgICAgcWVtdV9pb3ZlY19kZXN0cm95KCZyZXF1ZXN0LT52KTsKKyAgICAg ICAgZ19mcmVlKHJlcXVlc3QpOwogICAgIH0KIAogICAgIHFlbXVfYmhfZGVsZXRlKGRhdGFwbGFu ZS0+YmgpOwotLSAKQW50aG9ueSBQRVJBUkQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0 cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlz dGluZm8veGVuLWRldmVs