X-Git-Url: http://git.tuebingen.mpg.de/?p=osl.git;a=blobdiff_plain;f=osl.c;h=5a0dde80ea6eb623172caa2f538834cf12b0a01b;hp=1d5db11ef4c65b32bca5f546596b5d1668262d5c;hb=ad58fcdf85adb652fd1454470c12e3dec9f8cc36;hpb=c870a921193000e3a5123ee4037a81c18218aea5 diff --git a/osl.c b/osl.c index 1d5db11..5a0dde8 100644 --- a/osl.c +++ b/osl.c @@ -8,56 +8,46 @@ #include /* readdir() */ #include - #include "log.h" -#include "error.h" -#include "fd.h" -#include "list.h" +#include "osl.h" +#include "util.h" #include "osl_core.h" -/** - * 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). - */ -static __must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...) +/* Taken from Drepper: How to write shared libraries, Appendix B. */ +#include +#define MSGSTRFIELD(line) MSGSTRFIELD1(line) +#define MSGSTRFIELD1(line) str##line +static const union msgstr_t { + struct { +#define OSL_ERROR(n, s) char MSGSTRFIELD(__LINE__)[sizeof(s)]; +#include "errtab.h" +#undef OSL_ERROR + }; + char str[0]; +} msgstr = { { +#define OSL_ERROR(n, s) s, +#include "errtab.h" +#undef OSL_ERROR +} }; +static const unsigned int errmsgidx[] = { +#define OSL_ERROR(n, s) [n] = offsetof(union msgstr_t, MSGSTRFIELD(__LINE__)), +#include "errtab.h" +#undef OSL_ERROR +}; + +__export const char *osl_strerror(int num) { - int n; - size_t size = 100; - char *p = malloc(size); + return msgstr.str + errmsgidx[num]; +} - 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; - } - } - return p; +int loglevel = 0; + +static void __attribute ((constructor)) init_loglevel(void) +{ + char *p = getenv("OSL_LOGLEVEL"); + + /* don't log anything if unset */ + loglevel = p? atoi(p) : EMERG + 1; } /** @@ -76,7 +66,7 @@ __printf_2_3 void __log(int ll, const char* fmt,...) time_t t1; char str[255] = ""; - if (ll < 2) + if (ll < loglevel) return; outfd = stderr; time(&t1); @@ -100,120 +90,30 @@ __printf_2_3 void __log(int ll, const char* fmt,...) * contains the resulting offset location as measured in bytes from the * beginning of the file. * - * \return Positive on success. Otherwise, the function returns \p -E_LSEEK. + * \return Positive on success. Otherwise, the function returns \p -E_OSL_LSEEK. * * \sa lseek(2). */ static int __lseek(int fd, off_t *offset, int whence) { *offset = lseek(fd, *offset, whence); - int ret = -E_LSEEK; + int ret = -E_OSL_LSEEK; if (*offset == -1) return ret; return 1; } -/** - * 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, the - * function returns \p -E_WRITE. - * - * \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 : -E_WRITE; - } -} - -/** - * Write the whole buffer to a file descriptor. - * - * \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 the given buffer and continues on short writes and - * when interrupted by a signal. - * - * \return Positive on success, negative on errors. Possible errors: any - * errors returned by para_write(). - * - * \sa para_write(). - */ -static ssize_t write_all(int fd, const void *buf, size_t size) -{ -// DEBUG_LOG("writing %zu bytes\n", size); - const char *b = buf; - while (size) { - ssize_t ret = __write(fd, b, size); -// DEBUG_LOG("ret: %zd\n", ret); - if (ret < 0) - return ret; - b += ret; - size -= ret; - } - return 1; -} -/** - * 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 Positive on success, negative on errors. Possible errors include: - * any errors from para_open() or para_write(). - * - * \sa para_open(), para_write(). - */ -static int write_file(const char *filename, const void *buf, size_t size) -{ - int ret, fd; - - ret = para_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; -} - -static int append_file(const char *filename, char *header, size_t header_size, - char *data, size_t data_size, uint32_t *new_pos) +static int append_file(const char *filename, char *data, size_t data_size, + uint32_t *new_pos) { int ret, fd; // DEBUG_LOG("appending %zu + %zu bytes\n", header_size, data_size); - ret = para_open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644); + ret = osl_open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644); if (ret < 0) return ret; fd = ret; - if (header && header_size) { - ret = write_all(fd, header, header_size); - if (ret < 0) - goto out; - } - ret = write_all(fd, data, data_size); + ret = write_all(fd, data, &data_size); if (ret < 0) goto out; if (new_pos) { @@ -233,55 +133,18 @@ out: static int verify_name(const char *name) { if (!name) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!*name) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (strchr(name, '/')) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!strcmp(name, "..")) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; if (!strcmp(name, ".")) - return -E_BAD_NAME; + return -E_OSL_BAD_NAME; return 1; } -/** - * Compare two osl objects pointing to unsigned integers of 32 bit size. - * - * \param obj1 Pointer to the first integer. - * \param obj2 Pointer to the second integer. - * - * \return The values required for an osl compare function. - * - * \sa osl_compare_func, osl_hash_compare(). - */ -int uint32_compare(const struct osl_object *obj1, const struct osl_object *obj2) -{ - uint32_t d1 = read_u32((const char *)obj1->data); - uint32_t d2 = read_u32((const char *)obj2->data); - - if (d1 < d2) - return 1; - if (d1 > d2) - return -1; - return 0; -} - -/** - * Compare two osl objects pointing to hash values. - * - * \param obj1 Pointer to the first hash object. - * \param obj2 Pointer to the second hash object. - * - * \return The values required for an osl compare function. - * - * \sa osl_compare_func, uint32_compare(). - */ -int osl_hash_compare(const struct osl_object *obj1, const struct osl_object *obj2) -{ - return hash_compare((HASH_TYPE *)obj1->data, (HASH_TYPE *)obj2->data); -} - static char *disk_storage_dirname(const struct osl_table *t, unsigned col_num, const char *ds_name) { @@ -315,7 +178,7 @@ static int disk_storage_name_of_row(const struct osl_table *t, *name = disk_storage_name_of_object(t, &obj); if (*name) return 1; - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; } static void column_name_hash(const char *col_name, HASH_TYPE *hash) @@ -328,11 +191,10 @@ static int init_column_descriptions(struct osl_table *t) int i, j, ret; const struct osl_column_description *cd; - ret = -E_BAD_TABLE_DESC; ret = verify_name(t->desc->name); if (ret < 0) goto err; - ret = -E_BAD_DB_DIR; + ret = -E_OSL_BAD_DB_DIR; if (!t->desc->dir && (t->num_disk_storage_columns || t->num_mapped_columns)) goto err; /* the size of the index header without column descriptions */ @@ -341,11 +203,11 @@ static int init_column_descriptions(struct osl_table *t) struct osl_column *col = t->columns + i; if (cd->storage_flags & OSL_RBTREE) { if (!cd->compare_function) - return -E_NO_COMPARE_FUNC; + return -E_OSL_NO_COMPARE_FUNC; } if (cd->storage_type == OSL_NO_STORAGE) continue; - ret = -E_NO_COLUMN_NAME; + ret = -E_OSL_NO_COLUMN_NAME; if (!cd->name || !cd->name[0]) goto err; ret = verify_name(cd->name); @@ -353,7 +215,7 @@ static int init_column_descriptions(struct osl_table *t) goto err; t->index_header_size += index_column_description_size(cd->name); column_name_hash(cd->name, col->name_hash); - ret = -E_DUPLICATE_COL_NAME; + ret = -E_OSL_DUPLICATE_COL_NAME; for (j = i + 1; j < t->desc->num_columns; j++) { const char *name2 = get_column_description(t->desc, j)->name; @@ -376,10 +238,7 @@ err: * of these tests fail. On success, a struct \p osl_table is allocated and * initialized with data derived from \p desc. * - * \return Positive on success, negative on errors. Possible errors include: \p - * E_BAD_TABLE_DESC, \p E_NO_COLUMN_DESC, \p E_NO_COLUMNS, \p - * E_BAD_STORAGE_TYPE, \p E_BAD_STORAGE_FLAGS, \p E_BAD_STORAGE_SIZE, \p - * E_NO_UNIQUE_RBTREE_COLUMN, \p E_NO_RBTREE_COL. + * \return Standard. * * \sa struct osl_table. */ @@ -388,22 +247,22 @@ int init_table_structure(const struct osl_table_description *desc, { const struct osl_column_description *cd; struct osl_table *t = calloc(1, sizeof(*t)); - int i, ret = -ERRNO_TO_ERROR(ENOMEM), have_disk_storage_name_column = 0; + int i, ret = -E_OSL_NOMEM, have_disk_storage_name_column = 0; if (!t) return ret; - ret = -E_BAD_TABLE_DESC; + ret = -E_OSL_BAD_TABLE_DESC; if (!desc) goto err; DEBUG_LOG("creating table structure for '%s' from table " "description\n", desc->name); - ret = -E_NO_COLUMN_DESC; + ret = -E_OSL_NO_COLUMN_DESC; if (!desc->column_descriptions) goto err; - ret = -E_NO_COLUMNS; + ret = -E_OSL_NO_COLUMNS; if (!desc->num_columns) goto err; - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; t->columns = calloc(desc->num_columns, sizeof(struct osl_column)); if (!t->columns) goto err; @@ -413,14 +272,14 @@ int init_table_structure(const struct osl_table_description *desc, enum osl_storage_flags sf = cd->storage_flags; struct osl_column *col = &t->columns[i]; - ret = -E_BAD_STORAGE_TYPE; + ret = -E_OSL_BAD_STORAGE_TYPE; if (st != OSL_MAPPED_STORAGE && st != OSL_DISK_STORAGE && st != OSL_NO_STORAGE) goto err; - ret = -E_BAD_STORAGE_FLAGS; + ret = -E_OSL_BAD_STORAGE_FLAGS; if (st == OSL_DISK_STORAGE && sf & OSL_RBTREE) goto err; - ret = -E_BAD_STORAGE_SIZE; + ret = -E_OSL_BAD_STORAGE_SIZE; if (sf & OSL_FIXED_SIZE && !cd->data_size) goto err; switch (st) { @@ -447,10 +306,10 @@ int init_table_structure(const struct osl_table_description *desc, } } } - ret = -E_NO_UNIQUE_RBTREE_COLUMN; + ret = -E_OSL_NO_UNIQUE_RBTREE_COLUMN; if (t->num_disk_storage_columns && !have_disk_storage_name_column) goto err; - ret = -E_NO_RBTREE_COL; + ret = -E_OSL_NO_RBTREE_COL; if (!t->num_rbtrees) goto err; /* success */ @@ -472,10 +331,10 @@ err: * \param map The memory mapping of the index file. * \param desc The values found in the index header are returned here. * - * Read the index header, check for the paraslash magic string and the table version number. - * Read all information stored in the index header into \a desc. + * Read the index header, check for the osl magic string and the table version + * number. Read all information stored in the index header into \a desc. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa struct osl_table_description, osl_create_table. */ @@ -489,29 +348,29 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) struct osl_column_description *cd; if (map->size < MIN_INDEX_HEADER_SIZE(1)) - return -E_SHORT_TABLE; - if (strncmp(buf + IDX_PARA_MAGIC, PARA_MAGIC, strlen(PARA_MAGIC))) - return -E_NO_MAGIC; + return -E_OSL_SHORT_TABLE; + if (strncmp(buf + IDX_OSL_MAGIC, OSL_MAGIC, strlen(OSL_MAGIC))) + return -E_OSL_NO_MAGIC; version = read_u8(buf + IDX_VERSION); if (version < MIN_TABLE_VERSION || version > MAX_TABLE_VERSION) - return -E_VERSION_MISMATCH; + return -E_OSL_VERSION_MISMATCH; desc->flags = read_u8(buf + IDX_TABLE_FLAGS); desc->num_columns = read_u16(buf + IDX_NUM_COLUMNS); - DEBUG_LOG("%u columns\n", desc->num_columns); + INFO_LOG("%u columns\n", desc->num_columns); if (!desc->num_columns) - return -E_NO_COLUMNS; + return -E_OSL_NO_COLUMNS; header_size = read_u16(buf + IDX_HEADER_SIZE); if (map->size < header_size) - return -E_BAD_SIZE; + return -E_OSL_BAD_SIZE; desc->column_descriptions = calloc(desc->num_columns, sizeof(struct osl_column_description)); if (!desc->column_descriptions) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; offset = IDX_COLUMN_DESCRIPTIONS; FOR_EACH_COLUMN(i, desc, cd) { char *null_byte; - ret = -E_SHORT_TABLE; + ret = -E_OSL_SHORT_TABLE; if (map->size < offset + MIN_IDX_COLUMN_DESCRIPTION_SIZE) { ERROR_LOG("map size = %zu < %u = offset + min desc size\n", map->size, offset + MIN_IDX_COLUMN_DESCRIPTION_SIZE); @@ -523,17 +382,17 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) cd->data_size = read_u32(buf + offset + IDX_CD_DATA_SIZE); null_byte = memchr(buf + offset + IDX_CD_NAME, '\0', map->size - offset - IDX_CD_NAME); - ret = -E_INDEX_CORRUPTION; + ret = -E_OSL_INDEX_CORRUPTION; if (!null_byte) goto err; - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; cd->name = strdup(buf + offset + IDX_CD_NAME); if (!cd->name) goto err; offset += index_column_description_size(cd->name); } if (offset != header_size) { - ret = -E_INDEX_CORRUPTION; + ret = -E_OSL_INDEX_CORRUPTION; ERROR_LOG("real header size = %u != %u = stored header size\n", offset, header_size); goto err; @@ -559,17 +418,17 @@ static int compare_table_descriptions(struct osl_table *t) ret = read_table_desc(&t->index_map, &desc); if (ret < 0) return ret; - ret = -E_BAD_TABLE_FLAGS; + ret = -E_OSL_BAD_TABLE_FLAGS; if (desc.flags != t->desc->flags) goto out; - ret = -E_BAD_COLUMN_NUM; + ret = -E_OSL_BAD_COLUMN_NUM; if (desc.num_columns > t->desc->num_columns) goto out; if (desc.num_columns < t->desc->num_columns) { struct osl_column_description *cd; unsigned diff = t->desc->num_columns - desc.num_columns; INFO_LOG("extending table by %u volatile columns\n", diff); - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; desc.column_descriptions = realloc(desc.column_descriptions, t->desc->num_columns * sizeof(struct osl_column_description)); if (!desc.column_descriptions) @@ -583,26 +442,26 @@ static int compare_table_descriptions(struct osl_table *t) } FOR_EACH_COLUMN(i, t->desc, cd1) { cd2 = get_column_description(&desc, i); - ret = -E_BAD_STORAGE_TYPE; + ret = -E_OSL_BAD_STORAGE_TYPE; if (cd1->storage_type != cd2->storage_type) goto out; if (cd1->storage_type == OSL_NO_STORAGE) continue; - ret = -E_BAD_STORAGE_FLAGS; + ret = -E_OSL_BAD_STORAGE_FLAGS; if (cd1->storage_flags != cd2->storage_flags) { ERROR_LOG("sf1 = %u != %u = sf2\n", cd1->storage_flags, cd2->storage_flags); goto out; } - ret = -E_BAD_DATA_SIZE; + ret = -E_OSL_BAD_DATA_SIZE; if (cd1->storage_flags & OSL_FIXED_SIZE) if (cd1->data_size != cd2->data_size) goto out; - ret = -E_BAD_COLUMN_NAME; + ret = -E_OSL_BAD_COLUMN_NAME; if (strcmp(cd1->name, cd2->name)) goto out; } - DEBUG_LOG("table description of '%s' matches on-disk data, good\n", + INFO_LOG("table description of '%s' matches on-disk data, good\n", t->desc->name); ret = 1; out: @@ -624,8 +483,8 @@ static int create_table_index(struct osl_table *t) t->desc->name); buf = calloc(1, size); if (!buf) - return -ERRNO_TO_ERROR(ENOMEM); - sprintf(buf + IDX_PARA_MAGIC, "%s", PARA_MAGIC); + return -E_OSL_NOMEM; + sprintf(buf + IDX_OSL_MAGIC, "%s", OSL_MAGIC); write_u8(buf + IDX_TABLE_FLAGS, t->desc->flags); write_u8(buf + IDX_DIRTY_FLAG, 0); write_u8(buf + IDX_VERSION, CURRENT_TABLE_VERSION); @@ -651,20 +510,13 @@ static int create_table_index(struct osl_table *t) if (filename) ret = write_file(filename, buf, size); else - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; free(buf); free(filename); return ret; } -/** - * Create a new osl table. - * - * \param desc Pointer to the table description. - * - * \return Standard. - */ -int osl_create_table(const struct osl_table_description *desc) +__export int osl_create_table(const struct osl_table_description *desc) { const struct osl_column_description *cd; char *table_dir = NULL, *filename; @@ -678,25 +530,25 @@ int osl_create_table(const struct osl_table_description *desc) if (cd->storage_type == OSL_NO_STORAGE) continue; if (!table_dir) { - ret = para_mkdir(desc->dir, 0777); - if (ret < 0 && !is_errno(-ret, EEXIST)) + ret = osl_mkdir(desc->dir, 0777); + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) goto out; table_dir = make_message("%s/%s", desc->dir, desc->name); - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; if (!table_dir) goto out; - ret = para_mkdir(table_dir, 0777); + ret = osl_mkdir(table_dir, 0777); if (ret < 0) goto out; } - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; filename = column_filename(t, i); if (!filename) goto out; INFO_LOG("filename: %s\n", filename); if (cd->storage_type == OSL_MAPPED_STORAGE) { - ret = para_open(filename, O_RDWR | O_CREAT | O_EXCL, + ret = osl_open(filename, O_RDWR | O_CREAT | O_EXCL, 0644); free(filename); if (ret < 0) @@ -705,7 +557,7 @@ int osl_create_table(const struct osl_table_description *desc) continue; } /* DISK STORAGE */ - ret = para_mkdir(filename, 0777); + ret = osl_mkdir(filename, 0777); free(filename); if (ret < 0) goto out; @@ -748,7 +600,7 @@ static void unmap_column(struct osl_table *t, unsigned col_num) int ret; if (!map.data) return; - ret = para_munmap(map.data, map.size); + ret = osl_munmap(map.data, map.size); assert(ret > 0); map.data = NULL; } @@ -761,7 +613,7 @@ static void unmap_column(struct osl_table *t, unsigned col_num) * * \return Positive on success, negative on errors. * - * \sa map_table(), enum osl_close_flags, para_munmap(). + * \sa map_table(), enum osl_close_flags, osl_munmap(). */ int unmap_table(struct osl_table *t, enum osl_close_flags flags) { @@ -771,12 +623,12 @@ int unmap_table(struct osl_table *t, enum osl_close_flags flags) if (!t->num_mapped_columns) /* can this ever happen? */ return 1; - DEBUG_LOG("unmapping table '%s'\n", t->desc->name); + INFO_LOG("unmapping table '%s'\n", t->desc->name); if (!t->index_map.data) - return -E_NOT_MAPPED; + return -E_OSL_NOT_MAPPED; if (flags & OSL_MARK_CLEAN) mark_table_clean(t); - ret = para_munmap(t->index_map.data, t->index_map.size); + ret = osl_munmap(t->index_map.data, t->index_map.size); if (ret < 0) return ret; t->index_map.data = NULL; @@ -791,11 +643,12 @@ static int map_column(struct osl_table *t, unsigned col_num) { struct stat statbuf; char *filename = column_filename(t, col_num); - int ret = -E_STAT; + int ret; if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - if (stat(filename, &statbuf) < 0) { + return -E_OSL_NOMEM; + ret = osl_stat(filename, &statbuf); + if (ret < 0) { free(filename); return ret; } @@ -831,11 +684,11 @@ int map_table(struct osl_table *t, enum map_table_flags flags) if (!t->num_mapped_columns) return 0; if (t->index_map.data) - return -E_ALREADY_MAPPED; + return -E_OSL_ALREADY_MAPPED; filename = index_filename(t->desc); if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - DEBUG_LOG("mapping table '%s' (index: %s)\n", t->desc->name, filename); + return -E_OSL_NOMEM; + INFO_LOG("mapping table '%s' (index: %s)\n", t->desc->name, filename); ret = mmap_full_file(filename, flags & MAP_TBL_FL_MAP_RDONLY? O_RDONLY : O_RDWR, &t->index_map.data, &t->index_map.size, NULL); free(filename); @@ -846,7 +699,7 @@ int map_table(struct osl_table *t, enum map_table_flags flags) if (ret < 0) goto err; } - ret = -E_BUSY; + ret = -E_OSL_BUSY; if (!(flags & MAP_TBL_FL_IGNORE_DIRTY)) { if (table_is_dirty(t)) { ERROR_LOG("%s is dirty\n", t->desc->name); @@ -867,10 +720,10 @@ int map_table(struct osl_table *t, enum map_table_flags flags) err: /* unmap what is already mapped */ for (i--; i >= 0; i--) { struct osl_object map = t->columns[i].data_map; - para_munmap(map.data, map.size); + osl_munmap(map.data, map.size); map.data = NULL; } - para_munmap(t->index_map.data, t->index_map.size); + osl_munmap(t->index_map.data, t->index_map.size); t->index_map.data = NULL; return ret; } @@ -886,8 +739,7 @@ err: /* unmap what is already mapped */ * It is considered an error if \a col_num does not refer to a column * of storage type \p OSL_MAPPED_STORAGE. * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_ROW_NUM, \p E_INVALID_OBJECT. + * \return Standard. * * \sa osl_storage_type. */ @@ -896,27 +748,24 @@ int get_mapped_object(const struct osl_table *t, unsigned col_num, { struct osl_column *col = &t->columns[col_num]; uint32_t offset; - char *header; char *cell_index; int ret; if (t->num_rows <= row_num) - return -E_BAD_ROW_NUM; + return -E_OSL_BAD_ROW_NUM; ret = get_cell_index(t, row_num, col_num, &cell_index); if (ret < 0) return ret; offset = read_u32(cell_index); - obj->size = read_u32(cell_index + 4) - 1; - header = col->data_map.data + offset; - obj->data = header + 1; - if (read_u8(header) == 0xff) { - ERROR_LOG("col %u, size %zu, offset %u\n", col_num, - obj->size, offset); - return -E_INVALID_OBJECT; - } + obj->size = read_u32(cell_index + 4); + obj->data = col->data_map.data + offset; return 1; } +/* + * It's OK to call this with result = rb_node = NULL. If result is not NULL, + * and rb key was not found, result points to the parent node. + */ static int search_rbtree(const struct osl_object *obj, const struct osl_table *t, unsigned col_num, struct rb_node **result, struct rb_node ***rb_link) @@ -955,7 +804,7 @@ static int search_rbtree(const struct osl_object *obj, *result = parent; if (rb_link) *rb_link = new; - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; } static int insert_rbtree(struct osl_table *t, unsigned col_num, @@ -967,7 +816,7 @@ static int insert_rbtree(struct osl_table *t, unsigned col_num, int ret = search_rbtree(obj, t, col_num, &parent, &rb_link); if (ret > 0) - return -E_RB_KEY_EXISTS; + return -E_OSL_RB_KEY_EXISTS; rbtree_num = t->columns[col_num].rbtree_num; n = get_rb_node_pointer(row, rbtree_num); rb_link_node(n, parent, rb_link); @@ -1012,7 +861,7 @@ static int add_row_to_rbtrees(struct osl_table *t, uint32_t row_num, const struct osl_column_description *cd; if (!row) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; row->num = row_num; row->volatile_objects = volatile_objs; FOR_EACH_RBTREE_COLUMN(i, t, cd) { @@ -1100,27 +949,13 @@ void clear_rbtrees(struct osl_table *t) } -/** - * Close an osl table. - * - * \param t Pointer to the table to be closed. - * \param flags Options for what should be cleaned up. - * - * If osl_open_table() succeeds, the resulting table pointer must later be - * passed to this function in order to flush all changes to the file system and - * to free the resources that were allocated by osl_open_table(). - * - * \return Positive on success, negative on errors. Possible errors: \p E_BAD_TABLE, - * errors returned by unmap_table(). - * - * \sa osl_open_table(), unmap_table(). - */ -int osl_close_table(struct osl_table *t, enum osl_close_flags flags) +__export int osl_close_table(struct osl_table *t, enum osl_close_flags flags) { int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; + NOTICE_LOG("closing table %s\n", t->desc->name); free_volatile_objects(t, flags); clear_rbtrees(t); ret = unmap_table(t, flags); @@ -1167,7 +1002,7 @@ int row_is_invalid(struct osl_table *t, uint32_t row_num) * This function marks each mapped object in the index entry of \a row as * invalid. * - * \return Positive on success, negative on errors. + * \return Standard. */ int mark_row_invalid(struct osl_table *t, uint32_t row_num) { @@ -1186,7 +1021,7 @@ int mark_row_invalid(struct osl_table *t, uint32_t row_num) * * \param t The table containing the rbtrees to be initialized. * - * \return Positive on success, negative on errors. + * \return Standard. */ int init_rbtrees(struct osl_table *t) { @@ -1213,27 +1048,14 @@ int init_rbtrees(struct osl_table *t) return 1; } -/** - * Open an osl table. - * - * Each osl table must be opened before its data can be accessed. - * - * \param table_desc Describes the table to be opened. - * \param result Contains a pointer to the open table on success. - * - * The table description given by \a desc should coincide with the - * description used at creation time. - * - * \return Standard. - */ -int osl_open_table(const struct osl_table_description *table_desc, +__export int osl_open_table(const struct osl_table_description *table_desc, struct osl_table **result) { int i, ret; struct osl_table *t; const struct osl_column_description *cd; - INFO_LOG("opening table %s\n", table_desc->name); + NOTICE_LOG("opening table %s\n", table_desc->name); ret = init_table_structure(table_desc, &t); if (ret < 0) return ret; @@ -1241,17 +1063,15 @@ int osl_open_table(const struct osl_table_description *table_desc, struct stat statbuf; char *dirname = column_filename(t, i); - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; if (!dirname) goto err; /* check if directory exists */ - ret = stat(dirname, &statbuf); + ret = osl_stat(dirname, &statbuf); free(dirname); - if (ret < 0) { - ret = -ERRNO_TO_ERROR(errno); + if (ret < 0) goto err; - } - ret = -ERRNO_TO_ERROR(ENOTDIR); + ret = -E_OSL_NOTDIR; if (!S_ISDIR(statbuf.st_mode)) goto err; } @@ -1283,10 +1103,10 @@ static int create_disk_storage_object_dir(const struct osl_table *t, return 1; dirname = disk_storage_dirname(t, col_num, ds_name); if (!dirname) - return -ERRNO_TO_ERROR(ENOMEM); - ret = para_mkdir(dirname, 0777); + return -E_OSL_NOMEM; + ret = osl_mkdir(dirname, 0777); free(dirname); - if (ret < 0 && !is_errno(-ret, EEXIST)) + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) return ret; return 1; } @@ -1302,7 +1122,7 @@ static int write_disk_storage_file(const struct osl_table *t, unsigned col_num, return ret; filename = disk_storage_path(t, col_num, ds_name); if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; ret = write_file(filename, obj->data, obj->size); free(filename); return ret; @@ -1313,12 +1133,10 @@ static int append_map_file(const struct osl_table *t, unsigned col_num, { char *filename = column_filename(t, col_num); int ret; - char header = 0; /* zero means valid object */ if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - ret = append_file(filename, &header, 1, obj->data, obj->size, - new_size); + return -E_OSL_NOMEM; + ret = append_file(filename, obj->data, obj->size, new_size); free(filename); return ret; } @@ -1332,45 +1150,12 @@ static int append_row_index(const struct osl_table *t, char *row_index) return 1; filename = index_filename(t->desc); if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - ret = append_file(filename, NULL, 0, row_index, - t->row_index_size, NULL); + return -E_OSL_NOMEM; + ret = append_file(filename, row_index, t->row_index_size, NULL); free(filename); return ret; } -/** - * 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 Positive on success, negative on errors. Possible errors include: \p - * E_STAT, \p E_BAD_SIZE, \p E_TRUNC. - * - * \sa truncate(2) - */ -int para_truncate(const char *path, off_t size) -{ - int ret; - struct stat statbuf; - - ret = -E_STAT; - if (stat(path, &statbuf) < 0) - goto out; - ret = -E_BAD_SIZE; - if (statbuf.st_size < size) - goto out; - ret = -E_TRUNC; - if (truncate(path, statbuf.st_size - size) < 0) - goto out; - ret = 1; -out: - return ret; -} - static int truncate_mapped_file(const struct osl_table *t, unsigned col_num, off_t size) { @@ -1378,8 +1163,8 @@ static int truncate_mapped_file(const struct osl_table *t, unsigned col_num, char *filename = column_filename(t, col_num); if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - ret = para_truncate(filename, size); + return -E_OSL_NOMEM; + ret = truncate_file(filename, size); free(filename); return ret; } @@ -1388,51 +1173,26 @@ static int delete_disk_storage_file(const struct osl_table *t, unsigned col_num, const char *ds_name) { char *dirname, *filename = disk_storage_path(t, col_num, ds_name); - int ret, err; + int ret = 1; if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); - ret = unlink(filename); - err = errno; + return -E_OSL_NOMEM; + if (unlink(filename) < 0) + ret = errno == ENOENT? -E_OSL_NOENT : -E_OSL_UNLINK; free(filename); if (ret < 0) - return -ERRNO_TO_ERROR(err); + return ret; if (!(t->desc->flags & OSL_LARGE_TABLE)) return 1; dirname = disk_storage_dirname(t, col_num, ds_name); if (!dirname) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; rmdir(dirname); free(dirname); return 1; } -/** - * Add a new row to an osl table and retrieve this row. - * - * \param t Pointer to an open osl table. - * \param objects Array of objects to be added. - * \param row Result pointer. - * - * The \a objects parameter must point to an array containing one object per - * column. The order of the objects in the array is given by the table - * description of \a table. Several sanity checks are performed during object - * insertion and the function returns without modifying the table if any of - * these tests fail. In fact, it is atomic in the sense that it either - * succeeds or leaves the table unchanged (i.e. either all or none of the - * objects are added to the table). - * - * It is considered an error if an object is added to a column with associated - * rbtree if this object is equal to an object already contained in that column - * (i.e. the compare function for the column's rbtree returns zero). - * - * Possible errors include: \p E_RB_KEY_EXISTS, \p E_BAD_DATA_SIZE. - * - * \return Positive on success, negative on errors. - * - * \sa struct osl_table_description, osl_compare_func, osl_add_row(). - */ -int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, +__export int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, struct osl_row **row) { int i, ret; @@ -1443,21 +1203,21 @@ int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; rb_parents = malloc(t->num_rbtrees * sizeof(struct rn_node*)); if (!rb_parents) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; rb_links = malloc(t->num_rbtrees * sizeof(struct rn_node**)); if (!rb_links) { free(rb_parents); - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; } if (t->num_mapped_columns) { new_row_index = malloc(t->row_index_size); if (!new_row_index) { free(rb_links); free(rb_parents); - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; } } /* pass 1: sanity checks */ @@ -1467,14 +1227,14 @@ int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, enum osl_storage_type st = cd->storage_type; enum osl_storage_flags sf = cd->storage_flags; -// ret = -E_NULL_OBJECT; +// ret = -E_OSL_NULL_OBJECT; // if (!objects[i]) // goto out; if (st == OSL_DISK_STORAGE) continue; if (sf & OSL_RBTREE) { unsigned rbtree_num = t->columns[i].rbtree_num; - ret = -E_RB_KEY_EXISTS; + ret = -E_OSL_RB_KEY_EXISTS; // DEBUG_LOG("checking whether %p exists\n", // objects[i].data); if (search_rbtree(objects + i, t, i, @@ -1485,7 +1245,7 @@ int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, if (sf & OSL_FIXED_SIZE) { // DEBUG_LOG("fixed size. need: %zu, have: %d\n", // objects[i].size, cd->data_size); - ret = -E_BAD_DATA_SIZE; + ret = -E_OSL_BAD_DATA_SIZE; if (objects[i].size != cd->data_size) goto out; } @@ -1493,7 +1253,7 @@ int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, if (t->num_disk_storage_columns) { ds_name = disk_storage_name_of_object(t, &objects[t->disk_storage_name_column]); - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; if (!ds_name) goto out; } @@ -1530,13 +1290,13 @@ int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, if (ret < 0) { /* truncate index and rollback changes */ char *filename = index_filename(t->desc); if (filename) - para_truncate(filename, t->row_index_size); + truncate_file(filename, t->row_index_size); free(filename); goto rollback; } /* pass 3: add entry to rbtrees */ if (t->num_volatile_columns) { - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; volatile_objs = calloc(t->num_volatile_columns, sizeof(struct osl_object)); if (!volatile_objs) @@ -1574,49 +1334,22 @@ out: return ret; } -/** - * Add a new row to an osl table. - * - * \param t Same meaning as osl_add_and_get_row(). - * \param objects Same meaning as osl_add_and_get_row(). - * - * \return The return value of the underlying call to osl_add_and_get_row(). - * - * This is equivalent to osl_add_and_get_row(t, objects, NULL). - */ -int osl_add_row(struct osl_table *t, struct osl_object *objects) +__export int osl_add_row(struct osl_table *t, struct osl_object *objects) { return osl_add_and_get_row(t, objects, NULL); } -/** - * Retrieve an object identified by row and column - * - * \param t Pointer to an open osl table. - * \param r Pointer to the row. - * \param col_num The column number. - * \param object The result pointer. - * - * The column determined by \a col_num must be of type \p OSL_MAPPED_STORAGE - * or \p OSL_NO_STORAGE, i.e. no disk storage objects may be retrieved by this - * function. - * - * \return Positive if object was found, negative on errors. Possible errors - * include: \p E_BAD_TABLE, \p E_BAD_STORAGE_TYPE. - * - * \sa osl_storage_type, osl_open_disk_object(). - */ -int osl_get_object(const struct osl_table *t, const struct osl_row *r, +__export int osl_get_object(const struct osl_table *t, const struct osl_row *r, unsigned col_num, struct osl_object *object) { const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; cd = get_column_description(t->desc, col_num); /* col must not be disk storage */ if (cd->storage_type == OSL_DISK_STORAGE) - return -E_BAD_STORAGE_TYPE; + return -E_OSL_BAD_STORAGE_TYPE; if (cd->storage_type == OSL_MAPPED_STORAGE) return get_mapped_object(t, col_num, r->num, object); /* volatile */ @@ -1624,43 +1357,14 @@ int osl_get_object(const struct osl_table *t, const struct osl_row *r, return 1; } -static int mark_mapped_object_invalid(const struct osl_table *t, - uint32_t row_num, unsigned col_num) -{ - struct osl_object obj; - char *p; - int ret = get_mapped_object(t, col_num, row_num, &obj); - - if (ret < 0) - return ret; - p = obj.data; - p--; - *p = 0xff; - return 1; -} - -/** - * Delete a row from an osl table. - * - * \param t Pointer to an open osl table. - * \param row Pointer to the row to delete. - * - * This removes all disk storage objects, removes all rbtree nodes, and frees - * all volatile objects belonging to the given row. For mapped columns, the - * data is merely marked invalid and may be pruned from time to time by - * para_fsck. - * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_TABLE, errors returned by osl_get_object(). - */ -int osl_del_row(struct osl_table *t, struct osl_row *row) +__export int osl_del_row(struct osl_table *t, struct osl_row *row) { struct osl_row *r = row; int i, ret; const struct osl_column_description *cd; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; INFO_LOG("deleting row %p\n", row); if (t->num_disk_storage_columns) { @@ -1676,10 +1380,8 @@ int osl_del_row(struct osl_table *t, struct osl_row *row) struct osl_column *col = t->columns + i; enum osl_storage_type st = cd->storage_type; remove_rb_node(t, i, r); - if (st == OSL_MAPPED_STORAGE) { - mark_mapped_object_invalid(t, r->num, i); + if (st == OSL_MAPPED_STORAGE) continue; - } if (st == OSL_NO_STORAGE && !(cd->storage_flags & OSL_DONT_FREE)) free(r->volatile_objects[col->volatile_num].data); } @@ -1702,32 +1404,14 @@ static int check_rbtree_col(const struct osl_table *t, unsigned col_num, struct osl_column **col) { if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; if (!(get_column_description(t->desc, col_num)->storage_flags & OSL_RBTREE)) - return -E_BAD_STORAGE_FLAGS; + return -E_OSL_BAD_STORAGE_FLAGS; *col = t->columns + col_num; return 1; } -/** - * Get the row that contains the given object. - * - * \param t Pointer to an open osl table. - * \param col_num The number of the column to be searched. - * \param obj The object to be looked up. - * \param result Points to the row containing \a obj. - * - * Lookup \a obj in \a t and return the row containing \a obj. The column - * specified by \a col_num must have an associated rbtree. - * - * \return Positive on success, negative on errors. If an error occurred, \a - * result is set to \p NULL. Possible errors include: \p E_BAD_TABLE, \p - * E_BAD_STORAGE_FLAGS, errors returned by get_mapped_object(), \p - * E_RB_KEY_NOT_FOUND. - * - * \sa osl_storage_flags - */ -int osl_get_row(const struct osl_table *t, unsigned col_num, +__export int osl_get_row(const struct osl_table *t, unsigned col_num, const struct osl_object *obj, struct osl_row **result) { int ret; @@ -1747,7 +1431,7 @@ int osl_get_row(const struct osl_table *t, unsigned col_num, return 1; } -static int rbtree_loop(struct osl_column *col, void *private_data, +static int rbtree_loop(struct osl_column *col, void *private_data, osl_rbtree_loop_func *func) { struct rb_node *n, *tmp; @@ -1757,14 +1441,13 @@ static int rbtree_loop(struct osl_column *col, void *private_data, n; n = tmp, tmp = tmp? rb_next(tmp) : NULL) { struct osl_row *r = get_row_pointer(n, col->rbtree_num); - int ret = func(r, private_data); - if (ret < 0) - return ret; + if (func(r, private_data) < 0) + return -E_OSL_LOOP; } return 1; } -static int rbtree_loop_reverse(struct osl_column *col, void *private_data, +static int rbtree_loop_reverse(struct osl_column *col, void *private_data, osl_rbtree_loop_func *func) { struct rb_node *n, *tmp; @@ -1774,38 +1457,13 @@ static int rbtree_loop_reverse(struct osl_column *col, void *private_data, n; n = tmp, tmp = tmp? rb_prev(tmp) : NULL) { struct osl_row *r = get_row_pointer(n, col->rbtree_num); - int ret = func(r, private_data); - if (ret < 0) - return ret; + if (func(r, private_data) < 0) + return -E_OSL_LOOP; } return 1; } -/** - * Loop over all nodes in an rbtree. - * - * \param t Pointer to an open osl table. - * \param col_num The column to use for iterating over the elements. - * \param private_data Pointer that gets passed to \a func. - * \param func The function to be called for each node in the rbtree. - * - * This function does an in-order walk of the rbtree associated with \a - * col_num. It is an error if the \p OSL_RBTREE flag is not set for this - * column. For each node in the rbtree, the given function \a func is called - * with two pointers as arguments: The first osl_row* argument points to the - * row that contains the object corresponding to the rbtree node currently - * traversed, and the \a private_data pointer is passed verbatim to \a func as the - * second argument. The loop terminates either if \a func returns a negative - * value, or if all nodes of the tree have been visited. - * - * - * \return Positive on success, negative on errors. If the termination of the - * loop was caused by \a func returning a negative value, this value is - * returned. - * - * \sa osl_storage_flags, osl_rbtree_loop_reverse(), osl_compare_func. - */ -int osl_rbtree_loop(const struct osl_table *t, unsigned col_num, +__export int osl_rbtree_loop(const struct osl_table *t, unsigned col_num, void *private_data, osl_rbtree_loop_func *func) { struct osl_column *col; @@ -1816,22 +1474,7 @@ int osl_rbtree_loop(const struct osl_table *t, unsigned col_num, return rbtree_loop(col, private_data, func); } -/** - * Loop over all nodes in an rbtree in reverse order. - * - * \param t Identical meaning as in \p osl_rbtree_loop(). - * \param col_num Identical meaning as in \p osl_rbtree_loop(). - * \param private_data Identical meaning as in \p osl_rbtree_loop(). - * \param func Identical meaning as in \p osl_rbtree_loop(). - * - * This function is identical to \p osl_rbtree_loop(), the only difference - * is that the tree is walked in reverse order. - * - * \return The same return value as \p osl_rbtree_loop(). - * - * \sa osl_rbtree_loop(). - */ -int osl_rbtree_loop_reverse(const struct osl_table *t, unsigned col_num, +__export int osl_rbtree_loop_reverse(const struct osl_table *t, unsigned col_num, void *private_data, osl_rbtree_loop_func *func) { struct osl_column *col; @@ -1857,7 +1500,7 @@ static int rename_disk_storage_objects(struct osl_table *t, return 1; /* object did not change */ old_ds_name = disk_storage_name_of_object(t, old_obj); new_ds_name = disk_storage_name_of_object(t, new_obj); - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; if (!old_ds_name || ! new_ds_name) goto out; @@ -1869,9 +1512,9 @@ static int rename_disk_storage_objects(struct osl_table *t, old_filename = disk_storage_path(t, i, old_ds_name); new_filename = disk_storage_path(t, i, new_ds_name); if (!old_filename || !new_filename) - ret = -ERRNO_TO_ERROR(ENOMEM); + ret = -E_OSL_NOMEM; else - ret = para_rename(old_filename, new_filename); + ret = osl_rename(old_filename, new_filename); free(old_filename); free(new_filename); if (ret < 0) @@ -1885,26 +1528,7 @@ out: } -/** - * Change an object in an osl table. - * - * \param t Pointer to an open osl table. - * \param r Pointer to the row containing the object to be updated. - * \param col_num Number of the column containing the object to be updated. - * \param obj Pointer to the replacement object. - * - * This function gets rid of all references to the old object. This includes - * removal of the rbtree node in case there is an rbtree associated with \a - * col_num. It then inserts \a obj into the table and the rbtree if necessary. - * - * If the \p OSL_RBTREE flag is set for \a col_num, you \b MUST call this - * function in order to change the contents of an object, even for volatile or - * mapped columns of constant size (which may be updated directly if \p - * OSL_RBTREE is not set). Otherwise the rbtree might become corrupted. - * - * \return Standard - */ -int osl_update_object(struct osl_table *t, const struct osl_row *r, +__export int osl_update_object(struct osl_table *t, const struct osl_row *r, unsigned col_num, struct osl_object *obj) { struct osl_column *col; @@ -1912,17 +1536,17 @@ int osl_update_object(struct osl_table *t, const struct osl_row *r, int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; col = &t->columns[col_num]; cd = get_column_description(t->desc, col_num); DEBUG_LOG("updating column %u of %s\n", col_num, t->desc->name); if (cd->storage_flags & OSL_RBTREE) { if (search_rbtree(obj, t, col_num, NULL, NULL) > 0) - return -E_RB_KEY_EXISTS; + return -E_OSL_RB_KEY_EXISTS; } if (cd->storage_flags & OSL_FIXED_SIZE) { if (obj->size != cd->data_size) - return -E_BAD_DATA_SIZE; + return -E_OSL_BAD_DATA_SIZE; } remove_rb_node(t, col_num, r); if (cd->storage_type == OSL_NO_STORAGE) { /* TODO: If fixed size, reuse object? */ @@ -1934,7 +1558,7 @@ int osl_update_object(struct osl_table *t, const struct osl_row *r, if (ret < 0) return ret; ret = delete_disk_storage_file(t, col_num, ds_name); - if (ret < 0 && !is_errno(-ret, ENOENT)) { + if (ret < 0 && ret != -E_OSL_NOENT) { free(ds_name); return ret; } @@ -1963,9 +1587,6 @@ int osl_update_object(struct osl_table *t, const struct osl_row *r, uint32_t new_data_map_size; char *row_index; ret = get_row_index(t, r->num, &row_index); - if (ret < 0) - return ret; - ret = mark_mapped_object_invalid(t, r->num, col_num); if (ret < 0) return ret; unmap_column(t, col_num); @@ -1988,24 +1609,7 @@ int osl_update_object(struct osl_table *t, const struct osl_row *r, return 1; } -/** - * Retrieve an object of type \p OSL_DISK_STORAGE by row and column. - * - * \param t Pointer to an open osl table. - * \param r Pointer to the row containing the object. - * \param col_num The column number. - * \param obj Points to the result upon successful return. - * - * For columns of type \p OSL_DISK_STORAGE, this function must be used to - * retrieve one of its containing objects. Afterwards, osl_close_disk_object() - * must be called in order to deallocate the resources. - * - * \return Positive on success, negative on errors. Possible errors include: - * \p E_BAD_TABLE, \p E_BAD_STORAGE_TYPE, errors returned by osl_get_object(). - * - * \sa osl_get_object(), osl_storage_type, osl_close_disk_object(). - */ -int osl_open_disk_object(const struct osl_table *t, const struct osl_row *r, +__export int osl_open_disk_object(const struct osl_table *t, const struct osl_row *r, unsigned col_num, struct osl_object *obj) { const struct osl_column_description *cd; @@ -2013,10 +1617,10 @@ int osl_open_disk_object(const struct osl_table *t, const struct osl_row *r, int ret; if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; cd = get_column_description(t->desc, col_num); if (cd->storage_type != OSL_DISK_STORAGE) - return -E_BAD_STORAGE_TYPE; + return -E_OSL_BAD_STORAGE_TYPE; ret = disk_storage_name_of_row(t, r, &ds_name); if (ret < 0) @@ -2024,63 +1628,28 @@ int osl_open_disk_object(const struct osl_table *t, const struct osl_row *r, filename = disk_storage_path(t, col_num, ds_name); free(ds_name); if (!filename) - return -ERRNO_TO_ERROR(ENOMEM); + return -E_OSL_NOMEM; DEBUG_LOG("filename: %s\n", filename); ret = mmap_full_file(filename, O_RDONLY, &obj->data, &obj->size, NULL); free(filename); return ret; } -/** - * Free resources that were allocated during osl_open_disk_object(). - * - * \param obj Pointer to the object previously returned by open_disk_object(). - * - * \return The return value of the underlying call to para_munmap(). - * - * \sa para_munmap(). - */ -int osl_close_disk_object(struct osl_object *obj) +__export int osl_close_disk_object(struct osl_object *obj) { - return para_munmap(obj->data, obj->size); + return osl_munmap(obj->data, obj->size); } -/** - * Get the number of rows of the given table. - * - * \param t Pointer to an open osl table. - * \param num_rows Result is returned here. - * - * The number of rows returned via \a num_rows excluding any invalid rows. - * - * \return Positive on success, \p -E_BAD_TABLE if \a t is \p NULL. - */ -int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows) +__export int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows) { if (!t) - return -E_BAD_TABLE; + return -E_OSL_BAD_TABLE; assert(t->num_rows >= t->num_invalid_rows); *num_rows = t->num_rows - t->num_invalid_rows; return 1; } -/** - * Get the rank of a row. - * - * \param t An open osl table. - * \param r The row to get the rank of. - * \param col_num The number of an rbtree column. - * \param rank Result pointer. - * - * The rank is, by definition, the position of the row in the linear order - * determined by an in-order tree walk of the rbtree associated with column - * number \a col_num of \a table. - * - * \return Positive on success, negative on errors. - * - * \sa osl_get_nth_row(). - */ -int osl_get_rank(const struct osl_table *t, struct osl_row *r, +__export int osl_get_rank(const struct osl_table *t, struct osl_row *r, unsigned col_num, unsigned *rank) { struct osl_object obj; @@ -2098,31 +1667,11 @@ int osl_get_rank(const struct osl_table *t, struct osl_row *r, return ret; ret = rb_rank(node, rank); if (ret < 0) - return -E_BAD_ROW; + return -E_OSL_BAD_ROW; return 1; } -/** - * Get the row with n-th greatest value. - * - * \param t Pointer to an open osl table. - * \param col_num The column number. - * \param n The rank of the desired row. - * \param result Row is returned here. - * - * Retrieve the n-th order statistic with respect to the compare function - * of the rbtree column \a col_num. In other words, get that row with - * \a n th greatest value in column \a col_num. It's an error if - * \a col_num is not a rbtree column, or if \a n is larger than the - * number of rows in the table. - * - * \return Positive on success, negative on errors. Possible errors: - * \p E_BAD_TABLE, \p E_BAD_STORAGE_FLAGS, \p E_RB_KEY_NOT_FOUND. - * - * \sa osl_storage_flags, osl_compare_func, osl_get_row(), - * osl_rbtree_last_row(), osl_rbtree_first_row(), osl_get_rank(). - */ -int osl_get_nth_row(const struct osl_table *t, unsigned col_num, +__export int osl_get_nth_row(const struct osl_table *t, unsigned col_num, unsigned n, struct osl_row **result) { struct osl_column *col; @@ -2131,60 +1680,29 @@ int osl_get_nth_row(const struct osl_table *t, unsigned col_num, int ret; if (n == 0) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; ret = osl_get_num_rows(t, &num_rows); if (ret < 0) return ret; if (n > num_rows) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; ret = check_rbtree_col(t, col_num, &col); if (ret < 0) return ret; node = rb_nth(col->rbtree.rb_node, n); if (!node) - return -E_RB_KEY_NOT_FOUND; + return -E_OSL_RB_KEY_NOT_FOUND; *result = get_row_pointer(node, col->rbtree_num); return 1; } -/** - * Get the row corresponding to the smallest rbtree node of a column. - * - * \param t An open rbtree table. - * \param col_num The number of the rbtree column. - * \param result A pointer to the first row is returned here. - * - * The rbtree node of the smallest object (with respect to the corresponding - * compare function) is selected and the row containing this object is - * returned. It is an error if \a col_num refers to a column without an - * associated rbtree. - * - * \return Positive on success, negative on errors. - * - * \sa osl_get_nth_row(), osl_rbtree_last_row(). - */ -int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, +__export int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, struct osl_row **result) { return osl_get_nth_row(t, col_num, 1, result); } -/** - * Get the row corresponding to the greatest rbtree node of a column. - * - * \param t The same meaning as in \p osl_rbtree_first_row(). - * \param col_num The same meaning as in \p osl_rbtree_first_row(). - * \param result The same meaning as in \p osl_rbtree_first_row(). - * - * This function works just like osl_rbtree_first_row(), the only difference - * is that the row containing the greatest rather than the smallest object is - * returned. - * - * \return Positive on success, negative on errors. - * - * \sa osl_get_nth_row(), osl_rbtree_first_row(). - */ -int osl_rbtree_last_row(const struct osl_table *t, unsigned col_num, +__export int osl_rbtree_last_row(const struct osl_table *t, unsigned col_num, struct osl_row **result) { unsigned num_rows;