From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751489AbdJEGUp (ORCPT ); Thu, 5 Oct 2017 02:20:45 -0400 Received: from home.keithp.com ([63.227.221.253]:43292 "EHLO elaine.keithp.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751270AbdJEGUJ (ORCPT ); Thu, 5 Oct 2017 02:20:09 -0400 From: Keith Packard To: linux-kernel@vger.kernel.org, Dave Airlie , Daniel Vetter Cc: Keith Packard , dri-devel@lists.freedesktop.org Subject: [PATCH 6/6] drm: Add four ioctls for managing drm mode object leases [v4] Date: Wed, 4 Oct 2017 23:13:10 -0700 Message-Id: <20171005061310.29919-7-keithp@keithp.com> X-Mailer: git-send-email 2.13.3 In-Reply-To: <20171005061310.29919-1-keithp@keithp.com> References: <20171005061310.29919-1-keithp@keithp.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org drm_mode_create_lease Creates a lease for a list of drm mode objects, returning an fd for the new drm_master and a 64-bit identifier for the lessee drm_mode_list_lesees List the identifiers of the lessees for a master file drm_mode_get_lease List the leased objects for a master file drm_mode_revoke_lease Erase the set of objects managed by a lease. This should suffice to at least create and query leases. Changes for v2 as suggested by Daniel Vetter : * query ioctls only query the master associated with the provided file. * 'mask_lease' value has been removed * change ioctl has been removed. Changes for v3 suggested in part by Dave Airlie * Add revoke ioctl. Changes for v3 suggested by Dave Airlie * Expand on the comment about the magic use of &drm_lease_idr_object * Pad lease ioctl structures to align on 64-bit boundaries Signed-off-by: Keith Packard --- drivers/gpu/drm/drm_ioctl.c | 4 + drivers/gpu/drm/drm_lease.c | 277 ++++++++++++++++++++++++++++++++++++++++++++ include/drm/drm_lease.h | 12 ++ include/uapi/drm/drm.h | 5 + include/uapi/drm/drm_mode.h | 66 +++++++++++ 5 files changed, 364 insertions(+) diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c index 7d0e481c5729..3ed76220b4b1 100644 --- a/drivers/gpu/drm/drm_ioctl.c +++ b/drivers/gpu/drm/drm_ioctl.c @@ -657,6 +657,10 @@ static const struct drm_ioctl_desc drm_ioctls[] = { DRM_UNLOCKED|DRM_RENDER_ALLOW), DRM_IOCTL_DEF(DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, drm_syncobj_fd_to_handle_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_CREATE_LEASE, drm_mode_create_lease_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_LIST_LESSEES, drm_mode_list_lessees_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_GET_LEASE, drm_mode_get_lease_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), + DRM_IOCTL_DEF(DRM_IOCTL_MODE_REVOKE_LEASE, drm_mode_revoke_lease_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED), }; #define DRM_CORE_IOCTL_COUNT ARRAY_SIZE( drm_ioctls ) diff --git a/drivers/gpu/drm/drm_lease.c b/drivers/gpu/drm/drm_lease.c index 2ac404264d75..e885ea76de8f 100644 --- a/drivers/gpu/drm/drm_lease.c +++ b/drivers/gpu/drm/drm_lease.c @@ -23,6 +23,8 @@ #define drm_for_each_lessee(lessee, lessor) \ list_for_each_entry((lessee), &(lessor)->lessees, lessee_list) +static uint64_t drm_lease_idr_object; + /** * drm_lease_owner - return ancestor owner drm_master * @master: drm_master somewhere within tree of lessees and lessors @@ -377,3 +379,278 @@ void _drm_lease_revoke(struct drm_master *top) } } } + +/** + * drm_mode_create_lease_ioctl - create a new lease + * @dev: the drm device + * @data: pointer to struct drm_mode_create_lease + * @file_priv: the file being manipulated + * + * The master associated with the specified file will have a lease + * created containing the objects specified in the ioctl structure. + * A file descriptor will be allocated for that and returned to the + * application. + */ +int drm_mode_create_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *lessor_priv) +{ + struct drm_mode_create_lease *cl = data; + size_t object_count; + size_t o; + int ret = 0; + struct idr leases; + struct drm_master *lessor = lessor_priv->master; + struct drm_master *lessee = NULL; + struct file *lessee_file = NULL; + struct file *lessor_file = lessor_priv->filp; + struct drm_file *lessee_priv; + int fd = -1; + + /* Do not allow sub-leases */ + if (lessor->lessor) + return -EINVAL; + + object_count = cl->object_count; + idr_init(&leases); + + /* Allocate a file descriptor for the lease */ + fd = get_unused_fd_flags(cl->flags & (O_CLOEXEC | O_NONBLOCK)); + + DRM_DEBUG_LEASE("Creating new lease\n"); + + /* Lookup the mode objects and add their IDs to the lease request */ + for (o = 0; o < object_count; o++) { + __u32 object_id; + + if (copy_from_user(&object_id, + u64_to_user_ptr(cl->object_ids) + o * sizeof (__u32), + sizeof (__u32))) { + ret = -EFAULT; + goto out_leases; + } + DRM_DEBUG_LEASE("Adding object %d to lease\n", object_id); + + /* + * We're using an IDR to hold the set of leased + * objects, but we don't need to point at the object's + * data structure from the lease as the main crtc_idr + * will be used to actually find that. Instead, all we + * really want is a 'leased/not-leased' result, for + * which any non-NULL pointer will work fine. + */ + ret = idr_alloc(&leases, &drm_lease_idr_object , object_id, object_id + 1, GFP_KERNEL); + if (ret < 0) { + DRM_DEBUG_LEASE("Object %d cannot be inserted into leases (%d)\n", + object_id, ret); + goto out_leases; + } + } + + mutex_lock(&dev->master_mutex); + + DRM_DEBUG_LEASE("Creating lease\n"); + lessee = drm_lease_create(lessor, &leases); + + if (IS_ERR(lessee)) { + ret = PTR_ERR(lessee); + mutex_unlock(&dev->master_mutex); + goto out_leases; + } + + /* Clone the lessor file to create a new file for us */ + DRM_DEBUG_LEASE("Allocating lease file\n"); + path_get(&lessor_file->f_path); + lessee_file = alloc_file(&lessor_file->f_path, + lessor_file->f_mode, + fops_get(lessor_file->f_inode->i_fop)); + mutex_unlock(&dev->master_mutex); + + if (IS_ERR(lessee_file)) { + ret = PTR_ERR(lessee_file); + goto out_lessee; + } + + /* Initialize the new file for DRM */ + DRM_DEBUG_LEASE("Initializing the file with %p\n", lessee_file->f_op->open); + ret = lessee_file->f_op->open(lessee_file->f_inode, lessee_file); + if (ret) + goto out_lessee_file; + + lessee_priv = lessee_file->private_data; + + /* Change the file to a master one */ + drm_master_put(&lessee_priv->master); + lessee_priv->master = lessee; + lessee_priv->is_master = 1; + lessee_priv->authenticated = 1; + + /* Hook up the fd */ + fd_install(fd, lessee_file); + + /* Pass fd back to userspace */ + DRM_DEBUG_LEASE("Returning fd %d id %d\n", fd, lessee->lessee_id); + cl->fd = fd; + cl->lessee_id = lessee->lessee_id; + + DRM_DEBUG_LEASE("drm_mode_create_lease_ioctl succeeded\n"); + return 0; + +out_lessee_file: + fput(lessee_file); + +out_lessee: + drm_master_put(&lessee); + +out_leases: + idr_destroy(&leases); + put_unused_fd(fd); + + DRM_DEBUG_LEASE("drm_mode_create_lease_ioctl failed: %d\n", ret); + return ret; +} + +/** + * drm_mode_list_lessees_ioctl - list lessee ids + * @dev: the drm device + * @data: pointer to struct drm_mode_list_lessees + * @lessor_priv: the file being manipulated + * + * Starting from the master associated with the specified file, + * the master with the provided lessee_id is found, and then + * an array of lessee ids associated with leases from that master + * are returned. + */ + +int drm_mode_list_lessees_ioctl(struct drm_device *dev, + void *data, struct drm_file *lessor_priv) +{ + struct drm_mode_list_lessees *arg = data; + __u32 __user *lessee_ids = (__u32 __user *) (uintptr_t) (arg->lessees_ptr); + __u32 count_lessees = arg->count_lessees; + struct drm_master *lessor = lessor_priv->master, *lessee; + int count; + int ret = 0; + + DRM_DEBUG_LEASE("List lessees for %d\n", lessor->lessee_id); + + mutex_lock(&dev->master_mutex); + + count = 0; + drm_for_each_lessee(lessee, lessor) { + /* Only list un-revoked leases */ + if (!idr_is_empty(&lessee->leases)) { + if (count_lessees > count) { + DRM_DEBUG_LEASE("Add lessee %d\n", lessee->lessee_id); + ret = put_user(lessee->lessee_id, lessee_ids + count); + if (ret) + break; + } + count++; + } + } + + DRM_DEBUG_LEASE("Lessor leases to %d\n", count); + if (ret == 0) + arg->count_lessees = count; + + mutex_unlock(&dev->master_mutex); + + return ret; +} + +/** + * drm_mode_get_lease_ioctl - list leased objects + * @dev: the drm device + * @data: pointer to struct drm_mode_get_lease + * @file_priv: the file being manipulated + * + * Return the list of leased objects for the specified lessee + */ + +int drm_mode_get_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *lessee_priv) +{ + struct drm_mode_get_lease *arg = data; + __u32 __user *object_ids = (__u32 __user *) (uintptr_t) (arg->objects_ptr); + __u32 count_objects = arg->count_objects; + struct drm_master *lessee = lessee_priv->master; + struct idr *object_idr; + int count; + void *entry; + int object; + int ret = 0; + + DRM_DEBUG_LEASE("get lease for %d\n", lessee->lessee_id); + + mutex_lock(&dev->master_mutex); + + if (lessee->lessor == NULL) + /* owner can use all objects */ + object_idr = &lessee->dev->mode_config.crtc_idr; + else + /* lessee can only use allowed object */ + object_idr = &lessee->leases; + + count = 0; + idr_for_each_entry(object_idr, entry, object) { + if (count_objects > count) { + DRM_DEBUG_LEASE("adding object %d\n", object); + ret = put_user(object, object_ids + count); + if (ret) + break; + } + count++; + } + + DRM_DEBUG("lease holds %d objects\n", count); + if (ret == 0) + arg->count_objects = count; + + mutex_unlock(&dev->master_mutex); + + return ret; +} + +/** + * drm_mode_revoke_lease_ioctl - revoke lease + * @dev: the drm device + * @data: pointer to struct drm_mode_revoke_lease + * @file_priv: the file being manipulated + * + * This removes all of the objects from the lease without + * actually getting rid of the lease itself; that way all + * references to it still work correctly + */ +int drm_mode_revoke_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *lessor_priv) +{ + struct drm_mode_revoke_lease *arg = data; + struct drm_master *lessor = lessor_priv->master; + struct drm_master *lessee; + int ret = 0; + + DRM_DEBUG_LEASE("revoke lease for %d\n", arg->lessee_id); + + mutex_lock(&dev->master_mutex); + + lessee = _drm_find_lessee(lessor, arg->lessee_id); + + /* No such lessee */ + if (!lessee) { + ret = -ENOENT; + goto fail; + } + + /* Lease is not held by lessor */ + if (lessee->lessor != lessor) { + ret = -EACCES; + goto fail; + } + + _drm_lease_revoke(lessee); + +fail: + mutex_unlock(&dev->master_mutex); + + return ret; +} diff --git a/include/drm/drm_lease.h b/include/drm/drm_lease.h index a49667db1d6d..53ffcee2617e 100644 --- a/include/drm/drm_lease.h +++ b/include/drm/drm_lease.h @@ -33,4 +33,16 @@ uint32_t drm_lease_filter_crtcs(struct drm_file *file_priv, uint32_t crtcs); uint32_t drm_lease_filter_encoders(struct drm_file *file_priv, uint32_t encoders); +int drm_mode_create_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); + +int drm_mode_list_lessees_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); + +int drm_mode_get_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); + +int drm_mode_revoke_lease_ioctl(struct drm_device *dev, + void *data, struct drm_file *file_priv); + #endif /* _DRM_LEASE_H_ */ diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h index 101593ab10ac..dd350bf0ad75 100644 --- a/include/uapi/drm/drm.h +++ b/include/uapi/drm/drm.h @@ -841,6 +841,11 @@ extern "C" { #define DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD DRM_IOWR(0xC1, struct drm_syncobj_handle) #define DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE DRM_IOWR(0xC2, struct drm_syncobj_handle) +#define DRM_IOCTL_MODE_CREATE_LEASE DRM_IOWR(0xC3, struct drm_mode_create_lease) +#define DRM_IOCTL_MODE_LIST_LESSEES DRM_IOWR(0xC4, struct drm_mode_list_lessees) +#define DRM_IOCTL_MODE_GET_LEASE DRM_IOWR(0xC5, struct drm_mode_get_lease) +#define DRM_IOCTL_MODE_REVOKE_LEASE DRM_IOWR(0xC6, struct drm_mode_revoke_lease) + /** * Device specific ioctls should only be in their respective headers * The device specific ioctl range is from 0x40 to 0x9f. diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h index 403339f98a92..5964f25fa88e 100644 --- a/include/uapi/drm/drm_mode.h +++ b/include/uapi/drm/drm_mode.h @@ -732,6 +732,72 @@ struct drm_mode_destroy_blob { __u32 blob_id; }; +/** + * Lease mode resources, creating another drm_master. + */ +struct drm_mode_create_lease { + /** Pointer to array of object ids (__u32) */ + __u64 object_ids; + /** Number of object ids */ + __u32 object_count; + /** flags for new FD (O_CLOEXEC, etc) */ + __u32 flags; + + /** Return: unique identifier for lessee. */ + __u32 lessee_id; + /** Return: file descriptor to new drm_master file */ + __u32 fd; +}; + +/** + * List lesses from a drm_master + */ +struct drm_mode_list_lessees { + /** Number of lessees. + * On input, provides length of the array. + * On output, provides total number. No + * more than the input number will be written + * back, so two calls can be used to get + * the size and then the data. + */ + __u32 count_lessees; + __u32 pad; + + /** Pointer to lessees. + * pointer to __u64 array of lessee ids + */ + __u64 lessees_ptr; +}; + +/** + * Get leased objects + */ +struct drm_mode_get_lease { + /** Number of leased objects. + * On input, provides length of the array. + * On output, provides total number. No + * more than the input number will be written + * back, so two calls can be used to get + * the size and then the data. + */ + __u32 count_objects; + __u32 pad; + + /** Pointer to objects. + * pointer to __u32 array of object ids + */ + __u64 objects_ptr; +}; + +/** + * Revoke lease + */ +struct drm_mode_revoke_lease { + /** Unique ID of lessee + */ + __u32 lessee_id; +}; + #if defined(__cplusplus) } #endif -- 2.13.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Keith Packard Subject: [PATCH 6/6] drm: Add four ioctls for managing drm mode object leases [v4] Date: Wed, 4 Oct 2017 23:13:10 -0700 Message-ID: <20171005061310.29919-7-keithp@keithp.com> References: <20171005061310.29919-1-keithp@keithp.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from elaine.keithp.com (home.keithp.com [63.227.221.253]) by gabe.freedesktop.org (Postfix) with ESMTP id 414786E5DE for ; Thu, 5 Oct 2017 06:13:16 +0000 (UTC) In-Reply-To: <20171005061310.29919-1-keithp@keithp.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org, Dave Airlie , Daniel Vetter Cc: Keith Packard , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org ZHJtX21vZGVfY3JlYXRlX2xlYXNlCgoJQ3JlYXRlcyBhIGxlYXNlIGZvciBhIGxpc3Qgb2YgZHJt IG1vZGUgb2JqZWN0cywgcmV0dXJuaW5nIGFuCglmZCBmb3IgdGhlIG5ldyBkcm1fbWFzdGVyIGFu ZCBhIDY0LWJpdCBpZGVudGlmaWVyIGZvciB0aGUgbGVzc2VlCgpkcm1fbW9kZV9saXN0X2xlc2Vl cwoKCUxpc3QgdGhlIGlkZW50aWZpZXJzIG9mIHRoZSBsZXNzZWVzIGZvciBhIG1hc3RlciBmaWxl Cgpkcm1fbW9kZV9nZXRfbGVhc2UKCglMaXN0IHRoZSBsZWFzZWQgb2JqZWN0cyBmb3IgYSBtYXN0 ZXIgZmlsZQoKZHJtX21vZGVfcmV2b2tlX2xlYXNlCgoJRXJhc2UgdGhlIHNldCBvZiBvYmplY3Rz IG1hbmFnZWQgYnkgYSBsZWFzZS4KClRoaXMgc2hvdWxkIHN1ZmZpY2UgdG8gYXQgbGVhc3QgY3Jl YXRlIGFuZCBxdWVyeSBsZWFzZXMuCgpDaGFuZ2VzIGZvciB2MiBhcyBzdWdnZXN0ZWQgYnkgRGFu aWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD46CgogKiBxdWVyeSBpb2N0bHMgb25s eSBxdWVyeSB0aGUgbWFzdGVyIGFzc29jaWF0ZWQgd2l0aAogICB0aGUgcHJvdmlkZWQgZmlsZS4K CiAqICdtYXNrX2xlYXNlJyB2YWx1ZSBoYXMgYmVlbiByZW1vdmVkCgogKiBjaGFuZ2UgaW9jdGwg aGFzIGJlZW4gcmVtb3ZlZC4KCkNoYW5nZXMgZm9yIHYzIHN1Z2dlc3RlZCBpbiBwYXJ0IGJ5IERh dmUgQWlybGllIDxhaXJsaWVkQGdtYWlsLmNvbT4KCiAqIEFkZCByZXZva2UgaW9jdGwuCgpDaGFu Z2VzIGZvciB2MyBzdWdnZXN0ZWQgYnkgRGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwuY29tPgoK ICogRXhwYW5kIG9uIHRoZSBjb21tZW50IGFib3V0IHRoZSBtYWdpYyB1c2Ugb2YgJmRybV9sZWFz ZV9pZHJfb2JqZWN0CiAqIFBhZCBsZWFzZSBpb2N0bCBzdHJ1Y3R1cmVzIHRvIGFsaWduIG9uIDY0 LWJpdCBib3VuZGFyaWVzCgpTaWduZWQtb2ZmLWJ5OiBLZWl0aCBQYWNrYXJkIDxrZWl0aHBAa2Vp dGhwLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2lvY3RsLmMgfCAgIDQgKwogZHJpdmVy cy9ncHUvZHJtL2RybV9sZWFzZS5jIHwgMjc3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBpbmNsdWRlL2RybS9kcm1fbGVhc2UuaCAgICAgfCAgMTIgKysKIGlu Y2x1ZGUvdWFwaS9kcm0vZHJtLmggICAgICB8ICAgNSArCiBpbmNsdWRlL3VhcGkvZHJtL2RybV9t b2RlLmggfCAgNjYgKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgMzY0IGluc2VydGlvbnMo KykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2lvY3RsLmMgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2lvY3RsLmMKaW5kZXggN2QwZTQ4MWM1NzI5Li4zZWQ3NjIyMGI0YjEgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1faW9jdGwuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2lvY3RsLmMKQEAgLTY1Nyw2ICs2NTcsMTAgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1f aW9jdGxfZGVzYyBkcm1faW9jdGxzW10gPSB7CiAJCSAgICAgIERSTV9VTkxPQ0tFRHxEUk1fUkVO REVSX0FMTE9XKSwKIAlEUk1fSU9DVExfREVGKERSTV9JT0NUTF9TWU5DT0JKX0ZEX1RPX0hBTkRM RSwgZHJtX3N5bmNvYmpfZmRfdG9faGFuZGxlX2lvY3RsLAogCQkgICAgICBEUk1fVU5MT0NLRUR8 RFJNX1JFTkRFUl9BTExPVyksCisJRFJNX0lPQ1RMX0RFRihEUk1fSU9DVExfTU9ERV9DUkVBVEVf TEVBU0UsIGRybV9tb2RlX2NyZWF0ZV9sZWFzZV9pb2N0bCwgRFJNX01BU1RFUnxEUk1fQ09OVFJP TF9BTExPV3xEUk1fVU5MT0NLRUQpLAorCURSTV9JT0NUTF9ERUYoRFJNX0lPQ1RMX01PREVfTElT VF9MRVNTRUVTLCBkcm1fbW9kZV9saXN0X2xlc3NlZXNfaW9jdGwsIERSTV9NQVNURVJ8RFJNX0NP TlRST0xfQUxMT1d8RFJNX1VOTE9DS0VEKSwKKwlEUk1fSU9DVExfREVGKERSTV9JT0NUTF9NT0RF X0dFVF9MRUFTRSwgZHJtX21vZGVfZ2V0X2xlYXNlX2lvY3RsLCBEUk1fTUFTVEVSfERSTV9DT05U Uk9MX0FMTE9XfERSTV9VTkxPQ0tFRCksCisJRFJNX0lPQ1RMX0RFRihEUk1fSU9DVExfTU9ERV9S RVZPS0VfTEVBU0UsIGRybV9tb2RlX3Jldm9rZV9sZWFzZV9pb2N0bCwgRFJNX01BU1RFUnxEUk1f Q09OVFJPTF9BTExPV3xEUk1fVU5MT0NLRUQpLAogfTsKIAogI2RlZmluZSBEUk1fQ09SRV9JT0NU TF9DT1VOVAlBUlJBWV9TSVpFKCBkcm1faW9jdGxzICkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9kcm1fbGVhc2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fbGVhc2UuYwppbmRleCAyYWM0 MDQyNjRkNzUuLmU4ODVlYTc2ZGU4ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9s ZWFzZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fbGVhc2UuYwpAQCAtMjMsNiArMjMsOCBA QAogI2RlZmluZSBkcm1fZm9yX2VhY2hfbGVzc2VlKGxlc3NlZSwgbGVzc29yKSBcCiAJbGlzdF9m b3JfZWFjaF9lbnRyeSgobGVzc2VlKSwgJihsZXNzb3IpLT5sZXNzZWVzLCBsZXNzZWVfbGlzdCkK IAorc3RhdGljIHVpbnQ2NF90IGRybV9sZWFzZV9pZHJfb2JqZWN0OworCiAvKioKICAqIGRybV9s ZWFzZV9vd25lciAtIHJldHVybiBhbmNlc3RvciBvd25lciBkcm1fbWFzdGVyCiAgKiBAbWFzdGVy OiBkcm1fbWFzdGVyIHNvbWV3aGVyZSB3aXRoaW4gdHJlZSBvZiBsZXNzZWVzIGFuZCBsZXNzb3Jz CkBAIC0zNzcsMyArMzc5LDI3OCBAQCB2b2lkIF9kcm1fbGVhc2VfcmV2b2tlKHN0cnVjdCBkcm1f bWFzdGVyICp0b3ApCiAJCX0KIAl9CiB9CisKKy8qKgorICogZHJtX21vZGVfY3JlYXRlX2xlYXNl X2lvY3RsIC0gY3JlYXRlIGEgbmV3IGxlYXNlCisgKiBAZGV2OiB0aGUgZHJtIGRldmljZQorICog QGRhdGE6IHBvaW50ZXIgdG8gc3RydWN0IGRybV9tb2RlX2NyZWF0ZV9sZWFzZQorICogQGZpbGVf cHJpdjogdGhlIGZpbGUgYmVpbmcgbWFuaXB1bGF0ZWQKKyAqCisgKiBUaGUgbWFzdGVyIGFzc29j aWF0ZWQgd2l0aCB0aGUgc3BlY2lmaWVkIGZpbGUgd2lsbCBoYXZlIGEgbGVhc2UKKyAqIGNyZWF0 ZWQgY29udGFpbmluZyB0aGUgb2JqZWN0cyBzcGVjaWZpZWQgaW4gdGhlIGlvY3RsIHN0cnVjdHVy ZS4KKyAqIEEgZmlsZSBkZXNjcmlwdG9yIHdpbGwgYmUgYWxsb2NhdGVkIGZvciB0aGF0IGFuZCBy ZXR1cm5lZCB0byB0aGUKKyAqIGFwcGxpY2F0aW9uLgorICovCitpbnQgZHJtX21vZGVfY3JlYXRl X2xlYXNlX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCQkJdm9pZCAqZGF0YSwgc3Ry dWN0IGRybV9maWxlICpsZXNzb3JfcHJpdikKK3sKKwlzdHJ1Y3QgZHJtX21vZGVfY3JlYXRlX2xl YXNlICpjbCA9IGRhdGE7CisJc2l6ZV90IG9iamVjdF9jb3VudDsKKwlzaXplX3QgbzsKKwlpbnQg cmV0ID0gMDsKKwlzdHJ1Y3QgaWRyIGxlYXNlczsKKwlzdHJ1Y3QgZHJtX21hc3RlciAqbGVzc29y ID0gbGVzc29yX3ByaXYtPm1hc3RlcjsKKwlzdHJ1Y3QgZHJtX21hc3RlciAqbGVzc2VlID0gTlVM TDsKKwlzdHJ1Y3QgZmlsZSAqbGVzc2VlX2ZpbGUgPSBOVUxMOworCXN0cnVjdCBmaWxlICpsZXNz b3JfZmlsZSA9IGxlc3Nvcl9wcml2LT5maWxwOworCXN0cnVjdCBkcm1fZmlsZSAqbGVzc2VlX3By aXY7CisJaW50IGZkID0gLTE7CisKKwkvKiBEbyBub3QgYWxsb3cgc3ViLWxlYXNlcyAqLworCWlm IChsZXNzb3ItPmxlc3NvcikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlvYmplY3RfY291bnQgPSBj bC0+b2JqZWN0X2NvdW50OworCWlkcl9pbml0KCZsZWFzZXMpOworCisJLyogQWxsb2NhdGUgYSBm aWxlIGRlc2NyaXB0b3IgZm9yIHRoZSBsZWFzZSAqLworCWZkID0gZ2V0X3VudXNlZF9mZF9mbGFn cyhjbC0+ZmxhZ3MgJiAoT19DTE9FWEVDIHwgT19OT05CTE9DSykpOworCisJRFJNX0RFQlVHX0xF QVNFKCJDcmVhdGluZyBuZXcgbGVhc2VcbiIpOworCisJLyogTG9va3VwIHRoZSBtb2RlIG9iamVj dHMgYW5kIGFkZCB0aGVpciBJRHMgdG8gdGhlIGxlYXNlIHJlcXVlc3QgKi8KKwlmb3IgKG8gPSAw OyBvIDwgb2JqZWN0X2NvdW50OyBvKyspIHsKKwkJX191MzIgb2JqZWN0X2lkOworCisJCWlmIChj b3B5X2Zyb21fdXNlcigmb2JqZWN0X2lkLAorCQkJCSAgIHU2NF90b191c2VyX3B0cihjbC0+b2Jq ZWN0X2lkcykgKyBvICogc2l6ZW9mIChfX3UzMiksCisJCQkJICAgc2l6ZW9mIChfX3UzMikpKSB7 CisJCQlyZXQgPSAtRUZBVUxUOworCQkJZ290byBvdXRfbGVhc2VzOworCQl9CisJCURSTV9ERUJV R19MRUFTRSgiQWRkaW5nIG9iamVjdCAlZCB0byBsZWFzZVxuIiwgb2JqZWN0X2lkKTsKKworCQkv KgorCQkgKiBXZSdyZSB1c2luZyBhbiBJRFIgdG8gaG9sZCB0aGUgc2V0IG9mIGxlYXNlZAorCQkg KiBvYmplY3RzLCBidXQgd2UgZG9uJ3QgbmVlZCB0byBwb2ludCBhdCB0aGUgb2JqZWN0J3MKKwkJ ICogZGF0YSBzdHJ1Y3R1cmUgZnJvbSB0aGUgbGVhc2UgYXMgdGhlIG1haW4gY3J0Y19pZHIKKwkJ ICogd2lsbCBiZSB1c2VkIHRvIGFjdHVhbGx5IGZpbmQgdGhhdC4gSW5zdGVhZCwgYWxsIHdlCisJ CSAqIHJlYWxseSB3YW50IGlzIGEgJ2xlYXNlZC9ub3QtbGVhc2VkJyByZXN1bHQsIGZvcgorCQkg KiB3aGljaCBhbnkgbm9uLU5VTEwgcG9pbnRlciB3aWxsIHdvcmsgZmluZS4KKwkJICovCisJCXJl dCA9IGlkcl9hbGxvYygmbGVhc2VzLCAmZHJtX2xlYXNlX2lkcl9vYmplY3QgLCBvYmplY3RfaWQs IG9iamVjdF9pZCArIDEsIEdGUF9LRVJORUwpOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0RF QlVHX0xFQVNFKCJPYmplY3QgJWQgY2Fubm90IGJlIGluc2VydGVkIGludG8gbGVhc2VzICglZClc biIsCisJCQkJCW9iamVjdF9pZCwgcmV0KTsKKwkJCWdvdG8gb3V0X2xlYXNlczsKKwkJfQorCX0K KworCW11dGV4X2xvY2soJmRldi0+bWFzdGVyX211dGV4KTsKKworCURSTV9ERUJVR19MRUFTRSgi Q3JlYXRpbmcgbGVhc2VcbiIpOworCWxlc3NlZSA9IGRybV9sZWFzZV9jcmVhdGUobGVzc29yLCAm bGVhc2VzKTsKKworCWlmIChJU19FUlIobGVzc2VlKSkgeworCQlyZXQgPSBQVFJfRVJSKGxlc3Nl ZSk7CisJCW11dGV4X3VubG9jaygmZGV2LT5tYXN0ZXJfbXV0ZXgpOworCQlnb3RvIG91dF9sZWFz ZXM7CisJfQorCisJLyogQ2xvbmUgdGhlIGxlc3NvciBmaWxlIHRvIGNyZWF0ZSBhIG5ldyBmaWxl IGZvciB1cyAqLworCURSTV9ERUJVR19MRUFTRSgiQWxsb2NhdGluZyBsZWFzZSBmaWxlXG4iKTsK KwlwYXRoX2dldCgmbGVzc29yX2ZpbGUtPmZfcGF0aCk7CisJbGVzc2VlX2ZpbGUgPSBhbGxvY19m aWxlKCZsZXNzb3JfZmlsZS0+Zl9wYXRoLAorCQkJCSBsZXNzb3JfZmlsZS0+Zl9tb2RlLAorCQkJ CSBmb3BzX2dldChsZXNzb3JfZmlsZS0+Zl9pbm9kZS0+aV9mb3ApKTsKKwltdXRleF91bmxvY2so JmRldi0+bWFzdGVyX211dGV4KTsKKworCWlmIChJU19FUlIobGVzc2VlX2ZpbGUpKSB7CisJCXJl dCA9IFBUUl9FUlIobGVzc2VlX2ZpbGUpOworCQlnb3RvIG91dF9sZXNzZWU7CisJfQorCisJLyog SW5pdGlhbGl6ZSB0aGUgbmV3IGZpbGUgZm9yIERSTSAqLworCURSTV9ERUJVR19MRUFTRSgiSW5p dGlhbGl6aW5nIHRoZSBmaWxlIHdpdGggJXBcbiIsIGxlc3NlZV9maWxlLT5mX29wLT5vcGVuKTsK KwlyZXQgPSBsZXNzZWVfZmlsZS0+Zl9vcC0+b3BlbihsZXNzZWVfZmlsZS0+Zl9pbm9kZSwgbGVz c2VlX2ZpbGUpOworCWlmIChyZXQpCisJCWdvdG8gb3V0X2xlc3NlZV9maWxlOworCisJbGVzc2Vl X3ByaXYgPSBsZXNzZWVfZmlsZS0+cHJpdmF0ZV9kYXRhOworCisJLyogQ2hhbmdlIHRoZSBmaWxl IHRvIGEgbWFzdGVyIG9uZSAqLworCWRybV9tYXN0ZXJfcHV0KCZsZXNzZWVfcHJpdi0+bWFzdGVy KTsKKwlsZXNzZWVfcHJpdi0+bWFzdGVyID0gbGVzc2VlOworCWxlc3NlZV9wcml2LT5pc19tYXN0 ZXIgPSAxOworCWxlc3NlZV9wcml2LT5hdXRoZW50aWNhdGVkID0gMTsKKworCS8qIEhvb2sgdXAg dGhlIGZkICovCisJZmRfaW5zdGFsbChmZCwgbGVzc2VlX2ZpbGUpOworCisJLyogUGFzcyBmZCBi YWNrIHRvIHVzZXJzcGFjZSAqLworCURSTV9ERUJVR19MRUFTRSgiUmV0dXJuaW5nIGZkICVkIGlk ICVkXG4iLCBmZCwgbGVzc2VlLT5sZXNzZWVfaWQpOworCWNsLT5mZCA9IGZkOworCWNsLT5sZXNz ZWVfaWQgPSBsZXNzZWUtPmxlc3NlZV9pZDsKKworCURSTV9ERUJVR19MRUFTRSgiZHJtX21vZGVf Y3JlYXRlX2xlYXNlX2lvY3RsIHN1Y2NlZWRlZFxuIik7CisJcmV0dXJuIDA7CisKK291dF9sZXNz ZWVfZmlsZToKKwlmcHV0KGxlc3NlZV9maWxlKTsKKworb3V0X2xlc3NlZToKKwlkcm1fbWFzdGVy X3B1dCgmbGVzc2VlKTsKKworb3V0X2xlYXNlczoKKwlpZHJfZGVzdHJveSgmbGVhc2VzKTsKKwlw dXRfdW51c2VkX2ZkKGZkKTsKKworCURSTV9ERUJVR19MRUFTRSgiZHJtX21vZGVfY3JlYXRlX2xl YXNlX2lvY3RsIGZhaWxlZDogJWRcbiIsIHJldCk7CisJcmV0dXJuIHJldDsKK30KKworLyoqCisg KiBkcm1fbW9kZV9saXN0X2xlc3NlZXNfaW9jdGwgLSBsaXN0IGxlc3NlZSBpZHMKKyAqIEBkZXY6 IHRoZSBkcm0gZGV2aWNlCisgKiBAZGF0YTogcG9pbnRlciB0byBzdHJ1Y3QgZHJtX21vZGVfbGlz dF9sZXNzZWVzCisgKiBAbGVzc29yX3ByaXY6IHRoZSBmaWxlIGJlaW5nIG1hbmlwdWxhdGVkCisg KgorICogU3RhcnRpbmcgZnJvbSB0aGUgbWFzdGVyIGFzc29jaWF0ZWQgd2l0aCB0aGUgc3BlY2lm aWVkIGZpbGUsCisgKiB0aGUgbWFzdGVyIHdpdGggdGhlIHByb3ZpZGVkIGxlc3NlZV9pZCBpcyBm b3VuZCwgYW5kIHRoZW4KKyAqIGFuIGFycmF5IG9mIGxlc3NlZSBpZHMgYXNzb2NpYXRlZCB3aXRo IGxlYXNlcyBmcm9tIHRoYXQgbWFzdGVyCisgKiBhcmUgcmV0dXJuZWQuCisgKi8KKworaW50IGRy bV9tb2RlX2xpc3RfbGVzc2Vlc19pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQkJICAg ICAgIHZvaWQgKmRhdGEsIHN0cnVjdCBkcm1fZmlsZSAqbGVzc29yX3ByaXYpCit7CisJc3RydWN0 IGRybV9tb2RlX2xpc3RfbGVzc2VlcyAqYXJnID0gZGF0YTsKKwlfX3UzMiBfX3VzZXIgKmxlc3Nl ZV9pZHMgPSAoX191MzIgX191c2VyICopICh1aW50cHRyX3QpIChhcmctPmxlc3NlZXNfcHRyKTsK KwlfX3UzMiBjb3VudF9sZXNzZWVzID0gYXJnLT5jb3VudF9sZXNzZWVzOworCXN0cnVjdCBkcm1f bWFzdGVyICpsZXNzb3IgPSBsZXNzb3JfcHJpdi0+bWFzdGVyLCAqbGVzc2VlOworCWludCBjb3Vu dDsKKwlpbnQgcmV0ID0gMDsKKworCURSTV9ERUJVR19MRUFTRSgiTGlzdCBsZXNzZWVzIGZvciAl ZFxuIiwgbGVzc29yLT5sZXNzZWVfaWQpOworCisJbXV0ZXhfbG9jaygmZGV2LT5tYXN0ZXJfbXV0 ZXgpOworCisJY291bnQgPSAwOworCWRybV9mb3JfZWFjaF9sZXNzZWUobGVzc2VlLCBsZXNzb3Ip IHsKKwkJLyogT25seSBsaXN0IHVuLXJldm9rZWQgbGVhc2VzICovCisJCWlmICghaWRyX2lzX2Vt cHR5KCZsZXNzZWUtPmxlYXNlcykpIHsKKwkJCWlmIChjb3VudF9sZXNzZWVzID4gY291bnQpIHsK KwkJCQlEUk1fREVCVUdfTEVBU0UoIkFkZCBsZXNzZWUgJWRcbiIsIGxlc3NlZS0+bGVzc2VlX2lk KTsKKwkJCQlyZXQgPSBwdXRfdXNlcihsZXNzZWUtPmxlc3NlZV9pZCwgbGVzc2VlX2lkcyArIGNv dW50KTsKKwkJCQlpZiAocmV0KQorCQkJCQlicmVhazsKKwkJCX0KKwkJCWNvdW50Kys7CisJCX0K Kwl9CisKKwlEUk1fREVCVUdfTEVBU0UoIkxlc3NvciBsZWFzZXMgdG8gJWRcbiIsIGNvdW50KTsK KwlpZiAocmV0ID09IDApCisJCWFyZy0+Y291bnRfbGVzc2VlcyA9IGNvdW50OworCisJbXV0ZXhf dW5sb2NrKCZkZXYtPm1hc3Rlcl9tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorCisvKioKKyAq IGRybV9tb2RlX2dldF9sZWFzZV9pb2N0bCAtIGxpc3QgbGVhc2VkIG9iamVjdHMKKyAqIEBkZXY6 IHRoZSBkcm0gZGV2aWNlCisgKiBAZGF0YTogcG9pbnRlciB0byBzdHJ1Y3QgZHJtX21vZGVfZ2V0 X2xlYXNlCisgKiBAZmlsZV9wcml2OiB0aGUgZmlsZSBiZWluZyBtYW5pcHVsYXRlZAorICoKKyAq IFJldHVybiB0aGUgbGlzdCBvZiBsZWFzZWQgb2JqZWN0cyBmb3IgdGhlIHNwZWNpZmllZCBsZXNz ZWUKKyAqLworCitpbnQgZHJtX21vZGVfZ2V0X2xlYXNlX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsCisJCQkgICAgIHZvaWQgKmRhdGEsIHN0cnVjdCBkcm1fZmlsZSAqbGVzc2VlX3ByaXYp Cit7CisJc3RydWN0IGRybV9tb2RlX2dldF9sZWFzZSAqYXJnID0gZGF0YTsKKwlfX3UzMiBfX3Vz ZXIgKm9iamVjdF9pZHMgPSAoX191MzIgX191c2VyICopICh1aW50cHRyX3QpIChhcmctPm9iamVj dHNfcHRyKTsKKwlfX3UzMiBjb3VudF9vYmplY3RzID0gYXJnLT5jb3VudF9vYmplY3RzOworCXN0 cnVjdCBkcm1fbWFzdGVyICpsZXNzZWUgPSBsZXNzZWVfcHJpdi0+bWFzdGVyOworCXN0cnVjdCBp ZHIgKm9iamVjdF9pZHI7CisJaW50IGNvdW50OworCXZvaWQgKmVudHJ5OworCWludCBvYmplY3Q7 CisJaW50IHJldCA9IDA7CisKKwlEUk1fREVCVUdfTEVBU0UoImdldCBsZWFzZSBmb3IgJWRcbiIs IGxlc3NlZS0+bGVzc2VlX2lkKTsKKworCW11dGV4X2xvY2soJmRldi0+bWFzdGVyX211dGV4KTsK KworCWlmIChsZXNzZWUtPmxlc3NvciA9PSBOVUxMKQorCQkvKiBvd25lciBjYW4gdXNlIGFsbCBv YmplY3RzICovCisJCW9iamVjdF9pZHIgPSAmbGVzc2VlLT5kZXYtPm1vZGVfY29uZmlnLmNydGNf aWRyOworCWVsc2UKKwkJLyogbGVzc2VlIGNhbiBvbmx5IHVzZSBhbGxvd2VkIG9iamVjdCAqLwor CQlvYmplY3RfaWRyID0gJmxlc3NlZS0+bGVhc2VzOworCisJY291bnQgPSAwOworCWlkcl9mb3Jf ZWFjaF9lbnRyeShvYmplY3RfaWRyLCBlbnRyeSwgb2JqZWN0KSB7CisJCWlmIChjb3VudF9vYmpl Y3RzID4gY291bnQpIHsKKwkJCURSTV9ERUJVR19MRUFTRSgiYWRkaW5nIG9iamVjdCAlZFxuIiwg b2JqZWN0KTsKKwkJCXJldCA9IHB1dF91c2VyKG9iamVjdCwgb2JqZWN0X2lkcyArIGNvdW50KTsK KwkJCWlmIChyZXQpCisJCQkJYnJlYWs7CisJCX0KKwkJY291bnQrKzsKKwl9CisKKwlEUk1fREVC VUcoImxlYXNlIGhvbGRzICVkIG9iamVjdHNcbiIsIGNvdW50KTsKKwlpZiAocmV0ID09IDApCisJ CWFyZy0+Y291bnRfb2JqZWN0cyA9IGNvdW50OworCisJbXV0ZXhfdW5sb2NrKCZkZXYtPm1hc3Rl cl9tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorCisvKioKKyAqIGRybV9tb2RlX3Jldm9rZV9s ZWFzZV9pb2N0bCAtIHJldm9rZSBsZWFzZQorICogQGRldjogdGhlIGRybSBkZXZpY2UKKyAqIEBk YXRhOiBwb2ludGVyIHRvIHN0cnVjdCBkcm1fbW9kZV9yZXZva2VfbGVhc2UKKyAqIEBmaWxlX3By aXY6IHRoZSBmaWxlIGJlaW5nIG1hbmlwdWxhdGVkCisgKgorICogVGhpcyByZW1vdmVzIGFsbCBv ZiB0aGUgb2JqZWN0cyBmcm9tIHRoZSBsZWFzZSB3aXRob3V0CisgKiBhY3R1YWxseSBnZXR0aW5n IHJpZCBvZiB0aGUgbGVhc2UgaXRzZWxmOyB0aGF0IHdheSBhbGwKKyAqIHJlZmVyZW5jZXMgdG8g aXQgc3RpbGwgd29yayBjb3JyZWN0bHkKKyAqLworaW50IGRybV9tb2RlX3Jldm9rZV9sZWFzZV9p b2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQkJCXZvaWQgKmRhdGEsIHN0cnVjdCBkcm1f ZmlsZSAqbGVzc29yX3ByaXYpCit7CisJc3RydWN0IGRybV9tb2RlX3Jldm9rZV9sZWFzZSAqYXJn ID0gZGF0YTsKKwlzdHJ1Y3QgZHJtX21hc3RlciAqbGVzc29yID0gbGVzc29yX3ByaXYtPm1hc3Rl cjsKKwlzdHJ1Y3QgZHJtX21hc3RlciAqbGVzc2VlOworCWludCByZXQgPSAwOworCisJRFJNX0RF QlVHX0xFQVNFKCJyZXZva2UgbGVhc2UgZm9yICVkXG4iLCBhcmctPmxlc3NlZV9pZCk7CisKKwlt dXRleF9sb2NrKCZkZXYtPm1hc3Rlcl9tdXRleCk7CisKKwlsZXNzZWUgPSBfZHJtX2ZpbmRfbGVz c2VlKGxlc3NvciwgYXJnLT5sZXNzZWVfaWQpOworCisJLyogTm8gc3VjaCBsZXNzZWUgKi8KKwlp ZiAoIWxlc3NlZSkgeworCQlyZXQgPSAtRU5PRU5UOworCQlnb3RvIGZhaWw7CisJfQorCisJLyog TGVhc2UgaXMgbm90IGhlbGQgYnkgbGVzc29yICovCisJaWYgKGxlc3NlZS0+bGVzc29yICE9IGxl c3NvcikgeworCQlyZXQgPSAtRUFDQ0VTOworCQlnb3RvIGZhaWw7CisJfQorCisJX2RybV9sZWFz ZV9yZXZva2UobGVzc2VlKTsKKworZmFpbDoKKwltdXRleF91bmxvY2soJmRldi0+bWFzdGVyX211 dGV4KTsKKworCXJldHVybiByZXQ7Cit9CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fbGVh c2UuaCBiL2luY2x1ZGUvZHJtL2RybV9sZWFzZS5oCmluZGV4IGE0OTY2N2RiMWQ2ZC4uNTNmZmNl ZTI2MTdlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fbGVhc2UuaAorKysgYi9pbmNsdWRl L2RybS9kcm1fbGVhc2UuaApAQCAtMzMsNCArMzMsMTYgQEAgdWludDMyX3QgZHJtX2xlYXNlX2Zp bHRlcl9jcnRjcyhzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdiwgdWludDMyX3QgY3J0Y3MpOwog CiB1aW50MzJfdCBkcm1fbGVhc2VfZmlsdGVyX2VuY29kZXJzKHN0cnVjdCBkcm1fZmlsZSAqZmls ZV9wcml2LCB1aW50MzJfdCBlbmNvZGVycyk7CiAKK2ludCBkcm1fbW9kZV9jcmVhdGVfbGVhc2Vf aW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJCQl2b2lkICpkYXRhLCBzdHJ1Y3QgZHJt X2ZpbGUgKmZpbGVfcHJpdik7CisKK2ludCBkcm1fbW9kZV9saXN0X2xlc3NlZXNfaW9jdGwoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKKwkJCQl2b2lkICpkYXRhLCBzdHJ1Y3QgZHJtX2ZpbGUgKmZp bGVfcHJpdik7CisKK2ludCBkcm1fbW9kZV9nZXRfbGVhc2VfaW9jdGwoc3RydWN0IGRybV9kZXZp Y2UgKmRldiwKKwkJCSAgICAgdm9pZCAqZGF0YSwgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYp OworCitpbnQgZHJtX21vZGVfcmV2b2tlX2xlYXNlX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCisJCQkJdm9pZCAqZGF0YSwgc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYpOworCiAjZW5k aWYgLyogX0RSTV9MRUFTRV9IXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2RybS9kcm0u aCBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtLmgKaW5kZXggMTAxNTkzYWIxMGFjLi5kZDM1MGJmMGFk NzUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9kcm0vZHJtLmgKKysrIGIvaW5jbHVkZS91YXBp L2RybS9kcm0uaApAQCAtODQxLDYgKzg0MSwxMSBAQCBleHRlcm4gIkMiIHsKICNkZWZpbmUgRFJN X0lPQ1RMX1NZTkNPQkpfSEFORExFX1RPX0ZECURSTV9JT1dSKDB4QzEsIHN0cnVjdCBkcm1fc3lu Y29ial9oYW5kbGUpCiAjZGVmaW5lIERSTV9JT0NUTF9TWU5DT0JKX0ZEX1RPX0hBTkRMRQlEUk1f SU9XUigweEMyLCBzdHJ1Y3QgZHJtX3N5bmNvYmpfaGFuZGxlKQogCisjZGVmaW5lIERSTV9JT0NU TF9NT0RFX0NSRUFURV9MRUFTRQlEUk1fSU9XUigweEMzLCBzdHJ1Y3QgZHJtX21vZGVfY3JlYXRl X2xlYXNlKQorI2RlZmluZSBEUk1fSU9DVExfTU9ERV9MSVNUX0xFU1NFRVMJRFJNX0lPV1IoMHhD NCwgc3RydWN0IGRybV9tb2RlX2xpc3RfbGVzc2VlcykKKyNkZWZpbmUgRFJNX0lPQ1RMX01PREVf R0VUX0xFQVNFCURSTV9JT1dSKDB4QzUsIHN0cnVjdCBkcm1fbW9kZV9nZXRfbGVhc2UpCisjZGVm aW5lIERSTV9JT0NUTF9NT0RFX1JFVk9LRV9MRUFTRQlEUk1fSU9XUigweEM2LCBzdHJ1Y3QgZHJt X21vZGVfcmV2b2tlX2xlYXNlKQorCiAvKioKICAqIERldmljZSBzcGVjaWZpYyBpb2N0bHMgc2hv dWxkIG9ubHkgYmUgaW4gdGhlaXIgcmVzcGVjdGl2ZSBoZWFkZXJzCiAgKiBUaGUgZGV2aWNlIHNw ZWNpZmljIGlvY3RsIHJhbmdlIGlzIGZyb20gMHg0MCB0byAweDlmLgpkaWZmIC0tZ2l0IGEvaW5j bHVkZS91YXBpL2RybS9kcm1fbW9kZS5oIGIvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCmlu ZGV4IDQwMzMzOWY5OGE5Mi4uNTk2NGYyNWZhODhlIDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkv ZHJtL2RybV9tb2RlLmgKKysrIGIvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCkBAIC03MzIs NiArNzMyLDcyIEBAIHN0cnVjdCBkcm1fbW9kZV9kZXN0cm95X2Jsb2IgewogCV9fdTMyIGJsb2Jf aWQ7CiB9OwogCisvKioKKyAqIExlYXNlIG1vZGUgcmVzb3VyY2VzLCBjcmVhdGluZyBhbm90aGVy IGRybV9tYXN0ZXIuCisgKi8KK3N0cnVjdCBkcm1fbW9kZV9jcmVhdGVfbGVhc2UgeworCS8qKiBQ b2ludGVyIHRvIGFycmF5IG9mIG9iamVjdCBpZHMgKF9fdTMyKSAqLworCV9fdTY0IG9iamVjdF9p ZHM7CisJLyoqIE51bWJlciBvZiBvYmplY3QgaWRzICovCisJX191MzIgb2JqZWN0X2NvdW50Owor CS8qKiBmbGFncyBmb3IgbmV3IEZEIChPX0NMT0VYRUMsIGV0YykgKi8KKwlfX3UzMiBmbGFnczsK KworCS8qKiBSZXR1cm46IHVuaXF1ZSBpZGVudGlmaWVyIGZvciBsZXNzZWUuICovCisJX191MzIg bGVzc2VlX2lkOworCS8qKiBSZXR1cm46IGZpbGUgZGVzY3JpcHRvciB0byBuZXcgZHJtX21hc3Rl ciBmaWxlICovCisJX191MzIgZmQ7Cit9OworCisvKioKKyAqIExpc3QgbGVzc2VzIGZyb20gYSBk cm1fbWFzdGVyCisgKi8KK3N0cnVjdCBkcm1fbW9kZV9saXN0X2xlc3NlZXMgeworCS8qKiBOdW1i ZXIgb2YgbGVzc2Vlcy4KKwkgKiBPbiBpbnB1dCwgcHJvdmlkZXMgbGVuZ3RoIG9mIHRoZSBhcnJh eS4KKwkgKiBPbiBvdXRwdXQsIHByb3ZpZGVzIHRvdGFsIG51bWJlci4gTm8KKwkgKiBtb3JlIHRo YW4gdGhlIGlucHV0IG51bWJlciB3aWxsIGJlIHdyaXR0ZW4KKwkgKiBiYWNrLCBzbyB0d28gY2Fs bHMgY2FuIGJlIHVzZWQgdG8gZ2V0CisJICogdGhlIHNpemUgYW5kIHRoZW4gdGhlIGRhdGEuCisJ ICovCisJX191MzIgY291bnRfbGVzc2VlczsKKwlfX3UzMiBwYWQ7CisKKwkvKiogUG9pbnRlciB0 byBsZXNzZWVzLgorCSAqIHBvaW50ZXIgdG8gX191NjQgYXJyYXkgb2YgbGVzc2VlIGlkcworCSAq LworCV9fdTY0IGxlc3NlZXNfcHRyOworfTsKKworLyoqCisgKiBHZXQgbGVhc2VkIG9iamVjdHMK KyAqLworc3RydWN0IGRybV9tb2RlX2dldF9sZWFzZSB7CisJLyoqIE51bWJlciBvZiBsZWFzZWQg b2JqZWN0cy4KKwkgKiBPbiBpbnB1dCwgcHJvdmlkZXMgbGVuZ3RoIG9mIHRoZSBhcnJheS4KKwkg KiBPbiBvdXRwdXQsIHByb3ZpZGVzIHRvdGFsIG51bWJlci4gTm8KKwkgKiBtb3JlIHRoYW4gdGhl IGlucHV0IG51bWJlciB3aWxsIGJlIHdyaXR0ZW4KKwkgKiBiYWNrLCBzbyB0d28gY2FsbHMgY2Fu IGJlIHVzZWQgdG8gZ2V0CisJICogdGhlIHNpemUgYW5kIHRoZW4gdGhlIGRhdGEuCisJICovCisJ X191MzIgY291bnRfb2JqZWN0czsKKwlfX3UzMiBwYWQ7CisKKwkvKiogUG9pbnRlciB0byBvYmpl Y3RzLgorCSAqIHBvaW50ZXIgdG8gX191MzIgYXJyYXkgb2Ygb2JqZWN0IGlkcworCSAqLworCV9f dTY0IG9iamVjdHNfcHRyOworfTsKKworLyoqCisgKiBSZXZva2UgbGVhc2UKKyAqLworc3RydWN0 IGRybV9tb2RlX3Jldm9rZV9sZWFzZSB7CisJLyoqIFVuaXF1ZSBJRCBvZiBsZXNzZWUKKwkgKi8K KwlfX3UzMiBsZXNzZWVfaWQ7Cit9OworCiAjaWYgZGVmaW5lZChfX2NwbHVzcGx1cykKIH0KICNl bmRpZgotLSAKMi4xMy4zCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmkt ZGV2ZWwK