Hello,
I've corrected the parts you pointed out.
On Sat, 25 Jul 2026 02:30:07 Samuel Thibault wrote:
> I'd rather return errno rather than hardcoding ENOMEM whenever possible,
> in case malloc may have other issues, better report them precisely.
>
> (but take care that an intermediate function call may overwrite errno so
> in some case you need to save it).
Are there any recommendations for when to return errno instead of ENOMEM? If
the function is static and only checks for an error, then I don't think
there's any point in changing ENOMEM to errno. Am I correct in assuming this
primarily applies to library callbacks? I can also check all other malloc,
calloc, and realloc and return errno there if necessary. I'm not worried
about
the amount of work involved; I just need to know what exactly I need to
do. :)
Thanks,
--
Mikhail Karpov
From 5973f69afcbb48146d28a2e7a80338669e22adfe Mon Sep 17 00:00:00 2001
From: Mikhail Karpov <[email protected]>
Date: Sat, 25 Jul 2026 12:01:58 +0700
Subject: [PATCH] Added checks for alloc return value in several place
---
defpager/backing.c | 5 ++++
defpager/defpager.c | 23 ++++++++++++----
eth-multiplexer/netfs_impl.c | 9 ++++++
ext2fs/dir.c | 27 +++++++++++++++++-
fatfs/fat.c | 3 ++
fatfs/pager.c | 3 ++
libbpf/bpf_impl.c | 4 +++
libdiskfs/file-chg.c | 7 +++++
libpager/lock-object.c | 1 +
libpager/object-init.c | 7 +++++
libpager/pager-attr.c | 1 +
libps/proclist.c | 6 +++-
libps/procstat.c | 6 ++++
libstore/remap.c | 9 +++++-
lwip/lwip-util.c | 9 +++++-
lwip/pfinet-ops.c | 8 ++++++
lwip/port/netif/ifcommon.c | 3 ++
lwip/socket-ops.c | 3 ++
mach-defpager/default_pager.c | 44 ++++++++++++++++++++++++++++++
nfs/ops.c | 7 ++++-
nfsd/cache.c | 6 ++++
nfsd/fsys.c | 18 +++++++++++-
nfsd/loop.c | 3 ++
nfsd/xdr.c | 2 ++
pfinet/glue-include/linux/kernel.h | 3 ++
pfinet/socket-ops.c | 3 ++
proc/mgt.c | 1 +
procfs/dircat.c | 15 +++++++++-
startup/startup.c | 9 ++++++
term/main.c | 3 ++
term/munge.c | 2 ++
term/users.c | 12 ++++++++
trans/magic.c | 3 +-
trans/new-fifo.c | 1 +
trans/remap.c | 3 ++
utils/msgport.c | 11 ++++++++
utils/ps.c | 2 ++
utils/settrans.c | 2 +-
38 files changed, 270 insertions(+), 14 deletions(-)
diff --git a/defpager/backing.c b/defpager/backing.c
index 56fe6551..d261dcc9 100644
--- a/defpager/backing.c
+++ b/defpager/backing.c
@@ -50,6 +50,9 @@ init_backing (char *name)
bmap_len = backing_store->size / vm_page_size / NBBY;
bmap = malloc (bmap_len);
+ if (!bmap)
+ return errno;
+
for (i = 0; i < bmap_len; i++)
bmap[i] = 0xff;
bmap_rotor = bmap;
@@ -60,6 +63,8 @@ init_backing (char *name)
sure we don't tromp on the misfeature in Linux of using the first
page for permanent data. */
*bmap_rotor |= 1;
+
+ return 0;
}
int
diff --git a/defpager/defpager.c b/defpager/defpager.c
index 3b3cda1e..4508b75f 100644
--- a/defpager/defpager.c
+++ b/defpager/defpager.c
@@ -33,7 +33,7 @@ struct user_pager_info
/* Expand the P->map as necessary to handle an incoming request of the
page at ADDR. */
-static inline void
+static inline error_t
expand_map (struct user_pager_info *p, vm_offset_t addr)
{
/* See if this is beyond the current extent */
@@ -44,11 +44,16 @@ expand_map (struct user_pager_info *p, vm_offset_t addr)
newsize = page + vm_page_size;
newmap = realloc (pager->map, size / vm_page_size * sizeof (off_t));
+ if (!newmap)
+ return ENOMEM;
- memset (pager->map + pager->size / vm_page_size * sizeof(off_t), 0, (newsize - pager->size) / vm_page_size * sizeof(off_t));
+ memset (pager->map + pager->size / vm_page_size * sizeof(off_t),
+ 0, (newsize - pager->size) / vm_page_size * sizeof(off_t));
pager->size = newsize;
pager->map = newmap;
}
+
+ return 0;
}
error_t
@@ -63,10 +68,16 @@ pager_read_page (struct user_pager_info *pager,
/* We never request write locks. */
*write_lock = 0;
- expand_map (pager, page);
+ error_t err = expand_map (pager, page);
+ if (err)
+ return err;
if (!pager->map[pfn])
- vm_allocate (mach_task_self (), buf, vm_page_size, 1);
+ {
+ err = vm_allocate (mach_task_self (), buf, vm_page_size, 1);
+ if (err)
+ return err;
+ }
else
{
store_read (backing_store, pager->map[pfn], vm_page_size,
@@ -89,7 +100,9 @@ pager_write_page (struct user_pager_info *pager,
int pfn = page / vm_page_size;
size_t nwritten;
- expand_map (pager, page);
+ error_t err = expand_map (pager, page);
+ if (err)
+ return err;
if (!pager->map[pfn])
pager->map[pfn] = allocate_backing_page ();
diff --git a/eth-multiplexer/netfs_impl.c b/eth-multiplexer/netfs_impl.c
index 83a23132..97ebeb69 100644
--- a/eth-multiplexer/netfs_impl.c
+++ b/eth-multiplexer/netfs_impl.c
@@ -86,6 +86,9 @@ lookup (const char *name)
struct lnode *ln = (struct lnode *) lookup_dev_by_name (name);
char *copied_name = malloc (strlen (name) + 1);
+ if (!copied_name)
+ return NULL;
+
strcpy (copied_name, name);
if (ln)
{
@@ -305,6 +308,12 @@ error_t netfs_attempt_lookup (struct iouser *user, struct node *dir,
}
*node = lookup (name);
+ if (!*node)
+ {
+ pthread_mutex_unlock (&dir->lock);
+ return errno;
+ }
+
pthread_mutex_lock (&(*node)->lock);
pthread_mutex_unlock (&dir->lock);
return 0;
diff --git a/ext2fs/dir.c b/ext2fs/dir.c
index 55f26579..74a9ea29 100644
--- a/ext2fs/dir.c
+++ b/ext2fs/dir.c
@@ -493,6 +493,12 @@ dirscanblock (vm_address_t blockaddr, struct node *dp, int idx,
{
diskfs_node_disknode (dp)->dirents =
malloc ((dp->dn_stat.st_size / DIRBLKSIZ) * sizeof (int));
+ if (!diskfs_node_disknode (dp)->dirents)
+ {
+ ext2_warning ("Failed to allocate memory for dirents");
+ return ENOENT;
+ }
+
for (i = 0; i < dp->dn_stat.st_size/DIRBLKSIZ; i++)
diskfs_node_disknode (dp)->dirents[i] = -1;
}
@@ -687,9 +693,16 @@ diskfs_direnter_hard (struct node *dp, const char *name, struct node *np,
anything at all. */
if (diskfs_node_disknode (dp)->dirents)
{
- diskfs_node_disknode (dp)->dirents =
+ int *new_dirents =
realloc (diskfs_node_disknode (dp)->dirents,
(dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int)));
+ if (!new_dirents)
+ {
+ ext2_warning ("Failed to reallocate memory for new_dirents");
+ return ENOENT;
+ }
+
+ diskfs_node_disknode (dp)->dirents = new_dirents;
for (i = oldsize / DIRBLKSIZ;
i < dp->dn_stat.st_size / DIRBLKSIZ;
i++)
@@ -701,6 +714,12 @@ diskfs_direnter_hard (struct node *dp, const char *name, struct node *np,
{
diskfs_node_disknode (dp)->dirents =
malloc (dp->dn_stat.st_size / DIRBLKSIZ * sizeof (int));
+ if (!diskfs_node_disknode (dp)->dirents)
+ {
+ ext2_warning ("Failed to allocate memory for dirents");
+ return ENOENT;
+ }
+
for (i = 0; i < dp->dn_stat.st_size / DIRBLKSIZ; i++)
diskfs_node_disknode (dp)->dirents[i] = -1;
diskfs_node_disknode (dp)->dirents[ds->idx] = 1;
@@ -907,6 +926,12 @@ diskfs_get_directs (struct node *dp,
if (!diskfs_node_disknode (dp)->dirents)
{
diskfs_node_disknode (dp)->dirents = malloc (nblks * sizeof (int));
+ if (!diskfs_node_disknode (dp)->dirents)
+ {
+ ext2_warning ("Failed to allocate memory for dirents");
+ return ENOENT;
+ }
+
for (i = 0; i < nblks; i++)
diskfs_node_disknode (dp)->dirents[i] = -1;
}
diff --git a/fatfs/fat.c b/fatfs/fat.c
index e765376d..4af321c6 100644
--- a/fatfs/fat.c
+++ b/fatfs/fat.c
@@ -72,6 +72,9 @@ fat_read_sblock (void)
size_t read = sizeof(struct boot_sector);
sblock = malloc (read);
+ if (!sblock)
+ error (1, ENOMEM, "Failed to allocate memory for superblock.");
+
err = store_read (store, 0, read, (void **) &sblock, &read);
if (err)
error (1, err, "Could not read superblock");
diff --git a/fatfs/pager.c b/fatfs/pager.c
index e2302cec..c56f9f56 100644
--- a/fatfs/pager.c
+++ b/fatfs/pager.c
@@ -776,6 +776,9 @@ create_fat_pager (void)
/* The disk pager. */
struct user_pager_info *upi = malloc (sizeof (struct user_pager_info));
+ if (!upi)
+ error (2, ENOMEM, "Failed to allocate memory for user_pager_info.");
+
upi->type = FAT;
disk_pager_bucket = ports_create_bucket ();
diskfs_start_disk_pager (upi, disk_pager_bucket, MAY_CACHE, 0,
diff --git a/libbpf/bpf_impl.c b/libbpf/bpf_impl.c
index c78176c2..38d71aba 100644
--- a/libbpf/bpf_impl.c
+++ b/libbpf/bpf_impl.c
@@ -612,6 +612,8 @@ net_set_filter(if_filter_list_t *ifp, mach_port_t rcv_port, int priority,
* a normal packet filter structure.
*/
my_infp = (net_rcv_port_t) calloc(1, sizeof(struct net_rcv_port));
+ if (!my_infp)
+ return (D_NO_MEMORY);
my_infp->rcv_port = rcv_port;
is_new_infp = TRUE;
} else {
@@ -622,6 +624,8 @@ net_set_filter(if_filter_list_t *ifp, mach_port_t rcv_port, int priority,
*/
my_infp = 0;
hash_entp = (net_hash_entry_t) calloc(1, sizeof(struct net_hash_entry));
+ if (!hash_entp)
+ return (D_NO_MEMORY);
is_new_infp = FALSE;
}
diff --git a/libdiskfs/file-chg.c b/libdiskfs/file-chg.c
index 18170c25..40d1a4ed 100644
--- a/libdiskfs/file-chg.c
+++ b/libdiskfs/file-chg.c
@@ -43,7 +43,14 @@ diskfs_S_file_notice_changes (struct protid *cred, mach_port_t notify)
pthread_mutex_unlock (&np->lock);
return err;
}
+
req = malloc (sizeof (struct modreq));
+ if (!req)
+ {
+ pthread_mutex_unlock (&np->lock);
+ return ENOMEM;
+ }
+
req->port = notify;
req->next = np->filemod_reqs;
np->filemod_reqs = req;
diff --git a/libpager/lock-object.c b/libpager/lock-object.c
index d8a4c1f8..01114ee2 100644
--- a/libpager/lock-object.c
+++ b/libpager/lock-object.c
@@ -52,6 +52,7 @@ _pager_lock_object (struct pager *p,
if (!lr)
{
lr = malloc (sizeof (struct lock_request));
+ assert_backtrace (lr);
lr->start = offset;
lr->end = offset + size;
lr->pending_writes = 0;
diff --git a/libpager/object-init.c b/libpager/object-init.c
index 619d28f3..87b55f46 100644
--- a/libpager/object-init.c
+++ b/libpager/object-init.c
@@ -43,6 +43,13 @@ _pager_S_memory_object_init (struct pager *p,
{
#ifdef KERNEL_INIT_RACE
struct pending_init *i = malloc (sizeof (struct pending_init));
+ if (!i)
+ {
+ printf ("failed to allocate memory for pending_init");
+ pthread_mutex_unlock (&p->interlock);
+ return ENOMEM;
+ }
+
printf ("pager out-of-sequence init\n");
i->control = control;
i->name = name;
diff --git a/libpager/pager-attr.c b/libpager/pager-attr.c
index 4280e26d..66c9b61f 100644
--- a/libpager/pager-attr.c
+++ b/libpager/pager-attr.c
@@ -65,6 +65,7 @@ pager_change_attributes (struct pager *p,
if (!ar)
{
ar = malloc (sizeof (struct attribute_request));
+ assert_backtrace (ar);
ar->may_cache = may_cache;
ar->copy_strategy = copy_strategy;
ar->attrs_pending = 1;
diff --git a/libps/proclist.c b/libps/proclist.c
index e1ce4c16..bbbe03a5 100644
--- a/libps/proclist.c
+++ b/libps/proclist.c
@@ -124,7 +124,11 @@ proc_stat_list_add_pids (struct proc_stat_list *pp,
struct proc_stat **end = pp->proc_stats + pp->num_procs;
if (proc_stats)
- *proc_stats = NEWVEC (struct proc_stat *, num_procs);
+ {
+ *proc_stats = NEWVEC (struct proc_stat *, num_procs);
+ if (!*proc_stats)
+ return ENOMEM;
+ }
for (i = 0; i < num_procs; i++)
{
diff --git a/libps/procstat.c b/libps/procstat.c
index 4de4216d..a34da630 100644
--- a/libps/procstat.c
+++ b/libps/procstat.c
@@ -204,6 +204,12 @@ merge_procinfo (struct proc_stat *ps, ps_flags_t need, ps_flags_t have)
ps->thread_waits = malloc (WAITS_MALLOC_SIZE);
ps->thread_waits_len = WAITS_MALLOC_SIZE;
ps->thread_waits_vm_alloced = 0;
+ if (! ps->thread_waits)
+ {
+ if (! (have & PSTAT_PROCINFO))
+ free (new_pi);
+ return ENOMEM;
+ }
}
new_waits = ps->thread_waits;
new_waits_len = ps->thread_waits_len;
diff --git a/libstore/remap.c b/libstore/remap.c
index bbe78509..79339924 100644
--- a/libstore/remap.c
+++ b/libstore/remap.c
@@ -317,7 +317,14 @@ store_remap_runs (const struct store_run *runs, size_t num_runs,
}
if (xruns_alloced > *num_xruns)
- *xruns = realloc (*xruns, *num_xruns * sizeof (struct store_run));
+ {
+ void *new_xruns = realloc (*xruns, *num_xruns
+ * sizeof (struct store_run));
+ if (!new_xruns)
+ return 0;
+
+ xruns = new_xruns;
+ }
return 0;
}
diff --git a/lwip/lwip-util.c b/lwip/lwip-util.c
index 4a83b8f0..32b3796b 100644
--- a/lwip/lwip-util.c
+++ b/lwip/lwip-util.c
@@ -150,7 +150,10 @@ init_ifs (void *arg)
int i;
if (netif_list == 0)
- netif_list = calloc (1, sizeof (struct netif));
+ {
+ netif_list = calloc (1, sizeof (struct netif));
+ assert_backtrace (netif_list);
+ }
if (netif_list->next == 0)
init_loopback ();
@@ -186,6 +189,7 @@ init_ifs (void *arg)
continue;
netif = calloc (1, sizeof (struct netif));
+ assert_backtrace (netif);
create_netif_state (in->dev_name, &ifc);
@@ -366,6 +370,9 @@ configure_device (struct netif *netif, ip4_addr_t addr, ip4_addr_t netmask,
{
/* Call update_if() inside the tcpip_thread */
struct update_if_args *arg = calloc (1, sizeof (struct update_if_args));
+ if (!arg)
+ return ENOMEM;
+
arg->netif = netif;
arg->addr = addr;
arg->netmask = netmask;
diff --git a/lwip/pfinet-ops.c b/lwip/pfinet-ops.c
index 0755fcb3..b9d2ef25 100644
--- a/lwip/pfinet-ops.c
+++ b/lwip/pfinet-ops.c
@@ -106,6 +106,9 @@ lwip_S_pfinet_siocgifconf (io_t port,
void *buf = mmap (0, amount, PROT_READ | PROT_WRITE,
MAP_ANON, 0, 0);
if (buf == MAP_FAILED)
+ /* Should check whether errno is indeed ENOMEM --
+ but this can't be done in a straightforward way,
+ because the glue headers #undef errno. */
return ENOMEM;
ifc.ifc_buf = buf;
@@ -209,6 +212,8 @@ lwip_S_pfinet_getroutes (io_t port,
*dealloc_data = FALSE;
rtable = calloc (MAX_ROUTES, sizeof (ifrtreq_t));
+ if (!rtable)
+ return ENOMEM;
available_count = get_routes (rtable);
@@ -231,6 +236,9 @@ lwip_S_pfinet_getroutes (io_t port,
if (*routes == MAP_FAILED)
{
+ /* Should check whether errno is indeed ENOMEM --
+ but this can't be done in a straightforward way,
+ because the glue headers #undef errno. */
*len = 0;
return ENOMEM;
}
diff --git a/lwip/port/netif/ifcommon.c b/lwip/port/netif/ifcommon.c
index cc4290a0..a86c4edf 100644
--- a/lwip/port/netif/ifcommon.c
+++ b/lwip/port/netif/ifcommon.c
@@ -156,6 +156,9 @@ if_change_flags (struct netif * netif, uint16_t flags)
*/
struct if_change_flags_args *args =
calloc (1, sizeof (struct if_change_flags_args));
+ if (!args)
+ return ENOMEM;
+
args->netif = netif;
args->flags = flags;
err = tcpip_callback_wait(_if_change_flags, args);
diff --git a/lwip/socket-ops.c b/lwip/socket-ops.c
index 55f5a606..b422f289 100644
--- a/lwip/socket-ops.c
+++ b/lwip/socket-ops.c
@@ -291,6 +291,9 @@ lwip_S_socket_whatis_address (struct sock_addr * addr,
void *buf = mmap (0, addr->address.sa.sa_len, PROT_READ | PROT_WRITE,
MAP_ANON, 0, 0);
if (buf == MAP_FAILED)
+ /* Should check whether errno is indeed ENOMEM --
+ but this can't be done in a straightforward way,
+ because the glue headers #undef errno. */
return ENOMEM;
*data = buf;
diff --git a/mach-defpager/default_pager.c b/mach-defpager/default_pager.c
index e55fa642..813a0a53 100644
--- a/mach-defpager/default_pager.c
+++ b/mach-defpager/default_pager.c
@@ -188,13 +188,20 @@ new_partition (const char *name, struct file_direct *fdp,
bmsize = howmany(size, NB_BM) * sizeof(bm_entry_t);
part = (partition_t) malloc(sizeof(struct part));
+ if (!part)
+ panic("(default pager): failed to allocate memory for part");
pthread_mutex_init(&part->p_lock, NULL);
part->name = (char*) malloc(n + 1);
+ if (!part->name)
+ panic("(default pager): failed to allocate memory for part->name");
strcpy(part->name, name);
part->total_size = size;
part->free = size;
part->id = id;
part->bitmap = (bm_entry_t *)malloc(bmsize);
+ if (!part->bitmap)
+ panic("(default pager): "
+ "failed to allocate memory for part->bitmap");
part->going_away= FALSE;
part->file = fdp;
@@ -633,6 +640,8 @@ dp_map_t pager_get_direct_map(dpager_t pager)
}
mapptr = (dp_map_t) malloc(alloc_size);
+ if (!mapptr)
+ panic("(default pager): failed to allocate memory for mapptr");
for (emapptr = &mapptr[(alloc_size-1) / sizeof(vm_offset_t)];
emapptr >= mapptr;
emapptr--)
@@ -683,10 +692,16 @@ pager_alloc(dpager_t pager,
if (INDIRECT_PAGEMAP(size)) {
mapptr = (vm_offset_t *)
malloc(INDIRECT_PAGEMAP_SIZE(size));
+ if (!mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for mapptr");
for (i = INDIRECT_PAGEMAP_ENTRIES(size); --i >= 0;)
mapptr[i] = 0;
} else {
mapptr = (vm_offset_t *) malloc(PAGEMAP_SIZE(size));
+ if (!mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for mapptr");
for (i = 0; i < size; i++)
mapptr[i] = NO_CHECKSUM;
}
@@ -828,6 +843,9 @@ pager_extend(dpager_t pager,
*/
new_mapptr = (dp_map_t)
malloc(INDIRECT_PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager_get_direct_map(pager);
for (i = 0; i < INDIRECT_PAGEMAP_ENTRIES(old_size); i++)
new_mapptr[i] = old_mapptr[i];
@@ -839,6 +857,9 @@ pager_extend(dpager_t pager,
#ifdef CHECKSUM
new_mapptr = (vm_offset_t *)
malloc(INDIRECT_PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager->checksum;
for (i = 0; i < INDIRECT_PAGEMAP_ENTRIES(old_size); i++)
new_mapptr[i] = old_mapptr[i];
@@ -873,6 +894,9 @@ pager_extend(dpager_t pager,
* Allocate new second-level map first.
*/
new_mapptr = (dp_map_t) malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager_get_direct_map(pager);
for (i = 0; i < old_size; i++)
new_mapptr[i] = old_mapptr[i];
@@ -894,6 +918,9 @@ pager_extend(dpager_t pager,
*/
new_mapptr = (dp_map_t)
malloc(INDIRECT_PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
new_mapptr[0].indirect = old_mapptr;
for (i = 1; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
new_mapptr[i].indirect = 0;
@@ -904,6 +931,9 @@ pager_extend(dpager_t pager,
* Allocate new second-level map first.
*/
new_mapptr = (vm_offset_t *)malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager->checksum;
for (i = 0; i < old_size; i++)
new_mapptr[i] = old_mapptr[i];
@@ -917,6 +947,9 @@ pager_extend(dpager_t pager,
*/
new_mapptr = (vm_offset_t *)
malloc(INDIRECT_PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
new_mapptr[0] = (vm_offset_t) old_mapptr;
for (i = 1; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
new_mapptr[i] = 0;
@@ -932,6 +965,9 @@ pager_extend(dpager_t pager,
* Enlarging a direct block.
*/
new_mapptr = (dp_map_t) malloc(PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager_get_direct_map(pager);
for (i = 0; i < old_size; i++)
new_mapptr[i] = old_mapptr[i];
@@ -943,6 +979,9 @@ pager_extend(dpager_t pager,
#ifdef CHECKSUM
new_mapptr = (vm_offset_t *)
malloc(PAGEMAP_SIZE(new_size));
+ if (!new_mapptr)
+ panic("(default pager): "
+ "failed to allocate memory for new_mapptr");
old_mapptr = pager->checksum;
for (i = 0; i < old_size; i++)
new_mapptr[i] = old_mapptr[i];
@@ -1021,6 +1060,9 @@ pager_truncate(dpager_t pager, vm_size_t new_size) /* in pages */
{
const dp_map_t old_mapptr = pager->map;
pager->map = (dp_map_t) malloc (INDIRECT_PAGEMAP_SIZE(new_size));
+ if (!pager->map)
+ panic("(default pager): "
+ "failed to allocate memory for pager->map");
memcpy (pager->map, old_mapptr, INDIRECT_PAGEMAP_SIZE(new_size));
free ((char *) old_mapptr);
}
@@ -1042,6 +1084,8 @@ pager_truncate(dpager_t pager, vm_size_t new_size) /* in pages */
/* Now reduce the size of the direct map itself. */
const dp_map_t old_mapptr = pager->map;
pager->map = (dp_map_t) malloc (PAGEMAP_SIZE (new_size));
+ if (!pager->map)
+ panic("(default pager): failed to allocate memory for pager->map");
memcpy (pager->map, old_mapptr, PAGEMAP_SIZE (new_size));
free ((char *) old_mapptr);
}
diff --git a/nfs/ops.c b/nfs/ops.c
index affdd931..1bbf7e1d 100644
--- a/nfs/ops.c
+++ b/nfs/ops.c
@@ -2086,10 +2086,15 @@ netfs_attempt_mksymlink (struct iouser *cred,
if (np->nn->dtrans == NOT_POSSIBLE)
return EOPNOTSUPP;
+ char *name = malloc (strlen (arg) + 1);
+ if (!name)
+ return ENOMEM;
+
if (np->nn->dtrans == SYMLINK)
free (np->nn->transarg.name);
- np->nn->transarg.name = malloc (strlen (arg) + 1);
+ np->nn->transarg.name = name;
+
strcpy (np->nn->transarg.name, arg);
np->nn->dtrans = SYMLINK;
np->nn->stat_updated = 0;
diff --git a/nfsd/cache.c b/nfsd/cache.c
index 864739c0..f13a8ca5 100644
--- a/nfsd/cache.c
+++ b/nfsd/cache.c
@@ -106,10 +106,13 @@ idspec_lookup (int nuids, int ngids, int *uids, int *gids)
assert_backtrace (sizeof (uid_t) == sizeof (int));
i = malloc (sizeof (struct idspec));
+ assert_backtrace (i);
i->nuids = nuids;
i->ngids = ngids;
i->uids = malloc (nuids * sizeof (uid_t));
i->gids = malloc (ngids * sizeof (gid_t));
+ assert_backtrace (i->uids);
+ assert_backtrace (i->gids);
memcpy (i->uids, uids, nuids * sizeof (uid_t));
memcpy (i->gids, gids, ngids * sizeof (gid_t));
i->references = 1;
@@ -304,6 +307,7 @@ lookup_cache_handle (int *p, struct cache_handle **cp, struct idspec *i)
}
c = malloc (sizeof (struct cache_handle));
+ assert_backtrace (c);
memcpy (c->handle.array, p, NFS2_FHSIZE);
cred_ref (i);
c->ids = i;
@@ -448,6 +452,7 @@ create_cached_handle (int fs, struct cache_handle *credc, file_t userport)
/* Create it anew. */
c = malloc (sizeof (struct cache_handle));
+ assert_backtrace (c);
memcpy (c->handle.array, fhandle.array, NFS2_FHSIZE);
cred_ref (credc->ids);
c->ids = credc->ids;
@@ -498,6 +503,7 @@ check_cached_replies (int xid,
}
cr = malloc (sizeof (struct cached_reply));
+ assert_backtrace (cr);
pthread_mutex_init (&cr->lock, NULL);
pthread_mutex_lock (&cr->lock);
memcpy (&cr->source, sender, sizeof (struct sockaddr_in));
diff --git a/nfsd/fsys.c b/nfsd/fsys.c
index f7467165..def443e2 100644
--- a/nfsd/fsys.c
+++ b/nfsd/fsys.c
@@ -24,6 +24,7 @@
#include <hurd.h>
#include <fcntl.h>
#include <string.h>
+#include <assert-backtrace.h>
#include "nfsd.h"
@@ -54,6 +55,12 @@ init_filesystems (void)
fsystable = (struct fsys_spec *) malloc ((fsystablesize = 10)
* sizeof (struct fsys_spec));
+ if (!fsystable)
+ {
+ error (0, ENOMEM, "Failed to allocate memory for fsystable");
+ return;
+ }
+
for (i = 0; i < fsystablesize; i++)
{
fsystable[i].fsys = MACH_PORT_NULL;
@@ -96,8 +103,15 @@ init_filesystems (void)
if (index >= fsystablesize)
{
- fsystable = (struct fsys_spec *)
+ void *new_fsystable =
realloc (fsystable, index * 2 * sizeof (struct fsys_spec));
+ if (!new_fsystable)
+ {
+ error (0, ENOMEM, "Cannot reallocate memory for fsystable");
+ return;
+ }
+
+ fsystable = new_fsystable;
for (i = fsystablesize; i < index * 2; i++)
{
fsystable[i].fsys = MACH_PORT_NULL;
@@ -190,6 +204,7 @@ enter_filesystem (char *name, file_t root)
fsystable = (struct fsys_spec *) realloc (fsystable,
(fsystablesize * 2)
* sizeof (struct fsys_spec));
+ assert_backtrace (fsystable);
for (i = fsystablesize; i < fsystablesize * 2; i++)
{
fsystable[i].fsys = MACH_PORT_NULL;
@@ -199,6 +214,7 @@ enter_filesystem (char *name, file_t root)
}
fsystable[nfsys].name = malloc (strlen (name) + 1);
+ assert_backtrace (fsystable[nfsys].name);
strcpy (fsystable[nfsys].name, name);
file_getcontrol (root, &fsystable[nfsys].fsys);
nfsys++;
diff --git a/nfsd/loop.c b/nfsd/loop.c
index 8e3ab251..386a9043 100644
--- a/nfsd/loop.c
+++ b/nfsd/loop.c
@@ -20,6 +20,7 @@
#include <string.h>
#include <fcntl.h>
+#include <assert-backtrace.h>
#include "nfsd.h"
@@ -81,6 +82,7 @@ server_loop (void *arg)
goto repost_reply;
r = (int *) (rbuf = malloc (MAXIOSIZE));
+ assert_backtrace (r);
if (ntohl (*p) != RPC_MSG_VERSION)
{
@@ -177,6 +179,7 @@ server_loop (void *arg)
{
free (rbuf);
r = (int *) (rbuf = malloc (amt));
+ assert_backtrace (r);
}
}
diff --git a/nfsd/xdr.c b/nfsd/xdr.c
index 8b175595..c40dc1ed 100644
--- a/nfsd/xdr.c
+++ b/nfsd/xdr.c
@@ -23,6 +23,7 @@
#include <sys/stat.h>
#include <sys/statfs.h>
#include <string.h>
+#include <assert-backtrace.h>
#include "nfsd.h"
/* Any better ideas? */
@@ -96,6 +97,7 @@ decode_name (int *p, char **name)
len = ntohl (*p);
p++;
*name = malloc (len + 1);
+ assert_backtrace (*name);
memcpy (*name, p, len);
(*name)[len] = '\0';
return p + INTSIZE (len);
diff --git a/pfinet/glue-include/linux/kernel.h b/pfinet/glue-include/linux/kernel.h
index 62ba2ff1..e34c0a77 100644
--- a/pfinet/glue-include/linux/kernel.h
+++ b/pfinet/glue-include/linux/kernel.h
@@ -46,6 +46,9 @@ static inline int
getname (const char *name, char **newp)
{
*newp = malloc (strlen (name) + 1);
+ if (!*newp)
+ return ENOMEM;
+
strcpy (*newp, name);
return 0;
}
diff --git a/pfinet/socket-ops.c b/pfinet/socket-ops.c
index ff2e82bb..5c587faa 100644
--- a/pfinet/socket-ops.c
+++ b/pfinet/socket-ops.c
@@ -349,6 +349,9 @@ S_socket_whatis_address (struct sock_addr *addr,
void *new_data = mmap (0, addr->address.sa_len, PROT_READ|PROT_WRITE,
MAP_ANON, 0, 0);
if (new_data == MAP_FAILED)
+ /* Should check whether errno is indeed ENOMEM --
+ but this can't be done in a straightforward way,
+ because the glue headers #undef errno. */
return ENOMEM;
*data = new_data;
diff --git a/proc/mgt.c b/proc/mgt.c
index dcb619af..05af823f 100644
--- a/proc/mgt.c
+++ b/proc/mgt.c
@@ -885,6 +885,7 @@ complete_proc (struct proc *p, pid_t pid)
if (!nulllogin)
{
nulllogin = malloc (sizeof (struct login) + sizeof (nullsname) + 1);
+ assert_backtrace (nulllogin);
nulllogin->l_refcnt = 1;
strcpy (nulllogin->l_name, nullsname);
}
diff --git a/procfs/dircat.c b/procfs/dircat.c
index 5a60899a..c257927c 100644
--- a/procfs/dircat.c
+++ b/procfs/dircat.c
@@ -36,6 +36,8 @@ dircat_get_contents (void *hook, char **contents, ssize_t *contents_len)
pos = 0;
*contents = malloc (sz = 512);
+ if (!*contents)
+ return ENOMEM;
for (i=0; i < dcn->num_dirs; i++)
{
@@ -53,8 +55,19 @@ dircat_get_contents (void *hook, char **contents, ssize_t *contents_len)
return err;
}
+ char *new_contents;
while (pos + sublen > sz)
- *contents = realloc (*contents, sz *= 2);
+ {
+ new_contents = realloc (*contents, sz *= 2);
+ if (!new_contents)
+ {
+ free (*contents);
+ *contents = NULL;
+ return ENOMEM;
+ }
+
+ *contents = new_contents;
+ }
memcpy (*contents + pos, subcon, sublen);
pos += sublen;
diff --git a/startup/startup.c b/startup/startup.c
index fe409f5c..8aa078af 100644
--- a/startup/startup.c
+++ b/startup/startup.c
@@ -1586,10 +1586,19 @@ S_startup_request_notification (mach_port_t server,
calls; this is important. We need later notification requests
to get executed first. */
nt = malloc (sizeof (struct ntfy_task));
+ if (!nt)
+ return ENOMEM;
+
nt->notify_port = notify;
nt->next = ntfy_tasks;
ntfy_tasks = nt;
nt->name = malloc (strlen (name) + 1);
+ if (!nt->name)
+ {
+ free (nt);
+ return ENOMEM;
+ }
+
strcpy (nt->name, name);
return 0;
}
diff --git a/term/main.c b/term/main.c
index 99ce2c66..9c1d807d 100644
--- a/term/main.c
+++ b/term/main.c
@@ -132,6 +132,9 @@ parse_opt (int opt, char *arg, struct argp_state *state)
case ARGP_KEY_INIT:
state->hook = calloc (1, sizeof *v);
+ if (!state->hook)
+ argp_failure (state, ENOMEM, 0, "Failed to allocate memory for"
+ " state->hook");
break;
case ARGP_KEY_FINI:
free (v);
diff --git a/term/munge.c b/term/munge.c
index 0903dd03..ca27ac15 100644
--- a/term/munge.c
+++ b/term/munge.c
@@ -752,6 +752,8 @@ reallocate_queue (struct queue *q)
/* Make the queue twice as large. */
newq = malloc (sizeof (struct queue)
+ q->arraylen * 2 * sizeof (quoted_char));
+ assert_backtrace (newq);
+
newq->susp = q->susp;
newq->lowat = q->lowat;
newq->hiwat = q->hiwat;
diff --git a/term/users.c b/term/users.c
index 629534ff..1dbf41e8 100644
--- a/term/users.c
+++ b/term/users.c
@@ -445,6 +445,11 @@ S_term_open_ctty (struct trivfs_protid *cred,
if (!err)
{
struct protid_hook *hook = malloc (sizeof (struct protid_hook));
+ if (!hook)
+ {
+ ports_port_deref (newcred);
+ return ENOMEM;
+ }
hook->pid = pid;
hook->pgrp = pgrp;
@@ -1938,7 +1943,14 @@ trivfs_S_io_async (struct trivfs_protid *cred,
pthread_mutex_unlock (&global_lock);
return EBADF;
}
+
ar = malloc (sizeof (struct async_req));
+ if (!ar)
+ {
+ pthread_mutex_unlock (&global_lock);
+ return ENOMEM;
+ }
+
ar->notify = notify;
ar->next = async_requests;
async_requests = ar;
diff --git a/trans/magic.c b/trans/magic.c
index 73fdaea3..d7e4146a 100644
--- a/trans/magic.c
+++ b/trans/magic.c
@@ -427,7 +427,7 @@ parse_opt (int opt, char *arg, struct argp_state *state)
void *buf = mmap (0, getpagesize (), PROT_READ|PROT_WRITE,
MAP_ANON, 0, 0);
if (buf == MAP_FAILED)
- return errno;
+ argp_failure (state, errno, 0, "Failed to allocate memory");
m->dirbuf = buf;
struct dirent *d;
d = add (m->dirbuf, ".");
@@ -462,6 +462,7 @@ main (int argc, char **argv)
mach_port_t bootstrap;
struct trivfs_control *fsys;
struct magic *m = calloc (1, sizeof *m);
+ assert_backtrace (m);
argp_parse (&argp, argc, argv, 0, 0, m);
diff --git a/trans/new-fifo.c b/trans/new-fifo.c
index 7880eb24..ee8f4820 100644
--- a/trans/new-fifo.c
+++ b/trans/new-fifo.c
@@ -100,6 +100,7 @@ static void
fifo_trans_create (struct fifo_trans *from, struct fifo_trans **trans)
{
struct fifo_trans *new = malloc (sizeof (struct fifo_trans));
+ assert_backtrace (new);
new->server = 0;
pthread_mutex_init (&new->active_fifo_lock, NULL);
diff --git a/trans/remap.c b/trans/remap.c
index 39d6ff92..b91fe10b 100644
--- a/trans/remap.c
+++ b/trans/remap.c
@@ -124,6 +124,9 @@ parse_opt (int key, char *arg, struct argp_state *state)
{
/* Second of a pair */
struct remap *remap = malloc (sizeof (*remap));
+ if (!remap)
+ argp_failure (state, ENOMEM, 0, "Failed to allocate memory for"
+ " remap");
remap->from = remap_from;
remap->to = strdup (arg);
remap->next = remaps;
diff --git a/utils/msgport.c b/utils/msgport.c
index e3ea4302..45b2e8bf 100644
--- a/utils/msgport.c
+++ b/utils/msgport.c
@@ -555,6 +555,8 @@ add_cmd (cmd_func_t func, size_t minargs, size_t maxargs,
struct cmds_argp_params *params = state->input;
size_t num_cmds = *params->num_cmds + 1;
cmd_t *cmds = realloc (*params->cmds, num_cmds * sizeof(cmd_t));
+ if (!cmds)
+ return ENOMEM;
*params->cmds = cmds;
*params->num_cmds = num_cmds;
@@ -565,6 +567,12 @@ add_cmd (cmd_func_t func, size_t minargs, size_t maxargs,
if (maxargs)
{
cmd->args = malloc (maxargs * sizeof (char *));
+ if (!cmd->args)
+ {
+ free (cmds);
+ return ENOMEM;
+ }
+
if (arg)
cmd->args[i++] = arg;
while (i < maxargs
@@ -596,6 +604,9 @@ parse_cmd_opt (int key, char *arg, struct argp_state *state)
re-parse it with 2 dashes prepended. */
size_t len = strlen (arg) + 1;
arg_hack_buf = realloc (arg_hack_buf, 2 + len);
+ if (!arg_hack_buf)
+ argp_failure (state, ENOMEM, 0, "Failed to reallocate memory for"
+ " arg_hack_buf");
state->argv[--state->next] = arg_hack_buf;
state->argv[state->next][0] = '-';
state->argv[state->next][1] = '-';
diff --git a/utils/ps.c b/utils/ps.c
index 6a08f736..14dac8db 100644
--- a/utils/ps.c
+++ b/utils/ps.c
@@ -276,6 +276,8 @@ main(int argc, char *argv[])
{
size_t len = strlen (arg) + 1;
arg_hack_buf = realloc (arg_hack_buf, 1 + len);
+ if (!arg_hack_buf)
+ return ENOMEM;
state->argv[--state->next] = arg_hack_buf;
state->argv[state->next][0] = '-';
memcpy (&state->argv[state->next][1], arg, len);
diff --git a/utils/settrans.c b/utils/settrans.c
index 1622f708..1407504d 100644
--- a/utils/settrans.c
+++ b/utils/settrans.c
@@ -121,7 +121,7 @@ get_credentials (void)
return errno;
gids = malloc (gids_len * sizeof (gid_t));
- if (! uids)
+ if (! gids)
return ENOMEM;
gids_len = getgroups (gids_len, gids);
--
2.43.0
