From: Andre Noll Date: Sat, 31 May 2008 06:32:50 +0000 (+0200) Subject: Generate osl.h from osl.h.in. X-Git-Tag: v0.1.0~99 X-Git-Url: http://git.tue.mpg.de/?a=commitdiff_plain;h=026cd39b227af84bf84f52c40d1910dcd265b93e;p=osl.git Generate osl.h from osl.h.in. We need to export the osl error codes to the applications that link against osl. Prefix these error codes with OSL. --- diff --git a/Makefile b/Makefile index 70b83c7..4e8b48e 100644 --- a/Makefile +++ b/Makefile @@ -57,5 +57,15 @@ Makefile.deps: $(wildcard *.c *.h) $(dso_filename): $(objects) $(CC) $(dso_opts) -o $@ $(objects) -lcrypto +osl_errors.h: errlist + sed -e 's/\([A-Z_]*\) .*/ E_OSL_\1/' \ + -e '1s/^/enum osl_errors {\n/1' \ + -e '$$!s/$$/,/g' \ + -e '$$s/$$/\n};/1' $< > $@ + +errtab.h: errlist + sed -e 's/^\([A-Z_]*\)\s*\(.*\)/_S(E_OSL_\1, \2)/g' $< > $@ +osl.h: osl.h.in osl_errors.h + cat $^ > $@ clean: - rm -f *.o $(dso_filename) + rm -f *.o $(dso_filename) osl.h osl_errors.h errtab.h diff --git a/osl.c b/osl.c index 3ec2f54..957e9a7 100644 --- a/osl.c +++ b/osl.c @@ -100,14 +100,14 @@ __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; @@ -124,7 +124,7 @@ static int __lseek(int fd, off_t *offset, int whence) * occurred during the write. * * \return On success, the number of bytes written is returned, otherwise, the - * function returns \p -E_WRITE. + * function returns \p -E_OSL_WRITE. * * \sa write(2). */ @@ -136,7 +136,7 @@ static ssize_t __write(int fd, const void *buf, size_t size) ret = write(fd, buf, size); if ((ret < 0) && (errno == EAGAIN || errno == EINTR)) continue; - return ret >= 0? ret : -E_WRITE; + return ret >= 0? ret : -E_OSL_WRITE; } } @@ -230,15 +230,15 @@ 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; } @@ -325,11 +325,11 @@ 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 = -E_OSL_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 */ @@ -338,11 +338,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); @@ -350,7 +350,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; @@ -373,10 +373,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. */ @@ -389,15 +386,15 @@ int init_table_structure(const struct osl_table_description *desc, 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); @@ -410,14 +407,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) { @@ -444,10 +441,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,7 +469,7 @@ err: * 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. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa struct osl_table_description, osl_create_table. */ @@ -486,20 +483,20 @@ 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; + return -E_OSL_SHORT_TABLE; if (strncmp(buf + IDX_PARA_MAGIC, PARA_MAGIC, strlen(PARA_MAGIC))) - return -E_NO_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); 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) @@ -508,7 +505,7 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) 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); @@ -520,7 +517,7 @@ 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); @@ -530,7 +527,7 @@ int read_table_desc(struct osl_object *map, struct osl_table_description *desc) 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; @@ -556,10 +553,10 @@ 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) { @@ -580,22 +577,22 @@ 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; } @@ -770,7 +767,7 @@ int unmap_table(struct osl_table *t, enum osl_close_flags flags) return 1; DEBUG_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); @@ -788,7 +785,7 @@ 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 = -E_OSL_STAT; if (!filename) return -ERRNO_TO_ERROR(ENOMEM); @@ -828,7 +825,7 @@ 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); @@ -843,7 +840,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); @@ -883,8 +880,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. */ @@ -898,7 +894,7 @@ int get_mapped_object(const struct osl_table *t, unsigned col_num, 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; @@ -909,7 +905,7 @@ int get_mapped_object(const struct osl_table *t, unsigned col_num, if (read_u8(header) == 0xff) { ERROR_LOG("col %u, size %zu, offset %u\n", col_num, obj->size, offset); - return -E_INVALID_OBJECT; + return -E_OSL_INVALID_OBJECT; } return 1; } @@ -952,7 +948,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, @@ -964,7 +960,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); @@ -1107,8 +1103,7 @@ void clear_rbtrees(struct osl_table *t) * 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(). + * \return Standard. * * \sa osl_open_table(), unmap_table(). */ @@ -1117,7 +1112,7 @@ __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; free_volatile_objects(t, flags); clear_rbtrees(t); ret = unmap_table(t, flags); @@ -1164,7 +1159,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) { @@ -1183,7 +1178,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) { @@ -1344,8 +1339,7 @@ static int append_row_index(const struct osl_table *t, char *row_index) * * 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. + * \return Standard. * * \sa truncate(2) */ @@ -1354,13 +1348,13 @@ int para_truncate(const char *path, off_t size) int ret; struct stat statbuf; - ret = -E_STAT; + ret = -E_OSL_STAT; if (stat(path, &statbuf) < 0) goto out; - ret = -E_BAD_SIZE; + ret = -E_OSL_BAD_SIZE; if (statbuf.st_size < size) goto out; - ret = -E_TRUNC; + ret = -E_OSL_TRUNC; if (truncate(path, statbuf.st_size - size) < 0) goto out; ret = 1; @@ -1423,9 +1417,7 @@ static int delete_disk_storage_file(const struct osl_table *t, unsigned col_num, * 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. + * \return Standard. * * \sa struct osl_table_description, osl_compare_func, osl_add_row(). */ @@ -1440,7 +1432,7 @@ __export 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); @@ -1464,14 +1456,14 @@ __export 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, @@ -1482,7 +1474,7 @@ __export 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; } @@ -1598,8 +1590,7 @@ __export int osl_add_row(struct osl_table *t, struct osl_object *objects) * 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. + * \return Standard. * * \sa osl_storage_type, osl_open_disk_object(). */ @@ -1609,11 +1600,11 @@ __export int osl_get_object(const struct osl_table *t, const struct osl_row *r, 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 */ @@ -1647,8 +1638,7 @@ static int mark_mapped_object_invalid(const struct osl_table *t, * 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(). + * \return Standard. */ __export int osl_del_row(struct osl_table *t, struct osl_row *row) { @@ -1657,7 +1647,7 @@ __export int osl_del_row(struct osl_table *t, struct osl_row *row) 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) { @@ -1699,9 +1689,9 @@ 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; } @@ -1717,10 +1707,7 @@ static int check_rbtree_col(const struct osl_table *t, unsigned col_num, * 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. + * \return Standard. * * \sa osl_storage_flags */ @@ -1796,9 +1783,8 @@ static int rbtree_loop_reverse(struct osl_column *col, void *private_data, * 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. + * \return Standard. 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. */ @@ -1909,17 +1895,17 @@ __export 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? */ @@ -1997,8 +1983,7 @@ __export int osl_update_object(struct osl_table *t, const struct osl_row *r, * 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(). + * \return Standard. * * \sa osl_get_object(), osl_storage_type, osl_close_disk_object(). */ @@ -2010,10 +1995,10 @@ __export int osl_open_disk_object(const struct osl_table *t, const struct osl_ro 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) @@ -2050,12 +2035,12 @@ __export int osl_close_disk_object(struct osl_object *obj) * * 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. + * \return Positive on success, \p -E_OSL_BAD_TABLE if \a t is \p NULL. */ __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; @@ -2073,7 +2058,7 @@ __export int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows) * 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. + * \return Standard. * * \sa osl_get_nth_row(). */ @@ -2095,7 +2080,7 @@ __export 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; } @@ -2113,8 +2098,7 @@ __export int osl_get_rank(const struct osl_table *t, struct osl_row *r, * \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. + * \return Standard. * * \sa osl_storage_flags, osl_compare_func, osl_get_row(), * osl_rbtree_last_row(), osl_rbtree_first_row(), osl_get_rank(). @@ -2128,18 +2112,18 @@ __export 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; } @@ -2156,7 +2140,7 @@ __export int osl_get_nth_row(const struct osl_table *t, unsigned col_num, * returned. It is an error if \a col_num refers to a column without an * associated rbtree. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_get_nth_row(), osl_rbtree_last_row(). */ @@ -2177,7 +2161,7 @@ __export int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, * is that the row containing the greatest rather than the smallest object is * returned. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_get_nth_row(), osl_rbtree_first_row(). */ diff --git a/osl.h b/osl.h deleted file mode 100644 index 8c386c7..0000000 --- a/osl.h +++ /dev/null @@ -1,180 +0,0 @@ -#include -/* - * Copyright (C) 2007-2008 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ - -/** \file osl.h User interface for the object storage layer. */ - -/** describes an object of the object storage layer (osl) */ -struct osl_object { - /** Pointer to the data of the object. */ - void *data; - /** The object's size. */ - size_t size; -}; - -/** Flags that change the internal handling of osl tables. */ -enum osl_table_flags { - /** This table will have many rows. */ - OSL_LARGE_TABLE = 1 -}; - -/** The three different types of storage for an osl column */ -enum osl_storage_type { - /** - * All data for this column is stored in one file which gets mmapped by - * osl_open_table(). This is suitable for columns that do not hold much - * data. - */ - OSL_MAPPED_STORAGE, - /** - * Each entry is stored on disk and is loaded on demand by - * open_disk_object(). This is the preferable storage type for large - * objects that need not be in memory all the time. - */ - OSL_DISK_STORAGE, - /** - * Objects for columns of this type are volatile: They are only stored - * in memory and are discarded once the table gets closed. - */ - OSL_NO_STORAGE -}; - -/** - * Additional per-column flags - */ -enum osl_storage_flags { - /** - * Build an rbtree for this column. This is only possible if the - * storage type of the column is either \a OSL_MAPPED_STORAGE or \a - * OSL_NO_STORAGE. In order to lookup objects in the table by using \a - * osl_get_row(), the lookup column must have an associated rbtree. - * - * \sa osl_storage_type, osl_get_row() - */ - OSL_RBTREE = 1, - /** The data for this column will have constant size. */ - OSL_FIXED_SIZE = 2, - /** All values of this column will be different. */ - OSL_UNIQUE = 4, - /** Do not free the data for this column (\p OSL_NO_STORAGE). */ - OSL_DONT_FREE = 8 -}; - -struct osl_table; -struct osl_row; - -/** - * In order to build up an rbtree a compare function for the objects must be - * specified. Such a function always takes pointers to the two objects to be - * compared. It must return -1, zero, or 1, if the first argument is considered - * to be respectively less than, equal to, or greater than the second. If two - * members compare as equal, their order in the sorted array is undefined. - */ -typedef int osl_compare_func(const struct osl_object *obj1, - const struct osl_object *obj2); -typedef int osl_rbtree_loop_func(struct osl_row *row, void *data); - -osl_compare_func osl_hash_compare, uint32_compare; - -/** - * Describes one column of a osl table. - */ -struct osl_column_description { - /** One of zje tree possible types of storage */ - enum osl_storage_type storage_type; - /** Specifies further properties of the column */ - enum osl_storage_flags storage_flags; - /** - * The column name determines the name of the directory where all data - * for this column will be stored. Its hash is stored in the table - * header. This field is ignored if the storage type is \a NO_STORAGE - */ - char *name; - /** - * For columns with an associated rbtree, this must point to a function - * that compares the values of two objects, either a built-in function - * or a function defined by the application may be supplied. This - * field is ignored if the column does not have an associated rbtree. - * - * \sa osl_storage_flags, osl_compare_func - */ - osl_compare_func *compare_function; - /** - * If the \a OSL_FIXED_SIZE flag is set for this column, this value - * determines the fixed size of all objects of this column. It is - * ignored, if \a OSL_FIXED_SIZE is not set. - */ - uint32_t data_size; -}; - -/** - * Describes one osl table. - */ -struct osl_table_description { - /** The directory which contains all files of this table. */ - const char *dir; - /** - * The table name. A subdirectory of \a dir called \a name is created - * at table creation time. It must be a valid name for a subdirectory. - * In particular, no slashes are allowed for \a name. - */ - const char *name; - /** The number of columns of this table. */ - uint16_t num_columns; - /** Further table-wide information. */ - enum osl_table_flags flags; - /** The array describing the individual columns of the table. */ - struct osl_column_description *column_descriptions; -}; - -/** Flags to be passed to \a osl_close_table(). */ -enum osl_close_flags { - /** - * The table header contains a "dirty" flag which specifies whether - * the table is currently open by another process. This flag specifies - * that the dirty flag should be cleared before closing the table. - */ - OSL_MARK_CLEAN = 1, - /** - * If the table contains columns of type \a OSL_NO_STORAGE and this - * flag is passed to osl_close_table(), free(3) is called for each - * object of each column of type \a OSL_NO_STORAGE. - */ - OSL_FREE_VOLATILE = 2 -}; - - - -int osl_create_table(const struct osl_table_description *desc); -int osl_open_table(const struct osl_table_description *desc, - struct osl_table **result); -int osl_close_table(struct osl_table *t, enum osl_close_flags flags); -int osl_get_row(const struct osl_table *t, unsigned col_num, - const struct osl_object *obj, struct osl_row **result); -int osl_get_object(const struct osl_table *t, const struct osl_row *row, - unsigned col_num, struct osl_object *object); -int osl_open_disk_object(const struct osl_table *t, - const struct osl_row *r, unsigned col_num, struct osl_object *obj); -int osl_close_disk_object(struct osl_object *obj); -int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, - struct osl_row **row); -int osl_add_row(struct osl_table *t, struct osl_object *objects); -int osl_del_row(struct osl_table *t, struct osl_row *row); -int osl_rbtree_loop(const struct osl_table *t, unsigned col_num, - void *private_data, osl_rbtree_loop_func *func); -int osl_rbtree_loop_reverse(const struct osl_table *t, unsigned col_num, - void *private_data, osl_rbtree_loop_func *func); -int osl_update_object(struct osl_table *t, const struct osl_row *r, - unsigned col_num, struct osl_object *obj); -int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows); -int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, - struct osl_row **result); -int osl_rbtree_last_row(const struct osl_table *t, unsigned col_num, - struct osl_row **result); -int osl_get_nth_row(const struct osl_table *t, unsigned col_num, - unsigned n, struct osl_row **result); -int osl_get_rank(const struct osl_table *t, struct osl_row *r, - unsigned col_num, unsigned *rank); diff --git a/osl.h.in b/osl.h.in new file mode 100644 index 0000000..8c386c7 --- /dev/null +++ b/osl.h.in @@ -0,0 +1,180 @@ +#include +/* + * Copyright (C) 2007-2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file osl.h User interface for the object storage layer. */ + +/** describes an object of the object storage layer (osl) */ +struct osl_object { + /** Pointer to the data of the object. */ + void *data; + /** The object's size. */ + size_t size; +}; + +/** Flags that change the internal handling of osl tables. */ +enum osl_table_flags { + /** This table will have many rows. */ + OSL_LARGE_TABLE = 1 +}; + +/** The three different types of storage for an osl column */ +enum osl_storage_type { + /** + * All data for this column is stored in one file which gets mmapped by + * osl_open_table(). This is suitable for columns that do not hold much + * data. + */ + OSL_MAPPED_STORAGE, + /** + * Each entry is stored on disk and is loaded on demand by + * open_disk_object(). This is the preferable storage type for large + * objects that need not be in memory all the time. + */ + OSL_DISK_STORAGE, + /** + * Objects for columns of this type are volatile: They are only stored + * in memory and are discarded once the table gets closed. + */ + OSL_NO_STORAGE +}; + +/** + * Additional per-column flags + */ +enum osl_storage_flags { + /** + * Build an rbtree for this column. This is only possible if the + * storage type of the column is either \a OSL_MAPPED_STORAGE or \a + * OSL_NO_STORAGE. In order to lookup objects in the table by using \a + * osl_get_row(), the lookup column must have an associated rbtree. + * + * \sa osl_storage_type, osl_get_row() + */ + OSL_RBTREE = 1, + /** The data for this column will have constant size. */ + OSL_FIXED_SIZE = 2, + /** All values of this column will be different. */ + OSL_UNIQUE = 4, + /** Do not free the data for this column (\p OSL_NO_STORAGE). */ + OSL_DONT_FREE = 8 +}; + +struct osl_table; +struct osl_row; + +/** + * In order to build up an rbtree a compare function for the objects must be + * specified. Such a function always takes pointers to the two objects to be + * compared. It must return -1, zero, or 1, if the first argument is considered + * to be respectively less than, equal to, or greater than the second. If two + * members compare as equal, their order in the sorted array is undefined. + */ +typedef int osl_compare_func(const struct osl_object *obj1, + const struct osl_object *obj2); +typedef int osl_rbtree_loop_func(struct osl_row *row, void *data); + +osl_compare_func osl_hash_compare, uint32_compare; + +/** + * Describes one column of a osl table. + */ +struct osl_column_description { + /** One of zje tree possible types of storage */ + enum osl_storage_type storage_type; + /** Specifies further properties of the column */ + enum osl_storage_flags storage_flags; + /** + * The column name determines the name of the directory where all data + * for this column will be stored. Its hash is stored in the table + * header. This field is ignored if the storage type is \a NO_STORAGE + */ + char *name; + /** + * For columns with an associated rbtree, this must point to a function + * that compares the values of two objects, either a built-in function + * or a function defined by the application may be supplied. This + * field is ignored if the column does not have an associated rbtree. + * + * \sa osl_storage_flags, osl_compare_func + */ + osl_compare_func *compare_function; + /** + * If the \a OSL_FIXED_SIZE flag is set for this column, this value + * determines the fixed size of all objects of this column. It is + * ignored, if \a OSL_FIXED_SIZE is not set. + */ + uint32_t data_size; +}; + +/** + * Describes one osl table. + */ +struct osl_table_description { + /** The directory which contains all files of this table. */ + const char *dir; + /** + * The table name. A subdirectory of \a dir called \a name is created + * at table creation time. It must be a valid name for a subdirectory. + * In particular, no slashes are allowed for \a name. + */ + const char *name; + /** The number of columns of this table. */ + uint16_t num_columns; + /** Further table-wide information. */ + enum osl_table_flags flags; + /** The array describing the individual columns of the table. */ + struct osl_column_description *column_descriptions; +}; + +/** Flags to be passed to \a osl_close_table(). */ +enum osl_close_flags { + /** + * The table header contains a "dirty" flag which specifies whether + * the table is currently open by another process. This flag specifies + * that the dirty flag should be cleared before closing the table. + */ + OSL_MARK_CLEAN = 1, + /** + * If the table contains columns of type \a OSL_NO_STORAGE and this + * flag is passed to osl_close_table(), free(3) is called for each + * object of each column of type \a OSL_NO_STORAGE. + */ + OSL_FREE_VOLATILE = 2 +}; + + + +int osl_create_table(const struct osl_table_description *desc); +int osl_open_table(const struct osl_table_description *desc, + struct osl_table **result); +int osl_close_table(struct osl_table *t, enum osl_close_flags flags); +int osl_get_row(const struct osl_table *t, unsigned col_num, + const struct osl_object *obj, struct osl_row **result); +int osl_get_object(const struct osl_table *t, const struct osl_row *row, + unsigned col_num, struct osl_object *object); +int osl_open_disk_object(const struct osl_table *t, + const struct osl_row *r, unsigned col_num, struct osl_object *obj); +int osl_close_disk_object(struct osl_object *obj); +int osl_add_and_get_row(struct osl_table *t, struct osl_object *objects, + struct osl_row **row); +int osl_add_row(struct osl_table *t, struct osl_object *objects); +int osl_del_row(struct osl_table *t, struct osl_row *row); +int osl_rbtree_loop(const struct osl_table *t, unsigned col_num, + void *private_data, osl_rbtree_loop_func *func); +int osl_rbtree_loop_reverse(const struct osl_table *t, unsigned col_num, + void *private_data, osl_rbtree_loop_func *func); +int osl_update_object(struct osl_table *t, const struct osl_row *r, + unsigned col_num, struct osl_object *obj); +int osl_get_num_rows(const struct osl_table *t, unsigned *num_rows); +int osl_rbtree_first_row(const struct osl_table *t, unsigned col_num, + struct osl_row **result); +int osl_rbtree_last_row(const struct osl_table *t, unsigned col_num, + struct osl_row **result); +int osl_get_nth_row(const struct osl_table *t, unsigned col_num, + unsigned n, struct osl_row **result); +int osl_get_rank(const struct osl_table *t, struct osl_row *r, + unsigned col_num, unsigned *rank);