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 Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5ADDFC77B70 for ; Wed, 5 Apr 2023 20:24:54 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id DD8FF6B0071; Wed, 5 Apr 2023 16:24:53 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id D89846B0074; Wed, 5 Apr 2023 16:24:53 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id C2B066B0075; Wed, 5 Apr 2023 16:24:53 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0010.hostedemail.com [216.40.44.10]) by kanga.kvack.org (Postfix) with ESMTP id B319D6B0071 for ; Wed, 5 Apr 2023 16:24:53 -0400 (EDT) Received: from smtpin12.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id 8ACD9803B9 for ; Wed, 5 Apr 2023 20:24:53 +0000 (UTC) X-FDA: 80648466066.12.0017BC5 Received: from mail-lf1-f47.google.com (mail-lf1-f47.google.com [209.85.167.47]) by imf05.hostedemail.com (Postfix) with ESMTP id 63B83100017 for ; Wed, 5 Apr 2023 20:24:51 +0000 (UTC) Authentication-Results: imf05.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b=nvtBMbWW; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (imf05.hostedemail.com: domain of zhi.wang.linux@gmail.com designates 209.85.167.47 as permitted sender) smtp.mailfrom=zhi.wang.linux@gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1680726291; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=z7bGBU2amChf9VSLvjx9x2NsgYO154k1agCs2bfejtI=; b=NKzvqoRVgzWhXh7WUBwVZFDOi6QWhTnTyiSJfWOmHEZ3Qr/BnY9RhIA6ieuniQ2e9eg8yO gjSkN2osmehZQN1J5nVRjkY7Kc2KCFsqCoE5tVtr0zpNiQ5Q4E5x+19ZlOhlDPwtUIePjb yUhm+qEbDIhRDFBOUVRkGkSN1X7+iNk= ARC-Authentication-Results: i=1; imf05.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b=nvtBMbWW; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (imf05.hostedemail.com: domain of zhi.wang.linux@gmail.com designates 209.85.167.47 as permitted sender) smtp.mailfrom=zhi.wang.linux@gmail.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1680726291; a=rsa-sha256; cv=none; b=CJwmvxVZbc5DxaxEWji8Qj0RUMGGgdPU7nh9j7M65nvCQfX2rqlhNE7+mJ2KplGhDZmwfq dssxPy45RzbwJHMuTOAEQTw1exsJlQnT+I0FSD1EDX1WKGXjNHG7C/rZotxBx7KU9OYDDT pY76wNIkqtFpSqgq5bFPPgOtFmELDVk= Received: by mail-lf1-f47.google.com with SMTP id 2adb3069b0e04-4dd9da1c068so471433e87.0 for ; Wed, 05 Apr 2023 13:24:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680726289; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:subject:cc:to:from:date:from:to:cc:subject:date :message-id:reply-to; bh=z7bGBU2amChf9VSLvjx9x2NsgYO154k1agCs2bfejtI=; b=nvtBMbWW2FPV97W8xfZ9Osx1LEiYvRQo78jbVtTnLDUBI68wEW53YmRiXoCx95HqVF qR3NK0fSkVHaVJHJ0PGxkA/fJVylAGIsIDCI1o8MZWHALUaKR6GbTr5r04nefDAm6lZp US/vGvP4+Scl4f2jwk/dO3hkXR2iBpoLYbnOGn0dDPytuY8RB0J/gGUL0PrYmMXo5gow o30Pc7yGwWAOQUS2e4GfG+4QIQlvW+27m0hnhYyUfkvuIwp+Yj9stH244itQHtgkEr13 BBQzouGUuXGvzU/88sLGqpgpa/nvoOGTxFTVZcSgfURJRfv6106Aqf4XCu0ZBzYvxWbm QhKw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680726289; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:subject:cc:to:from:date:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=z7bGBU2amChf9VSLvjx9x2NsgYO154k1agCs2bfejtI=; b=kdJ9rUIPo9gM6euk3PPMi9XBIZphRjhFBOWIfFjdk2E0p2Ob93kRGt+jfsrlRXtJim AomsiOai7RXwJeRJgC9kaTxAc2xhGKNANK5ymSQu9jy/9OuPmZSj1ovFSnRlI8VV8Kxz 5nznJf+Oaf9rp8aXSsIi6mbiT+lgeWKMmavNHoB3qvQW8zsbE1H3/LQ5EpWIjALKKpfU E2oXMmz7sURo0+DutwDMZ7vNaGrSNBKvJmHk5/OVWNTRIUNJblZcOB+X7fTfBvGzCVUy 8CwlvARvz9ObEJUv7T/j+adGdV8OX0F9QOorqYFqP5SfLSltnCC+m8/Lz2DjtaWNpFdD Lv+Q== X-Gm-Message-State: AAQBX9eGFH1e218+c+qI8Q4d2Uxrz/xbJ9zb/EGQ2U2ogzwCbwkGJIKY sL52Nfnc/iQOiG63o83v2YQ= X-Google-Smtp-Source: AKy350aWWwjMz3kM8AO3ZsWhy9vCtRp+zieAq0a1+W55O0O03xHKWs0G/djXvt+fvVY7HssIuMVhjQ== X-Received: by 2002:ac2:4462:0:b0:4eb:7fa:515 with SMTP id y2-20020ac24462000000b004eb07fa0515mr952369lfl.2.1680726289387; Wed, 05 Apr 2023 13:24:49 -0700 (PDT) Received: from localhost (88-115-161-74.elisa-laajakaista.fi. [88.115.161.74]) by smtp.gmail.com with ESMTPSA id t26-20020ac24c1a000000b004b5480edf67sm2972361lfq.36.2023.04.05.13.24.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 05 Apr 2023 13:24:49 -0700 (PDT) Date: Wed, 5 Apr 2023 23:24:35 +0300 From: Zhi Wang To: Cc: , , , , , , , , , , , , , , , , , Subject: Re: [PATCH v3 6/6] vfio/nvgpu: register device memory for poison handling Message-ID: <20230405232435.0000090a.zhi.wang.linux@gmail.com> In-Reply-To: <20230405180134.16932-7-ankita@nvidia.com> References: <20230405180134.16932-1-ankita@nvidia.com> <20230405180134.16932-7-ankita@nvidia.com> X-Mailer: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32) MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit X-Rspam-User: X-Rspamd-Server: rspam02 X-Rspamd-Queue-Id: 63B83100017 X-Stat-Signature: g5nfymoo39apie1s9sd1iqsz5h3cmd4i X-HE-Tag: 1680726291-385855 X-HE-Meta: U2FsdGVkX19dIxjK+oyiB198FMy3KB5/9zveGC4D8c/lQbwrLM43dici8eAeDIN/vQB1WzRmbPLcyGADiG6FSPpyUWzR34ZGbkZ12U6Uah5gMZLFdOjtHXH6NHpbp9nSKoRBdM74GvRm9Vn8+2+i1hEIbPhF4PDiDVaNCZ4ktl2VgP5AlD2zYZCD7MRyY/ZrnASiCPG/8bUCQDNPj+fJzfMEQlw/2Iob3BP/POfvxoKgjYLXPfQaxNSLgPVZHbkftsfHMVUWkgWJC97n2Q014m6ODueYEuQKp2HFspfnke/5wYszoqtFSF63Se45zxy/6BkKixma6BvQiDbYY3qwknetP3HrygxO0X3GjYBkGJY2MaQYhzHypoFmT7JfGjZttwNoza6x/b1d9BHmTaIuKZU/iNTrELOJxeuFgmJy4Y3yj5i0TNkGISuM3tWg+I+o7XdVSEPP77pZ2iUMJopVXnO5VYjRASBIu5y18gy02bPCEEG45MK9Y2BOM8nWgAPYetkOZv6b/b8ZiFZR9M+NLpwTXurY0RYkUQhlx2O42ZEi6+qoNyKd7KTENunVnw/r1gQ5wy6QO5l2BBE7CXixHZOgsdVEOgIEfGmsz/3hIF24mdZFmEkv/1J/Pr46HNJHPko8xhURy8gCiTlbxyV/9rrvWDE9rPvPyDwxxDNQjdmnKVF0KGPidv77edcHeRnK+MC/+dgLVI87fMaJF3+ckdWiIbWLYBoPVq6IlZ2SGl6zYBWZbPwUSYhIwerf/wqzAd9wTwrFvblw9PaJrGJkw7tr9hb6Od+i0FZBDcQvfAxZ8TemJwiM05ecMR1tUEwm9JU7bfRsc9GfSSfUfDfqTSlR5rbtjAdWM1x9Pyx4zJoXPSXCejBnArUromDdWhUHQo7UL4Tbnv1LxO5O1QZSFafbxKRJ1HNH9+ABJh/7O/iJ6bEO8rFl4PWwyvI5ugTDcfzXPtSjJ1yT6rjSuX1 QHqeB7WV 3qD7/WRK9c1LRt9BdpayWl88CrFH6D8EtU+xHEUl3+4n4Nq1+K18qxSurJQFUuJrwxtL8l/2pAYtQ+5esrn3l8i50cpMMQ/lUZYaK0z99mp3BTjwEG9fsNBF9GBlPrGeRwsksvQFDjX77+DwooEcDBpdu0AJYmMp/a4hp6aqiRMh16abfiFJ7cmGNIAHV/V0plwb26GaJxaW0BzcGO0QvjDai5svnz/52QDp4e+GkWWqiqeFabZcDfUnq7qirQVT1zIbEgxFiDiaOZ6O8s0aOGdEF8uoKapxH6GqxI4E9FmNnjAh8IZzoPR0yU3mtozL0U27SFqtXxAyL/Cbqll2gavm5t6V7q+zpF0ZZXM3klIyBFZkWEg6TThmrYHeIUCCMoIw68kO5asWOtwjKpfZP5KJ7ZzPuP1NGzBLAD9gR/D1HJ1lEUHyxMHtuwnKirx+VptfeFHouOD1i7XbPW4/IsvFiWQK79chDGfxIeVt/x0zHfu+25a3QuKpVg3957r79U3sy X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: On Wed, 5 Apr 2023 11:01:34 -0700 wrote: > From: Ankit Agrawal > > The nvgpu-vfio-pci module maps QEMU VMA to device memory through > remap_pfn_range(). The new mechanism to handle poison on memory not backed > by struct page is leveraged here. > > nvgpu-vfio-pci defines a function pfn_memory_failure() to get the ECC PFN > from the MM. The function is registered with kernel MM along with the > address space and PFN range through register_pfn_address_space(). > > Track poisoned PFN in the nvgpu-vfio-pci module as bitmap with a bit per > PFN. The PFN is communicated by the kernel MM to the module through the > failure function, which sets the appropriate bit in the bitmap. > > Register a VMA fault ops for the module. It returns VM_FAULT_HWPOISON > in case the bit for the PFN is set in the bitmap. > > Clear bitmap on reset to reflect the clean state of the device memory > after reset. > > Signed-off-by: Ankit Agrawal > --- > drivers/vfio/pci/nvgpu/main.c | 116 ++++++++++++++++++++++++++++++++-- > 1 file changed, 110 insertions(+), 6 deletions(-) > > diff --git a/drivers/vfio/pci/nvgpu/main.c b/drivers/vfio/pci/nvgpu/main.c > index 2dd8cc6e0145..8ccd3fe33a0f 100644 > --- a/drivers/vfio/pci/nvgpu/main.c > +++ b/drivers/vfio/pci/nvgpu/main.c > @@ -5,6 +5,8 @@ > > #include > #include > +#include > +#include > > #define DUMMY_PFN \ > (((nvdev->mem_prop.hpa + nvdev->mem_prop.mem_length) >> PAGE_SHIFT) - 1) > @@ -12,12 +14,78 @@ > struct dev_mem_properties { > uint64_t hpa; > uint64_t mem_length; > + unsigned long *pfn_bitmap; > int bar1_start_offset; > }; > > struct nvgpu_vfio_pci_core_device { > struct vfio_pci_core_device core_device; > struct dev_mem_properties mem_prop; > + struct pfn_address_space pfn_address_space; > +}; > + > +void nvgpu_vfio_pci_pfn_memory_failure(struct pfn_address_space *pfn_space, > + unsigned long pfn) > +{ > + struct nvgpu_vfio_pci_core_device *nvdev = container_of( > + pfn_space, struct nvgpu_vfio_pci_core_device, pfn_address_space); > + > + /* > + * MM has called to notify a poisoned page. Track that in the bitmap. > + */ > + __set_bit(pfn - (pfn_space->node.start), nvdev->mem_prop.pfn_bitmap); > +} > + > +struct pfn_address_space_ops nvgpu_vfio_pci_pas_ops = { > + .failure = nvgpu_vfio_pci_pfn_memory_failure, > +}; > + > +static int > +nvgpu_vfio_pci_register_pfn_range(struct nvgpu_vfio_pci_core_device *nvdev, > + struct vm_area_struct *vma) > +{ > + unsigned long nr_pages; > + int ret = 0; > + > + nr_pages = nvdev->mem_prop.mem_length >> PAGE_SHIFT; > + > + nvdev->pfn_address_space.node.start = vma->vm_pgoff; > + nvdev->pfn_address_space.node.last = vma->vm_pgoff + nr_pages - 1; > + nvdev->pfn_address_space.ops = &nvgpu_vfio_pci_pas_ops; > + nvdev->pfn_address_space.mapping = vma->vm_file->f_mapping; > + > + ret = register_pfn_address_space(&(nvdev->pfn_address_space)); > + > + return ret; > +} > + > +static vm_fault_t nvgpu_vfio_pci_fault(struct vm_fault *vmf) > +{ > + unsigned long mem_offset = vmf->pgoff - vmf->vma->vm_pgoff; > + struct nvgpu_vfio_pci_core_device *nvdev = container_of( > + vmf->vma->vm_file->private_data, > + struct nvgpu_vfio_pci_core_device, core_device.vdev); > + int ret; > + > + /* > + * Check if the page is poisoned. > + */ > + if (mem_offset < (nvdev->mem_prop.mem_length >> PAGE_SHIFT) && > + test_bit(mem_offset, nvdev->mem_prop.pfn_bitmap)) > + return VM_FAULT_HWPOISON; > + > + ret = remap_pfn_range(vmf->vma, > + vmf->vma->vm_start + (mem_offset << PAGE_SHIFT), > + DUMMY_PFN, PAGE_SIZE, > + vmf->vma->vm_page_prot); > + if (ret) > + return VM_FAULT_ERROR; > + > + return VM_FAULT_NOPAGE; > +} > + > +static const struct vm_operations_struct nvgpu_vfio_pci_mmap_ops = { > + .fault = nvgpu_vfio_pci_fault, > }; > > static int vfio_get_bar1_start_offset(struct vfio_pci_core_device *vdev) > @@ -26,8 +94,9 @@ static int vfio_get_bar1_start_offset(struct vfio_pci_core_device *vdev) > > pci_read_config_byte(vdev->pdev, 0x10, &val); > /* > - * The BAR1 start offset in the PCI config space depends on the BAR0size. > - * Check if the BAR0 is 64b and return the approproiate BAR1 offset. > + * The BAR1 start offset in the PCI config space depends on the BAR0 > + * size. Check if the BAR0 is 64b and return the approproiate BAR1 > + * offset. > */ > if (val & PCI_BASE_ADDRESS_MEM_TYPE_64) > return VFIO_PCI_BAR2_REGION_INDEX; > @@ -54,6 +123,16 @@ static int nvgpu_vfio_pci_open_device(struct vfio_device *core_vdev) > return ret; > } > > +void nvgpu_vfio_pci_close_device(struct vfio_device *core_vdev) > +{ > + struct nvgpu_vfio_pci_core_device *nvdev = container_of( > + core_vdev, struct nvgpu_vfio_pci_core_device, core_device.vdev); > + > + unregister_pfn_address_space(&(nvdev->pfn_address_space)); > + > + vfio_pci_core_close_device(core_vdev); > +} > + > int nvgpu_vfio_pci_mmap(struct vfio_device *core_vdev, > struct vm_area_struct *vma) > { > @@ -93,8 +172,11 @@ int nvgpu_vfio_pci_mmap(struct vfio_device *core_vdev, > return ret; > > vma->vm_pgoff = start_pfn + pgoff; > + vma->vm_ops = &nvgpu_vfio_pci_mmap_ops; > > - return 0; > + ret = nvgpu_vfio_pci_register_pfn_range(nvdev, vma); > + > + return ret; > } > > long nvgpu_vfio_pci_ioctl(struct vfio_device *core_vdev, unsigned int cmd, > @@ -140,7 +222,14 @@ long nvgpu_vfio_pci_ioctl(struct vfio_device *core_vdev, unsigned int cmd, > } > > return vfio_pci_core_ioctl(core_vdev, cmd, arg); > - > + case VFIO_DEVICE_RESET: > + /* > + * Resetting the GPU clears up the poisoned page. Reset the > + * poisoned page bitmap. > + */ > + memset(nvdev->mem_prop.pfn_bitmap, 0, > + nvdev->mem_prop.mem_length >> (PAGE_SHIFT + 3)); > + return vfio_pci_core_ioctl(core_vdev, cmd, arg); > default: > return vfio_pci_core_ioctl(core_vdev, cmd, arg); > } > @@ -151,7 +240,7 @@ static const struct vfio_device_ops nvgpu_vfio_pci_ops = { > .init = vfio_pci_core_init_dev, > .release = vfio_pci_core_release_dev, > .open_device = nvgpu_vfio_pci_open_device, > - .close_device = vfio_pci_core_close_device, > + .close_device = nvgpu_vfio_pci_close_device, > .ioctl = nvgpu_vfio_pci_ioctl, > .read = vfio_pci_core_read, > .write = vfio_pci_core_write, > @@ -188,7 +277,20 @@ nvgpu_vfio_pci_fetch_memory_property(struct pci_dev *pdev, > > ret = device_property_read_u64(&(pdev->dev), "nvidia,gpu-mem-size", > &(nvdev->mem_prop.mem_length)); > - return ret; > + if (ret) > + return ret; > + > + /* > + * A bitmap is maintained to teack the pages that are poisoned. Each ^track? > + * page is represented by a bit. Allocation size in bytes is > + * determined by shifting the device memory size by PAGE_SHIFT to > + * determine the number of pages; and further shifted by 3 as each > + * byte could track 8 pages. > + */ > + nvdev->mem_prop.pfn_bitmap > + = vzalloc(nvdev->mem_prop.mem_length >> (PAGE_SHIFT + 3)); > + > + return 0; > } > > static int nvgpu_vfio_pci_probe(struct pci_dev *pdev, > @@ -224,6 +326,8 @@ static void nvgpu_vfio_pci_remove(struct pci_dev *pdev) > struct nvgpu_vfio_pci_core_device *nvdev = nvgpu_drvdata(pdev); > struct vfio_pci_core_device *vdev = &nvdev->core_device; > > + vfree(nvdev->mem_prop.pfn_bitmap); > + > vfio_pci_core_unregister_device(vdev); > vfio_put_device(&vdev->vdev); > }