X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=4694491a9b81602902bef4149cd233e0e8537570;hp=6d0d385ef02279dfae721566cc69941d89b10b12;hb=05d13ca333a3158a98f0c0e048a85564c6b9ed88;hpb=98060d83459ba10409f295898f0ec917f938b4d3 diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 6d0d385..4694491a 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -27,7 +27,7 @@ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2013, Intel Corporation. + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -45,6 +45,7 @@ #define _GNU_SOURCE #endif +#include #include #include #include @@ -56,6 +57,7 @@ #include #include #include +#include #include #include #include @@ -69,54 +71,13 @@ #endif #include -#include +#include +#include #include -#include -#include #include +#include #include "lustreapi_internal.h" -static unsigned llapi_dir_filetype_table[] = { - [DT_UNKNOWN]= 0, - [DT_FIFO]= S_IFIFO, - [DT_CHR] = S_IFCHR, - [DT_DIR] = S_IFDIR, - [DT_BLK] = S_IFBLK, - [DT_REG] = S_IFREG, - [DT_LNK] = S_IFLNK, - [DT_SOCK]= S_IFSOCK, -#if defined(DT_DOOR) && defined(S_IFDOOR) - [DT_DOOR]= S_IFDOOR, -#endif -}; - -#if defined(DT_DOOR) && defined(S_IFDOOR) -static const int DT_MAX = DT_DOOR; -#else -static const int DT_MAX = DT_SOCK; -#endif - -static unsigned llapi_filetype_dir_table[] = { - [0]= DT_UNKNOWN, - [S_IFIFO]= DT_FIFO, - [S_IFCHR] = DT_CHR, - [S_IFDIR] = DT_DIR, - [S_IFBLK] = DT_BLK, - [S_IFREG] = DT_REG, - [S_IFLNK] = DT_LNK, - [S_IFSOCK]= DT_SOCK, -#if defined(DT_DOOR) && defined(S_IFDOOR) - [S_IFDOOR]= DT_DOOR, -#endif -}; - -#if defined(DT_DOOR) && defined(S_IFDOOR) -static const int S_IFMAX = DT_DOOR; -#else -static const int S_IFMAX = DT_SOCK; -#endif - -/* liblustreapi message level */ static int llapi_msg_level = LLAPI_MSG_MAX; void llapi_msg_set_level(int level) @@ -130,48 +91,102 @@ void llapi_msg_set_level(int level) llapi_msg_level = level; } -/* llapi_error will preserve errno */ -void llapi_error(int level, int _rc, char *fmt, ...) +int llapi_msg_get_level(void) +{ + return llapi_msg_level; +} + +static void error_callback_default(enum llapi_message_level level, int err, + const char *fmt, va_list ap) +{ + vfprintf(stderr, fmt, ap); + if (level & LLAPI_MSG_NO_ERRNO) + fprintf(stderr, "\n"); + else + fprintf(stderr, ": %s (%d)\n", strerror(err), err); +} + +static void info_callback_default(enum llapi_message_level level, int err, + const char *fmt, va_list ap) { - va_list args; - int tmp_errno = errno; - /* to protect using errno as _rc argument */ - int rc = abs(_rc); + vfprintf(stdout, fmt, ap); +} - if ((level & LLAPI_MSG_MASK) > llapi_msg_level) - return; +static llapi_log_callback_t llapi_error_callback = error_callback_default; +static llapi_log_callback_t llapi_info_callback = info_callback_default; - va_start(args, fmt); - vfprintf(stderr, fmt, args); - va_end(args); - if (level & LLAPI_MSG_NO_ERRNO) - fprintf(stderr, "\n"); - else - fprintf(stderr, ": %s (%d)\n", strerror(rc), rc); - errno = tmp_errno; +/* llapi_error will preserve errno */ +void llapi_error(enum llapi_message_level level, int err, const char *fmt, ...) +{ + va_list args; + int tmp_errno = errno; + + if ((level & LLAPI_MSG_MASK) > llapi_msg_level) + return; + + va_start(args, fmt); + llapi_error_callback(level, abs(err), fmt, args); + va_end(args); + errno = tmp_errno; } /* llapi_printf will preserve errno */ -void llapi_printf(int level, char *fmt, ...) +void llapi_printf(enum llapi_message_level level, const char *fmt, ...) +{ + va_list args; + int tmp_errno = errno; + + if ((level & LLAPI_MSG_MASK) > llapi_msg_level) + return; + + va_start(args, fmt); + llapi_info_callback(level, 0, fmt, args); + va_end(args); + errno = tmp_errno; +} + +/** + * Set a custom error logging function. Passing in NULL will reset the logging + * callback to its default value. + * + * This function returns the value of the old callback. + */ +llapi_log_callback_t llapi_error_callback_set(llapi_log_callback_t cb) +{ + llapi_log_callback_t old = llapi_error_callback; + + if (cb != NULL) + llapi_error_callback = cb; + else + llapi_error_callback = error_callback_default; + + return old; +} + +/** + * Set a custom info logging function. Passing in NULL will reset the logging + * callback to its default value. + * + * This function returns the value of the old callback. + */ +llapi_log_callback_t llapi_info_callback_set(llapi_log_callback_t cb) { - va_list args; - int tmp_errno = errno; + llapi_log_callback_t old = llapi_info_callback; - if ((level & LLAPI_MSG_MASK) > llapi_msg_level) - return; + if (cb != NULL) + llapi_info_callback = cb; + else + llapi_info_callback = info_callback_default; - va_start(args, fmt); - vfprintf(stdout, fmt, args); - va_end(args); - errno = tmp_errno; + return old; } /** * size_units is to be initialized (or zeroed) by caller. */ -int parse_size(char *optarg, unsigned long long *size, - unsigned long long *size_units, int bytes_spec) +int llapi_parse_size(const char *optarg, unsigned long long *size, + unsigned long long *size_units, int bytes_spec) { char *end; @@ -241,26 +256,26 @@ int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, "larger than expected (%u)", page_size, LOV_MIN_STRIPE_SIZE); } - if (stripe_size < 0 || (stripe_size & (LOV_MIN_STRIPE_SIZE - 1))) { + if (!llapi_stripe_size_is_aligned(stripe_size)) { rc = -EINVAL; - llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe_size %lu, " + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe_size %llu, " "must be an even multiple of %d bytes", stripe_size, page_size); return rc; } - if (stripe_offset < -1 || stripe_offset > MAX_OBD_DEVICES) { + if (!llapi_stripe_offset_is_valid(stripe_offset)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe offset %d", stripe_offset); return rc; } - if (stripe_count < -1 || stripe_count > LOV_MAX_STRIPE_COUNT) { + if (!llapi_stripe_count_is_valid(stripe_count)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe count %d", stripe_count); return rc; } - if (stripe_size >= (1ULL << 32)) { + if (llapi_stripe_size_is_too_big(stripe_size)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "warning: stripe size 4G or larger " @@ -331,6 +346,24 @@ static int find_poolpath(char *fsname, char *poolname, char *poolpath) return 0; } +/* + * Trim a trailing newline from a string, if it exists. + */ +int llapi_chomp_string(char *buf) +{ + if (!buf || !*buf) + return 0; + + while (buf[1]) + buf++; + + if (*buf != '\n') + return 0; + + *buf = '\0'; + return '\n'; +} + /** * return a parameter string for a specific device type or mountpoint * @@ -348,7 +381,7 @@ static int find_poolpath(char *fsname, char *poolname, char *poolpath) * Return 0 for success, with a NUL-terminated string in \param result. * Return -ve value for error. */ -static int get_param(const char *param_path, char *result, +int get_param(const char *param_path, char *result, unsigned int result_size) { char file[PATH_MAX + 1], pattern[PATH_MAX + 1], buf[result_size]; @@ -358,7 +391,7 @@ static int get_param(const char *param_path, char *result, snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s", param_path); rc = first_match(pattern, file); - if (rc) + if (rc != 0 || result == NULL) return rc; fp = fopen(file, "r"); @@ -401,53 +434,80 @@ static int get_param_obdvar(const char *fsname, const char *file_path, const char *obd_type, const char *param_name, char *value, unsigned int val_len) { - char devices[PATH_MAX + 1], dev[PATH_MAX + 1] = "*", fs[PATH_MAX + 1]; - FILE *fp = fopen(DEVICES_LIST, "r"); - int rc = 0; + char devices[PATH_MAX]; + char dev[PATH_MAX] = "*"; + char fs[PATH_MAX]; + FILE *fp = NULL; + int rc = 0; - if (!fsname && file_path) { - rc = llapi_search_fsname(file_path, fs); - if (rc) { - llapi_error(LLAPI_MSG_ERROR, rc, - "'%s' is not on a Lustre filesystem", - file_path); - if (fp != NULL) - fclose(fp); - return rc; - } - } else if (fsname) { - strcpy(fs, fsname); - } + fp = fopen(DEVICES_LIST, "r"); + if (fp == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); + goto out; + } - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); - return rc; - } + if (fsname == NULL && file_path != NULL) { + rc = llapi_search_fsname(file_path, fs); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "'%s' is not on a Lustre filesystem", + file_path); + goto out; + } + } else if (fsname != NULL) { + rc = strlcpy(fs, fsname, sizeof(fs)); + if (rc >= sizeof(fs)) { + rc = -E2BIG; + goto out; + } + } - while (fgets(devices, sizeof(devices), fp) != NULL) { - char *bufp = devices, *tmp; + while (fgets(devices, sizeof(devices) - 1, fp) != NULL) { + char *bufp = devices, *tmp; + + devices[sizeof(devices) - 1] = '\0'; + while (bufp[0] == ' ') + ++bufp; + + tmp = strstr(bufp, obd_type); + if (tmp != NULL) { + tmp += strlen(obd_type) + 1; + if (strcmp(tmp, fs)) + continue; + rc = strlcpy(dev, tmp, sizeof(dev)); + if (rc >= sizeof(dev)) { + rc = -E2BIG; + goto out; + } - while (bufp[0] == ' ') - ++bufp; + tmp = strchr(dev, ' '); + if (tmp != NULL) + *tmp = '\0'; + break; + } + } - tmp = strstr(bufp, obd_type); - if (tmp) { - tmp += strlen(obd_type) + 1; - if (strcmp(tmp, fs)) - continue; - strcpy(dev, tmp); - tmp = strchr(dev, ' '); - *tmp = '\0'; - break; - } - } + if (dev[0] == '*' && strlen(fs)) { + rc = snprintf(dev, sizeof(dev), "%s-*", fs); + if (rc >= sizeof(dev)) { + rc = -E2BIG; + goto out; + } + } + rc = snprintf(devices, sizeof(devices), "%s/%s/%s", obd_type, dev, + param_name); + if (rc >= sizeof(devices)) { + rc = -E2BIG; + goto out; + } - if (dev[0] == '*' && strlen(fs)) - snprintf(dev, PATH_MAX, "%s-*", fs); - snprintf(devices, PATH_MAX, "%s/%s/%s", obd_type, dev, param_name); - fclose(fp); - return get_param(devices, value, val_len); + fclose(fp); + return get_param(devices, value, val_len); +out: + if (fp != NULL) + fclose(fp); + return rc; } /* @@ -524,7 +584,7 @@ static int get_param_lmv(const char *path, static int get_mds_md_size(const char *path) { - int md_size = lov_mds_md_size(LOV_MAX_STRIPE_COUNT, LOV_MAGIC_V3); + int md_size = lov_user_md_size(LOV_MAX_STRIPE_COUNT, LOV_USER_MAGIC_V3); char buf[80]; int rc; @@ -541,6 +601,11 @@ out: return md_size; } +int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) +{ + return get_param_lmv(path, "uuid", buf, bufsize); +} + /* * if pool is NULL, search ostname in target_obd * if pool is not NULL: @@ -557,10 +622,14 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) if (ostname != NULL) len = strlen(ostname); - if (poolname == NULL) - rc = find_target_obdpath(fsname, buffer); - else + if (poolname == NULL) { + if (len == 0) + rc = -EINVAL; + else + rc = find_target_obdpath(fsname, buffer); + } else { rc = find_poolpath(fsname, poolname, buffer); + } if (rc) return rc; @@ -593,98 +662,192 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) return 0; } -int llapi_file_open_pool(const char *name, int flags, int mode, - unsigned long long stripe_size, int stripe_offset, - int stripe_count, int stripe_pattern, char *pool_name) +/** + * Open a Lustre file. + * + * \param name the name of the file to be opened + * \param flags access mode, see flags in open(2) + * \param mode permission of the file if it is created, see mode in open(2) + * \param param stripe pattern of the newly created file + * + * \retval file descriptor of opened file + * \retval negative errno on failure + */ +int llapi_file_open_param(const char *name, int flags, mode_t mode, + const struct llapi_stripe_param *param) { - struct lov_user_md_v3 lum = { 0 }; - int fd, rc = 0; - int isdir = 0; + char fsname[MAX_OBD_NAME + 1] = { 0 }; + char *pool_name = param->lsp_pool; + struct lov_user_md *lum = NULL; + size_t lum_size = sizeof(*lum); + int fd, rc; - /* Make sure we have a good pool */ - if (pool_name != NULL) { - char fsname[MAX_OBD_NAME + 1], *ptr; + /* Make sure we are on a Lustre file system */ + rc = llapi_search_fsname(name, fsname); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "'%s' is not on a Lustre filesystem", + name); + return rc; + } - rc = llapi_search_fsname(name, fsname); - if (rc) { - llapi_error(LLAPI_MSG_ERROR, rc, - "'%s' is not on a Lustre filesystem", - name); - return rc; - } + /* Check if the stripe pattern is sane. */ + rc = llapi_stripe_limit_check(param->lsp_stripe_size, + param->lsp_stripe_offset, + param->lsp_stripe_count, + param->lsp_stripe_pattern); + if (rc != 0) + return rc; - /* in case user gives the full pool name ., - * strip the fsname */ - ptr = strchr(pool_name, '.'); - if (ptr != NULL) { - *ptr = '\0'; - if (strcmp(pool_name, fsname) != 0) { - *ptr = '.'; - llapi_err_noerrno(LLAPI_MSG_ERROR, - "Pool '%s' is not on filesystem '%s'", - pool_name, fsname); - return -EINVAL; - } - pool_name = ptr + 1; - } + /* Make sure we have a good pool */ + if (pool_name != NULL) { + /* in case user gives the full pool name ., + * strip the fsname */ + char *ptr = strchr(pool_name, '.'); + if (ptr != NULL) { + *ptr = '\0'; + if (strcmp(pool_name, fsname) != 0) { + *ptr = '.'; + llapi_err_noerrno(LLAPI_MSG_ERROR, + "Pool '%s' is not on filesystem '%s'", + pool_name, fsname); + return -EINVAL; + } + pool_name = ptr + 1; + } - /* Make sure the pool exists and is non-empty */ - rc = llapi_search_ost(fsname, pool_name, NULL); - if (rc < 1) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "pool '%s.%s' %s", fsname, pool_name, - rc == 0 ? "has no OSTs" : "does not exist"); - return -EINVAL; - } - } + /* Make sure the pool exists and is non-empty */ + rc = llapi_search_ost(fsname, pool_name, NULL); + if (rc < 1) { + char *err = rc == 0 ? "has no OSTs" : "does not exist"; - fd = open(name, flags | O_LOV_DELAY_CREATE, mode); - if (fd < 0 && errno == EISDIR) { - fd = open(name, O_DIRECTORY | O_RDONLY); - isdir++; - } + llapi_err_noerrno(LLAPI_MSG_ERROR, "pool '%s.%s' %s", + fsname, pool_name, err); + return -EINVAL; + } - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); - return rc; - } + lum_size = sizeof(struct lov_user_md_v3); + } - rc = llapi_stripe_limit_check(stripe_size, stripe_offset, stripe_count, - stripe_pattern); - if (rc != 0) - goto out; + /* sanity check of target list */ + if (param->lsp_is_specific) { + char ostname[MAX_OBD_NAME + 1]; + bool found = false; + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) { + snprintf(ostname, sizeof(ostname), "%s-OST%04x_UUID", + fsname, param->lsp_osts[i]); + rc = llapi_search_ost(fsname, pool_name, ostname); + if (rc <= 0) { + if (rc == 0) + rc = -ENODEV; + + llapi_error(LLAPI_MSG_ERROR, rc, + "%s: cannot find OST %s in %s", + __func__, ostname, + pool_name != NULL ? + "pool" : "system"); + return rc; + } - /* Initialize IOCTL striping pattern structure */ - lum.lmm_magic = LOV_USER_MAGIC_V3; - lum.lmm_pattern = stripe_pattern; - lum.lmm_stripe_size = stripe_size; - lum.lmm_stripe_count = stripe_count; - lum.lmm_stripe_offset = stripe_offset; - if (pool_name != NULL) { - strncpy(lum.lmm_pool_name, pool_name, LOV_MAXPOOLNAME); - } else { - /* If no pool is specified at all, use V1 request */ - lum.lmm_magic = LOV_USER_MAGIC_V1; - } + /* Make sure stripe offset is in OST list. */ + if (param->lsp_osts[i] == param->lsp_stripe_offset) + found = true; + } + if (!found) { + llapi_error(LLAPI_MSG_ERROR, -EINVAL, + "%s: stripe offset '%d' is not in the " + "target list", + __func__, param->lsp_stripe_offset); + return -EINVAL; + } - if (ioctl(fd, LL_IOC_LOV_SETSTRIPE, &lum)) { - char *errmsg = "stripe already set"; - rc = -errno; - if (errno != EEXIST && errno != EALREADY) - errmsg = strerror(errno); + lum_size = lov_user_md_size(param->lsp_stripe_count, + LOV_USER_MAGIC_SPECIFIC); + } - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error on ioctl "LPX64" for '%s' (%d): %s", - (__u64)LL_IOC_LOV_SETSTRIPE, name, fd,errmsg); - } -out: - if (rc) { - close(fd); - fd = rc; - } + lum = calloc(1, lum_size); + if (lum == NULL) + return -ENOMEM; + +retry_open: + fd = open(name, flags | O_LOV_DELAY_CREATE, mode); + if (fd < 0) { + if (errno == EISDIR && !(flags & O_DIRECTORY)) { + flags = O_DIRECTORY | O_RDONLY; + goto retry_open; + } + } + + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + free(lum); + return rc; + } - return fd; + /* Initialize IOCTL striping pattern structure */ + lum->lmm_magic = LOV_USER_MAGIC_V1; + lum->lmm_pattern = param->lsp_stripe_pattern; + lum->lmm_stripe_size = param->lsp_stripe_size; + lum->lmm_stripe_count = param->lsp_stripe_count; + lum->lmm_stripe_offset = param->lsp_stripe_offset; + if (pool_name != NULL) { + struct lov_user_md_v3 *lumv3 = (void *)lum; + + lumv3->lmm_magic = LOV_USER_MAGIC_V3; + strncpy(lumv3->lmm_pool_name, pool_name, LOV_MAXPOOLNAME); + } + if (param->lsp_is_specific) { + struct lov_user_md_v3 *lumv3 = (void *)lum; + int i; + + lumv3->lmm_magic = LOV_USER_MAGIC_SPECIFIC; + if (pool_name == NULL) { + /* LOV_USER_MAGIC_SPECIFIC uses v3 format plus specified + * OST list, therefore if pool is not specified we have + * to pack a null pool name for placeholder. */ + memset(lumv3->lmm_pool_name, 0, LOV_MAXPOOLNAME); + } + + for (i = 0; i < param->lsp_stripe_count; i++) + lumv3->lmm_objects[i].l_ost_idx = param->lsp_osts[i]; + } + + if (ioctl(fd, LL_IOC_LOV_SETSTRIPE, lum) != 0) { + char *errmsg = "stripe already set"; + + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error on ioctl "LPX64" for '%s' (%d): %s", + (__u64)LL_IOC_LOV_SETSTRIPE, name, fd, + errmsg); + + close(fd); + fd = rc; + } + + free(lum); + + return fd; +} + +int llapi_file_open_pool(const char *name, int flags, int mode, + unsigned long long stripe_size, int stripe_offset, + int stripe_count, int stripe_pattern, char *pool_name) +{ + const struct llapi_stripe_param param = { + .lsp_stripe_size = stripe_size, + .lsp_stripe_count = stripe_count, + .lsp_stripe_pattern = stripe_pattern, + .lsp_stripe_offset = stripe_offset, + .lsp_pool = pool_name + }; + return llapi_file_open_param(name, flags, mode, ¶m); } int llapi_file_open(const char *name, int flags, int mode, @@ -727,12 +890,54 @@ int llapi_file_create_pool(const char *name, unsigned long long stripe_size, return 0; } -/** - * In DNE phase I, only stripe_offset will be used in this function. - * stripe_count, stripe_pattern and pool_name will be supported later. - */ -int llapi_dir_create_pool(const char *name, int flags, int stripe_offset, - int stripe_count, int stripe_pattern, char *pool_name) +int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) +{ + struct lmv_user_md lum = { 0 }; + int fd; + int rc = 0; + + lum.lum_magic = LMV_USER_MAGIC; + lum.lum_stripe_offset = stripe_offset; + lum.lum_stripe_count = stripe_count; + lum.lum_hash_type = stripe_pattern; + if (pool_name != NULL) { + if (strlen(pool_name) >= sizeof(lum.lum_pool_name)) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error LL_IOC_LMV_SET_DEFAULT_STRIPE '%s'" + ": too large pool name: %s", name, pool_name); + return -E2BIG; + } + strncpy(lum.lum_pool_name, pool_name, + sizeof(lum.lum_pool_name)); + } + + fd = open(name, O_DIRECTORY | O_RDONLY); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + return rc; + } + + rc = ioctl(fd, LL_IOC_LMV_SET_DEFAULT_STRIPE, &lum); + if (rc < 0) { + char *errmsg = "stripe already set"; + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error on LL_IOC_LMV_SETSTRIPE '%s' (%d): %s", + name, fd, errmsg); + } + close(fd); + return rc; +} + +int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) { struct lmv_user_md lmu = { 0 }; struct obd_ioctl_data data = { 0 }; @@ -755,36 +960,37 @@ int llapi_dir_create_pool(const char *name, int flags, int stripe_offset, lmu.lum_stripe_count = stripe_count; lmu.lum_hash_type = stripe_pattern; if (pool_name != NULL) { - if (strlen(pool_name) >= LOV_MAXPOOLNAME) { + if (strlen(pool_name) > LOV_MAXPOOLNAME) { llapi_err_noerrno(LLAPI_MSG_ERROR, "error LL_IOC_LMV_SETSTRIPE '%s' : too large" "pool name: %s", name, pool_name); - GOTO(out, rc = -E2BIG); + rc = -E2BIG; + goto out; } memcpy(lmu.lum_pool_name, pool_name, strlen(pool_name)); } filename = basename(namepath); - lmu.lum_type = LMV_STRIPE_TYPE; dir = dirname(dirpath); data.ioc_inlbuf1 = (char *)filename; data.ioc_inllen1 = strlen(filename) + 1; data.ioc_inlbuf2 = (char *)&lmu; data.ioc_inllen2 = sizeof(struct lmv_user_md); + data.ioc_type = mode; rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { llapi_error(LLAPI_MSG_ERROR, rc, "error: LL_IOC_LMV_SETSTRIPE pack failed '%s'.", name); - GOTO(out, rc); + goto out; } fd = open(dir, O_DIRECTORY | O_RDONLY); if (fd < 0) { rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); - GOTO(out, rc); + goto out; } if (ioctl(fd, LL_IOC_LMV_SETSTRIPE, buf)) { @@ -827,7 +1033,7 @@ int llapi_direntry_remove(char *dname) rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", filename); - GOTO(out, rc); + goto out; } if (ioctl(fd, LL_IOC_REMOVE_ENTRY, filename)) { @@ -878,10 +1084,11 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) mntlen = strlen(mnt.mnt_dir); ptr = strrchr(mnt.mnt_fsname, '/'); - if (!ptr && !len) { - rc = -EINVAL; - break; - } + /* thanks to the call to llapi_is_lustre_mnt() above, + * we are sure that mnt.mnt_fsname contains ":/", + * so ptr should never be NULL */ + if (ptr == NULL) + continue; ptr++; /* Check the fsname for a match, if given */ @@ -966,19 +1173,23 @@ int llapi_search_fsname(const char *pathname, char *fsname) path = realpath(pathname, NULL); if (path == NULL) { - char buf[PATH_MAX + 1], *ptr; - - buf[0] = 0; - if (pathname[0] != '/') { - /* Need an absolute path, but realpath() only works for - * pathnames that actually exist. We go through the - * extra hurdle of dirname(getcwd() + pathname) in - * case the relative pathname contains ".." in it. */ - if (getcwd(buf, sizeof(buf) - 1) == NULL) - return -errno; - strcat(buf, "/"); - } - strncat(buf, pathname, sizeof(buf) - strlen(buf)); + char buf[PATH_MAX], *ptr; + + buf[0] = '\0'; + if (pathname[0] != '/') { + /* Need an absolute path, but realpath() only works for + * pathnames that actually exist. We go through the + * extra hurdle of dirname(getcwd() + pathname) in + * case the relative pathname contains ".." in it. */ + if (getcwd(buf, sizeof(buf) - 2) == NULL) + return -errno; + rc = strlcat(buf, "/", sizeof(buf)); + if (rc >= sizeof(buf)) + return -E2BIG; + } + rc = strlcat(buf, pathname, sizeof(buf)); + if (rc >= sizeof(buf)) + return -E2BIG; path = realpath(buf, NULL); if (path == NULL) { ptr = strrchr(buf, '/'); @@ -1074,20 +1285,20 @@ static int poolpath(char *fsname, char *pathname, char *pool_pathname) int llapi_get_poolmembers(const char *poolname, char **members, int list_size, char *buffer, int buffer_size) { - char fsname[PATH_MAX + 1]; - char *pool, *tmp; - char pathname[PATH_MAX + 1]; - char path[PATH_MAX + 1]; - char buf[1024]; + char fsname[PATH_MAX]; + char *pool, *tmp; + char pathname[PATH_MAX]; + char path[PATH_MAX]; + char buf[1024]; FILE *fd; int rc = 0; int nb_entries = 0; int used = 0; /* name is FSNAME.POOLNAME */ - if (strlen(poolname) > PATH_MAX) - return -EOVERFLOW; - strcpy(fsname, poolname); + if (strlen(poolname) >= sizeof(fsname)) + return -EOVERFLOW; + strlcpy(fsname, poolname, sizeof(fsname)); pool = strchr(fsname, '.'); if (pool == NULL) return -EINVAL; @@ -1104,7 +1315,9 @@ int llapi_get_poolmembers(const char *poolname, char **members, } llapi_printf(LLAPI_MSG_NORMAL, "Pool: %s.%s\n", fsname, pool); - sprintf(path, "%s/%s", pathname, pool); + rc = snprintf(path, sizeof(path), "%s/%s", pathname, pool); + if (rc >= sizeof(path)) + return -EOVERFLOW; fd = fopen(path, "r"); if (fd == NULL) { rc = -errno; @@ -1118,6 +1331,7 @@ int llapi_get_poolmembers(const char *poolname, char **members, rc = -EOVERFLOW; break; } + buf[sizeof(buf) - 1] = '\0'; /* remove '\n' */ tmp = strchr(buf, '\n'); if (tmp != NULL) @@ -1186,10 +1400,14 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, " a Lustre filesystem", name); return rc; } - strcpy(fsname, rname); + if (strlen(rname) > sizeof(fsname)-1) + return -E2BIG; + strncpy(fsname, rname, sizeof(fsname)); } else { /* name is FSNAME */ - strcpy(fsname, name); + if (strlen(name) > sizeof(fsname)-1) + return -E2BIG; + strncpy(fsname, name, sizeof(fsname)); rc = poolpath(fsname, NULL, pathname); } if (rc != 0) { @@ -1258,8 +1476,14 @@ int llapi_poollist(const char *name) int obdcount, bufsize, rc, nb, i; char *poolname = NULL, *tmp = NULL, data[16]; - if (name[0] != '/') { - fsname = strdup(name); + if (name == NULL) + return -EINVAL; + + if (name[0] != '/') { + fsname = strdup(name); + if (fsname == NULL) + return -ENOMEM; + poolname = strchr(fsname, '.'); if (poolname) *poolname = '\0'; @@ -1312,61 +1536,65 @@ err: return rc; } -typedef int (semantic_func_t)(char *path, DIR *parent, DIR *d, +typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d, void *data, struct dirent64 *de); #define OBD_NOT_FOUND (-1) static int common_param_init(struct find_param *param, char *path) { - int lumlen = get_mds_md_size(path); + int lum_size = get_mds_md_size(path); - if (lumlen < PATH_MAX + 1) - lumlen = PATH_MAX + 1; + if (lum_size < PATH_MAX + 1) + lum_size = PATH_MAX + 1; - param->lumlen = lumlen; - param->lmd = malloc(sizeof(lstat_t) + param->lumlen); - if (param->lmd == NULL) { + param->fp_lum_size = lum_size; + param->fp_lmd = malloc(sizeof(lstat_t) + param->fp_lum_size); + if (param->fp_lmd == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, - "error: allocation of %d bytes for ioctl", - sizeof(lstat_t) + param->lumlen); + "error: allocation of %zu bytes for ioctl", + sizeof(lstat_t) + param->fp_lum_size); return -ENOMEM; } - param->fp_lmv_count = 256; - param->fp_lmv_md = malloc(lmv_user_md_size(256, LMV_MAGIC_V1)); + param->fp_lmv_stripe_count = 256; + param->fp_lmv_md = malloc(lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); if (param->fp_lmv_md == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %d bytes for ioctl", - lmv_user_md_size(256, LMV_MAGIC_V1)); + lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); return -ENOMEM; } - param->got_uuids = 0; - param->obdindexes = NULL; - param->obdindex = OBD_NOT_FOUND; - param->mdtindex = OBD_NOT_FOUND; + param->fp_got_uuids = 0; + param->fp_obd_indexes = NULL; + param->fp_obd_index = OBD_NOT_FOUND; + if (!param->fp_migrate) + param->fp_mdt_index = OBD_NOT_FOUND; return 0; } static void find_param_fini(struct find_param *param) { - if (param->obdindexes) - free(param->obdindexes); + if (param->fp_obd_indexes) + free(param->fp_obd_indexes); - if (param->lmd) - free(param->lmd); + if (param->fp_lmd) + free(param->fp_lmd); if (param->fp_lmv_md) free(param->fp_lmv_md); } -static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data, +static int cb_common_fini(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { - struct find_param *param = (struct find_param *)data; - param->depth--; - return 0; + struct find_param *param = data; + param->fp_depth--; + + return 0; } /* set errno upon failure */ @@ -1389,13 +1617,13 @@ static DIR *opendir_parent(char *path) static int cb_get_dirstripe(char *path, DIR *d, struct find_param *param) { - struct lmv_user_md *lmv = (struct lmv_user_md *)param->fp_lmv_md; - int ret = 0; + param->fp_lmv_md->lum_stripe_count = param->fp_lmv_stripe_count; + if (param->fp_get_default_lmv) + param->fp_lmv_md->lum_magic = LMV_USER_MAGIC; + else + param->fp_lmv_md->lum_magic = LMV_MAGIC_V1; - lmv->lum_stripe_count = param->fp_lmv_count; - lmv->lum_magic = LMV_MAGIC_V1; - ret = ioctl(dirfd(d), LL_IOC_LMV_GETSTRIPE, lmv); - return ret; + return ioctl(dirfd(d), LL_IOC_LMV_GETSTRIPE, param->fp_lmv_md); } static int get_lmd_info(char *path, DIR *parent, DIR *dir, @@ -1410,14 +1638,18 @@ static int get_lmd_info(char *path, DIR *parent, DIR *dir, if (dir) { ret = ioctl(dirfd(dir), LL_IOC_MDC_GETINFO, (void *)lmd); } else if (parent) { - char *fname = strrchr(path, '/'); + char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - /* retrieve needed file info */ - strncpy((char *)lmd, fname, lumlen); - ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); - } else { - return ret; + /* To avoid opening, locking, and closing each file on the + * client if that is not needed. The GETFILEINFO ioctl can + * be done on the patent dir with a single open for all + * files in that directory, and it also doesn't pollute the + * client dcache with millions of dentries when traversing + * a large filesystem. */ + fname = (fname == NULL ? path : fname + 1); + /* retrieve needed file info */ + strlcpy((char *)lmd, fname, lumlen); + ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); } if (ret) { @@ -1462,8 +1694,8 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, int len, ret; DIR *d, *p = NULL; - ret = 0; - len = strlen(path); + ret = 0; + len = strlen(path); d = opendir(path); if (!d && errno != ENOTDIR) { @@ -1474,18 +1706,20 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, } else if (!d && !parent) { /* ENOTDIR. Open the parent dir. */ p = opendir_parent(path); - if (!p) - GOTO(out, ret = -errno); + if (!p) { + ret = -errno; + goto out; + } } - if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de))) - goto err; + if (sem_init && (ret = sem_init(path, parent ?: p, &d, data, de))) + goto err; - if (!d || (param->get_lmv && !param->recursive)) - GOTO(out, ret = 0); + if (d == NULL) + goto out; while ((dent = readdir64(d)) != NULL) { - param->have_fileinfo = 0; + int rc; if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; @@ -1505,17 +1739,17 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, strcat(path, dent->d_name); if (dent->d_type == DT_UNKNOWN) { - lstat_t *st = ¶m->lmd->lmd_st; - - ret = get_lmd_info(path, d, NULL, param->lmd, - param->lumlen); - if (ret == 0) { - dent->d_type = - llapi_filetype_dir_table[st->st_mode & - S_IFMT]; - } - if (ret == -ENOENT) - continue; + lstat_t *st = ¶m->fp_lmd->lmd_st; + + rc = get_lmd_info(path, d, NULL, param->fp_lmd, + param->fp_lum_size); + if (rc == 0) + dent->d_type = IFTODT(st->st_mode); + else if (ret == 0) + ret = rc; + + if (rc == -ENOENT) + continue; } switch (dent->d_type) { case DT_UNKNOWN: @@ -1523,35 +1757,35 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, "error: %s: '%s' is UNKNOWN type %d", __func__, dent->d_name, dent->d_type); break; - case DT_DIR: - ret = llapi_semantic_traverse(path, size, d, sem_init, - sem_fini, data, dent); - if (ret < 0) - goto out; - break; - default: - ret = 0; - if (sem_init) { - ret = sem_init(path, d, NULL, data, dent); - if (ret < 0) - goto out; - } - if (sem_fini && ret == 0) - sem_fini(path, d, NULL, data, dent); + case DT_DIR: + rc = llapi_semantic_traverse(path, size, d, sem_init, + sem_fini, data, dent); + if (rc != 0 && ret == 0) + ret = rc; + break; + default: + rc = 0; + if (sem_init) { + rc = sem_init(path, d, NULL, data, dent); + if (rc < 0 && ret == 0) + ret = rc; + } + if (sem_fini && rc == 0) + sem_fini(path, d, NULL, data, dent); } } out: path[len] = 0; - if (sem_fini) - sem_fini(path, parent, d, data, de); + if (sem_fini) + sem_fini(path, parent, &d, data, de); err: if (d) closedir(d); if (p) closedir(p); - return ret; + return ret; } static int param_callback(char *path, semantic_func_t sem_init, @@ -1571,11 +1805,12 @@ static int param_callback(char *path, semantic_func_t sem_init, if (!buf) return -ENOMEM; - strncpy(buf, path, PATH_MAX + 1); + strlcpy(buf, path, PATH_MAX + 1); ret = common_param_init(param, buf); if (ret) goto out; - param->depth = 0; + + param->fp_depth = 0; ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, sem_init, sem_fini, param, NULL); @@ -1646,16 +1881,17 @@ enum tgt_type { /* * If uuidp is NULL, return the number of available obd uuids. * If uuidp is non-NULL, then it will return the uuids of the obds. If - * there are more OSTs then allocated to uuidp, then an error is returned with + * there are more OSTs than allocated to uuidp, then an error is returned with * the ost_count set to number of available obd uuids. */ static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, int *ost_count, enum tgt_type type) { - struct obd_uuid name; - char buf[1024]; - FILE *fp; - int rc = 0, index = 0; + struct obd_uuid name; + char buf[1024]; + char format[32]; + FILE *fp; + int rc = 0, index = 0; /* Get the lov name */ if (type == LOV_TYPE) { @@ -1678,9 +1914,11 @@ static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, return rc; } - while (fgets(buf, sizeof(buf), fp) != NULL) { - if (uuidp && (index < *ost_count)) { - if (sscanf(buf, "%d: %s", &index, uuidp[index].uuid) <2) + snprintf(format, sizeof(format), + "%%d: %%%zus", sizeof(uuidp[0].uuid) - 1); + while (fgets(buf, sizeof(buf), fp) != NULL) { + if (uuidp && (index < *ost_count)) { + if (sscanf(buf, format, &index, uuidp[index].uuid) < 2) break; } index++; @@ -1744,21 +1982,21 @@ int llapi_uuid_match(char *real_uuid, char *search_uuid) return (strncmp(search_uuid, real_uuid, cmplen) == 0); } -/* Here, param->obduuid points to a single obduuid, the index of which is - * returned in param->obdindex */ +/* Here, param->fp_obd_uuid points to a single obduuid, the index of which is + * returned in param->fp_obd_index */ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) { - struct obd_uuid obd_uuid; - char uuid[sizeof(struct obd_uuid)]; - char buf[1024]; - FILE *fp; - int rc = 0, index; + struct obd_uuid obd_uuid; + char buf[1024]; + char format[32]; + FILE *fp; + int rc = 0; - if (param->got_uuids) + if (param->fp_got_uuids) return rc; /* Get the lov/lmv name */ - if (param->get_lmv) + if (param->fp_get_lmv) rc = llapi_file_fget_lmv_uuid(dirfd(dir), &obd_uuid); else rc = llapi_file_fget_lov_uuid(dirfd(dir), &obd_uuid); @@ -1772,11 +2010,11 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) return rc; } - param->got_uuids = 1; + param->fp_got_uuids = 1; - /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", - param->get_lmv ? "lmv" : "lov", obd_uuid.uuid); + /* Now get the ost uuids from /proc */ + snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", + param->fp_get_lmv ? "lmv" : "lov", obd_uuid.uuid); fp = fopen(buf, "r"); if (fp == NULL) { rc = -errno; @@ -1784,46 +2022,52 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) return rc; } - if (!param->obduuid && !param->quiet && !param->obds_printed) - llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", - param->get_lmv ? "MDTS" : "OBDS:"); + if (!param->fp_obd_uuid && !param->fp_quiet && !param->fp_obds_printed) + llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", + param->fp_get_lmv ? "MDTS" : "OBDS:"); - while (fgets(buf, sizeof(buf), fp) != NULL) { - if (sscanf(buf, "%d: %s", &index, uuid) < 2) - break; + snprintf(format, sizeof(format), + "%%d: %%%zus", sizeof(obd_uuid.uuid) - 1); + while (fgets(buf, sizeof(buf), fp) != NULL) { + int index; - if (param->obduuid) { - if (llapi_uuid_match(uuid, param->obduuid->uuid)) { - param->obdindex = index; - break; - } - } else if (!param->quiet && !param->obds_printed) { - /* Print everything */ - llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); - } - } - param->obds_printed = 1; + if (sscanf(buf, format, &index, obd_uuid.uuid) < 2) + break; + + if (param->fp_obd_uuid) { + if (llapi_uuid_match(obd_uuid.uuid, + param->fp_obd_uuid->uuid)) { + param->fp_obd_index = index; + break; + } + } else if (!param->fp_quiet && !param->fp_obds_printed) { + /* Print everything */ + llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); + } + } + param->fp_obds_printed = 1; fclose(fp); - if (param->obduuid && (param->obdindex == OBD_NOT_FOUND)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: unknown obduuid: %s", - __func__, param->obduuid->uuid); - rc = -EINVAL; - } + if (param->fp_obd_uuid && (param->fp_obd_index == OBD_NOT_FOUND)) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: unknown obduuid: %s", + __func__, param->fp_obd_uuid->uuid); + rc = -EINVAL; + } return (rc); } -/* In this case, param->obduuid will be an array of obduuids and +/* In this case, param->fp_obd_uuid will be an array of obduuids and * obd index for all these obduuids will be returned in - * param->obdindexes */ + * param->fp_obd_indexes */ static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, int num_obds, int **obdindexes, int *obdindex, enum tgt_type type) { - int ret, obdcount, obd_valid = 0, obdnum, i; + int ret, obdcount, obd_valid = 0, obdnum; + long i; struct obd_uuid *uuids = NULL; char buf[16]; int *indexes; @@ -1911,20 +2155,27 @@ static int setup_target_indexes(DIR *dir, char *path, struct find_param *param) { int ret = 0; - if (param->mdtuuid) { - ret = setup_indexes(dir, path, param->mdtuuid, param->num_mdts, - ¶m->mdtindexes, ¶m->mdtindex, LMV_TYPE); - if (ret) - return ret; - } - if (param->obduuid) { - ret = setup_indexes(dir, path, param->obduuid, param->num_obds, - ¶m->obdindexes, ¶m->obdindex, LOV_TYPE); - if (ret) - return ret; - } - param->got_uuids = 1; - return ret; + if (param->fp_mdt_uuid) { + ret = setup_indexes(dir, path, param->fp_mdt_uuid, + param->fp_num_mdts, + ¶m->fp_mdt_indexes, + ¶m->fp_mdt_index, LMV_TYPE); + if (ret) + return ret; + } + + if (param->fp_obd_uuid) { + ret = setup_indexes(dir, path, param->fp_obd_uuid, + param->fp_num_obds, + ¶m->fp_obd_indexes, + ¶m->fp_obd_index, LOV_TYPE); + if (ret) + return ret; + } + + param->fp_got_uuids = 1; + + return ret; } int llapi_ostlist(char *path, struct find_param *param) @@ -1970,7 +2221,7 @@ static int clilovpath(const char *fsname, const char *const pathname, if (rc != 0) return rc; - strncpy(clilovpath, buffer, sizeof(buffer)); + strlcpy(clilovpath, buffer, sizeof(buffer)); return 0; } @@ -2078,10 +2329,10 @@ static int sattr_cache_get_defaults(const char *const fsname, if (rc) return rc; } else { - strncpy(fsname_buf, fsname, PATH_MAX); + strlcpy(fsname_buf, fsname, sizeof(fsname_buf)); } - if (strncmp(fsname_buf, cache.fsname, PATH_MAX) != 0) { + if (strncmp(fsname_buf, cache.fsname, sizeof(fsname_buf) - 1) != 0) { /* * Ensure all 3 sattrs (count, size, and offset) are * successfully retrieved and stored in tmp before writing to @@ -2095,7 +2346,7 @@ static int sattr_cache_get_defaults(const char *const fsname, cache.stripecount = tmp[0]; cache.stripesize = tmp[1]; cache.stripeoffset = tmp[2]; - strncpy(cache.fsname, fsname_buf, PATH_MAX); + strlcpy(cache.fsname, fsname_buf, sizeof(cache.fsname)); } if (scount) @@ -2114,7 +2365,7 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, int raw, char *pool_name) { char *prefix = is_dir ? "" : "lmm_"; - char nl = is_dir ? ' ' : '\n'; + char *seperator = ""; int rc; if (is_dir && lmm_oi_seq(&lum->lmm_oi) == FID_SEQ_LOV_DEFAULT) { @@ -2146,25 +2397,27 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, &scount, NULL, NULL); if (rc == 0) - llapi_printf(LLAPI_MSG_NORMAL, "%d%c", - scount, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%d", + scount); else llapi_error(LLAPI_MSG_ERROR, rc, "Cannot determine default" " stripe count."); } else { - llapi_printf(LLAPI_MSG_NORMAL, "%d%c", + llapi_printf(LLAPI_MSG_NORMAL, "%d", lum->lmm_stripe_count == (typeof(lum->lmm_stripe_count))(-1) - ? -1 : lum->lmm_stripe_count, nl); + ? -1 : lum->lmm_stripe_count); } } else { - llapi_printf(LLAPI_MSG_NORMAL, "%hd%c", - (__s16)lum->lmm_stripe_count, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%hd", + (__s16)lum->lmm_stripe_count); } + seperator = is_dir ? " " : "\n"; } if (verbose & VERBOSE_SIZE) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_SIZE) llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_size: ", prefix); @@ -2173,53 +2426,62 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, rc = sattr_cache_get_defaults(NULL, path, NULL, &ssize, NULL); if (rc == 0) - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", ssize, - nl); + llapi_printf(LLAPI_MSG_NORMAL, "%u", ssize); else llapi_error(LLAPI_MSG_ERROR, rc, "Cannot determine default" " stripe size."); } else { - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", - lum->lmm_stripe_size, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%u", + lum->lmm_stripe_size); } + seperator = is_dir ? " " : "\n"; } - if ((verbose & VERBOSE_DETAIL) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "lmm_stripe_pattern: %x%c", - lum->lmm_pattern, nl); - } + if ((verbose & VERBOSE_LAYOUT) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_LAYOUT) + llapi_printf(LLAPI_MSG_NORMAL, "%spattern: ", + prefix); + llapi_printf(LLAPI_MSG_NORMAL, "%.x", lum->lmm_pattern); + seperator = "\n"; + } if ((verbose & VERBOSE_GENERATION) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_GENERATION) llapi_printf(LLAPI_MSG_NORMAL, "%slayout_gen: ", prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", - (int)lum->lmm_layout_gen, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%u", + (int)lum->lmm_layout_gen); + seperator = "\n"; } if (verbose & VERBOSE_OFFSET) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_OFFSET) llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ", prefix); if (is_dir) - llapi_printf(LLAPI_MSG_NORMAL, "%d%c", + llapi_printf(LLAPI_MSG_NORMAL, "%d", lum->lmm_stripe_offset == (typeof(lum->lmm_stripe_offset))(-1) ? -1 : - lum->lmm_stripe_offset, nl); + lum->lmm_stripe_offset); else - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", - objects[0].l_ost_idx, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%u", + objects[0].l_ost_idx); + seperator = is_dir ? " " : "\n"; } if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_POOL) llapi_printf(LLAPI_MSG_NORMAL, "%spool: ", prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%s%c", pool_name, nl); + llapi_printf(LLAPI_MSG_NORMAL, "%s", pool_name); } - if (is_dir && (verbose != VERBOSE_OBJID)) + if (!is_dir || (is_dir && (verbose != VERBOSE_OBJID))) llapi_printf(LLAPI_MSG_NORMAL, "\n"); } @@ -2243,7 +2505,8 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, lov_dump_user_lmm_header(lum, path, objects, is_dir, header, depth, raw, pool_name); - if (!is_dir && (header & VERBOSE_OBJID)) { + if (!is_dir && (header & VERBOSE_OBJID) && + !(lum->lmm_pattern & LOV_PATTERN_F_RELEASED)) { if (obdstripe == 1) llapi_printf(LLAPI_MSG_NORMAL, "\tobdidx\t\t objid\t\t objid\t\t group\n"); @@ -2275,20 +2538,30 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, struct lmv_user_mds_data *objects = lum->lum_objects; char *prefix = lum->lum_magic == LMV_USER_MAGIC ? "(Default)" : ""; int i, obdstripe = 0; + char *separator = ""; if (obdindex != OBD_NOT_FOUND) { - for (i = 0; i < lum->lum_stripe_count; i++) { - if (obdindex == objects[i].lum_mds) { - llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, - path); + if (lum->lum_stripe_count == 0) { + if (obdindex == lum->lum_stripe_offset) obdstripe = 1; - break; + } else { + for (i = 0; i < lum->lum_stripe_count; i++) { + if (obdindex == objects[i].lum_mds) { + llapi_printf(LLAPI_MSG_NORMAL, + "%s%s\n", prefix, + path); + obdstripe = 1; + break; + } } } } else { obdstripe = 1; } + if (!obdstripe) + return; + /* show all information default */ if (!verbose) { if (lum->lum_magic == LMV_USER_MAGIC) @@ -2297,36 +2570,41 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, verbose = VERBOSE_OBJID; } - if (lum->lum_magic == LMV_USER_MAGIC) - verbose &= ~VERBOSE_OBJID; - if (depth && path && ((verbose != VERBOSE_OBJID))) - llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); + llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, path); if (verbose & VERBOSE_COUNT) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_COUNT) llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_count: "); - llapi_printf(LLAPI_MSG_NORMAL, "%u\n", + llapi_printf(LLAPI_MSG_NORMAL, "%u", (int)lum->lum_stripe_count); + if (verbose & VERBOSE_OFFSET) + separator = " "; + else + separator = "\n"; } if (verbose & VERBOSE_OFFSET) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_OFFSET) llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_offset: "); - llapi_printf(LLAPI_MSG_NORMAL, "%d\n", + llapi_printf(LLAPI_MSG_NORMAL, "%d", (int)lum->lum_stripe_offset); + separator = "\n"; } - if (verbose & VERBOSE_OBJID) { - if ((obdstripe == 1)) + if (verbose & VERBOSE_OBJID && lum->lum_magic != LMV_USER_MAGIC) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (obdstripe == 1 && lum->lum_stripe_count > 0) llapi_printf(LLAPI_MSG_NORMAL, - "\tmdtidx\t\t FID[seq:oid:ver]\n"); + "mdtidx\t\t FID[seq:oid:ver]\n"); for (i = 0; i < lum->lum_stripe_count; i++) { int idx = objects[i].lum_mds; struct lu_fid *fid = &objects[i].lum_fid; if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) llapi_printf(LLAPI_MSG_NORMAL, - "\t%6u\t\t "DFID"\t\t%s\n", + "%6u\t\t "DFID"\t\t%s\n", idx, PFID(fid), obdindex == idx ? " *" : ""); } @@ -2334,43 +2612,46 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, } if ((verbose & VERBOSE_POOL) && (pool_name[0] != '\0')) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_POOL) llapi_printf(LLAPI_MSG_NORMAL, "%slmv_pool: ", prefix); llapi_printf(LLAPI_MSG_NORMAL, "%s%c ", pool_name, ' '); + separator = "\n"; } - llapi_printf(LLAPI_MSG_NORMAL, "\n"); + + if (!(verbose & VERBOSE_OBJID) || lum->lum_magic == LMV_USER_MAGIC) + llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) { __u32 magic; - if (param->get_lmv) + if (param->fp_get_lmv || param->fp_get_default_lmv) magic = (__u32)param->fp_lmv_md->lum_magic; else - magic = *(__u32 *)¶m->lmd->lmd_lmm; /* lum->lmm_magic */ + magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; /* lum->lmm_magic */ switch (magic) { case LOV_USER_MAGIC_V1: - lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL, - param->lmd->lmd_lmm.lmm_objects, - path, is_dir, - param->obdindex, param->maxdepth, - param->verbose, param->raw); + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, NULL, + param->fp_lmd->lmd_lmm.lmm_objects, + path, is_dir, + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose, param->fp_raw); break; case LOV_USER_MAGIC_V3: { char pool_name[LOV_MAXPOOLNAME + 1]; struct lov_user_ost_data_v1 *objects; - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; - - strncpy(pool_name, lmmv3->lmm_pool_name, LOV_MAXPOOLNAME); - pool_name[LOV_MAXPOOLNAME] = '\0'; - objects = lmmv3->lmm_objects; - lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name, - objects, path, is_dir, - param->obdindex, param->maxdepth, - param->verbose, param->raw); + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + + strlcpy(pool_name, lmmv3->lmm_pool_name, sizeof(pool_name)); + objects = lmmv3->lmm_objects; + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, pool_name, + objects, path, is_dir, + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose, param->fp_raw); break; } case LMV_MAGIC_V1: @@ -2379,16 +2660,16 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) struct lmv_user_md *lum; lum = (struct lmv_user_md *)param->fp_lmv_md; - strncpy(pool_name, lum->lum_pool_name, LOV_MAXPOOLNAME); + strlcpy(pool_name, lum->lum_pool_name, sizeof(pool_name)); lmv_dump_user_lmm(lum, pool_name, path, - param->obdindex, param->maxdepth, - param->verbose); + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose); break; } default: llapi_printf(LLAPI_MSG_NORMAL, "unknown lmm_magic: %#x " "(expecting one of %#x %#x %#x %#x)\n", - *(__u32 *)¶m->lmd->lmd_lmm, + *(__u32 *)¶m->fp_lmd->lmd_lmm, LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3, LMV_USER_MAGIC, LMV_MAGIC_V1); return; @@ -2519,46 +2800,46 @@ static int find_value_cmp(unsigned long long file, unsigned long long limit, * updated timestamps. */ static int find_time_check(lstat_t *st, struct find_param *param, int mds) { - int ret; - int rc = 1; - - /* Check if file is accepted. */ - if (param->atime) { - ret = find_value_cmp(st->st_atime, param->atime, - param->asign, param->exclude_atime, - 24 * 60 * 60, mds); - if (ret < 0) - return ret; - rc = ret; - } - - if (param->mtime) { - ret = find_value_cmp(st->st_mtime, param->mtime, - param->msign, param->exclude_mtime, - 24 * 60 * 60, mds); - if (ret < 0) - return ret; - - /* If the previous check matches, but this one is not yet clear, - * we should return 0 to do an RPC on OSTs. */ - if (rc == 1) - rc = ret; - } + int rc = 1; + int rc2; + + /* Check if file is accepted. */ + if (param->fp_atime) { + rc2 = find_value_cmp(st->st_atime, param->fp_atime, + param->fp_asign, param->fp_exclude_atime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + rc = rc2; + } - if (param->ctime) { - ret = find_value_cmp(st->st_ctime, param->ctime, - param->csign, param->exclude_ctime, - 24 * 60 * 60, mds); - if (ret < 0) - return ret; + if (param->fp_mtime) { + rc2 = find_value_cmp(st->st_mtime, param->fp_mtime, + param->fp_msign, param->fp_exclude_mtime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + + /* If the previous check matches, but this one is not yet clear, + * we should return 0 to do an RPC on OSTs. */ + if (rc == 1) + rc = rc2; + } - /* If the previous check matches, but this one is not yet clear, - * we should return 0 to do an RPC on OSTs. */ - if (rc == 1) - rc = ret; - } + if (param->fp_ctime) { + rc2 = find_value_cmp(st->st_ctime, param->fp_ctime, + param->fp_csign, param->fp_exclude_ctime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + + /* If the previous check matches, but this one is not yet clear, + * we should return 0 to do an RPC on OSTs. */ + if (rc == 1) + rc = rc2; + } - return rc; + return rc; } /** @@ -2568,68 +2849,68 @@ static int find_time_check(lstat_t *st, struct find_param *param, int mds) */ static int check_obd_match(struct find_param *param) { - lstat_t *st = ¶m->lmd->lmd_st; - struct lov_user_ost_data_v1 *lmm_objects; - int i, j; + lstat_t *st = ¶m->fp_lmd->lmd_st; + struct lov_user_ost_data_v1 *lmm_objects; + int i, j; - if (param->obduuid && param->obdindex == OBD_NOT_FOUND) - return 0; + if (param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) + return 0; - if (!S_ISREG(st->st_mode)) - return 0; + if (!S_ISREG(st->st_mode)) + return 0; - /* Only those files should be accepted, which have a - * stripe on the specified OST. */ - if (!param->lmd->lmd_lmm.lmm_stripe_count) - return 0; + /* Only those files should be accepted, which have a + * stripe on the specified OST. */ + if (!param->fp_lmd->lmd_lmm.lmm_stripe_count) + return 0; - if (param->lmd->lmd_lmm.lmm_magic == - LOV_USER_MAGIC_V3) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; + if (param->fp_lmd->lmd_lmm.lmm_magic == + LOV_USER_MAGIC_V3) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; - lmm_objects = lmmv3->lmm_objects; - } else if (param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { - lmm_objects = param->lmd->lmd_lmm.lmm_objects; - } else { - llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", - __func__, param->lmd->lmd_lmm.lmm_magic); - return -EINVAL; - } + lmm_objects = lmmv3->lmm_objects; + } else if (param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { + lmm_objects = param->fp_lmd->lmd_lmm.lmm_objects; + } else { + llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", + __func__, param->fp_lmd->lmd_lmm.lmm_magic); + return -EINVAL; + } - for (i = 0; i < param->lmd->lmd_lmm.lmm_stripe_count; i++) { - for (j = 0; j < param->num_obds; j++) { - if (param->obdindexes[j] == - lmm_objects[i].l_ost_idx) { - if (param->exclude_obd) - return 0; - return 1; - } - } - } + for (i = 0; i < param->fp_lmd->lmd_lmm.lmm_stripe_count; i++) { + for (j = 0; j < param->fp_num_obds; j++) { + if (param->fp_obd_indexes[j] == + lmm_objects[i].l_ost_idx) { + if (param->fp_exclude_obd) + return 0; + return 1; + } + } + } - if (param->exclude_obd) + if (param->fp_exclude_obd) return 1; - return 0; + + return 0; } static int check_mdt_match(struct find_param *param) { - int i; + int i; - if (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND) - return 0; + if (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND) + return 0; - /* FIXME: For striped dir, we should get stripe information and check */ - for (i = 0; i < param->num_mdts; i++) { - if (param->mdtindexes[i] == param->file_mdtindex) - if (param->exclude_mdt) - return 0; - return 1; - } + /* FIXME: For striped dir, we should get stripe information and check */ + for (i = 0; i < param->fp_num_mdts; i++) { + if (param->fp_mdt_indexes[i] == param->fp_file_mdt_index) + return !param->fp_exclude_mdt; + } - if (param->exclude_mdt) - return 1; - return 0; + if (param->fp_exclude_mdt) + return 1; + + return 0; } /** @@ -2647,243 +2928,258 @@ static int print_failed_tgt(struct find_param *param, char *path, int type) memset(&stat_buf, 0, sizeof(struct obd_statfs)); memset(&uuid_buf, 0, sizeof(struct obd_uuid)); - ret = llapi_obd_statfs(path, type, - param->obdindex, &stat_buf, - &uuid_buf); - if (ret) { - llapi_printf(LLAPI_MSG_NORMAL, - "obd_uuid: %s failed %s ", - param->obduuid->uuid, - strerror(errno)); - } - return ret; + ret = llapi_obd_statfs(path, type, + param->fp_obd_index, &stat_buf, + &uuid_buf); + if (ret) { + llapi_printf(LLAPI_MSG_NORMAL, + "obd_uuid: %s failed %s ", + param->fp_obd_uuid->uuid, + strerror(errno)); + } + + return ret; } -static int cb_find_init(char *path, DIR *parent, DIR *dir, +static int cb_find_init(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { struct find_param *param = (struct find_param *)data; + DIR *dir = dirp == NULL ? NULL : *dirp; int decision = 1; /* 1 is accepted; -1 is rejected. */ - lstat_t *st = ¶m->lmd->lmd_st; + lstat_t *st = ¶m->fp_lmd->lmd_st; int lustre_fs = 1; int checked_type = 0; int ret = 0; LASSERT(parent != NULL || dir != NULL); - if (param->have_fileinfo == 0) - param->lmd->lmd_lmm.lmm_stripe_count = 0; + param->fp_lmd->lmd_lmm.lmm_stripe_count = 0; - /* If a regular expression is presented, make the initial decision */ - if (param->pattern != NULL) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - ret = fnmatch(param->pattern, fname, 0); - if ((ret == FNM_NOMATCH && !param->exclude_pattern) || - (ret == 0 && param->exclude_pattern)) - goto decided; - } + /* If a regular expression is presented, make the initial decision */ + if (param->fp_pattern != NULL) { + char *fname = strrchr(path, '/'); + fname = (fname == NULL ? path : fname + 1); + ret = fnmatch(param->fp_pattern, fname, 0); + if ((ret == FNM_NOMATCH && !param->fp_exclude_pattern) || + (ret == 0 && param->fp_exclude_pattern)) + goto decided; + } - /* See if we can check the file type from the dirent. */ - if (param->type && de != NULL && de->d_type != DT_UNKNOWN && - de->d_type < DT_MAX) { - checked_type = 1; - if (llapi_dir_filetype_table[de->d_type] == param->type) { - if (param->exclude_type) - goto decided; - } else { - if (!param->exclude_type) - goto decided; - } - } + /* See if we can check the file type from the dirent. */ + if (param->fp_type != 0 && de != NULL && de->d_type != DT_UNKNOWN) { + checked_type = 1; - ret = 0; + if (DTTOIF(de->d_type) == param->fp_type) { + if (param->fp_exclude_type) + goto decided; + } else { + if (!param->fp_exclude_type) + goto decided; + } + } - /* Request MDS for the stat info if some of these parameters need - * to be compared. */ - if (param->obduuid || param->mdtuuid || param->check_uid || - param->check_gid || param->check_pool || param->atime || - param->ctime || param->mtime || param->check_size || - param->check_stripecount || param->check_stripesize) - decision = 0; + ret = 0; - if (param->type && checked_type == 0) + /* Request MDS for the stat info if some of these parameters need + * to be compared. */ + if (param->fp_obd_uuid || param->fp_mdt_uuid || + param->fp_check_uid || param->fp_check_gid || + param->fp_atime || param->fp_mtime || param->fp_ctime || + param->fp_check_pool || param->fp_check_size || + param->fp_check_stripe_count || param->fp_check_stripe_size || + param->fp_check_layout) + decision = 0; + + if (param->fp_type != 0 && checked_type == 0) decision = 0; - if (param->have_fileinfo == 0 && decision == 0) { - ret = get_lmd_info(path, parent, dir, param->lmd, - param->lumlen); - if (ret == 0) { - if (dir) { - ret = llapi_file_fget_mdtidx(dirfd(dir), - ¶m->file_mdtindex); - } else { - int fd; - lstat_t tmp_st; - - ret = lstat_f(path, &tmp_st); - if (ret) { - ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: lstat failed" - "for %s", __func__, path); - return ret; - } - if (S_ISREG(tmp_st.st_mode)) { - fd = open(path, O_RDONLY); - if (fd > 0) { - ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); - close(fd); - } else { - ret = fd; - } - } else { - /* For special inode, it assumes to - * reside on the same MDT with the - * parent */ - fd = dirfd(parent); - ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); - } - } - } - if (ret) { - if (ret == -ENOTTY) - lustre_fs = 0; - if (ret == -ENOENT) - goto decided; - return ret; - } - } + if (decision == 0) { + ret = get_lmd_info(path, parent, dir, param->fp_lmd, + param->fp_lum_size); + if (ret == 0 && param->fp_mdt_uuid != NULL) { + if (dir != NULL) { + ret = llapi_file_fget_mdtidx(dirfd(dir), + ¶m->fp_file_mdt_index); + } else if (S_ISREG(st->st_mode)) { + int fd; + + /* FIXME: we could get the MDT index from the + * file's FID in lmd->lmd_lmm.lmm_oi without + * opening the file, once we are sure that + * LFSCK2 (2.6) has fixed up pre-2.0 LOV EAs. + * That would still be an ioctl() to map the + * FID to the MDT, but not an open RPC. */ + fd = open(path, O_RDONLY); + if (fd > 0) { + ret = llapi_file_fget_mdtidx(fd, + ¶m->fp_file_mdt_index); + close(fd); + } else { + ret = -errno; + } + } else { + /* For a special file, we assume it resides on + * the same MDT as the parent directory. */ + ret = llapi_file_fget_mdtidx(dirfd(parent), + ¶m->fp_file_mdt_index); + } + } + if (ret != 0) { + if (ret == -ENOTTY) + lustre_fs = 0; + if (ret == -ENOENT) + goto decided; - if (param->type && !checked_type) { - if ((st->st_mode & S_IFMT) == param->type) { - if (param->exclude_type) - goto decided; - } else { - if (!param->exclude_type) - goto decided; - } - } + return ret; + } + } - /* Prepare odb. */ - if (param->obduuid || param->mdtuuid) { - if (lustre_fs && param->got_uuids && - param->st_dev != st->st_dev) { - /* A lustre/lustre mount point is crossed. */ - param->got_uuids = 0; - param->obds_printed = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; - } + if (param->fp_type && !checked_type) { + if ((st->st_mode & S_IFMT) == param->fp_type) { + if (param->fp_exclude_type) + goto decided; + } else { + if (!param->fp_exclude_type) + goto decided; + } + } - if (lustre_fs && !param->got_uuids) { - ret = setup_target_indexes(dir ? dir : parent, path, - param); - if (ret) - return ret; + /* Prepare odb. */ + if (param->fp_obd_uuid || param->fp_mdt_uuid) { + if (lustre_fs && param->fp_got_uuids && + param->fp_dev != st->st_dev) { + /* A lustre/lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_obds_printed = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; + } - param->st_dev = st->st_dev; - } else if (!lustre_fs && param->got_uuids) { - /* A lustre/non-lustre mount point is crossed. */ - param->got_uuids = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; + if (lustre_fs && !param->fp_got_uuids) { + ret = setup_target_indexes(dir ? dir : parent, path, + param); + if (ret) + return ret; + + param->fp_dev = st->st_dev; + } else if (!lustre_fs && param->fp_got_uuids) { + /* A lustre/non-lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; } } - if (param->check_stripesize) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_size, - param->stripesize, - param->stripesize_sign, - param->exclude_stripesize, - param->stripesize_units, 0); - if (decision == -1) - goto decided; - } + if (param->fp_check_stripe_size) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_size, + param->fp_stripe_size, + param->fp_stripe_size_sign, + param->fp_exclude_stripe_size, + param->fp_stripe_size_units, 0); + if (decision == -1) + goto decided; + } - if (param->check_stripecount) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_count, - param->stripecount, - param->stripecount_sign, - param->exclude_stripecount, 1, 0); - if (decision == -1) - goto decided; - } + if (param->fp_check_stripe_count) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_count, + param->fp_stripe_count, + param->fp_stripe_count_sign, + param->fp_exclude_stripe_count, 1, 0); + if (decision == -1) + goto decided; + } + + if (param->fp_check_layout) { + __u32 found; + + found = (param->fp_lmd->lmd_lmm.lmm_pattern & param->fp_layout); + if ((param->fp_lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) || + (found && param->fp_exclude_layout) || + (!found && !param->fp_exclude_layout)) { + decision = -1; + goto decided; + } + } + + /* If an OBD UUID is specified but none matches, skip this file. */ + if ((param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) || + (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND)) + goto decided; + + /* If a OST or MDT UUID is given, and some OST matches, + * check it here. */ + if (param->fp_obd_index != OBD_NOT_FOUND || + param->fp_mdt_index != OBD_NOT_FOUND) { + if (param->fp_obd_uuid) { + if (check_obd_match(param)) { + /* If no mdtuuid is given, we are done. + * Otherwise, fall through to the mdtuuid + * check below. */ + if (!param->fp_mdt_uuid) + goto obd_matches; + } else { + goto decided; + } + } + + if (param->fp_mdt_uuid) { + if (check_mdt_match(param)) + goto obd_matches; + goto decided; + } + } - /* If an OBD UUID is specified but none matches, skip this file. */ - if ((param->obduuid && param->obdindex == OBD_NOT_FOUND) || - (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND)) - goto decided; - - /* If a OST or MDT UUID is given, and some OST matches, - * check it here. */ - if (param->obdindex != OBD_NOT_FOUND || - param->mdtindex != OBD_NOT_FOUND) { - if (param->obduuid) { - if (check_obd_match(param)) { - /* If no mdtuuid is given, we are done. - * Otherwise, fall through to the mdtuuid - * check below. */ - if (!param->mdtuuid) - goto obd_matches; - } else { - goto decided; - } - } - if (param->mdtuuid) { - if (check_mdt_match(param)) - goto obd_matches; - goto decided; - } - } obd_matches: - if (param->check_uid) { - if (st->st_uid == param->uid) { - if (param->exclude_uid) - goto decided; - } else { - if (!param->exclude_uid) - goto decided; - } - } + if (param->fp_check_uid) { + if (st->st_uid == param->fp_uid) { + if (param->fp_exclude_uid) + goto decided; + } else { + if (!param->fp_exclude_uid) + goto decided; + } + } - if (param->check_gid) { - if (st->st_gid == param->gid) { - if (param->exclude_gid) - goto decided; - } else { - if (!param->exclude_gid) - goto decided; - } - } + if (param->fp_check_gid) { + if (st->st_gid == param->fp_gid) { + if (param->fp_exclude_gid) + goto decided; + } else { + if (!param->fp_exclude_gid) + goto decided; + } + } - if (param->check_pool) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; - - /* empty requested pool is taken as no pool search => V1 */ - if (((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && - (param->poolname[0] == '\0')) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strncmp(lmmv3->lmm_pool_name, - param->poolname, LOV_MAXPOOLNAME) == 0)) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strcmp(param->poolname, "*") == 0))) { - if (param->exclude_pool) - goto decided; - } else { - if (!param->exclude_pool) - goto decided; - } - } + if (param->fp_check_pool) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + + /* empty requested pool is taken as no pool search => V1 */ + if (((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && + (param->fp_poolname[0] == '\0')) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strncmp(lmmv3->lmm_pool_name, + param->fp_poolname, LOV_MAXPOOLNAME) == 0)) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strcmp(param->fp_poolname, "*") == 0))) { + if (param->fp_exclude_pool) + goto decided; + } else { + if (!param->fp_exclude_pool) + goto decided; + } + } - /* Check the time on mds. */ - decision = 1; - if (param->atime || param->ctime || param->mtime) { + /* Check the time on mds. */ + decision = 1; + if (param->fp_atime || param->fp_mtime || param->fp_ctime) { int for_mds; - for_mds = lustre_fs ? (S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) - : 0; + for_mds = lustre_fs ? (S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) + : 0; decision = find_time_check(st, param, for_mds); if (decision == -1) goto decided; @@ -2893,30 +3189,29 @@ obd_matches: The regular stat is almost of the same speed as some new 'glimpse-size-ioctl'. */ - if (param->check_size && S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) + if (param->fp_check_size && S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) decision = 0; - while (!decision) { + if (param->fp_check_size && S_ISDIR(st->st_mode)) + decision = 0; + + if (!decision) { /* For regular files with the stripe the decision may have not * been taken yet if *time or size is to be checked. */ - LASSERT((S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) || - param->mdtindex != OBD_NOT_FOUND); - - if (param->obdindex != OBD_NOT_FOUND) + if (param->fp_obd_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LOV); - if (param->mdtindex != OBD_NOT_FOUND) + if (param->fp_mdt_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LMV); - if (dir) { - ret = ioctl(dirfd(dir), IOC_LOV_GETINFO, - (void *)param->lmd); - } else if (parent) { - ret = ioctl(dirfd(parent), IOC_LOV_GETINFO, - (void *)param->lmd); - } + if (dir != NULL) + ret = fstat_f(dirfd(dir), st); + else if (de != NULL) + ret = fstatat_f(dirfd(parent), de->d_name, st, + AT_SYMLINK_NOFOLLOW); + else + ret = lstat_f(path, st); if (ret) { if (errno == ENOENT) { @@ -2937,18 +3232,17 @@ obd_matches: decision = find_time_check(st, param, 0); if (decision == -1) goto decided; - - break; } - if (param->check_size) - decision = find_value_cmp(st->st_size, param->size, - param->size_sign, param->exclude_size, - param->size_units, 0); + if (param->fp_check_size) + decision = find_value_cmp(st->st_size, param->fp_size, + param->fp_size_sign, + param->fp_exclude_size, + param->fp_size_units, 0); if (decision != -1) { llapi_printf(LLAPI_MSG_NORMAL, "%s", path); - if (param->zeroend) + if (param->fp_zero_end) llapi_printf(LLAPI_MSG_NORMAL, "%c", '\0'); else llapi_printf(LLAPI_MSG_NORMAL, "\n"); @@ -2956,11 +3250,90 @@ obd_matches: decided: /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; +} + +static int cb_mv_init(char *path, DIR *parent, DIR **dirp, + void *param_data, struct dirent64 *de) +{ + struct find_param *param = (struct find_param *)param_data; + DIR *dir = parent; + char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; + char *rawbuf = raw; + struct obd_ioctl_data data = { 0 }; + int fd; + int ret; + char *filename; + + LASSERT(parent != NULL || dirp != NULL); + if (dirp != NULL) + closedir(*dirp); + + if (parent == NULL) { + dir = opendir_parent(path); + if (dir == NULL) { + *dirp = NULL; + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "can not open %s", path); + return ret; + } + } + + fd = dirfd(dir); + + filename = basename(path); + data.ioc_inlbuf1 = (char *)filename; + data.ioc_inllen1 = strlen(filename) + 1; + data.ioc_inlbuf2 = (char *)¶m->fp_mdt_index; + data.ioc_inllen2 = sizeof(param->fp_mdt_index); + ret = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + if (ret != 0) { + llapi_error(LLAPI_MSG_ERROR, ret, + "llapi_obd_statfs: error packing ioctl data"); + goto out; + } + + ret = ioctl(fd, LL_IOC_MIGRATE, rawbuf); + if (ret != 0) { + ret = -errno; + fprintf(stderr, "%s migrate failed %d\n", path, ret); + goto out; + } else if (param->fp_verbose & VERBOSE_DETAIL) { + fprintf(stdout, "migrate %s to MDT%d\n", + path, param->fp_mdt_index); + } + +out: + if (dirp != NULL) { + /* If the directory is being migration, we need + * close the directory after migration, + * so the old directory cache will be cleanup + * on the client side, and re-open to get the + * new directory handle */ + *dirp = opendir(path); + if (dirp == NULL) { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: Failed to open '%s'", __func__, path); + return ret; + } + } + + if (parent == NULL) + closedir(dir); + + return ret; +} + +int llapi_mv(char *path, struct find_param *param) +{ + return param_callback(path, cb_mv_init, cb_common_fini, param); } int llapi_find(char *path, struct find_param *param) @@ -2980,111 +3353,104 @@ int llapi_file_fget_mdtidx(int fd, int *mdtidx) return 0; } -static int cb_get_mdt_index(char *path, DIR *parent, DIR *d, void *data, +static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { - struct find_param *param = (struct find_param *)data; - int ret = 0; - int mdtidx; + struct find_param *param = (struct find_param *)data; + DIR *d = dirp == NULL ? NULL : *dirp; + int ret; + int mdtidx; - LASSERT(parent != NULL || d != NULL); + LASSERT(parent != NULL || d != NULL); - if (d) { - ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); - } else if (parent) { - int fd; + if (d != NULL) { + ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); + } else /* if (parent) */ { + int fd; - fd = open(path, O_RDONLY); - if (fd > 0) { - ret = llapi_file_fget_mdtidx(fd, &mdtidx); - close(fd); - } else { - ret = -errno; - } - } + fd = open(path, O_RDONLY | O_NOCTTY); + if (fd > 0) { + ret = llapi_file_fget_mdtidx(fd, &mdtidx); + close(fd); + } else { + ret = -errno; + } + } - if (ret) { - if (ret == -ENODATA) { - if (!param->obduuid) - llapi_printf(LLAPI_MSG_NORMAL, - "%s has no stripe info\n", path); - goto out; - } else if (ret == -ENOENT) { - llapi_error(LLAPI_MSG_WARN, ret, - "warning: %s: %s does not exist", - __func__, path); - goto out; - } else if (ret == -ENOTTY) { - llapi_error(LLAPI_MSG_ERROR, ret, - "%s: '%s' not on a Lustre fs?", - __func__, path); - } else { - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: LL_IOC_GET_MDTIDX failed for %s", - __func__, path); - } - return ret; - } + if (ret != 0) { + if (ret == -ENODATA) { + if (!param->fp_obd_uuid) + llapi_printf(LLAPI_MSG_NORMAL, + "'%s' has no stripe info\n", path); + goto out; + } else if (ret == -ENOENT) { + llapi_error(LLAPI_MSG_WARN, ret, + "warning: %s: '%s' does not exist", + __func__, path); + goto out; + } else if (ret == -ENOTTY) { + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: '%s' not on a Lustre fs", + __func__, path); + } else { + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: '%s' failed get_mdtidx", + __func__, path); + } + return ret; + } - /* The 'LASSERT(parent != NULL || d != NULL);' guarantees - * that either 'd' or 'parent' is not null. - * So in all cases llapi_file_fget_mdtidx() is called, - * thus initializing 'mdtidx'. */ - if (param->quiet || !(param->verbose & VERBOSE_DETAIL)) - /* coverity[uninit_use_in_call] */ - llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx); - else - /* coverity[uninit_use_in_call] */ - llapi_printf(LLAPI_MSG_NORMAL, "%s\nmdt_index:\t%d\n", - path, mdtidx); + if (param->fp_quiet || !(param->fp_verbose & VERBOSE_DETAIL)) + llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx); + else + llapi_printf(LLAPI_MSG_NORMAL, "%s\nmdt_index:\t%d\n", + path, mdtidx); out: - /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + /* Do not go down anymore? */ + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; } -static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, +static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { struct find_param *param = (struct find_param *)data; + DIR *d = dirp == NULL ? NULL : *dirp; int ret = 0; LASSERT(parent != NULL || d != NULL); - if (param->obduuid) { - param->quiet = 1; + if (param->fp_obd_uuid) { + param->fp_quiet = 1; ret = setup_obd_uuid(d ? d : parent, path, param); if (ret) return ret; } if (d) { - if (param->get_lmv) { + if (param->fp_get_lmv || param->fp_get_default_lmv) { ret = cb_get_dirstripe(path, d, param); } else { ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); } - } else if (parent) { + } else if (parent && !param->fp_get_lmv && !param->fp_get_default_lmv) { char *fname = strrchr(path, '/'); fname = (fname == NULL ? path : fname + 1); - if (param->get_lmv) { - llapi_printf(LLAPI_MSG_NORMAL, - "%s get dirstripe information for file\n", - path); - goto out; - } - - strncpy((char *)¶m->lmd->lmd_lmm, fname, param->lumlen); + strlcpy((char *)¶m->fp_lmd->lmd_lmm, fname, + param->fp_lum_size); ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); + } else { + return 0; } if (ret) { @@ -3095,17 +3461,39 @@ static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, * a check later on in the code path. * The object_seq needs to be set for the "(Default)" * prefix to be displayed. */ - struct lov_user_md *lmm = ¶m->lmd->lmd_lmm; - lmm->lmm_magic = LOV_MAGIC_V1; - if (!param->raw) - ostid_set_seq(&lmm->lmm_oi, - FID_SEQ_LOV_DEFAULT); - lmm->lmm_stripe_count = 0; - lmm->lmm_stripe_size = 0; - lmm->lmm_stripe_offset = -1; - goto dump; + if (param->fp_get_default_lmv) { + struct lmv_user_md *lum = param->fp_lmv_md; + + lum->lum_magic = LMV_USER_MAGIC; + lum->lum_stripe_count = 0; + lum->lum_stripe_offset = -1; + goto dump; + } else if (param->fp_get_lmv) { + struct lmv_user_md *lum = param->fp_lmv_md; + int mdtidx; + + ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); + if (ret != 0) + goto err_out; + lum->lum_magic = LMV_MAGIC_V1; + lum->lum_stripe_count = 0; + lum->lum_stripe_offset = mdtidx; + goto dump; + } else { + struct lov_user_md *lmm = + ¶m->fp_lmd->lmd_lmm; + + lmm->lmm_magic = LOV_USER_MAGIC_V1; + if (!param->fp_raw) + ostid_set_seq(&lmm->lmm_oi, + FID_SEQ_LOV_DEFAULT); + lmm->lmm_stripe_count = 0; + lmm->lmm_stripe_size = 0; + lmm->lmm_stripe_offset = -1; + goto dump; + } } else if (errno == ENODATA && parent != NULL) { - if (!param->obduuid && !param->mdtuuid) + if (!param->fp_obd_uuid && !param->fp_mdt_uuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; @@ -3121,31 +3509,33 @@ static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, __func__, path); } else { ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: %s failed for %s", - __func__, d ? "LL_IOC_LOV_GETSTRIPE" : - "IOC_MDC_GETFILESTRIPE", path); - } +err_out: + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: %s failed for %s", + __func__, d ? "LL_IOC_LOV_GETSTRIPE" : + "IOC_MDC_GETFILESTRIPE", path); + } return ret; } dump: - if (!(param->verbose & VERBOSE_MDTINDEX)) + if (!(param->fp_verbose & VERBOSE_MDTINDEX)) llapi_lov_dump_user_lmm(param, path, d ? 1 : 0); out: - /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + /* Do not get down anymore? */ + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; } int llapi_getstripe(char *path, struct find_param *param) { - return param_callback(path, (param->verbose & VERBOSE_MDTINDEX) ? + return param_callback(path, (param->fp_verbose & VERBOSE_MDTINDEX) ? cb_get_mdt_index : cb_getstripe, cb_common_fini, param); } @@ -3180,18 +3570,20 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, if (errno == EISDIR) fd = open(path, O_DIRECTORY | O_RDONLY); - if (fd < 0) { - rc = errno ? -errno : -EBADF; - llapi_error(LLAPI_MSG_ERROR, rc, "error: %s: opening '%s'", - __func__, path); - return rc; - } - rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf); - if (rc) - rc = errno ? -errno : -EINVAL; + if (fd < 0) { + rc = errno ? -errno : -EBADF; + llapi_error(LLAPI_MSG_ERROR, rc, "error: %s: opening '%s'", + __func__, path); + /* If we can't even open a file on the filesystem (e.g. with + * -ESHUTDOWN), force caller to exit or it will loop forever. */ + return -ENODEV; + } + rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf); + if (rc) + rc = errno ? -errno : -EINVAL; - close(fd); - return rc; + close(fd); + return rc; } #define MAX_STRING_SIZE 128 @@ -3313,7 +3705,7 @@ int llapi_quotacheck(char *mnt, int check_type) return rc; } - rc = ioctl(dirfd(root), LL_IOC_QUOTACHECK, check_type); + rc = ioctl(dirfd(root), OBD_IOC_QUOTACHECK, check_type); if (rc < 0) rc = -errno; @@ -3335,7 +3727,7 @@ int llapi_poll_quotacheck(char *mnt, struct if_quotacheck *qchk) } while (1) { - rc = ioctl(dirfd(root), LL_IOC_POLL_QUOTACHECK, qchk); + rc = ioctl(dirfd(root), OBD_IOC_POLL_QUOTACHECK, qchk); if (!rc) break; sleep(poll_intvl); @@ -3359,7 +3751,7 @@ int llapi_quotactl(char *mnt, struct if_quotactl *qctl) return rc; } - rc = ioctl(dirfd(root), LL_IOC_QUOTACTL, qctl); + rc = ioctl(dirfd(root), OBD_IOC_QUOTACTL, qctl); if (rc < 0) rc = -errno; @@ -3367,19 +3759,20 @@ int llapi_quotactl(char *mnt, struct if_quotactl *qctl) return rc; } -static int cb_quotachown(char *path, DIR *parent, DIR *d, void *data, +static int cb_quotachown(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { struct find_param *param = (struct find_param *)data; + DIR *d = dirp == NULL ? NULL : *dirp; lstat_t *st; int rc; LASSERT(parent != NULL || d != NULL); - rc = get_lmd_info(path, parent, d, param->lmd, param->lumlen); + rc = get_lmd_info(path, parent, d, param->fp_lmd, param->fp_lum_size); if (rc) { if (rc == -ENODATA) { - if (!param->obduuid && !param->quiet) + if (!param->fp_obd_uuid && !param->fp_quiet) llapi_error(LLAPI_MSG_ERROR, -ENODATA, "%s has no stripe info", path); rc = 0; @@ -3389,7 +3782,7 @@ static int cb_quotachown(char *path, DIR *parent, DIR *d, void *data, return rc; } - st = ¶m->lmd->lmd_st; + st = ¶m->fp_lmd->lmd_st; /* libc chown() will do extra check, and if the real owner is * the same as the ones to set, it won't fall into kernel, so @@ -3414,9 +3807,9 @@ int llapi_quotachown(char *path, int flag) struct find_param param; memset(¶m, 0, sizeof(param)); - param.recursive = 1; - param.verbose = 0; - param.quiet = 1; + param.fp_recursive = 1; + param.fp_verbose = 0; + param.fp_quiet = 1; return param_callback(path, cb_quotachown, NULL, ¶m); } @@ -3454,7 +3847,7 @@ static int rmtacl_notify(int ops) if (fd < 0) { rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, - "Can't open '%s'\n", mnt->mnt_dir); + "Can't open '%s'", mnt->mnt_dir); goto out; } @@ -3462,7 +3855,9 @@ static int rmtacl_notify(int ops) close(fd); if (rc < 0) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "ioctl %d\n", fd); + llapi_error(LLAPI_MSG_ERROR, rc, + "ioctl RMTACL on '%s' err %d", + mnt->mnt_dir, rc); goto out; } @@ -3626,14 +4021,14 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) if (output_func) { if (pipe(fd) < 0) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "Can't create pipe\n"); + llapi_error(LLAPI_MSG_ERROR, rc, "Can't create pipe"); return rc; } pid = fork(); if (pid < 0) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "Can't fork\n"); + llapi_error(LLAPI_MSG_ERROR, rc, "Can't fork"); close(fd[0]); close(fd[1]); return rc; @@ -3644,7 +4039,7 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) if (dup2(fd[1], 1) < 0) { rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, - "Can't dup2 %d\n", fd[1]); + "Can't dup2 %d", fd[1]); close(fd[1]); return rc; } @@ -3665,7 +4060,7 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) fp = fdopen(fd[0], "r"); if (fp == NULL) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "fdopen %d failed\n", fd[0]); + llapi_error(LLAPI_MSG_ERROR, rc, "fdopen %d failed", fd[0]); kill(pid, SIGKILL); close(fd[0]); return rc; @@ -3681,7 +4076,7 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) if (waitpid(pid, &status, 0) < 0) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "waitpid %d failed\n", pid); + llapi_error(LLAPI_MSG_ERROR, rc, "waitpid %d failed", pid); return rc; } @@ -3769,7 +4164,8 @@ int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp, { char fsname[20]; char *ptr; - int fd, index, rc; + int fd, rc; + long index; /* Take path, fsname, or MDTname. Assume MDT0000 in the former cases. Open root and parse mdt index. */ @@ -3825,9 +4221,9 @@ static int changelog_ioctl(const char *mdtname, int opc, int id, #define CHANGELOG_PRIV_MAGIC 0xCA8E1080 struct changelog_private { - int magic; - int flags; - lustre_kernelcomm kuc; + int magic; + enum changelog_send_flag flags; + lustre_kernelcomm kuc; }; /** Start reading from a changelog @@ -3837,44 +4233,53 @@ struct changelog_private { * @param startrec Report changes beginning with this record number * (just call llapi_changelog_fini when done; don't need an endrec) */ -int llapi_changelog_start(void **priv, int flags, const char *device, - long long startrec) +int llapi_changelog_start(void **priv, enum changelog_send_flag flags, + const char *device, long long startrec) { - struct changelog_private *cp; - int rc; + struct changelog_private *cp; + static bool warned; + int rc; - /* Set up the receiver control struct */ - cp = calloc(1, sizeof(*cp)); - if (cp == NULL) - return -ENOMEM; + /* Set up the receiver control struct */ + cp = calloc(1, sizeof(*cp)); + if (cp == NULL) + return -ENOMEM; - cp->magic = CHANGELOG_PRIV_MAGIC; - cp->flags = flags; + cp->magic = CHANGELOG_PRIV_MAGIC; + cp->flags = flags; - /* Set up the receiver */ - rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */); - if (rc < 0) - goto out_free; + /* Set up the receiver */ + rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */, 0); + if (rc < 0) + goto out_free; - *priv = cp; + *priv = cp; - /* Tell the kernel to start sending */ - rc = changelog_ioctl(device, OBD_IOC_CHANGELOG_SEND, cp->kuc.lk_wfd, - startrec, flags); - /* Only the kernel reference keeps the write side open */ - close(cp->kuc.lk_wfd); - cp->kuc.lk_wfd = 0; - if (rc < 0) { - /* frees and clears priv */ - llapi_changelog_fini(priv); - return rc; - } + /* CHANGELOG_FLAG_JOBID will eventually become mandatory. Display a + * warning if it's missing. */ + if (!(flags & CHANGELOG_FLAG_JOBID) && !warned) { + llapi_err_noerrno(LLAPI_MSG_WARN, "warning: %s() called " + "w/o CHANGELOG_FLAG_JOBID", __func__); + warned = true; + } - return 0; + /* Tell the kernel to start sending */ + rc = changelog_ioctl(device, OBD_IOC_CHANGELOG_SEND, cp->kuc.lk_wfd, + startrec, flags); + /* Only the kernel reference keeps the write side open */ + close(cp->kuc.lk_wfd); + cp->kuc.lk_wfd = LK_NOFD; + if (rc < 0) { + /* frees and clears priv */ + llapi_changelog_fini(priv); + return rc; + } + + return 0; out_free: - free(cp); - return rc; + free(cp); + return rc; } /** Finish reading from a changelog */ @@ -3891,24 +4296,15 @@ int llapi_changelog_fini(void **priv) return 0; } -/** Convert a changelog_rec to changelog_ext_rec, in this way client can treat - * all records in the format of changelog_ext_rec, this can make record - * analysis simpler. +/** + * Convert all records to a same format according to the caller's wishes. + * Default is CLF_VERSION | CLF_RENAME. + * Add CLF_JOBID if explicitely requested. + * + * \param rec The record to remap. It is expected to be big enough to + * properly handle the final format. + * \return 1 if anything changed. 0 otherwise. */ -static inline int changelog_extend_rec(struct changelog_ext_rec *ext) -{ - if (!CHANGELOG_REC_EXTENDED(ext)) { - struct changelog_rec *rec = (struct changelog_rec *)ext; - - memmove(ext->cr_name, rec->cr_name, rec->cr_namelen); - fid_zero(&ext->cr_sfid); - fid_zero(&ext->cr_spfid); - return 1; - } - - return 0; -} - /** Read the next changelog entry * @param priv Opaque private control structure * @param rech Changelog record handle; record will be allocated here @@ -3916,26 +4312,31 @@ static inline int changelog_extend_rec(struct changelog_ext_rec *ext) * <0 error code * 1 EOF */ -int llapi_changelog_recv(void *priv, struct changelog_ext_rec **rech) +#define DEFAULT_RECORD_FMT (CLF_VERSION | CLF_RENAME) +int llapi_changelog_recv(void *priv, struct changelog_rec **rech) { - struct changelog_private *cp = (struct changelog_private *)priv; - struct kuc_hdr *kuch; - int rc = 0; + struct changelog_private *cp = (struct changelog_private *)priv; + struct kuc_hdr *kuch; + enum changelog_rec_flags rec_fmt = DEFAULT_RECORD_FMT; + int rc = 0; + + if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) + return -EINVAL; + if (rech == NULL) + return -EINVAL; + kuch = malloc(KUC_CHANGELOG_MSG_MAXSIZE); + if (kuch == NULL) + return -ENOMEM; - if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) - return -EINVAL; - if (rech == NULL) - return -EINVAL; - kuch = malloc(CR_MAXSIZE + sizeof(*kuch)); - if (kuch == NULL) - return -ENOMEM; + if (cp->flags & CHANGELOG_FLAG_JOBID) + rec_fmt |= CLF_JOBID; repeat: - rc = libcfs_ukuc_msg_get(&cp->kuc, (char *)kuch, - CR_MAXSIZE + sizeof(*kuch), - KUC_TRANSPORT_CHANGELOG); - if (rc < 0) - goto out_free; + rc = libcfs_ukuc_msg_get(&cp->kuc, (char *)kuch, + KUC_CHANGELOG_MSG_MAXSIZE, + KUC_TRANSPORT_CHANGELOG); + if (rc < 0) + goto out_free; if ((kuch->kuc_transport != KUC_TRANSPORT_CHANGELOG) || ((kuch->kuc_msgtype != CL_RECORD) && @@ -3957,11 +4358,10 @@ repeat: } } - /* Our message is a changelog_ext_rec. Use pointer math to skip - * kuch_hdr and point directly to the message payload. - */ - *rech = (struct changelog_ext_rec *)(kuch + 1); - changelog_extend_rec(*rech); + /* Our message is a changelog_rec. Use pointer math to skip + * kuch_hdr and point directly to the message payload. */ + *rech = (struct changelog_rec *)(kuch + 1); + changelog_remap_rec(*rech, rec_fmt); return 0; @@ -3972,7 +4372,7 @@ out_free: } /** Release the changelog record when done with it. */ -int llapi_changelog_free(struct changelog_ext_rec **rech) +int llapi_changelog_free(struct changelog_rec **rech) { if (*rech) { /* We allocated memory starting at the kuc_hdr, but passed @@ -3989,7 +4389,7 @@ int llapi_changelog_free(struct changelog_ext_rec **rech) int llapi_changelog_clear(const char *mdtname, const char *idstr, long long endrec) { - int id; + long id; if (endrec < 0) { llapi_err_noerrno(LLAPI_MSG_ERROR, @@ -4042,9 +4442,13 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, if (rc != -ENOENT) llapi_error(LLAPI_MSG_ERROR, rc, "ioctl err %d", rc); } else { - memcpy(buf, gf->gf_path, gf->gf_pathlen); - *recno = gf->gf_recno; - *linkno = gf->gf_linkno; + memcpy(buf, gf->gf_path, gf->gf_pathlen); + if (buf[0] == '\0') { /* ROOT path */ + buf[0] = '/'; + buf[1] = '\0'; + } + *recno = gf->gf_recno; + *linkno = gf->gf_linkno; } free(gf); @@ -4068,6 +4472,20 @@ static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) return 0; } +int llapi_get_mdt_index_by_fid(int fd, const lustre_fid *fid, + int *mdt_index) +{ + int rc; + + rc = ioctl(fd, LL_IOC_FID2MDTIDX, fid); + if (rc < 0) + return -errno; + + *mdt_index = rc; + + return rc; +} + int llapi_fd2fid(const int fd, lustre_fid *fid) { int rc; @@ -4101,6 +4519,50 @@ int llapi_path2fid(const char *path, lustre_fid *fid) return rc; } +int llapi_fd2parent(int fd, unsigned int linkno, lustre_fid *parent_fid, + char *name, size_t name_size) +{ + struct getparent *gp; + int rc; + + gp = malloc(sizeof(*gp) + name_size); + if (gp == NULL) + return -ENOMEM; + + gp->gp_linkno = linkno; + gp->gp_name_size = name_size; + + rc = ioctl(fd, LL_IOC_GETPARENT, gp); + if (rc < 0) { + rc = -errno; + goto err_free; + } + + *parent_fid = gp->gp_fid; + + strncpy(name, gp->gp_name, name_size); + name[name_size - 1] = '\0'; + +err_free: + free(gp); + return rc; +} + +int llapi_path2parent(const char *path, unsigned int linkno, + lustre_fid *parent_fid, char *name, size_t name_size) +{ + int fd; + int rc; + + fd = open(path, O_RDONLY | O_NONBLOCK | O_NOFOLLOW); + if (fd < 0) + return -errno; + + rc = llapi_fd2parent(fd, linkno, parent_fid, name, name_size); + close(fd); + return rc; +} + int llapi_get_connect_flags(const char *mnt, __u64 *flags) { DIR *root; @@ -4158,9 +4620,12 @@ int llapi_get_version(char *buffer, int buffer_size, * this value to verify if file data was modified. This only checks the file * data, not metadata. * - * \param flags If set to LL_DV_NOFLUSH, the data version will be read - * directly from OST without regard to possible dirty cache on - * client nodes. + * \param flags 0: no flush pages, usually used it the process has already + * taken locks; + * LL_DV_RD_FLUSH: OSTs will take LCK_PR to flush dirty pages + * from clients; + * LL_DV_WR_FLUSH: OSTs will take LCK_PW to flush all caching + * pages from clients. * * \retval 0 on success. * \retval -errno on error. @@ -4182,55 +4647,59 @@ int llapi_get_data_version(int fd, __u64 *data_version, __u64 flags) } /* - * Create a volatile file and open it for write: - * - file is created as a standard file in the directory - * - file does not appears in directory and directory mtime does not change - * - file is removed at close - * - file modes are rw-------, if user wants another one it must use fchmod() - * \param directory Directory where the file is created - * \param idx MDT index on which the file is created - * \param flags Std open flags + * Create a file without any name open it for read/write + * + * - file is created as if it were a standard file in the given \a directory + * - file does not appear in \a directory and mtime does not change because + * the filename is handled specially by the Lustre MDS. + * - file is removed at final close + * - file modes are rw------- since it doesn't make sense to have a read-only + * or write-only file that cannot be opened again. + * - if user wants another mode it must use fchmod() on the open file, no + * security problems arise because it cannot be opened by another process. + * + * \param[in] directory directory from which to inherit layout/MDT idx + * \param[in] idx MDT index on which the file is created, + * \a idx == -1 means no specific MDT is requested + * \param[in] open_flags standard open(2) flags * * \retval 0 on success. * \retval -errno on error. */ -int llapi_create_volatile_idx(char *directory, int idx, int mode) +int llapi_create_volatile_idx(char *directory, int idx, int open_flags) { char file_path[PATH_MAX]; char filename[PATH_MAX]; int fd; - int random; + int rnumber; int rc; - fd = open("/dev/urandom", O_RDONLY); - if (fd < 0) { - llapi_error(LLAPI_MSG_ERROR, errno, - "Cannot open /dev/urandom\n"); - return -errno; - } - rc = read(fd, &random, sizeof(random)); - close(fd); - if (rc < sizeof(random)) { - llapi_error(LLAPI_MSG_ERROR, errno, - "Cannot read %d bytes from /dev/urandom\n", - sizeof(random)); - return -errno; - } + rnumber = random(); if (idx == -1) - sprintf(filename, LUSTRE_VOLATILE_HDR"::%.4X", random); + snprintf(filename, sizeof(filename), + LUSTRE_VOLATILE_HDR"::%.4X", rnumber); else - sprintf(filename, LUSTRE_VOLATILE_IDX"%.4X", 0, random); + snprintf(filename, sizeof(filename), + LUSTRE_VOLATILE_HDR":%.4X:%.4X", idx, rnumber); - sprintf(file_path, "%s/%s", directory, filename); + rc = snprintf(file_path, sizeof(file_path), + "%s/%s", directory, filename); + if (rc >= sizeof(file_path)) + return -E2BIG; - fd = open(file_path, O_RDWR|O_CREAT|mode, S_IRUSR|S_IWUSR); + fd = open(file_path, O_RDWR | O_CREAT | open_flags, S_IRUSR | S_IWUSR); if (fd < 0) { llapi_error(LLAPI_MSG_ERROR, errno, - "Cannot create volatile file %s in %s\n", + "Cannot create volatile file '%s' in '%s'", filename + LUSTRE_VOLATILE_HDR_LEN, directory); return -errno; } + /* unlink file in case this wasn't a Lustre filesystem, and the + * magic volatile filename wasn't handled as intended. The effect + * is the same. */ + unlink(file_path); + return fd; } @@ -4242,13 +4711,16 @@ int llapi_create_volatile_idx(char *directory, int idx, int mode) */ int llapi_fswap_layouts(int fd1, int fd2, __u64 dv1, __u64 dv2, __u64 flags) { - struct lustre_swap_layouts lsl; - int rc; + struct lustre_swap_layouts lsl; + int rc; - srandom(time(NULL)); lsl.sl_fd = fd2; lsl.sl_flags = flags; - lsl.sl_gid = random(); + + do + lsl.sl_gid = random(); + while (lsl.sl_gid == 0); + lsl.sl_dv1 = dv1; lsl.sl_dv2 = dv2; rc = ioctl(fd1, LL_IOC_LOV_SWAP_LAYOUTS, &lsl); @@ -4268,28 +4740,96 @@ int llapi_swap_layouts(const char *path1, const char *path2, fd1 = open(path1, O_WRONLY | O_LOV_DELAY_CREATE); if (fd1 < 0) { - llapi_error(LLAPI_MSG_ERROR, -errno, - "error: cannot open for write %s", - path1); - return -errno; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error: cannot open '%s' for write", path1); + goto out; } fd2 = open(path2, O_WRONLY | O_LOV_DELAY_CREATE); if (fd2 < 0) { - llapi_error(LLAPI_MSG_ERROR, -errno, - "error: cannot open for write %s", - path2); - close(fd1); - return -errno; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error: cannot open '%s' for write", path2); + goto out_close; } rc = llapi_fswap_layouts(fd1, fd2, dv1, dv2, flags); if (rc < 0) llapi_error(LLAPI_MSG_ERROR, rc, - "error: cannot swap layouts between %s and %s\n", - path1, path2); + "error: cannot swap layout between '%s' and '%s'", + path1, path2); - close(fd1); close(fd2); +out_close: + close(fd1); +out: + return rc; +} + +/** + * Attempt to open a file with Lustre file identifier \a fid + * and return an open file descriptor. + * + * \param[in] lustre_dir path within Lustre filesystem containing \a fid + * \param[in] fid Lustre file identifier of file to open + * \param[in] flags open() flags + * + * \retval non-negative file descriptor on successful open + * \retval -1 if an error occurred + */ +int llapi_open_by_fid(const char *lustre_dir, const lustre_fid *fid, int flags) +{ + char mntdir[PATH_MAX]; + char path[PATH_MAX]; + int rc; + + rc = llapi_search_mounts(lustre_dir, 0, mntdir, NULL); + if (rc != 0) + return -1; + + snprintf(path, sizeof(path), "%s/.lustre/fid/"DFID, mntdir, PFID(fid)); + return open(path, flags); +} + +/** + * Take group lock. + * + * \param fd File to lock. + * \param gid Group Identifier. + * + * \retval 0 on success. + * \retval -errno on failure. + */ +int llapi_group_lock(int fd, int gid) +{ + int rc; + + rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot get group lock"); + } + return rc; +} + +/** + * Put group lock. + * + * \param fd File to unlock. + * \param gid Group Identifier. + * + * \retval 0 on success. + * \retval -errno on failure. + */ +int llapi_group_unlock(int fd, int gid) +{ + int rc; + + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot put group lock"); + } return rc; }