X-Git-Url: http://git.tuebingen.mpg.de/?p=osl.git;a=blobdiff_plain;f=fsck.c;h=357fbe765846a503f0ab7e7b04d47e636048b317;hp=d800017c4ba002b61751fe1ff7e298878d00b5fc;hb=7d53d2f571da94ec9caf85fb456118ebee85fcf9;hpb=dd58755b9a202ab317f96e5dd5d9220c4354774a diff --git a/fsck.c b/fsck.c index d800017..357fbe7 100644 --- a/fsck.c +++ b/fsck.c @@ -6,10 +6,6 @@ /** \file fsck.c The program used to check an osl table. */ -/* FIXME: check error codes of make_message or write wrapper */ - - - #include #include #include @@ -19,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" @@ -40,24 +36,34 @@ static struct fsck_args_info conf; -enum fsck_errors { - E_RANGE_VIOLATION, - E_INVALID_OBJECT, - E_NOT_A_REGULAR_FILE, - E_FSCK_SYNTAX, +#define FSCK_ERRORS \ + FSCK_ERROR(RANGE_VIOLATION, "range violation detected, very bad"), \ + FSCK_ERROR(NOT_A_REGULAR_FILE, "not a regular file"), \ + FSCK_ERROR(SYNTAX, "fsck syntax error"), \ + FSCK_ERROR(ACCESS, "permission denied"), \ + FSCK_ERROR(CHDIR, "could not change directory"), \ + FSCK_ERROR(OPENDIR, "could not open directory"), + +#define FSCK_ERROR(num, txt) E_FSCK_ ## num +enum { + FSCK_DUMMY = (1 << FSCK_ERROR_BIT) - 1, + FSCK_ERRORS +}; +#undef FSCK_ERROR +#define FSCK_ERROR(num, txt) txt +const char const *fsck_errors[] = { + FSCK_ERRORS }; -__printf_2_3 void para_log(int ll, const char* fmt,...) +static const char *fsck_strerror(int num) { - va_list argp; - - if (ll < conf.loglevel_arg) - return; - va_start(argp, fmt); - vfprintf(stderr, fmt, argp); - va_end(argp); + if (num & (1 << FSCK_ERROR_BIT)) + return fsck_errors[num & ((1 << FSCK_ERROR_BIT) - 1)]; + return osl_strerror(num); } +extern int loglevel; + /* taken from git */ signed char hexval_table[256] = { -1, -1, -1, -1, -1, -1, -1, -1, /* 00-07 */ @@ -127,7 +133,7 @@ static int _write_all(int fd, const char *buf, size_t len) * * \sa malloc(3). */ -__must_check __malloc static void *para_malloc(size_t size) +__must_check __malloc static void *fsck_malloc(size_t size) { assert(size); void *p = malloc(size); @@ -152,9 +158,9 @@ __must_check __malloc static void *para_malloc(size_t size) * * \sa calloc(3) */ -__must_check __malloc static void *para_calloc(size_t size) +__must_check __malloc static void *fsck_calloc(size_t size) { - void *ret = para_malloc(size); + void *ret = fsck_malloc(size); memset(ret, 0, size); return ret; @@ -173,7 +179,7 @@ __must_check __malloc static void *para_calloc(size_t size) * * \sa strdup(3) */ -__must_check __malloc static char *para_strdup(const char *s) +__must_check __malloc static char *fsck_strdup(const char *s) { char *ret; @@ -183,18 +189,6 @@ __must_check __malloc static char *para_strdup(const char *s) exit(EXIT_FAILURE); } -/** - * Get the home directory of the current user. - * - * \return A dynammically allocated string that must be freed by the caller. If - * the home directory could not be found, this function returns "/tmp". - */ -__must_check __malloc static char *para_homedir(void) -{ - struct passwd *pw = getpwuid(getuid()); - return para_strdup(pw? pw->pw_dir : "/tmp"); -} - /** * Compare two osl objects pointing to unsigned integers of 32 bit size. * @@ -217,6 +211,86 @@ static int uint32_compare(const struct osl_object *obj1, const struct osl_object return 0; } +/** + * A wrapper for fchdir(). + * + * \param fd An open file descriptor. + * + * \return Standard. + */ +static inline int __fchdir(int fd) +{ + if (fchdir(fd) >= 0) + return 1; + return errno == EACCES? -E_FSCK_ACCESS : -E_FSCK_CHDIR; +} + +/** + * Wrapper for chdir(2). + * + * \param path The specified directory. + * + * \return Standard. + */ +_static_inline_ int __chdir(const char *path) +{ + if (chdir(path) >= 0) + return 1; + return errno == EACCES? -E_FSCK_ACCESS : -E_FSCK_CHDIR; +} + +/** + * Save the cwd and open a given directory. + * + * \param dirname Path to the directory to open. + * \param dir Result pointer. + * \param cwd File descriptor of the current working directory. + * + * \return Standard. + * + * Opening the current directory (".") and calling fchdir() to return is + * usually faster and more reliable than saving cwd in some buffer and calling + * chdir() afterwards. + * + * If \a cwd is not \p NULL "." is opened and the resulting file descriptor is + * stored in \a cwd. If the function returns success, and \a cwd is not \p + * NULL, the caller must close this file descriptor (probably after calling + * fchdir(*cwd)). + * + * On errors, the function undos everything, so the caller needs neither close + * any files, nor change back to the original working directory. + * + * \sa getcwd(3). + * + */ +static int fsck_opendir(const char *dirname, DIR **dir, int *cwd) +{ + int ret; + + if (cwd) { + ret = osl_open(".", O_RDONLY, 0); + if (ret < 0) + return ret; + *cwd = ret; + } + ret = __chdir(dirname); + if (ret < 0) + goto close_cwd; + *dir = opendir("."); + if (*dir) + return 1; + ret = errno == EACCES? -E_FSCK_ACCESS : -E_FSCK_OPENDIR; +/* Ignore return value of fchdir() and close(). We're busted anyway. */ + if (cwd) + fchdir(*cwd); +close_cwd: + if (cwd) + close(*cwd); + return ret; +} + + + /** * Traverse the given directory recursively. * @@ -236,10 +310,10 @@ static int for_each_file_in_dir(const char *dirname, { DIR *dir; struct dirent *entry; - int cwd_fd, ret2, ret = para_opendir(dirname, &dir, &cwd_fd); + int cwd_fd, ret2, ret = fsck_opendir(dirname, &dir, &cwd_fd); if (ret < 0) - return ret == -ERRNO_TO_ERROR(EACCES)? 1 : ret; + return ret == -E_FSCK_ACCESS? 1 : ret; /* scan cwd recursively */ while ((entry = readdir(dir))) { mode_t m; @@ -272,7 +346,7 @@ static int for_each_file_in_dir(const char *dirname, ret = 1; out: closedir(dir); - ret2 = para_fchdir(cwd_fd); + ret2 = __fchdir(cwd_fd); if (ret2 < 0 && ret >= 0) ret = ret2; close(cwd_fd); @@ -308,7 +382,7 @@ static int check_range(struct osl_table *t, uint32_t row_num, uint32_t col_num) if (obj_start < map_start || obj_start + obj.size > map_start + col->data_map.size) { CRIT_LOG("range violation in row %u, col %u\n", row_num, col_num); - return -E_RANGE_VIOLATION; + return -E_FSCK_RANGE_VIOLATION; } DEBUG_LOG("col %u: ok\n", col_num); return 1; @@ -336,13 +410,8 @@ static int check_index_ranges(struct osl_table *t) continue; ret = check_range(t, i, j); if (ret < 0) { - if (ret != -E_INVALID_OBJECT && - ret != -E_RANGE_VIOLATION) + if (ret != -E_FSCK_RANGE_VIOLATION) goto err; - if (ret == -E_INVALID_OBJECT) { - CRIT_LOG("row %d, col %d maps to an " - "invalid object\n", i, j); - } ret = mark_row_invalid(t, i); if (ret < 0) goto err; @@ -421,7 +490,7 @@ static int prune_invalid_rows_from_index(struct osl_table *t) DEBUG_LOG("unmapping index\n"); osl_munmap(t->index_map.data, t->index_map.size); filename = index_filename(t->desc); - ret = para_truncate(filename, t->row_index_size + ret = truncate_file(filename, t->row_index_size * t->num_invalid_rows); free(filename); if (ret < 0) @@ -437,7 +506,7 @@ static int check_for_invalid_objects(struct osl_table *t, uint32_t **lost_bytes) { int i, j, ret; const struct osl_column_description *cd; - uint32_t *loss = para_malloc(sizeof(uint32_t) * t->desc->num_columns); + uint32_t *loss = fsck_malloc(sizeof(uint32_t) * t->desc->num_columns); INFO_LOG("looking for mapped objects not contained in index\n"); /* first count used bytes */ @@ -446,14 +515,9 @@ static int check_for_invalid_objects(struct osl_table *t, uint32_t **lost_bytes) for (j = 0; j < t->num_rows; j++) { struct osl_object obj; ret = get_mapped_object(t, i, j, &obj); - if (ret >= 0) { - loss[i] -= obj.size + 1; /* add one for header byte */ - continue; - } - if (ret != -E_INVALID_OBJECT) + if (ret < 0) goto err; - CRIT_LOG("row %d, col %d points to an invalid " - "mapped object, bad\n", j, i); + loss[i] -= obj.size; } } ret = 0; @@ -505,8 +569,8 @@ static int prune_objects(struct osl_table *t, uint32_t *lost_bytes) { int i, ret; const struct osl_column_description *cd; - char **col_filenames = para_calloc(t->desc->num_columns * sizeof(char *)); - char **new_col_filenames = para_calloc(t->desc->num_columns * sizeof(char *)); + char **col_filenames = fsck_calloc(t->desc->num_columns * sizeof(char *)); + char **new_col_filenames = fsck_calloc(t->desc->num_columns * sizeof(char *)); char *idx_filename = index_filename(t->desc); char *old_idx_filename = make_message("%s.bak", idx_filename); int fd; @@ -544,7 +608,7 @@ static int prune_objects(struct osl_table *t, uint32_t *lost_bytes) ret = osl_rename(new_col_filenames[i], col_filenames[i]); if (ret < 0) { /* we're kinda screwed here */ CRIT_LOG("rename of col %i failed: %s\n", i, - strerror(errno)); + osl_strerror(errno)); goto out_free; } } @@ -623,7 +687,7 @@ out: free(path); if (ret < 0) return ret; - ret = -E_NOT_A_REGULAR_FILE; + ret = -E_FSCK_NOT_A_REGULAR_FILE; if (!(S_IFREG & statbuf.st_mode)) return ret; return 1; @@ -639,7 +703,7 @@ static int check_disk_storage_presence(struct osl_table *t) if (!t->num_rows) return 1; - hashes = para_malloc(t->num_rows * HASH_SIZE); + hashes = fsck_malloc(t->num_rows * HASH_SIZE); INFO_LOG("looking for missing disk storage objects\n"); for (i = 0; i < t->num_rows; i++) { if (row_is_invalid(t, i)) @@ -683,7 +747,7 @@ static unsigned files_pruned; int prune_disk_storage_file(const char *path, void *private_data) { HASH_TYPE hash[HASH_SIZE]; - unsigned flags = *(unsigned *)private_data; + uint8_t flags = *(uint8_t *)private_data; struct osl_object obj = {.data = hash, .size = HASH_SIZE}; struct osl_row *row; int ret = -1; @@ -740,8 +804,9 @@ static int prune_disk_storage_files(struct osl_table *t) INFO_LOG("looking for unreferenced disk storage files\n"); FOR_EACH_DISK_STORAGE_COLUMN(i, t, cd) { char *dirname = column_filename(t, i); + uint8_t flags = t->desc->flags; ret = for_each_file_in_dir(dirname, prune_disk_storage_file, - (unsigned *)&t->desc->flags); + &flags); free(dirname); } if (files_pruned) @@ -858,7 +923,7 @@ const char *get_asc_storage_type(enum osl_storage_type st) #define APPEND_ASC_SF(sf, flag, str) do { if (sf & flag) { \ if (str) str = make_message("%s%s", str, " | " # flag); \ - else str = para_strdup(#flag); }} while (0) + else str = fsck_strdup(#flag); }} while (0) char *get_asc_storage_flags(enum osl_storage_type sf) @@ -1083,11 +1148,11 @@ out: return ret; } -static int check_table(char *base_dir, char *table_name) +static int check_table(char *db_dir, char *table_name) { struct osl_table_description desc = { .column_descriptions = NULL, - .dir = base_dir, + .dir = db_dir, .name = table_name }; int ret; @@ -1110,11 +1175,11 @@ out: return ret; } -static int check_all_tables(char *base_dir) +static int check_all_tables(char *db_dir) { DIR *dir; struct dirent *entry; - int cwd_fd, ret2, ret = para_opendir(base_dir, &dir, &cwd_fd); + int cwd_fd, ret2, ret = fsck_opendir(db_dir, &dir, &cwd_fd); if (ret < 0) return ret; @@ -1130,12 +1195,12 @@ static int check_all_tables(char *base_dir) m = s.st_mode; if (!S_ISDIR(m)) continue; - ret = check_table(base_dir, entry->d_name); + ret = check_table(db_dir, entry->d_name); if (ret < 0) break; } closedir(dir); - ret2 = para_fchdir(cwd_fd); + ret2 = __fchdir(cwd_fd); if (ret2 < 0 && ret >= 0) ret = ret2; close(cwd_fd); @@ -1145,44 +1210,38 @@ static int check_all_tables(char *base_dir) int main(int argc, char **argv) { int i, ret; - char *base_dir = NULL; - - ret = fsck_cmdline_parser(argc, argv, &conf); + struct fsck_cmdline_parser_params params = { + .override = 0, + .initialize = 1, + .check_required = 1, + .check_ambiguity = 1, + .print_errors = 1 + }; + ret = fsck_cmdline_parser_ext(argc, argv, &conf, ¶ms); if (ret < 0) { + loglevel = EMERG; ret = -E_FSCK_SYNTAX; goto out; } + loglevel = conf.loglevel_arg; HANDLE_VERSION_FLAG("fsck", conf); - if (conf.base_dir_given) - base_dir = para_strdup(conf.base_dir_arg); - else { - char *home = para_homedir(); - base_dir = make_message("%s/.paraslash/afs_database", home); - free(home); - } + INFO_LOG("database dir: %s\n", conf.database_dir_arg); if (!conf.inputs_num) { - ret = check_all_tables(base_dir); + ret = check_all_tables(conf.database_dir_arg); goto out; } for (i = 0; i < conf.inputs_num; i++) { - ret = check_table(base_dir, conf.inputs[i]); + ret = check_table(conf.database_dir_arg, conf.inputs[i]); if (ret < 0) break; } out: if (ret < 0) { - /* FIXME: osl_strerror() is BAD!!! */ - ERROR_LOG("%s%s: %s\n", - base_dir? "base_dir: " : "", - base_dir? base_dir : "", - osl_strerror(-ret) - ); + ERROR_LOG("%s\n", fsck_strerror(-ret)); if (conf.loglevel_arg > 1) EMERG_LOG("re-run with \"--loglevel %d\" to increase verbosity\n", conf.loglevel_arg - 1); } else NOTICE_LOG("success\n"); - if (base_dir) - free(base_dir); return ret < 0? EXIT_FAILURE : EXIT_SUCCESS; }