From: Elliot Berman <quic_eberman@quicinc.com> To: Alex Elder <elder@linaro.org>, Srinivas Kandagatla <srinivas.kandagatla@linaro.org>, Murali Nalajal <quic_mnalajal@quicinc.com>, Trilok Soni <quic_tsoni@quicinc.com>, Srivatsa Vaddagiri <quic_svaddagi@quicinc.com>, Carl van Schaik <quic_cvanscha@quicinc.com>, Philip Derrin <quic_pderrin@quicinc.com>, Prakruthi Deepak Heragu <quic_pheragu@quicinc.com>, Jonathan Corbet <corbet@lwn.net>, Rob Herring <robh+dt@kernel.org>, Krzysztof Kozlowski <krzysztof.kozlowski+dt@linaro.org>, Conor Dooley <conor+dt@kernel.org>, Catalin Marinas <catalin.marinas@arm.com>, Will Deacon <will@kernel.org>, Konrad Dybcio <konrad.dybcio@linaro.org>, Bjorn Andersson <andersson@kernel.org>, Dmitry Baryshkov <dmitry.baryshkov@linaro.org>, "Fuad Tabba" <tabba@google.com>, Sean Christopherson <seanjc@google.com>, "Andrew Morton" <akpm@linux-foundation.org> Cc: <linux-arm-msm@vger.kernel.org>, <linux-doc@vger.kernel.org>, <linux-kernel@vger.kernel.org>, <devicetree@vger.kernel.org>, <linux-arm-kernel@lists.infradead.org>, <linux-mm@kvack.org>, Elliot Berman <quic_eberman@quicinc.com> Subject: [PATCH v17 25/35] virt: gunyah: guestmem: Initialize RM mem parcels from guestmem Date: Thu, 22 Feb 2024 15:16:48 -0800 [thread overview] Message-ID: <20240222-gunyah-v17-25-1e9da6763d38@quicinc.com> (raw) In-Reply-To: <20240222-gunyah-v17-0-1e9da6763d38@quicinc.com> Gunyah Resource Manager sets up a virtual machine based on a device tree which lives in guest memory. Resource manager requires this memory to be provided as a memory parcel for it to read and manipulate. Implement a function to construct a memory parcel from a guestmem binding. Signed-off-by: Elliot Berman <quic_eberman@quicinc.com> --- drivers/virt/gunyah/guest_memfd.c | 207 ++++++++++++++++++++++++++++++++++++++ drivers/virt/gunyah/vm_mgr.h | 6 ++ 2 files changed, 213 insertions(+) diff --git a/drivers/virt/gunyah/guest_memfd.c b/drivers/virt/gunyah/guest_memfd.c index d6be8bf67d996..0c35ffa616d9c 100644 --- a/drivers/virt/gunyah/guest_memfd.c +++ b/drivers/virt/gunyah/guest_memfd.c @@ -684,3 +684,210 @@ int gunyah_gmem_modify_mapping(struct gunyah_vm *ghvm, fput(file); return ret; } + +int gunyah_gmem_share_parcel(struct gunyah_vm *ghvm, struct gunyah_rm_mem_parcel *parcel, + u64 *gfn, u64 *nr) +{ + struct folio *folio, *prev_folio; + unsigned long nr_entries, i, j, start, end; + struct gunyah_gmem_binding *b; + bool lend; + int ret; + + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + + if (!*nr) + return -EINVAL; + + down_read(&ghvm->bindings_lock); + b = mtree_load(&ghvm->bindings, *gfn); + if (!b || *gfn > b->gfn + b->nr || *gfn < b->gfn) { + ret = -ENOENT; + goto unlock; + } + + /** + * Generally, indices can be based on gfn, guest_memfd offset, or + * offset into binding. start and end are based on offset into binding. + */ + start = *gfn - b->gfn; + + if (start + *nr > b->nr) { + ret = -ENOENT; + goto unlock; + } + + end = start + *nr; + lend = gunyah_guest_mem_is_lend(ghvm, b->flags); + + /** + * First, calculate the number of physically discontiguous regions + * the parcel covers. Each memory entry corresponds to one folio. + * In future, each memory entry could correspond to contiguous + * folios that are also adjacent in guest_memfd, but parcels + * are only being used for small amounts of memory for now, so + * this optimization is premature. + */ + nr_entries = 0; + prev_folio = NULL; + for (i = start + b->i_off; i < end + b->i_off;) { + folio = gunyah_gmem_get_folio(file_inode(b->file), i); /* A */ + if (!folio) { + ret = -ENOMEM; + goto out; + } + + if (lend) { + /* don't lend a folio that is mapped by host */ + if (!gunyah_folio_lend_safe(folio)) { + folio_unlock(folio); + folio_put(folio); + ret = -EPERM; + goto out; + } + folio_set_private(folio); + } + + nr_entries++; + i = folio_index(folio) + folio_nr_pages(folio); + } + end = i - b->i_off; + + parcel->mem_entries = + kcalloc(nr_entries, sizeof(*parcel->mem_entries), GFP_KERNEL); + if (!parcel->mem_entries) { + ret = -ENOMEM; + goto out; + } + + /** + * Walk through all the folios again, now filling the mem_entries array. + */ + j = 0; + prev_folio = NULL; + for (i = start + b->i_off; i < end + b->i_off; j++) { + folio = filemap_get_folio(file_inode(b->file)->i_mapping, i); /* B */ + if (WARN_ON(IS_ERR(folio))) { + ret = PTR_ERR(folio); + i = end + b->i_off; + goto out; + } + + parcel->mem_entries[j].size = cpu_to_le64(folio_size(folio)); + parcel->mem_entries[j].phys_addr = cpu_to_le64(PFN_PHYS(folio_pfn(folio))); + i = folio_index(folio) + folio_nr_pages(folio); + folio_put(folio); /* B */ + } + BUG_ON(j != nr_entries); + parcel->n_mem_entries = nr_entries; + + if (lend) + parcel->n_acl_entries = 1; + + parcel->acl_entries = kcalloc(parcel->n_acl_entries, + sizeof(*parcel->acl_entries), GFP_KERNEL); + if (!parcel->n_acl_entries) { + ret = -ENOMEM; + goto free_entries; + } + + parcel->acl_entries[0].vmid = cpu_to_le16(ghvm->vmid); + if (b->flags & GUNYAH_MEM_ALLOW_READ) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_R; + if (b->flags & GUNYAH_MEM_ALLOW_WRITE) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_W; + if (b->flags & GUNYAH_MEM_ALLOW_EXEC) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_X; + + if (!lend) { + u16 host_vmid; + + ret = gunyah_rm_get_vmid(ghvm->rm, &host_vmid); + if (ret) + goto free_acl; + + parcel->acl_entries[1].vmid = cpu_to_le16(host_vmid); + parcel->acl_entries[1].perms = GUNYAH_RM_ACL_R | GUNYAH_RM_ACL_W | GUNYAH_RM_ACL_X; + } + + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + folio = filemap_get_folio(file_inode(b->file)->i_mapping, start); /* C */ + *gfn = folio_index(folio) - b->i_off + b->gfn; + *nr = end - (folio_index(folio) - b->i_off); + folio_put(folio); /* C */ + + ret = gunyah_rm_mem_share(ghvm->rm, parcel); + goto out; +free_acl: + kfree(parcel->acl_entries); + parcel->acl_entries = NULL; +free_entries: + kfree(parcel->mem_entries); + parcel->mem_entries = NULL; + parcel->n_mem_entries = 0; +out: + /* unlock the folios */ + for (j = start + b->i_off; j < i;) { + folio = filemap_get_folio(file_inode(b->file)->i_mapping, j); /* D */ + if (WARN_ON(IS_ERR(folio))) + continue; + j = folio_index(folio) + folio_nr_pages(folio); + folio_unlock(folio); /* A */ + if (ret) { + if (folio_test_private(folio)) { + gunyah_folio_host_reclaim(folio); + folio_clear_private(folio); + } + folio_put(folio); /* A */ + } + folio_put(folio); /* D */ + /* matching folio_put for A is done at + * (1) gunyah_gmem_reclaim_parcel or + * (2) after gunyah_gmem_parcel_to_paged, gunyah_vm_reclaim_folio + */ + } +unlock: + up_read(&ghvm->bindings_lock); + return ret; +} + +int gunyah_gmem_reclaim_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 gfn, + u64 nr) +{ + struct gunyah_rm_mem_entry *entry; + struct folio *folio; + pgoff_t i; + int ret; + + if (parcel->mem_handle != GUNYAH_MEM_HANDLE_INVAL) { + ret = gunyah_rm_mem_reclaim(ghvm->rm, parcel); + if (ret) { + dev_err(ghvm->parent, "Failed to reclaim parcel: %d\n", + ret); + /* We can't reclaim the pages -- hold onto the pages + * forever because we don't know what state the memory + * is in + */ + return ret; + } + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + + for (i = 0; i < parcel->n_mem_entries; i++) { + entry = &parcel->mem_entries[i]; + + folio = pfn_folio(PHYS_PFN(le64_to_cpu(entry->phys_addr))); + + if (folio_test_private(folio)) + gunyah_folio_host_reclaim(folio); + + folio_clear_private(folio); + folio_put(folio); /* A */ + } + + kfree(parcel->mem_entries); + kfree(parcel->acl_entries); + } + + return 0; +} diff --git a/drivers/virt/gunyah/vm_mgr.h b/drivers/virt/gunyah/vm_mgr.h index d9f101fc52632..b6bc66f018b09 100644 --- a/drivers/virt/gunyah/vm_mgr.h +++ b/drivers/virt/gunyah/vm_mgr.h @@ -181,5 +181,11 @@ int gunyah_gmem_modify_mapping(struct gunyah_vm *ghvm, struct gunyah_map_mem_args *args); struct gunyah_gmem_binding; void gunyah_gmem_remove_binding(struct gunyah_gmem_binding *binding); +int gunyah_gmem_share_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 *gfn, + u64 *nr); +int gunyah_gmem_reclaim_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 gfn, + u64 nr); #endif -- 2.34.1
WARNING: multiple messages have this Message-ID (diff)
From: Elliot Berman <quic_eberman@quicinc.com> To: Alex Elder <elder@linaro.org>, Srinivas Kandagatla <srinivas.kandagatla@linaro.org>, Murali Nalajal <quic_mnalajal@quicinc.com>, Trilok Soni <quic_tsoni@quicinc.com>, Srivatsa Vaddagiri <quic_svaddagi@quicinc.com>, Carl van Schaik <quic_cvanscha@quicinc.com>, Philip Derrin <quic_pderrin@quicinc.com>, Prakruthi Deepak Heragu <quic_pheragu@quicinc.com>, Jonathan Corbet <corbet@lwn.net>, Rob Herring <robh+dt@kernel.org>, Krzysztof Kozlowski <krzysztof.kozlowski+dt@linaro.org>, Conor Dooley <conor+dt@kernel.org>, Catalin Marinas <catalin.marinas@arm.com>, Will Deacon <will@kernel.org>, Konrad Dybcio <konrad.dybcio@linaro.org>, Bjorn Andersson <andersson@kernel.org>, Dmitry Baryshkov <dmitry.baryshkov@linaro.org>, "Fuad Tabba" <tabba@google.com>, Sean Christopherson <seanjc@google.com>, "Andrew Morton" <akpm@linux-foundation.org> Cc: <linux-arm-msm@vger.kernel.org>, <linux-doc@vger.kernel.org>, <linux-kernel@vger.kernel.org>, <devicetree@vger.kernel.org>, <linux-arm-kernel@lists.infradead.org>, <linux-mm@kvack.org>, Elliot Berman <quic_eberman@quicinc.com> Subject: [PATCH v17 25/35] virt: gunyah: guestmem: Initialize RM mem parcels from guestmem Date: Thu, 22 Feb 2024 15:16:48 -0800 [thread overview] Message-ID: <20240222-gunyah-v17-25-1e9da6763d38@quicinc.com> (raw) In-Reply-To: <20240222-gunyah-v17-0-1e9da6763d38@quicinc.com> Gunyah Resource Manager sets up a virtual machine based on a device tree which lives in guest memory. Resource manager requires this memory to be provided as a memory parcel for it to read and manipulate. Implement a function to construct a memory parcel from a guestmem binding. Signed-off-by: Elliot Berman <quic_eberman@quicinc.com> --- drivers/virt/gunyah/guest_memfd.c | 207 ++++++++++++++++++++++++++++++++++++++ drivers/virt/gunyah/vm_mgr.h | 6 ++ 2 files changed, 213 insertions(+) diff --git a/drivers/virt/gunyah/guest_memfd.c b/drivers/virt/gunyah/guest_memfd.c index d6be8bf67d996..0c35ffa616d9c 100644 --- a/drivers/virt/gunyah/guest_memfd.c +++ b/drivers/virt/gunyah/guest_memfd.c @@ -684,3 +684,210 @@ int gunyah_gmem_modify_mapping(struct gunyah_vm *ghvm, fput(file); return ret; } + +int gunyah_gmem_share_parcel(struct gunyah_vm *ghvm, struct gunyah_rm_mem_parcel *parcel, + u64 *gfn, u64 *nr) +{ + struct folio *folio, *prev_folio; + unsigned long nr_entries, i, j, start, end; + struct gunyah_gmem_binding *b; + bool lend; + int ret; + + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + + if (!*nr) + return -EINVAL; + + down_read(&ghvm->bindings_lock); + b = mtree_load(&ghvm->bindings, *gfn); + if (!b || *gfn > b->gfn + b->nr || *gfn < b->gfn) { + ret = -ENOENT; + goto unlock; + } + + /** + * Generally, indices can be based on gfn, guest_memfd offset, or + * offset into binding. start and end are based on offset into binding. + */ + start = *gfn - b->gfn; + + if (start + *nr > b->nr) { + ret = -ENOENT; + goto unlock; + } + + end = start + *nr; + lend = gunyah_guest_mem_is_lend(ghvm, b->flags); + + /** + * First, calculate the number of physically discontiguous regions + * the parcel covers. Each memory entry corresponds to one folio. + * In future, each memory entry could correspond to contiguous + * folios that are also adjacent in guest_memfd, but parcels + * are only being used for small amounts of memory for now, so + * this optimization is premature. + */ + nr_entries = 0; + prev_folio = NULL; + for (i = start + b->i_off; i < end + b->i_off;) { + folio = gunyah_gmem_get_folio(file_inode(b->file), i); /* A */ + if (!folio) { + ret = -ENOMEM; + goto out; + } + + if (lend) { + /* don't lend a folio that is mapped by host */ + if (!gunyah_folio_lend_safe(folio)) { + folio_unlock(folio); + folio_put(folio); + ret = -EPERM; + goto out; + } + folio_set_private(folio); + } + + nr_entries++; + i = folio_index(folio) + folio_nr_pages(folio); + } + end = i - b->i_off; + + parcel->mem_entries = + kcalloc(nr_entries, sizeof(*parcel->mem_entries), GFP_KERNEL); + if (!parcel->mem_entries) { + ret = -ENOMEM; + goto out; + } + + /** + * Walk through all the folios again, now filling the mem_entries array. + */ + j = 0; + prev_folio = NULL; + for (i = start + b->i_off; i < end + b->i_off; j++) { + folio = filemap_get_folio(file_inode(b->file)->i_mapping, i); /* B */ + if (WARN_ON(IS_ERR(folio))) { + ret = PTR_ERR(folio); + i = end + b->i_off; + goto out; + } + + parcel->mem_entries[j].size = cpu_to_le64(folio_size(folio)); + parcel->mem_entries[j].phys_addr = cpu_to_le64(PFN_PHYS(folio_pfn(folio))); + i = folio_index(folio) + folio_nr_pages(folio); + folio_put(folio); /* B */ + } + BUG_ON(j != nr_entries); + parcel->n_mem_entries = nr_entries; + + if (lend) + parcel->n_acl_entries = 1; + + parcel->acl_entries = kcalloc(parcel->n_acl_entries, + sizeof(*parcel->acl_entries), GFP_KERNEL); + if (!parcel->n_acl_entries) { + ret = -ENOMEM; + goto free_entries; + } + + parcel->acl_entries[0].vmid = cpu_to_le16(ghvm->vmid); + if (b->flags & GUNYAH_MEM_ALLOW_READ) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_R; + if (b->flags & GUNYAH_MEM_ALLOW_WRITE) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_W; + if (b->flags & GUNYAH_MEM_ALLOW_EXEC) + parcel->acl_entries[0].perms |= GUNYAH_RM_ACL_X; + + if (!lend) { + u16 host_vmid; + + ret = gunyah_rm_get_vmid(ghvm->rm, &host_vmid); + if (ret) + goto free_acl; + + parcel->acl_entries[1].vmid = cpu_to_le16(host_vmid); + parcel->acl_entries[1].perms = GUNYAH_RM_ACL_R | GUNYAH_RM_ACL_W | GUNYAH_RM_ACL_X; + } + + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + folio = filemap_get_folio(file_inode(b->file)->i_mapping, start); /* C */ + *gfn = folio_index(folio) - b->i_off + b->gfn; + *nr = end - (folio_index(folio) - b->i_off); + folio_put(folio); /* C */ + + ret = gunyah_rm_mem_share(ghvm->rm, parcel); + goto out; +free_acl: + kfree(parcel->acl_entries); + parcel->acl_entries = NULL; +free_entries: + kfree(parcel->mem_entries); + parcel->mem_entries = NULL; + parcel->n_mem_entries = 0; +out: + /* unlock the folios */ + for (j = start + b->i_off; j < i;) { + folio = filemap_get_folio(file_inode(b->file)->i_mapping, j); /* D */ + if (WARN_ON(IS_ERR(folio))) + continue; + j = folio_index(folio) + folio_nr_pages(folio); + folio_unlock(folio); /* A */ + if (ret) { + if (folio_test_private(folio)) { + gunyah_folio_host_reclaim(folio); + folio_clear_private(folio); + } + folio_put(folio); /* A */ + } + folio_put(folio); /* D */ + /* matching folio_put for A is done at + * (1) gunyah_gmem_reclaim_parcel or + * (2) after gunyah_gmem_parcel_to_paged, gunyah_vm_reclaim_folio + */ + } +unlock: + up_read(&ghvm->bindings_lock); + return ret; +} + +int gunyah_gmem_reclaim_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 gfn, + u64 nr) +{ + struct gunyah_rm_mem_entry *entry; + struct folio *folio; + pgoff_t i; + int ret; + + if (parcel->mem_handle != GUNYAH_MEM_HANDLE_INVAL) { + ret = gunyah_rm_mem_reclaim(ghvm->rm, parcel); + if (ret) { + dev_err(ghvm->parent, "Failed to reclaim parcel: %d\n", + ret); + /* We can't reclaim the pages -- hold onto the pages + * forever because we don't know what state the memory + * is in + */ + return ret; + } + parcel->mem_handle = GUNYAH_MEM_HANDLE_INVAL; + + for (i = 0; i < parcel->n_mem_entries; i++) { + entry = &parcel->mem_entries[i]; + + folio = pfn_folio(PHYS_PFN(le64_to_cpu(entry->phys_addr))); + + if (folio_test_private(folio)) + gunyah_folio_host_reclaim(folio); + + folio_clear_private(folio); + folio_put(folio); /* A */ + } + + kfree(parcel->mem_entries); + kfree(parcel->acl_entries); + } + + return 0; +} diff --git a/drivers/virt/gunyah/vm_mgr.h b/drivers/virt/gunyah/vm_mgr.h index d9f101fc52632..b6bc66f018b09 100644 --- a/drivers/virt/gunyah/vm_mgr.h +++ b/drivers/virt/gunyah/vm_mgr.h @@ -181,5 +181,11 @@ int gunyah_gmem_modify_mapping(struct gunyah_vm *ghvm, struct gunyah_map_mem_args *args); struct gunyah_gmem_binding; void gunyah_gmem_remove_binding(struct gunyah_gmem_binding *binding); +int gunyah_gmem_share_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 *gfn, + u64 *nr); +int gunyah_gmem_reclaim_parcel(struct gunyah_vm *ghvm, + struct gunyah_rm_mem_parcel *parcel, u64 gfn, + u64 nr); #endif -- 2.34.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
next prev parent reply other threads:[~2024-02-22 23:17 UTC|newest] Thread overview: 150+ messages / expand[flat|nested] mbox.gz Atom feed top 2024-02-22 23:16 [PATCH v17 00/35] Drivers for Gunyah hypervisor Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 01/35] docs: gunyah: Introduce Gunyah Hypervisor Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-05 10:53 ` Pavan Kondeti 2024-03-05 10:53 ` Pavan Kondeti 2024-03-07 15:37 ` Srivatsa Vaddagiri 2024-03-07 15:37 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 02/35] dt-bindings: Add binding for gunyah hypervisor Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 03/35] gunyah: Common types and error codes for Gunyah hypercalls Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 04/35] virt: gunyah: Add hypercalls to identify Gunyah Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 05/35] virt: gunyah: Add hypervisor driver Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-23 21:10 ` Konrad Dybcio 2024-02-23 21:10 ` Konrad Dybcio 2024-02-23 22:58 ` Elliot Berman 2024-02-23 22:58 ` Elliot Berman 2024-02-23 23:46 ` Konrad Dybcio 2024-02-23 23:46 ` Konrad Dybcio 2024-03-07 15:38 ` Srivatsa Vaddagiri 2024-03-07 15:38 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 06/35] virt: gunyah: msgq: Add hypercalls to send and receive messages Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 07/35] gunyah: rsc_mgr: Add resource manager RPC core Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-07 15:38 ` Srivatsa Vaddagiri 2024-03-07 15:38 ` Srivatsa Vaddagiri 2024-03-07 16:41 ` Elliot Berman 2024-03-07 16:41 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 08/35] gunyah: vm_mgr: Introduce basic VM Manager Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-07 15:39 ` Srivatsa Vaddagiri 2024-03-07 15:39 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 09/35] gunyah: rsc_mgr: Add VM lifecycle RPC Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-07 15:39 ` Srivatsa Vaddagiri 2024-03-07 15:39 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 10/35] gunyah: vm_mgr: Add VM start/stop Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-11 5:38 ` Srivatsa Vaddagiri 2024-03-11 5:38 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 11/35] virt: gunyah: Translate gh_rm_hyp_resource into gunyah_resource Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-11 5:39 ` Srivatsa Vaddagiri 2024-03-11 5:39 ` Srivatsa Vaddagiri 2024-03-11 17:19 ` Elliot Berman 2024-03-11 17:19 ` Elliot Berman 2024-04-05 3:10 ` Pavan Kondeti 2024-04-05 3:10 ` Pavan Kondeti 2024-04-05 15:18 ` Elliot Berman 2024-04-05 15:18 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 12/35] virt: gunyah: Add resource tickets Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-11 5:38 ` Srivatsa Vaddagiri 2024-03-11 5:38 ` Srivatsa Vaddagiri 2024-03-11 17:13 ` Elliot Berman 2024-03-11 17:13 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 13/35] gunyah: vm_mgr: Add framework for VM Functions Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-13 9:20 ` Srivatsa Vaddagiri 2024-03-13 9:20 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 14/35] virt: gunyah: Add hypercalls for running a vCPU Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-13 9:21 ` Srivatsa Vaddagiri 2024-03-13 9:21 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 15/35] virt: gunyah: Add proxy-scheduled vCPUs Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-13 9:21 ` Srivatsa Vaddagiri 2024-03-13 9:21 ` Srivatsa Vaddagiri 2024-04-24 9:39 ` Srivatsa Vaddagiri 2024-04-24 9:39 ` Srivatsa Vaddagiri 2024-04-24 17:01 ` Elliot Berman 2024-04-24 17:01 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 16/35] gunyah: Add hypercalls for demand paging Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-13 15:35 ` Srivatsa Vaddagiri 2024-03-13 15:35 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 17/35] gunyah: rsc_mgr: Add memory parcel RPC Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-14 14:02 ` Srivatsa Vaddagiri 2024-03-14 14:02 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 18/35] mm/interval_tree: Export iter_first/iter_next Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 19/35] arch/mm: Export direct {un,}map functions Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-23 7:09 ` Christoph Hellwig 2024-02-23 7:09 ` Christoph Hellwig 2024-02-24 0:37 ` Elliot Berman 2024-02-24 0:37 ` Elliot Berman 2024-02-26 11:06 ` Christoph Hellwig 2024-02-26 11:06 ` Christoph Hellwig 2024-02-26 11:53 ` David Hildenbrand 2024-02-26 11:53 ` David Hildenbrand 2024-02-26 17:27 ` Elliot Berman 2024-02-26 17:27 ` Elliot Berman 2024-02-27 9:49 ` David Hildenbrand 2024-02-27 9:49 ` David Hildenbrand 2024-03-01 1:35 ` Elliot Berman 2024-03-01 1:35 ` Elliot Berman 2024-03-04 13:10 ` Quentin Perret 2024-03-04 13:10 ` Quentin Perret 2024-03-04 23:37 ` Elliot Berman 2024-03-04 23:37 ` Elliot Berman 2024-03-05 15:30 ` Quentin Perret 2024-03-05 15:30 ` Quentin Perret 2024-03-05 20:26 ` Elliot Berman 2024-03-05 20:26 ` Elliot Berman 2024-03-06 12:05 ` Quentin Perret 2024-03-06 12:05 ` Quentin Perret 2024-03-08 19:55 ` Elliot Berman 2024-03-08 19:55 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 20/35] virt: gunyah: Add interfaces to map memory into guest address space Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 21/35] gunyah: rsc_mgr: Add platform ops on mem_lend/mem_reclaim Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 22/35] virt: gunyah: Add Qualcomm Gunyah platform ops Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 23/35] virt: gunyah: Implement guestmemfd Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 24/35] virt: gunyah: Add ioctl to bind guestmem to VMs Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` Elliot Berman [this message] 2024-02-22 23:16 ` [PATCH v17 25/35] virt: gunyah: guestmem: Initialize RM mem parcels from guestmem Elliot Berman 2024-02-22 23:16 ` [PATCH v17 26/35] virt: gunyah: Share guest VM dtb configuration to Gunyah Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 27/35] gunyah: rsc_mgr: Add RPC to enable demand paging Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 28/35] virt: gunyah: Enable " Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 29/35] gunyah: rsc_mgr: Add RPC to set VM boot context Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-14 14:02 ` Srivatsa Vaddagiri 2024-03-14 14:02 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 30/35] virt: gunyah: Allow userspace to initialize context of primary vCPU Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-03-14 14:03 ` Srivatsa Vaddagiri 2024-03-14 14:03 ` Srivatsa Vaddagiri 2024-02-22 23:16 ` [PATCH v17 31/35] virt: gunyah: Add hypercalls for sending doorbell Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 32/35] virt: gunyah: Add irqfd interface Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 33/35] virt: gunyah: Add IO handlers Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 34/35] virt: gunyah: Add ioeventfd Elliot Berman 2024-02-22 23:16 ` Elliot Berman 2024-02-22 23:16 ` [PATCH v17 35/35] MAINTAINERS: Add Gunyah hypervisor drivers section Elliot Berman 2024-02-22 23:16 ` Elliot Berman
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20240222-gunyah-v17-25-1e9da6763d38@quicinc.com \ --to=quic_eberman@quicinc.com \ --cc=akpm@linux-foundation.org \ --cc=andersson@kernel.org \ --cc=catalin.marinas@arm.com \ --cc=conor+dt@kernel.org \ --cc=corbet@lwn.net \ --cc=devicetree@vger.kernel.org \ --cc=dmitry.baryshkov@linaro.org \ --cc=elder@linaro.org \ --cc=konrad.dybcio@linaro.org \ --cc=krzysztof.kozlowski+dt@linaro.org \ --cc=linux-arm-kernel@lists.infradead.org \ --cc=linux-arm-msm@vger.kernel.org \ --cc=linux-doc@vger.kernel.org \ --cc=linux-kernel@vger.kernel.org \ --cc=linux-mm@kvack.org \ --cc=quic_cvanscha@quicinc.com \ --cc=quic_mnalajal@quicinc.com \ --cc=quic_pderrin@quicinc.com \ --cc=quic_pheragu@quicinc.com \ --cc=quic_svaddagi@quicinc.com \ --cc=quic_tsoni@quicinc.com \ --cc=robh+dt@kernel.org \ --cc=seanjc@google.com \ --cc=srinivas.kandagatla@linaro.org \ --cc=tabba@google.com \ --cc=will@kernel.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.