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=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 33D71C47089 for ; Thu, 27 May 2021 14:13:55 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C1C19613CA for ; Thu, 27 May 2021 14:13:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C1C19613CA Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 66B236E906; Thu, 27 May 2021 14:13:47 +0000 (UTC) Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by gabe.freedesktop.org (Postfix) with ESMTPS id 652376E8BC for ; Thu, 27 May 2021 14:13:46 +0000 (UTC) Received: by mail-wr1-x42c.google.com with SMTP id x8so18504wrq.9 for ; Thu, 27 May 2021 07:13:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0gJ0EhPNdCNzK20cvZzaw98VrCAQrfDkYIzGvwsH1A4=; b=Ra0iM7vH/R0ek2CNebr7jKzfK/6o/toVlQzwHdNGsX7IvPeGkrvdP3l30R/E32XY60 Y54fm9tiVqgmh04Ve68+CSR35fKLaINSgJGbkm/EtbWByAnEiiv41uqfYwThrFe9iTzS rV0TL7XtwPbDozyXSrweIv5zCRODkuAPImyBw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0gJ0EhPNdCNzK20cvZzaw98VrCAQrfDkYIzGvwsH1A4=; b=cz6UYkp7zlBVe+VH2srFcL/25Xbn8XWfLwCpdVMvqSDJSmzzl1slSaeXhIv1n4kydn VdzO0YfBPhYo4tUIV0f1RCa1CyIlCsfXaykOmia/6bOo8YFwXmG4V0kQjy6EfIPjVM31 UUt4VgCxxOPa0jEQwbD+HqvKjY4Ix0L42lru7zl6xAnlLAFV26lTw1LiC/0LWpJnFZaY dO1z25pGtA5pSq5vUPbnJjGrGAfh6GuU2e6v1+0vkJD5Oak6F+YwAbZ4oEmb6ke/fry7 yuODp/QDlleRCe9XPWHpPCU/uwa+Jc0ilAK1DxCmtFEF8omFWYCWixrS40Q+V+hJOoS8 W3Lg== X-Gm-Message-State: AOAM533x74Gn3jW3h/Tn0AgsDyhVqypz4qD9WYabeKldDHKXgRWxXp4c kn1E0xom9BZC9x3MOq+mN3vOW3llWmwCxA== X-Google-Smtp-Source: ABdhPJzqxcCM4afV72tqEiJBV1WMbFyXgJW1Z85RT95iJlEYhSQM/BxOujyWucaB8gLz3SQhLj8TTw== X-Received: by 2002:a05:6000:108f:: with SMTP id y15mr3704988wrw.115.1622124825104; Thu, 27 May 2021 07:13:45 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id x10sm3381136wrt.65.2021.05.27.07.13.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 27 May 2021 07:13:44 -0700 (PDT) From: Daniel Vetter To: Intel Graphics Development Subject: [PATCH 2/4] drm/vgem: use shmem helpers Date: Thu, 27 May 2021 16:13:35 +0200 Message-Id: <20210527141337.3857901-3-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.31.0 In-Reply-To: <20210527141337.3857901-1-daniel.vetter@ffwll.ch> References: <20210527141337.3857901-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Daniel Vetter , DRI Development , Melissa Wen , Thomas Zimmermann , Daniel Vetter , Chris Wilson , =?UTF-8?q?Christian=20K=C3=B6nig?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Aside from deleting lots of code the real motivation here is to switch the mmap over to VM_PFNMAP, to be more consistent with what real gpu drivers do. They're all VM_PFNMP, which means get_user_pages doesn't work, and even if you try and there's a struct page behind that, touching it and mucking around with its refcount can upset drivers real bad. v2: Review from Thomas: - sort #include - drop more dead code that I didn't spot somehow v3: select DRM_GEM_SHMEM_HELPER to make it build (intel-gfx-ci) Cc: Thomas Zimmermann Acked-by: Thomas Zimmermann Cc: John Stultz Cc: Sumit Semwal Cc: "Christian König" Signed-off-by: Daniel Vetter Cc: Melissa Wen Cc: Chris Wilson --- drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/vgem/vgem_drv.c | 340 +------------------------------- 2 files changed, 4 insertions(+), 337 deletions(-) diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index d3a9ca4b1cec..1c24de03547e 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -269,6 +269,7 @@ source "drivers/gpu/drm/kmb/Kconfig" config DRM_VGEM tristate "Virtual GEM provider" depends on DRM + select DRM_GEM_SHMEM_HELPER help Choose this option to get a virtual graphics memory manager, as used by Mesa's software renderer for enhanced performance. diff --git a/drivers/gpu/drm/vgem/vgem_drv.c b/drivers/gpu/drm/vgem/vgem_drv.c index a0e75f1d5d01..b1b3a5ffc542 100644 --- a/drivers/gpu/drm/vgem/vgem_drv.c +++ b/drivers/gpu/drm/vgem/vgem_drv.c @@ -38,6 +38,7 @@ #include #include +#include #include #include #include @@ -50,87 +51,11 @@ #define DRIVER_MAJOR 1 #define DRIVER_MINOR 0 -static const struct drm_gem_object_funcs vgem_gem_object_funcs; - static struct vgem_device { struct drm_device drm; struct platform_device *platform; } *vgem_device; -static void vgem_gem_free_object(struct drm_gem_object *obj) -{ - struct drm_vgem_gem_object *vgem_obj = to_vgem_bo(obj); - - kvfree(vgem_obj->pages); - mutex_destroy(&vgem_obj->pages_lock); - - if (obj->import_attach) - drm_prime_gem_destroy(obj, vgem_obj->table); - - drm_gem_object_release(obj); - kfree(vgem_obj); -} - -static vm_fault_t vgem_gem_fault(struct vm_fault *vmf) -{ - struct vm_area_struct *vma = vmf->vma; - struct drm_vgem_gem_object *obj = vma->vm_private_data; - /* We don't use vmf->pgoff since that has the fake offset */ - unsigned long vaddr = vmf->address; - vm_fault_t ret = VM_FAULT_SIGBUS; - loff_t num_pages; - pgoff_t page_offset; - page_offset = (vaddr - vma->vm_start) >> PAGE_SHIFT; - - num_pages = DIV_ROUND_UP(obj->base.size, PAGE_SIZE); - - if (page_offset >= num_pages) - return VM_FAULT_SIGBUS; - - mutex_lock(&obj->pages_lock); - if (obj->pages) { - get_page(obj->pages[page_offset]); - vmf->page = obj->pages[page_offset]; - ret = 0; - } - mutex_unlock(&obj->pages_lock); - if (ret) { - struct page *page; - - page = shmem_read_mapping_page( - file_inode(obj->base.filp)->i_mapping, - page_offset); - if (!IS_ERR(page)) { - vmf->page = page; - ret = 0; - } else switch (PTR_ERR(page)) { - case -ENOSPC: - case -ENOMEM: - ret = VM_FAULT_OOM; - break; - case -EBUSY: - ret = VM_FAULT_RETRY; - break; - case -EFAULT: - case -EINVAL: - ret = VM_FAULT_SIGBUS; - break; - default: - WARN_ON(PTR_ERR(page)); - ret = VM_FAULT_SIGBUS; - break; - } - - } - return ret; -} - -static const struct vm_operations_struct vgem_gem_vm_ops = { - .fault = vgem_gem_fault, - .open = drm_gem_vm_open, - .close = drm_gem_vm_close, -}; - static int vgem_open(struct drm_device *dev, struct drm_file *file) { struct vgem_file *vfile; @@ -159,265 +84,12 @@ static void vgem_postclose(struct drm_device *dev, struct drm_file *file) kfree(vfile); } -static struct drm_vgem_gem_object *__vgem_gem_create(struct drm_device *dev, - unsigned long size) -{ - struct drm_vgem_gem_object *obj; - int ret; - - obj = kzalloc(sizeof(*obj), GFP_KERNEL); - if (!obj) - return ERR_PTR(-ENOMEM); - - obj->base.funcs = &vgem_gem_object_funcs; - - ret = drm_gem_object_init(dev, &obj->base, roundup(size, PAGE_SIZE)); - if (ret) { - kfree(obj); - return ERR_PTR(ret); - } - - mutex_init(&obj->pages_lock); - - return obj; -} - -static void __vgem_gem_destroy(struct drm_vgem_gem_object *obj) -{ - drm_gem_object_release(&obj->base); - kfree(obj); -} - -static struct drm_gem_object *vgem_gem_create(struct drm_device *dev, - struct drm_file *file, - unsigned int *handle, - unsigned long size) -{ - struct drm_vgem_gem_object *obj; - int ret; - - obj = __vgem_gem_create(dev, size); - if (IS_ERR(obj)) - return ERR_CAST(obj); - - ret = drm_gem_handle_create(file, &obj->base, handle); - if (ret) { - drm_gem_object_put(&obj->base); - return ERR_PTR(ret); - } - - return &obj->base; -} - -static int vgem_gem_dumb_create(struct drm_file *file, struct drm_device *dev, - struct drm_mode_create_dumb *args) -{ - struct drm_gem_object *gem_object; - u64 pitch, size; - - pitch = args->width * DIV_ROUND_UP(args->bpp, 8); - size = args->height * pitch; - if (size == 0) - return -EINVAL; - - gem_object = vgem_gem_create(dev, file, &args->handle, size); - if (IS_ERR(gem_object)) - return PTR_ERR(gem_object); - - args->size = gem_object->size; - args->pitch = pitch; - - drm_gem_object_put(gem_object); - - DRM_DEBUG("Created object of size %llu\n", args->size); - - return 0; -} - static struct drm_ioctl_desc vgem_ioctls[] = { DRM_IOCTL_DEF_DRV(VGEM_FENCE_ATTACH, vgem_fence_attach_ioctl, DRM_RENDER_ALLOW), DRM_IOCTL_DEF_DRV(VGEM_FENCE_SIGNAL, vgem_fence_signal_ioctl, DRM_RENDER_ALLOW), }; -static int vgem_mmap(struct file *filp, struct vm_area_struct *vma) -{ - unsigned long flags = vma->vm_flags; - int ret; - - ret = drm_gem_mmap(filp, vma); - if (ret) - return ret; - - /* Keep the WC mmaping set by drm_gem_mmap() but our pages - * are ordinary and not special. - */ - vma->vm_flags = flags | VM_DONTEXPAND | VM_DONTDUMP; - return 0; -} - -static const struct file_operations vgem_driver_fops = { - .owner = THIS_MODULE, - .open = drm_open, - .mmap = vgem_mmap, - .poll = drm_poll, - .read = drm_read, - .unlocked_ioctl = drm_ioctl, - .compat_ioctl = drm_compat_ioctl, - .release = drm_release, -}; - -static struct page **vgem_pin_pages(struct drm_vgem_gem_object *bo) -{ - mutex_lock(&bo->pages_lock); - if (bo->pages_pin_count++ == 0) { - struct page **pages; - - pages = drm_gem_get_pages(&bo->base); - if (IS_ERR(pages)) { - bo->pages_pin_count--; - mutex_unlock(&bo->pages_lock); - return pages; - } - - bo->pages = pages; - } - mutex_unlock(&bo->pages_lock); - - return bo->pages; -} - -static void vgem_unpin_pages(struct drm_vgem_gem_object *bo) -{ - mutex_lock(&bo->pages_lock); - if (--bo->pages_pin_count == 0) { - drm_gem_put_pages(&bo->base, bo->pages, true, true); - bo->pages = NULL; - } - mutex_unlock(&bo->pages_lock); -} - -static int vgem_prime_pin(struct drm_gem_object *obj) -{ - struct drm_vgem_gem_object *bo = to_vgem_bo(obj); - long n_pages = obj->size >> PAGE_SHIFT; - struct page **pages; - - pages = vgem_pin_pages(bo); - if (IS_ERR(pages)) - return PTR_ERR(pages); - - /* Flush the object from the CPU cache so that importers can rely - * on coherent indirect access via the exported dma-address. - */ - drm_clflush_pages(pages, n_pages); - - return 0; -} - -static void vgem_prime_unpin(struct drm_gem_object *obj) -{ - struct drm_vgem_gem_object *bo = to_vgem_bo(obj); - - vgem_unpin_pages(bo); -} - -static struct sg_table *vgem_prime_get_sg_table(struct drm_gem_object *obj) -{ - struct drm_vgem_gem_object *bo = to_vgem_bo(obj); - - return drm_prime_pages_to_sg(obj->dev, bo->pages, bo->base.size >> PAGE_SHIFT); -} - -static struct drm_gem_object* vgem_prime_import(struct drm_device *dev, - struct dma_buf *dma_buf) -{ - struct vgem_device *vgem = container_of(dev, typeof(*vgem), drm); - - return drm_gem_prime_import_dev(dev, dma_buf, &vgem->platform->dev); -} - -static struct drm_gem_object *vgem_prime_import_sg_table(struct drm_device *dev, - struct dma_buf_attachment *attach, struct sg_table *sg) -{ - struct drm_vgem_gem_object *obj; - int npages; - - obj = __vgem_gem_create(dev, attach->dmabuf->size); - if (IS_ERR(obj)) - return ERR_CAST(obj); - - npages = PAGE_ALIGN(attach->dmabuf->size) / PAGE_SIZE; - - obj->table = sg; - obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL); - if (!obj->pages) { - __vgem_gem_destroy(obj); - return ERR_PTR(-ENOMEM); - } - - obj->pages_pin_count++; /* perma-pinned */ - drm_prime_sg_to_page_array(obj->table, obj->pages, npages); - return &obj->base; -} - -static int vgem_prime_vmap(struct drm_gem_object *obj, struct dma_buf_map *map) -{ - struct drm_vgem_gem_object *bo = to_vgem_bo(obj); - long n_pages = obj->size >> PAGE_SHIFT; - struct page **pages; - void *vaddr; - - pages = vgem_pin_pages(bo); - if (IS_ERR(pages)) - return PTR_ERR(pages); - - vaddr = vmap(pages, n_pages, 0, pgprot_writecombine(PAGE_KERNEL)); - if (!vaddr) - return -ENOMEM; - dma_buf_map_set_vaddr(map, vaddr); - - return 0; -} - -static void vgem_prime_vunmap(struct drm_gem_object *obj, struct dma_buf_map *map) -{ - struct drm_vgem_gem_object *bo = to_vgem_bo(obj); - - vunmap(map->vaddr); - vgem_unpin_pages(bo); -} - -static int vgem_prime_mmap(struct drm_gem_object *obj, - struct vm_area_struct *vma) -{ - int ret; - - if (obj->size < vma->vm_end - vma->vm_start) - return -EINVAL; - - if (!obj->filp) - return -ENODEV; - - ret = call_mmap(obj->filp, vma); - if (ret) - return ret; - - vma_set_file(vma, obj->filp); - vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; - vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags)); - - return 0; -} - -static const struct drm_gem_object_funcs vgem_gem_object_funcs = { - .free = vgem_gem_free_object, - .pin = vgem_prime_pin, - .unpin = vgem_prime_unpin, - .get_sg_table = vgem_prime_get_sg_table, - .vmap = vgem_prime_vmap, - .vunmap = vgem_prime_vunmap, - .vm_ops = &vgem_gem_vm_ops, -}; +DEFINE_DRM_GEM_FOPS(vgem_driver_fops); static const struct drm_driver vgem_driver = { .driver_features = DRIVER_GEM | DRIVER_RENDER, @@ -427,13 +99,7 @@ static const struct drm_driver vgem_driver = { .num_ioctls = ARRAY_SIZE(vgem_ioctls), .fops = &vgem_driver_fops, - .dumb_create = vgem_gem_dumb_create, - - .prime_handle_to_fd = drm_gem_prime_handle_to_fd, - .prime_fd_to_handle = drm_gem_prime_fd_to_handle, - .gem_prime_import = vgem_prime_import, - .gem_prime_import_sg_table = vgem_prime_import_sg_table, - .gem_prime_mmap = vgem_prime_mmap, + DRM_GEM_SHMEM_DRIVER_OPS, .name = DRIVER_NAME, .desc = DRIVER_DESC, -- 2.31.0 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=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 E24B8C4707F for ; Thu, 27 May 2021 14:13:57 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A545E613CA for ; Thu, 27 May 2021 14:13:57 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A545E613CA Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 18AC46EA2F; Thu, 27 May 2021 14:13:48 +0000 (UTC) Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by gabe.freedesktop.org (Postfix) with ESMTPS id 672D56E8CE for ; Thu, 27 May 2021 14:13:46 +0000 (UTC) Received: by mail-wr1-x42c.google.com with SMTP id f11so71069wrq.1 for ; Thu, 27 May 2021 07:13:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0gJ0EhPNdCNzK20cvZzaw98VrCAQrfDkYIzGvwsH1A4=; b=Ra0iM7vH/R0ek2CNebr7jKzfK/6o/toVlQzwHdNGsX7IvPeGkrvdP3l30R/E32XY60 Y54fm9tiVqgmh04Ve68+CSR35fKLaINSgJGbkm/EtbWByAnEiiv41uqfYwThrFe9iTzS rV0TL7XtwPbDozyXSrweIv5zCRODkuAPImyBw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0gJ0EhPNdCNzK20cvZzaw98VrCAQrfDkYIzGvwsH1A4=; b=uDmY5p1XrNdib/0kYGrhb+IgkZr8S5kjG7P/NmuG7wt5t4xIgbB1dxcaq2NSulHWhv sfy3RWQvQioQVoy8tcuV0r0LhhaXmnecwGEdFlFFyK4U/or68Irhgsi9IIgGPn200j/R eXLwIcOJhnqI6OOYOGuKrYY8sEDOnIYUKKnpdLXKSfDpyoXe4UP+PaDxsy39TdXKv9Nf H5B42eLK7AtLCcSft567v+09SEUbHKdBmHRzaUxj+PySOrfy61CenRQxn+efUHPKIrX+ AFxR2HpnlNbFKEU1bkNJ8daMH3cJ7UN+0XvCm0GXvxJHrAESYAwxAUw3NkEwfOPXvP1f 06dA== X-Gm-Message-State: AOAM531e7PCWZZGeYZhKD0iPjpBjihrOrLHTgFSeN3CmVAeeGIOsDh5X SsRdg6znPBStMrrUShZZ3cnEoke5yxUqqg== X-Google-Smtp-Source: ABdhPJzqxcCM4afV72tqEiJBV1WMbFyXgJW1Z85RT95iJlEYhSQM/BxOujyWucaB8gLz3SQhLj8TTw== X-Received: by 2002:a05:6000:108f:: with SMTP id y15mr3704988wrw.115.1622124825104; Thu, 27 May 2021 07:13:45 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id x10sm3381136wrt.65.2021.05.27.07.13.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 27 May 2021 07:13:44 -0700 (PDT) From: Daniel Vetter To: Intel Graphics Development Date: Thu, 27 May 2021 16:13:35 +0200 Message-Id: <20210527141337.3857901-3-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.31.0 In-Reply-To: <20210527141337.3857901-1-daniel.vetter@ffwll.ch> References: <20210527141337.3857901-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 2/4] drm/vgem: use shmem helpers X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Daniel Vetter , DRI Development , Sumit Semwal , Melissa Wen , John Stultz , Thomas Zimmermann , Daniel Vetter , Chris Wilson , =?UTF-8?q?Christian=20K=C3=B6nig?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" QXNpZGUgZnJvbSBkZWxldGluZyBsb3RzIG9mIGNvZGUgdGhlIHJlYWwgbW90aXZhdGlvbiBoZXJl IGlzIHRvIHN3aXRjaAp0aGUgbW1hcCBvdmVyIHRvIFZNX1BGTk1BUCwgdG8gYmUgbW9yZSBjb25z aXN0ZW50IHdpdGggd2hhdCByZWFsIGdwdQpkcml2ZXJzIGRvLiBUaGV5J3JlIGFsbCBWTV9QRk5N UCwgd2hpY2ggbWVhbnMgZ2V0X3VzZXJfcGFnZXMgZG9lc24ndAp3b3JrLCBhbmQgZXZlbiBpZiB5 b3UgdHJ5IGFuZCB0aGVyZSdzIGEgc3RydWN0IHBhZ2UgYmVoaW5kIHRoYXQsCnRvdWNoaW5nIGl0 IGFuZCBtdWNraW5nIGFyb3VuZCB3aXRoIGl0cyByZWZjb3VudCBjYW4gdXBzZXQgZHJpdmVycwpy ZWFsIGJhZC4KCnYyOiBSZXZpZXcgZnJvbSBUaG9tYXM6Ci0gc29ydCAjaW5jbHVkZQotIGRyb3Ag bW9yZSBkZWFkIGNvZGUgdGhhdCBJIGRpZG4ndCBzcG90IHNvbWVob3cKCnYzOiBzZWxlY3QgRFJN X0dFTV9TSE1FTV9IRUxQRVIgdG8gbWFrZSBpdCBidWlsZCAoaW50ZWwtZ2Z4LWNpKQoKQ2M6IFRo b21hcyBaaW1tZXJtYW5uIDx0emltbWVybWFubkBzdXNlLmRlPgpBY2tlZC1ieTogVGhvbWFzIFpp bW1lcm1hbm4gPHR6aW1tZXJtYW5uQHN1c2UuZGU+CkNjOiBKb2huIFN0dWx0eiA8am9obi5zdHVs dHpAbGluYXJvLm9yZz4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+ CkNjOiAiQ2hyaXN0aWFuIEvDtm5pZyIgPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KU2lnbmVk LW9mZi1ieTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+CkNjOiBNZWxp c3NhIFdlbiA8bWVsaXNzYS5zcndAZ21haWwuY29tPgpDYzogQ2hyaXMgV2lsc29uIDxjaHJpc0Bj aHJpcy13aWxzb24uY28udWs+Ci0tLQogZHJpdmVycy9ncHUvZHJtL0tjb25maWcgICAgICAgICB8 ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0vdmdlbS92Z2VtX2Rydi5jIHwgMzQwICstLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwg MzM3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnIGIv ZHJpdmVycy9ncHUvZHJtL0tjb25maWcKaW5kZXggZDNhOWNhNGIxY2VjLi4xYzI0ZGUwMzU0N2Ug MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9LY29uZmlnCkBAIC0yNjksNiArMjY5LDcgQEAgc291cmNlICJkcml2ZXJzL2dwdS9kcm0va21i L0tjb25maWciCiBjb25maWcgRFJNX1ZHRU0KIAl0cmlzdGF0ZSAiVmlydHVhbCBHRU0gcHJvdmlk ZXIiCiAJZGVwZW5kcyBvbiBEUk0KKwlzZWxlY3QgRFJNX0dFTV9TSE1FTV9IRUxQRVIKIAloZWxw CiAJICBDaG9vc2UgdGhpcyBvcHRpb24gdG8gZ2V0IGEgdmlydHVhbCBncmFwaGljcyBtZW1vcnkg bWFuYWdlciwKIAkgIGFzIHVzZWQgYnkgTWVzYSdzIHNvZnR3YXJlIHJlbmRlcmVyIGZvciBlbmhh bmNlZCBwZXJmb3JtYW5jZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS92Z2VtL3ZnZW1f ZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0vdmdlbS92Z2VtX2Rydi5jCmluZGV4IGEwZTc1ZjFkNWQw MS4uYjFiM2E1ZmZjNTQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdmdlbS92Z2VtX2Ry di5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS92Z2VtL3ZnZW1fZHJ2LmMKQEAgLTM4LDYgKzM4LDcg QEAKIAogI2luY2x1ZGUgPGRybS9kcm1fZHJ2Lmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9maWxlLmg+ CisjaW5jbHVkZSA8ZHJtL2RybV9nZW1fc2htZW1faGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2Ry bV9pb2N0bC5oPgogI2luY2x1ZGUgPGRybS9kcm1fbWFuYWdlZC5oPgogI2luY2x1ZGUgPGRybS9k cm1fcHJpbWUuaD4KQEAgLTUwLDg3ICs1MSwxMSBAQAogI2RlZmluZSBEUklWRVJfTUFKT1IJMQog I2RlZmluZSBEUklWRVJfTUlOT1IJMAogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRybV9nZW1fb2Jq ZWN0X2Z1bmNzIHZnZW1fZ2VtX29iamVjdF9mdW5jczsKLQogc3RhdGljIHN0cnVjdCB2Z2VtX2Rl dmljZSB7CiAJc3RydWN0IGRybV9kZXZpY2UgZHJtOwogCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBsYXRmb3JtOwogfSAqdmdlbV9kZXZpY2U7CiAKLXN0YXRpYyB2b2lkIHZnZW1fZ2VtX2ZyZWVf b2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQotewotCXN0cnVjdCBkcm1fdmdlbV9n ZW1fb2JqZWN0ICp2Z2VtX29iaiA9IHRvX3ZnZW1fYm8ob2JqKTsKLQotCWt2ZnJlZSh2Z2VtX29i ai0+cGFnZXMpOwotCW11dGV4X2Rlc3Ryb3koJnZnZW1fb2JqLT5wYWdlc19sb2NrKTsKLQotCWlm IChvYmotPmltcG9ydF9hdHRhY2gpCi0JCWRybV9wcmltZV9nZW1fZGVzdHJveShvYmosIHZnZW1f b2JqLT50YWJsZSk7Ci0KLQlkcm1fZ2VtX29iamVjdF9yZWxlYXNlKG9iaik7Ci0Ja2ZyZWUodmdl bV9vYmopOwotfQotCi1zdGF0aWMgdm1fZmF1bHRfdCB2Z2VtX2dlbV9mYXVsdChzdHJ1Y3Qgdm1f ZmF1bHQgKnZtZikKLXsKLQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSA9IHZtZi0+dm1hOwot CXN0cnVjdCBkcm1fdmdlbV9nZW1fb2JqZWN0ICpvYmogPSB2bWEtPnZtX3ByaXZhdGVfZGF0YTsK LQkvKiBXZSBkb24ndCB1c2Ugdm1mLT5wZ29mZiBzaW5jZSB0aGF0IGhhcyB0aGUgZmFrZSBvZmZz ZXQgKi8KLQl1bnNpZ25lZCBsb25nIHZhZGRyID0gdm1mLT5hZGRyZXNzOwotCXZtX2ZhdWx0X3Qg cmV0ID0gVk1fRkFVTFRfU0lHQlVTOwotCWxvZmZfdCBudW1fcGFnZXM7Ci0JcGdvZmZfdCBwYWdl X29mZnNldDsKLQlwYWdlX29mZnNldCA9ICh2YWRkciAtIHZtYS0+dm1fc3RhcnQpID4+IFBBR0Vf U0hJRlQ7Ci0KLQludW1fcGFnZXMgPSBESVZfUk9VTkRfVVAob2JqLT5iYXNlLnNpemUsIFBBR0Vf U0laRSk7Ci0KLQlpZiAocGFnZV9vZmZzZXQgPj0gbnVtX3BhZ2VzKQotCQlyZXR1cm4gVk1fRkFV TFRfU0lHQlVTOwotCi0JbXV0ZXhfbG9jaygmb2JqLT5wYWdlc19sb2NrKTsKLQlpZiAob2JqLT5w YWdlcykgewotCQlnZXRfcGFnZShvYmotPnBhZ2VzW3BhZ2Vfb2Zmc2V0XSk7Ci0JCXZtZi0+cGFn ZSA9IG9iai0+cGFnZXNbcGFnZV9vZmZzZXRdOwotCQlyZXQgPSAwOwotCX0KLQltdXRleF91bmxv Y2soJm9iai0+cGFnZXNfbG9jayk7Ci0JaWYgKHJldCkgewotCQlzdHJ1Y3QgcGFnZSAqcGFnZTsK LQotCQlwYWdlID0gc2htZW1fcmVhZF9tYXBwaW5nX3BhZ2UoCi0JCQkJCWZpbGVfaW5vZGUob2Jq LT5iYXNlLmZpbHApLT5pX21hcHBpbmcsCi0JCQkJCXBhZ2Vfb2Zmc2V0KTsKLQkJaWYgKCFJU19F UlIocGFnZSkpIHsKLQkJCXZtZi0+cGFnZSA9IHBhZ2U7Ci0JCQlyZXQgPSAwOwotCQl9IGVsc2Ug c3dpdGNoIChQVFJfRVJSKHBhZ2UpKSB7Ci0JCQljYXNlIC1FTk9TUEM6Ci0JCQljYXNlIC1FTk9N RU06Ci0JCQkJcmV0ID0gVk1fRkFVTFRfT09NOwotCQkJCWJyZWFrOwotCQkJY2FzZSAtRUJVU1k6 Ci0JCQkJcmV0ID0gVk1fRkFVTFRfUkVUUlk7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIC1FRkFVTFQ6 Ci0JCQljYXNlIC1FSU5WQUw6Ci0JCQkJcmV0ID0gVk1fRkFVTFRfU0lHQlVTOwotCQkJCWJyZWFr OwotCQkJZGVmYXVsdDoKLQkJCQlXQVJOX09OKFBUUl9FUlIocGFnZSkpOwotCQkJCXJldCA9IFZN X0ZBVUxUX1NJR0JVUzsKLQkJCQlicmVhazsKLQkJfQotCi0JfQotCXJldHVybiByZXQ7Ci19Ci0K LXN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm1fb3BlcmF0aW9uc19zdHJ1Y3QgdmdlbV9nZW1fdm1fb3Bz ID0gewotCS5mYXVsdCA9IHZnZW1fZ2VtX2ZhdWx0LAotCS5vcGVuID0gZHJtX2dlbV92bV9vcGVu LAotCS5jbG9zZSA9IGRybV9nZW1fdm1fY2xvc2UsCi19OwotCiBzdGF0aWMgaW50IHZnZW1fb3Bl bihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGUpCiB7CiAJc3Ry dWN0IHZnZW1fZmlsZSAqdmZpbGU7CkBAIC0xNTksMjY1ICs4NCwxMiBAQCBzdGF0aWMgdm9pZCB2 Z2VtX3Bvc3RjbG9zZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2ZpbGUgKmZp bGUpCiAJa2ZyZWUodmZpbGUpOwogfQogCi1zdGF0aWMgc3RydWN0IGRybV92Z2VtX2dlbV9vYmpl Y3QgKl9fdmdlbV9nZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCi0JCQkJCQl1bnNp Z25lZCBsb25nIHNpemUpCi17Ci0Jc3RydWN0IGRybV92Z2VtX2dlbV9vYmplY3QgKm9iajsKLQlp bnQgcmV0OwotCi0Jb2JqID0ga3phbGxvYyhzaXplb2YoKm9iaiksIEdGUF9LRVJORUwpOwotCWlm ICghb2JqKQotCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKLQotCW9iai0+YmFzZS5mdW5jcyA9 ICZ2Z2VtX2dlbV9vYmplY3RfZnVuY3M7Ci0KLQlyZXQgPSBkcm1fZ2VtX29iamVjdF9pbml0KGRl diwgJm9iai0+YmFzZSwgcm91bmR1cChzaXplLCBQQUdFX1NJWkUpKTsKLQlpZiAocmV0KSB7Ci0J CWtmcmVlKG9iaik7Ci0JCXJldHVybiBFUlJfUFRSKHJldCk7Ci0JfQotCi0JbXV0ZXhfaW5pdCgm b2JqLT5wYWdlc19sb2NrKTsKLQotCXJldHVybiBvYmo7Ci19Ci0KLXN0YXRpYyB2b2lkIF9fdmdl bV9nZW1fZGVzdHJveShzdHJ1Y3QgZHJtX3ZnZW1fZ2VtX29iamVjdCAqb2JqKQotewotCWRybV9n ZW1fb2JqZWN0X3JlbGVhc2UoJm9iai0+YmFzZSk7Ci0Ja2ZyZWUob2JqKTsKLX0KLQotc3RhdGlj IHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdmdlbV9nZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsCi0JCQkJCSAgICAgIHN0cnVjdCBkcm1fZmlsZSAqZmlsZSwKLQkJCQkJICAgICAgdW5z aWduZWQgaW50ICpoYW5kbGUsCi0JCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSkKLXsKLQlz dHJ1Y3QgZHJtX3ZnZW1fZ2VtX29iamVjdCAqb2JqOwotCWludCByZXQ7Ci0KLQlvYmogPSBfX3Zn ZW1fZ2VtX2NyZWF0ZShkZXYsIHNpemUpOwotCWlmIChJU19FUlIob2JqKSkKLQkJcmV0dXJuIEVS Ul9DQVNUKG9iaik7Ci0KLQlyZXQgPSBkcm1fZ2VtX2hhbmRsZV9jcmVhdGUoZmlsZSwgJm9iai0+ YmFzZSwgaGFuZGxlKTsKLQlpZiAocmV0KSB7Ci0JCWRybV9nZW1fb2JqZWN0X3B1dCgmb2JqLT5i YXNlKTsKLQkJcmV0dXJuIEVSUl9QVFIocmV0KTsKLQl9Ci0KLQlyZXR1cm4gJm9iai0+YmFzZTsK LX0KLQotc3RhdGljIGludCB2Z2VtX2dlbV9kdW1iX2NyZWF0ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZp bGUsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCi0JCQkJc3RydWN0IGRybV9tb2RlX2NyZWF0ZV9k dW1iICphcmdzKQotewotCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iamVjdDsKLQl1NjQg cGl0Y2gsIHNpemU7Ci0KLQlwaXRjaCA9IGFyZ3MtPndpZHRoICogRElWX1JPVU5EX1VQKGFyZ3Mt PmJwcCwgOCk7Ci0Jc2l6ZSA9IGFyZ3MtPmhlaWdodCAqIHBpdGNoOwotCWlmIChzaXplID09IDAp Ci0JCXJldHVybiAtRUlOVkFMOwotCi0JZ2VtX29iamVjdCA9IHZnZW1fZ2VtX2NyZWF0ZShkZXYs IGZpbGUsICZhcmdzLT5oYW5kbGUsIHNpemUpOwotCWlmIChJU19FUlIoZ2VtX29iamVjdCkpCi0J CXJldHVybiBQVFJfRVJSKGdlbV9vYmplY3QpOwotCi0JYXJncy0+c2l6ZSA9IGdlbV9vYmplY3Qt PnNpemU7Ci0JYXJncy0+cGl0Y2ggPSBwaXRjaDsKLQotCWRybV9nZW1fb2JqZWN0X3B1dChnZW1f b2JqZWN0KTsKLQotCURSTV9ERUJVRygiQ3JlYXRlZCBvYmplY3Qgb2Ygc2l6ZSAlbGx1XG4iLCBh cmdzLT5zaXplKTsKLQotCXJldHVybiAwOwotfQotCiBzdGF0aWMgc3RydWN0IGRybV9pb2N0bF9k ZXNjIHZnZW1faW9jdGxzW10gPSB7CiAJRFJNX0lPQ1RMX0RFRl9EUlYoVkdFTV9GRU5DRV9BVFRB Q0gsIHZnZW1fZmVuY2VfYXR0YWNoX2lvY3RsLCBEUk1fUkVOREVSX0FMTE9XKSwKIAlEUk1fSU9D VExfREVGX0RSVihWR0VNX0ZFTkNFX1NJR05BTCwgdmdlbV9mZW5jZV9zaWduYWxfaW9jdGwsIERS TV9SRU5ERVJfQUxMT1cpLAogfTsKIAotc3RhdGljIGludCB2Z2VtX21tYXAoc3RydWN0IGZpbGUg KmZpbHAsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQotewotCXVuc2lnbmVkIGxvbmcgZmxh Z3MgPSB2bWEtPnZtX2ZsYWdzOwotCWludCByZXQ7Ci0KLQlyZXQgPSBkcm1fZ2VtX21tYXAoZmls cCwgdm1hKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JLyogS2VlcCB0aGUgV0MgbW1h cGluZyBzZXQgYnkgZHJtX2dlbV9tbWFwKCkgYnV0IG91ciBwYWdlcwotCSAqIGFyZSBvcmRpbmFy eSBhbmQgbm90IHNwZWNpYWwuCi0JICovCi0Jdm1hLT52bV9mbGFncyA9IGZsYWdzIHwgVk1fRE9O VEVYUEFORCB8IFZNX0RPTlREVU1QOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgY29uc3Qgc3Ry dWN0IGZpbGVfb3BlcmF0aW9ucyB2Z2VtX2RyaXZlcl9mb3BzID0gewotCS5vd25lcgkJPSBUSElT X01PRFVMRSwKLQkub3BlbgkJPSBkcm1fb3BlbiwKLQkubW1hcAkJPSB2Z2VtX21tYXAsCi0JLnBv bGwJCT0gZHJtX3BvbGwsCi0JLnJlYWQJCT0gZHJtX3JlYWQsCi0JLnVubG9ja2VkX2lvY3RsID0g ZHJtX2lvY3RsLAotCS5jb21wYXRfaW9jdGwJPSBkcm1fY29tcGF0X2lvY3RsLAotCS5yZWxlYXNl CT0gZHJtX3JlbGVhc2UsCi19OwotCi1zdGF0aWMgc3RydWN0IHBhZ2UgKip2Z2VtX3Bpbl9wYWdl cyhzdHJ1Y3QgZHJtX3ZnZW1fZ2VtX29iamVjdCAqYm8pCi17Ci0JbXV0ZXhfbG9jaygmYm8tPnBh Z2VzX2xvY2spOwotCWlmIChiby0+cGFnZXNfcGluX2NvdW50KysgPT0gMCkgewotCQlzdHJ1Y3Qg cGFnZSAqKnBhZ2VzOwotCi0JCXBhZ2VzID0gZHJtX2dlbV9nZXRfcGFnZXMoJmJvLT5iYXNlKTsK LQkJaWYgKElTX0VSUihwYWdlcykpIHsKLQkJCWJvLT5wYWdlc19waW5fY291bnQtLTsKLQkJCW11 dGV4X3VubG9jaygmYm8tPnBhZ2VzX2xvY2spOwotCQkJcmV0dXJuIHBhZ2VzOwotCQl9Ci0KLQkJ Ym8tPnBhZ2VzID0gcGFnZXM7Ci0JfQotCW11dGV4X3VubG9jaygmYm8tPnBhZ2VzX2xvY2spOwot Ci0JcmV0dXJuIGJvLT5wYWdlczsKLX0KLQotc3RhdGljIHZvaWQgdmdlbV91bnBpbl9wYWdlcyhz dHJ1Y3QgZHJtX3ZnZW1fZ2VtX29iamVjdCAqYm8pCi17Ci0JbXV0ZXhfbG9jaygmYm8tPnBhZ2Vz X2xvY2spOwotCWlmICgtLWJvLT5wYWdlc19waW5fY291bnQgPT0gMCkgewotCQlkcm1fZ2VtX3B1 dF9wYWdlcygmYm8tPmJhc2UsIGJvLT5wYWdlcywgdHJ1ZSwgdHJ1ZSk7Ci0JCWJvLT5wYWdlcyA9 IE5VTEw7Ci0JfQotCW11dGV4X3VubG9jaygmYm8tPnBhZ2VzX2xvY2spOwotfQotCi1zdGF0aWMg aW50IHZnZW1fcHJpbWVfcGluKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQotewotCXN0cnVj dCBkcm1fdmdlbV9nZW1fb2JqZWN0ICpibyA9IHRvX3ZnZW1fYm8ob2JqKTsKLQlsb25nIG5fcGFn ZXMgPSBvYmotPnNpemUgPj4gUEFHRV9TSElGVDsKLQlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOwotCi0J cGFnZXMgPSB2Z2VtX3Bpbl9wYWdlcyhibyk7Ci0JaWYgKElTX0VSUihwYWdlcykpCi0JCXJldHVy biBQVFJfRVJSKHBhZ2VzKTsKLQotCS8qIEZsdXNoIHRoZSBvYmplY3QgZnJvbSB0aGUgQ1BVIGNh Y2hlIHNvIHRoYXQgaW1wb3J0ZXJzIGNhbiByZWx5Ci0JICogb24gY29oZXJlbnQgaW5kaXJlY3Qg YWNjZXNzIHZpYSB0aGUgZXhwb3J0ZWQgZG1hLWFkZHJlc3MuCi0JICovCi0JZHJtX2NsZmx1c2hf cGFnZXMocGFnZXMsIG5fcGFnZXMpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB2b2lkIHZn ZW1fcHJpbWVfdW5waW4oc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmopCi17Ci0Jc3RydWN0IGRy bV92Z2VtX2dlbV9vYmplY3QgKmJvID0gdG9fdmdlbV9ibyhvYmopOwotCi0JdmdlbV91bnBpbl9w YWdlcyhibyk7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKnZnZW1fcHJpbWVfZ2V0X3Nn X3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQotewotCXN0cnVjdCBkcm1fdmdlbV9n ZW1fb2JqZWN0ICpibyA9IHRvX3ZnZW1fYm8ob2JqKTsKLQotCXJldHVybiBkcm1fcHJpbWVfcGFn ZXNfdG9fc2cob2JqLT5kZXYsIGJvLT5wYWdlcywgYm8tPmJhc2Uuc2l6ZSA+PiBQQUdFX1NISUZU KTsKLX0KLQotc3RhdGljIHN0cnVjdCBkcm1fZ2VtX29iamVjdCogdmdlbV9wcmltZV9pbXBvcnQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwKLQkJCQkJCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmKQot ewotCXN0cnVjdCB2Z2VtX2RldmljZSAqdmdlbSA9IGNvbnRhaW5lcl9vZihkZXYsIHR5cGVvZigq dmdlbSksIGRybSk7Ci0KLQlyZXR1cm4gZHJtX2dlbV9wcmltZV9pbXBvcnRfZGV2KGRldiwgZG1h X2J1ZiwgJnZnZW0tPnBsYXRmb3JtLT5kZXYpOwotfQotCi1zdGF0aWMgc3RydWN0IGRybV9nZW1f b2JqZWN0ICp2Z2VtX3ByaW1lX2ltcG9ydF9zZ190YWJsZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LAotCQkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLCBzdHJ1Y3Qgc2dfdGFibGUg KnNnKQotewotCXN0cnVjdCBkcm1fdmdlbV9nZW1fb2JqZWN0ICpvYmo7Ci0JaW50IG5wYWdlczsK LQotCW9iaiA9IF9fdmdlbV9nZW1fY3JlYXRlKGRldiwgYXR0YWNoLT5kbWFidWYtPnNpemUpOwot CWlmIChJU19FUlIob2JqKSkKLQkJcmV0dXJuIEVSUl9DQVNUKG9iaik7Ci0KLQlucGFnZXMgPSBQ QUdFX0FMSUdOKGF0dGFjaC0+ZG1hYnVmLT5zaXplKSAvIFBBR0VfU0laRTsKLQotCW9iai0+dGFi bGUgPSBzZzsKLQlvYmotPnBhZ2VzID0ga3ZtYWxsb2NfYXJyYXkobnBhZ2VzLCBzaXplb2Yoc3Ry dWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOwotCWlmICghb2JqLT5wYWdlcykgewotCQlfX3ZnZW1f Z2VtX2Rlc3Ryb3kob2JqKTsKLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Ci0JfQotCi0Jb2Jq LT5wYWdlc19waW5fY291bnQrKzsgLyogcGVybWEtcGlubmVkICovCi0JZHJtX3ByaW1lX3NnX3Rv X3BhZ2VfYXJyYXkob2JqLT50YWJsZSwgb2JqLT5wYWdlcywgbnBhZ2VzKTsKLQlyZXR1cm4gJm9i ai0+YmFzZTsKLX0KLQotc3RhdGljIGludCB2Z2VtX3ByaW1lX3ZtYXAoc3RydWN0IGRybV9nZW1f b2JqZWN0ICpvYmosIHN0cnVjdCBkbWFfYnVmX21hcCAqbWFwKQotewotCXN0cnVjdCBkcm1fdmdl bV9nZW1fb2JqZWN0ICpibyA9IHRvX3ZnZW1fYm8ob2JqKTsKLQlsb25nIG5fcGFnZXMgPSBvYmot PnNpemUgPj4gUEFHRV9TSElGVDsKLQlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOwotCXZvaWQgKnZhZGRy OwotCi0JcGFnZXMgPSB2Z2VtX3Bpbl9wYWdlcyhibyk7Ci0JaWYgKElTX0VSUihwYWdlcykpCi0J CXJldHVybiBQVFJfRVJSKHBhZ2VzKTsKLQotCXZhZGRyID0gdm1hcChwYWdlcywgbl9wYWdlcywg MCwgcGdwcm90X3dyaXRlY29tYmluZShQQUdFX0tFUk5FTCkpOwotCWlmICghdmFkZHIpCi0JCXJl dHVybiAtRU5PTUVNOwotCWRtYV9idWZfbWFwX3NldF92YWRkcihtYXAsIHZhZGRyKTsKLQotCXJl dHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCB2Z2VtX3ByaW1lX3Z1bm1hcChzdHJ1Y3QgZHJtX2dl bV9vYmplY3QgKm9iaiwgc3RydWN0IGRtYV9idWZfbWFwICptYXApCi17Ci0Jc3RydWN0IGRybV92 Z2VtX2dlbV9vYmplY3QgKmJvID0gdG9fdmdlbV9ibyhvYmopOwotCi0JdnVubWFwKG1hcC0+dmFk ZHIpOwotCXZnZW1fdW5waW5fcGFnZXMoYm8pOwotfQotCi1zdGF0aWMgaW50IHZnZW1fcHJpbWVf bW1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaiwKLQkJCSAgIHN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqdm1hKQotewotCWludCByZXQ7Ci0KLQlpZiAob2JqLT5zaXplIDwgdm1hLT52bV9lbmQg LSB2bWEtPnZtX3N0YXJ0KQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmICghb2JqLT5maWxwKQot CQlyZXR1cm4gLUVOT0RFVjsKLQotCXJldCA9IGNhbGxfbW1hcChvYmotPmZpbHAsIHZtYSk7Ci0J aWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQotCXZtYV9zZXRfZmlsZSh2bWEsIG9iai0+ZmlscCk7 Ci0Jdm1hLT52bV9mbGFncyB8PSBWTV9ET05URVhQQU5EIHwgVk1fRE9OVERVTVA7Ci0Jdm1hLT52 bV9wYWdlX3Byb3QgPSBwZ3Byb3Rfd3JpdGVjb21iaW5lKHZtX2dldF9wYWdlX3Byb3Qodm1hLT52 bV9mbGFncykpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2dl bV9vYmplY3RfZnVuY3MgdmdlbV9nZW1fb2JqZWN0X2Z1bmNzID0gewotCS5mcmVlID0gdmdlbV9n ZW1fZnJlZV9vYmplY3QsCi0JLnBpbiA9IHZnZW1fcHJpbWVfcGluLAotCS51bnBpbiA9IHZnZW1f cHJpbWVfdW5waW4sCi0JLmdldF9zZ190YWJsZSA9IHZnZW1fcHJpbWVfZ2V0X3NnX3RhYmxlLAot CS52bWFwID0gdmdlbV9wcmltZV92bWFwLAotCS52dW5tYXAgPSB2Z2VtX3ByaW1lX3Z1bm1hcCwK LQkudm1fb3BzID0gJnZnZW1fZ2VtX3ZtX29wcywKLX07CitERUZJTkVfRFJNX0dFTV9GT1BTKHZn ZW1fZHJpdmVyX2ZvcHMpOwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9kcml2ZXIgdmdlbV9k cml2ZXIgPSB7CiAJLmRyaXZlcl9mZWF0dXJlcwkJPSBEUklWRVJfR0VNIHwgRFJJVkVSX1JFTkRF UiwKQEAgLTQyNywxMyArOTksNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9kcml2ZXIgdmdl bV9kcml2ZXIgPSB7CiAJLm51bV9pb2N0bHMgCQkJPSBBUlJBWV9TSVpFKHZnZW1faW9jdGxzKSwK IAkuZm9wcwkJCQk9ICZ2Z2VtX2RyaXZlcl9mb3BzLAogCi0JLmR1bWJfY3JlYXRlCQkJPSB2Z2Vt X2dlbV9kdW1iX2NyZWF0ZSwKLQotCS5wcmltZV9oYW5kbGVfdG9fZmQgPSBkcm1fZ2VtX3ByaW1l X2hhbmRsZV90b19mZCwKLQkucHJpbWVfZmRfdG9faGFuZGxlID0gZHJtX2dlbV9wcmltZV9mZF90 b19oYW5kbGUsCi0JLmdlbV9wcmltZV9pbXBvcnQgPSB2Z2VtX3ByaW1lX2ltcG9ydCwKLQkuZ2Vt X3ByaW1lX2ltcG9ydF9zZ190YWJsZSA9IHZnZW1fcHJpbWVfaW1wb3J0X3NnX3RhYmxlLAotCS5n ZW1fcHJpbWVfbW1hcCA9IHZnZW1fcHJpbWVfbW1hcCwKKwlEUk1fR0VNX1NITUVNX0RSSVZFUl9P UFMsCiAKIAkubmFtZQk9IERSSVZFUl9OQU1FLAogCS5kZXNjCT0gRFJJVkVSX0RFU0MsCi0tIAoy LjMxLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCklu dGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=