From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751527AbdJEGVM (ORCPT ); Thu, 5 Oct 2017 02:21:12 -0400 Received: from home.keithp.com ([63.227.221.253]:43288 "EHLO elaine.keithp.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751267AbdJEGUI (ORCPT ); Thu, 5 Oct 2017 02:20:08 -0400 From: Keith Packard To: linux-kernel@vger.kernel.org, Dave Airlie , Daniel Vetter Cc: Keith Packard , dri-devel@lists.freedesktop.org Subject: [PATCH 4/6] drm: Add drm_object lease infrastructure [v4] Date: Wed, 4 Oct 2017 23:13:08 -0700 Message-Id: <20171005061310.29919-5-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> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This provides new data structures to hold "lease" information about drm mode setting objects, and provides for creating new drm_masters which have access to a subset of the available drm resources. An 'owner' is a drm_master which is not leasing the objects from another drm_master, and hence 'owns' them. A 'lessee' is a drm_master which is leasing objects from some other drm_master. Each lessee holds the set of objects which it is leasing from the lessor. A 'lessor' is a drm_master which is leasing objects to another drm_master. This is the same as the owner in the current code. The set of objects any drm_master 'controls' is limited to the set of objects it leases (for lessees) or all objects (for owners). Objects not controlled by a drm_master cannot be modified through the various state manipulating ioctls, and any state reported back to user space will be edited to make them appear idle and/or unusable. For instance, connectors always report 'disconnected', while encoders report no possible crtcs or clones. The full list of lessees leasing objects from an owner (either directly, or indirectly through another lessee), can be searched from an idr in the drm_master of the owner. Changes for v2 as suggested by Daniel Vetter : * Sub-leasing has been disabled. * BUG_ON for lock checking replaced with lockdep_assert_held * 'change' ioctl has been removed. * Leased objects can always be controlled by the lessor; the 'mask_lease' flag has been removed * Checking for leased status has been simplified, replacing the drm_lease_check function with drm_lease_held. Changes in v3, some suggested by Dave Airlie * Add revocation. This allows leases to be effectively revoked by removing all of the objects they have access to. The lease itself hangs around as it's hanging off a file. * Free the leases IDR when the master is destroyed * _drm_lease_held should look at lessees, not lessor * Allow non-master files to check for lease status Changes in v4, suggested by Dave Airlie * Formatting and whitespace changes Signed-off-by: Keith Packard --- drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_auth.c | 29 +++- drivers/gpu/drm/drm_lease.c | 379 ++++++++++++++++++++++++++++++++++++++++++ include/drm/drm_auth.h | 20 +++ include/drm/drm_lease.h | 36 ++++ include/drm/drm_mode_object.h | 1 + 6 files changed, 465 insertions(+), 2 deletions(-) create mode 100644 drivers/gpu/drm/drm_lease.c create mode 100644 include/drm/drm_lease.h diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 24a066e1841c..3a47f5ae6f16 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -17,7 +17,7 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \ drm_encoder.o drm_mode_object.o drm_property.o \ drm_plane.o drm_color_mgmt.o drm_print.o \ drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \ - drm_syncobj.o + drm_syncobj.o drm_lease.o drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o drm-$(CONFIG_DRM_VM) += drm_vm.o diff --git a/drivers/gpu/drm/drm_auth.c b/drivers/gpu/drm/drm_auth.c index 7ff697389d74..541177c71d51 100644 --- a/drivers/gpu/drm/drm_auth.c +++ b/drivers/gpu/drm/drm_auth.c @@ -31,6 +31,7 @@ #include #include "drm_internal.h" #include "drm_legacy.h" +#include /** * DOC: master and authentication @@ -93,7 +94,7 @@ int drm_authmagic(struct drm_device *dev, void *data, return file ? 0 : -EINVAL; } -static struct drm_master *drm_master_create(struct drm_device *dev) +struct drm_master *drm_master_create(struct drm_device *dev) { struct drm_master *master; @@ -107,6 +108,14 @@ static struct drm_master *drm_master_create(struct drm_device *dev) idr_init(&master->magic_map); master->dev = dev; + /* initialize the tree of output resource lessees */ + master->lessor = NULL; + master->lessee_id = 0; + INIT_LIST_HEAD(&master->lessees); + INIT_LIST_HEAD(&master->lessee_list); + idr_init(&master->leases); + idr_init(&master->lessee_idr); + return master; } @@ -189,6 +198,12 @@ int drm_setmaster_ioctl(struct drm_device *dev, void *data, goto out_unlock; } + if (file_priv->master->lessor != NULL) { + DRM_DEBUG_LEASE("Attempt to set lessee %d as master\n", file_priv->master->lessee_id); + ret = -EINVAL; + goto out_unlock; + } + ret = drm_set_master(dev, file_priv, false); out_unlock: mutex_unlock(&dev->master_mutex); @@ -270,6 +285,13 @@ void drm_master_release(struct drm_file *file_priv) if (dev->master == file_priv->master) drm_drop_master(dev, file_priv); out: + if (file_priv->is_master) { + /* Revoke any leases held by this or lessees, but only if + * this is the "real" master + */ + _drm_lease_revoke(master); + } + /* drop the master reference held by the file priv */ if (file_priv->master) drm_master_put(&file_priv->master); @@ -310,12 +332,17 @@ static void drm_master_destroy(struct kref *kref) struct drm_master *master = container_of(kref, struct drm_master, refcount); struct drm_device *dev = master->dev; + drm_lease_destroy(master); + if (dev->driver->master_destroy) dev->driver->master_destroy(dev, master); drm_legacy_master_rmmaps(dev, master); idr_destroy(&master->magic_map); + idr_destroy(&master->leases); + idr_destroy(&master->lessee_idr); + kfree(master->unique); kfree(master); } diff --git a/drivers/gpu/drm/drm_lease.c b/drivers/gpu/drm/drm_lease.c new file mode 100644 index 000000000000..2ac404264d75 --- /dev/null +++ b/drivers/gpu/drm/drm_lease.c @@ -0,0 +1,379 @@ +/* + * Copyright © 2017 Keith Packard + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ + +#include +#include "drm_internal.h" +#include "drm_legacy.h" +#include "drm_crtc_internal.h" +#include +#include +#include + +#define drm_for_each_lessee(lessee, lessor) \ + list_for_each_entry((lessee), &(lessor)->lessees, lessee_list) + +/** + * drm_lease_owner - return ancestor owner drm_master + * @master: drm_master somewhere within tree of lessees and lessors + * + * RETURN: + * + * drm_master at the top of the tree (i.e, with lessor NULL + */ +struct drm_master *drm_lease_owner(struct drm_master *master) +{ + while (master->lessor != NULL) + master = master->lessor; + return master; +} +EXPORT_SYMBOL(drm_lease_owner); + +/** + * _drm_find_lessee - find lessee by id + * @master: drm_master of lessor + * @id: lessee_id + * + * RETURN: + * + * drm_master of the lessee if valid, NULL otherwise + */ + +static struct drm_master* +_drm_find_lessee(struct drm_master *master, int lessee_id) +{ + return idr_find(&drm_lease_owner(master)->lessee_idr, lessee_id); +} + +/** + * _drm_lease_held_master - check to see if an object is leased (or owned) by master + * @master: the master to check the lease status of + * @id: the id to check + * + * Checks if the specified master holds a lease on the object. Return + * value: + * + * true 'master' holds a lease on (or owns) the object + * false 'master' does not hold a lease. + */ +static int _drm_lease_held_master(struct drm_master *master, int id) +{ + lockdep_assert_held(&master->dev->mode_config.idr_mutex); + if (master->lessor) + return idr_find(&master->leases, id) != NULL; + return true; +} + +/** + * _drm_has_leased - check to see if an object has been leased + * @master: the master to check the lease status of + * @id: the id to check + * + * Checks if any lessee of 'master' holds a lease on 'id'. Return + * value: + * + * true Some lessee holds a lease on the object. + * false No lessee has a lease on the object. + */ +static bool _drm_has_leased(struct drm_master *master, int id) +{ + struct drm_master *lessee; + + drm_for_each_lessee(lessee, master) + if (_drm_lease_held_master(lessee, id)) + return true; + return false; +} + +/** + * _drm_lease_held - check drm_mode_object lease status (idr_mutex held) + * @master: the drm_master + * @id: the object id + * + * Checks if the specified master holds a lease on the object. Return + * value: + * + * true 'master' holds a lease on (or owns) the object + * false 'master' does not hold a lease. + */ +bool _drm_lease_held(struct drm_file *file_priv, int id) +{ + if (file_priv == NULL || file_priv->master == NULL) + return true; + + return _drm_lease_held_master(file_priv->master, id); +} +EXPORT_SYMBOL(_drm_lease_held); + +/** + * drm_lease_held - check drm_mode_object lease status (idr_mutex not held) + * @master: the drm_master + * @id: the object id + * + * Checks if the specified master holds a lease on the object. Return + * value: + * + * true 'master' holds a lease on (or owns) the object + * false 'master' does not hold a lease. + */ +bool drm_lease_held(struct drm_file *file_priv, int id) +{ + struct drm_master *master; + bool ret; + + if (file_priv == NULL || file_priv->master == NULL) + return true; + + master = file_priv->master; + mutex_lock(&master->dev->mode_config.idr_mutex); + ret = _drm_lease_held_master(master, id); + mutex_unlock(&master->dev->mode_config.idr_mutex); + return ret; +} +EXPORT_SYMBOL(drm_lease_held); + +/** + * drm_lease_filter_crtcs - restricted crtc set to leased values + * @file_priv: requestor file + * @crtcs: bitmask of crtcs to check + * + * Reconstructs a crtc mask based on the crtcs which are visible + * through the specified file. + */ +uint32_t drm_lease_filter_crtcs(struct drm_file *file_priv, uint32_t crtcs_in) +{ + struct drm_master *master; + struct drm_device *dev; + struct drm_crtc *crtc; + int count_in, count_out; + uint32_t crtcs_out = 0; + + if (file_priv == NULL || file_priv->master == NULL) + return crtcs_in; + + master = file_priv->master; + dev = master->dev; + + count_in = count_out = 0; + mutex_lock(&master->dev->mode_config.idr_mutex); + list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { + if (_drm_lease_held_master(master, crtc->base.id)) { + uint32_t mask_in = 1ul << count_in; + if ((crtcs_in & mask_in) != 0) { + uint32_t mask_out = 1ul << count_out; + crtcs_out |= mask_out; + } + count_out++; + } + count_in++; + } + mutex_unlock(&master->dev->mode_config.idr_mutex); + return crtcs_out; +} +EXPORT_SYMBOL(drm_lease_filter_crtcs); + +/** + * drm_lease_filter_encoders - restrict encoder set to leased values + * @file_priv: requestor file + * @encoders: bitmask of encoders to check + * + * Reconstructs an encoder mask based on the encoders which are + * visible through the specified file. + */ +uint32_t drm_lease_filter_encoders(struct drm_file *file_priv, uint32_t encoders_in) +{ + struct drm_master *master; + struct drm_device *dev; + struct drm_encoder *encoder; + int count_in, count_out; + uint32_t encoders_out = 0; + + count_in = count_out = 0; + if (file_priv == NULL || file_priv->master == NULL) + return encoders_in; + + master = file_priv->master; + dev = master->dev; + + mutex_lock(&master->dev->mode_config.idr_mutex); + list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { + if (_drm_lease_held_master(master, encoder->base.id)) { + uint32_t mask_in = 1ul << count_in; + if ((encoders_in & mask_in) != 0) { + uint32_t mask_out = 1ul << count_out; + encoders_out |= mask_out; + } + count_out++; + } + count_in++; + } + mutex_unlock(&master->dev->mode_config.idr_mutex); + return encoders_out; +} +EXPORT_SYMBOL(drm_lease_filter_encoders); + +/* + * drm_lease_create - create a new drm_master with leased objects + * @lessor: lease holder (or owner) of objects + * @leases: objects to lease to the new drm_master + * + * Uses drm_master_create to allocate a new drm_master, then checks to + * make sure all of the desired objects can be leased, atomically + * leasing them to the new drmmaster. + * + * ERR_PTR(-EACCESS) some other master holds the title to any object + * ERR_PTR(-ENOENT) some object is not a valid DRM object for this device + * ERR_PTR(-EBUSY) some other lessee holds title to this object + * ERR_PTR(-EEXIST) same object specified more than once in the provided list + * ERR_PTR(-ENOMEM) allocation failed + */ +static struct drm_master *drm_lease_create(struct drm_master *lessor, struct idr *leases) +{ + struct drm_device *dev = lessor->dev; + int error; + struct drm_master *lessee; + int object; + int id; + void *entry; + + DRM_DEBUG_LEASE("lessor %d\n", lessor->lessee_id); + + lockdep_assert_held(&lessor->dev->master_mutex); + + lessee = drm_master_create(lessor->dev); + if (!lessee) { + DRM_DEBUG_LEASE("drm_master_create failed\n"); + return ERR_PTR(-ENOMEM); + } + + /* Insert the new lessee into the tree */ + id = idr_alloc(&(drm_lease_owner(lessor)->lessee_idr), lessee, 1, 0, GFP_KERNEL); + if (id < 0) { + error = id; + goto out_lessee; + } + + lessee->lessee_id = id; + lessee->lessor = drm_master_get(lessor); + list_add_tail(&lessee->lessee_list, &lessor->lessees); + + /* Lock the mode object mutex to make the check and allocation atomic */ + mutex_lock(&lessor->dev->mode_config.idr_mutex); + idr_for_each_entry(leases, entry, object) { + error = 0; + if (!idr_find(&dev->mode_config.crtc_idr, object)) + error = -ENOENT; + else if (!_drm_lease_held_master(lessor, object)) + error = -EACCES; + else if (_drm_has_leased(lessor, object)) + error = -EBUSY; + + if (error != 0) { + DRM_DEBUG_LEASE("object %d failed %d\n", object, error); + goto out_unlock; + } + } + + /* Move the leases over */ + lessee->leases = *leases; + mutex_unlock(&lessor->dev->mode_config.idr_mutex); + DRM_DEBUG_LEASE("new lessee %d %p, lessor %d %p\n", lessee->lessee_id, lessee, lessor->lessee_id, lessor); + return lessee; + +out_unlock: + mutex_unlock(&lessor->dev->mode_config.idr_mutex); + +out_lessee: + drm_master_put(&lessee); + return ERR_PTR(error); +} + +/** + * drm_lease_destroy - a master is going away + * @master: the drm_master being destroyed + * + * All lessees will have been destroyed as they + * hold a reference on their lessor. Notify any + * lessor for this master so that it can check + * the list of lessees. + */ +void drm_lease_destroy(struct drm_master *master) +{ + struct drm_device *dev = master->dev; + + lockdep_assert_held(&dev->master_mutex); + + DRM_DEBUG_LEASE("drm_lease_destroy %d\n", master->lessee_id); + + /* This master is referenced by all lessees, hence it cannot be destroyed + * until all of them have been + */ + WARN_ON(!list_empty(&master->lessees)); + + /* Remove this master from the lessee idr in the owner */ + if (master->lessee_id != 0) { + DRM_DEBUG_LEASE("remove master %d from device list of lessees\n", master->lessee_id); + idr_remove(&(drm_lease_owner(master)->lessee_idr), master->lessee_id); + } + + /* Remove this master from any lessee list it may be on */ + list_del(&master->lessee_list); + if (master->lessor) { + /* Tell the master to check the lessee list */ + drm_sysfs_hotplug_event(dev); + drm_master_put(&master->lessor); + } + + DRM_DEBUG_LEASE("drm_lease_destroy done %d\n", master->lessee_id); +} + +/** + * _drm_lease_revoke - revoke access to all leased objects + * @master: the master losing its lease + */ + +void _drm_lease_revoke(struct drm_master *top) +{ + int object; + void *entry; + struct drm_master *master = top; + + /* + * Walk the tree starting at 'top' emptying all leases. Because + * the tree is fully connected, we can do this without recursing + */ + for (;;) { + DRM_DEBUG_LEASE("revoke leases for %p %d\n", master, master->lessee_id); + + /* Evacuate the lease */ + idr_for_each_entry(&master->leases, entry, object) + idr_remove(&master->leases, object); + + /* Depth-first list walk */ + + /* Down */ + if (!list_empty(&master->lessees)) { + master = list_first_entry(&master->lessees, struct drm_master, lessee_list); + } else { + /* Up */ + while (master != top && master == list_last_entry(&master->lessor->lessees, struct drm_master, lessee_list)) + master = master->lessor; + + if (master == top) + break; + + /* Over */ + master = list_entry(master->lessee_list.next, struct drm_master, lessee_list); + } + } +} diff --git a/include/drm/drm_auth.h b/include/drm/drm_auth.h index 81a40c2a9a3e..4b7fc22d3fc9 100644 --- a/include/drm/drm_auth.h +++ b/include/drm/drm_auth.h @@ -52,6 +52,12 @@ struct drm_lock_data { * @dev: Link back to the DRM device * @lock: DRI1 lock information. * @driver_priv: Pointer to driver-private information. + * @lessor: Lease holder + * @lessee_id: id for lessees. Owners always have id 0 + * @lessee_list: other lessees of the same master + * @lessees: drm_masters leasing from this one + * @leases: Objects leased to this drm_master. + * @lessee_idr: All lessees under this owner (only used where lessor == NULL) * * Note that master structures are only relevant for the legacy/primary device * nodes, hence there can only be one per device, not one per drm_minor. @@ -76,10 +82,24 @@ struct drm_master { struct idr magic_map; struct drm_lock_data lock; void *driver_priv; + + /* Tree of display resource leases, each of which is a drm_master struct + * All of these get activated simultaneously, so drm_device master points + * at the top of the tree (for which lessor is NULL) + */ + + struct drm_master *lessor; + int lessee_id; + struct list_head lessee_list; + struct list_head lessees; + struct idr leases; + struct idr lessee_idr; }; struct drm_master *drm_master_get(struct drm_master *master); void drm_master_put(struct drm_master **master); bool drm_is_current_master(struct drm_file *fpriv); +struct drm_master *drm_master_create(struct drm_device *dev); + #endif diff --git a/include/drm/drm_lease.h b/include/drm/drm_lease.h new file mode 100644 index 000000000000..a49667db1d6d --- /dev/null +++ b/include/drm/drm_lease.h @@ -0,0 +1,36 @@ +/* + * Copyright © 2017 Keith Packard + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ + +#ifndef _DRM_LEASE_H_ +#define _DRM_LEASE_H_ + +struct drm_file; +struct drm_device; +struct drm_master; + +struct drm_master *drm_lease_owner(struct drm_master *master); + +void drm_lease_destroy(struct drm_master *lessee); + +bool drm_lease_held(struct drm_file *file_priv, int id); + +bool _drm_lease_held(struct drm_file *file_priv, int id); + +void _drm_lease_revoke(struct drm_master *master); + +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); + +#endif /* _DRM_LEASE_H_ */ diff --git a/include/drm/drm_mode_object.h b/include/drm/drm_mode_object.h index b2f920b518e3..c8155cb5a932 100644 --- a/include/drm/drm_mode_object.h +++ b/include/drm/drm_mode_object.h @@ -24,6 +24,7 @@ #define __DRM_MODESET_H__ #include +#include struct drm_object_properties; struct drm_property; struct drm_device; -- 2.13.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Keith Packard Subject: [PATCH 4/6] drm: Add drm_object lease infrastructure [v4] Date: Wed, 4 Oct 2017 23:13:08 -0700 Message-ID: <20171005061310.29919-5-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 6A3EA6E5DE for ; Thu, 5 Oct 2017 06:13:15 +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 VGhpcyBwcm92aWRlcyBuZXcgZGF0YSBzdHJ1Y3R1cmVzIHRvIGhvbGQgImxlYXNlIiBpbmZvcm1h dGlvbiBhYm91dApkcm0gbW9kZSBzZXR0aW5nIG9iamVjdHMsIGFuZCBwcm92aWRlcyBmb3IgY3Jl YXRpbmcgbmV3IGRybV9tYXN0ZXJzCndoaWNoIGhhdmUgYWNjZXNzIHRvIGEgc3Vic2V0IG9mIHRo ZSBhdmFpbGFibGUgZHJtIHJlc291cmNlcy4KCkFuICdvd25lcicgaXMgYSBkcm1fbWFzdGVyIHdo aWNoIGlzIG5vdCBsZWFzaW5nIHRoZSBvYmplY3RzIGZyb20KYW5vdGhlciBkcm1fbWFzdGVyLCBh bmQgaGVuY2UgJ293bnMnIHRoZW0uCgpBICdsZXNzZWUnIGlzIGEgZHJtX21hc3RlciB3aGljaCBp cyBsZWFzaW5nIG9iamVjdHMgZnJvbSBzb21lIG90aGVyCmRybV9tYXN0ZXIuIEVhY2ggbGVzc2Vl IGhvbGRzIHRoZSBzZXQgb2Ygb2JqZWN0cyB3aGljaCBpdCBpcyBsZWFzaW5nCmZyb20gdGhlIGxl c3Nvci4KCkEgJ2xlc3NvcicgaXMgYSBkcm1fbWFzdGVyIHdoaWNoIGlzIGxlYXNpbmcgb2JqZWN0 cyB0byBhbm90aGVyCmRybV9tYXN0ZXIuIFRoaXMgaXMgdGhlIHNhbWUgYXMgdGhlIG93bmVyIGlu IHRoZSBjdXJyZW50IGNvZGUuCgpUaGUgc2V0IG9mIG9iamVjdHMgYW55IGRybV9tYXN0ZXIgJ2Nv bnRyb2xzJyBpcyBsaW1pdGVkIHRvIHRoZSBzZXQgb2YKb2JqZWN0cyBpdCBsZWFzZXMgKGZvciBs ZXNzZWVzKSBvciBhbGwgb2JqZWN0cyAoZm9yIG93bmVycykuCgpPYmplY3RzIG5vdCBjb250cm9s bGVkIGJ5IGEgZHJtX21hc3RlciBjYW5ub3QgYmUgbW9kaWZpZWQgdGhyb3VnaCB0aGUKdmFyaW91 cyBzdGF0ZSBtYW5pcHVsYXRpbmcgaW9jdGxzLCBhbmQgYW55IHN0YXRlIHJlcG9ydGVkIGJhY2sg dG8gdXNlcgpzcGFjZSB3aWxsIGJlIGVkaXRlZCB0byBtYWtlIHRoZW0gYXBwZWFyIGlkbGUgYW5k L29yIHVudXNhYmxlLiBGb3IKaW5zdGFuY2UsIGNvbm5lY3RvcnMgYWx3YXlzIHJlcG9ydCAnZGlz Y29ubmVjdGVkJywgd2hpbGUgZW5jb2RlcnMKcmVwb3J0IG5vIHBvc3NpYmxlIGNydGNzIG9yIGNs b25lcy4KClRoZSBmdWxsIGxpc3Qgb2YgbGVzc2VlcyBsZWFzaW5nIG9iamVjdHMgZnJvbSBhbiBv d25lciAoZWl0aGVyCmRpcmVjdGx5LCBvciBpbmRpcmVjdGx5IHRocm91Z2ggYW5vdGhlciBsZXNz ZWUpLCBjYW4gYmUgc2VhcmNoZWQgZnJvbQphbiBpZHIgaW4gdGhlIGRybV9tYXN0ZXIgb2YgdGhl IG93bmVyLgoKQ2hhbmdlcyBmb3IgdjIgYXMgc3VnZ2VzdGVkIGJ5IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+OgoKKiBTdWItbGVhc2luZyBoYXMgYmVlbiBkaXNhYmxlZC4K CiogQlVHX09OIGZvciBsb2NrIGNoZWNraW5nIHJlcGxhY2VkIHdpdGggbG9ja2RlcF9hc3NlcnRf aGVsZAoKKiAnY2hhbmdlJyBpb2N0bCBoYXMgYmVlbiByZW1vdmVkLgoKKiBMZWFzZWQgb2JqZWN0 cyBjYW4gYWx3YXlzIGJlIGNvbnRyb2xsZWQgYnkgdGhlIGxlc3NvcjsgdGhlCiAgJ21hc2tfbGVh c2UnIGZsYWcgaGFzIGJlZW4gcmVtb3ZlZAoKKiBDaGVja2luZyBmb3IgbGVhc2VkIHN0YXR1cyBo YXMgYmVlbiBzaW1wbGlmaWVkLCByZXBsYWNpbmcKICB0aGUgZHJtX2xlYXNlX2NoZWNrIGZ1bmN0 aW9uIHdpdGggZHJtX2xlYXNlX2hlbGQuCgpDaGFuZ2VzIGluIHYzLCBzb21lIHN1Z2dlc3RlZCBi eSBEYXZlIEFpcmxpZSA8YWlybGllZEBnbWFpbC5jb20+CgoqIEFkZCByZXZvY2F0aW9uLiBUaGlz IGFsbG93cyBsZWFzZXMgdG8gYmUgZWZmZWN0aXZlbHkgcmV2b2tlZCBieQogIHJlbW92aW5nIGFs bCBvZiB0aGUgb2JqZWN0cyB0aGV5IGhhdmUgYWNjZXNzIHRvLiBUaGUgbGVhc2UgaXRzZWxmCiAg aGFuZ3MgYXJvdW5kIGFzIGl0J3MgaGFuZ2luZyBvZmYgYSBmaWxlLgoKKiBGcmVlIHRoZSBsZWFz ZXMgSURSIHdoZW4gdGhlIG1hc3RlciBpcyBkZXN0cm95ZWQKCiogX2RybV9sZWFzZV9oZWxkIHNo b3VsZCBsb29rIGF0IGxlc3NlZXMsIG5vdCBsZXNzb3IKCiogQWxsb3cgbm9uLW1hc3RlciBmaWxl cyB0byBjaGVjayBmb3IgbGVhc2Ugc3RhdHVzCgpDaGFuZ2VzIGluIHY0LCBzdWdnZXN0ZWQgYnkg RGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwuY29tPgoKKiBGb3JtYXR0aW5nIGFuZCB3aGl0ZXNw YWNlIGNoYW5nZXMKClNpZ25lZC1vZmYtYnk6IEtlaXRoIFBhY2thcmQgPGtlaXRocEBrZWl0aHAu Y29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgIHwgICAyICstCiBkcml2ZXJz L2dwdS9kcm0vZHJtX2F1dGguYyAgICB8ICAyOSArKystCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2xl YXNlLmMgICB8IDM3OSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGluY2x1ZGUvZHJtL2RybV9hdXRoLmggICAgICAgIHwgIDIwICsrKwogaW5jbHVkZS9kcm0vZHJt X2xlYXNlLmggICAgICAgfCAgMzYgKysrKwogaW5jbHVkZS9kcm0vZHJtX21vZGVfb2JqZWN0Lmgg fCAgIDEgKwogNiBmaWxlcyBjaGFuZ2VkLCA0NjUgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMo LSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vZHJtX2xlYXNlLmMKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2RybS9kcm1fbGVhc2UuaAoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQppbmRleCAyNGEw NjZlMTg0MWMuLjNhNDdmNWFlNmYxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2Vm aWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQpAQCAtMTcsNyArMTcsNyBAQCBkcm0t eSAgICAgICA6PQlkcm1fYXV0aC5vIGRybV9idWZzLm8gZHJtX2NhY2hlLm8gXAogCQlkcm1fZW5j b2Rlci5vIGRybV9tb2RlX29iamVjdC5vIGRybV9wcm9wZXJ0eS5vIFwKIAkJZHJtX3BsYW5lLm8g ZHJtX2NvbG9yX21nbXQubyBkcm1fcHJpbnQubyBcCiAJCWRybV9kdW1iX2J1ZmZlcnMubyBkcm1f bW9kZV9jb25maWcubyBkcm1fdmJsYW5rLm8gXAotCQlkcm1fc3luY29iai5vCisJCWRybV9zeW5j b2JqLm8gZHJtX2xlYXNlLm8KIAogZHJtLSQoQ09ORklHX0RSTV9MSUJfUkFORE9NKSArPSBsaWIv ZHJtX3JhbmRvbS5vCiBkcm0tJChDT05GSUdfRFJNX1ZNKSArPSBkcm1fdm0ubwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdXRoLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F1dGgu YwppbmRleCA3ZmY2OTczODlkNzQuLjU0MTE3N2M3MWQ1MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2RybV9hdXRoLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdXRoLmMKQEAgLTMx LDYgKzMxLDcgQEAKICNpbmNsdWRlIDxkcm0vZHJtUC5oPgogI2luY2x1ZGUgImRybV9pbnRlcm5h bC5oIgogI2luY2x1ZGUgImRybV9sZWdhY3kuaCIKKyNpbmNsdWRlIDxkcm0vZHJtX2xlYXNlLmg+ CiAKIC8qKgogICogRE9DOiBtYXN0ZXIgYW5kIGF1dGhlbnRpY2F0aW9uCkBAIC05Myw3ICs5NCw3 IEBAIGludCBkcm1fYXV0aG1hZ2ljKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEs CiAJcmV0dXJuIGZpbGUgPyAwIDogLUVJTlZBTDsKIH0KIAotc3RhdGljIHN0cnVjdCBkcm1fbWFz dGVyICpkcm1fbWFzdGVyX2NyZWF0ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQorc3RydWN0IGRy bV9tYXN0ZXIgKmRybV9tYXN0ZXJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiB7CiAJ c3RydWN0IGRybV9tYXN0ZXIgKm1hc3RlcjsKIApAQCAtMTA3LDYgKzEwOCwxNCBAQCBzdGF0aWMg c3RydWN0IGRybV9tYXN0ZXIgKmRybV9tYXN0ZXJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpCiAJaWRyX2luaXQoJm1hc3Rlci0+bWFnaWNfbWFwKTsKIAltYXN0ZXItPmRldiA9IGRldjsK IAorCS8qIGluaXRpYWxpemUgdGhlIHRyZWUgb2Ygb3V0cHV0IHJlc291cmNlIGxlc3NlZXMgKi8K KwltYXN0ZXItPmxlc3NvciA9IE5VTEw7CisJbWFzdGVyLT5sZXNzZWVfaWQgPSAwOworCUlOSVRf TElTVF9IRUFEKCZtYXN0ZXItPmxlc3NlZXMpOworCUlOSVRfTElTVF9IRUFEKCZtYXN0ZXItPmxl c3NlZV9saXN0KTsKKwlpZHJfaW5pdCgmbWFzdGVyLT5sZWFzZXMpOworCWlkcl9pbml0KCZtYXN0 ZXItPmxlc3NlZV9pZHIpOworCiAJcmV0dXJuIG1hc3RlcjsKIH0KIApAQCAtMTg5LDYgKzE5OCwx MiBAQCBpbnQgZHJtX3NldG1hc3Rlcl9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lk ICpkYXRhLAogCQlnb3RvIG91dF91bmxvY2s7CiAJfQogCisJaWYgKGZpbGVfcHJpdi0+bWFzdGVy LT5sZXNzb3IgIT0gTlVMTCkgeworCQlEUk1fREVCVUdfTEVBU0UoIkF0dGVtcHQgdG8gc2V0IGxl c3NlZSAlZCBhcyBtYXN0ZXJcbiIsIGZpbGVfcHJpdi0+bWFzdGVyLT5sZXNzZWVfaWQpOworCQly ZXQgPSAtRUlOVkFMOworCQlnb3RvIG91dF91bmxvY2s7CisJfQorCiAJcmV0ID0gZHJtX3NldF9t YXN0ZXIoZGV2LCBmaWxlX3ByaXYsIGZhbHNlKTsKIG91dF91bmxvY2s6CiAJbXV0ZXhfdW5sb2Nr KCZkZXYtPm1hc3Rlcl9tdXRleCk7CkBAIC0yNzAsNiArMjg1LDEzIEBAIHZvaWQgZHJtX21hc3Rl cl9yZWxlYXNlKHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KQogCWlmIChkZXYtPm1hc3RlciA9 PSBmaWxlX3ByaXYtPm1hc3RlcikKIAkJZHJtX2Ryb3BfbWFzdGVyKGRldiwgZmlsZV9wcml2KTsK IG91dDoKKwlpZiAoZmlsZV9wcml2LT5pc19tYXN0ZXIpIHsKKwkJLyogUmV2b2tlIGFueSBsZWFz ZXMgaGVsZCBieSB0aGlzIG9yIGxlc3NlZXMsIGJ1dCBvbmx5IGlmCisJCSAqIHRoaXMgaXMgdGhl ICJyZWFsIiBtYXN0ZXIKKwkJICovCisJCV9kcm1fbGVhc2VfcmV2b2tlKG1hc3Rlcik7CisJfQor CiAJLyogZHJvcCB0aGUgbWFzdGVyIHJlZmVyZW5jZSBoZWxkIGJ5IHRoZSBmaWxlIHByaXYgKi8K IAlpZiAoZmlsZV9wcml2LT5tYXN0ZXIpCiAJCWRybV9tYXN0ZXJfcHV0KCZmaWxlX3ByaXYtPm1h c3Rlcik7CkBAIC0zMTAsMTIgKzMzMiwxNyBAQCBzdGF0aWMgdm9pZCBkcm1fbWFzdGVyX2Rlc3Ry b3koc3RydWN0IGtyZWYgKmtyZWYpCiAJc3RydWN0IGRybV9tYXN0ZXIgKm1hc3RlciA9IGNvbnRh aW5lcl9vZihrcmVmLCBzdHJ1Y3QgZHJtX21hc3RlciwgcmVmY291bnQpOwogCXN0cnVjdCBkcm1f ZGV2aWNlICpkZXYgPSBtYXN0ZXItPmRldjsKIAorCWRybV9sZWFzZV9kZXN0cm95KG1hc3Rlcik7 CisKIAlpZiAoZGV2LT5kcml2ZXItPm1hc3Rlcl9kZXN0cm95KQogCQlkZXYtPmRyaXZlci0+bWFz dGVyX2Rlc3Ryb3koZGV2LCBtYXN0ZXIpOwogCiAJZHJtX2xlZ2FjeV9tYXN0ZXJfcm1tYXBzKGRl diwgbWFzdGVyKTsKIAogCWlkcl9kZXN0cm95KCZtYXN0ZXItPm1hZ2ljX21hcCk7CisJaWRyX2Rl c3Ryb3koJm1hc3Rlci0+bGVhc2VzKTsKKwlpZHJfZGVzdHJveSgmbWFzdGVyLT5sZXNzZWVfaWRy KTsKKwogCWtmcmVlKG1hc3Rlci0+dW5pcXVlKTsKIAlrZnJlZShtYXN0ZXIpOwogfQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9sZWFzZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9s ZWFzZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMmFjNDA0MjY0 ZDc1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9sZWFzZS5jCkBAIC0w LDAgKzEsMzc5IEBACisvKgorICogQ29weXJpZ2h0IMKpIDIwMTcgS2VpdGggUGFja2FyZCA8a2Vp dGhwQGtlaXRocC5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBU aGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorI2luY2x1ZGUg ImRybV9pbnRlcm5hbC5oIgorI2luY2x1ZGUgImRybV9sZWdhY3kuaCIKKyNpbmNsdWRlICJkcm1f Y3J0Y19pbnRlcm5hbC5oIgorI2luY2x1ZGUgPGRybS9kcm1fbGVhc2UuaD4KKyNpbmNsdWRlIDxk cm0vZHJtX2F1dGguaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisKKyNkZWZp bmUgZHJtX2Zvcl9lYWNoX2xlc3NlZShsZXNzZWUsIGxlc3NvcikgXAorCWxpc3RfZm9yX2VhY2hf ZW50cnkoKGxlc3NlZSksICYobGVzc29yKS0+bGVzc2VlcywgbGVzc2VlX2xpc3QpCisKKy8qKgor ICogZHJtX2xlYXNlX293bmVyIC0gcmV0dXJuIGFuY2VzdG9yIG93bmVyIGRybV9tYXN0ZXIKKyAq IEBtYXN0ZXI6IGRybV9tYXN0ZXIgc29tZXdoZXJlIHdpdGhpbiB0cmVlIG9mIGxlc3NlZXMgYW5k IGxlc3NvcnMKKyAqCisgKiBSRVRVUk46CisgKgorICogZHJtX21hc3RlciBhdCB0aGUgdG9wIG9m IHRoZSB0cmVlIChpLmUsIHdpdGggbGVzc29yIE5VTEwKKyAqLworc3RydWN0IGRybV9tYXN0ZXIg KmRybV9sZWFzZV9vd25lcihzdHJ1Y3QgZHJtX21hc3RlciAqbWFzdGVyKQoreworCXdoaWxlICht YXN0ZXItPmxlc3NvciAhPSBOVUxMKQorCQltYXN0ZXIgPSBtYXN0ZXItPmxlc3NvcjsKKwlyZXR1 cm4gbWFzdGVyOworfQorRVhQT1JUX1NZTUJPTChkcm1fbGVhc2Vfb3duZXIpOworCisvKioKKyAq IF9kcm1fZmluZF9sZXNzZWUgLSBmaW5kIGxlc3NlZSBieSBpZAorICogQG1hc3RlcjogZHJtX21h c3RlciBvZiBsZXNzb3IKKyAqIEBpZDogbGVzc2VlX2lkCisgKgorICogUkVUVVJOOgorICoKKyAq IGRybV9tYXN0ZXIgb2YgdGhlIGxlc3NlZSBpZiB2YWxpZCwgTlVMTCBvdGhlcndpc2UKKyAqLwor CitzdGF0aWMgc3RydWN0IGRybV9tYXN0ZXIqCitfZHJtX2ZpbmRfbGVzc2VlKHN0cnVjdCBkcm1f bWFzdGVyICptYXN0ZXIsIGludCBsZXNzZWVfaWQpCit7CisJcmV0dXJuIGlkcl9maW5kKCZkcm1f bGVhc2Vfb3duZXIobWFzdGVyKS0+bGVzc2VlX2lkciwgbGVzc2VlX2lkKTsKK30KKworLyoqCisg KiBfZHJtX2xlYXNlX2hlbGRfbWFzdGVyIC0gY2hlY2sgdG8gc2VlIGlmIGFuIG9iamVjdCBpcyBs ZWFzZWQgKG9yIG93bmVkKSBieSBtYXN0ZXIKKyAqIEBtYXN0ZXI6IHRoZSBtYXN0ZXIgdG8gY2hl Y2sgdGhlIGxlYXNlIHN0YXR1cyBvZgorICogQGlkOiB0aGUgaWQgdG8gY2hlY2sKKyAqCisgKiBD aGVja3MgaWYgdGhlIHNwZWNpZmllZCBtYXN0ZXIgaG9sZHMgYSBsZWFzZSBvbiB0aGUgb2JqZWN0 LiBSZXR1cm4KKyAqIHZhbHVlOgorICoKKyAqCXRydWUJCSdtYXN0ZXInIGhvbGRzIGEgbGVhc2Ug b24gKG9yIG93bnMpIHRoZSBvYmplY3QKKyAqCWZhbHNlCQknbWFzdGVyJyBkb2VzIG5vdCBob2xk IGEgbGVhc2UuCisgKi8KK3N0YXRpYyBpbnQgX2RybV9sZWFzZV9oZWxkX21hc3RlcihzdHJ1Y3Qg ZHJtX21hc3RlciAqbWFzdGVyLCBpbnQgaWQpCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbWFz dGVyLT5kZXYtPm1vZGVfY29uZmlnLmlkcl9tdXRleCk7CisJaWYgKG1hc3Rlci0+bGVzc29yKQor CQlyZXR1cm4gaWRyX2ZpbmQoJm1hc3Rlci0+bGVhc2VzLCBpZCkgIT0gTlVMTDsKKwlyZXR1cm4g dHJ1ZTsKK30KKworLyoqCisgKiBfZHJtX2hhc19sZWFzZWQgLSBjaGVjayB0byBzZWUgaWYgYW4g b2JqZWN0IGhhcyBiZWVuIGxlYXNlZAorICogQG1hc3RlcjogdGhlIG1hc3RlciB0byBjaGVjayB0 aGUgbGVhc2Ugc3RhdHVzIG9mCisgKiBAaWQ6IHRoZSBpZCB0byBjaGVjaworICoKKyAqIENoZWNr cyBpZiBhbnkgbGVzc2VlIG9mICdtYXN0ZXInIGhvbGRzIGEgbGVhc2Ugb24gJ2lkJy4gUmV0dXJu CisgKiB2YWx1ZToKKyAqCisgKgl0cnVlCQlTb21lIGxlc3NlZSBob2xkcyBhIGxlYXNlIG9uIHRo ZSBvYmplY3QuCisgKglmYWxzZQkJTm8gbGVzc2VlIGhhcyBhIGxlYXNlIG9uIHRoZSBvYmplY3Qu CisgKi8KK3N0YXRpYyBib29sIF9kcm1faGFzX2xlYXNlZChzdHJ1Y3QgZHJtX21hc3RlciAqbWFz dGVyLCBpbnQgaWQpCit7CisJc3RydWN0IGRybV9tYXN0ZXIgKmxlc3NlZTsKKworCWRybV9mb3Jf ZWFjaF9sZXNzZWUobGVzc2VlLCBtYXN0ZXIpCisJCWlmIChfZHJtX2xlYXNlX2hlbGRfbWFzdGVy KGxlc3NlZSwgaWQpKQorCQkJcmV0dXJuIHRydWU7CisJcmV0dXJuIGZhbHNlOworfQorCisvKioK KyAqIF9kcm1fbGVhc2VfaGVsZCAtIGNoZWNrIGRybV9tb2RlX29iamVjdCBsZWFzZSBzdGF0dXMg KGlkcl9tdXRleCBoZWxkKQorICogQG1hc3RlcjogdGhlIGRybV9tYXN0ZXIKKyAqIEBpZDogdGhl IG9iamVjdCBpZAorICoKKyAqIENoZWNrcyBpZiB0aGUgc3BlY2lmaWVkIG1hc3RlciBob2xkcyBh IGxlYXNlIG9uIHRoZSBvYmplY3QuIFJldHVybgorICogdmFsdWU6CisgKgorICoJdHJ1ZQkJJ21h c3RlcicgaG9sZHMgYSBsZWFzZSBvbiAob3Igb3ducykgdGhlIG9iamVjdAorICoJZmFsc2UJCSdt YXN0ZXInIGRvZXMgbm90IGhvbGQgYSBsZWFzZS4KKyAqLworYm9vbCBfZHJtX2xlYXNlX2hlbGQo c3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYsIGludCBpZCkKK3sKKwlpZiAoZmlsZV9wcml2ID09 IE5VTEwgfHwgZmlsZV9wcml2LT5tYXN0ZXIgPT0gTlVMTCkKKwkJcmV0dXJuIHRydWU7CisKKwly ZXR1cm4gX2RybV9sZWFzZV9oZWxkX21hc3RlcihmaWxlX3ByaXYtPm1hc3RlciwgaWQpOworfQor RVhQT1JUX1NZTUJPTChfZHJtX2xlYXNlX2hlbGQpOworCisvKioKKyAqIGRybV9sZWFzZV9oZWxk IC0gY2hlY2sgZHJtX21vZGVfb2JqZWN0IGxlYXNlIHN0YXR1cyAoaWRyX211dGV4IG5vdCBoZWxk KQorICogQG1hc3RlcjogdGhlIGRybV9tYXN0ZXIKKyAqIEBpZDogdGhlIG9iamVjdCBpZAorICoK KyAqIENoZWNrcyBpZiB0aGUgc3BlY2lmaWVkIG1hc3RlciBob2xkcyBhIGxlYXNlIG9uIHRoZSBv YmplY3QuIFJldHVybgorICogdmFsdWU6CisgKgorICoJdHJ1ZQkJJ21hc3RlcicgaG9sZHMgYSBs ZWFzZSBvbiAob3Igb3ducykgdGhlIG9iamVjdAorICoJZmFsc2UJCSdtYXN0ZXInIGRvZXMgbm90 IGhvbGQgYSBsZWFzZS4KKyAqLworYm9vbCBkcm1fbGVhc2VfaGVsZChzdHJ1Y3QgZHJtX2ZpbGUg KmZpbGVfcHJpdiwgaW50IGlkKQoreworCXN0cnVjdCBkcm1fbWFzdGVyICptYXN0ZXI7CisJYm9v bCByZXQ7CisKKwlpZiAoZmlsZV9wcml2ID09IE5VTEwgfHwgZmlsZV9wcml2LT5tYXN0ZXIgPT0g TlVMTCkKKwkJcmV0dXJuIHRydWU7CisKKwltYXN0ZXIgPSBmaWxlX3ByaXYtPm1hc3RlcjsKKwlt dXRleF9sb2NrKCZtYXN0ZXItPmRldi0+bW9kZV9jb25maWcuaWRyX211dGV4KTsKKwlyZXQgPSBf ZHJtX2xlYXNlX2hlbGRfbWFzdGVyKG1hc3RlciwgaWQpOworCW11dGV4X3VubG9jaygmbWFzdGVy LT5kZXYtPm1vZGVfY29uZmlnLmlkcl9tdXRleCk7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9T WU1CT0woZHJtX2xlYXNlX2hlbGQpOworCisvKioKKyAqIGRybV9sZWFzZV9maWx0ZXJfY3J0Y3Mg LSByZXN0cmljdGVkIGNydGMgc2V0IHRvIGxlYXNlZCB2YWx1ZXMKKyAqIEBmaWxlX3ByaXY6IHJl cXVlc3RvciBmaWxlCisgKiBAY3J0Y3M6IGJpdG1hc2sgb2YgY3J0Y3MgdG8gY2hlY2sKKyAqCisg KiBSZWNvbnN0cnVjdHMgYSBjcnRjIG1hc2sgYmFzZWQgb24gdGhlIGNydGNzIHdoaWNoIGFyZSB2 aXNpYmxlCisgKiB0aHJvdWdoIHRoZSBzcGVjaWZpZWQgZmlsZS4KKyAqLwordWludDMyX3QgZHJt X2xlYXNlX2ZpbHRlcl9jcnRjcyhzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdiwgdWludDMyX3Qg Y3J0Y3NfaW4pCit7CisJc3RydWN0IGRybV9tYXN0ZXIgKm1hc3RlcjsKKwlzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlpbnQgY291bnRfaW4sIGNvdW50 X291dDsKKwl1aW50MzJfdCBjcnRjc19vdXQgPSAwOworCisJaWYgKGZpbGVfcHJpdiA9PSBOVUxM IHx8IGZpbGVfcHJpdi0+bWFzdGVyID09IE5VTEwpCisJCXJldHVybiBjcnRjc19pbjsKKworCW1h c3RlciA9IGZpbGVfcHJpdi0+bWFzdGVyOworCWRldiA9IG1hc3Rlci0+ZGV2OworCisJY291bnRf aW4gPSBjb3VudF9vdXQgPSAwOworCW11dGV4X2xvY2soJm1hc3Rlci0+ZGV2LT5tb2RlX2NvbmZp Zy5pZHJfbXV0ZXgpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoY3J0YywgJmRldi0+bW9kZV9jb25m aWcuY3J0Y19saXN0LCBoZWFkKSB7CisJCWlmIChfZHJtX2xlYXNlX2hlbGRfbWFzdGVyKG1hc3Rl ciwgY3J0Yy0+YmFzZS5pZCkpIHsKKwkJCXVpbnQzMl90IG1hc2tfaW4gPSAxdWwgPDwgY291bnRf aW47CisJCQlpZiAoKGNydGNzX2luICYgbWFza19pbikgIT0gMCkgeworCQkJCXVpbnQzMl90IG1h c2tfb3V0ID0gMXVsIDw8IGNvdW50X291dDsKKwkJCQljcnRjc19vdXQgfD0gbWFza19vdXQ7CisJ CQl9CisJCQljb3VudF9vdXQrKzsKKwkJfQorCQljb3VudF9pbisrOworCX0KKwltdXRleF91bmxv Y2soJm1hc3Rlci0+ZGV2LT5tb2RlX2NvbmZpZy5pZHJfbXV0ZXgpOworCXJldHVybiBjcnRjc19v dXQ7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9sZWFzZV9maWx0ZXJfY3J0Y3MpOworCisvKioKKyAq IGRybV9sZWFzZV9maWx0ZXJfZW5jb2RlcnMgLSByZXN0cmljdCBlbmNvZGVyIHNldCB0byBsZWFz ZWQgdmFsdWVzCisgKiBAZmlsZV9wcml2OiByZXF1ZXN0b3IgZmlsZQorICogQGVuY29kZXJzOiBi aXRtYXNrIG9mIGVuY29kZXJzIHRvIGNoZWNrCisgKgorICogUmVjb25zdHJ1Y3RzIGFuIGVuY29k ZXIgbWFzayBiYXNlZCBvbiB0aGUgZW5jb2RlcnMgd2hpY2ggYXJlCisgKiB2aXNpYmxlIHRocm91 Z2ggdGhlIHNwZWNpZmllZCBmaWxlLgorICovCit1aW50MzJfdCBkcm1fbGVhc2VfZmlsdGVyX2Vu Y29kZXJzKHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2LCB1aW50MzJfdCBlbmNvZGVyc19pbikK K3sKKwlzdHJ1Y3QgZHJtX21hc3RlciAqbWFzdGVyOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXY7 CisJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOworCWludCBjb3VudF9pbiwgY291bnRfb3V0 OworCXVpbnQzMl90IGVuY29kZXJzX291dCA9IDA7CisKKwljb3VudF9pbiA9IGNvdW50X291dCA9 IDA7CisJaWYgKGZpbGVfcHJpdiA9PSBOVUxMIHx8IGZpbGVfcHJpdi0+bWFzdGVyID09IE5VTEwp CisJCXJldHVybiBlbmNvZGVyc19pbjsKKworCW1hc3RlciA9IGZpbGVfcHJpdi0+bWFzdGVyOwor CWRldiA9IG1hc3Rlci0+ZGV2OworCisJbXV0ZXhfbG9jaygmbWFzdGVyLT5kZXYtPm1vZGVfY29u ZmlnLmlkcl9tdXRleCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShlbmNvZGVyLCAmZGV2LT5tb2Rl X2NvbmZpZy5lbmNvZGVyX2xpc3QsIGhlYWQpIHsKKwkJaWYgKF9kcm1fbGVhc2VfaGVsZF9tYXN0 ZXIobWFzdGVyLCBlbmNvZGVyLT5iYXNlLmlkKSkgeworCQkJdWludDMyX3QgbWFza19pbiA9IDF1 bCA8PCBjb3VudF9pbjsKKwkJCWlmICgoZW5jb2RlcnNfaW4gJiBtYXNrX2luKSAhPSAwKSB7CisJ CQkJdWludDMyX3QgbWFza19vdXQgPSAxdWwgPDwgY291bnRfb3V0OworCQkJCWVuY29kZXJzX291 dCB8PSBtYXNrX291dDsKKwkJCX0KKwkJCWNvdW50X291dCsrOworCQl9CisJCWNvdW50X2luKys7 CisJfQorCW11dGV4X3VubG9jaygmbWFzdGVyLT5kZXYtPm1vZGVfY29uZmlnLmlkcl9tdXRleCk7 CisJcmV0dXJuIGVuY29kZXJzX291dDsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2xlYXNlX2ZpbHRl cl9lbmNvZGVycyk7CisKKy8qCisgKiBkcm1fbGVhc2VfY3JlYXRlIC0gY3JlYXRlIGEgbmV3IGRy bV9tYXN0ZXIgd2l0aCBsZWFzZWQgb2JqZWN0cworICogQGxlc3NvcjogbGVhc2UgaG9sZGVyIChv ciBvd25lcikgb2Ygb2JqZWN0cworICogQGxlYXNlczogb2JqZWN0cyB0byBsZWFzZSB0byB0aGUg bmV3IGRybV9tYXN0ZXIKKyAqCisgKiBVc2VzIGRybV9tYXN0ZXJfY3JlYXRlIHRvIGFsbG9jYXRl IGEgbmV3IGRybV9tYXN0ZXIsIHRoZW4gY2hlY2tzIHRvCisgKiBtYWtlIHN1cmUgYWxsIG9mIHRo ZSBkZXNpcmVkIG9iamVjdHMgY2FuIGJlIGxlYXNlZCwgYXRvbWljYWxseQorICogbGVhc2luZyB0 aGVtIHRvIHRoZSBuZXcgZHJtbWFzdGVyLgorICoKKyAqIAlFUlJfUFRSKC1FQUNDRVNTKQlzb21l IG90aGVyIG1hc3RlciBob2xkcyB0aGUgdGl0bGUgdG8gYW55IG9iamVjdAorICogCUVSUl9QVFIo LUVOT0VOVCkJc29tZSBvYmplY3QgaXMgbm90IGEgdmFsaWQgRFJNIG9iamVjdCBmb3IgdGhpcyBk ZXZpY2UKKyAqIAlFUlJfUFRSKC1FQlVTWSkJCXNvbWUgb3RoZXIgbGVzc2VlIGhvbGRzIHRpdGxl IHRvIHRoaXMgb2JqZWN0CisgKglFUlJfUFRSKC1FRVhJU1QpCXNhbWUgb2JqZWN0IHNwZWNpZmll ZCBtb3JlIHRoYW4gb25jZSBpbiB0aGUgcHJvdmlkZWQgbGlzdAorICoJRVJSX1BUUigtRU5PTUVN KQlhbGxvY2F0aW9uIGZhaWxlZAorICovCitzdGF0aWMgc3RydWN0IGRybV9tYXN0ZXIgKmRybV9s ZWFzZV9jcmVhdGUoc3RydWN0IGRybV9tYXN0ZXIgKmxlc3Nvciwgc3RydWN0IGlkciAqbGVhc2Vz KQoreworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBsZXNzb3ItPmRldjsKKwlpbnQgZXJyb3I7 CisJc3RydWN0IGRybV9tYXN0ZXIgKmxlc3NlZTsKKwlpbnQgb2JqZWN0OworCWludCBpZDsKKwl2 b2lkICplbnRyeTsKKworCURSTV9ERUJVR19MRUFTRSgibGVzc29yICVkXG4iLCBsZXNzb3ItPmxl c3NlZV9pZCk7CisKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZsZXNzb3ItPmRldi0+bWFzdGVyX211 dGV4KTsKKworCWxlc3NlZSA9IGRybV9tYXN0ZXJfY3JlYXRlKGxlc3Nvci0+ZGV2KTsKKwlpZiAo IWxlc3NlZSkgeworCQlEUk1fREVCVUdfTEVBU0UoImRybV9tYXN0ZXJfY3JlYXRlIGZhaWxlZFxu Iik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKworCS8qIEluc2VydCB0aGUgbmV3 IGxlc3NlZSBpbnRvIHRoZSB0cmVlICovCisJaWQgPSBpZHJfYWxsb2MoJihkcm1fbGVhc2Vfb3du ZXIobGVzc29yKS0+bGVzc2VlX2lkciksIGxlc3NlZSwgMSwgMCwgR0ZQX0tFUk5FTCk7CisJaWYg KGlkIDwgMCkgeworCQllcnJvciA9IGlkOworCQlnb3RvIG91dF9sZXNzZWU7CisJfQorCisJbGVz c2VlLT5sZXNzZWVfaWQgPSBpZDsKKwlsZXNzZWUtPmxlc3NvciA9IGRybV9tYXN0ZXJfZ2V0KGxl c3Nvcik7CisJbGlzdF9hZGRfdGFpbCgmbGVzc2VlLT5sZXNzZWVfbGlzdCwgJmxlc3Nvci0+bGVz c2Vlcyk7CisKKwkvKiBMb2NrIHRoZSBtb2RlIG9iamVjdCBtdXRleCB0byBtYWtlIHRoZSBjaGVj ayBhbmQgYWxsb2NhdGlvbiBhdG9taWMgKi8KKwltdXRleF9sb2NrKCZsZXNzb3ItPmRldi0+bW9k ZV9jb25maWcuaWRyX211dGV4KTsKKwlpZHJfZm9yX2VhY2hfZW50cnkobGVhc2VzLCBlbnRyeSwg b2JqZWN0KSB7CisJCWVycm9yID0gMDsKKwkJaWYgKCFpZHJfZmluZCgmZGV2LT5tb2RlX2NvbmZp Zy5jcnRjX2lkciwgb2JqZWN0KSkKKwkJCWVycm9yID0gLUVOT0VOVDsKKwkJZWxzZSBpZiAoIV9k cm1fbGVhc2VfaGVsZF9tYXN0ZXIobGVzc29yLCBvYmplY3QpKQorCQkJZXJyb3IgPSAtRUFDQ0VT OworCQllbHNlIGlmIChfZHJtX2hhc19sZWFzZWQobGVzc29yLCBvYmplY3QpKQorCQkJZXJyb3Ig PSAtRUJVU1k7CisKKwkJaWYgKGVycm9yICE9IDApIHsKKwkJCURSTV9ERUJVR19MRUFTRSgib2Jq ZWN0ICVkIGZhaWxlZCAlZFxuIiwgb2JqZWN0LCBlcnJvcik7CisJCQlnb3RvIG91dF91bmxvY2s7 CisJCX0KKwl9CisKKwkvKiBNb3ZlIHRoZSBsZWFzZXMgb3ZlciAqLworCWxlc3NlZS0+bGVhc2Vz ID0gKmxlYXNlczsKKwltdXRleF91bmxvY2soJmxlc3Nvci0+ZGV2LT5tb2RlX2NvbmZpZy5pZHJf bXV0ZXgpOworCURSTV9ERUJVR19MRUFTRSgibmV3IGxlc3NlZSAlZCAlcCwgbGVzc29yICVkICVw XG4iLCBsZXNzZWUtPmxlc3NlZV9pZCwgbGVzc2VlLCBsZXNzb3ItPmxlc3NlZV9pZCwgbGVzc29y KTsKKwlyZXR1cm4gbGVzc2VlOworCitvdXRfdW5sb2NrOgorCW11dGV4X3VubG9jaygmbGVzc29y LT5kZXYtPm1vZGVfY29uZmlnLmlkcl9tdXRleCk7CisKK291dF9sZXNzZWU6CisJZHJtX21hc3Rl cl9wdXQoJmxlc3NlZSk7CisJcmV0dXJuIEVSUl9QVFIoZXJyb3IpOworfQorCisvKioKKyAqIGRy bV9sZWFzZV9kZXN0cm95IC0gYSBtYXN0ZXIgaXMgZ29pbmcgYXdheQorICogQG1hc3RlcjogdGhl IGRybV9tYXN0ZXIgYmVpbmcgZGVzdHJveWVkCisgKgorICogQWxsIGxlc3NlZXMgd2lsbCBoYXZl IGJlZW4gZGVzdHJveWVkIGFzIHRoZXkKKyAqIGhvbGQgYSByZWZlcmVuY2Ugb24gdGhlaXIgbGVz c29yLiBOb3RpZnkgYW55CisgKiBsZXNzb3IgZm9yIHRoaXMgbWFzdGVyIHNvIHRoYXQgaXQgY2Fu IGNoZWNrCisgKiB0aGUgbGlzdCBvZiBsZXNzZWVzLgorICovCit2b2lkIGRybV9sZWFzZV9kZXN0 cm95KHN0cnVjdCBkcm1fbWFzdGVyICptYXN0ZXIpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRl diA9IG1hc3Rlci0+ZGV2OworCisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmZGV2LT5tYXN0ZXJfbXV0 ZXgpOworCisJRFJNX0RFQlVHX0xFQVNFKCJkcm1fbGVhc2VfZGVzdHJveSAlZFxuIiwgbWFzdGVy LT5sZXNzZWVfaWQpOworCisJLyogVGhpcyBtYXN0ZXIgaXMgcmVmZXJlbmNlZCBieSBhbGwgbGVz c2VlcywgaGVuY2UgaXQgY2Fubm90IGJlIGRlc3Ryb3llZAorCSAqIHVudGlsIGFsbCBvZiB0aGVt IGhhdmUgYmVlbgorCSAqLworCVdBUk5fT04oIWxpc3RfZW1wdHkoJm1hc3Rlci0+bGVzc2Vlcykp OworCisJLyogUmVtb3ZlIHRoaXMgbWFzdGVyIGZyb20gdGhlIGxlc3NlZSBpZHIgaW4gdGhlIG93 bmVyICovCisJaWYgKG1hc3Rlci0+bGVzc2VlX2lkICE9IDApIHsKKwkJRFJNX0RFQlVHX0xFQVNF KCJyZW1vdmUgbWFzdGVyICVkIGZyb20gZGV2aWNlIGxpc3Qgb2YgbGVzc2Vlc1xuIiwgbWFzdGVy LT5sZXNzZWVfaWQpOworCQlpZHJfcmVtb3ZlKCYoZHJtX2xlYXNlX293bmVyKG1hc3RlciktPmxl c3NlZV9pZHIpLCBtYXN0ZXItPmxlc3NlZV9pZCk7CisJfQorCisJLyogUmVtb3ZlIHRoaXMgbWFz dGVyIGZyb20gYW55IGxlc3NlZSBsaXN0IGl0IG1heSBiZSBvbiAqLworCWxpc3RfZGVsKCZtYXN0 ZXItPmxlc3NlZV9saXN0KTsKKwlpZiAobWFzdGVyLT5sZXNzb3IpIHsKKwkJLyogVGVsbCB0aGUg bWFzdGVyIHRvIGNoZWNrIHRoZSBsZXNzZWUgbGlzdCAqLworCQlkcm1fc3lzZnNfaG90cGx1Z19l dmVudChkZXYpOworCQlkcm1fbWFzdGVyX3B1dCgmbWFzdGVyLT5sZXNzb3IpOworCX0KKworCURS TV9ERUJVR19MRUFTRSgiZHJtX2xlYXNlX2Rlc3Ryb3kgZG9uZSAlZFxuIiwgbWFzdGVyLT5sZXNz ZWVfaWQpOworfQorCisvKioKKyAqIF9kcm1fbGVhc2VfcmV2b2tlIC0gcmV2b2tlIGFjY2VzcyB0 byBhbGwgbGVhc2VkIG9iamVjdHMKKyAqIEBtYXN0ZXI6IHRoZSBtYXN0ZXIgbG9zaW5nIGl0cyBs ZWFzZQorICovCisKK3ZvaWQgX2RybV9sZWFzZV9yZXZva2Uoc3RydWN0IGRybV9tYXN0ZXIgKnRv cCkKK3sKKwlpbnQgb2JqZWN0OworCXZvaWQgKmVudHJ5OworCXN0cnVjdCBkcm1fbWFzdGVyICpt YXN0ZXIgPSB0b3A7CisKKwkvKgorCSAqIFdhbGsgdGhlIHRyZWUgc3RhcnRpbmcgYXQgJ3RvcCcg ZW1wdHlpbmcgYWxsIGxlYXNlcy4gQmVjYXVzZQorCSAqIHRoZSB0cmVlIGlzIGZ1bGx5IGNvbm5l Y3RlZCwgd2UgY2FuIGRvIHRoaXMgd2l0aG91dCByZWN1cnNpbmcKKwkgKi8KKwlmb3IgKDs7KSB7 CisJCURSTV9ERUJVR19MRUFTRSgicmV2b2tlIGxlYXNlcyBmb3IgJXAgJWRcbiIsIG1hc3Rlciwg bWFzdGVyLT5sZXNzZWVfaWQpOworCisJCS8qIEV2YWN1YXRlIHRoZSBsZWFzZSAqLworCQlpZHJf Zm9yX2VhY2hfZW50cnkoJm1hc3Rlci0+bGVhc2VzLCBlbnRyeSwgb2JqZWN0KQorCQkJaWRyX3Jl bW92ZSgmbWFzdGVyLT5sZWFzZXMsIG9iamVjdCk7CisKKwkJLyogRGVwdGgtZmlyc3QgbGlzdCB3 YWxrICovCisKKwkJLyogRG93biAqLworCQlpZiAoIWxpc3RfZW1wdHkoJm1hc3Rlci0+bGVzc2Vl cykpIHsKKwkJCW1hc3RlciA9IGxpc3RfZmlyc3RfZW50cnkoJm1hc3Rlci0+bGVzc2Vlcywgc3Ry dWN0IGRybV9tYXN0ZXIsIGxlc3NlZV9saXN0KTsKKwkJfSBlbHNlIHsKKwkJCS8qIFVwICovCisJ CQl3aGlsZSAobWFzdGVyICE9IHRvcCAmJiBtYXN0ZXIgPT0gbGlzdF9sYXN0X2VudHJ5KCZtYXN0 ZXItPmxlc3Nvci0+bGVzc2Vlcywgc3RydWN0IGRybV9tYXN0ZXIsIGxlc3NlZV9saXN0KSkKKwkJ CQltYXN0ZXIgPSBtYXN0ZXItPmxlc3NvcjsKKworCQkJaWYgKG1hc3RlciA9PSB0b3ApCisJCQkJ YnJlYWs7CisKKwkJCS8qIE92ZXIgKi8KKwkJCW1hc3RlciA9IGxpc3RfZW50cnkobWFzdGVyLT5s ZXNzZWVfbGlzdC5uZXh0LCBzdHJ1Y3QgZHJtX21hc3RlciwgbGVzc2VlX2xpc3QpOworCQl9CisJ fQorfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2F1dGguaCBiL2luY2x1ZGUvZHJtL2Ry bV9hdXRoLmgKaW5kZXggODFhNDBjMmE5YTNlLi40YjdmYzIyZDNmYzkgMTAwNjQ0Ci0tLSBhL2lu Y2x1ZGUvZHJtL2RybV9hdXRoLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2F1dGguaApAQCAtNTIs NiArNTIsMTIgQEAgc3RydWN0IGRybV9sb2NrX2RhdGEgewogICogQGRldjogTGluayBiYWNrIHRv IHRoZSBEUk0gZGV2aWNlCiAgKiBAbG9jazogRFJJMSBsb2NrIGluZm9ybWF0aW9uLgogICogQGRy aXZlcl9wcml2OiBQb2ludGVyIHRvIGRyaXZlci1wcml2YXRlIGluZm9ybWF0aW9uLgorICogQGxl c3NvcjogTGVhc2UgaG9sZGVyCisgKiBAbGVzc2VlX2lkOiBpZCBmb3IgbGVzc2Vlcy4gT3duZXJz IGFsd2F5cyBoYXZlIGlkIDAKKyAqIEBsZXNzZWVfbGlzdDogb3RoZXIgbGVzc2VlcyBvZiB0aGUg c2FtZSBtYXN0ZXIKKyAqIEBsZXNzZWVzOiBkcm1fbWFzdGVycyBsZWFzaW5nIGZyb20gdGhpcyBv bmUKKyAqIEBsZWFzZXM6IE9iamVjdHMgbGVhc2VkIHRvIHRoaXMgZHJtX21hc3Rlci4KKyAqIEBs ZXNzZWVfaWRyOiBBbGwgbGVzc2VlcyB1bmRlciB0aGlzIG93bmVyIChvbmx5IHVzZWQgd2hlcmUg bGVzc29yID09IE5VTEwpCiAgKgogICogTm90ZSB0aGF0IG1hc3RlciBzdHJ1Y3R1cmVzIGFyZSBv bmx5IHJlbGV2YW50IGZvciB0aGUgbGVnYWN5L3ByaW1hcnkgZGV2aWNlCiAgKiBub2RlcywgaGVu Y2UgdGhlcmUgY2FuIG9ubHkgYmUgb25lIHBlciBkZXZpY2UsIG5vdCBvbmUgcGVyIGRybV9taW5v ci4KQEAgLTc2LDEwICs4MiwyNCBAQCBzdHJ1Y3QgZHJtX21hc3RlciB7CiAJc3RydWN0IGlkciBt YWdpY19tYXA7CiAJc3RydWN0IGRybV9sb2NrX2RhdGEgbG9jazsKIAl2b2lkICpkcml2ZXJfcHJp djsKKworCS8qIFRyZWUgb2YgZGlzcGxheSByZXNvdXJjZSBsZWFzZXMsIGVhY2ggb2Ygd2hpY2gg aXMgYSBkcm1fbWFzdGVyIHN0cnVjdAorCSAqIEFsbCBvZiB0aGVzZSBnZXQgYWN0aXZhdGVkIHNp bXVsdGFuZW91c2x5LCBzbyBkcm1fZGV2aWNlIG1hc3RlciBwb2ludHMKKwkgKiBhdCB0aGUgdG9w IG9mIHRoZSB0cmVlIChmb3Igd2hpY2ggbGVzc29yIGlzIE5VTEwpCisJICovCisKKwlzdHJ1Y3Qg ZHJtX21hc3RlciAqbGVzc29yOworCWludAlsZXNzZWVfaWQ7CisJc3RydWN0IGxpc3RfaGVhZCBs ZXNzZWVfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxlc3NlZXM7CisJc3RydWN0IGlkciBsZWFz ZXM7CisJc3RydWN0IGlkciBsZXNzZWVfaWRyOwogfTsKIAogc3RydWN0IGRybV9tYXN0ZXIgKmRy bV9tYXN0ZXJfZ2V0KHN0cnVjdCBkcm1fbWFzdGVyICptYXN0ZXIpOwogdm9pZCBkcm1fbWFzdGVy X3B1dChzdHJ1Y3QgZHJtX21hc3RlciAqKm1hc3Rlcik7CiBib29sIGRybV9pc19jdXJyZW50X21h c3RlcihzdHJ1Y3QgZHJtX2ZpbGUgKmZwcml2KTsKIAorc3RydWN0IGRybV9tYXN0ZXIgKmRybV9t YXN0ZXJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOworCiAjZW5kaWYKZGlmZiAtLWdp dCBhL2luY2x1ZGUvZHJtL2RybV9sZWFzZS5oIGIvaW5jbHVkZS9kcm0vZHJtX2xlYXNlLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5hNDk2NjdkYjFkNmQKLS0tIC9k ZXYvbnVsbAorKysgYi9pbmNsdWRlL2RybS9kcm1fbGVhc2UuaApAQCAtMCwwICsxLDM2IEBACisv KgorICogQ29weXJpZ2h0IMKpIDIwMTcgS2VpdGggUGFja2FyZCA8a2VpdGhwQGtlaXRocC5jb20+ CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICovCisKKyNpZm5kZWYgX0RSTV9MRUFTRV9IXworI2RlZmluZSBfRFJNX0xFQVNFX0hfCisK K3N0cnVjdCBkcm1fZmlsZTsKK3N0cnVjdCBkcm1fZGV2aWNlOworc3RydWN0IGRybV9tYXN0ZXI7 CisKK3N0cnVjdCBkcm1fbWFzdGVyICpkcm1fbGVhc2Vfb3duZXIoc3RydWN0IGRybV9tYXN0ZXIg Km1hc3Rlcik7CisKK3ZvaWQgZHJtX2xlYXNlX2Rlc3Ryb3koc3RydWN0IGRybV9tYXN0ZXIgKmxl c3NlZSk7CisKK2Jvb2wgZHJtX2xlYXNlX2hlbGQoc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYs IGludCBpZCk7CisKK2Jvb2wgX2RybV9sZWFzZV9oZWxkKHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9w cml2LCBpbnQgaWQpOworCit2b2lkIF9kcm1fbGVhc2VfcmV2b2tlKHN0cnVjdCBkcm1fbWFzdGVy ICptYXN0ZXIpOworCit1aW50MzJfdCBkcm1fbGVhc2VfZmlsdGVyX2NydGNzKHN0cnVjdCBkcm1f ZmlsZSAqZmlsZV9wcml2LCB1aW50MzJfdCBjcnRjcyk7CisKK3VpbnQzMl90IGRybV9sZWFzZV9m aWx0ZXJfZW5jb2RlcnMoc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYsIHVpbnQzMl90IGVuY29k ZXJzKTsKKworI2VuZGlmIC8qIF9EUk1fTEVBU0VfSF8gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUv ZHJtL2RybV9tb2RlX29iamVjdC5oIGIvaW5jbHVkZS9kcm0vZHJtX21vZGVfb2JqZWN0LmgKaW5k ZXggYjJmOTIwYjUxOGUzLi5jODE1NWNiNWE5MzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2Ry bV9tb2RlX29iamVjdC5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9tb2RlX29iamVjdC5oCkBAIC0y NCw2ICsyNCw3IEBACiAjZGVmaW5lIF9fRFJNX01PREVTRVRfSF9fCiAKICNpbmNsdWRlIDxsaW51 eC9rcmVmLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9sZWFzZS5oPgogc3RydWN0IGRybV9vYmplY3Rf cHJvcGVydGllczsKIHN0cnVjdCBkcm1fcHJvcGVydHk7CiBzdHJ1Y3QgZHJtX2RldmljZTsKLS0g CjIuMTMuMwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K ZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==