X-Git-Url: http://git.tuebingen.mpg.de/?p=osl.git;a=blobdiff_plain;f=fsck.c;h=bd1b5567ba86c05d2f168ecf9506c8dcda7ab5f7;hp=ef068d369a879c160f2569f282777765b2497371;hb=cf207dcadaa03addb1381012f9b822a754a526af;hpb=b7f006eecd456214d36db9e901d979d5f998e813 diff --git a/fsck.c b/fsck.c index ef068d3..bd1b556 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 @@ -18,8 +14,7 @@ #include "log.h" #include "osl.h" -#include "error.h" -#include "fd.h" +#include "util.h" #include "osl_core.h" #include "fsck.cmdline.h" @@ -43,8 +38,12 @@ static struct fsck_args_info conf; #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(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_BIT 29 #define FSCK_ERROR(num, txt) E_FSCK_ ## num enum { FSCK_DUMMY = (1 << FSCK_ERROR_BIT) - 1, @@ -63,16 +62,7 @@ static const char *fsck_strerror(int num) return osl_strerror(num); } -__printf_2_3 void para_log(int ll, const char* fmt,...) -{ - va_list argp; - - if (ll < conf.loglevel_arg) - return; - va_start(argp, fmt); - vfprintf(stderr, fmt, argp); - va_end(argp); -} +extern int loglevel; /* taken from git */ signed char hexval_table[256] = { @@ -143,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); @@ -168,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; @@ -189,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; @@ -199,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. * @@ -233,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. * @@ -252,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; @@ -288,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); @@ -352,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_OSL_INVALID_OBJECT && - ret != -E_FSCK_RANGE_VIOLATION) + if (ret != -E_FSCK_RANGE_VIOLATION) goto err; - if (ret == -E_OSL_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; @@ -437,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) @@ -453,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 */ @@ -462,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_OSL_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; @@ -521,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; @@ -655,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)) @@ -699,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; @@ -756,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) @@ -874,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) @@ -1013,12 +1062,12 @@ static int dump_rows(char *dump_dir, struct osl_table *t) current_dir = make_message("%s/rows_%u-%u", dump_dir, i, i + 999); NOTICE_LOG("dumping rows %u - %u\n", i, i + 999); ret = osl_mkdir(current_dir, 0777); - if (ret < 0 && !is_errno(-ret, EEXIST)) + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) goto out; } row_dir = make_message("%s/row_%03u", current_dir, i); ret = osl_mkdir(row_dir, 0777); - if (ret < 0 && !is_errno(-ret, EEXIST)) { + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) { free(row_dir); goto out; } @@ -1042,11 +1091,11 @@ static int dump_table(char *dump_dir, struct osl_table_description *desc) if (ret < 0) goto out; ret = osl_mkdir(dump_dir, 0777); - if (ret < 0 && !is_errno(-ret, EEXIST)) + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) goto out; table_dump_dir = make_message("%s/%s", dump_dir, desc->name); ret = osl_mkdir(table_dump_dir, 0777); - if (ret < 0 && !is_errno(-ret, EEXIST)) + if (ret < 0 && ret != -E_OSL_DIR_EXISTS) goto out; desc_file = make_message("%s/table_description.c", table_dump_dir); ret = osl_open(desc_file, O_WRONLY | O_CREAT | O_EXCL, 0644); @@ -1099,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; @@ -1126,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; @@ -1146,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); @@ -1161,43 +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) { - ERROR_LOG("%s%s: %s\n", - base_dir? "base_dir: " : "", - base_dir? base_dir : "", - fsck_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; }