From: Andre Noll Date: Fri, 6 Jun 2008 12:54:37 +0000 (+0200) Subject: Rename fd.[ch] to util.[ch]. X-Git-Tag: v0.1.0~52 X-Git-Url: http://git.tuebingen.mpg.de/?p=osl.git;a=commitdiff_plain;h=c1a4bb030717f2d2d209ccd8ab898ab66fa16869 Rename fd.[ch] to util.[ch]. It contains not only fd-related stuff. --- diff --git a/Makefile b/Makefile index 24775a4..b42b1a9 100644 --- a/Makefile +++ b/Makefile @@ -3,8 +3,8 @@ prefix := /usr/local libdir := $(prefix)/lib includedir := $(prefix)/include -objects := osl.o fd.o rbtree.o sha1.o -fsck_objects := fsck.fsck.o osl.fsck.o fd.fsck.o rbtree.fsck.o sha1.fsck.o fsck.cmdline.o +objects := osl.o util.o rbtree.o sha1.o +fsck_objects := fsck.fsck.o osl.fsck.o util.fsck.o rbtree.fsck.o sha1.fsck.o fsck.cmdline.o headers := osl.h INSTALL := install diff --git a/fd.c b/fd.c deleted file mode 100644 index 0dc3f29..0000000 --- a/fd.c +++ /dev/null @@ -1,272 +0,0 @@ -/* - * Copyright (C) 2006-2008 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ - -/** \file fd.c Helper functions for file descriptor handling. */ - -#include -#include -#include -#include -#include - -#include "log.h" -#include "osl.h" -#include "error.h" -#include "fd.h" - -/** - * Wrapper for the write system call. - * - * \param fd The file descriptor to write to. - * \param buf The buffer to write. - * \param size The length of \a buf in bytes. - * - * This function writes out the given buffer and retries if an interrupt - * occurred during the write. - * - * \return On success, the number of bytes written is returned, otherwise, a - * negative error code is returned. - * - * \sa write(2). - */ -static ssize_t __write(int fd, const void *buf, size_t size) -{ - ssize_t ret; - - for (;;) { - ret = write(fd, buf, size); - if ((ret < 0) && (errno == EAGAIN || errno == EINTR)) - continue; - return ret >= 0? ret : -ERRNO_TO_ERROR(errno); - } -} - -/** - * Write a buffer to a file descriptor, re-write on short writes. - * - * \param fd The file descriptor. - * \param buf The buffer to be sent. - * \param len The length of \a buf. - * - * \return Standard. In any case, the number of bytes that have been written is - * stored in \a len. - */ -int write_all(int fd, const char *buf, size_t *len) -{ - size_t total = *len; - - assert(total); - *len = 0; - while (*len < total) { - int ret = __write(fd, buf + *len, total - *len); - if (ret < 0) - return ret; - *len += ret; - } - return 1; -} - -/** - * Wrapper for the open(2) system call. - * - * \param path The filename. - * \param flags The usual open(2) flags. - * \param mode Specifies the permissions to use. - * - * The mode parameter must be specified when O_CREAT is in the flags, and is - * ignored otherwise. - * - * \return The file descriptor on success, negative on errors. - * - * \sa open(2). - */ -int osl_open(const char *path, int flags, mode_t mode) -{ - int ret = open(path, flags, mode); - - if (ret >= 0) - return ret; - return -ERRNO_TO_ERROR(errno); -} - -/** - * Open a file, write the given buffer and close the file. - * - * \param filename Full path to the file to open. - * \param buf The buffer to write to the file. - * \param size The size of \a buf. - * - * \return Standard. - */ -int write_file(const char *filename, const void *buf, size_t size) -{ - int ret, fd; - - ret = osl_open(filename, O_WRONLY | O_CREAT | O_EXCL, 0644); - if (ret < 0) - return ret; - fd = ret; - ret = write_all(fd, buf, &size); - if (ret < 0) - goto out; - ret = 1; -out: - close(fd); - return ret; -} - -/** - * Open a file and map it into memory. - * - * \param path Name of the regular file to map. - * \param open_mode Either \p O_RDONLY or \p O_RDWR. - * \param map On success, the mapping is returned here. - * \param size size of the mapping. - * \param fd_ptr The file descriptor of the mapping. - * - * If \a fd_ptr is \p NULL, the file descriptor resulting from the underlying - * open call is closed after mmap(). Otherwise the file is kept open and the - * file descriptor is returned in \a fd_ptr. - * - * \return Standard. - * - * \sa osl_open(), mmap(2). - */ -int mmap_full_file(const char *path, int open_mode, void **map, - size_t *size, int *fd_ptr) -{ - int fd, ret, mmap_prot, mmap_flags; - struct stat file_status; - - if (open_mode == O_RDONLY) { - mmap_prot = PROT_READ; - mmap_flags = MAP_PRIVATE; - } else { - mmap_prot = PROT_READ | PROT_WRITE; - mmap_flags = MAP_SHARED; - } - ret = osl_open(path, open_mode, 0); - if (ret < 0) - return ret; - fd = ret; - if (fstat(fd, &file_status) < 0) { - ret = -ERRNO_TO_ERROR(errno); - goto out; - } - *size = file_status.st_size; - ret = -E_OSL_EMPTY; - DEBUG_LOG("%s: size %zu\n", path, *size); - if (!*size) - goto out; - *map = mmap(NULL, *size, mmap_prot, mmap_flags, fd, 0); - if (*map == MAP_FAILED) { - *map = NULL; - ret = -E_OSL_MMAP; - goto out; - } - ret = 1; -out: - if (ret < 0 || !fd_ptr) - close(fd); - else - *fd_ptr = fd; - return ret; -} - -/** - * A wrapper for munmap(2). - * - * \param start The start address of the memory mapping. - * \param length The size of the mapping. - * - * \return Positive on success, \p -E_MUNMAP on errors. - * - * \sa munmap(2), mmap_full_file(). - */ -int osl_munmap(void *start, size_t length) -{ - int err; - if (munmap(start, length) >= 0) - return 1; - err = errno; - ERROR_LOG("munmap (%p/%zu) failed: %s\n", start, length, - strerror(err)); - return -ERRNO_TO_ERROR(err); -} - -/** - * Allocate a sufficiently large string and print into it. - * - * \param fmt A usual format string. - * - * Produce output according to \p fmt. No artificial bound on the length of the - * resulting string is imposed. - * - * \return This function either returns a pointer to a string that must be - * freed by the caller or \p NULL if memory allocation failed. - * - * \sa printf(3). - */ -__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...) -{ - int n; - size_t size = 100; - char *p = malloc(size); - - if (!p) - return NULL; - while (1) { - char *q; - va_list ap; - /* Try to print in the allocated space. */ - va_start(ap, fmt); - n = vsnprintf(p, size, fmt, ap); - va_end(ap); - /* If that worked, return the string. */ - if (n > -1 && n < size) - break; - /* Else try again with more space. */ - if (n > -1) /* glibc 2.1 */ - size = n + 1; /* precisely what is needed */ - else /* glibc 2.0 */ - size *= 2; /* twice the old size */ - q = realloc(p, size); - if (!q) { - free(p); - return NULL; - } - p = q; - } - return p; -} - -/** - * A wrapper for truncate(2) - * - * \param path Name of the regular file to truncate - * \param size Number of bytes to \b shave \b off - * - * Truncate the regular file named by \a path by \a size bytes. - * - * \return Standard. - * - * \sa truncate(2) - */ -int truncate_file(const char *path, off_t size) -{ - int ret; - struct stat statbuf; - - ret = osl_stat(path, &statbuf); - if (ret < 0) - return ret; - ret = -E_OSL_BAD_SIZE; - if (statbuf.st_size < size) - return ret; - if (truncate(path, statbuf.st_size - size) < 0) - return -ERRNO_TO_ERROR(errno); - return 1; -} diff --git a/fd.h b/fd.h deleted file mode 100644 index 536e3c8..0000000 --- a/fd.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (C) 2006-2008 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ - -/** \file fd.h exported symbols from fd.c */ - -int osl_open(const char *path, int flags, mode_t mode); -int mmap_full_file(const char *filename, int open_mode, void **map, - size_t *size, int *fd_ptr); -int osl_munmap(void *start, size_t length); -int write_all(int fd, const char *buf, size_t *len); -int write_file(const char *filename, const void *buf, size_t size); -int truncate_file(const char *filename, off_t size); - -/** - * A wrapper for mkdir(2). - * - * \param path Name of the directory to create. - * \param mode The permissions to use. - * - * \return Standard. - */ -static inline int osl_mkdir(const char *path, mode_t mode) -{ - if (!mkdir(path, mode)) - return 1; - return -ERRNO_TO_ERROR(errno); -} - -/** - * A wrapper for rename(2). - * - * \param old_path The source path. - * \param new_path The destination path. - * - * \return Standard. - * - * \sa rename(2). - */ -_static_inline_ int osl_rename(const char *old_path, const char *new_path) -{ - if (rename(old_path, new_path) < 0) - return -ERRNO_TO_ERROR(errno); - return 1; -} - -_static_inline_ int osl_stat(const char *path, struct stat *buf) -{ - if (stat(path, buf) >= 0) - return 1; - return -ERRNO_TO_ERROR(errno); -} diff --git a/fsck.c b/fsck.c index 6f13671..29c4e2c 100644 --- a/fsck.c +++ b/fsck.c @@ -15,7 +15,7 @@ #include "log.h" #include "osl.h" #include "error.h" -#include "fd.h" +#include "util.h" #include "osl_core.h" #include "fsck.cmdline.h" diff --git a/osl.c b/osl.c index b9424e3..31b40c2 100644 --- a/osl.c +++ b/osl.c @@ -11,7 +11,7 @@ #include "log.h" #include "osl.h" #include "error.h" -#include "fd.h" +#include "util.h" #include "osl_core.h" /* Taken from Drepper: How to write shared libraries, Appendix B. */ diff --git a/util.c b/util.c new file mode 100644 index 0000000..7bf74b0 --- /dev/null +++ b/util.c @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2006-2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file util.c Helper functions needed by both libosl and oslfsck. */ + +#include +#include +#include +#include +#include + +#include "log.h" +#include "osl.h" +#include "error.h" +#include "util.h" + +/** + * Wrapper for the write system call. + * + * \param fd The file descriptor to write to. + * \param buf The buffer to write. + * \param size The length of \a buf in bytes. + * + * This function writes out the given buffer and retries if an interrupt + * occurred during the write. + * + * \return On success, the number of bytes written is returned, otherwise, a + * negative error code is returned. + * + * \sa write(2). + */ +static ssize_t __write(int fd, const void *buf, size_t size) +{ + ssize_t ret; + + for (;;) { + ret = write(fd, buf, size); + if ((ret < 0) && (errno == EAGAIN || errno == EINTR)) + continue; + return ret >= 0? ret : -ERRNO_TO_ERROR(errno); + } +} + +/** + * Write a buffer to a file descriptor, re-write on short writes. + * + * \param fd The file descriptor. + * \param buf The buffer to be sent. + * \param len The length of \a buf. + * + * \return Standard. In any case, the number of bytes that have been written is + * stored in \a len. + */ +int write_all(int fd, const char *buf, size_t *len) +{ + size_t total = *len; + + assert(total); + *len = 0; + while (*len < total) { + int ret = __write(fd, buf + *len, total - *len); + if (ret < 0) + return ret; + *len += ret; + } + return 1; +} + +/** + * Wrapper for the open(2) system call. + * + * \param path The filename. + * \param flags The usual open(2) flags. + * \param mode Specifies the permissions to use. + * + * The mode parameter must be specified when O_CREAT is in the flags, and is + * ignored otherwise. + * + * \return The file descriptor on success, negative on errors. + * + * \sa open(2). + */ +int osl_open(const char *path, int flags, mode_t mode) +{ + int ret = open(path, flags, mode); + + if (ret >= 0) + return ret; + return -ERRNO_TO_ERROR(errno); +} + +/** + * Open a file, write the given buffer and close the file. + * + * \param filename Full path to the file to open. + * \param buf The buffer to write to the file. + * \param size The size of \a buf. + * + * \return Standard. + */ +int write_file(const char *filename, const void *buf, size_t size) +{ + int ret, fd; + + ret = osl_open(filename, O_WRONLY | O_CREAT | O_EXCL, 0644); + if (ret < 0) + return ret; + fd = ret; + ret = write_all(fd, buf, &size); + if (ret < 0) + goto out; + ret = 1; +out: + close(fd); + return ret; +} + +/** + * Open a file and map it into memory. + * + * \param path Name of the regular file to map. + * \param open_mode Either \p O_RDONLY or \p O_RDWR. + * \param map On success, the mapping is returned here. + * \param size size of the mapping. + * \param fd_ptr The file descriptor of the mapping. + * + * If \a fd_ptr is \p NULL, the file descriptor resulting from the underlying + * open call is closed after mmap(). Otherwise the file is kept open and the + * file descriptor is returned in \a fd_ptr. + * + * \return Standard. + * + * \sa osl_open(), mmap(2). + */ +int mmap_full_file(const char *path, int open_mode, void **map, + size_t *size, int *fd_ptr) +{ + int fd, ret, mmap_prot, mmap_flags; + struct stat file_status; + + if (open_mode == O_RDONLY) { + mmap_prot = PROT_READ; + mmap_flags = MAP_PRIVATE; + } else { + mmap_prot = PROT_READ | PROT_WRITE; + mmap_flags = MAP_SHARED; + } + ret = osl_open(path, open_mode, 0); + if (ret < 0) + return ret; + fd = ret; + if (fstat(fd, &file_status) < 0) { + ret = -ERRNO_TO_ERROR(errno); + goto out; + } + *size = file_status.st_size; + ret = -E_OSL_EMPTY; + DEBUG_LOG("%s: size %zu\n", path, *size); + if (!*size) + goto out; + *map = mmap(NULL, *size, mmap_prot, mmap_flags, fd, 0); + if (*map == MAP_FAILED) { + *map = NULL; + ret = -E_OSL_MMAP; + goto out; + } + ret = 1; +out: + if (ret < 0 || !fd_ptr) + close(fd); + else + *fd_ptr = fd; + return ret; +} + +/** + * A wrapper for munmap(2). + * + * \param start The start address of the memory mapping. + * \param length The size of the mapping. + * + * \return Positive on success, \p -E_MUNMAP on errors. + * + * \sa munmap(2), mmap_full_file(). + */ +int osl_munmap(void *start, size_t length) +{ + int err; + if (munmap(start, length) >= 0) + return 1; + err = errno; + ERROR_LOG("munmap (%p/%zu) failed: %s\n", start, length, + strerror(err)); + return -ERRNO_TO_ERROR(err); +} + +/** + * Allocate a sufficiently large string and print into it. + * + * \param fmt A usual format string. + * + * Produce output according to \p fmt. No artificial bound on the length of the + * resulting string is imposed. + * + * \return This function either returns a pointer to a string that must be + * freed by the caller or \p NULL if memory allocation failed. + * + * \sa printf(3). + */ +__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...) +{ + int n; + size_t size = 100; + char *p = malloc(size); + + if (!p) + return NULL; + while (1) { + char *q; + va_list ap; + /* Try to print in the allocated space. */ + va_start(ap, fmt); + n = vsnprintf(p, size, fmt, ap); + va_end(ap); + /* If that worked, return the string. */ + if (n > -1 && n < size) + break; + /* Else try again with more space. */ + if (n > -1) /* glibc 2.1 */ + size = n + 1; /* precisely what is needed */ + else /* glibc 2.0 */ + size *= 2; /* twice the old size */ + q = realloc(p, size); + if (!q) { + free(p); + return NULL; + } + p = q; + } + return p; +} + +/** + * A wrapper for truncate(2) + * + * \param path Name of the regular file to truncate + * \param size Number of bytes to \b shave \b off + * + * Truncate the regular file named by \a path by \a size bytes. + * + * \return Standard. + * + * \sa truncate(2) + */ +int truncate_file(const char *path, off_t size) +{ + int ret; + struct stat statbuf; + + ret = osl_stat(path, &statbuf); + if (ret < 0) + return ret; + ret = -E_OSL_BAD_SIZE; + if (statbuf.st_size < size) + return ret; + if (truncate(path, statbuf.st_size - size) < 0) + return -ERRNO_TO_ERROR(errno); + return 1; +} diff --git a/util.h b/util.h new file mode 100644 index 0000000..2e3c66f --- /dev/null +++ b/util.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2006-2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file util.h exported functions from util.c */ + +int osl_open(const char *path, int flags, mode_t mode); +int mmap_full_file(const char *filename, int open_mode, void **map, + size_t *size, int *fd_ptr); +int osl_munmap(void *start, size_t length); +int write_all(int fd, const char *buf, size_t *len); +int write_file(const char *filename, const void *buf, size_t size); +int truncate_file(const char *filename, off_t size); + +/** + * A wrapper for mkdir(2). + * + * \param path Name of the directory to create. + * \param mode The permissions to use. + * + * \return Standard. + */ +static inline int osl_mkdir(const char *path, mode_t mode) +{ + if (!mkdir(path, mode)) + return 1; + return -ERRNO_TO_ERROR(errno); +} + +/** + * A wrapper for rename(2). + * + * \param old_path The source path. + * \param new_path The destination path. + * + * \return Standard. + * + * \sa rename(2). + */ +_static_inline_ int osl_rename(const char *old_path, const char *new_path) +{ + if (rename(old_path, new_path) < 0) + return -ERRNO_TO_ERROR(errno); + return 1; +} + +_static_inline_ int osl_stat(const char *path, struct stat *buf) +{ + if (stat(path, buf) >= 0) + return 1; + return -ERRNO_TO_ERROR(errno); +}