From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E26EEC433FF for ; Fri, 2 Aug 2019 05:23:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A2B0620880 for ; Fri, 2 Aug 2019 05:23:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387740AbfHBFXp (ORCPT ); Fri, 2 Aug 2019 01:23:45 -0400 Received: from mx1.redhat.com ([209.132.183.28]:49094 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732740AbfHBFWz (ORCPT ); Fri, 2 Aug 2019 01:22:55 -0400 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 5B32C307D988; Fri, 2 Aug 2019 05:22:54 +0000 (UTC) Received: from sirius.home.kraxel.org (ovpn-116-81.ams2.redhat.com [10.36.116.81]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2DF1819C68; Fri, 2 Aug 2019 05:22:53 +0000 (UTC) Received: by sirius.home.kraxel.org (Postfix, from userid 1000) id 64A709D12; Fri, 2 Aug 2019 07:22:50 +0200 (CEST) From: Gerd Hoffmann To: dri-devel@lists.freedesktop.org Cc: ckoenig.leichtzumerken@gmail.com, thomas@shipmail.org, tzimmermann@suse.de, daniel@ffwll.ch, bskeggs@redhat.com, Gerd Hoffmann , Christian Koenig , Huang Rui , David Airlie , linux-kernel@vger.kernel.org (open list) Subject: [PATCH v4 10/17] drm/ttm: switch ttm core from bo->resv to bo->base.resv Date: Fri, 2 Aug 2019 07:22:40 +0200 Message-Id: <20190802052247.18427-11-kraxel@redhat.com> In-Reply-To: <20190802052247.18427-1-kraxel@redhat.com> References: <20190802052247.18427-1-kraxel@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.48]); Fri, 02 Aug 2019 05:22:54 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Signed-off-by: Gerd Hoffmann Reviewed-by: Christian König --- include/drm/ttm/ttm_bo_driver.h | 12 ++-- drivers/gpu/drm/ttm/ttm_bo.c | 96 +++++++++++++------------- drivers/gpu/drm/ttm/ttm_bo_util.c | 16 ++--- drivers/gpu/drm/ttm/ttm_bo_vm.c | 6 +- drivers/gpu/drm/ttm/ttm_execbuf_util.c | 20 +++--- drivers/gpu/drm/ttm/ttm_tt.c | 2 +- 6 files changed, 76 insertions(+), 76 deletions(-) diff --git a/include/drm/ttm/ttm_bo_driver.h b/include/drm/ttm/ttm_bo_driver.h index c9b8ba492f24..5b54e3254d13 100644 --- a/include/drm/ttm/ttm_bo_driver.h +++ b/include/drm/ttm/ttm_bo_driver.h @@ -654,14 +654,14 @@ static inline int __ttm_bo_reserve(struct ttm_buffer_object *bo, if (WARN_ON(ticket)) return -EBUSY; - success = reservation_object_trylock(bo->resv); + success = reservation_object_trylock(bo->base.resv); return success ? 0 : -EBUSY; } if (interruptible) - ret = reservation_object_lock_interruptible(bo->resv, ticket); + ret = reservation_object_lock_interruptible(bo->base.resv, ticket); else - ret = reservation_object_lock(bo->resv, ticket); + ret = reservation_object_lock(bo->base.resv, ticket); if (ret == -EINTR) return -ERESTARTSYS; return ret; @@ -745,10 +745,10 @@ static inline int ttm_bo_reserve_slowpath(struct ttm_buffer_object *bo, WARN_ON(!kref_read(&bo->kref)); if (interruptible) - ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock, + ret = ww_mutex_lock_slow_interruptible(&bo->base.resv->lock, ticket); else - ww_mutex_lock_slow(&bo->resv->lock, ticket); + ww_mutex_lock_slow(&bo->base.resv->lock, ticket); if (likely(ret == 0)) ttm_bo_del_sub_from_lru(bo); @@ -773,7 +773,7 @@ static inline void ttm_bo_unreserve(struct ttm_buffer_object *bo) else ttm_bo_move_to_lru_tail(bo, NULL); spin_unlock(&bo->bdev->glob->lru_lock); - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); } /* diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c index cd3a179a7e25..4d43a241e7eb 100644 --- a/drivers/gpu/drm/ttm/ttm_bo.c +++ b/drivers/gpu/drm/ttm/ttm_bo.c @@ -173,7 +173,7 @@ static void ttm_bo_add_mem_to_lru(struct ttm_buffer_object *bo, struct ttm_bo_device *bdev = bo->bdev; struct ttm_mem_type_manager *man; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); if (!list_empty(&bo->lru)) return; @@ -244,7 +244,7 @@ static void ttm_bo_bulk_move_set_pos(struct ttm_lru_bulk_move_pos *pos, void ttm_bo_move_to_lru_tail(struct ttm_buffer_object *bo, struct ttm_lru_bulk_move *bulk) { - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); ttm_bo_del_from_lru(bo); ttm_bo_add_to_lru(bo); @@ -277,8 +277,8 @@ void ttm_bo_bulk_move_lru_tail(struct ttm_lru_bulk_move *bulk) if (!pos->first) continue; - reservation_object_assert_held(pos->first->resv); - reservation_object_assert_held(pos->last->resv); + reservation_object_assert_held(pos->first->base.resv); + reservation_object_assert_held(pos->last->base.resv); man = &pos->first->bdev->man[TTM_PL_TT]; list_bulk_move_tail(&man->lru[i], &pos->first->lru, @@ -292,8 +292,8 @@ void ttm_bo_bulk_move_lru_tail(struct ttm_lru_bulk_move *bulk) if (!pos->first) continue; - reservation_object_assert_held(pos->first->resv); - reservation_object_assert_held(pos->last->resv); + reservation_object_assert_held(pos->first->base.resv); + reservation_object_assert_held(pos->last->base.resv); man = &pos->first->bdev->man[TTM_PL_VRAM]; list_bulk_move_tail(&man->lru[i], &pos->first->lru, @@ -307,8 +307,8 @@ void ttm_bo_bulk_move_lru_tail(struct ttm_lru_bulk_move *bulk) if (!pos->first) continue; - reservation_object_assert_held(pos->first->resv); - reservation_object_assert_held(pos->last->resv); + reservation_object_assert_held(pos->first->base.resv); + reservation_object_assert_held(pos->last->base.resv); lru = &pos->first->bdev->glob->swap_lru[i]; list_bulk_move_tail(lru, &pos->first->swap, &pos->last->swap); @@ -439,12 +439,12 @@ static int ttm_bo_individualize_resv(struct ttm_buffer_object *bo) { int r; - if (bo->resv == &bo->base._resv) + if (bo->base.resv == &bo->base._resv) return 0; BUG_ON(!reservation_object_trylock(&bo->base._resv)); - r = reservation_object_copy_fences(&bo->base._resv, bo->resv); + r = reservation_object_copy_fences(&bo->base._resv, bo->base.resv); if (r) reservation_object_unlock(&bo->base._resv); @@ -482,23 +482,23 @@ static void ttm_bo_cleanup_refs_or_queue(struct ttm_buffer_object *bo) /* Last resort, if we fail to allocate memory for the * fences block for the BO to become idle */ - reservation_object_wait_timeout_rcu(bo->resv, true, false, + reservation_object_wait_timeout_rcu(bo->base.resv, true, false, 30 * HZ); spin_lock(&glob->lru_lock); goto error; } spin_lock(&glob->lru_lock); - ret = reservation_object_trylock(bo->resv) ? 0 : -EBUSY; + ret = reservation_object_trylock(bo->base.resv) ? 0 : -EBUSY; if (!ret) { if (reservation_object_test_signaled_rcu(&bo->base._resv, true)) { ttm_bo_del_from_lru(bo); spin_unlock(&glob->lru_lock); - if (bo->resv != &bo->base._resv) + if (bo->base.resv != &bo->base._resv) reservation_object_unlock(&bo->base._resv); ttm_bo_cleanup_memtype_use(bo); - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); return; } @@ -514,9 +514,9 @@ static void ttm_bo_cleanup_refs_or_queue(struct ttm_buffer_object *bo) ttm_bo_add_to_lru(bo); } - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); } - if (bo->resv != &bo->base._resv) + if (bo->base.resv != &bo->base._resv) reservation_object_unlock(&bo->base._resv); error: @@ -550,7 +550,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, int ret; if (unlikely(list_empty(&bo->ddestroy))) - resv = bo->resv; + resv = bo->base.resv; else resv = &bo->base._resv; @@ -563,7 +563,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, long lret; if (unlock_resv) - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); spin_unlock(&glob->lru_lock); lret = reservation_object_wait_timeout_rcu(resv, true, @@ -576,7 +576,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, return -EBUSY; spin_lock(&glob->lru_lock); - if (unlock_resv && !reservation_object_trylock(bo->resv)) { + if (unlock_resv && !reservation_object_trylock(bo->base.resv)) { /* * We raced, and lost, someone else holds the reservation now, * and is probably busy in ttm_bo_cleanup_memtype_use. @@ -593,7 +593,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, if (ret || unlikely(list_empty(&bo->ddestroy))) { if (unlock_resv) - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); spin_unlock(&glob->lru_lock); return ret; } @@ -606,7 +606,7 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, ttm_bo_cleanup_memtype_use(bo); if (unlock_resv) - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); return 0; } @@ -632,14 +632,14 @@ static bool ttm_bo_delayed_delete(struct ttm_bo_device *bdev, bool remove_all) kref_get(&bo->list_kref); list_move_tail(&bo->ddestroy, &removed); - if (remove_all || bo->resv != &bo->base._resv) { + if (remove_all || bo->base.resv != &bo->base._resv) { spin_unlock(&glob->lru_lock); - reservation_object_lock(bo->resv, NULL); + reservation_object_lock(bo->base.resv, NULL); spin_lock(&glob->lru_lock); ttm_bo_cleanup_refs(bo, false, !remove_all, true); - } else if (reservation_object_trylock(bo->resv)) { + } else if (reservation_object_trylock(bo->base.resv)) { ttm_bo_cleanup_refs(bo, false, !remove_all, true); } else { spin_unlock(&glob->lru_lock); @@ -708,7 +708,7 @@ static int ttm_bo_evict(struct ttm_buffer_object *bo, struct ttm_placement placement; int ret = 0; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); placement.num_placement = 0; placement.num_busy_placement = 0; @@ -778,8 +778,8 @@ static bool ttm_bo_evict_swapout_allowable(struct ttm_buffer_object *bo, { bool ret = false; - if (bo->resv == ctx->resv) { - reservation_object_assert_held(bo->resv); + if (bo->base.resv == ctx->resv) { + reservation_object_assert_held(bo->base.resv); if (ctx->flags & TTM_OPT_FLAG_ALLOW_RES_EVICT || !list_empty(&bo->ddestroy)) ret = true; @@ -787,7 +787,7 @@ static bool ttm_bo_evict_swapout_allowable(struct ttm_buffer_object *bo, if (busy) *busy = false; } else { - ret = reservation_object_trylock(bo->resv); + ret = reservation_object_trylock(bo->base.resv); *locked = ret; if (busy) *busy = !ret; @@ -815,10 +815,10 @@ static int ttm_mem_evict_wait_busy(struct ttm_buffer_object *busy_bo, return -EBUSY; if (ctx->interruptible) - r = reservation_object_lock_interruptible(busy_bo->resv, + r = reservation_object_lock_interruptible(busy_bo->base.resv, ticket); else - r = reservation_object_lock(busy_bo->resv, ticket); + r = reservation_object_lock(busy_bo->base.resv, ticket); /* * TODO: It would be better to keep the BO locked until allocation is at @@ -826,7 +826,7 @@ static int ttm_mem_evict_wait_busy(struct ttm_buffer_object *busy_bo, * of TTM. */ if (!r) - reservation_object_unlock(busy_bo->resv); + reservation_object_unlock(busy_bo->base.resv); return r == -EDEADLK ? -EBUSY : r; } @@ -852,7 +852,7 @@ static int ttm_mem_evict_first(struct ttm_bo_device *bdev, if (!ttm_bo_evict_swapout_allowable(bo, ctx, &locked, &busy)) { if (busy && !busy_bo && - bo->resv->lock.ctx != ticket) + bo->base.resv->lock.ctx != ticket) busy_bo = bo; continue; } @@ -860,7 +860,7 @@ static int ttm_mem_evict_first(struct ttm_bo_device *bdev, if (place && !bdev->driver->eviction_valuable(bo, place)) { if (locked) - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); continue; } break; @@ -932,9 +932,9 @@ static int ttm_bo_add_move_fence(struct ttm_buffer_object *bo, spin_unlock(&man->move_lock); if (fence) { - reservation_object_add_shared_fence(bo->resv, fence); + reservation_object_add_shared_fence(bo->base.resv, fence); - ret = reservation_object_reserve_shared(bo->resv, 1); + ret = reservation_object_reserve_shared(bo->base.resv, 1); if (unlikely(ret)) { dma_fence_put(fence); return ret; @@ -967,7 +967,7 @@ static int ttm_bo_mem_force_space(struct ttm_buffer_object *bo, if (mem->mm_node) break; ret = ttm_mem_evict_first(bdev, mem->mem_type, place, ctx, - bo->resv->lock.ctx); + bo->base.resv->lock.ctx); if (unlikely(ret != 0)) return ret; } while (1); @@ -1089,7 +1089,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, bool type_found = false; int i, ret; - ret = reservation_object_reserve_shared(bo->resv, 1); + ret = reservation_object_reserve_shared(bo->base.resv, 1); if (unlikely(ret)) return ret; @@ -1170,7 +1170,7 @@ static int ttm_bo_move_buffer(struct ttm_buffer_object *bo, int ret = 0; struct ttm_mem_reg mem; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); mem.num_pages = bo->num_pages; mem.size = mem.num_pages << PAGE_SHIFT; @@ -1240,7 +1240,7 @@ int ttm_bo_validate(struct ttm_buffer_object *bo, int ret; uint32_t new_flags; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); /* * Check whether we need to move buffer. */ @@ -1332,7 +1332,7 @@ int ttm_bo_init_reserved(struct ttm_bo_device *bdev, if (resv) { bo->resv = resv; bo->base.resv = resv; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); } else { bo->resv = &bo->base._resv; bo->base.resv = &bo->base._resv; @@ -1360,7 +1360,7 @@ int ttm_bo_init_reserved(struct ttm_bo_device *bdev, * since otherwise lockdep will be angered in radeon. */ if (!resv) { - locked = reservation_object_trylock(bo->resv); + locked = reservation_object_trylock(bo->base.resv); WARN_ON(!locked); } @@ -1804,13 +1804,13 @@ int ttm_bo_wait(struct ttm_buffer_object *bo, long timeout = 15 * HZ; if (no_wait) { - if (reservation_object_test_signaled_rcu(bo->resv, true)) + if (reservation_object_test_signaled_rcu(bo->base.resv, true)) return 0; else return -EBUSY; } - timeout = reservation_object_wait_timeout_rcu(bo->resv, true, + timeout = reservation_object_wait_timeout_rcu(bo->base.resv, true, interruptible, timeout); if (timeout < 0) return timeout; @@ -1818,7 +1818,7 @@ int ttm_bo_wait(struct ttm_buffer_object *bo, if (timeout == 0) return -EBUSY; - reservation_object_add_excl_fence(bo->resv, NULL); + reservation_object_add_excl_fence(bo->base.resv, NULL); return 0; } EXPORT_SYMBOL(ttm_bo_wait); @@ -1934,7 +1934,7 @@ int ttm_bo_swapout(struct ttm_bo_global *glob, struct ttm_operation_ctx *ctx) * already swapped buffer. */ if (locked) - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); kref_put(&bo->list_kref, ttm_bo_release_list); return ret; } @@ -1972,14 +1972,14 @@ int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo) ret = mutex_lock_interruptible(&bo->wu_mutex); if (unlikely(ret != 0)) return -ERESTARTSYS; - if (!ww_mutex_is_locked(&bo->resv->lock)) + if (!ww_mutex_is_locked(&bo->base.resv->lock)) goto out_unlock; - ret = reservation_object_lock_interruptible(bo->resv, NULL); + ret = reservation_object_lock_interruptible(bo->base.resv, NULL); if (ret == -EINTR) ret = -ERESTARTSYS; if (unlikely(ret != 0)) goto out_unlock; - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); out_unlock: mutex_unlock(&bo->wu_mutex); diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c index f5009c1b6a9c..425a6d627b30 100644 --- a/drivers/gpu/drm/ttm/ttm_bo_util.c +++ b/drivers/gpu/drm/ttm/ttm_bo_util.c @@ -517,9 +517,9 @@ static int ttm_buffer_object_transfer(struct ttm_buffer_object *bo, kref_init(&fbo->base.kref); fbo->base.destroy = &ttm_transfered_destroy; fbo->base.acc_size = 0; - fbo->base.resv = &fbo->base.base._resv; - reservation_object_init(fbo->base.resv); - ret = reservation_object_trylock(fbo->base.resv); + fbo->base.base.resv = &fbo->base.base._resv; + reservation_object_init(fbo->base.base.resv); + ret = reservation_object_trylock(fbo->base.base.resv); WARN_ON(!ret); *new_obj = &fbo->base; @@ -689,7 +689,7 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo, int ret; struct ttm_buffer_object *ghost_obj; - reservation_object_add_excl_fence(bo->resv, fence); + reservation_object_add_excl_fence(bo->base.resv, fence); if (evict) { ret = ttm_bo_wait(bo, false, false); if (ret) @@ -716,7 +716,7 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo, if (ret) return ret; - reservation_object_add_excl_fence(ghost_obj->resv, fence); + reservation_object_add_excl_fence(ghost_obj->base.resv, fence); /** * If we're not moving to fixed memory, the TTM object @@ -752,7 +752,7 @@ int ttm_bo_pipeline_move(struct ttm_buffer_object *bo, int ret; - reservation_object_add_excl_fence(bo->resv, fence); + reservation_object_add_excl_fence(bo->base.resv, fence); if (!evict) { struct ttm_buffer_object *ghost_obj; @@ -772,7 +772,7 @@ int ttm_bo_pipeline_move(struct ttm_buffer_object *bo, if (ret) return ret; - reservation_object_add_excl_fence(ghost_obj->resv, fence); + reservation_object_add_excl_fence(ghost_obj->base.resv, fence); /** * If we're not moving to fixed memory, the TTM object @@ -841,7 +841,7 @@ int ttm_bo_pipeline_gutting(struct ttm_buffer_object *bo) if (ret) return ret; - ret = reservation_object_copy_fences(ghost->resv, bo->resv); + ret = reservation_object_copy_fences(ghost->base.resv, bo->base.resv); /* Last resort, wait for the BO to be idle when we are OOM */ if (ret) ttm_bo_wait(bo, false, false); diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c index fb6875a789b7..85f5bcbe0c76 100644 --- a/drivers/gpu/drm/ttm/ttm_bo_vm.c +++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c @@ -71,7 +71,7 @@ static vm_fault_t ttm_bo_vm_fault_idle(struct ttm_buffer_object *bo, ttm_bo_get(bo); up_read(&vmf->vma->vm_mm->mmap_sem); (void) dma_fence_wait(bo->moving, true); - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); ttm_bo_put(bo); goto out_unlock; } @@ -131,7 +131,7 @@ static vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf) * for reserve, and if it fails, retry the fault after waiting * for the buffer to become unreserved. */ - if (unlikely(!reservation_object_trylock(bo->resv))) { + if (unlikely(!reservation_object_trylock(bo->base.resv))) { if (vmf->flags & FAULT_FLAG_ALLOW_RETRY) { if (!(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) { ttm_bo_get(bo); @@ -296,7 +296,7 @@ static vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf) out_io_unlock: ttm_mem_io_unlock(man); out_unlock: - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); return ret; } diff --git a/drivers/gpu/drm/ttm/ttm_execbuf_util.c b/drivers/gpu/drm/ttm/ttm_execbuf_util.c index 957ec375a4ba..861c4145b462 100644 --- a/drivers/gpu/drm/ttm/ttm_execbuf_util.c +++ b/drivers/gpu/drm/ttm/ttm_execbuf_util.c @@ -39,7 +39,7 @@ static void ttm_eu_backoff_reservation_reverse(struct list_head *list, list_for_each_entry_continue_reverse(entry, list, head) { struct ttm_buffer_object *bo = entry->bo; - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); } } @@ -71,7 +71,7 @@ void ttm_eu_backoff_reservation(struct ww_acquire_ctx *ticket, if (list_empty(&bo->lru)) ttm_bo_add_to_lru(bo); - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); } spin_unlock(&glob->lru_lock); @@ -114,7 +114,7 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket, ret = __ttm_bo_reserve(bo, intr, (ticket == NULL), ticket); if (!ret && unlikely(atomic_read(&bo->cpu_writers) > 0)) { - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); ret = -EBUSY; @@ -130,7 +130,7 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket, if (!entry->num_shared) continue; - ret = reservation_object_reserve_shared(bo->resv, + ret = reservation_object_reserve_shared(bo->base.resv, entry->num_shared); if (!ret) continue; @@ -144,16 +144,16 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket, if (ret == -EDEADLK) { if (intr) { - ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock, + ret = ww_mutex_lock_slow_interruptible(&bo->base.resv->lock, ticket); } else { - ww_mutex_lock_slow(&bo->resv->lock, ticket); + ww_mutex_lock_slow(&bo->base.resv->lock, ticket); ret = 0; } } if (!ret && entry->num_shared) - ret = reservation_object_reserve_shared(bo->resv, + ret = reservation_object_reserve_shared(bo->base.resv, entry->num_shared); if (unlikely(ret != 0)) { @@ -201,14 +201,14 @@ void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket, list_for_each_entry(entry, list, head) { bo = entry->bo; if (entry->num_shared) - reservation_object_add_shared_fence(bo->resv, fence); + reservation_object_add_shared_fence(bo->base.resv, fence); else - reservation_object_add_excl_fence(bo->resv, fence); + reservation_object_add_excl_fence(bo->base.resv, fence); if (list_empty(&bo->lru)) ttm_bo_add_to_lru(bo); else ttm_bo_move_to_lru_tail(bo, NULL); - reservation_object_unlock(bo->resv); + reservation_object_unlock(bo->base.resv); } spin_unlock(&glob->lru_lock); if (ticket) diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c index e3a0691582ff..00b4a3337840 100644 --- a/drivers/gpu/drm/ttm/ttm_tt.c +++ b/drivers/gpu/drm/ttm/ttm_tt.c @@ -48,7 +48,7 @@ int ttm_tt_create(struct ttm_buffer_object *bo, bool zero_alloc) struct ttm_bo_device *bdev = bo->bdev; uint32_t page_flags = 0; - reservation_object_assert_held(bo->resv); + reservation_object_assert_held(bo->base.resv); if (bdev->need_dma32) page_flags |= TTM_PAGE_FLAG_DMA32; -- 2.18.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gerd Hoffmann Subject: [PATCH v4 10/17] drm/ttm: switch ttm core from bo->resv to bo->base.resv Date: Fri, 2 Aug 2019 07:22:40 +0200 Message-ID: <20190802052247.18427-11-kraxel@redhat.com> References: <20190802052247.18427-1-kraxel@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by gabe.freedesktop.org (Postfix) with ESMTPS id C11146E8A9 for ; Fri, 2 Aug 2019 05:22:54 +0000 (UTC) In-Reply-To: <20190802052247.18427-1-kraxel@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: thomas@shipmail.org, tzimmermann@suse.de, David Airlie , ckoenig.leichtzumerken@gmail.com, open list , Huang Rui , Gerd Hoffmann , Christian Koenig , bskeggs@redhat.com List-Id: dri-devel@lists.freedesktop.org U2lnbmVkLW9mZi1ieTogR2VyZCBIb2ZmbWFubiA8a3JheGVsQHJlZGhhdC5jb20+ClJldmlld2Vk LWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Ci0tLQogaW5j bHVkZS9kcm0vdHRtL3R0bV9ib19kcml2ZXIuaCAgICAgICAgfCAxMiArKy0tCiBkcml2ZXJzL2dw dS9kcm0vdHRtL3R0bV9iby5jICAgICAgICAgICB8IDk2ICsrKysrKysrKysrKystLS0tLS0tLS0t LS0tCiBkcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib191dGlsLmMgICAgICB8IDE2ICsrLS0tCiBk cml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib192bS5jICAgICAgICB8ICA2ICstCiBkcml2ZXJzL2dw dS9kcm0vdHRtL3R0bV9leGVjYnVmX3V0aWwuYyB8IDIwICsrKy0tLQogZHJpdmVycy9ncHUvZHJt L3R0bS90dG1fdHQuYyAgICAgICAgICAgfCAgMiArLQogNiBmaWxlcyBjaGFuZ2VkLCA3NiBpbnNl cnRpb25zKCspLCA3NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS90dG0v dHRtX2JvX2RyaXZlci5oIGIvaW5jbHVkZS9kcm0vdHRtL3R0bV9ib19kcml2ZXIuaAppbmRleCBj OWI4YmE0OTJmMjQuLjViNTRlMzI1NGQxMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vdHRtL3R0 bV9ib19kcml2ZXIuaAorKysgYi9pbmNsdWRlL2RybS90dG0vdHRtX2JvX2RyaXZlci5oCkBAIC02 NTQsMTQgKzY1NCwxNCBAQCBzdGF0aWMgaW5saW5lIGludCBfX3R0bV9ib19yZXNlcnZlKHN0cnVj dCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJCWlmIChXQVJOX09OKHRpY2tldCkpCiAJCQlyZXR1 cm4gLUVCVVNZOwogCi0JCXN1Y2Nlc3MgPSByZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+ cmVzdik7CisJCXN1Y2Nlc3MgPSByZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+YmFzZS5y ZXN2KTsKIAkJcmV0dXJuIHN1Y2Nlc3MgPyAwIDogLUVCVVNZOwogCX0KIAogCWlmIChpbnRlcnJ1 cHRpYmxlKQotCQlyZXQgPSByZXNlcnZhdGlvbl9vYmplY3RfbG9ja19pbnRlcnJ1cHRpYmxlKGJv LT5yZXN2LCB0aWNrZXQpOworCQlyZXQgPSByZXNlcnZhdGlvbl9vYmplY3RfbG9ja19pbnRlcnJ1 cHRpYmxlKGJvLT5iYXNlLnJlc3YsIHRpY2tldCk7CiAJZWxzZQotCQlyZXQgPSByZXNlcnZhdGlv bl9vYmplY3RfbG9jayhiby0+cmVzdiwgdGlja2V0KTsKKwkJcmV0ID0gcmVzZXJ2YXRpb25fb2Jq ZWN0X2xvY2soYm8tPmJhc2UucmVzdiwgdGlja2V0KTsKIAlpZiAocmV0ID09IC1FSU5UUikKIAkJ cmV0dXJuIC1FUkVTVEFSVFNZUzsKIAlyZXR1cm4gcmV0OwpAQCAtNzQ1LDEwICs3NDUsMTAgQEAg c3RhdGljIGlubGluZSBpbnQgdHRtX2JvX3Jlc2VydmVfc2xvd3BhdGgoc3RydWN0IHR0bV9idWZm ZXJfb2JqZWN0ICpibywKIAlXQVJOX09OKCFrcmVmX3JlYWQoJmJvLT5rcmVmKSk7CiAKIAlpZiAo aW50ZXJydXB0aWJsZSkKLQkJcmV0ID0gd3dfbXV0ZXhfbG9ja19zbG93X2ludGVycnVwdGlibGUo JmJvLT5yZXN2LT5sb2NrLAorCQlyZXQgPSB3d19tdXRleF9sb2NrX3Nsb3dfaW50ZXJydXB0aWJs ZSgmYm8tPmJhc2UucmVzdi0+bG9jaywKIAkJCQkJCSAgICAgICB0aWNrZXQpOwogCWVsc2UKLQkJ d3dfbXV0ZXhfbG9ja19zbG93KCZiby0+cmVzdi0+bG9jaywgdGlja2V0KTsKKwkJd3dfbXV0ZXhf bG9ja19zbG93KCZiby0+YmFzZS5yZXN2LT5sb2NrLCB0aWNrZXQpOwogCiAJaWYgKGxpa2VseShy ZXQgPT0gMCkpCiAJCXR0bV9ib19kZWxfc3ViX2Zyb21fbHJ1KGJvKTsKQEAgLTc3Myw3ICs3NzMs NyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgdHRtX2JvX3VucmVzZXJ2ZShzdHJ1Y3QgdHRtX2J1ZmZl cl9vYmplY3QgKmJvKQogCWVsc2UKIAkJdHRtX2JvX21vdmVfdG9fbHJ1X3RhaWwoYm8sIE5VTEwp OwogCXNwaW5fdW5sb2NrKCZiby0+YmRldi0+Z2xvYi0+bHJ1X2xvY2spOwotCXJlc2VydmF0aW9u X29iamVjdF91bmxvY2soYm8tPnJlc3YpOworCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8t PmJhc2UucmVzdik7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0 bV9iby5jIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYwppbmRleCBjZDNhMTc5YTdlMjUu LjRkNDNhMjQxZTdlYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9iby5jCkBAIC0xNzMsNyArMTczLDcgQEAgc3Rh dGljIHZvaWQgdHRtX2JvX2FkZF9tZW1fdG9fbHJ1KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAq Ym8sCiAJc3RydWN0IHR0bV9ib19kZXZpY2UgKmJkZXYgPSBiby0+YmRldjsKIAlzdHJ1Y3QgdHRt X21lbV90eXBlX21hbmFnZXIgKm1hbjsKIAotCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVs ZChiby0+cmVzdik7CisJcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2VydF9oZWxkKGJvLT5iYXNlLnJl c3YpOwogCiAJaWYgKCFsaXN0X2VtcHR5KCZiby0+bHJ1KSkKIAkJcmV0dXJuOwpAQCAtMjQ0LDcg KzI0NCw3IEBAIHN0YXRpYyB2b2lkIHR0bV9ib19idWxrX21vdmVfc2V0X3BvcyhzdHJ1Y3QgdHRt X2xydV9idWxrX21vdmVfcG9zICpwb3MsCiB2b2lkIHR0bV9ib19tb3ZlX3RvX2xydV90YWlsKHN0 cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJCQkgICAgIHN0cnVjdCB0dG1fbHJ1X2J1bGtf bW92ZSAqYnVsaykKIHsKLQlyZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0X2hlbGQoYm8tPnJlc3Yp OworCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+YmFzZS5yZXN2KTsKIAogCXR0 bV9ib19kZWxfZnJvbV9scnUoYm8pOwogCXR0bV9ib19hZGRfdG9fbHJ1KGJvKTsKQEAgLTI3Nyw4 ICsyNzcsOCBAQCB2b2lkIHR0bV9ib19idWxrX21vdmVfbHJ1X3RhaWwoc3RydWN0IHR0bV9scnVf YnVsa19tb3ZlICpidWxrKQogCQlpZiAoIXBvcy0+Zmlyc3QpCiAJCQljb250aW51ZTsKIAotCQly ZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0X2hlbGQocG9zLT5maXJzdC0+cmVzdik7Ci0JCXJlc2Vy dmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChwb3MtPmxhc3QtPnJlc3YpOworCQlyZXNlcnZhdGlv bl9vYmplY3RfYXNzZXJ0X2hlbGQocG9zLT5maXJzdC0+YmFzZS5yZXN2KTsKKwkJcmVzZXJ2YXRp b25fb2JqZWN0X2Fzc2VydF9oZWxkKHBvcy0+bGFzdC0+YmFzZS5yZXN2KTsKIAogCQltYW4gPSAm cG9zLT5maXJzdC0+YmRldi0+bWFuW1RUTV9QTF9UVF07CiAJCWxpc3RfYnVsa19tb3ZlX3RhaWwo Jm1hbi0+bHJ1W2ldLCAmcG9zLT5maXJzdC0+bHJ1LApAQCAtMjkyLDggKzI5Miw4IEBAIHZvaWQg dHRtX2JvX2J1bGtfbW92ZV9scnVfdGFpbChzdHJ1Y3QgdHRtX2xydV9idWxrX21vdmUgKmJ1bGsp CiAJCWlmICghcG9zLT5maXJzdCkKIAkJCWNvbnRpbnVlOwogCi0JCXJlc2VydmF0aW9uX29iamVj dF9hc3NlcnRfaGVsZChwb3MtPmZpcnN0LT5yZXN2KTsKLQkJcmVzZXJ2YXRpb25fb2JqZWN0X2Fz c2VydF9oZWxkKHBvcy0+bGFzdC0+cmVzdik7CisJCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRf aGVsZChwb3MtPmZpcnN0LT5iYXNlLnJlc3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0 X2hlbGQocG9zLT5sYXN0LT5iYXNlLnJlc3YpOwogCiAJCW1hbiA9ICZwb3MtPmZpcnN0LT5iZGV2 LT5tYW5bVFRNX1BMX1ZSQU1dOwogCQlsaXN0X2J1bGtfbW92ZV90YWlsKCZtYW4tPmxydVtpXSwg JnBvcy0+Zmlyc3QtPmxydSwKQEAgLTMwNyw4ICszMDcsOCBAQCB2b2lkIHR0bV9ib19idWxrX21v dmVfbHJ1X3RhaWwoc3RydWN0IHR0bV9scnVfYnVsa19tb3ZlICpidWxrKQogCQlpZiAoIXBvcy0+ Zmlyc3QpCiAJCQljb250aW51ZTsKIAotCQlyZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0X2hlbGQo cG9zLT5maXJzdC0+cmVzdik7Ci0JCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChwb3Mt Pmxhc3QtPnJlc3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0X2hlbGQocG9zLT5maXJz dC0+YmFzZS5yZXN2KTsKKwkJcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2VydF9oZWxkKHBvcy0+bGFz dC0+YmFzZS5yZXN2KTsKIAogCQlscnUgPSAmcG9zLT5maXJzdC0+YmRldi0+Z2xvYi0+c3dhcF9s cnVbaV07CiAJCWxpc3RfYnVsa19tb3ZlX3RhaWwobHJ1LCAmcG9zLT5maXJzdC0+c3dhcCwgJnBv cy0+bGFzdC0+c3dhcCk7CkBAIC00MzksMTIgKzQzOSwxMiBAQCBzdGF0aWMgaW50IHR0bV9ib19p bmRpdmlkdWFsaXplX3Jlc3Yoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibykKIHsKIAlpbnQg cjsKIAotCWlmIChiby0+cmVzdiA9PSAmYm8tPmJhc2UuX3Jlc3YpCisJaWYgKGJvLT5iYXNlLnJl c3YgPT0gJmJvLT5iYXNlLl9yZXN2KQogCQlyZXR1cm4gMDsKIAogCUJVR19PTighcmVzZXJ2YXRp b25fb2JqZWN0X3RyeWxvY2soJmJvLT5iYXNlLl9yZXN2KSk7CiAKLQlyID0gcmVzZXJ2YXRpb25f b2JqZWN0X2NvcHlfZmVuY2VzKCZiby0+YmFzZS5fcmVzdiwgYm8tPnJlc3YpOworCXIgPSByZXNl cnZhdGlvbl9vYmplY3RfY29weV9mZW5jZXMoJmJvLT5iYXNlLl9yZXN2LCBiby0+YmFzZS5yZXN2 KTsKIAlpZiAocikKIAkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jaygmYm8tPmJhc2UuX3Jlc3Yp OwogCkBAIC00ODIsMjMgKzQ4MiwyMyBAQCBzdGF0aWMgdm9pZCB0dG1fYm9fY2xlYW51cF9yZWZz X29yX3F1ZXVlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCiAJCS8qIExhc3QgcmVzb3J0 LCBpZiB3ZSBmYWlsIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgdGhlCiAJCSAqIGZlbmNlcyBibG9j ayBmb3IgdGhlIEJPIHRvIGJlY29tZSBpZGxlCiAJCSAqLwotCQlyZXNlcnZhdGlvbl9vYmplY3Rf d2FpdF90aW1lb3V0X3JjdShiby0+cmVzdiwgdHJ1ZSwgZmFsc2UsCisJCXJlc2VydmF0aW9uX29i amVjdF93YWl0X3RpbWVvdXRfcmN1KGJvLT5iYXNlLnJlc3YsIHRydWUsIGZhbHNlLAogCQkJCQkJ ICAgIDMwICogSFopOwogCQlzcGluX2xvY2soJmdsb2ItPmxydV9sb2NrKTsKIAkJZ290byBlcnJv cjsKIAl9CiAKIAlzcGluX2xvY2soJmdsb2ItPmxydV9sb2NrKTsKLQlyZXQgPSByZXNlcnZhdGlv bl9vYmplY3RfdHJ5bG9jayhiby0+cmVzdikgPyAwIDogLUVCVVNZOworCXJldCA9IHJlc2VydmF0 aW9uX29iamVjdF90cnlsb2NrKGJvLT5iYXNlLnJlc3YpID8gMCA6IC1FQlVTWTsKIAlpZiAoIXJl dCkgewogCQlpZiAocmVzZXJ2YXRpb25fb2JqZWN0X3Rlc3Rfc2lnbmFsZWRfcmN1KCZiby0+YmFz ZS5fcmVzdiwgdHJ1ZSkpIHsKIAkJCXR0bV9ib19kZWxfZnJvbV9scnUoYm8pOwogCQkJc3Bpbl91 bmxvY2soJmdsb2ItPmxydV9sb2NrKTsKLQkJCWlmIChiby0+cmVzdiAhPSAmYm8tPmJhc2UuX3Jl c3YpCisJCQlpZiAoYm8tPmJhc2UucmVzdiAhPSAmYm8tPmJhc2UuX3Jlc3YpCiAJCQkJcmVzZXJ2 YXRpb25fb2JqZWN0X3VubG9jaygmYm8tPmJhc2UuX3Jlc3YpOwogCiAJCQl0dG1fYm9fY2xlYW51 cF9tZW10eXBlX3VzZShibyk7Ci0JCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5yZXN2 KTsKKwkJCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8tPmJhc2UucmVzdik7CiAJCQlyZXR1 cm47CiAJCX0KIApAQCAtNTE0LDkgKzUxNCw5IEBAIHN0YXRpYyB2b2lkIHR0bV9ib19jbGVhbnVw X3JlZnNfb3JfcXVldWUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibykKIAkJCXR0bV9ib19h ZGRfdG9fbHJ1KGJvKTsKIAkJfQogCi0JCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8tPnJl c3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5iYXNlLnJlc3YpOwogCX0KLQlp ZiAoYm8tPnJlc3YgIT0gJmJvLT5iYXNlLl9yZXN2KQorCWlmIChiby0+YmFzZS5yZXN2ICE9ICZi by0+YmFzZS5fcmVzdikKIAkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jaygmYm8tPmJhc2UuX3Jl c3YpOwogCiBlcnJvcjoKQEAgLTU1MCw3ICs1NTAsNyBAQCBzdGF0aWMgaW50IHR0bV9ib19jbGVh bnVwX3JlZnMoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAlpbnQgcmV0OwogCiAJaWYg KHVubGlrZWx5KGxpc3RfZW1wdHkoJmJvLT5kZGVzdHJveSkpKQotCQlyZXN2ID0gYm8tPnJlc3Y7 CisJCXJlc3YgPSBiby0+YmFzZS5yZXN2OwogCWVsc2UKIAkJcmVzdiA9ICZiby0+YmFzZS5fcmVz djsKIApAQCAtNTYzLDcgKzU2Myw3IEBAIHN0YXRpYyBpbnQgdHRtX2JvX2NsZWFudXBfcmVmcyhz dHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCQlsb25nIGxyZXQ7CiAKIAkJaWYgKHVubG9j a19yZXN2KQotCQkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhiby0+cmVzdik7CisJCQlyZXNl cnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5iYXNlLnJlc3YpOwogCQlzcGluX3VubG9jaygmZ2xv Yi0+bHJ1X2xvY2spOwogCiAJCWxyZXQgPSByZXNlcnZhdGlvbl9vYmplY3Rfd2FpdF90aW1lb3V0 X3JjdShyZXN2LCB0cnVlLApAQCAtNTc2LDcgKzU3Niw3IEBAIHN0YXRpYyBpbnQgdHRtX2JvX2Ns ZWFudXBfcmVmcyhzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCQkJcmV0dXJuIC1FQlVT WTsKIAogCQlzcGluX2xvY2soJmdsb2ItPmxydV9sb2NrKTsKLQkJaWYgKHVubG9ja19yZXN2ICYm ICFyZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+cmVzdikpIHsKKwkJaWYgKHVubG9ja19y ZXN2ICYmICFyZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+YmFzZS5yZXN2KSkgewogCQkJ LyoKIAkJCSAqIFdlIHJhY2VkLCBhbmQgbG9zdCwgc29tZW9uZSBlbHNlIGhvbGRzIHRoZSByZXNl cnZhdGlvbiBub3csCiAJCQkgKiBhbmQgaXMgcHJvYmFibHkgYnVzeSBpbiB0dG1fYm9fY2xlYW51 cF9tZW10eXBlX3VzZS4KQEAgLTU5Myw3ICs1OTMsNyBAQCBzdGF0aWMgaW50IHR0bV9ib19jbGVh bnVwX3JlZnMoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAogCWlmIChyZXQgfHwgdW5s aWtlbHkobGlzdF9lbXB0eSgmYm8tPmRkZXN0cm95KSkpIHsKIAkJaWYgKHVubG9ja19yZXN2KQot CQkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhiby0+cmVzdik7CisJCQlyZXNlcnZhdGlvbl9v YmplY3RfdW5sb2NrKGJvLT5iYXNlLnJlc3YpOwogCQlzcGluX3VubG9jaygmZ2xvYi0+bHJ1X2xv Y2spOwogCQlyZXR1cm4gcmV0OwogCX0KQEAgLTYwNiw3ICs2MDYsNyBAQCBzdGF0aWMgaW50IHR0 bV9ib19jbGVhbnVwX3JlZnMoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAl0dG1fYm9f Y2xlYW51cF9tZW10eXBlX3VzZShibyk7CiAKIAlpZiAodW5sb2NrX3Jlc3YpCi0JCXJlc2VydmF0 aW9uX29iamVjdF91bmxvY2soYm8tPnJlc3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2Nr KGJvLT5iYXNlLnJlc3YpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC02MzIsMTQgKzYzMiwxNCBAQCBz dGF0aWMgYm9vbCB0dG1fYm9fZGVsYXllZF9kZWxldGUoc3RydWN0IHR0bV9ib19kZXZpY2UgKmJk ZXYsIGJvb2wgcmVtb3ZlX2FsbCkKIAkJa3JlZl9nZXQoJmJvLT5saXN0X2tyZWYpOwogCQlsaXN0 X21vdmVfdGFpbCgmYm8tPmRkZXN0cm95LCAmcmVtb3ZlZCk7CiAKLQkJaWYgKHJlbW92ZV9hbGwg fHwgYm8tPnJlc3YgIT0gJmJvLT5iYXNlLl9yZXN2KSB7CisJCWlmIChyZW1vdmVfYWxsIHx8IGJv LT5iYXNlLnJlc3YgIT0gJmJvLT5iYXNlLl9yZXN2KSB7CiAJCQlzcGluX3VubG9jaygmZ2xvYi0+ bHJ1X2xvY2spOwotCQkJcmVzZXJ2YXRpb25fb2JqZWN0X2xvY2soYm8tPnJlc3YsIE5VTEwpOwor CQkJcmVzZXJ2YXRpb25fb2JqZWN0X2xvY2soYm8tPmJhc2UucmVzdiwgTlVMTCk7CiAKIAkJCXNw aW5fbG9jaygmZ2xvYi0+bHJ1X2xvY2spOwogCQkJdHRtX2JvX2NsZWFudXBfcmVmcyhibywgZmFs c2UsICFyZW1vdmVfYWxsLCB0cnVlKTsKIAotCQl9IGVsc2UgaWYgKHJlc2VydmF0aW9uX29iamVj dF90cnlsb2NrKGJvLT5yZXN2KSkgeworCQl9IGVsc2UgaWYgKHJlc2VydmF0aW9uX29iamVjdF90 cnlsb2NrKGJvLT5iYXNlLnJlc3YpKSB7CiAJCQl0dG1fYm9fY2xlYW51cF9yZWZzKGJvLCBmYWxz ZSwgIXJlbW92ZV9hbGwsIHRydWUpOwogCQl9IGVsc2UgewogCQkJc3Bpbl91bmxvY2soJmdsb2It PmxydV9sb2NrKTsKQEAgLTcwOCw3ICs3MDgsNyBAQCBzdGF0aWMgaW50IHR0bV9ib19ldmljdChz dHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCXN0cnVjdCB0dG1fcGxhY2VtZW50IHBsYWNl bWVudDsKIAlpbnQgcmV0ID0gMDsKIAotCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChi by0+cmVzdik7CisJcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2VydF9oZWxkKGJvLT5iYXNlLnJlc3Yp OwogCiAJcGxhY2VtZW50Lm51bV9wbGFjZW1lbnQgPSAwOwogCXBsYWNlbWVudC5udW1fYnVzeV9w bGFjZW1lbnQgPSAwOwpAQCAtNzc4LDggKzc3OCw4IEBAIHN0YXRpYyBib29sIHR0bV9ib19ldmlj dF9zd2Fwb3V0X2FsbG93YWJsZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogewogCWJv b2wgcmV0ID0gZmFsc2U7CiAKLQlpZiAoYm8tPnJlc3YgPT0gY3R4LT5yZXN2KSB7Ci0JCXJlc2Vy dmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+cmVzdik7CisJaWYgKGJvLT5iYXNlLnJlc3Yg PT0gY3R4LT5yZXN2KSB7CisJCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+YmFz ZS5yZXN2KTsKIAkJaWYgKGN0eC0+ZmxhZ3MgJiBUVE1fT1BUX0ZMQUdfQUxMT1dfUkVTX0VWSUNU CiAJCSAgICB8fCAhbGlzdF9lbXB0eSgmYm8tPmRkZXN0cm95KSkKIAkJCXJldCA9IHRydWU7CkBA IC03ODcsNyArNzg3LDcgQEAgc3RhdGljIGJvb2wgdHRtX2JvX2V2aWN0X3N3YXBvdXRfYWxsb3dh YmxlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJCWlmIChidXN5KQogCQkJKmJ1c3kg PSBmYWxzZTsKIAl9IGVsc2UgewotCQlyZXQgPSByZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhi by0+cmVzdik7CisJCXJldCA9IHJlc2VydmF0aW9uX29iamVjdF90cnlsb2NrKGJvLT5iYXNlLnJl c3YpOwogCQkqbG9ja2VkID0gcmV0OwogCQlpZiAoYnVzeSkKIAkJCSpidXN5ID0gIXJldDsKQEAg LTgxNSwxMCArODE1LDEwIEBAIHN0YXRpYyBpbnQgdHRtX21lbV9ldmljdF93YWl0X2J1c3koc3Ry dWN0IHR0bV9idWZmZXJfb2JqZWN0ICpidXN5X2JvLAogCQlyZXR1cm4gLUVCVVNZOwogCiAJaWYg KGN0eC0+aW50ZXJydXB0aWJsZSkKLQkJciA9IHJlc2VydmF0aW9uX29iamVjdF9sb2NrX2ludGVy cnVwdGlibGUoYnVzeV9iby0+cmVzdiwKKwkJciA9IHJlc2VydmF0aW9uX29iamVjdF9sb2NrX2lu dGVycnVwdGlibGUoYnVzeV9iby0+YmFzZS5yZXN2LAogCQkJCQkJCSAgdGlja2V0KTsKIAllbHNl Ci0JCXIgPSByZXNlcnZhdGlvbl9vYmplY3RfbG9jayhidXN5X2JvLT5yZXN2LCB0aWNrZXQpOwor CQlyID0gcmVzZXJ2YXRpb25fb2JqZWN0X2xvY2soYnVzeV9iby0+YmFzZS5yZXN2LCB0aWNrZXQp OwogCiAJLyoKIAkgKiBUT0RPOiBJdCB3b3VsZCBiZSBiZXR0ZXIgdG8ga2VlcCB0aGUgQk8gbG9j a2VkIHVudGlsIGFsbG9jYXRpb24gaXMgYXQKQEAgLTgyNiw3ICs4MjYsNyBAQCBzdGF0aWMgaW50 IHR0bV9tZW1fZXZpY3Rfd2FpdF9idXN5KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYnVzeV9i bywKIAkgKiBvZiBUVE0uCiAJICovCiAJaWYgKCFyKQotCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5s b2NrKGJ1c3lfYm8tPnJlc3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGJ1c3lfYm8t PmJhc2UucmVzdik7CiAKIAlyZXR1cm4gciA9PSAtRURFQURMSyA/IC1FQlVTWSA6IHI7CiB9CkBA IC04NTIsNyArODUyLDcgQEAgc3RhdGljIGludCB0dG1fbWVtX2V2aWN0X2ZpcnN0KHN0cnVjdCB0 dG1fYm9fZGV2aWNlICpiZGV2LAogCQkJaWYgKCF0dG1fYm9fZXZpY3Rfc3dhcG91dF9hbGxvd2Fi bGUoYm8sIGN0eCwgJmxvY2tlZCwKIAkJCQkJCQkgICAgJmJ1c3kpKSB7CiAJCQkJaWYgKGJ1c3kg JiYgIWJ1c3lfYm8gJiYKLQkJCQkgICAgYm8tPnJlc3YtPmxvY2suY3R4ICE9IHRpY2tldCkKKwkJ CQkgICAgYm8tPmJhc2UucmVzdi0+bG9jay5jdHggIT0gdGlja2V0KQogCQkJCQlidXN5X2JvID0g Ym87CiAJCQkJY29udGludWU7CiAJCQl9CkBAIC04NjAsNyArODYwLDcgQEAgc3RhdGljIGludCB0 dG1fbWVtX2V2aWN0X2ZpcnN0KHN0cnVjdCB0dG1fYm9fZGV2aWNlICpiZGV2LAogCQkJaWYgKHBs YWNlICYmICFiZGV2LT5kcml2ZXItPmV2aWN0aW9uX3ZhbHVhYmxlKGJvLAogCQkJCQkJCQkgICAg ICBwbGFjZSkpIHsKIAkJCQlpZiAobG9ja2VkKQotCQkJCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5s b2NrKGJvLT5yZXN2KTsKKwkJCQkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhiby0+YmFzZS5y ZXN2KTsKIAkJCQljb250aW51ZTsKIAkJCX0KIAkJCWJyZWFrOwpAQCAtOTMyLDkgKzkzMiw5IEBA IHN0YXRpYyBpbnQgdHRtX2JvX2FkZF9tb3ZlX2ZlbmNlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dCAqYm8sCiAJc3Bpbl91bmxvY2soJm1hbi0+bW92ZV9sb2NrKTsKIAogCWlmIChmZW5jZSkgewot CQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX3NoYXJlZF9mZW5jZShiby0+cmVzdiwgZmVuY2UpOwor CQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX3NoYXJlZF9mZW5jZShiby0+YmFzZS5yZXN2LCBmZW5j ZSk7CiAKLQkJcmV0ID0gcmVzZXJ2YXRpb25fb2JqZWN0X3Jlc2VydmVfc2hhcmVkKGJvLT5yZXN2 LCAxKTsKKwkJcmV0ID0gcmVzZXJ2YXRpb25fb2JqZWN0X3Jlc2VydmVfc2hhcmVkKGJvLT5iYXNl LnJlc3YsIDEpOwogCQlpZiAodW5saWtlbHkocmV0KSkgewogCQkJZG1hX2ZlbmNlX3B1dChmZW5j ZSk7CiAJCQlyZXR1cm4gcmV0OwpAQCAtOTY3LDcgKzk2Nyw3IEBAIHN0YXRpYyBpbnQgdHRtX2Jv X21lbV9mb3JjZV9zcGFjZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCQlpZiAobWVt LT5tbV9ub2RlKQogCQkJYnJlYWs7CiAJCXJldCA9IHR0bV9tZW1fZXZpY3RfZmlyc3QoYmRldiwg bWVtLT5tZW1fdHlwZSwgcGxhY2UsIGN0eCwKLQkJCQkJICBiby0+cmVzdi0+bG9jay5jdHgpOwor CQkJCQkgIGJvLT5iYXNlLnJlc3YtPmxvY2suY3R4KTsKIAkJaWYgKHVubGlrZWx5KHJldCAhPSAw KSkKIAkJCXJldHVybiByZXQ7CiAJfSB3aGlsZSAoMSk7CkBAIC0xMDg5LDcgKzEwODksNyBAQCBp bnQgdHRtX2JvX21lbV9zcGFjZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCWJvb2wg dHlwZV9mb3VuZCA9IGZhbHNlOwogCWludCBpLCByZXQ7CiAKLQlyZXQgPSByZXNlcnZhdGlvbl9v YmplY3RfcmVzZXJ2ZV9zaGFyZWQoYm8tPnJlc3YsIDEpOworCXJldCA9IHJlc2VydmF0aW9uX29i amVjdF9yZXNlcnZlX3NoYXJlZChiby0+YmFzZS5yZXN2LCAxKTsKIAlpZiAodW5saWtlbHkocmV0 KSkKIAkJcmV0dXJuIHJldDsKIApAQCAtMTE3MCw3ICsxMTcwLDcgQEAgc3RhdGljIGludCB0dG1f Ym9fbW92ZV9idWZmZXIoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAlpbnQgcmV0ID0g MDsKIAlzdHJ1Y3QgdHRtX21lbV9yZWcgbWVtOwogCi0JcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2Vy dF9oZWxkKGJvLT5yZXN2KTsKKwlyZXNlcnZhdGlvbl9vYmplY3RfYXNzZXJ0X2hlbGQoYm8tPmJh c2UucmVzdik7CiAKIAltZW0ubnVtX3BhZ2VzID0gYm8tPm51bV9wYWdlczsKIAltZW0uc2l6ZSA9 IG1lbS5udW1fcGFnZXMgPDwgUEFHRV9TSElGVDsKQEAgLTEyNDAsNyArMTI0MCw3IEBAIGludCB0 dG1fYm9fdmFsaWRhdGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAlpbnQgcmV0Owog CXVpbnQzMl90IG5ld19mbGFnczsKIAotCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChi by0+cmVzdik7CisJcmVzZXJ2YXRpb25fb2JqZWN0X2Fzc2VydF9oZWxkKGJvLT5iYXNlLnJlc3Yp OwogCS8qCiAJICogQ2hlY2sgd2hldGhlciB3ZSBuZWVkIHRvIG1vdmUgYnVmZmVyLgogCSAqLwpA QCAtMTMzMiw3ICsxMzMyLDcgQEAgaW50IHR0bV9ib19pbml0X3Jlc2VydmVkKHN0cnVjdCB0dG1f Ym9fZGV2aWNlICpiZGV2LAogCWlmIChyZXN2KSB7CiAJCWJvLT5yZXN2ID0gcmVzdjsKIAkJYm8t PmJhc2UucmVzdiA9IHJlc3Y7Ci0JCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+ cmVzdik7CisJCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+YmFzZS5yZXN2KTsK IAl9IGVsc2UgewogCQliby0+cmVzdiA9ICZiby0+YmFzZS5fcmVzdjsKIAkJYm8tPmJhc2UucmVz diA9ICZiby0+YmFzZS5fcmVzdjsKQEAgLTEzNjAsNyArMTM2MCw3IEBAIGludCB0dG1fYm9faW5p dF9yZXNlcnZlZChzdHJ1Y3QgdHRtX2JvX2RldmljZSAqYmRldiwKIAkgKiBzaW5jZSBvdGhlcndp c2UgbG9ja2RlcCB3aWxsIGJlIGFuZ2VyZWQgaW4gcmFkZW9uLgogCSAqLwogCWlmICghcmVzdikg ewotCQlsb2NrZWQgPSByZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+cmVzdik7CisJCWxv Y2tlZCA9IHJlc2VydmF0aW9uX29iamVjdF90cnlsb2NrKGJvLT5iYXNlLnJlc3YpOwogCQlXQVJO X09OKCFsb2NrZWQpOwogCX0KIApAQCAtMTgwNCwxMyArMTgwNCwxMyBAQCBpbnQgdHRtX2JvX3dh aXQoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAlsb25nIHRpbWVvdXQgPSAxNSAqIEha OwogCiAJaWYgKG5vX3dhaXQpIHsKLQkJaWYgKHJlc2VydmF0aW9uX29iamVjdF90ZXN0X3NpZ25h bGVkX3JjdShiby0+cmVzdiwgdHJ1ZSkpCisJCWlmIChyZXNlcnZhdGlvbl9vYmplY3RfdGVzdF9z aWduYWxlZF9yY3UoYm8tPmJhc2UucmVzdiwgdHJ1ZSkpCiAJCQlyZXR1cm4gMDsKIAkJZWxzZQog CQkJcmV0dXJuIC1FQlVTWTsKIAl9CiAKLQl0aW1lb3V0ID0gcmVzZXJ2YXRpb25fb2JqZWN0X3dh aXRfdGltZW91dF9yY3UoYm8tPnJlc3YsIHRydWUsCisJdGltZW91dCA9IHJlc2VydmF0aW9uX29i amVjdF93YWl0X3RpbWVvdXRfcmN1KGJvLT5iYXNlLnJlc3YsIHRydWUsCiAJCQkJCQkgICAgICBp bnRlcnJ1cHRpYmxlLCB0aW1lb3V0KTsKIAlpZiAodGltZW91dCA8IDApCiAJCXJldHVybiB0aW1l b3V0OwpAQCAtMTgxOCw3ICsxODE4LDcgQEAgaW50IHR0bV9ib193YWl0KHN0cnVjdCB0dG1fYnVm ZmVyX29iamVjdCAqYm8sCiAJaWYgKHRpbWVvdXQgPT0gMCkKIAkJcmV0dXJuIC1FQlVTWTsKIAot CXJlc2VydmF0aW9uX29iamVjdF9hZGRfZXhjbF9mZW5jZShiby0+cmVzdiwgTlVMTCk7CisJcmVz ZXJ2YXRpb25fb2JqZWN0X2FkZF9leGNsX2ZlbmNlKGJvLT5iYXNlLnJlc3YsIE5VTEwpOwogCXJl dHVybiAwOwogfQogRVhQT1JUX1NZTUJPTCh0dG1fYm9fd2FpdCk7CkBAIC0xOTM0LDcgKzE5MzQs NyBAQCBpbnQgdHRtX2JvX3N3YXBvdXQoc3RydWN0IHR0bV9ib19nbG9iYWwgKmdsb2IsIHN0cnVj dCB0dG1fb3BlcmF0aW9uX2N0eCAqY3R4KQogCSAqIGFscmVhZHkgc3dhcHBlZCBidWZmZXIuCiAJ ICovCiAJaWYgKGxvY2tlZCkKLQkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhiby0+cmVzdik7 CisJCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8tPmJhc2UucmVzdik7CiAJa3JlZl9wdXQo JmJvLT5saXN0X2tyZWYsIHR0bV9ib19yZWxlYXNlX2xpc3QpOwogCXJldHVybiByZXQ7CiB9CkBA IC0xOTcyLDE0ICsxOTcyLDE0IEBAIGludCB0dG1fYm9fd2FpdF91bnJlc2VydmVkKHN0cnVjdCB0 dG1fYnVmZmVyX29iamVjdCAqYm8pCiAJcmV0ID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZi by0+d3VfbXV0ZXgpOwogCWlmICh1bmxpa2VseShyZXQgIT0gMCkpCiAJCXJldHVybiAtRVJFU1RB UlRTWVM7Ci0JaWYgKCF3d19tdXRleF9pc19sb2NrZWQoJmJvLT5yZXN2LT5sb2NrKSkKKwlpZiAo IXd3X211dGV4X2lzX2xvY2tlZCgmYm8tPmJhc2UucmVzdi0+bG9jaykpCiAJCWdvdG8gb3V0X3Vu bG9jazsKLQlyZXQgPSByZXNlcnZhdGlvbl9vYmplY3RfbG9ja19pbnRlcnJ1cHRpYmxlKGJvLT5y ZXN2LCBOVUxMKTsKKwlyZXQgPSByZXNlcnZhdGlvbl9vYmplY3RfbG9ja19pbnRlcnJ1cHRpYmxl KGJvLT5iYXNlLnJlc3YsIE5VTEwpOwogCWlmIChyZXQgPT0gLUVJTlRSKQogCQlyZXQgPSAtRVJF U1RBUlRTWVM7CiAJaWYgKHVubGlrZWx5KHJldCAhPSAwKSkKIAkJZ290byBvdXRfdW5sb2NrOwot CXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8tPnJlc3YpOworCXJlc2VydmF0aW9uX29iamVj dF91bmxvY2soYm8tPmJhc2UucmVzdik7CiAKIG91dF91bmxvY2s6CiAJbXV0ZXhfdW5sb2NrKCZi by0+d3VfbXV0ZXgpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm9fdXRp bC5jIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm9fdXRpbC5jCmluZGV4IGY1MDA5YzFiNmE5 Yy4uNDI1YTZkNjI3YjMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib191 dGlsLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm9fdXRpbC5jCkBAIC01MTcsOSAr NTE3LDkgQEAgc3RhdGljIGludCB0dG1fYnVmZmVyX29iamVjdF90cmFuc2ZlcihzdHJ1Y3QgdHRt X2J1ZmZlcl9vYmplY3QgKmJvLAogCWtyZWZfaW5pdCgmZmJvLT5iYXNlLmtyZWYpOwogCWZiby0+ YmFzZS5kZXN0cm95ID0gJnR0bV90cmFuc2ZlcmVkX2Rlc3Ryb3k7CiAJZmJvLT5iYXNlLmFjY19z aXplID0gMDsKLQlmYm8tPmJhc2UucmVzdiA9ICZmYm8tPmJhc2UuYmFzZS5fcmVzdjsKLQlyZXNl cnZhdGlvbl9vYmplY3RfaW5pdChmYm8tPmJhc2UucmVzdik7Ci0JcmV0ID0gcmVzZXJ2YXRpb25f b2JqZWN0X3RyeWxvY2soZmJvLT5iYXNlLnJlc3YpOworCWZiby0+YmFzZS5iYXNlLnJlc3YgPSAm ZmJvLT5iYXNlLmJhc2UuX3Jlc3Y7CisJcmVzZXJ2YXRpb25fb2JqZWN0X2luaXQoZmJvLT5iYXNl LmJhc2UucmVzdik7CisJcmV0ID0gcmVzZXJ2YXRpb25fb2JqZWN0X3RyeWxvY2soZmJvLT5iYXNl LmJhc2UucmVzdik7CiAJV0FSTl9PTighcmV0KTsKIAogCSpuZXdfb2JqID0gJmZiby0+YmFzZTsK QEAgLTY4OSw3ICs2ODksNyBAQCBpbnQgdHRtX2JvX21vdmVfYWNjZWxfY2xlYW51cChzdHJ1Y3Qg dHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCWludCByZXQ7CiAJc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpnaG9zdF9vYmo7CiAKLQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVuY2UoYm8t PnJlc3YsIGZlbmNlKTsKKwlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVuY2UoYm8tPmJh c2UucmVzdiwgZmVuY2UpOwogCWlmIChldmljdCkgewogCQlyZXQgPSB0dG1fYm9fd2FpdChibywg ZmFsc2UsIGZhbHNlKTsKIAkJaWYgKHJldCkKQEAgLTcxNiw3ICs3MTYsNyBAQCBpbnQgdHRtX2Jv X21vdmVfYWNjZWxfY2xlYW51cChzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAogCQlpZiAo cmV0KQogCQkJcmV0dXJuIHJldDsKIAotCQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVu Y2UoZ2hvc3Rfb2JqLT5yZXN2LCBmZW5jZSk7CisJCXJlc2VydmF0aW9uX29iamVjdF9hZGRfZXhj bF9mZW5jZShnaG9zdF9vYmotPmJhc2UucmVzdiwgZmVuY2UpOwogCiAJCS8qKgogCQkgKiBJZiB3 ZSdyZSBub3QgbW92aW5nIHRvIGZpeGVkIG1lbW9yeSwgdGhlIFRUTSBvYmplY3QKQEAgLTc1Miw3 ICs3NTIsNyBAQCBpbnQgdHRtX2JvX3BpcGVsaW5lX21vdmUoc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpibywKIAogCWludCByZXQ7CiAKLQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVu Y2UoYm8tPnJlc3YsIGZlbmNlKTsKKwlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVuY2Uo Ym8tPmJhc2UucmVzdiwgZmVuY2UpOwogCiAJaWYgKCFldmljdCkgewogCQlzdHJ1Y3QgdHRtX2J1 ZmZlcl9vYmplY3QgKmdob3N0X29iajsKQEAgLTc3Miw3ICs3NzIsNyBAQCBpbnQgdHRtX2JvX3Bp cGVsaW5lX21vdmUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKIAkJaWYgKHJldCkKIAkJ CXJldHVybiByZXQ7CiAKLQkJcmVzZXJ2YXRpb25fb2JqZWN0X2FkZF9leGNsX2ZlbmNlKGdob3N0 X29iai0+cmVzdiwgZmVuY2UpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVuY2Uo Z2hvc3Rfb2JqLT5iYXNlLnJlc3YsIGZlbmNlKTsKIAogCQkvKioKIAkJICogSWYgd2UncmUgbm90 IG1vdmluZyB0byBmaXhlZCBtZW1vcnksIHRoZSBUVE0gb2JqZWN0CkBAIC04NDEsNyArODQxLDcg QEAgaW50IHR0bV9ib19waXBlbGluZV9ndXR0aW5nKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAq Ym8pCiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAotCXJldCA9IHJlc2VydmF0aW9uX29iamVj dF9jb3B5X2ZlbmNlcyhnaG9zdC0+cmVzdiwgYm8tPnJlc3YpOworCXJldCA9IHJlc2VydmF0aW9u X29iamVjdF9jb3B5X2ZlbmNlcyhnaG9zdC0+YmFzZS5yZXN2LCBiby0+YmFzZS5yZXN2KTsKIAkv KiBMYXN0IHJlc29ydCwgd2FpdCBmb3IgdGhlIEJPIHRvIGJlIGlkbGUgd2hlbiB3ZSBhcmUgT09N ICovCiAJaWYgKHJldCkKIAkJdHRtX2JvX3dhaXQoYm8sIGZhbHNlLCBmYWxzZSk7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib192bS5jIGIvZHJpdmVycy9ncHUvZHJtL3R0 bS90dG1fYm9fdm0uYwppbmRleCBmYjY4NzVhNzg5YjcuLjg1ZjViY2JlMGM3NiAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm9fdm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0v dHRtL3R0bV9ib192bS5jCkBAIC03MSw3ICs3MSw3IEBAIHN0YXRpYyB2bV9mYXVsdF90IHR0bV9i b192bV9mYXVsdF9pZGxlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJCXR0bV9ib19n ZXQoYm8pOwogCQl1cF9yZWFkKCZ2bWYtPnZtYS0+dm1fbW0tPm1tYXBfc2VtKTsKIAkJKHZvaWQp IGRtYV9mZW5jZV93YWl0KGJvLT5tb3ZpbmcsIHRydWUpOwotCQlyZXNlcnZhdGlvbl9vYmplY3Rf dW5sb2NrKGJvLT5yZXN2KTsKKwkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhiby0+YmFzZS5y ZXN2KTsKIAkJdHRtX2JvX3B1dChibyk7CiAJCWdvdG8gb3V0X3VubG9jazsKIAl9CkBAIC0xMzEs NyArMTMxLDcgQEAgc3RhdGljIHZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2ZhdWx0KHN0cnVjdCB2bV9m YXVsdCAqdm1mKQogCSAqIGZvciByZXNlcnZlLCBhbmQgaWYgaXQgZmFpbHMsIHJldHJ5IHRoZSBm YXVsdCBhZnRlciB3YWl0aW5nCiAJICogZm9yIHRoZSBidWZmZXIgdG8gYmVjb21lIHVucmVzZXJ2 ZWQuCiAJICovCi0JaWYgKHVubGlrZWx5KCFyZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+ cmVzdikpKSB7CisJaWYgKHVubGlrZWx5KCFyZXNlcnZhdGlvbl9vYmplY3RfdHJ5bG9jayhiby0+ YmFzZS5yZXN2KSkpIHsKIAkJaWYgKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX0FMTE9XX1JFVFJZ KSB7CiAJCQlpZiAoISh2bWYtPmZsYWdzICYgRkFVTFRfRkxBR19SRVRSWV9OT1dBSVQpKSB7CiAJ CQkJdHRtX2JvX2dldChibyk7CkBAIC0yOTYsNyArMjk2LDcgQEAgc3RhdGljIHZtX2ZhdWx0X3Qg dHRtX2JvX3ZtX2ZhdWx0KHN0cnVjdCB2bV9mYXVsdCAqdm1mKQogb3V0X2lvX3VubG9jazoKIAl0 dG1fbWVtX2lvX3VubG9jayhtYW4pOwogb3V0X3VubG9jazoKLQlyZXNlcnZhdGlvbl9vYmplY3Rf dW5sb2NrKGJvLT5yZXN2KTsKKwlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5iYXNlLnJl c3YpOwogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90dG0v dHRtX2V4ZWNidWZfdXRpbC5jIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fZXhlY2J1Zl91dGls LmMKaW5kZXggOTU3ZWMzNzVhNGJhLi44NjFjNDE0NWI0NjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS90dG0vdHRtX2V4ZWNidWZfdXRpbC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS90dG0v dHRtX2V4ZWNidWZfdXRpbC5jCkBAIC0zOSw3ICszOSw3IEBAIHN0YXRpYyB2b2lkIHR0bV9ldV9i YWNrb2ZmX3Jlc2VydmF0aW9uX3JldmVyc2Uoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCwKIAlsaXN0 X2Zvcl9lYWNoX2VudHJ5X2NvbnRpbnVlX3JldmVyc2UoZW50cnksIGxpc3QsIGhlYWQpIHsKIAkJ c3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGVudHJ5LT5ibzsKIAotCQlyZXNlcnZhdGlv bl9vYmplY3RfdW5sb2NrKGJvLT5yZXN2KTsKKwkJcmVzZXJ2YXRpb25fb2JqZWN0X3VubG9jayhi by0+YmFzZS5yZXN2KTsKIAl9CiB9CiAKQEAgLTcxLDcgKzcxLDcgQEAgdm9pZCB0dG1fZXVfYmFj a29mZl9yZXNlcnZhdGlvbihzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKnRpY2tldCwKIAogCQlpZiAo bGlzdF9lbXB0eSgmYm8tPmxydSkpCiAJCQl0dG1fYm9fYWRkX3RvX2xydShibyk7Ci0JCXJlc2Vy dmF0aW9uX29iamVjdF91bmxvY2soYm8tPnJlc3YpOworCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5s b2NrKGJvLT5iYXNlLnJlc3YpOwogCX0KIAlzcGluX3VubG9jaygmZ2xvYi0+bHJ1X2xvY2spOwog CkBAIC0xMTQsNyArMTE0LDcgQEAgaW50IHR0bV9ldV9yZXNlcnZlX2J1ZmZlcnMoc3RydWN0IHd3 X2FjcXVpcmVfY3R4ICp0aWNrZXQsCiAKIAkJcmV0ID0gX190dG1fYm9fcmVzZXJ2ZShibywgaW50 ciwgKHRpY2tldCA9PSBOVUxMKSwgdGlja2V0KTsKIAkJaWYgKCFyZXQgJiYgdW5saWtlbHkoYXRv bWljX3JlYWQoJmJvLT5jcHVfd3JpdGVycykgPiAwKSkgewotCQkJcmVzZXJ2YXRpb25fb2JqZWN0 X3VubG9jayhiby0+cmVzdik7CisJCQlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5iYXNl LnJlc3YpOwogCiAJCQlyZXQgPSAtRUJVU1k7CiAKQEAgLTEzMCw3ICsxMzAsNyBAQCBpbnQgdHRt X2V1X3Jlc2VydmVfYnVmZmVycyhzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKnRpY2tldCwKIAkJCWlm ICghZW50cnktPm51bV9zaGFyZWQpCiAJCQkJY29udGludWU7CiAKLQkJCXJldCA9IHJlc2VydmF0 aW9uX29iamVjdF9yZXNlcnZlX3NoYXJlZChiby0+cmVzdiwKKwkJCXJldCA9IHJlc2VydmF0aW9u X29iamVjdF9yZXNlcnZlX3NoYXJlZChiby0+YmFzZS5yZXN2LAogCQkJCQkJCQllbnRyeS0+bnVt X3NoYXJlZCk7CiAJCQlpZiAoIXJldCkKIAkJCQljb250aW51ZTsKQEAgLTE0NCwxNiArMTQ0LDE2 IEBAIGludCB0dG1fZXVfcmVzZXJ2ZV9idWZmZXJzKHN0cnVjdCB3d19hY3F1aXJlX2N0eCAqdGlj a2V0LAogCiAJCWlmIChyZXQgPT0gLUVERUFETEspIHsKIAkJCWlmIChpbnRyKSB7Ci0JCQkJcmV0 ID0gd3dfbXV0ZXhfbG9ja19zbG93X2ludGVycnVwdGlibGUoJmJvLT5yZXN2LT5sb2NrLAorCQkJ CXJldCA9IHd3X211dGV4X2xvY2tfc2xvd19pbnRlcnJ1cHRpYmxlKCZiby0+YmFzZS5yZXN2LT5s b2NrLAogCQkJCQkJCQkgICAgICAgdGlja2V0KTsKIAkJCX0gZWxzZSB7Ci0JCQkJd3dfbXV0ZXhf bG9ja19zbG93KCZiby0+cmVzdi0+bG9jaywgdGlja2V0KTsKKwkJCQl3d19tdXRleF9sb2NrX3Ns b3coJmJvLT5iYXNlLnJlc3YtPmxvY2ssIHRpY2tldCk7CiAJCQkJcmV0ID0gMDsKIAkJCX0KIAkJ fQogCiAJCWlmICghcmV0ICYmIGVudHJ5LT5udW1fc2hhcmVkKQotCQkJcmV0ID0gcmVzZXJ2YXRp b25fb2JqZWN0X3Jlc2VydmVfc2hhcmVkKGJvLT5yZXN2LAorCQkJcmV0ID0gcmVzZXJ2YXRpb25f b2JqZWN0X3Jlc2VydmVfc2hhcmVkKGJvLT5iYXNlLnJlc3YsCiAJCQkJCQkJCWVudHJ5LT5udW1f c2hhcmVkKTsKIAogCQlpZiAodW5saWtlbHkocmV0ICE9IDApKSB7CkBAIC0yMDEsMTQgKzIwMSwx NCBAQCB2b2lkIHR0bV9ldV9mZW5jZV9idWZmZXJfb2JqZWN0cyhzdHJ1Y3Qgd3dfYWNxdWlyZV9j dHggKnRpY2tldCwKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCBsaXN0LCBoZWFkKSB7CiAJ CWJvID0gZW50cnktPmJvOwogCQlpZiAoZW50cnktPm51bV9zaGFyZWQpCi0JCQlyZXNlcnZhdGlv bl9vYmplY3RfYWRkX3NoYXJlZF9mZW5jZShiby0+cmVzdiwgZmVuY2UpOworCQkJcmVzZXJ2YXRp b25fb2JqZWN0X2FkZF9zaGFyZWRfZmVuY2UoYm8tPmJhc2UucmVzdiwgZmVuY2UpOwogCQllbHNl Ci0JCQlyZXNlcnZhdGlvbl9vYmplY3RfYWRkX2V4Y2xfZmVuY2UoYm8tPnJlc3YsIGZlbmNlKTsK KwkJCXJlc2VydmF0aW9uX29iamVjdF9hZGRfZXhjbF9mZW5jZShiby0+YmFzZS5yZXN2LCBmZW5j ZSk7CiAJCWlmIChsaXN0X2VtcHR5KCZiby0+bHJ1KSkKIAkJCXR0bV9ib19hZGRfdG9fbHJ1KGJv KTsKIAkJZWxzZQogCQkJdHRtX2JvX21vdmVfdG9fbHJ1X3RhaWwoYm8sIE5VTEwpOwotCQlyZXNl cnZhdGlvbl9vYmplY3RfdW5sb2NrKGJvLT5yZXN2KTsKKwkJcmVzZXJ2YXRpb25fb2JqZWN0X3Vu bG9jayhiby0+YmFzZS5yZXN2KTsKIAl9CiAJc3Bpbl91bmxvY2soJmdsb2ItPmxydV9sb2NrKTsK IAlpZiAodGlja2V0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fdHQuYyBi L2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX3R0LmMKaW5kZXggZTNhMDY5MTU4MmZmLi4wMGI0YTMz Mzc4NDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX3R0LmMKKysrIGIvZHJp dmVycy9ncHUvZHJtL3R0bS90dG1fdHQuYwpAQCAtNDgsNyArNDgsNyBAQCBpbnQgdHRtX3R0X2Ny ZWF0ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBib29sIHplcm9fYWxsb2MpCiAJc3Ry dWN0IHR0bV9ib19kZXZpY2UgKmJkZXYgPSBiby0+YmRldjsKIAl1aW50MzJfdCBwYWdlX2ZsYWdz ID0gMDsKIAotCXJlc2VydmF0aW9uX29iamVjdF9hc3NlcnRfaGVsZChiby0+cmVzdik7CisJcmVz ZXJ2YXRpb25fb2JqZWN0X2Fzc2VydF9oZWxkKGJvLT5iYXNlLnJlc3YpOwogCiAJaWYgKGJkZXYt Pm5lZWRfZG1hMzIpCiAJCXBhZ2VfZmxhZ3MgfD0gVFRNX1BBR0VfRkxBR19ETUEzMjsKLS0gCjIu MTguMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs