From b295b475d60d90b6e66336f28540be2f199ca9b6 Mon Sep 17 00:00:00 2001
From: Ian Kumlien <pomac@demius.net>
Date: Fri, 25 Jan 2013 23:44:48 +0100
Subject: [PATCH] [RFC] Abort on memory allocation failure.
declare btrfs_<calloc|malloc|strdup|strndup>, verify the memory
and abort() if allocation fails.
Please verify, there is a small glitch about strndup being redefined
during compilation - haven't had time to figure out why this happened.
Another issue is that there seems to be a malloc failure tracking,
which will no longer work.
---
bit-radix.c | 4 +---
btrfs-image.c | 32 ++++++++++----------------
btrfs-list.c | 66 ++++++++++++-----------------------------------------
btrfs-map-logical.c | 2 +-
btrfs-vol.c | 4 ++--
btrfsck.c | 30 +++++++++++-------------
btrfsctl.c | 4 ++--
calc-size.c | 6 +----
cmds-filesystem.c | 4 +---
cmds-inspect.c | 8 ++-----
cmds-receive.c | 16 ++++++-------
cmds-scrub.c | 20 ++++++----------
cmds-send.c | 2 +-
cmds-subvolume.c | 14 ++++++------
convert.c | 40 ++++++++------------------------
disk-io.c | 22 ++++++++----------
extent-cache.c | 4 +---
extent_io.c | 10 ++------
find-root.c | 25 +++++++-------------
kerncompat.h | 7 +++---
mkfs.c | 24 ++++++++-----------
qgroup.c | 6 +----
quick-test.c | 2 +-
radix-tree.c | 8 +++----
repair.c | 4 +---
restore.c | 27 ++++------------------
send-stream.c | 4 +---
send-utils.c | 8 +++----
transaction.h | 4 +++-
utils-alloc.h | 45 ++++++++++++++++++++++++++++++++++++
utils.c | 32 ++++++--------------------
utils.h | 2 ++
volumes.c | 9 ++------
33 files changed, 189 insertions(+), 306 deletions(-)
create mode 100644 utils-alloc.h
@@ -34,9 +34,7 @@ int set_radix_bit(struct radix_tree_root *radix, unsigned long bit)
bits = radix_tree_lookup(radix, slot);
if (!bits) {
- bits = malloc(BIT_ARRAY_BYTES);
- if (!bits)
- return -ENOMEM;
+ bits = btrfs_malloc(BIT_ARRAY_BYTES);
memset(bits + 1, 0, BIT_ARRAY_BYTES - sizeof(unsigned long));
bits[0] = slot;
radix_tree_preload(GFP_NOFS);
@@ -214,7 +214,7 @@ static void *dump_worker(void *data)
u8 *orig = async->buffer;
async->bufsize = compressBound(async->size);
- async->buffer = malloc(async->bufsize);
+ async->buffer = btrfs_malloc(async->bufsize);
ret = compress2(async->buffer,
(unsigned long *)&async->bufsize,
@@ -260,18 +260,15 @@ static int metadump_init(struct metadump_struct *md, struct btrfs_root *root,
md->out = out;
md->pending_start = (u64)-1;
md->compress_level = compress_level;
- md->cluster = calloc(1, BLOCK_SIZE);
- if (!md->cluster)
- return -ENOMEM;
+ md->cluster = btrfs_calloc(1, BLOCK_SIZE);
meta_cluster_init(md, 0);
if (!num_threads)
return 0;
md->num_threads = num_threads;
- md->threads = calloc(num_threads, sizeof(pthread_t));
- if (!md->threads)
- return -ENOMEM;
+ md->threads = btrfs_calloc(num_threads, sizeof(pthread_t));
+
for (i = 0; i < num_threads; i++) {
ret = pthread_create(md->threads + i, NULL, dump_worker, md);
if (ret)
@@ -377,14 +374,12 @@ static int flush_pending(struct metadump_struct *md, int done)
int ret;
if (md->pending_size) {
- async = calloc(1, sizeof(*async));
- if (!async)
- return -ENOMEM;
+ async = btrfs_calloc(1, sizeof(*async));
async->start = md->pending_start;
async->size = md->pending_size;
async->bufsize = async->size;
- async->buffer = malloc(async->bufsize);
+ async->buffer = btrfs_malloc(async->bufsize);
offset = 0;
start = async->start;
@@ -610,8 +605,7 @@ static void *restore_worker(void *data)
int ret;
outfd = fileno(mdres->out);
- buffer = malloc(MAX_PENDING_SIZE * 2);
- BUG_ON(!buffer);
+ buffer = btrfs_malloc(MAX_PENDING_SIZE * 2);
while (1) {
pthread_mutex_lock(&mdres->mutex);
@@ -671,9 +665,8 @@ static int mdresotre_init(struct mdrestore_struct *mdres,
return 0;
mdres->num_threads = num_threads;
- mdres->threads = calloc(num_threads, sizeof(pthread_t));
- if (!mdres->threads)
- return -ENOMEM;
+ mdres->threads = btrfs_calloc(num_threads, sizeof(pthread_t));
+
for (i = 0; i < num_threads; i++) {
ret = pthread_create(mdres->threads + i, NULL, restore_worker,
mdres);
@@ -716,10 +709,10 @@ static int add_cluster(struct meta_cluster *cluster,
nritems = le32_to_cpu(header->nritems);
for (i = 0; i < nritems; i++) {
item = &cluster->items[i];
- async = calloc(1, sizeof(*async));
+ async = btrfs_calloc(1, sizeof(*async));
async->start = le64_to_cpu(item->bytenr);
async->bufsize = le32_to_cpu(item->size);
- async->buffer = malloc(async->bufsize);
+ async->buffer = btrfs_malloc(async->bufsize);
ret = fread(async->buffer, async->bufsize, 1, mdres->in);
BUG_ON(ret != 1);
bytenr += async->bufsize;
@@ -777,8 +770,7 @@ static int restore_metadump(const char *input, FILE *out, int num_threads)
}
}
- cluster = malloc(BLOCK_SIZE);
- BUG_ON(!cluster);
+ cluster = btrfs_malloc(BLOCK_SIZE);
ret = mdresotre_init(&mdrestore, in, out, num_threads);
BUG_ON(ret);
@@ -264,11 +264,7 @@ struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void)
size = sizeof(struct btrfs_list_comparer_set) +
BTRFS_LIST_NCOMPS_INCREASE * sizeof(struct btrfs_list_comparer);
- set = malloc(size);
- if (!set) {
- fprintf(stderr, "memory allocation failed\n");
- exit(1);
- }
+ set = btrfs_malloc(size);
memset(set, 0, size);
set->total = BTRFS_LIST_NCOMPS_INCREASE;
@@ -446,11 +442,7 @@ static int update_root(struct root_lookup *root_lookup,
if (ri->name)
free(ri->name);
- ri->name = malloc(name_len + 1);
- if (!ri->name) {
- fprintf(stderr, "memory allocation failed\n");
- exit(1);
- }
+ ri->name = btrfs_malloc(name_len + 1);
strncpy(ri->name, name, name_len);
ri->name[name_len] = 0;
}
@@ -503,20 +495,12 @@ static int add_root(struct root_lookup *root_lookup,
if (!ret)
return 0;
- ri = malloc(sizeof(*ri));
- if (!ri) {
- printf("memory allocation failed\n");
- exit(1);
- }
+ ri = btrfs_malloc(sizeof(*ri));
memset(ri, 0, sizeof(*ri));
ri->root_id = root_id;
if (name && name_len > 0) {
- ri->name = malloc(name_len + 1);
- if (!ri->name) {
- fprintf(stderr, "memory allocation failed\n");
- exit(1);
- }
+ ri->name = btrfs_malloc(name_len + 1);
strncpy(ri->name, name, name_len);
ri->name[name_len] = 0;
}
@@ -602,11 +586,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
int add_len = strlen(found->path);
/* room for / and for null */
- tmp = malloc(add_len + 2 + len);
- if (!tmp) {
- perror("malloc failed");
- exit(1);
- }
+ tmp = btrfs_malloc(add_len + 2 + len);
if (full_path) {
memcpy(tmp + add_len + 1, full_path, len);
tmp[add_len] = '/';
@@ -616,7 +596,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
full_path = tmp;
len += add_len + 1;
} else {
- full_path = strdup(found->path);
+ full_path = btrfs_strdup(found->path);
len = add_len;
}
@@ -631,7 +611,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
char p[] = "<FS_TREE>";
add_len = strlen(p);
len = strlen(full_path);
- tmp = malloc(len + add_len + 2);
+ tmp = btrfs_malloc(len + add_len + 2);
memcpy(tmp + add_len + 1, full_path, len);
tmp[add_len] = '/';
memcpy(tmp, p, add_len);
@@ -690,20 +670,12 @@ static int lookup_ino_path(int fd, struct root_info *ri)
* we're in a subdirectory of ref_tree, the kernel ioctl
* puts a / in there for us
*/
- ri->path = malloc(strlen(ri->name) + strlen(args.name) + 1);
- if (!ri->path) {
- perror("malloc failed");
- exit(1);
- }
+ ri->path = btrfs_malloc(strlen(ri->name) + strlen(args.name) + 1);
strcpy(ri->path, args.name);
strcat(ri->path, ri->name);
} else {
/* we're at the root of ref_tree */
- ri->path = strdup(ri->name);
- if (!ri->path) {
- perror("strdup failed");
- exit(1);
- }
+ ri->path = btrfs_strdup(ri->name);
}
return 0;
}
@@ -834,11 +806,7 @@ static char *__ino_resolve(int fd, u64 dirid)
* we're in a subdirectory of ref_tree, the kernel ioctl
* puts a / in there for us
*/
- full = strdup(args.name);
- if (!full) {
- perror("malloc failed");
- return ERR_PTR(-ENOMEM);
- }
+ full = btrfs_strdup(args.name);
} else {
/* we're at the root of ref_tree */
full = NULL;
@@ -854,11 +822,9 @@ char *build_name(char *dirid, char *name)
{
char *full;
if (!dirid)
- return strdup(name);
+ return btrfs_strdup(name);
- full = malloc(strlen(dirid) + strlen(name) + 1);
- if (!full)
- return NULL;
+ full = btrfs_malloc(strlen(dirid) + strlen(name) + 1);
strcpy(full, dirid);
strcat(full, name);
return full;
@@ -923,7 +889,7 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
namelen = btrfs_stack_inode_ref_name_len(ref);
name = (char *)(ref + 1);
- name = strndup(name, namelen);
+ name = btrfs_strndup(name, namelen);
/* use our cached value */
if (dirid == *cache_dirid && *cache_name) {
@@ -1196,11 +1162,7 @@ struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void)
size = sizeof(struct btrfs_list_filter_set) +
BTRFS_LIST_NFILTERS_INCREASE * sizeof(struct btrfs_list_filter);
- set = malloc(size);
- if (!set) {
- fprintf(stderr, "memory allocation failed\n");
- exit(1);
- }
+ set = btrfs_malloc(size);
memset(set, 0, size);
set->total = BTRFS_LIST_NFILTERS_INCREASE;
@@ -148,7 +148,7 @@ int main(int ac, char **av)
}
break;
case 'o':
- output_file = strdup(optarg);
+ output_file = btrfs_strdup(optarg);
break;
default:
print_usage();
@@ -91,14 +91,14 @@ int main(int ac, char **av)
break;
switch(c) {
case 'a':
- device = strdup(optarg);
+ device = btrfs_strdup(optarg);
cmd = BTRFS_IOC_ADD_DEV;
break;
case 'b':
cmd = BTRFS_IOC_BALANCE;
break;
case 'r':
- device = strdup(optarg);
+ device = btrfs_strdup(optarg);
cmd = BTRFS_IOC_RM_DEV;
break;
default:
@@ -230,14 +230,14 @@ static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
struct inode_backref *orig;
size_t size;
- rec = malloc(sizeof(*rec));
+ rec = btrfs_malloc(sizeof(*rec));
memcpy(rec, orig_rec, sizeof(*rec));
rec->refs = 1;
INIT_LIST_HEAD(&rec->backrefs);
list_for_each_entry(orig, &orig_rec->backrefs, list) {
size = sizeof(*orig) + orig->namelen + 1;
- backref = malloc(size);
+ backref = btrfs_malloc(size);
memcpy(backref, orig, size);
list_add_tail(&backref->list, &rec->backrefs);
}
@@ -262,14 +262,14 @@ static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
rec = node->data;
}
} else if (mod) {
- rec = calloc(1, sizeof(*rec));
+ rec = btrfs_calloc(1, sizeof(*rec));
rec->ino = ino;
rec->extent_start = (u64)-1;
rec->first_extent_gap = (u64)-1;
rec->refs = 1;
INIT_LIST_HEAD(&rec->backrefs);
- node = malloc(sizeof(*node));
+ node = btrfs_malloc(sizeof(*node));
node->cache.start = ino;
node->cache.size = 1;
node->data = rec;
@@ -427,7 +427,7 @@ static struct inode_backref *get_inode_backref(struct inode_record *rec,
return backref;
}
- backref = malloc(sizeof(*backref) + namelen + 1);
+ backref = btrfs_malloc(sizeof(*backref) + namelen + 1);
memset(backref, 0, sizeof(*backref));
backref->dir = dir;
backref->namelen = namelen;
@@ -590,7 +590,7 @@ again:
remove_cache_extent(src, &node->cache);
ins = node;
} else {
- ins = malloc(sizeof(*ins));
+ ins = btrfs_malloc(sizeof(*ins));
ins->cache.start = node->cache.start;
ins->cache.size = node->cache.size;
ins->data = rec;
@@ -667,7 +667,7 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
int ret;
struct shared_node *node;
- node = calloc(1, sizeof(*node));
+ node = btrfs_calloc(1, sizeof(*node));
node->cache.start = bytenr;
node->cache.size = 1;
cache_tree_init(&node->root_cache);
@@ -1357,7 +1357,7 @@ static struct root_record *get_root_rec(struct cache_tree *root_cache,
if (cache) {
rec = container_of(cache, struct root_record, cache);
} else {
- rec = calloc(1, sizeof(*rec));
+ rec = btrfs_calloc(1, sizeof(*rec));
rec->objectid = objectid;
INIT_LIST_HEAD(&rec->backrefs);
rec->cache.start = objectid;
@@ -1384,7 +1384,7 @@ static struct root_backref *get_root_backref(struct root_record *rec,
return backref;
}
- backref = malloc(sizeof(*backref) + namelen + 1);
+ backref = btrfs_malloc(sizeof(*backref) + namelen + 1);
memset(backref, 0, sizeof(*backref));
backref->ref_root = ref_root;
backref->dir = dir;
@@ -2084,7 +2084,7 @@ static struct tree_backref *find_tree_backref(struct extent_record *rec,
static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
u64 parent, u64 root)
{
- struct tree_backref *ref = malloc(sizeof(*ref));
+ struct tree_backref *ref = btrfs_malloc(sizeof(*ref));
memset(&ref->node, 0, sizeof(ref->node));
if (parent > 0) {
ref->parent = parent;
@@ -2133,7 +2133,7 @@ static struct data_backref *alloc_data_backref(struct extent_record *rec,
u64 owner, u64 offset,
u64 max_size)
{
- struct data_backref *ref = malloc(sizeof(*ref));
+ struct data_backref *ref = btrfs_malloc(sizeof(*ref));
memset(&ref->node, 0, sizeof(ref->node));
ref->node.is_data = 1;
@@ -2207,7 +2207,7 @@ static int add_extent_rec(struct cache_tree *extent_cache,
maybe_free_extent_rec(extent_cache, rec);
return ret;
}
- rec = malloc(sizeof(*rec));
+ rec = btrfs_malloc(sizeof(*rec));
rec->start = start;
rec->max_size = max_size;
rec->nr = max(nr, max_size);
@@ -3402,11 +3402,7 @@ static int check_extents(struct btrfs_trans_handle *trans,
}
bits_nr = 1024;
- bits = malloc(bits_nr * sizeof(struct block_info));
- if (!bits) {
- perror("malloc");
- exit(1);
- }
+ bits = btrfs_malloc(bits_nr * sizeof(struct block_info));
add_root_to_pending(root->fs_info->tree_root->node, bits, bits_nr,
&extent_cache, &pending, &seen, &reada, &nodes,
@@ -125,12 +125,12 @@ int main(int ac, char **av)
}
fullpath = av[i + 1];
- snap_location = strdup(fullpath);
+ snap_location = btrfs_strdup(fullpath);
snap_location = dirname(snap_location);
snap_fd = open_file_or_dir(snap_location);
- name = strdup(fullpath);
+ name = btrfs_strdup(fullpath);
name = basename(name);
len = strlen(name);
@@ -232,11 +232,7 @@ int main(int argc, char **argv)
exit(1);
}
- roots = malloc(fs_roots_size);
- if (!roots) {
- fprintf(stderr, "No memory\n");
- goto out;
- }
+ roots = btrfs_malloc(fs_roots_size);
printf("Calculating size of root tree\n");
key.objectid = BTRFS_ROOT_TREE_OBJECTID;
@@ -65,9 +65,7 @@ static int cmd_df(int argc, char **argv)
return 12;
}
- sargs_orig = sargs = malloc(sizeof(struct btrfs_ioctl_space_args));
- if (!sargs)
- return -ENOMEM;
+ sargs_orig = sargs = btrfs_malloc(sizeof(struct btrfs_ioctl_space_args));
sargs->space_slots = 0;
sargs->total_spaces = 0;
@@ -38,9 +38,7 @@ static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
struct btrfs_ioctl_ino_path_args ipa;
struct btrfs_data_container *fspath;
- fspath = malloc(4096);
- if (!fspath)
- return 1;
+ fspath = btrfs_malloc(4096);
ipa.inum = inum;
ipa.size = 4096;
@@ -162,9 +160,7 @@ static int cmd_logical_resolve(int argc, char **argv)
usage(cmd_logical_resolve_usage);
size = min(size, (u64)64 * 1024);
- inodes = malloc(size);
- if (!inodes)
- return 1;
+ inodes = btrfs_malloc(size);
loi.logical = atoll(argv[optind]);
loi.size = size;
@@ -147,10 +147,10 @@ static int process_subvol(const char *path, const u8 *uuid, u64 ctransid,
if (ret < 0)
goto out;
- r->cur_subvol = calloc(1, sizeof(*r->cur_subvol));
+ r->cur_subvol = btrfs_calloc(1, sizeof(*r->cur_subvol));
r->parent_subvol = NULL;
- r->cur_subvol->path = strdup(path);
+ r->cur_subvol->path = btrfs_strdup(path);
r->full_subvol_path = path_cat(r->root_path, path);
fprintf(stderr, "At subvol %s\n", path);
@@ -192,10 +192,10 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
if (ret < 0)
goto out;
- r->cur_subvol = calloc(1, sizeof(*r->cur_subvol));
+ r->cur_subvol = btrfs_calloc(1, sizeof(*r->cur_subvol));
r->parent_subvol = NULL;
- r->cur_subvol->path = strdup(path);
+ r->cur_subvol->path = btrfs_strdup(path);
r->full_subvol_path = path_cat(r->root_path, path);
fprintf(stderr, "At snapshot %s\n", path);
@@ -487,7 +487,7 @@ static int open_inode_for_write(struct btrfs_receive *r, const char *path)
goto out;
}
free(r->write_path);
- r->write_path = strdup(path);
+ r->write_path = btrfs_strdup(path);
out:
return ret;
@@ -562,7 +562,7 @@ static int process_clone(const char *path, u64 offset, u64 len,
if (memcmp(clone_uuid, r->cur_subvol->received_uuid,
BTRFS_FSID_SIZE) == 0) {
/* TODO check generation of extent */
- subvol_path = strdup(r->cur_subvol->path);
+ subvol_path = btrfs_strdup(r->cur_subvol->path);
} else {
ret = -ENOENT;
fprintf(stderr, "ERROR: did not find source subvol.\n");
@@ -584,7 +584,7 @@ static int process_clone(const char *path, u64 offset, u64 len,
r->subvol_parent_name);
}
}*/
- subvol_path = strdup(si->path);
+ subvol_path = btrfs_strdup(si->path);
}
full_clone_path = path_cat3(r->root_path, subvol_path, clone_path);
@@ -792,7 +792,7 @@ int do_receive(struct btrfs_receive *r, const char *tomnt, int r_fd)
int ret;
int end = 0;
- r->root_path = strdup(tomnt);
+ r->root_path = btrfs_strdup(tomnt);
r->mnt_fd = open(tomnt, O_RDONLY | O_NOATIME);
if (r->mnt_fd < 0) {
ret = -errno;
@@ -510,8 +510,8 @@ again:
++curr;
p = realloc(p, (curr + 2) * sizeof(*p));
if (p)
- p[curr] = malloc(sizeof(**p));
- if (!p || !p[curr])
+ p[curr] = btrfs_malloc(sizeof(**p));
+ else
return ERR_PTR(-errno);
memset(p[curr], 0, sizeof(**p));
p[curr + 1] = NULL;
@@ -1026,7 +1026,7 @@ static int scrub_fs_info(char *path,
return 0;
}
- di_args = *di_ret = malloc(fi_args->num_devices * sizeof(*di_args));
+ di_args = *di_ret = btrfs_malloc(fi_args->num_devices * sizeof(*di_args));
if (!di_args) {
close(fd);
return -errno;
@@ -1108,7 +1108,7 @@ static int scrub_start(int argc, char **argv, int resume)
pthread_attr_t t_attr;
struct scrub_file_record **past_scrubs = NULL;
struct scrub_file_record *last_scrub = NULL;
- char *datafile = strdup(SCRUB_DATA_FILE);
+ char *datafile = btrfs_strdup(SCRUB_DATA_FILE);
char fsid[37];
char sock_path[BTRFS_PATH_NAME_MAX + 1] = "";
struct scrub_progress_cycle spc;
@@ -1196,15 +1196,9 @@ static int scrub_start(int argc, char **argv, int resume)
close(fdres);
}
- t_devs = malloc(fi_args.num_devices * sizeof(*t_devs));
- sp = calloc(fi_args.num_devices, sizeof(*sp));
- spc.progress = calloc(fi_args.num_devices * 2, sizeof(*spc.progress));
-
- if (!t_devs || !sp || !spc.progress) {
- ERR(!do_quiet, "ERROR: scrub failed: %s", strerror(errno));
- err = 1;
- goto out;
- }
+ t_devs = btrfs_malloc(fi_args.num_devices * sizeof(*t_devs));
+ sp = btrfs_calloc(fi_args.num_devices, sizeof(*sp));
+ spc.progress = btrfs_calloc(fi_args.num_devices * 2, sizeof(*spc.progress));
ret = pthread_attr_init(&t_attr);
if (ret) {
@@ -76,7 +76,7 @@ int find_mount_root(const char *path, char **mount_root)
if (longest_matchlen < len) {
free(longest_match);
longest_matchlen = len;
- longest_match = strdup(ent->mnt_dir);
+ longest_match = btrfs_strdup(ent->mnt_dir);
}
}
}
@@ -106,9 +106,9 @@ static int cmd_subvol_create(int argc, char **argv)
return 12;
}
- newname = strdup(dst);
+ newname = btrfs_strdup(dst);
newname = basename(newname);
- dstdir = strdup(dst);
+ dstdir = btrfs_strdup(dst);
dstdir = dirname(dstdir);
if( !strcmp(newname,".") || !strcmp(newname,"..") ||
@@ -218,9 +218,9 @@ again:
}
cpath = realpath(path, 0);
- dname = strdup(cpath);
+ dname = btrfs_strdup(cpath);
dname = dirname(dname);
- vname = strdup(cpath);
+ vname = btrfs_strdup(cpath);
vname = basename(vname);
free(cpath);
@@ -485,13 +485,13 @@ static int cmd_snapshot(int argc, char **argv)
}
if(res>0){
- newname = strdup(subvol);
+ newname = btrfs_strdup(subvol);
newname = basename(newname);
dstdir = dst;
}else{
- newname = strdup(dst);
+ newname = btrfs_strdup(dst);
newname = basename(newname);
- dstdir = strdup(dst);
+ dstdir = btrfs_strdup(dst);
dstdir = dirname(dstdir);
}
@@ -385,9 +385,7 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
char *buffer;
ret = -ENOMEM;
- buffer = malloc(blocksize);
- if (!buffer)
- goto fail;
+ buffer = btrfs_malloc(blocksize);
for (offset = 0; offset < num_bytes; offset += blocksize) {
ret = read_disk_extent(root, disk_bytenr + offset,
blocksize, buffer);
@@ -601,9 +599,7 @@ static int create_file_extents(struct btrfs_trans_handle *trans,
u64 disk_bytenr = data.disk_block * sectorsize;
u64 nbytes;
- buffer = malloc(num_bytes);
- if (!buffer)
- return -ENOMEM;
+ buffer = btrfs_malloc(num_bytes);
ret = read_disk_extent(root, disk_bytenr, num_bytes, buffer);
if (ret)
goto fail;
@@ -848,9 +844,7 @@ static int copy_single_xattr(struct btrfs_trans_handle *trans,
if (name_index == 2 || name_index == 3) {
size_t bufsize = acl_ea_size(ext2_acl_count(datalen));
- databuf = malloc(bufsize);
- if (!databuf)
- return -ENOMEM;
+ databuf = btrfs_malloc(bufsize);
ret = ext2_acl_to_xattr(databuf, data, bufsize, datalen);
if (ret)
goto out;
@@ -893,9 +887,7 @@ static int copy_extended_attrs(struct btrfs_trans_handle *trans,
if (inode_size <= EXT2_GOOD_OLD_INODE_SIZE) {
ext2_inode = (struct ext2_inode_large *)inode_buf;
} else {
- ext2_inode = (struct ext2_inode_large *)malloc(inode_size);
- if (!ext2_inode)
- return -ENOMEM;
+ ext2_inode = (struct ext2_inode_large *)btrfs_malloc(inode_size);
}
err = ext2fs_read_inode_full(ext2_fs, ext2_ino, (void *)ext2_inode,
inode_size);
@@ -945,11 +937,7 @@ static int copy_extended_attrs(struct btrfs_trans_handle *trans,
if (ext2_inode->i_file_acl == 0)
goto out;
- buffer = malloc(block_size);
- if (!buffer) {
- ret = -ENOMEM;
- goto out;
- }
+ buffer = btrfs_malloc(block_size);
err = ext2fs_read_ext_attr(ext2_fs, ext2_inode->i_file_acl, buffer);
if (err) {
fprintf(stderr, "ext2fs_read_ext_attr: %s\n",
@@ -1103,9 +1091,7 @@ static int copy_disk_extent(struct btrfs_root *root, u64 dst_bytenr,
char *buffer;
struct btrfs_fs_devices *fs_devs = root->fs_info->fs_devices;
- buffer = malloc(num_bytes);
- if (!buffer)
- return -ENOMEM;
+ buffer = btrfs_malloc(num_bytes);
ret = pread(fs_devs->latest_bdev, buffer, num_bytes, src_bytenr);
if (ret != num_bytes)
goto fail;
@@ -1730,9 +1716,7 @@ static int migrate_super_block(int fd, u64 old_bytenr, u32 sectorsize)
u32 bytenr;
BUG_ON(sectorsize < sizeof(*super));
- buf = malloc(sizeof(*buf) + sectorsize);
- if (!buf)
- return -ENOMEM;
+ buf = btrfs_malloc(sizeof(*buf) + sectorsize);
buf->len = sectorsize;
ret = pread(fd, buf->data, sectorsize, old_bytenr);
@@ -1810,9 +1794,7 @@ static int prepare_system_chunk(int fd, u64 sb_bytenr, u32 sectorsize)
struct btrfs_super_block *super;
BUG_ON(sectorsize < sizeof(*super));
- buf = malloc(sizeof(*buf) + sectorsize);
- if (!buf)
- return -ENOMEM;
+ buf = btrfs_malloc(sizeof(*buf) + sectorsize);
buf->len = sectorsize;
ret = pread(fd, buf->data, sectorsize, sb_bytenr);
@@ -2498,11 +2480,7 @@ int do_rollback(const char *devname, int force)
}
sectorsize = root->sectorsize;
- buf = malloc(sectorsize);
- if (!buf) {
- fprintf(stderr, "unable to allocate memory\n");
- goto fail;
- }
+ buf = btrfs_malloc(sectorsize);
btrfs_init_path(&path);
@@ -79,9 +79,7 @@ int csum_tree_block_size(struct extent_buffer *buf, u16 csum_size,
u32 len;
u32 crc = ~(u32)0;
- result = malloc(csum_size * sizeof(char));
- if (!result)
- return 1;
+ result = btrfs_malloc(csum_size * sizeof(char));
len = buf->len - BTRFS_CSUM_SIZE;
crc = crc32c(crc, buf->data + BTRFS_CSUM_SIZE, len);
@@ -456,7 +454,7 @@ static int find_and_setup_log_root(struct btrfs_root *tree_root,
{
u32 blocksize;
u64 blocknr = btrfs_super_log_root(disk_super);
- struct btrfs_root *log_root = malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *log_root = btrfs_malloc(sizeof(struct btrfs_root));
if (blocknr == 0)
return 0;
@@ -518,9 +516,7 @@ struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
u32 blocksize;
int ret = 0;
- root = malloc(sizeof(*root));
- if (!root)
- return ERR_PTR(-ENOMEM);
+ root = btrfs_malloc(sizeof(*root));
memset(root, 0, sizeof(*root));
if (location->offset == (u64)-1) {
ret = find_and_setup_root(tree_root, fs_info,
@@ -617,12 +613,12 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path,
u32 stripesize;
u64 generation;
struct btrfs_key key;
- struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *chunk_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *dev_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *csum_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
+ struct btrfs_root *tree_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *extent_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *chunk_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *dev_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *csum_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_fs_info *fs_info = btrfs_malloc(sizeof(*fs_info));
int ret;
struct btrfs_super_block *disk_super;
struct btrfs_fs_devices *fs_devices = NULL;
@@ -83,10 +83,8 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
struct cache_extent *alloc_cache_extent(u64 start, u64 size)
{
- struct cache_extent *pe = malloc(sizeof(*pe));
+ struct cache_extent *pe = btrfs_malloc(sizeof(*pe));
- if (!pe)
- return pe;
pe->start = start;
pe->size = size;
return pe;
@@ -43,9 +43,7 @@ static struct extent_state *alloc_extent_state(void)
{
struct extent_state *state;
- state = malloc(sizeof(*state));
- if (!state)
- return NULL;
+ state = btrfs_malloc(sizeof(*state));
state->refs = 1;
state->state = 0;
state->private = 0;
@@ -565,11 +563,7 @@ static struct extent_buffer *__alloc_extent_buffer(struct extent_io_tree *tree,
struct extent_buffer *eb;
int ret;
- eb = malloc(sizeof(struct extent_buffer) + blocksize);
- if (!eb) {
- BUG();
- return NULL;
- }
+ eb = btrfs_malloc(sizeof(struct extent_buffer) + blocksize);
memset(eb, 0, sizeof(struct extent_buffer) + blocksize);
eb->start = bytenr;
@@ -50,11 +50,7 @@ int csum_block(void *buf, u32 len)
u32 crc = ~(u32)0;
int ret = 0;
- result = malloc(csum_size * sizeof(char));
- if (!result) {
- fprintf(stderr, "No memory\n");
- return 1;
- }
+ result = btrfs_malloc(csum_size * sizeof(char));
len -= BTRFS_CSUM_SIZE;
crc = crc32c(crc, buf + BTRFS_CSUM_SIZE, len);
@@ -116,12 +112,12 @@ static struct btrfs_root *open_ctree_broken(int fd, const char *device)
u32 blocksize;
u32 stripesize;
u64 generation;
- struct btrfs_root *tree_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *extent_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *chunk_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *dev_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_root *csum_root = malloc(sizeof(struct btrfs_root));
- struct btrfs_fs_info *fs_info = malloc(sizeof(*fs_info));
+ struct btrfs_root *tree_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *extent_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *chunk_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *dev_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_root *csum_root = btrfs_malloc(sizeof(struct btrfs_root));
+ struct btrfs_fs_info *fs_info = btrfs_malloc(sizeof(*fs_info));
int ret;
struct btrfs_super_block *disk_super;
struct btrfs_fs_devices *fs_devices = NULL;
@@ -309,16 +305,11 @@ next:
static int read_physical(struct btrfs_root *root, int fd, u64 offset,
u64 bytenr, u64 len)
{
- char *iobuf = malloc(len);
+ char *iobuf = btrfs_malloc(len);
ssize_t done;
size_t total_read = 0;
int ret = 1;
- if (!iobuf) {
- fprintf(stderr, "No memory\n");
- return -1;
- }
-
while (total_read < len) {
done = pread64(fd, iobuf + total_read, len - total_read,
bytenr + total_read);
@@ -25,6 +25,7 @@
#include <endian.h>
#include <byteswap.h>
#include <assert.h>
+#include "utils-alloc.h"
#ifndef READ
#define READ 0
@@ -200,9 +201,9 @@ static inline long IS_ERR(const void *ptr)
/*
* kmalloc/kfree
*/
-#define kmalloc(x, y) malloc(x)
-#define kzalloc(x, y) calloc(1, x)
-#define kstrdup(x, y) strdup(x)
+#define kmalloc(x, y) btrfs_malloc(x)
+#define kzalloc(x, y) btrfs_calloc(1, x)
+#define kstrdup(x, y) btrfs_strdup(x)
#define kfree(x) free(x)
#define BUG_ON(c) assert(!(c))
@@ -61,7 +61,7 @@ static u64 parse_size(char *s)
u64 mult = 1;
u64 ret;
- s = strdup(s);
+ s = btrfs_strdup(s);
if (len && !isdigit(s[len - 1])) {
c = tolower(s[len - 1]);
@@ -395,7 +395,7 @@ static char *parse_label(char *input)
exit(1);
}
}
- return strdup(input);
+ return btrfs_strdup(input);
}
static struct option long_options[] = {
@@ -770,7 +770,7 @@ static int add_symbolic_link(struct btrfs_trans_handle *trans,
{
int ret;
u64 sectorsize = root->sectorsize;
- char *buf = malloc(sectorsize);
+ char *buf = btrfs_malloc(sectorsize);
ret = readlink(path_name, buf, sectorsize);
if (ret <= 0) {
@@ -819,7 +819,7 @@ static int add_file_items(struct btrfs_trans_handle *trans,
blocks += 1;
if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
- buffer = malloc(st->st_size);
+ buffer = btrfs_malloc(st->st_size);
ret_read = pread64(fd, buffer, st->st_size, bytes_read);
if (ret_read == -1) {
fprintf(stderr, "%s read failed\n", path_name);
@@ -837,7 +837,7 @@ static int add_file_items(struct btrfs_trans_handle *trans,
first_block = key.objectid;
bytes_read = 0;
- buffer = malloc(sectorsize);
+ buffer = btrfs_malloc(sectorsize);
do {
memset(buffer, 0, sectorsize);
@@ -887,9 +887,7 @@ static char *make_path(char *dir, char *name)
{
char *path;
- path = malloc(strlen(dir) + strlen(name) + 2);
- if (!path)
- return NULL;
+ path = btrfs_malloc(strlen(dir) + strlen(name) + 2);
strcpy(path, dir);
if (dir[strlen(dir) - 1] != '/')
strcat(path, "/");
@@ -919,9 +917,9 @@ static int traverse_directory(struct btrfs_trans_handle *trans,
u64 root_dir_inode_size = 0;
/* Add list for source directory */
- dir_entry = malloc(sizeof(struct directory_name_entry));
+ dir_entry = btrfs_malloc(sizeof(struct directory_name_entry));
dir_entry->dir_name = dir_name;
- dir_entry->path = strdup(dir_name);
+ dir_entry->path = btrfs_strdup(dir_name);
parent_inum = highest_inum + BTRFS_FIRST_FREE_OBJECTID;
dir_entry->inum = parent_inum;
@@ -1008,7 +1006,7 @@ static int traverse_directory(struct btrfs_trans_handle *trans,
}
if (S_ISDIR(st.st_mode)) {
- dir_entry = malloc(sizeof(struct directory_name_entry));
+ dir_entry = btrfs_malloc(sizeof(struct directory_name_entry));
dir_entry->dir_name = cur_file->d_name;
dir_entry->path = make_path(parent_dir_entry->path,
cur_file->d_name);
@@ -1184,12 +1182,10 @@ static int zero_output_file(int out_fd, u64 size, u32 sectorsize)
int len = sectorsize;
int loop_num = size / sectorsize;
u64 location = 0;
- char *buf = malloc(len);
+ char *buf = btrfs_malloc(len);
int ret = 0, i;
ssize_t written;
- if (!buf)
- return -ENOMEM;
memset(buf, 0, len);
for (i = 0; i < loop_num; i++) {
written = pwrite64(out_fd, buf, len, location);
@@ -52,11 +52,7 @@ int qgroup_inherit_realloc(struct btrfs_qgroup_inherit **inherit, int n,
(*inherit)->num_excl_copies;
}
- out = calloc(sizeof(*out) + sizeof(out->qgroups[0]) * (nitems + n), 1);
- if (out == NULL) {
- fprintf(stderr, "ERROR: Not enough memory\n");
- return 13;
- }
+ out = btrfs_calloc(sizeof(*out) + sizeof(out->qgroups[0]) * (nitems + n), 1);
if (*inherit) {
struct btrfs_qgroup_inherit *i = *inherit;
@@ -46,7 +46,7 @@ int main(int ac, char **av) {
struct btrfs_root *root;
struct btrfs_trans_handle *trans;
- buf = malloc(512);
+ buf = btrfs_malloc(512);
memset(buf, 0, 512);
radix_tree_init();
@@ -89,11 +89,9 @@ static struct radix_tree_node *
radix_tree_node_alloc(struct radix_tree_root *root)
{
struct radix_tree_node *ret;
- ret = malloc(sizeof(struct radix_tree_node));
- if (ret) {
- memset(ret, 0, sizeof(struct radix_tree_node));
- internal_nodes++;
- }
+ ret = btrfs_malloc(sizeof(struct radix_tree_node));
+ memset(ret, 0, sizeof(struct radix_tree_node));
+ internal_nodes++;
return ret;
}
@@ -32,9 +32,7 @@ int btrfs_add_corrupt_extent_record(struct btrfs_fs_info *info,
if (!info->corrupt_blocks)
return 0;
- corrupt = malloc(sizeof(*corrupt));
- if (!corrupt)
- return -ENOMEM;
+ corrupt = btrfs_malloc(sizeof(*corrupt));
memcpy(&corrupt->key, first_key, sizeof(*first_key));
corrupt->cache.start = start;
@@ -156,11 +156,7 @@ static int copy_one_inline(int fd, struct btrfs_path *path, u64 pos)
}
ram_size = btrfs_file_extent_ram_bytes(leaf, fi);
- outbuf = malloc(ram_size);
- if (!outbuf) {
- fprintf(stderr, "No memory\n");
- return -1;
- }
+ outbuf = btrfs_malloc(ram_size);
ret = decompress(buf, outbuf, len, ram_size);
if (ret) {
@@ -208,19 +204,10 @@ static int copy_one_extent(struct btrfs_root *root, int fd,
if (disk_size == 0)
return 0;
- inbuf = malloc(disk_size);
- if (!inbuf) {
- fprintf(stderr, "No memory\n");
- return -1;
- }
+ inbuf = btrfs_malloc(disk_size);
if (compress != BTRFS_COMPRESS_NONE) {
- outbuf = malloc(ram_size);
- if (!outbuf) {
- fprintf(stderr, "No memory\n");
- free(inbuf);
- return -1;
- }
+ outbuf = btrfs_malloc(ram_size);
}
again:
length = size_left;
@@ -592,13 +579,7 @@ static int search_dir(struct btrfs_root *root, struct btrfs_key *key,
}
} else if (type == BTRFS_FT_DIR) {
struct btrfs_root *search_root = root;
- char *dir = strdup(path_name);
-
- if (!dir) {
- fprintf(stderr, "Ran out of memory\n");
- btrfs_free_path(path);
- return -1;
- }
+ char *dir = btrfs_strdup(path_name);
if (location.type == BTRFS_ROOT_ITEM_KEY) {
/*
@@ -220,9 +220,7 @@ static int tlv_get_string(struct btrfs_send_stream *s, int attr, char **str)
TLV_GET(s, attr, &data, &len);
- *str = malloc(len + 1);
- if (!*str)
- return -ENOMEM;
+ *str = btrfs_malloc(len + 1);
memcpy(*str, data, len);
(*str)[len] = 0;
@@ -247,7 +247,7 @@ int subvol_uuid_search_init(int mnt_fd, struct subvol_uuid_search *s)
path = btrfs_list_path_for_root(mnt_fd,
sh->objectid);
if (!path)
- path = strdup("");
+ path = btrfs_strdup("");
if (IS_ERR(path)) {
ret = PTR_ERR(path);
fprintf(stderr, "ERROR: unable to "
@@ -257,7 +257,7 @@ int subvol_uuid_search_init(int mnt_fd, struct subvol_uuid_search *s)
goto out;
}
- si = calloc(1, sizeof(*si));
+ si = btrfs_calloc(1, sizeof(*si));
si->root_id = sh->objectid;
memcpy(si->uuid, root_item.uuid,
BTRFS_UUID_SIZE);
@@ -309,7 +309,7 @@ char *path_cat(const char *p1, const char *p2)
{
int p1_len = strlen(p1);
int p2_len = strlen(p2);
- char *new = malloc(p1_len + p2_len + 3);
+ char *new = btrfs_malloc(p1_len + p2_len + 3);
if (p1_len && p1[p1_len - 1] == '/')
p1_len--;
@@ -325,7 +325,7 @@ char *path_cat3(const char *p1, const char *p2, const char *p3)
int p1_len = strlen(p1);
int p2_len = strlen(p2);
int p3_len = strlen(p3);
- char *new = malloc(p1_len + p2_len + p3_len + 4);
+ char *new = btrfs_malloc(p1_len + p2_len + p3_len + 4);
if (p1_len && p1[p1_len - 1] == '/')
p1_len--;
@@ -16,6 +16,8 @@
* Boston, MA 021110-1307, USA.
*/
+#include "utils.h"
+
#ifndef __TRANSACTION__
#define __TRANSACTION__
@@ -32,7 +34,7 @@ static inline struct btrfs_trans_handle *
btrfs_start_transaction(struct btrfs_root *root, int num_blocks)
{
struct btrfs_fs_info *fs_info = root->fs_info;
- struct btrfs_trans_handle *h = malloc(sizeof(*h));
+ struct btrfs_trans_handle *h = btrfs_malloc(sizeof(*h));
BUG_ON(root->commit_root);
BUG_ON(fs_info->running_transaction);
new file mode 100644
@@ -0,0 +1,45 @@
+#ifndef __UTILS_ALLOC__
+#define __UTILS_ALLOC__
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static void *btrfs_malloc(size_t size) __attribute__((unused));
+static void *btrfs_calloc(size_t nmemb, size_t size) __attribute__((unused));
+static char *btrfs_strdup(const char *s) __attribute__((unused));
+static char *btrfs_strndup(const char *s, size_t n) __attribute__((unused));
+
+static void *btrfs_malloc(size_t size)
+{
+ void *tmp = malloc(size);
+ if (!tmp)
+ abort();
+ return tmp;
+}
+
+static void *btrfs_calloc(size_t nmemb, size_t size)
+{
+ void *tmp = calloc(1, size);
+ if (!tmp)
+ abort();
+ return tmp;
+}
+
+static char *btrfs_strdup(const char *s)
+{
+ char *tmp = strdup(s);
+ if (!tmp)
+ abort();
+ return tmp;
+}
+
+static char *btrfs_strndup(const char *s, size_t n)
+{
+ char *tmp = strndup(s, n);
+ if (!tmp)
+ abort();
+ return tmp;
+}
+
+#endif /* __UTILS_ALLOC__ */
@@ -125,7 +125,7 @@ int make_btrfs(int fd, const char *device, const char *label,
if (label)
strncpy(super.label, label, BTRFS_LABEL_SIZE - 1);
- buf = malloc(sizeof(*buf) + max(sectorsize, leafsize));
+ buf = btrfs_malloc(sizeof(*buf) + max(sectorsize, leafsize));
/* create the tree of root objects */
memset(buf->data, 0, leafsize);
@@ -427,12 +427,10 @@ static u64 device_size(int fd, struct stat *st)
static int zero_blocks(int fd, off_t start, size_t len)
{
- char *buf = malloc(len);
+ char *buf = btrfs_malloc(len);
int ret = 0;
ssize_t written;
- if (!buf)
- return -ENOMEM;
memset(buf, 0, len);
written = pwrite(fd, buf, len, start);
if (written != len)
@@ -962,21 +960,15 @@ int btrfs_scan_one_dir(char *dirname, int run_ioctl)
INIT_LIST_HEAD(&pending_list);
- pending = malloc(sizeof(*pending));
- if (!pending)
- return -ENOMEM;
+ pending = btrfs_malloc(sizeof(*pending));
strcpy(pending->name, dirname);
again:
dirname_len = strlen(pending->name);
pathlen = 1024;
- fullpath = malloc(pathlen);
+ fullpath = btrfs_malloc(pathlen);
dirname = pending->name;
- if (!fullpath) {
- ret = -ENOMEM;
- goto fail;
- }
dirp = opendir(dirname);
if (!dirp) {
fprintf(stderr, "Unable to open %s for scanning\n", dirname);
@@ -1001,11 +993,7 @@ again:
if (S_ISLNK(st.st_mode))
continue;
if (S_ISDIR(st.st_mode)) {
- struct pending_dir *next = malloc(sizeof(*next));
- if (!next) {
- ret = -ENOMEM;
- goto fail;
- }
+ struct pending_dir *next = btrfs_malloc(sizeof(*next));
strcpy(next->name, fullpath);
list_add_tail(&next->list, &pending_list);
}
@@ -1061,11 +1049,7 @@ int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
char *buf;
int ret = 0;
- buf = malloc(BTRFS_SUPER_INFO_SIZE);
- if (!buf) {
- ret = -ENOMEM;
- goto out;
- }
+ buf = btrfs_malloc(BTRFS_SUPER_INFO_SIZE);
ret = pread(fd, buf, BTRFS_SUPER_INFO_SIZE, super_offset);
if (ret != BTRFS_SUPER_INFO_SIZE)
goto brelse;
@@ -1081,7 +1065,6 @@ int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
ret = 1;
brelse:
free(buf);
-out:
return ret;
}
@@ -1110,7 +1093,7 @@ char *pretty_sizes(u64 size)
return NULL;
fraction = (float)last_size / 1024;
}
- pretty = malloc(pretty_len);
+ pretty = btrfs_malloc(pretty_len);
snprintf(pretty, pretty_len, "%.2f%s", fraction, size_strs[num_divs]);
return pretty;
}
@@ -1219,4 +1202,3 @@ scan_again:
}
return 0;
}
-
@@ -16,6 +16,8 @@
* Boston, MA 021110-1307, USA.
*/
+#include "utils-alloc.h"
+
#ifndef __UTILS__
#define __UTILS__
@@ -117,7 +117,7 @@ static int device_list_add(const char *path,
list_add(&device->dev_list, &fs_devices->devices);
device->fs_devices = fs_devices;
} else if (!device->name || strcmp(device->name, path)) {
- char *name = strdup(path);
+ char *name = btrfs_strdup(path);
if (!name)
return -ENOMEM;
kfree(device->name);
@@ -200,11 +200,7 @@ int btrfs_scan_one_device(int fd, const char *path,
u64 devid;
char uuidbuf[37];
- buf = malloc(4096);
- if (!buf) {
- ret = -ENOMEM;
- goto error;
- }
+ buf = btrfs_malloc(4096);
disk_super = (struct btrfs_super_block *)buf;
ret = btrfs_read_dev_super(fd, disk_super, super_offset);
if (ret < 0) {
@@ -222,7 +218,6 @@ int btrfs_scan_one_device(int fd, const char *path,
error_brelse:
free(buf);
-error:
return ret;
}
--
1.8.1.1