Hi,
Following path implements the uniform error handling for the utils.c
in btrfs-progs.
On Sun, Oct 12, 2014 at 2:01 PM, neo <cknvme@xxxxxxxxx> wrote:
> ---
> Makefile | 4 +-
> btrfs-syscalls.c | 180 +++++++++++++++++++++++++++++++++++++++++++++++++
> btrfs-syscalls.h | 55 +++++++++++++++
> kerncompat.h | 5 +-
> utils.c | 200 +++++++++++++++++++++++++++----------------------------
> 5 files changed, 337 insertions(+), 107 deletions(-)
> create mode 100644 btrfs-syscalls.c
> create mode 100644 btrfs-syscalls.h
>
> diff --git a/Makefile b/Makefile
> index 18eb944..d738f20 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -5,7 +5,7 @@ CC = gcc
> LN = ln
> AR = ar
> AM_CFLAGS = -Wall -D_FILE_OFFSET_BITS=64 -DBTRFS_FLAT_INCLUDES -fno-strict-aliasing -fPIC
> -CFLAGS = -g -O1 -fno-strict-aliasing
> +CFLAGS = -g -O1 -fno-strict-aliasing -rdynamic
> objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
> root-tree.o dir-item.o file-item.o inode-item.o inode-map.o \
> extent-cache.o extent_io.o volumes.o utils.o repair.o \
> @@ -17,7 +17,7 @@ cmds_objects = cmds-subvolume.o cmds-filesystem.o cmds-device.o cmds-scrub.o \
> cmds-restore.o cmds-rescue.o chunk-recover.o super-recover.o \
> cmds-property.o
> libbtrfs_objects = send-stream.o send-utils.o rbtree.o btrfs-list.o crc32c.o \
> - uuid-tree.o utils-lib.o
> + uuid-tree.o utils-lib.o btrfs-syscalls.o
> libbtrfs_headers = send-stream.h send-utils.h send.h rbtree.h btrfs-list.h \
> crc32c.h list.h kerncompat.h radix-tree.h extent-cache.h \
> extent_io.h ioctl.h ctree.h btrfsck.h version.h
> diff --git a/btrfs-syscalls.c b/btrfs-syscalls.c
> new file mode 100644
> index 0000000..b4d791b
> --- /dev/null
> +++ b/btrfs-syscalls.c
> @@ -0,0 +1,180 @@
> +/*******************************************************************************
> + * File Name : btrfs-syscalls.c
> + * Description : This file contains system call wrapper functions with
> + * uniform error handling.
> + ******************************************************************************/
> +#include "btrfs-syscalls.h"
> +
> +#define BKTRACE_BUFFER_SIZE 1024
> +
> +int err_verbose = 0;
> +static void *buf[BKTRACE_BUFFER_SIZE];
> +
> +void
> +btrfs_backtrace(void)
> +{
> + int i;
> + int nptrs;
> + char **entries;
> +
> + fprintf(stderr, "Call trace:\n");
> + nptrs = backtrace(buf, BKTRACE_BUFFER_SIZE);
> + entries = backtrace_symbols(buf, nptrs);
> + if (entries == NULL) {
> + fprintf(stderr, "ERROR: backtrace_symbols\n");
> + exit(EXIT_FAILURE);
> + }
> + for (i = 0; i < nptrs; i++) {
> + if (strstr(entries[i], "btrfs_backtrace") == NULL);
> + fprintf(stderr, "\t%s\n", entries[i]);
> + }
> + free(entries);
> +}
> +
> +int
> +btrfs_open(const char *pathname, int flags)
> +{
> + int ret;
> +
> + if ((ret = open(pathname, flags)) < 0)
> + SYS_ERROR("open : %s", pathname);
> +
> + return ret;
> +}
> +
> +int
> +btrfs_close(int fd)
> +{
> + int ret;
> +
> + if ((ret = close(fd)) < 0)
> + SYS_ERROR("close :");
> +
> + return ret;
> +}
> +
> +int
> +btrfs_stat(const char *path, struct stat *buf)
> +{
> + int ret;
> +
> + if ((ret = stat(path, buf)) < 0)
> + SYS_ERROR("stat : %s", path);
> +
> + return ret;
> +}
> +
> +int
> +btrfs_lstat(const char *path, struct stat *buf)
> +{
> + int ret;
> +
> + if ((ret = lstat(path, buf)) < 0) {
> + SYS_ERROR("lstat : %s", path);
> + }
> +
> + return ret;
> +}
> +
> +int
> +btrfs_fstat(int fd, struct stat *buf)
> +{
> + int ret;
> +
> + if ((ret = fstat(fd, buf)) < 0)
> + SYS_ERROR("fstat :");
> +
> + return ret;
> +}
> +
> +void*
> +btrfs_malloc(size_t size)
> +{
> + void *p;
> +
> + if ((p = malloc(size)) == NULL) {
> + if (size != 0)
> + SYS_ERROR("malloc :");
> + }
> +
> + return p;
> +}
> +
> +void*
> +btrfs_calloc(size_t nmemb, size_t size)
> +{
> + void *p;
> +
> + if ((p = calloc(nmemb, size)) == NULL) {
> + if (size != 0)
> + SYS_ERROR("calloc :");
> + }
> +
> + return p;
> +}
> +
> +FILE*
> +btrfs_fopen(const char *path, const char *mode)
> +{
> + FILE *f;
> +
> + if ((f = fopen(path, mode)) == NULL)
> + SYS_ERROR("fopen : %s", path);
> +
> + return f;
> +}
> +
> +DIR*
> +btrfs_opendir(const char *name)
> +{
> + DIR *d;
> +
> + if ((d = opendir(name)) == NULL)
> + SYS_ERROR("opendir :");
> +
> + return d;
> +}
> +
> +int
> +btrfs_dirfd(DIR *dirp)
> +{
> + int fd;
> +
> + if ((fd = dirfd(dirp)) < 0)
> + SYS_ERROR("dirfd :");
> +
> + return fd;
> +}
> +
> +int
> +btrfs_closedir(DIR *dirp)
> +{
> + int ret;
> +
> + if ((ret = closedir(dirp)) < 0)
> + SYS_ERROR("closedir :");
> +
> + return ret;
> +}
> +
> +ssize_t
> +btrfs_pwrite(int fd, const void *buf, size_t count, off_t offset)
> +{
> + ssize_t ret;
> +
> + if ((ret = pwrite(fd, buf, count, offset)) < 0)
> + SYS_ERROR("pwrite :");
> +
> + return ret;
> +}
> +
> +ssize_t
> +btrfs_pread(int fd, const void *buf, size_t count, off_t offset)
> +{
> + ssize_t ret;
> +
> + if ((ret = pread(fd, buf, count, offset)) < 0)
> + SYS_ERROR("pread :");
> +
> + return ret;
> +}
> diff --git a/btrfs-syscalls.h b/btrfs-syscalls.h
> new file mode 100644
> index 0000000..2c717bf
> --- /dev/null
> +++ b/btrfs-syscalls.h
> @@ -0,0 +1,55 @@
> +#ifndef __BTRFS_SYSCALLS_H__
> +#define __BTRFS_SYSCALLS_H__
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/ioctl.h>
> +#include <fcntl.h>
> +#include <dirent.h>
> +#include <unistd.h>
> +#include <execinfo.h>
> +#include <errno.h>
> +#include <stdio.h>
> +#include <string.h>
> +#include <stdarg.h>
> +#include <stdlib.h>
> +
> +
> +extern int err_verbose;
> +#define SYS_ERROR(M, ...)\
> + do {\
> + int e;\
> + e = errno;\
> + switch (err_verbose) {\
> + case 0:\
> + fprintf(stderr, "ERROR: " M " %s\n", ##__VA_ARGS__,\
> + strerror(errno));\
> + break;\
> + case 1:\
> + fprintf(stderr, "ERROR: %s: %s: %d: " M " %s\n", __FILE__, __func__,\
> + __LINE__, ##__VA_ARGS__, strerror(errno));\
> + break;\
> + case 2:\
> + btrfs_backtrace();\
> + fprintf(stderr, "ERROR: %s: %s: %d: " M " %s\n", __FILE__, __func__,\
> + __LINE__, ##__VA_ARGS__, strerror(errno));\
> + break;\
> + }\
> + errno = e;\
> + } while (0);
> +
> +int btrfs_open(const char *pathname, int flags);
> +int btrfs_close(int fd);
> +int btrfs_stat(const char *path, struct stat *buf);
> +int btrfs_fstat(int fd, struct stat *buf);
> +int btrfs_lstat(const char *path, struct stat *buf);
> +void* btrfs_malloc(size_t size);
> +void* btrfs_calloc(size_t nmemb, size_t size);
> +void btrfs_free(void *ptr);
> +FILE* btrfs_fopen(const char *path, const char *mode);
> +DIR* btrfs_opendir(const char *name);
> +int btrfs_dirfd(DIR *dirp);
> +int btrfs_closedir(DIR *dirp);
> +ssize_t btrfs_pwrite(int fd, const void *buf, size_t count, off_t offset);
> +ssize_t btrfs_pread(int fd, const void *buf, size_t count, off_t offset);
> +void btrfs_backtrace(void);
> +#endif /* EOF __BTRFS_SYSCALLS_H__ */
> diff --git a/kerncompat.h b/kerncompat.h
> index bb03194..4542318 100644
> --- a/kerncompat.h
> +++ b/kerncompat.h
> @@ -29,6 +29,7 @@
> #include <stddef.h>
> #include <linux/types.h>
> #include <stdint.h>
> +#include "btrfs-syscalls.h"
>
> #define ptr_to_u64(x) ((u64)(uintptr_t)x)
> #define u64_to_ptr(x) ((void *)(uintptr_t)x)
> @@ -232,8 +233,8 @@ static inline long IS_ERR(const void *ptr)
> /*
> * kmalloc/kfree
> */
> -#define kmalloc(x, y) malloc(x)
> -#define kzalloc(x, y) calloc(1, x)
> +#define kmalloc(x, y) btrfs_malloc(x)
> +#define kzalloc(x, y) btrfs_calloc(1, x)
> #define kstrdup(x, y) strdup(x)
> #define kfree(x) free(x)
>
> diff --git a/utils.c b/utils.c
> index c4f2a00..f18c4ae 100644
> --- a/utils.c
> +++ b/utils.c
> @@ -47,6 +47,7 @@
> #include "utils.h"
> #include "volumes.h"
> #include "ioctl.h"
> +#include "btrfs-syscalls.h"
>
> #ifndef BLKDISCARD
> #define BLKDISCARD _IO(0x12,119)
> @@ -105,8 +106,11 @@ static int discard_range(int fd, u64 start, u64 len)
> {
> u64 range[2] = { start, len };
>
> - if (ioctl(fd, BLKDISCARD, &range) < 0)
> + if (ioctl(fd, BLKDISCARD, &range) < 0) {
> + if (err_verbose > 1)
> + SYS_ERROR("ioctl : BLKDISCARD ");
> return errno;
> + }
> return 0;
> }
>
> @@ -236,7 +240,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> 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);
> @@ -319,7 +323,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
>
>
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[1]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[1]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -378,7 +382,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
> btrfs_set_header_nritems(buf, nritems);
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[2]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[2]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -465,7 +469,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
> btrfs_set_header_nritems(buf, nritems);
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[3]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[3]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -504,7 +508,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
> btrfs_set_header_nritems(buf, nritems);
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[4]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[4]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -517,7 +521,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
> btrfs_set_header_nritems(buf, 0);
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[5]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[5]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -529,7 +533,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID);
> btrfs_set_header_nritems(buf, 0);
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, leafsize, blocks[6]);
> + ret = btrfs_pwrite(fd, buf->data, leafsize, blocks[6]);
> if (ret != leafsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -541,7 +545,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
> memcpy(buf->data, &super, sizeof(super));
> buf->len = sectorsize;
> csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
> - ret = pwrite(fd, buf->data, sectorsize, blocks[0]);
> + ret = btrfs_pwrite(fd, buf->data, sectorsize, blocks[0]);
> if (ret != sectorsize) {
> ret = (ret < 0 ? -errno : -EIO);
> goto out;
> @@ -565,20 +569,22 @@ u64 btrfs_device_size(int fd, struct stat *st)
> }
> if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
> return size;
> + } else {
> + SYS_ERROR("ioctl : BLKGETSIZE64 ");
> }
> return 0;
> }
>
> 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);
> + written = btrfs_pwrite(fd, buf, len, start);
> if (written != len)
> ret = -EIO;
> free(buf);
> @@ -669,7 +675,7 @@ int btrfs_add_to_fsid(struct btrfs_trans_handle *trans,
> btrfs_set_stack_device_bytes_used(dev_item, device->bytes_used);
> memcpy(&dev_item->uuid, device->uuid, BTRFS_UUID_SIZE);
>
> - ret = pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
> + ret = btrfs_pwrite(fd, buf, sectorsize, BTRFS_SUPER_INFO_OFFSET);
> BUG_ON(ret != sectorsize);
>
> kfree(buf);
> @@ -685,7 +691,7 @@ int btrfs_prepare_device(int fd, char *file, int zero_end, u64 *block_count_ret,
> struct stat st;
> int i, ret;
>
> - ret = fstat(fd, &st);
> + ret = btrfs_fstat(fd, &st);
> if (ret < 0) {
> fprintf(stderr, "unable to stat %s\n", file);
> return 1;
> @@ -781,7 +787,7 @@ int is_block_device(const char *path)
> {
> struct stat statbuf;
>
> - if (stat(path, &statbuf) < 0)
> + if (btrfs_stat(path, &statbuf) < 0)
> return -errno;
>
> return S_ISBLK(statbuf.st_mode);
> @@ -834,7 +840,7 @@ int get_btrfs_mount(const char *dev, char *mp, size_t mp_size)
> goto out;
> }
>
> - fd = open(dev, O_RDONLY);
> + fd = btrfs_open(dev, O_RDONLY);
> if (fd < 0) {
> ret = -errno;
> fprintf(stderr, "Could not open %s: %s\n", dev, strerror(errno));
> @@ -849,7 +855,7 @@ int get_btrfs_mount(const char *dev, char *mp, size_t mp_size)
> }
> out:
> if (fd != -1)
> - close(fd);
> + btrfs_close(fd);
> return ret;
> }
>
> @@ -886,7 +892,7 @@ int open_path_or_dev_mnt(const char *path, DIR **dirstream)
> static int is_loop_device (const char* device) {
> struct stat statbuf;
>
> - if(stat(device, &statbuf) < 0)
> + if(btrfs_stat(device, &statbuf) < 0)
> return -errno;
>
> return (S_ISBLK(statbuf.st_mode) &&
> @@ -908,7 +914,7 @@ static int resolve_loop_device(const char* loop_dev, char* loop_file,
> if (!realpath(loop_dev, real_loop_dev))
> return -errno;
> snprintf(p, PATH_MAX, "/sys/block/%s/loop/backing_file", strrchr(real_loop_dev, '/'));
> - if (!(f = fopen(p, "r")))
> + if (!(f = btrfs_fopen(p, "r")))
> return -errno;
>
> snprintf(fmt, 20, "%%%i[^\n]", max_len-1);
> @@ -939,8 +945,8 @@ static int is_same_blk_file(const char* a, const char* b)
> if(strcmp(real_a, real_b) == 0)
> return 1;
>
> - if(stat(a, &st_buf_a) < 0 ||
> - stat(b, &st_buf_b) < 0)
> + if(btrfs_stat(a, &st_buf_a) < 0 ||
> + btrfs_stat(b, &st_buf_b) < 0)
> {
> if (errno == ENOENT)
> return 0;
> @@ -1020,7 +1026,7 @@ static int is_existing_blk_or_reg_file(const char* filename)
> {
> struct stat st_buf;
>
> - if(stat(filename, &st_buf) < 0) {
> + if(btrfs_stat(filename, &st_buf) < 0) {
> if(errno == ENOENT)
> return 0;
> else
> @@ -1067,7 +1073,7 @@ char *canonicalize_dm_name(const char *ptname)
> return NULL;
>
> snprintf(path, sizeof(path), "/sys/block/%s/dm/name", ptname);
> - if (!(f = fopen(path, "r")))
> + if (!(f = btrfs_fopen(path, "r")))
> return NULL;
>
> /* read <name>\n from sysfs */
> @@ -1119,14 +1125,14 @@ int check_mounted(const char* file)
> int fd;
> int ret;
>
> - fd = open(file, O_RDONLY);
> + fd = btrfs_open(file, O_RDONLY);
> if (fd < 0) {
> fprintf (stderr, "check_mounted(): Could not open %s\n", file);
> return -errno;
> }
>
> ret = check_mounted_where(fd, file, NULL, 0, NULL);
> - close(fd);
> + btrfs_close(fd);
>
> return ret;
> }
> @@ -1205,24 +1211,20 @@ void btrfs_register_one_device(char *fname)
> struct btrfs_ioctl_vol_args args;
> int fd;
> int ret;
> - int e;
>
> - fd = open("/dev/btrfs-control", O_RDONLY);
> + fd = btrfs_open("/dev/btrfs-control", O_RDONLY);
> if (fd < 0) {
> fprintf(stderr, "failed to open /dev/btrfs-control "
> - "skipping device registration: %s\n",
> - strerror(errno));
> + "skipping device registration.");
> return;
> }
> strncpy(args.name, fname, BTRFS_PATH_NAME_MAX);
> args.name[BTRFS_PATH_NAME_MAX-1] = 0;
> ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
> - e = errno;
> if(ret<0){
> - fprintf(stderr, "ERROR: device scan failed '%s' - %s\n",
> - fname, strerror(e));
> + SYS_ERROR("ioctl : BTRFS_IOC_SCAN_DEV : device scan failed %s", fname)
> }
> - close(fd);
> + btrfs_close(fd);
> }
>
> int btrfs_scan_one_dir(char *dirname, int run_ioctl)
> @@ -1241,21 +1243,21 @@ int btrfs_scan_one_dir(char *dirname, int run_ioctl)
>
> INIT_LIST_HEAD(&pending_list);
>
> - pending = malloc(sizeof(*pending));
> + pending = btrfs_malloc(sizeof(*pending));
> if (!pending)
> return -ENOMEM;
> strcpy(pending->name, dirname);
>
> again:
> dirname_len = strlen(pending->name);
> - fullpath = malloc(PATH_MAX);
> + fullpath = btrfs_malloc(PATH_MAX);
> dirname = pending->name;
>
> if (!fullpath) {
> ret = -ENOMEM;
> goto fail;
> }
> - dirp = opendir(dirname);
> + dirp = btrfs_opendir(dirname);
> if (!dirp) {
> fprintf(stderr, "Unable to open %s for scanning\n", dirname);
> ret = -errno;
> @@ -1272,15 +1274,14 @@ again:
> goto fail;
> }
> snprintf(fullpath, PATH_MAX, "%s/%s", dirname, dirent->d_name);
> - ret = lstat(fullpath, &st);
> + ret = btrfs_lstat(fullpath, &st);
> if (ret < 0) {
> - fprintf(stderr, "failed to stat %s\n", fullpath);
> continue;
> }
> if (S_ISLNK(st.st_mode))
> continue;
> if (S_ISDIR(st.st_mode)) {
> - struct pending_dir *next = malloc(sizeof(*next));
> + struct pending_dir *next = btrfs_malloc(sizeof(*next));
> if (!next) {
> ret = -ENOMEM;
> goto fail;
> @@ -1291,7 +1292,7 @@ again:
> if (!S_ISBLK(st.st_mode)) {
> continue;
> }
> - fd = open(fullpath, O_RDONLY);
> + fd = btrfs_open(fullpath, O_RDONLY);
> if (fd < 0) {
> /* ignore the following errors:
> ENXIO (device don't exists)
> @@ -1299,8 +1300,8 @@ again:
> like a cd tray empty)
> */
> if(errno != ENXIO && errno != ENOMEDIUM)
> - fprintf(stderr, "failed to read %s: %s\n",
> - fullpath, strerror(errno));
> + fprintf(stderr, "failed to read %s\n",
> + fullpath);
> continue;
> }
> ret = btrfs_scan_one_device(fd, fullpath, &tmp_devices,
> @@ -1309,7 +1310,7 @@ again:
> if (ret == 0 && run_ioctl > 0) {
> btrfs_register_one_device(fullpath);
> }
> - close(fd);
> + btrfs_close(fd);
> }
> if (!list_empty(&pending_list)) {
> free(pending);
> @@ -1317,7 +1318,7 @@ again:
> list);
> free(fullpath);
> list_del(&pending->list);
> - closedir(dirp);
> + btrfs_closedir(dirp);
> dirp = NULL;
> goto again;
> }
> @@ -1332,7 +1333,7 @@ fail:
> free(pending);
> }
> if (dirp)
> - closedir(dirp);
> + btrfs_closedir(dirp);
> return ret;
> }
>
> @@ -1353,12 +1354,12 @@ int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
> char *buf;
> int ret = 0;
>
> - buf = malloc(BTRFS_SUPER_INFO_SIZE);
> + buf = btrfs_malloc(BTRFS_SUPER_INFO_SIZE);
> if (!buf) {
> ret = -ENOMEM;
> goto out;
> }
> - ret = pread(fd, buf, BTRFS_SUPER_INFO_SIZE, super_offset);
> + ret = btrfs_pread(fd, buf, BTRFS_SUPER_INFO_SIZE, super_offset);
> if (ret != BTRFS_SUPER_INFO_SIZE)
> goto brelse;
>
> @@ -1484,20 +1485,18 @@ static int set_label_mounted(const char *mount_path, const char *label)
> {
> int fd;
>
> - fd = open(mount_path, O_RDONLY | O_NOATIME);
> + fd = btrfs_open(mount_path, O_RDONLY | O_NOATIME);
> if (fd < 0) {
> - fprintf(stderr, "ERROR: unable to access '%s'\n", mount_path);
> return -1;
> }
>
> if (ioctl(fd, BTRFS_IOC_SET_FSLABEL, label) < 0) {
> - fprintf(stderr, "ERROR: unable to set label %s\n",
> - strerror(errno));
> - close(fd);
> + SYS_ERROR("ioctl : BTRFS_IOC_SET_FSLABEL : unable to set label %s", mount_path);
> + btrfs_close(fd);
> return -1;
> }
>
> - close(fd);
> + btrfs_close(fd);
> return 0;
> }
>
> @@ -1541,21 +1540,20 @@ int get_label_mounted(const char *mount_path, char *labelp)
> char label[BTRFS_LABEL_SIZE];
> int fd;
>
> - fd = open(mount_path, O_RDONLY | O_NOATIME);
> + fd = btrfs_open(mount_path, O_RDONLY | O_NOATIME);
> if (fd < 0) {
> - fprintf(stderr, "ERROR: unable to access '%s'\n", mount_path);
> return -1;
> }
>
> memset(label, '\0', sizeof(label));
> if (ioctl(fd, BTRFS_IOC_GET_FSLABEL, label) < 0) {
> - fprintf(stderr, "ERROR: unable get label %s\n", strerror(errno));
> - close(fd);
> + SYS_ERROR("ioctl : BTRFS_IOC_GET_FSLABEL : unable to get label %s", mount_path);
> + btrfs_close(fd);
> return -1;
> }
>
> strncpy(labelp, label, sizeof(label));
> - close(fd);
> + btrfs_close(fd);
> return 0;
> }
>
> @@ -1604,7 +1602,7 @@ int btrfs_scan_block_devices(int run_ioctl)
> int special;
>
> scan_again:
> - proc_partitions = fopen("/proc/partitions","r");
> + proc_partitions = btrfs_fopen("/proc/partitions","r");
> if (!proc_partitions) {
> fprintf(stderr, "Unable to open '/proc/partitions' for scanning\n");
> return -ENOENT;
> @@ -1637,7 +1635,7 @@ scan_again:
> if (scans > 0 && !special)
> continue;
>
> - ret = lstat(fullpath, &st);
> + ret = btrfs_lstat(fullpath, &st);
> if (ret < 0) {
> fprintf(stderr, "failed to stat %s\n", fullpath);
> continue;
> @@ -1646,11 +1644,9 @@ scan_again:
> continue;
> }
>
> - fd = open(fullpath, O_RDONLY);
> + fd = btrfs_open(fullpath, O_RDONLY);
> if (fd < 0) {
> if (errno != ENOMEDIUM)
> - fprintf(stderr, "failed to open %s: %s\n",
> - fullpath, strerror(errno));
> continue;
> }
> ret = btrfs_scan_one_device(fd, fullpath, &tmp_devices,
> @@ -1659,7 +1655,7 @@ scan_again:
> if (ret == 0 && run_ioctl > 0) {
> btrfs_register_one_device(fullpath);
> }
> - close(fd);
> + btrfs_close(fd);
> }
>
> fclose(proc_partitions);
> @@ -1765,17 +1761,17 @@ int open_file_or_dir3(const char *fname, DIR **dirstream, int open_flags)
> struct stat st;
> int fd;
>
> - ret = stat(fname, &st);
> + ret = btrfs_stat(fname, &st);
> if (ret < 0) {
> return -1;
> }
> if (S_ISDIR(st.st_mode)) {
> - *dirstream = opendir(fname);
> + *dirstream = btrfs_opendir(fname);
> if (!*dirstream)
> return -1;
> - fd = dirfd(*dirstream);
> + fd = btrfs_dirfd(*dirstream);
> } else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
> - fd = open(fname, open_flags);
> + fd = btrfs_open(fname, open_flags);
> } else {
> /*
> * we set this on purpose, in case the caller output
> @@ -1787,7 +1783,7 @@ int open_file_or_dir3(const char *fname, DIR **dirstream, int open_flags)
> if (fd < 0) {
> fd = -1;
> if (*dirstream)
> - closedir(*dirstream);
> + btrfs_closedir(*dirstream);
> }
> return fd;
> }
> @@ -1800,9 +1796,9 @@ int open_file_or_dir(const char *fname, DIR **dirstream)
> void close_file_or_dir(int fd, DIR *dirstream)
> {
> if (dirstream)
> - closedir(dirstream);
> + btrfs_closedir(dirstream);
> else if (fd >= 0)
> - close(fd);
> + btrfs_close(fd);
> }
>
> int get_device_info(int fd, u64 devid,
> @@ -1813,7 +1809,9 @@ int get_device_info(int fd, u64 devid,
> di_args->devid = devid;
> memset(&di_args->uuid, '\0', sizeof(di_args->uuid));
>
> - ret = ioctl(fd, BTRFS_IOC_DEV_INFO, di_args);
> + if ((ret = ioctl(fd, BTRFS_IOC_DEV_INFO, di_args)) < 0) {
> + SYS_ERROR("ioctl : BTRFS_IOC_DEV_INFO ");
> + }
> return ret ? -errno : 0;
> }
>
> @@ -1847,11 +1845,9 @@ int get_fs_info(char *path, struct btrfs_ioctl_fs_info_args *fi_args,
> u64 devid;
>
> /* Ensure it's mounted, then set path to the mountpoint */
> - fd = open(path, O_RDONLY);
> + fd = btrfs_open(path, O_RDONLY);
> if (fd < 0) {
> ret = -errno;
> - fprintf(stderr, "Couldn't open %s: %s\n",
> - path, strerror(errno));
> goto out;
> }
> ret = check_mounted_where(fd, path, mp, sizeof(mp),
> @@ -1879,7 +1875,7 @@ int get_fs_info(char *path, struct btrfs_ioctl_fs_info_args *fi_args,
> i = devid;
>
> memcpy(fi_args->fsid, fs_devices_mnt->fsid, BTRFS_FSID_SIZE);
> - close(fd);
> + btrfs_close(fd);
> }
>
> /* at this point path must not be for a block device */
> @@ -1893,6 +1889,7 @@ int get_fs_info(char *path, struct btrfs_ioctl_fs_info_args *fi_args,
> if (fi_args->num_devices != 1) {
> ret = ioctl(fd, BTRFS_IOC_FS_INFO, fi_args);
> if (ret < 0) {
> + SYS_ERROR("ioctl : BTRFS_IOC_FS_INFO ");
> ret = -errno;
> goto out;
> }
> @@ -1901,7 +1898,7 @@ int get_fs_info(char *path, struct btrfs_ioctl_fs_info_args *fi_args,
> if (!fi_args->num_devices)
> goto out;
>
> - 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) {
> ret = -errno;
> goto out;
> @@ -1962,7 +1959,7 @@ static int is_swap_device(const char *file)
> char *cp;
> int ret = 0;
>
> - if (stat(file, &st_buf) < 0)
> + if (btrfs_stat(file, &st_buf) < 0)
> return -errno;
> if (S_ISBLK(st_buf.st_mode))
> dev = st_buf.st_rdev;
> @@ -1972,7 +1969,7 @@ static int is_swap_device(const char *file)
> } else
> return 0;
>
> - if ((f = fopen("/proc/swaps", "r")) == NULL)
> + if ((f = btrfs_fopen("/proc/swaps", "r")) == NULL)
> return 0;
>
> /* skip the first line */
> @@ -1985,7 +1982,7 @@ static int is_swap_device(const char *file)
> if ((cp = strchr(tmp, '\t')) != NULL)
> *cp = '\0';
> translate(tmp, buf);
> - if (stat(buf, &st_buf) != 0)
> + if (btrfs_stat(buf, &st_buf) != 0)
> continue;
> if (S_ISBLK(st_buf.st_mode)) {
> if (dev == st_buf.st_rdev) {
> @@ -2165,24 +2162,24 @@ int test_dev_for_mkfs(char *file, int force_overwrite, char *estr)
> return 1;
> }
> /* check if the device is busy */
> - fd = open(file, O_RDWR|O_EXCL);
> + fd = btrfs_open(file, O_RDWR|O_EXCL);
> if (fd < 0) {
> snprintf(estr, sz, "unable to open %s: %s\n", file,
> strerror(errno));
> return 1;
> }
> - if (fstat(fd, &st)) {
> + if (btrfs_fstat(fd, &st)) {
> snprintf(estr, sz, "unable to stat %s: %s\n", file,
> strerror(errno));
> - close(fd);
> + btrfs_close(fd);
> return 1;
> }
> if (!S_ISBLK(st.st_mode)) {
> fprintf(stderr, "'%s' is not a block device\n", file);
> - close(fd);
> + btrfs_close(fd);
> return 1;
> }
> - close(fd);
> + btrfs_close(fd);
> return 0;
> }
>
> @@ -2211,7 +2208,7 @@ int btrfs_scan_lblkid(int update_kernel)
> /* if we are here its definitely a btrfs disk*/
> strncpy(path, blkid_dev_devname(dev), PATH_MAX);
>
> - fd = open(path, O_RDONLY);
> + fd = btrfs_open(path, O_RDONLY);
> if (fd < 0) {
> printf("ERROR: could not open %s\n", path);
> continue;
> @@ -2261,24 +2258,24 @@ int is_vol_small(char *file)
> struct stat st;
> u64 size;
>
> - fd = open(file, O_RDONLY);
> + fd = btrfs_open(file, O_RDONLY);
> if (fd < 0)
> return -errno;
> - if (fstat(fd, &st) < 0) {
> + if (btrfs_fstat(fd, &st) < 0) {
> e = -errno;
> - close(fd);
> + btrfs_close(fd);
> return e;
> }
> size = btrfs_device_size(fd, &st);
> if (size == 0) {
> - close(fd);
> + btrfs_close(fd);
> return -1;
> }
> if (size < BTRFS_MKFS_SMALL_VOLUME_SIZE) {
> - close(fd);
> + btrfs_close(fd);
> return 1;
> } else {
> - close(fd);
> + btrfs_close(fd);
> return 0;
> }
> }
> @@ -2312,17 +2309,14 @@ int lookup_ino_rootid(int fd, u64 *rootid)
> {
> struct btrfs_ioctl_ino_lookup_args args;
> int ret;
> - int e;
>
> memset(&args, 0, sizeof(args));
> args.treeid = 0;
> args.objectid = BTRFS_FIRST_FREE_OBJECTID;
>
> ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
> - e = errno;
> if (ret) {
> - fprintf(stderr, "ERROR: Failed to lookup root id - %s\n",
> - strerror(e));
> + SYS_ERROR("ioctl : BTRFS_IOC_INO_LOOKUP : Failed to lookup root id");
> return ret;
> }
>
> @@ -2347,10 +2341,10 @@ int find_mount_root(const char *path, char **mount_root)
> int longest_matchlen = 0;
> char *longest_match = NULL;
>
> - fd = open(path, O_RDONLY | O_NOATIME);
> + fd = btrfs_open(path, O_RDONLY | O_NOATIME);
> if (fd < 0)
> return -errno;
> - close(fd);
> + btrfs_close(fd);
>
> mnttab = setmntent("/proc/self/mounts", "r");
> if (!mnttab)
> @@ -2391,18 +2385,18 @@ int test_minimum_size(const char *file, u32 leafsize)
> int fd;
> struct stat statbuf;
>
> - fd = open(file, O_RDONLY);
> + fd = btrfs_open(file, O_RDONLY);
> if (fd < 0)
> return -errno;
> - if (stat(file, &statbuf) < 0) {
> - close(fd);
> + if (btrfs_stat(file, &statbuf) < 0) {
> + btrfs_close(fd);
> return -errno;
> }
> if (btrfs_device_size(fd, &statbuf) < btrfs_min_dev_size(leafsize)) {
> - close(fd);
> + btrfs_close(fd);
> return 1;
> }
> - close(fd);
> + btrfs_close(fd);
> return 0;
> }
>
> @@ -2430,7 +2424,7 @@ int test_isdir(const char *path)
> struct stat st;
> int ret;
>
> - ret = stat(path, &st);
> + ret = btrfs_stat(path, &st);
> if(ret < 0 )
> return -1;
>
> --
> 1.9.1
>
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
