* [PATCH 0/2] xen/xenbus: some cleanups
@ 2020-05-11 7:31 Juergen Gross
2020-05-11 7:31 ` [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack Juergen Gross
2020-05-11 7:31 ` [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only Juergen Gross
0 siblings, 2 replies; 6+ messages in thread
From: Juergen Gross @ 2020-05-11 7:31 UTC (permalink / raw)
To: xen-devel, linux-kernel, clang-built-linux
Cc: Juergen Gross, Boris Ostrovsky, Stefano Stabellini
Avoid allocating large amount of data on the stack in
xenbus_map_ring_valloc() and some related return value cleanups.
Juergen Gross (2):
xen/xenbus: avoid large structs and arrays on the stack
xen/xenbus: let xenbus_map_ring_valloc() return errno values only
drivers/xen/xenbus/xenbus_client.c | 133 ++++++++++++++---------------
1 file changed, 64 insertions(+), 69 deletions(-)
--
2.26.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack
2020-05-11 7:31 [PATCH 0/2] xen/xenbus: some cleanups Juergen Gross
@ 2020-05-11 7:31 ` Juergen Gross
2020-05-11 18:01 ` Boris Ostrovsky
2020-05-11 7:31 ` [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only Juergen Gross
1 sibling, 1 reply; 6+ messages in thread
From: Juergen Gross @ 2020-05-11 7:31 UTC (permalink / raw)
To: xen-devel, linux-kernel, clang-built-linux
Cc: Juergen Gross, Boris Ostrovsky, Stefano Stabellini, Arnd Bergmann
xenbus_map_ring_valloc() and its sub-functions are putting quite large
structs and arrays on the stack. This is problematic at runtime, but
might also result in build failures (e.g. with clang due to the option
-Werror,-Wframe-larger-than=... used).
Fix that by moving most of the data from the stack into a dynamically
allocated struct. Performance is no issue here, as
xenbus_map_ring_valloc() is used only when adding a new PV device to
a backend driver.
While at it move some duplicated code from pv/hvm specific mapping
functions to the single caller.
Reported-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Juergen Gross <jgross@suse.com>
---
drivers/xen/xenbus/xenbus_client.c | 127 +++++++++++++++--------------
1 file changed, 66 insertions(+), 61 deletions(-)
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index 040d2a43e8e3..d8e5c5e4fa67 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -69,11 +69,27 @@ struct xenbus_map_node {
unsigned int nr_handles;
};
+struct map_ring_valloc {
+ struct xenbus_map_node *node;
+
+ /* Why do we need two arrays? See comment of __xenbus_map_ring */
+ union {
+ unsigned long addrs[XENBUS_MAX_RING_GRANTS];
+ pte_t *ptes[XENBUS_MAX_RING_GRANTS];
+ };
+ phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
+
+ struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS];
+ struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
+
+ unsigned int idx; /* HVM only. */
+};
+
static DEFINE_SPINLOCK(xenbus_valloc_lock);
static LIST_HEAD(xenbus_valloc_pages);
struct xenbus_ring_ops {
- int (*map)(struct xenbus_device *dev,
+ int (*map)(struct xenbus_device *dev, struct map_ring_valloc *info,
grant_ref_t *gnt_refs, unsigned int nr_grefs,
void **vaddr);
int (*unmap)(struct xenbus_device *dev, void *vaddr);
@@ -449,12 +465,32 @@ int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
unsigned int nr_grefs, void **vaddr)
{
int err;
+ struct map_ring_valloc *info;
+
+ *vaddr = NULL;
+
+ if (nr_grefs > XENBUS_MAX_RING_GRANTS)
+ return -EINVAL;
+
+ info = kzalloc(sizeof(*info), GFP_KERNEL);
+ if (!info)
+ return -ENOMEM;
+
+ info->node = kzalloc(sizeof(*info->node), GFP_KERNEL);
+ if (!info->node) {
+ err = -ENOMEM;
+ goto out;
+ }
+
+ err = ring_ops->map(dev, info, gnt_refs, nr_grefs, vaddr);
- err = ring_ops->map(dev, gnt_refs, nr_grefs, vaddr);
/* Some hypervisors are buggy and can return 1. */
if (err > 0)
err = GNTST_general_error;
+ out:
+ kfree(info->node);
+ kfree(info);
return err;
}
EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
@@ -466,12 +502,10 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
grant_ref_t *gnt_refs,
unsigned int nr_grefs,
grant_handle_t *handles,
- phys_addr_t *addrs,
+ struct map_ring_valloc *info,
unsigned int flags,
bool *leaked)
{
- struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS];
- struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
int i, j;
int err = GNTST_okay;
@@ -479,23 +513,22 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
return -EINVAL;
for (i = 0; i < nr_grefs; i++) {
- memset(&map[i], 0, sizeof(map[i]));
- gnttab_set_map_op(&map[i], addrs[i], flags, gnt_refs[i],
- dev->otherend_id);
+ gnttab_set_map_op(&info->map[i], info->phys_addrs[i], flags,
+ gnt_refs[i], dev->otherend_id);
handles[i] = INVALID_GRANT_HANDLE;
}
- gnttab_batch_map(map, i);
+ gnttab_batch_map(info->map, i);
for (i = 0; i < nr_grefs; i++) {
- if (map[i].status != GNTST_okay) {
- err = map[i].status;
- xenbus_dev_fatal(dev, map[i].status,
+ if (info->map[i].status != GNTST_okay) {
+ err = info->map[i].status;
+ xenbus_dev_fatal(dev, info->map[i].status,
"mapping in shared page %d from domain %d",
gnt_refs[i], dev->otherend_id);
goto fail;
} else
- handles[i] = map[i].handle;
+ handles[i] = info->map[i].handle;
}
return GNTST_okay;
@@ -503,19 +536,19 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
fail:
for (i = j = 0; i < nr_grefs; i++) {
if (handles[i] != INVALID_GRANT_HANDLE) {
- memset(&unmap[j], 0, sizeof(unmap[j]));
- gnttab_set_unmap_op(&unmap[j], (phys_addr_t)addrs[i],
+ gnttab_set_unmap_op(&info->unmap[j],
+ info->phys_addrs[i],
GNTMAP_host_map, handles[i]);
j++;
}
}
- if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, j))
+ if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, info->unmap, j))
BUG();
*leaked = false;
for (i = 0; i < j; i++) {
- if (unmap[i].status != GNTST_okay) {
+ if (info->unmap[i].status != GNTST_okay) {
*leaked = true;
break;
}
@@ -566,21 +599,12 @@ static int xenbus_unmap_ring(struct xenbus_device *dev, grant_handle_t *handles,
return err;
}
-struct map_ring_valloc_hvm
-{
- unsigned int idx;
-
- /* Why do we need two arrays? See comment of __xenbus_map_ring */
- phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
- unsigned long addrs[XENBUS_MAX_RING_GRANTS];
-};
-
static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn,
unsigned int goffset,
unsigned int len,
void *data)
{
- struct map_ring_valloc_hvm *info = data;
+ struct map_ring_valloc *info = data;
unsigned long vaddr = (unsigned long)gfn_to_virt(gfn);
info->phys_addrs[info->idx] = vaddr;
@@ -590,38 +614,27 @@ static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn,
}
static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
+ struct map_ring_valloc *info,
grant_ref_t *gnt_ref,
unsigned int nr_grefs,
void **vaddr)
{
- struct xenbus_map_node *node;
+ struct xenbus_map_node *node = info->node;
int err;
void *addr;
bool leaked = false;
- struct map_ring_valloc_hvm info = {
- .idx = 0,
- };
unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
- if (nr_grefs > XENBUS_MAX_RING_GRANTS)
- return -EINVAL;
-
- *vaddr = NULL;
-
- node = kzalloc(sizeof(*node), GFP_KERNEL);
- if (!node)
- return -ENOMEM;
-
err = alloc_xenballooned_pages(nr_pages, node->hvm.pages);
if (err)
goto out_err;
gnttab_foreach_grant(node->hvm.pages, nr_grefs,
xenbus_map_ring_setup_grant_hvm,
- &info);
+ info);
err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
- info.phys_addrs, GNTMAP_host_map, &leaked);
+ info, GNTMAP_host_map, &leaked);
node->nr_handles = nr_grefs;
if (err)
@@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
spin_unlock(&xenbus_valloc_lock);
*vaddr = addr;
+ info->node = NULL;
+
return 0;
out_xenbus_unmap_ring:
if (!leaked)
- xenbus_unmap_ring(dev, node->handles, nr_grefs, info.addrs);
+ xenbus_unmap_ring(dev, node->handles, nr_grefs, info->addrs);
else
pr_alert("leaking %p size %u page(s)",
addr, nr_pages);
@@ -653,7 +668,6 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
if (!leaked)
free_xenballooned_pages(nr_pages, node->hvm.pages);
out_err:
- kfree(node);
return err;
}
@@ -677,39 +691,29 @@ EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
#ifdef CONFIG_XEN_PV
static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
+ struct map_ring_valloc *info,
grant_ref_t *gnt_refs,
unsigned int nr_grefs,
void **vaddr)
{
- struct xenbus_map_node *node;
+ struct xenbus_map_node *node = info->node;
struct vm_struct *area;
- pte_t *ptes[XENBUS_MAX_RING_GRANTS];
- phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
int err = GNTST_okay;
int i;
bool leaked;
- *vaddr = NULL;
-
- if (nr_grefs > XENBUS_MAX_RING_GRANTS)
- return -EINVAL;
-
- node = kzalloc(sizeof(*node), GFP_KERNEL);
- if (!node)
- return -ENOMEM;
-
- area = alloc_vm_area(XEN_PAGE_SIZE * nr_grefs, ptes);
+ area = alloc_vm_area(XEN_PAGE_SIZE * nr_grefs, info->ptes);
if (!area) {
kfree(node);
return -ENOMEM;
}
for (i = 0; i < nr_grefs; i++)
- phys_addrs[i] = arbitrary_virt_to_machine(ptes[i]).maddr;
+ info->phys_addrs[i] =
+ arbitrary_virt_to_machine(info->ptes[i]).maddr;
err = __xenbus_map_ring(dev, gnt_refs, nr_grefs, node->handles,
- phys_addrs,
- GNTMAP_host_map | GNTMAP_contains_pte,
+ info, GNTMAP_host_map | GNTMAP_contains_pte,
&leaked);
if (err)
goto failed;
@@ -722,6 +726,8 @@ static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
spin_unlock(&xenbus_valloc_lock);
*vaddr = area->addr;
+ info->node = NULL;
+
return 0;
failed:
@@ -730,7 +736,6 @@ static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
else
pr_alert("leaking VM area %p size %u page(s)", area, nr_grefs);
- kfree(node);
return err;
}
--
2.26.1
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only
2020-05-11 7:31 [PATCH 0/2] xen/xenbus: some cleanups Juergen Gross
2020-05-11 7:31 ` [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack Juergen Gross
@ 2020-05-11 7:31 ` Juergen Gross
2020-05-11 18:32 ` Boris Ostrovsky
1 sibling, 1 reply; 6+ messages in thread
From: Juergen Gross @ 2020-05-11 7:31 UTC (permalink / raw)
To: xen-devel, linux-kernel
Cc: Juergen Gross, Boris Ostrovsky, Stefano Stabellini
Today xenbus_map_ring_valloc() can return either a negative errno
value (-ENOMEM or -EINVAL) or a grant status value. This is a mess as
e.g -ENOMEM and GNTST_eagain have the same numeric value.
Fix that by turning all grant mapping errors into -ENOENT. This is
no problem as all callers of xenbus_map_ring_valloc() only use the
return value to print an error message, and in case of mapping errors
the grant status value has already been printed by __xenbus_map_ring()
before.
Signed-off-by: Juergen Gross <jgross@suse.com>
---
drivers/xen/xenbus/xenbus_client.c | 22 ++++++----------------
1 file changed, 6 insertions(+), 16 deletions(-)
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index d8e5c5e4fa67..5e6b256ca916 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -456,8 +456,7 @@ EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
* Map @nr_grefs pages of memory into this domain from another
* domain's grant table. xenbus_map_ring_valloc allocates @nr_grefs
* pages of virtual address space, maps the pages to that address, and
- * sets *vaddr to that address. Returns 0 on success, and GNTST_*
- * (see xen/include/interface/grant_table.h) or -ENOMEM / -EINVAL on
+ * sets *vaddr to that address. Returns 0 on success, and -errno on
* error. If an error is returned, device will switch to
* XenbusStateClosing and the error message will be saved in XenStore.
*/
@@ -477,18 +476,11 @@ int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
return -ENOMEM;
info->node = kzalloc(sizeof(*info->node), GFP_KERNEL);
- if (!info->node) {
+ if (!info->node)
err = -ENOMEM;
- goto out;
- }
-
- err = ring_ops->map(dev, info, gnt_refs, nr_grefs, vaddr);
-
- /* Some hypervisors are buggy and can return 1. */
- if (err > 0)
- err = GNTST_general_error;
+ else
+ err = ring_ops->map(dev, info, gnt_refs, nr_grefs, vaddr);
- out:
kfree(info->node);
kfree(info);
return err;
@@ -507,7 +499,6 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
bool *leaked)
{
int i, j;
- int err = GNTST_okay;
if (nr_grefs > XENBUS_MAX_RING_GRANTS)
return -EINVAL;
@@ -522,7 +513,6 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
for (i = 0; i < nr_grefs; i++) {
if (info->map[i].status != GNTST_okay) {
- err = info->map[i].status;
xenbus_dev_fatal(dev, info->map[i].status,
"mapping in shared page %d from domain %d",
gnt_refs[i], dev->otherend_id);
@@ -531,7 +521,7 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
handles[i] = info->map[i].handle;
}
- return GNTST_okay;
+ return 0;
fail:
for (i = j = 0; i < nr_grefs; i++) {
@@ -554,7 +544,7 @@ static int __xenbus_map_ring(struct xenbus_device *dev,
}
}
- return err;
+ return -ENOENT;
}
/**
--
2.26.1
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack
2020-05-11 7:31 ` [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack Juergen Gross
@ 2020-05-11 18:01 ` Boris Ostrovsky
2020-05-12 9:13 ` Jürgen Groß
0 siblings, 1 reply; 6+ messages in thread
From: Boris Ostrovsky @ 2020-05-11 18:01 UTC (permalink / raw)
To: Juergen Gross, xen-devel, linux-kernel, clang-built-linux
Cc: Stefano Stabellini, Arnd Bergmann
[-- Attachment #1: Type: text/plain, Size: 1558 bytes --]
On 5/11/20 3:31 AM, Juergen Gross wrote:
>
> static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
I wonder whether we can drop valloc/vfree from xenbus_ring_ops' names.
> + struct map_ring_valloc *info,
> grant_ref_t *gnt_ref,
> unsigned int nr_grefs,
> void **vaddr)
> {
> - struct xenbus_map_node *node;
> + struct xenbus_map_node *node = info->node;
> int err;
> void *addr;
> bool leaked = false;
> - struct map_ring_valloc_hvm info = {
> - .idx = 0,
> - };
> unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
>
> - if (nr_grefs > XENBUS_MAX_RING_GRANTS)
> - return -EINVAL;
> -
> - *vaddr = NULL;
> -
> - node = kzalloc(sizeof(*node), GFP_KERNEL);
> - if (!node)
> - return -ENOMEM;
> -
> err = alloc_xenballooned_pages(nr_pages, node->hvm.pages);
> if (err)
> goto out_err;
>
> gnttab_foreach_grant(node->hvm.pages, nr_grefs,
> xenbus_map_ring_setup_grant_hvm,
> - &info);
> + info);
>
> err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
> - info.phys_addrs, GNTMAP_host_map, &leaked);
> + info, GNTMAP_host_map, &leaked);
> node->nr_handles = nr_grefs;
>
> if (err)
> @@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
> spin_unlock(&xenbus_valloc_lock);
>
> *vaddr = addr;
> + info->node = NULL;
Is this so that xenbus_map_ring_valloc() doesn't free it accidentally?
-boris
> +
> return 0;
>
>
[-- Attachment #2: pEpkey.asc --]
[-- Type: application/pgp-keys, Size: 5075 bytes --]
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only
2020-05-11 7:31 ` [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only Juergen Gross
@ 2020-05-11 18:32 ` Boris Ostrovsky
0 siblings, 0 replies; 6+ messages in thread
From: Boris Ostrovsky @ 2020-05-11 18:32 UTC (permalink / raw)
To: Juergen Gross, xen-devel, linux-kernel; +Cc: Stefano Stabellini
[-- Attachment #1: Type: text/plain, Size: 668 bytes --]
On 5/11/20 3:31 AM, Juergen Gross wrote:
> Today xenbus_map_ring_valloc() can return either a negative errno
> value (-ENOMEM or -EINVAL) or a grant status value. This is a mess as
> e.g -ENOMEM and GNTST_eagain have the same numeric value.
>
> Fix that by turning all grant mapping errors into -ENOENT. This is
> no problem as all callers of xenbus_map_ring_valloc() only use the
> return value to print an error message, and in case of mapping errors
> the grant status value has already been printed by __xenbus_map_ring()
> before.
>
> Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Boris Ostrovsky <boris.ostrovsky@oracle.com>
[-- Attachment #2: pEpkey.asc --]
[-- Type: application/pgp-keys, Size: 5075 bytes --]
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack
2020-05-11 18:01 ` Boris Ostrovsky
@ 2020-05-12 9:13 ` Jürgen Groß
0 siblings, 0 replies; 6+ messages in thread
From: Jürgen Groß @ 2020-05-12 9:13 UTC (permalink / raw)
To: Boris Ostrovsky, xen-devel, linux-kernel, clang-built-linux
Cc: Stefano Stabellini, Arnd Bergmann
On 11.05.20 20:01, Boris Ostrovsky wrote:
> On 5/11/20 3:31 AM, Juergen Gross wrote:
>>
>> static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
>
>
> I wonder whether we can drop valloc/vfree from xenbus_ring_ops' names.
I can do that.
>
>
>> + struct map_ring_valloc *info,
>> grant_ref_t *gnt_ref,
>> unsigned int nr_grefs,
>> void **vaddr)
>> {
>> - struct xenbus_map_node *node;
>> + struct xenbus_map_node *node = info->node;
>> int err;
>> void *addr;
>> bool leaked = false;
>> - struct map_ring_valloc_hvm info = {
>> - .idx = 0,
>> - };
>> unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
>>
>> - if (nr_grefs > XENBUS_MAX_RING_GRANTS)
>> - return -EINVAL;
>> -
>> - *vaddr = NULL;
>> -
>> - node = kzalloc(sizeof(*node), GFP_KERNEL);
>> - if (!node)
>> - return -ENOMEM;
>> -
>> err = alloc_xenballooned_pages(nr_pages, node->hvm.pages);
>> if (err)
>> goto out_err;
>>
>> gnttab_foreach_grant(node->hvm.pages, nr_grefs,
>> xenbus_map_ring_setup_grant_hvm,
>> - &info);
>> + info);
>>
>> err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
>> - info.phys_addrs, GNTMAP_host_map, &leaked);
>> + info, GNTMAP_host_map, &leaked);
>> node->nr_handles = nr_grefs;
>>
>> if (err)
>> @@ -641,11 +654,13 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
>> spin_unlock(&xenbus_valloc_lock);
>>
>> *vaddr = addr;
>> + info->node = NULL;
>
>
> Is this so that xenbus_map_ring_valloc() doesn't free it accidentally?
Yes.
Juergen
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2020-05-12 9:13 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-05-11 7:31 [PATCH 0/2] xen/xenbus: some cleanups Juergen Gross
2020-05-11 7:31 ` [PATCH 1/2] xen/xenbus: avoid large structs and arrays on the stack Juergen Gross
2020-05-11 18:01 ` Boris Ostrovsky
2020-05-12 9:13 ` Jürgen Groß
2020-05-11 7:31 ` [PATCH 2/2] xen/xenbus: let xenbus_map_ring_valloc() return errno values only Juergen Gross
2020-05-11 18:32 ` Boris Ostrovsky
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.