X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=bb1bf984ee0f6dbe3d850f9aee3fa6f3ba45dcbd;hp=1f9c35f980723902ea4d714ab3f19629fa65be22;hb=363e287ac9e8d07287d117ae4e85afb1015deca0;hpb=c919cdf5d960da9f3b78fd2c04b7e09ef915d3c6 diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 1f9c35f..bb1bf98 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2015, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -45,6 +41,7 @@ #define _GNU_SOURCE #endif +#include #include #include #include @@ -58,11 +55,12 @@ #include #include #include -#include #include +#include +#include #include +#include #include -#include #include /* for dirname() */ #ifdef HAVE_LINUX_UNISTD_H #include @@ -70,14 +68,23 @@ #include #endif #include +#include +#include +#include #include -#include +#include #include -#include +#include +#include #include "lustreapi_internal.h" static int llapi_msg_level = LLAPI_MSG_MAX; +const char *liblustreapi_cmd; + +char *mdt_hash_name[] = { "none", + LMV_HASH_NAME_ALL_CHARS, + LMV_HASH_NAME_FNV_1A_64 }; void llapi_msg_set_level(int level) { @@ -95,9 +102,24 @@ int llapi_msg_get_level(void) return llapi_msg_level; } +void llapi_set_command_name(const char *cmd) +{ + liblustreapi_cmd = cmd; +} + +void llapi_clear_command_name(void) +{ + liblustreapi_cmd = NULL; +} + static void error_callback_default(enum llapi_message_level level, int err, const char *fmt, va_list ap) { + if (liblustreapi_cmd != NULL) + fprintf(stderr, "%s %s: ", program_invocation_short_name, + liblustreapi_cmd); + else + fprintf(stderr, "%s: ", program_invocation_short_name); vfprintf(stderr, fmt, ap); if (level & LLAPI_MSG_NO_ERRNO) fprintf(stderr, "\n"); @@ -108,6 +130,15 @@ static void error_callback_default(enum llapi_message_level level, int err, static void info_callback_default(enum llapi_message_level level, int err, const char *fmt, va_list ap) { + if (err != 0) { + if (liblustreapi_cmd != NULL) { + fprintf(stdout, "%s %s: ", + program_invocation_short_name, + liblustreapi_cmd); + } else { + fprintf(stdout, "%s: ", program_invocation_short_name); + } + } vfprintf(stdout, fmt, ap); } @@ -250,6 +281,96 @@ int llapi_parse_size(const char *optarg, unsigned long long *size, return 0; } +int llapi_ioctl_pack(struct obd_ioctl_data *data, char **pbuf, int max_len) +{ + struct obd_ioctl_data *overlay; + char *ptr; + + data->ioc_len = obd_ioctl_packlen(data); + data->ioc_version = OBD_IOCTL_VERSION; + + if (*pbuf != NULL && data->ioc_len > max_len) { + llapi_error(LLAPI_MSG_ERROR, -EINVAL, + "pbuf = %p, ioc_len = %u, max_len = %d\n", + *pbuf, data->ioc_len, max_len); + return -EINVAL; + } + + if (*pbuf == NULL) + *pbuf = malloc(data->ioc_len); + + if (*pbuf == NULL) + return -ENOMEM; + + overlay = (struct obd_ioctl_data *)*pbuf; + memcpy(*pbuf, data, sizeof(*data)); + + ptr = overlay->ioc_bulk; + if (data->ioc_inlbuf1) { + memcpy(ptr, data->ioc_inlbuf1, data->ioc_inllen1); + ptr += __ALIGN_KERNEL(data->ioc_inllen1, 8); + } + + if (data->ioc_inlbuf2) { + memcpy(ptr, data->ioc_inlbuf2, data->ioc_inllen2); + ptr += __ALIGN_KERNEL(data->ioc_inllen2, 8); + } + + if (data->ioc_inlbuf3) { + memcpy(ptr, data->ioc_inlbuf3, data->ioc_inllen3); + ptr += __ALIGN_KERNEL(data->ioc_inllen3, 8); + } + + if (data->ioc_inlbuf4) { + memcpy(ptr, data->ioc_inlbuf4, data->ioc_inllen4); + ptr += __ALIGN_KERNEL(data->ioc_inllen4, 8); + } + + return 0; +} + +int llapi_ioctl_unpack(struct obd_ioctl_data *data, char *pbuf, int max_len) +{ + struct obd_ioctl_data *overlay; + char *ptr; + + if (pbuf == NULL) + return 1; + + overlay = (struct obd_ioctl_data *)pbuf; + + /* Preserve the caller's buffer pointers */ + overlay->ioc_inlbuf1 = data->ioc_inlbuf1; + overlay->ioc_inlbuf2 = data->ioc_inlbuf2; + overlay->ioc_inlbuf3 = data->ioc_inlbuf3; + overlay->ioc_inlbuf4 = data->ioc_inlbuf4; + + memcpy(data, pbuf, sizeof(*data)); + + ptr = overlay->ioc_bulk; + if (data->ioc_inlbuf1) { + memcpy(data->ioc_inlbuf1, ptr, data->ioc_inllen1); + ptr += __ALIGN_KERNEL(data->ioc_inllen1, 8); + } + + if (data->ioc_inlbuf2) { + memcpy(data->ioc_inlbuf2, ptr, data->ioc_inllen2); + ptr += __ALIGN_KERNEL(data->ioc_inllen2, 8); + } + + if (data->ioc_inlbuf3) { + memcpy(data->ioc_inlbuf3, ptr, data->ioc_inllen3); + ptr += __ALIGN_KERNEL(data->ioc_inllen3, 8); + } + + if (data->ioc_inlbuf4) { + memcpy(data->ioc_inlbuf4, ptr, data->ioc_inllen4); + ptr += __ALIGN_KERNEL(data->ioc_inllen4, 8); + } + + return 0; +} + /* XXX: llapi_xxx() functions return negative values upon failure */ int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, @@ -296,65 +417,31 @@ int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, return 0; } -/* return the first file matching this pattern */ -static int first_match(char *pattern, char *buffer) -{ - glob_t glob_info; - - if (glob(pattern, GLOB_BRACE, NULL, &glob_info)) - return -ENOENT; - - if (glob_info.gl_pathc < 1) { - globfree(&glob_info); - return -ENOENT; - } - - strcpy(buffer, glob_info.gl_pathv[0]); - - globfree(&glob_info); - return 0; -} - -static int find_target_obdpath(char *fsname, char *path) -{ - glob_t glob_info; - char pattern[PATH_MAX + 1]; - int rc; - - snprintf(pattern, PATH_MAX, - "/proc/fs/lustre/lov/%s-*/target_obd", - fsname); - rc = glob(pattern, GLOB_BRACE, NULL, &glob_info); - if (rc == GLOB_NOMATCH) - return -ENODEV; - else if (rc) - return -EINVAL; - - strcpy(path, glob_info.gl_pathv[0]); - globfree(&glob_info); - return 0; -} - -static int find_poolpath(char *fsname, char *poolname, char *poolpath) +int llapi_dir_stripe_limit_check(int stripe_offset, int stripe_count, + int hash_type) { - glob_t glob_info; - char pattern[PATH_MAX + 1]; - int rc; + int rc; - snprintf(pattern, PATH_MAX, - "/proc/fs/lustre/lov/%s-*/pools/%s", - fsname, poolname); - rc = glob(pattern, GLOB_BRACE, NULL, &glob_info); - /* If no pools, make sure the lov is available */ - if ((rc == GLOB_NOMATCH) && - (find_target_obdpath(fsname, poolpath) == -ENODEV)) - return -ENODEV; - if (rc) - return -EINVAL; + if (!llapi_dir_stripe_index_is_valid(stripe_offset)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe offset %d", + stripe_offset); + return rc; + } + if (!llapi_dir_stripe_count_is_valid(stripe_count)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe count %d", + stripe_count); + return rc; + } - strcpy(poolpath, glob_info.gl_pathv[0]); - globfree(&glob_info); - return 0; + if (!llapi_dir_hash_type_is_valid(hash_type)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad hash type %d", + hash_type); + return rc; + } + return 0; } /* @@ -375,200 +462,11 @@ int llapi_chomp_string(char *buf) return '\n'; } -/** - * return a parameter string for a specific device type or mountpoint - * - * \param param_path the path to the file containing parameter data - * \param result buffer for parameter value string - * \param result_size size of buffer for return value - * - * The \param param_path is appended to /proc/{fs,sys}/{lnet,lustre} to - * complete the absolute path to the file containing the parameter data - * the user is requesting. If that file exist then the data is read from - * the file and placed into the \param result buffer that is passed by - * the user. Data is only copied up to the \param result_size to prevent - * overflow of the array. - * - * Return 0 for success, with a NUL-terminated string in \param result. - * Return -ve value for error. - */ -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]; - FILE *fp = NULL; - int rc = 0; - - snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s", - param_path); - rc = first_match(pattern, file); - if (rc != 0 || result == NULL) - return rc; - - fp = fopen(file, "r"); - if (fp != NULL) { - while (fgets(buf, result_size, fp) != NULL) - strcpy(result, buf); - fclose(fp); - } else { - rc = -errno; - } - return rc; -} - -#define DEVICES_LIST "/proc/fs/lustre/devices" - -/** - * return a parameter string for a specific device type or mountpoint - * - * \param fsname Lustre filesystem name (optional) - * \param file_path path to file in filesystem (optional, if fsname unset) - * \param obd_type Lustre OBD device type - * \param param_name parameter name to fetch - * \param value return buffer for parameter value string - * \param val_len size of buffer for return value - * - * If fsname is specified then the parameter will be from that filesystem - * (if it exists). If file_path is given and it is in a mounted Lustre - * filesystem, then the parameter will be otherwise the value may be - * from any mounted filesystem (if there is more than one). - * - * If "obd_type" matches a Lustre device then the first matching device - * (as with "lctl dl", constrained by \param fsname or \param mount_path) - * will be used to provide the return value, otherwise the first such - * device found will be used. - * - * Return 0 for success, with a NUL-terminated string in \param buffer. - * Return -ve value for error. - */ -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]; - char dev[PATH_MAX] = "*"; - char fs[PATH_MAX]; - FILE *fp = NULL; - int rc = 0; - - fp = fopen(DEVICES_LIST, "r"); - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); - goto out; - } - - 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) - 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; - } - - tmp = strchr(dev, ' '); - if (tmp != NULL) - *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; - } - - fclose(fp); - return get_param(devices, value, val_len); -out: - if (fp != NULL) - fclose(fp); - return rc; -} - /* - * TYPE one of llite, lmv, lov. - * /proc/fs/lustre/TYPE/INST the directory of interest. + * Wrapper to grab parameter settings for lov.*-clilov-*.* values */ -static int get_param_cli(const char *type, const char *inst, - const char *param, char *buf, size_t buf_size) -{ - char param_path[PATH_MAX + 1]; - FILE *param_file = NULL; - int rc; - - snprintf(param_path, sizeof(param_path), - "/proc/fs/lustre/%s/%s/%s", type, inst, param); - - param_file = fopen(param_path, "r"); - if (param_file == NULL) { - rc = -errno; - goto out; - } - - if (fgets(buf, buf_size, param_file) == NULL) { - rc = -errno; - goto out; - } - - rc = 0; -out: - if (param_file != NULL) - fclose(param_file); - - return rc; -} - -static int get_param_llite(const char *path, - const char *param, char *buf, size_t buf_size) -{ - char inst[80]; - int rc; - - rc = llapi_getname(path, inst, sizeof(inst)); - if (rc != 0) - return rc; - - return get_param_cli("llite", inst, param, buf, buf_size); -} - -static int get_param_lov(const char *path, - const char *param, char *buf, size_t buf_size) +static int get_param_lov(const char *path, const char *param, + char *buf, size_t buf_size) { struct obd_uuid uuid; int rc; @@ -577,11 +475,15 @@ static int get_param_lov(const char *path, if (rc != 0) return rc; - return get_param_cli("lov", uuid.uuid, param, buf, buf_size); + return get_lustre_param_value("lov", uuid.uuid, FILTER_BY_EXACT, param, + buf, buf_size); } -static int get_param_lmv(const char *path, - const char *param, char *buf, size_t buf_size) +/* + * Wrapper to grab parameter settings for lmv.*-clilov-*.* values + */ +static int get_param_lmv(const char *path, const char *param, + char *buf, size_t buf_size) { struct obd_uuid uuid; int rc; @@ -590,26 +492,29 @@ static int get_param_lmv(const char *path, if (rc != 0) return rc; - return get_param_cli("lmv", uuid.uuid, param, buf, buf_size); + return get_lustre_param_value("lmv", uuid.uuid, FILTER_BY_EXACT, param, + buf, buf_size); } static int get_mds_md_size(const char *path) { + char buf[PATH_MAX], inst[PATH_MAX]; int md_size = lov_user_md_size(LOV_MAX_STRIPE_COUNT, LOV_USER_MAGIC_V3); - char buf[80]; int rc; - /* Get the max ea size from llite proc. */ - rc = get_param_llite(path, "max_easize", buf, sizeof(buf)); + rc = llapi_getname(path, inst, sizeof(inst)); if (rc != 0) - goto out; + return rc; + + /* Get the max ea size from llite parameters. */ + rc = get_lustre_param_value("llite", inst, FILTER_BY_EXACT, + "max_easize", buf, sizeof(buf)); + if (rc != 0) + return rc; rc = atoi(buf); - if (rc > 0) - md_size = rc; -out: - return md_size; + return rc > 0 ? rc : md_size; } int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) @@ -618,59 +523,84 @@ int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) } /* - * if pool is NULL, search ostname in target_obd + * if pool is NULL, search tgtname in target_obd * if pool is not NULL: * if pool not found returns errno < 0 - * if ostname is NULL, returns 1 if pool is not empty and 0 if pool empty - * if ostname is not NULL, returns 1 if OST is in pool and 0 if not + * if tgtname is NULL, returns 1 if pool is not empty and 0 if pool empty + * if tgtname is not NULL, returns 1 if OST is in pool and 0 if not */ -int llapi_search_ost(char *fsname, char *poolname, char *ostname) +int llapi_search_tgt(char *fsname, char *poolname, char *tgtname, bool is_mdt) { - FILE *fd; - char buffer[PATH_MAX + 1]; - int len = 0, rc; + char buffer[PATH_MAX]; + size_t len = 0; + glob_t param; + FILE *fd; + int rc; - if (ostname != NULL) - len = strlen(ostname); + /* You need one or the other */ + if (poolname == NULL && fsname == NULL) + return -EINVAL; - if (poolname == NULL) { - if (len == 0) - rc = -EINVAL; - else - rc = find_target_obdpath(fsname, buffer); + if (tgtname != NULL) + len = strlen(tgtname); + + if (poolname == NULL && len == 0) + return -EINVAL; + + /* Search by poolname and fsname if is not NULL */ + if (poolname != NULL) { + rc = poolpath(¶m, fsname, NULL); + if (rc == 0) { + snprintf(buffer, sizeof(buffer), "%s/%s", + param.gl_pathv[0], poolname); + } + } else if (fsname != NULL) { + rc = get_lustre_param_path(is_mdt ? "lmv" : "lov", fsname, + FILTER_BY_FS_NAME, + "target_obd", ¶m); + if (rc == 0) { + strncpy(buffer, param.gl_pathv[0], + sizeof(buffer)); + } } else { - rc = find_poolpath(fsname, poolname, buffer); + return -EINVAL; } - if (rc) - return rc; + cfs_free_param_data(¶m); + if (rc) + return rc; - fd = fopen(buffer, "r"); - if (fd == NULL) - return -errno; + fd = fopen(buffer, "r"); + if (fd == NULL) + return -errno; - while (fgets(buffer, sizeof(buffer), fd) != NULL) { - if (poolname == NULL) { - char *ptr; - /* Search for an ostname in the list of OSTs - Line format is IDX: fsname-OSTxxxx_UUID STATUS */ - ptr = strchr(buffer, ' '); - if ((ptr != NULL) && - (strncmp(ptr + 1, ostname, len) == 0)) { - fclose(fd); - return 1; - } - } else { - /* Search for an ostname in a pool, - (or an existing non-empty pool if no ostname) */ - if ((ostname == NULL) || - (strncmp(buffer, ostname, len) == 0)) { - fclose(fd); - return 1; - } - } - } - fclose(fd); - return 0; + while (fgets(buffer, sizeof(buffer), fd) != NULL) { + if (poolname == NULL) { + char *ptr; + /* Search for an tgtname in the list of targets + * Line format is IDX: fsname-OST/MDTxxxx_UUID STATUS */ + ptr = strchr(buffer, ' '); + if ((ptr != NULL) && + (strncmp(ptr + 1, tgtname, len) == 0)) { + fclose(fd); + return 1; + } + } else { + /* Search for an tgtname in a pool, + * (or an existing non-empty pool if no tgtname) */ + if ((tgtname == NULL) || + (strncmp(buffer, tgtname, len) == 0)) { + fclose(fd); + return 1; + } + } + } + fclose(fd); + return 0; +} + +int llapi_search_ost(char *fsname, char *poolname, char *ostname) +{ + return llapi_search_tgt(fsname, poolname, ostname, false); } /** @@ -834,9 +764,7 @@ retry_open: 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); + "setstripe error for '%s': %s", name, errmsg); close(fd); fd = rc; @@ -901,95 +829,228 @@ int llapi_file_create_pool(const char *name, unsigned long long stripe_size, return 0; } -int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, - int stripe_count, int stripe_pattern, - const char *pool_name) +static int verify_dir_param(const char *name, + const struct llapi_stripe_param *param) { - 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)); - } + char fsname[MAX_OBD_NAME + 1] = { 0 }; + char *pool_name = param->lsp_pool; + int rc; - fd = open(name, O_DIRECTORY | O_RDONLY); - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + /* 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 = 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); + /* Check if the stripe pattern is sane. */ + rc = llapi_dir_stripe_limit_check(param->lsp_stripe_offset, + param->lsp_stripe_count, + param->lsp_stripe_pattern); + if (rc != 0) + return rc; - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error on LL_IOC_LMV_SETSTRIPE '%s' (%d): %s", - name, fd, errmsg); - } - close(fd); - return rc; -} + /* 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, '.'); -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 }; + 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_tgt(fsname, pool_name, NULL, true); + if (rc < 1) { + char *err = rc == 0 ? "has no OSTs" : "does not exist"; + + llapi_err_noerrno(LLAPI_MSG_ERROR, "pool '%s.%s' %s", + fsname, pool_name, err); + return -EINVAL; + } + } + + /* sanity check of target list */ + if (param->lsp_is_specific) { + char mdtname[MAX_OBD_NAME + 1]; + bool found = false; + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) { + snprintf(mdtname, sizeof(mdtname), "%s-MDT%04x_UUID", + fsname, param->lsp_tgts[i]); + rc = llapi_search_tgt(fsname, pool_name, mdtname, true); + if (rc <= 0) { + if (rc == 0) + rc = -ENODEV; + + llapi_error(LLAPI_MSG_ERROR, rc, + "%s: cannot find MDT %s in %s", + __func__, mdtname, + pool_name != NULL ? + "pool" : "system"); + return rc; + } + + /* Make sure stripe offset is in MDT list. */ + if (param->lsp_tgts[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; + } + } + + return 0; +} + +static inline void param2lmu(struct lmv_user_md *lmu, + const struct llapi_stripe_param *param) +{ + lmu->lum_magic = param->lsp_is_specific ? LMV_USER_MAGIC_SPECIFIC : + LMV_USER_MAGIC; + lmu->lum_stripe_count = param->lsp_stripe_count; + lmu->lum_stripe_offset = param->lsp_stripe_offset; + lmu->lum_hash_type = param->lsp_stripe_pattern; + if (param->lsp_pool != NULL) + strncpy(lmu->lum_pool_name, param->lsp_pool, LOV_MAXPOOLNAME); + if (param->lsp_is_specific) { + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) + lmu->lum_objects[i].lum_mds = param->lsp_tgts[i]; + } +} + +int llapi_dir_set_default_lmv(const char *name, + const struct llapi_stripe_param *param) +{ + struct lmv_user_md lmu = { 0 }; + int fd; + int rc = 0; + + rc = verify_dir_param(name, param); + if (rc) + return rc; + + /* TODO: default lmv doesn't support specific targets yet */ + if (param->lsp_is_specific) + return -EINVAL; + + param2lmu(&lmu, param); + + 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, &lmu); + if (rc < 0) { + char *errmsg = "stripe already set"; + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "default dirstripe error on '%s': %s", + name, errmsg); + } + close(fd); + return rc; +} + +int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) +{ + const struct llapi_stripe_param param = { + .lsp_stripe_count = stripe_count, + .lsp_stripe_offset = stripe_offset, + .lsp_stripe_pattern = stripe_pattern, + .lsp_pool = (char *)pool_name + }; + + return llapi_dir_set_default_lmv(name, ¶m); +} + +/** + * Create a Lustre directory. + * + * \param name the name of the directory to be created + * \param mode permission of the file if it is created, see mode in open(2) + * \param param stripe pattern of the newly created directory + * + * \retval 0 on success + * \retval negative errno on failure + */ +int llapi_dir_create(const char *name, mode_t mode, + const struct llapi_stripe_param *param) +{ + struct lmv_user_md *lmu = NULL; + size_t lmu_size; + struct obd_ioctl_data data = { 0 }; char rawbuf[8192]; char *buf = rawbuf; char *dirpath = NULL; char *namepath = NULL; char *dir; char *filename; - int fd = -1; - int rc; + int fd, rc; + + rc = verify_dir_param(name, param); + if (rc) + return rc; + + lmu_size = lmv_user_md_size(param->lsp_stripe_count, + param->lsp_is_specific ? + LMV_USER_MAGIC_SPECIFIC : + LMV_USER_MAGIC); + + lmu = calloc(1, lmu_size); + if (lmu == NULL) + return -ENOMEM; dirpath = strdup(name); - namepath = strdup(name); - if (!dirpath || !namepath) + if (!dirpath) { + free(lmu); return -ENOMEM; + } - lmu.lum_magic = LMV_USER_MAGIC; - lmu.lum_stripe_offset = stripe_offset; - lmu.lum_stripe_count = stripe_count; - lmu.lum_hash_type = stripe_pattern; - if (pool_name != NULL) { - 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); - rc = -E2BIG; - goto out; - } - memcpy(lmu.lum_pool_name, pool_name, strlen(pool_name)); + namepath = strdup(name); + if (!namepath) { + free(dirpath); + free(lmu); + return -ENOMEM; } + param2lmu(lmu, param); + filename = basename(namepath); 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_inlbuf2 = (char *)lmu; + data.ioc_inllen2 = lmu_size; data.ioc_type = mode; - rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); + rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { llapi_error(LLAPI_MSG_ERROR, rc, "error: LL_IOC_LMV_SETSTRIPE pack failed '%s'.", @@ -1006,21 +1067,37 @@ int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, if (ioctl(fd, LL_IOC_LMV_SETSTRIPE, buf)) { 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); + "dirstripe error on '%s': %s", name, errmsg); } close(fd); out: - free(dirpath); free(namepath); + free(dirpath); + free(lmu); 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) +{ + const struct llapi_stripe_param param = { + .lsp_stripe_count = stripe_count, + .lsp_stripe_offset = stripe_offset, + .lsp_stripe_pattern = stripe_pattern, + .lsp_pool = (char *)pool_name + }; + + return llapi_dir_create(name, mode, ¶m); +} + int llapi_direntry_remove(char *dname) { char *dirpath = NULL; @@ -1050,8 +1127,8 @@ int llapi_direntry_remove(char *dname) if (ioctl(fd, LL_IOC_REMOVE_ENTRY, filename)) { char *errmsg = strerror(errno); llapi_err_noerrno(LLAPI_MSG_ERROR, - "error on ioctl "LPX64" for '%s' (%d): %s", - (__u64)LL_IOC_LMV_SETSTRIPE, filename, + "error on ioctl %#jx for '%s' (%d): %s", + (uintmax_t)LL_IOC_LMV_SETSTRIPE, filename, fd, errmsg); } out: @@ -1068,21 +1145,21 @@ out: */ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) { - struct mntent mnt; - char buf[PATH_MAX], mntdir[PATH_MAX]; - char *ptr; - FILE *fp; - int idx = 0, len = 0, mntlen, fd; - int rc = -ENODEV; + struct mntent mnt; + char buf[PATH_MAX], mntdir[PATH_MAX]; + char *ptr, *ptr_end; + FILE *fp; + int idx = 0, len = 0, mntlen, fd; + int rc = -ENODEV; /* get the mount point */ - fp = setmntent(MOUNTED, "r"); - if (fp == NULL) { - rc = -EIO; - llapi_error(LLAPI_MSG_ERROR, rc, - "setmntent(%s) failed", MOUNTED); - return rc; - } + fp = setmntent(PROC_MOUNTS, "r"); + if (fp == NULL) { + rc = -EIO; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot retrieve filesystem mount point"); + return rc; + } while (1) { if (getmntent_r(fp, &mnt, buf, sizeof(buf)) == NULL) break; @@ -1094,58 +1171,72 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) continue; mntlen = strlen(mnt.mnt_dir); - ptr = strrchr(mnt.mnt_fsname, '/'); + ptr = strchr(mnt.mnt_fsname, '/'); + while (ptr && *ptr == '/') + ptr++; /* 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++; + ptr_end = ptr; + while (*ptr_end != '/' && *ptr_end != '\0') + ptr_end++; - /* Check the fsname for a match, if given */ + /* Check the fsname for a match, if given */ if (!(want & WANT_FSNAME) && fsname != NULL && - (strlen(fsname) > 0) && (strcmp(ptr, fsname) != 0)) + (strlen(fsname) > 0) && + (strncmp(ptr, fsname, ptr_end - ptr) != 0)) continue; /* If the path isn't set return the first one we find */ - if (path == NULL || strlen(path) == 0) { - strcpy(mntdir, mnt.mnt_dir); - if ((want & WANT_FSNAME) && fsname != NULL) - strcpy(fsname, ptr); - rc = 0; - break; - /* Otherwise find the longest matching path */ - } else if ((strlen(path) >= mntlen) && (mntlen >= len) && - (strncmp(mnt.mnt_dir, path, mntlen) == 0)) { - strcpy(mntdir, mnt.mnt_dir); - len = mntlen; - if ((want & WANT_FSNAME) && fsname != NULL) - strcpy(fsname, ptr); - rc = 0; - } - } - endmntent(fp); - - /* Found it */ - if (rc == 0) { - if ((want & WANT_PATH) && path != NULL) - strcpy(path, mntdir); - if (want & WANT_FD) { - fd = open(mntdir, O_RDONLY | O_DIRECTORY | O_NONBLOCK); - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "error opening '%s'", mntdir); + if (path == NULL || strlen(path) == 0) { + strncpy(mntdir, mnt.mnt_dir, strlen(mnt.mnt_dir)); + mntdir[strlen(mnt.mnt_dir)] = '\0'; + if ((want & WANT_FSNAME) && fsname != NULL) { + strncpy(fsname, ptr, ptr_end - ptr); + fsname[ptr_end - ptr] = '\0'; + } + rc = 0; + break; + /* Otherwise find the longest matching path */ + } else if ((strlen(path) >= mntlen) && (mntlen >= len) && + (strncmp(mnt.mnt_dir, path, mntlen) == 0)) { + strncpy(mntdir, mnt.mnt_dir, strlen(mnt.mnt_dir)); + mntdir[strlen(mnt.mnt_dir)] = '\0'; + len = mntlen; + if ((want & WANT_FSNAME) && fsname != NULL) { + strncpy(fsname, ptr, ptr_end - ptr); + fsname[ptr_end - ptr] = '\0'; + } + rc = 0; + } + } + endmntent(fp); - } else { - *outfd = fd; - } - } - } else if (want & WANT_ERROR) - llapi_err_noerrno(LLAPI_MSG_ERROR, - "can't find fs root for '%s': %d", - (want & WANT_PATH) ? fsname : path, rc); - return rc; + /* Found it */ + if (rc == 0) { + if ((want & WANT_PATH) && path != NULL) { + strncpy(path, mntdir, strlen(mntdir)); + path[strlen(mntdir)] = '\0'; + } + if (want & WANT_FD) { + fd = open(mntdir, O_RDONLY | O_DIRECTORY | O_NONBLOCK); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot open '%s': %s", mntdir, + strerror(-rc)); + + } else { + *outfd = fd; + } + } + } else if (want & WANT_ERROR) + llapi_err_noerrno(LLAPI_MSG_ERROR, + "'%s' not on a mounted Lustre filesystem", + (want & WANT_PATH) ? fsname : path); + return rc; } /* @@ -1184,42 +1275,67 @@ int llapi_search_fsname(const char *pathname, char *fsname) path = realpath(pathname, NULL); if (path == NULL) { - char buf[PATH_MAX], *ptr; + char tmp[PATH_MAX - 1]; + char buf[PATH_MAX]; + char *ptr; + tmp[0] = '\0'; 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; + char realpath[PATH_MAX - 1]; + + if (getcwd(realpath, sizeof(realpath) - 2) == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot get current working directory"); + return rc; + } + + rc = snprintf(tmp, sizeof(tmp), "%s/", realpath); + if (rc >= sizeof(tmp)) { + rc = -E2BIG; + llapi_error(LLAPI_MSG_ERROR, rc, + "invalid parent path '%s'", + tmp); + return rc; + } } - rc = strlcat(buf, pathname, sizeof(buf)); - if (rc >= sizeof(buf)) - return -E2BIG; - path = realpath(buf, NULL); - if (path == NULL) { - ptr = strrchr(buf, '/'); - if (ptr == NULL) - return -ENOENT; - *ptr = '\0'; - path = realpath(buf, NULL); - if (path == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "pathname '%s' cannot expand", - pathname); - return rc; - } - } - } - rc = get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, path, -1); - free(path); - return rc; + + rc = snprintf(buf, sizeof(buf), "%s%s", tmp, pathname); + if (rc >= sizeof(buf)) { + rc = -E2BIG; + llapi_error(LLAPI_MSG_ERROR, rc, + "invalid path '%s'", pathname); + return rc; + } + path = realpath(buf, NULL); + if (path == NULL) { + ptr = strrchr(buf, '/'); + if (ptr == NULL) { + llapi_error(LLAPI_MSG_ERROR | + LLAPI_MSG_NO_ERRNO, 0, + "cannot resolve path '%s'", + buf); + return -ENOENT; + } + *ptr = '\0'; + path = realpath(buf, NULL); + if (path == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot resolve path '%s'", + pathname); + return rc; + } + } + } + rc = get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, path, -1); + free(path); + return rc; } int llapi_search_rootpath(char *pathname, const char *fsname) @@ -1229,57 +1345,36 @@ int llapi_search_rootpath(char *pathname, const char *fsname) int llapi_getname(const char *path, char *buf, size_t size) { - struct obd_uuid uuid_buf; - char *uuid = uuid_buf.uuid; - int rc, nr; - - memset(&uuid_buf, 0, sizeof(uuid_buf)); - rc = llapi_file_get_lov_uuid(path, &uuid_buf); - if (rc) - return rc; - - /* We want to turn lustre-clilov-ffff88002738bc00 into - * lustre-ffff88002738bc00. */ - - nr = snprintf(buf, size, "%.*s-%s", - (int) (strlen(uuid) - 24), uuid, - uuid + strlen(uuid) - 16); - - if (nr >= size) - rc = -ENAMETOOLONG; - - return rc; -} + struct obd_uuid uuid_buf; + char *uuid = uuid_buf.uuid; + char *cfg_instance; + int rc, len, fsname_len; + memset(&uuid_buf, 0, sizeof(uuid_buf)); + rc = llapi_file_get_lov_uuid(path, &uuid_buf); + if (rc) + return rc; -/* - * find the pool directory path under /proc - * (can be also used to test if a fsname is known) - */ -static int poolpath(char *fsname, char *pathname, char *pool_pathname) -{ - int rc = 0; - char pattern[PATH_MAX + 1]; - char buffer[PATH_MAX]; - - if (fsname == NULL) { - rc = llapi_search_fsname(pathname, buffer); - if (rc != 0) - return rc; - fsname = buffer; - strcpy(pathname, fsname); - } + /* + * We want to turn testfs-clilov-ffff88002738bc00 into + * testfs-ffff88002738bc00 in a portable way that doesn't depend + * on what is after "-clilov-" as it may change in the future. + * Unfortunately, the "fsname" part may contain a dash, so we + * can't just skip to the first dash, and the "instance" may be a + * UUID in the future, so we can't necessarily go to the last dash. + */ + cfg_instance = strstr(uuid, "-clilov-"); + if (!cfg_instance) + return -EINVAL; - snprintf(pattern, PATH_MAX, "/proc/fs/lustre/lov/%s-*/pools", fsname); - rc = first_match(pattern, buffer); - if (rc) - return rc; + fsname_len = cfg_instance - uuid; + cfg_instance += strlen("-clilov-"); + len = snprintf(buf, size, "%.*s-%s", fsname_len, uuid, cfg_instance); - /* in fsname test mode, pool_pathname is NULL */ - if (pool_pathname != NULL) - strcpy(pool_pathname, buffer); + if (len >= size) + rc = -ENAMETOOLONG; - return 0; + return rc; } /** @@ -1298,43 +1393,44 @@ int llapi_get_poolmembers(const char *poolname, char **members, { 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; + glob_t pathname; + char buf[PATH_MAX]; + FILE *fd; + int rc = 0; + int nb_entries = 0; + int used = 0; - /* name is FSNAME.POOLNAME */ + /* name is FSNAME.POOLNAME */ if (strlen(poolname) >= sizeof(fsname)) return -EOVERFLOW; - strlcpy(fsname, poolname, sizeof(fsname)); - pool = strchr(fsname, '.'); - if (pool == NULL) - return -EINVAL; - *pool = '\0'; - pool++; + snprintf(fsname, sizeof(fsname), "%s", poolname); + pool = strchr(fsname, '.'); + if (pool == NULL) + return -EINVAL; - rc = poolpath(fsname, NULL, pathname); - if (rc != 0) { - llapi_error(LLAPI_MSG_ERROR, rc, - "Lustre filesystem '%s' not found", - fsname); - return rc; - } + *pool = '\0'; + pool++; + + rc = poolpath(&pathname, fsname, NULL); + if (rc != 0) { + llapi_error(LLAPI_MSG_ERROR, rc, + "Lustre filesystem '%s' not found", + fsname); + return rc; + } - llapi_printf(LLAPI_MSG_NORMAL, "Pool: %s.%s\n", fsname, pool); - rc = snprintf(path, sizeof(path), "%s/%s", pathname, pool); - if (rc >= sizeof(path)) + llapi_printf(LLAPI_MSG_NORMAL, "Pool: %s.%s\n", fsname, pool); + rc = snprintf(buf, sizeof(buf), "%s/%s", pathname.gl_pathv[0], pool); + cfs_free_param_data(&pathname); + if (rc >= sizeof(buf)) return -EOVERFLOW; - fd = fopen(path, "r"); - if (fd == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "Cannot open %s", path); - return rc; - } + fd = fopen(buf, "r"); + if (fd == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot open %s", buf); + return rc; + } rc = 0; while (fgets(buf, sizeof(buf), fd) != NULL) { @@ -1377,11 +1473,12 @@ int llapi_get_poolmembers(const char *poolname, char **members, int llapi_get_poollist(const char *name, char **poollist, int list_size, char *buffer, int buffer_size) { - char fsname[PATH_MAX + 1], rname[PATH_MAX + 1], pathname[PATH_MAX + 1]; + char rname[PATH_MAX]; + glob_t pathname; + char *fsname; char *ptr; DIR *dir; - struct dirent pool; - struct dirent *cookie = NULL; + struct dirent *pool; int rc = 0; unsigned int nb_entries = 0; unsigned int used = 0; @@ -1405,87 +1502,89 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, return rc; } - rc = poolpath(NULL, rname, pathname); - if (rc != 0) { - llapi_error(LLAPI_MSG_ERROR, rc, "'%s' is not" - " a Lustre filesystem", name); - return rc; - } - if (strlen(rname) > sizeof(fsname)-1) - return -E2BIG; - strncpy(fsname, rname, sizeof(fsname)); - } else { - /* name is FSNAME */ - if (strlen(name) > sizeof(fsname)-1) - return -E2BIG; - strncpy(fsname, name, sizeof(fsname)); - rc = poolpath(fsname, NULL, pathname); - } - if (rc != 0) { - llapi_error(LLAPI_MSG_ERROR, rc, - "Lustre filesystem '%s' not found", name); - return rc; - } + fsname = strdup(rname); + if (!fsname) + return -ENOMEM; - llapi_printf(LLAPI_MSG_NORMAL, "Pools from %s:\n", fsname); - dir = opendir(pathname); - if (dir == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "Could not open pool list for '%s'", - name); - return rc; - } + rc = poolpath(&pathname, NULL, rname); + } else { + /* name is FSNAME */ + fsname = strdup(name); + if (!fsname) + return -ENOMEM; + rc = poolpath(&pathname, fsname, NULL); + } + if (rc != 0) { + llapi_error(LLAPI_MSG_ERROR, rc, + "Lustre filesystem '%s' not found", name); + goto free_path; + } - while(1) { - rc = readdir_r(dir, &pool, &cookie); + dir = opendir(pathname.gl_pathv[0]); + if (dir == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "Could not open pool list for '%s'", + name); + goto free_path; + } - if (rc != 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "Error reading pool list for '%s'", name); - goto out; - } else if ((rc == 0) && (cookie == NULL)) { - /* end of directory */ - break; - } + do { + errno = 0; + pool = readdir(dir); + if (pool == NULL) { + rc = -errno; + goto free_dir; + } /* ignore . and .. */ - if (!strcmp(pool.d_name, ".") || !strcmp(pool.d_name, "..")) + if (!strcmp(pool->d_name, ".") || !strcmp(pool->d_name, "..")) continue; /* check output bounds */ if (nb_entries >= list_size) { rc = -EOVERFLOW; - goto out; + goto free_dir_no_msg; } /* +2 for '.' and final '\0' */ - if (used + strlen(pool.d_name) + strlen(fsname) + 2 + if (used + strlen(pool->d_name) + strlen(fsname) + 2 > buffer_size) { rc = -EOVERFLOW; - goto out; + goto free_dir_no_msg; } - sprintf(buffer + used, "%s.%s", fsname, pool.d_name); + sprintf(buffer + used, "%s.%s", fsname, pool->d_name); poollist[nb_entries] = buffer + used; - used += strlen(pool.d_name) + strlen(fsname) + 2; + used += strlen(pool->d_name) + strlen(fsname) + 2; nb_entries++; - } + } while (1); -out: - closedir(dir); - return ((rc != 0) ? rc : nb_entries); +free_dir: + if (rc) + llapi_error(LLAPI_MSG_ERROR, rc, + "Error reading pool list for '%s'", name); + else + llapi_printf(LLAPI_MSG_NORMAL, "Pools from %s:\n", fsname); + +free_dir_no_msg: + closedir(dir); +free_path: + cfs_free_param_data(&pathname); + if (fsname) + free(fsname); + return rc != 0 ? rc : nb_entries; } /* wrapper for lfs.c and obd.c */ int llapi_poollist(const char *name) { - /* list of pool names (assume that pool count is smaller - than OST count) */ - char **list, *buffer = NULL, *path = NULL, *fsname = NULL; - int obdcount, bufsize, rc, nb, i; - char *poolname = NULL, *tmp = NULL, data[16]; + /* list of pool names (assume that pool count is smaller + than OST count) */ + char **list, *buffer = NULL, *fsname = (char *)name; + char *poolname = NULL, *tmp = NULL, data[16]; + enum param_filter type = FILTER_BY_PATH; + int obdcount, bufsize, rc, nb, i; if (name == NULL) return -EINVAL; @@ -1495,18 +1594,17 @@ int llapi_poollist(const char *name) if (fsname == NULL) return -ENOMEM; - poolname = strchr(fsname, '.'); - if (poolname) - *poolname = '\0'; - } else { - path = (char *) name; - } + poolname = strchr(fsname, '.'); + if (poolname) + *poolname = '\0'; + type = FILTER_BY_FS_NAME; + } - rc = get_param_obdvar(fsname, path, "lov", "numobd", - data, sizeof(data)); - if (rc < 0) - goto err; - obdcount = atoi(data); + rc = get_lustre_param_value("lov", fsname, type, "numobd", + data, sizeof(data)); + if (rc < 0) + goto err; + obdcount = atoi(data); /* Allocate space for each fsname-OST0000_UUID, 1 per OST, * and also an array to store the pointers for all that @@ -1542,9 +1640,9 @@ retry_get_pools: err: if (buffer) free(buffer); - if (fsname) - free(fsname); - return rc; + if (fsname != NULL && type == FILTER_BY_FS_NAME) + free(fsname); + return rc; } typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d, @@ -1556,11 +1654,18 @@ static int common_param_init(struct find_param *param, char *path) { int lum_size = get_mds_md_size(path); + if (lum_size < 0) + return lum_size; + + /* migrate has fp_lmv_md initialized outside */ + if (param->fp_migrate) + return 0; + if (lum_size < PATH_MAX + 1) lum_size = PATH_MAX + 1; param->fp_lum_size = lum_size; - param->fp_lmd = calloc(1, sizeof(lstat_t) + param->fp_lum_size); + param->fp_lmd = calloc(1, sizeof(lstat_t) + lum_size); if (param->fp_lmd == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %zu bytes for ioctl", @@ -1571,25 +1676,27 @@ static int common_param_init(struct find_param *param, char *path) param->fp_lmv_stripe_count = 256; param->fp_lmv_md = calloc(1, lmv_user_md_size(param->fp_lmv_stripe_count, - LMV_MAGIC_V1)); + LMV_USER_MAGIC_SPECIFIC)); if (param->fp_lmv_md == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %d bytes for ioctl", lmv_user_md_size(param->fp_lmv_stripe_count, - LMV_MAGIC_V1)); + LMV_USER_MAGIC_SPECIFIC)); return -ENOMEM; } 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; + param->fp_mdt_index = OBD_NOT_FOUND; return 0; } static void find_param_fini(struct find_param *param) { + if (param->fp_migrate) + return; + if (param->fp_obd_indexes) free(param->fp_obd_indexes); @@ -1610,21 +1717,21 @@ static int cb_common_fini(char *path, DIR *parent, DIR **dirp, void *data, } /* set errno upon failure */ -static DIR *opendir_parent(char *path) +static DIR *opendir_parent(const char *path) { - DIR *parent; - char *fname; - char c; + char *path_copy; + char *parent_path; + DIR *parent; - fname = strrchr(path, '/'); - if (fname == NULL) - return opendir("."); + path_copy = strdup(path); + if (path_copy == NULL) + return NULL; - c = fname[1]; - fname[1] = '\0'; - parent = opendir(path); - fname[1] = c; - return parent; + parent_path = dirname(path_copy); + parent = opendir(parent_path); + free(path_copy); + + return parent; } static int cb_get_dirstripe(char *path, DIR *d, struct find_param *param) @@ -1649,13 +1756,14 @@ again: free(param->fp_lmv_md); param->fp_lmv_stripe_count = stripe_count; - lmv_size = lmv_user_md_size(stripe_count, LMV_MAGIC_V1); + lmv_size = lmv_user_md_size(stripe_count, + LMV_USER_MAGIC_SPECIFIC); param->fp_lmv_md = malloc(lmv_size); if (param->fp_lmv_md == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %d bytes for ioctl", lmv_user_md_size(param->fp_lmv_stripe_count, - LMV_MAGIC_V1)); + LMV_USER_MAGIC_SPECIFIC)); return -ENOMEM; } goto again; @@ -1663,64 +1771,95 @@ again: return ret; } -static int get_lmd_info(char *path, DIR *parent, DIR *dir, - struct lov_user_mds_data *lmd, int lumlen) +int get_lmd_info_fd(char *path, int parent_fd, int dir_fd, + void *lmdbuf, int lmdlen, enum get_lmd_info_type type) { - lstat_t *st = &lmd->lmd_st; - int ret = 0; + struct lov_user_mds_data *lmd = lmdbuf; + lstat_t *st = &lmd->lmd_st; + int ret = 0; - if (parent == NULL && dir == NULL) - return -EINVAL; + if (parent_fd < 0 && dir_fd < 0) + return -EINVAL; + if (type != GET_LMD_INFO && type != GET_LMD_STRIPE) + return -EINVAL; - if (dir) { - ret = ioctl(dirfd(dir), LL_IOC_MDC_GETINFO, (void *)lmd); - } else if (parent) { + if (dir_fd >= 0) { + /* LL_IOC_MDC_GETINFO operates on the current directory inode + * and returns struct lov_user_mds_data, while + * LL_IOC_LOV_GETSTRIPE returns only struct lov_user_md. + */ + ret = ioctl(dir_fd, type == GET_LMD_INFO ? LL_IOC_MDC_GETINFO : + LL_IOC_LOV_GETSTRIPE, + lmdbuf); + } else if (parent_fd >= 0) { char *fname = strrchr(path, '/'); - /* 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 + /* IOC_MDC_GETFILEINFO takes as input the filename (relative to + * the parent directory) and returns struct lov_user_mds_data, + * while IOC_MDC_GETFILESTRIPE returns only struct lov_user_md. + * + * This avoids opening, locking, and closing each file on the + * client if that is not needed. Multiple of these ioctl() can + * be done on the parent 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. */ + * 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) { - if (errno == ENOTTY) { - /* ioctl is not supported, it is not a lustre fs. - * Do the regular lstat(2) instead. */ - ret = lstat_f(path, st); - if (ret) { - ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: lstat failed for %s", - __func__, path); - } - } else if (errno == ENOENT) { - ret = -errno; - llapi_error(LLAPI_MSG_WARN, ret, - "warning: %s: %s does not exist", - __func__, path); - } else if (errno != EISDIR) { - ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "%s ioctl failed for %s.", - dir ? "LL_IOC_MDC_GETINFO" : - "IOC_MDC_GETFILEINFO", path); - } else { + ret = snprintf(lmdbuf, lmdlen, "%s", fname); + if (ret < 0) + errno = -ret; + else if (ret >= lmdlen || ret++ == 0) + errno = EINVAL; + else + ret = ioctl(parent_fd, type == GET_LMD_INFO ? + IOC_MDC_GETFILEINFO : + IOC_MDC_GETFILESTRIPE, lmdbuf); + } + + if (ret && type == GET_LMD_INFO) { + if (errno == ENOTTY) { + /* ioctl is not supported, it is not a lustre fs. + * Do the regular lstat(2) instead. + */ + ret = lstat_f(path, st); + if (ret) { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: lstat failed for %s", + __func__, path); + } + } else if (errno == ENOENT) { + ret = -errno; + llapi_error(LLAPI_MSG_WARN, ret, + "warning: %s does not exist", path); + } else if (errno != EISDIR && errno != ENODATA) { ret = -errno; llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: IOC_MDC_GETFILEINFO failed for %s", - __func__, path); + "%s ioctl failed for %s.", + dir_fd >= 0 ? "LL_IOC_MDC_GETINFO" : + "IOC_MDC_GETFILEINFO", path); } } + return ret; } +static int get_lmd_info(char *path, DIR *parent, DIR *dir, void *lmdbuf, + int lmdlen, enum get_lmd_info_type type) +{ + int parent_fd = -1; + int dir_fd = -1; + + if (parent) + parent_fd = dirfd(parent); + if (dir) + dir_fd = dirfd(dir); + + return get_lmd_info_fd(path, parent_fd, dir_fd, lmdbuf, lmdlen, type); +} + static int llapi_semantic_traverse(char *path, int size, DIR *parent, semantic_func_t sem_init, semantic_func_t sem_fini, void *data, @@ -1758,28 +1897,24 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, while ((dent = readdir64(d)) != NULL) { int rc; - if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) - continue; - - /* Don't traverse .lustre directory */ - if (!(strcmp(dent->d_name, dot_lustre_name))) - continue; + if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) + continue; - path[len] = 0; - if ((len + dent->d_reclen + 2) > size) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: string buffer is too small", - __func__); - break; - } - strcat(path, "/"); - strcat(path, dent->d_name); + path[len] = 0; + if ((len + dent->d_reclen + 2) > size) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: string buffer too small", + __func__); + break; + } + strcat(path, "/"); + strcat(path, dent->d_name); - if (dent->d_type == DT_UNKNOWN) { + if (dent->d_type == DT_UNKNOWN) { lstat_t *st = ¶m->fp_lmd->lmd_st; rc = get_lmd_info(path, d, NULL, param->fp_lmd, - param->fp_lum_size); + param->fp_lum_size, GET_LMD_INFO); if (rc == 0) dent->d_type = IFTODT(st->st_mode); else if (ret == 0) @@ -1804,8 +1939,10 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, rc = 0; if (sem_init) { rc = sem_init(path, d, NULL, data, dent); - if (rc < 0 && ret == 0) + if (rc < 0 && ret == 0) { ret = rc; + break; + } } if (sem_fini && rc == 0) sem_fini(path, d, NULL, data, dent); @@ -1842,7 +1979,7 @@ static int param_callback(char *path, semantic_func_t sem_init, if (!buf) return -ENOMEM; - strlcpy(buf, path, PATH_MAX + 1); + snprintf(buf, PATH_MAX + 1, "%s", path); ret = common_param_init(param, buf); if (ret) goto out; @@ -1859,12 +1996,13 @@ out: int llapi_file_fget_lov_uuid(int fd, struct obd_uuid *lov_name) { - int rc = ioctl(fd, OBD_IOC_GETNAME, lov_name); - if (rc) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: can't get lov name."); - } - return rc; + int rc = ioctl(fd, OBD_IOC_GETNAME, lov_name); + + if (rc) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot get lov name"); + } + return rc; } int llapi_file_fget_lmv_uuid(int fd, struct obd_uuid *lov_name) @@ -1879,26 +2017,26 @@ int llapi_file_fget_lmv_uuid(int fd, struct obd_uuid *lov_name) int llapi_file_get_lov_uuid(const char *path, struct obd_uuid *lov_uuid) { - int fd, rc; + int fd, rc; - fd = open(path, O_RDONLY); - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); - return rc; - } + fd = open(path, O_RDONLY | O_NONBLOCK); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", path); + return rc; + } - rc = llapi_file_fget_lov_uuid(fd, lov_uuid); + rc = llapi_file_fget_lov_uuid(fd, lov_uuid); - close(fd); - return rc; + close(fd); + return rc; } int llapi_file_get_lmv_uuid(const char *path, struct obd_uuid *lov_uuid) { int fd, rc; - fd = open(path, O_RDONLY); + fd = open(path, O_RDONLY | O_NONBLOCK); if (fd < 0) { rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); @@ -1915,6 +2053,7 @@ enum tgt_type { LOV_TYPE = 1, LMV_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 @@ -1924,32 +2063,33 @@ enum tgt_type { static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, int *ost_count, enum tgt_type type) { + char buf[PATH_MAX], format[32]; + int rc = 0, index = 0; struct obd_uuid name; - char buf[1024]; - char format[32]; + glob_t param; FILE *fp; - int rc = 0, index = 0; - /* Get the lov name */ - if (type == LOV_TYPE) { - rc = llapi_file_fget_lov_uuid(fd, &name); - if (rc) - return rc; - } else { - rc = llapi_file_fget_lmv_uuid(fd, &name); - if (rc) - return rc; - } + /* Get the lov name */ + if (type == LOV_TYPE) + rc = llapi_file_fget_lov_uuid(fd, &name); + else + rc = llapi_file_fget_lmv_uuid(fd, &name); + if (rc != 0) + return rc; - /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", - type == LOV_TYPE ? "lov" : "lmv", name.uuid); - fp = fopen(buf, "r"); - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", buf); - return rc; - } + /* Now get the ost uuids */ + rc = get_lustre_param_path(type == LOV_TYPE ? "lov" : "lmv", name.uuid, + FILTER_BY_EXACT, "target_obd", ¶m); + if (rc != 0) + return -ENOENT; + + fp = fopen(param.gl_pathv[0], "r"); + if (fp == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", + param.gl_pathv[0]); + goto free_param; + } snprintf(format, sizeof(format), "%%d: %%%zus", sizeof(uuidp[0].uuid) - 1); @@ -1966,8 +2106,10 @@ static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, if (uuidp && (index > *ost_count)) rc = -EOVERFLOW; - *ost_count = index; - return rc; + *ost_count = index; +free_param: + cfs_free_param_data(¶m); + return rc; } int llapi_lov_get_uuids(int fd, struct obd_uuid *uuidp, int *ost_count) @@ -1977,23 +2119,23 @@ int llapi_lov_get_uuids(int fd, struct obd_uuid *uuidp, int *ost_count) int llapi_get_obd_count(char *mnt, int *count, int is_mdt) { - DIR *root; - int rc; + int root; + int rc; - root = opendir(mnt); - if (!root) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); - return rc; - } + root = open(mnt, O_RDONLY | O_DIRECTORY); + if (root < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; + } - *count = is_mdt; - rc = ioctl(dirfd(root), LL_IOC_GETOBDCOUNT, count); - if (rc < 0) - rc = -errno; + *count = is_mdt; + rc = ioctl(root, LL_IOC_GETOBDCOUNT, count); + if (rc < 0) + rc = -errno; - closedir(root); - return rc; + close(root); + return rc; } /* Check if user specified value matches a real uuid. Ignore _UUID, @@ -2021,47 +2163,55 @@ int llapi_uuid_match(char *real_uuid, char *search_uuid) /* 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) +static int setup_obd_uuid(int fd, char *dname, struct find_param *param) { struct obd_uuid obd_uuid; - char buf[1024]; + char buf[PATH_MAX]; + glob_t param_data; char format[32]; - FILE *fp; int rc = 0; + FILE *fp; if (param->fp_got_uuids) - return rc; + return rc; - /* Get the lov/lmv name */ + /* Get the lov/lmv name */ 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); - if (rc) { - if (rc != -ENOTTY) { - llapi_error(LLAPI_MSG_ERROR, rc, - "error: can't get lov name: %s", dname); - } else { - rc = 0; - } - return rc; - } + rc = llapi_file_fget_lmv_uuid(fd, &obd_uuid); + else + rc = llapi_file_fget_lov_uuid(fd, &obd_uuid); + if (rc) { + if (rc != -ENOTTY) { + llapi_error(LLAPI_MSG_ERROR, rc, + "error: can't get %s name: %s", + param->fp_get_lmv ? "lmv" : "lov", + dname); + } else { + rc = 0; + } + return rc; + } param->fp_got_uuids = 1; - /* 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; - llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", buf); - return rc; - } + /* Now get the ost uuids */ + rc = get_lustre_param_path(param->fp_get_lmv ? "lmv" : "lov", + obd_uuid.uuid, FILTER_BY_EXACT, + "target_obd", ¶m_data); + if (rc != 0) + return -ENOENT; + + fp = fopen(param_data.gl_pathv[0], "r"); + if (fp == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", + param_data.gl_pathv[0]); + goto free_param; + } 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:"); + param->fp_get_lmv ? "MDTS" : "OBDS"); snprintf(format, sizeof(format), "%%d: %%%zus", sizeof(obd_uuid.uuid) - 1); @@ -2092,8 +2242,9 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) __func__, param->fp_obd_uuid->uuid); rc = -EINVAL; } - - return (rc); +free_param: + cfs_free_param_data(¶m_data); + return rc; } /* In this case, param->fp_obd_uuid will be an array of obduuids and @@ -2116,31 +2267,29 @@ static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, if (ret != 0) return ret; - obdcount = atoi(buf); - uuids = (struct obd_uuid *)malloc(obdcount * - sizeof(struct obd_uuid)); - if (uuids == NULL) - return -ENOMEM; + obdcount = atoi(buf); + uuids = malloc(obdcount * sizeof(struct obd_uuid)); + if (uuids == NULL) + return -ENOMEM; retry_get_uuids: - ret = llapi_get_target_uuids(dirfd(dir), uuids, &obdcount, type); - if (ret) { - struct obd_uuid *uuids_temp; + ret = llapi_get_target_uuids(dirfd(dir), uuids, &obdcount, type); + if (ret) { + if (ret == -EOVERFLOW) { + struct obd_uuid *uuids_temp; - if (ret == -EOVERFLOW) { - uuids_temp = realloc(uuids, obdcount * - sizeof(struct obd_uuid)); + uuids_temp = realloc(uuids, obdcount * + sizeof(struct obd_uuid)); if (uuids_temp != NULL) { uuids = uuids_temp; - goto retry_get_uuids; + goto retry_get_uuids; } - else - ret = -ENOMEM; - } + ret = -ENOMEM; + } - llapi_error(LLAPI_MSG_ERROR, ret, "get ost uuid failed"); - goto out_free; - } + llapi_error(LLAPI_MSG_ERROR, ret, "cannot get ost uuid"); + goto out_free; + } indexes = malloc(num_obds * sizeof(*obdindex)); if (indexes == NULL) { @@ -2166,14 +2315,14 @@ retry_get_uuids: } } } - if (i >= obdcount) { - indexes[obdnum] = OBD_NOT_FOUND; - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: unknown obduuid: %s", - __func__, obduuids[obdnum].uuid); - ret = -EINVAL; - } - } + if (i >= obdcount) { + indexes[obdnum] = OBD_NOT_FOUND; + llapi_err_noerrno(LLAPI_MSG_ERROR, + "invalid obduuid '%s'", + obduuids[obdnum].uuid); + ret = -EINVAL; + } + } if (obd_valid == 0) *obdindex = OBD_NOT_FOUND; @@ -2217,80 +2366,17 @@ static int setup_target_indexes(DIR *dir, char *path, struct find_param *param) int llapi_ostlist(char *path, struct find_param *param) { - DIR *dir; - int ret; - - dir = opendir(path); - if (dir == NULL) - return -errno; - - ret = setup_obd_uuid(dir, path, param); - closedir(dir); - - return ret; -} - -/* - * Given a filesystem name, or a pathname of a file on a lustre filesystem, - * tries to determine the path to the filesystem's clilov directory under /proc - * - * fsname is limited to MTI_NAME_MAXLEN in lustre_idl.h - * The NUL terminator is compensated by the additional "%s" bytes. */ -#define LOV_LEN (sizeof("/proc/fs/lustre/lov/%s-clilov-*") + MTI_NAME_MAXLEN) -static int clilovpath(const char *fsname, const char *const pathname, - char *clilovpath) -{ - int rc; - char pattern[LOV_LEN]; - char buffer[PATH_MAX + 1]; - - if (fsname == NULL) { - rc = llapi_search_fsname(pathname, buffer); - if (rc != 0) - return rc; - fsname = buffer; - } - - snprintf(pattern, sizeof(pattern), "/proc/fs/lustre/lov/%s-clilov-*", - fsname); - - rc = first_match(pattern, buffer); - if (rc != 0) - return rc; - - strlcpy(clilovpath, buffer, sizeof(buffer)); - - return 0; -} - -/* - * Given the path to a stripe attribute proc file, tries to open and - * read the attribute and return the value using the attr parameter - */ -static int sattr_read_attr(const char *const fpath, - unsigned int *attr) -{ - - FILE *f; - char line[PATH_MAX + 1]; - int rc = 0; + int fd; + int ret; - f = fopen(fpath, "r"); - if (f == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "Cannot open '%s'", fpath); - return rc; - } + fd = open(path, O_RDONLY | O_DIRECTORY); + if (fd < 0) + return -errno; - if (fgets(line, sizeof(line), f) != NULL) { - *attr = atoi(line); - } else { - llapi_error(LLAPI_MSG_ERROR, errno, "Cannot read from '%s'", fpath); - rc = 1; - } + ret = setup_obd_uuid(fd, path, param); + close(fd); - fclose(f); - return rc; + return ret; } /* @@ -2299,41 +2385,38 @@ static int sattr_read_attr(const char *const fpath, * using pathname. */ static int sattr_get_defaults(const char *const fsname, - const char *const pathname, unsigned int *scount, unsigned int *ssize, unsigned int *soffset) { - int rc; - char dpath[PATH_MAX + 1]; - char fpath[PATH_MAX + 1]; - - rc = clilovpath(fsname, pathname, dpath); - if (rc != 0) - return rc; + char val[PATH_MAX]; + int rc; - if (scount) { - snprintf(fpath, PATH_MAX, "%s/stripecount", dpath); - rc = sattr_read_attr(fpath, scount); - if (rc != 0) - return rc; - } + if (scount) { + rc = get_lustre_param_value("lov", fsname, FILTER_BY_FS_NAME, + "stripecount", val, sizeof(val)); + if (rc != 0) + return rc; + *scount = atoi(val); + } - if (ssize) { - snprintf(fpath, PATH_MAX, "%s/stripesize", dpath); - rc = sattr_read_attr(fpath, ssize); - if (rc != 0) - return rc; - } + if (ssize) { + rc = get_lustre_param_value("lov", fsname, FILTER_BY_FS_NAME, + "stripesize", val, sizeof(val)); + if (rc != 0) + return rc; + *ssize = atoi(val); + } - if (soffset) { - snprintf(fpath, PATH_MAX, "%s/stripeoffset", dpath); - rc = sattr_read_attr(fpath, soffset); - if (rc != 0) - return rc; - } + if (soffset) { + rc = get_lustre_param_value("lov", fsname, FILTER_BY_FS_NAME, + "stripeoffset", val, sizeof(val)); + if (rc != 0) + return rc; + *soffset = atoi(val); + } - return 0; + return 0; } /* @@ -2342,11 +2425,9 @@ static int sattr_get_defaults(const char *const fsname, * next time they are needed. Only a single filesystem's attributes are * cached at a time. */ -static int sattr_cache_get_defaults(const char *const fsname, - const char *const pathname, - unsigned int *scount, - unsigned int *ssize, - unsigned int *soffset) +int sattr_cache_get_defaults(const char *const fsname, + const char *const pathname, unsigned int *scount, + unsigned int *ssize, unsigned int *soffset) { static struct { char fsname[PATH_MAX + 1]; @@ -2366,7 +2447,7 @@ static int sattr_cache_get_defaults(const char *const fsname, if (rc) return rc; } else { - strlcpy(fsname_buf, fsname, sizeof(fsname_buf)); + snprintf(fsname_buf, sizeof(fsname_buf), "%s", fsname); } if (strncmp(fsname_buf, cache.fsname, sizeof(fsname_buf) - 1) != 0) { @@ -2375,15 +2456,14 @@ static int sattr_cache_get_defaults(const char *const fsname, * successfully retrieved and stored in tmp before writing to * cache. */ - rc = sattr_get_defaults(fsname_buf, NULL, &tmp[0], &tmp[1], - &tmp[2]); + rc = sattr_get_defaults(fsname_buf, &tmp[0], &tmp[1], &tmp[2]); if (rc != 0) return rc; cache.stripecount = tmp[0]; cache.stripesize = tmp[1]; cache.stripeoffset = tmp[2]; - strlcpy(cache.fsname, fsname_buf, sizeof(cache.fsname)); + snprintf(cache.fsname, sizeof(cache.fsname), "%s", fsname_buf); } if (scount) @@ -2396,163 +2476,286 @@ static int sattr_cache_get_defaults(const char *const fsname, return 0; } -static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, - struct lov_user_ost_data_v1 *objects, - int is_dir, int verbose, int depth, - int raw, char *pool_name) +static char *layout2name(__u32 layout_pattern) { - char *prefix = is_dir ? "" : "lmm_"; + if (layout_pattern == LOV_PATTERN_MDT) + return "mdt"; + else if (layout_pattern == LOV_PATTERN_RAID0) + return "raid0"; + else if (layout_pattern == (LOV_PATTERN_RAID0 | LOV_PATTERN_F_RELEASED)) + return "released"; + else + return "unknown"; +} + +enum lov_dump_flags { + LDF_IS_DIR = 0x0001, + LDF_IS_RAW = 0x0002, + LDF_INDENT = 0x0004, + LDF_SKIP_OBJS = 0x0008, + LDF_YAML = 0x0010, +}; + +static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, + struct lov_user_ost_data_v1 *objects, + enum llapi_layout_verbose verbose, + int depth, char *pool_name, + enum lov_dump_flags flags) +{ + bool is_dir = flags & LDF_IS_DIR; + bool is_raw = flags & LDF_IS_RAW; + bool indent = flags & LDF_INDENT; + bool yaml = flags & LDF_YAML; + bool skip_objs = flags & LDF_SKIP_OBJS; + char *prefix = is_dir ? "" : "lmm_"; char *separator = ""; - int rc; + char *space = indent ? " " : ""; + int rc; if (is_dir && lmm_oi_seq(&lum->lmm_oi) == FID_SEQ_LOV_DEFAULT) { lmm_oi_set_seq(&lum->lmm_oi, 0); - if (verbose & VERBOSE_DETAIL) - llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); + if (!indent && (verbose & VERBOSE_DETAIL)) + llapi_printf(LLAPI_MSG_NORMAL, "%s(Default) ", space); } - if (depth && path && ((verbose != VERBOSE_OBJID) || !is_dir)) - llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); + if (!yaml && !indent && depth && path && + ((verbose != VERBOSE_OBJID) || !is_dir)) + llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); if ((verbose & VERBOSE_DETAIL) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "lmm_magic: 0x%08X\n", - lum->lmm_magic); - llapi_printf(LLAPI_MSG_NORMAL, "lmm_seq: "LPX64"\n", - lmm_oi_seq(&lum->lmm_oi)); - llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n", - lmm_oi_id(&lum->lmm_oi)); - } - - if (verbose & VERBOSE_COUNT) { - if (verbose & ~VERBOSE_COUNT) - llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_count: ", - prefix); - if (is_dir) { - if (!raw && lum->lmm_stripe_count == 0) { - unsigned int scount; - rc = sattr_cache_get_defaults(NULL, path, - &scount, NULL, - NULL); - if (rc == 0) - 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, "%s%smagic: 0x%08X\n", + space, prefix, lum->lmm_magic); + llapi_printf(LLAPI_MSG_NORMAL, "%s%sseq: %#jx\n", + space, prefix, + (uintmax_t)lmm_oi_seq(&lum->lmm_oi)); + llapi_printf(LLAPI_MSG_NORMAL, "%s%sobject_id: %#jx\n", + space, prefix, + (uintmax_t)lmm_oi_id(&lum->lmm_oi)); + } + if ((verbose & (VERBOSE_DETAIL | VERBOSE_DFID)) && !is_dir) { + __u64 seq; + __u32 oid; + __u32 ver; + + if (verbose & ~VERBOSE_DFID) + llapi_printf(LLAPI_MSG_NORMAL, "%slmm_fid: ", + space); + /* This needs a bit of hand-holding since old 1.x lmm_oi + * have { oi.oi_id = mds_inum, oi.oi_seq = 0 } and 2.x lmm_oi + * have { oi.oi_id = mds_oid, oi.oi_seq = mds_seq } instead of + * a real FID. Ideally the 2.x code would have stored this + * like a FID with { oi_id = mds_seq, oi_seq = mds_oid } so the + * ostid union lu_fid { f_seq = mds_seq, f_oid = mds_oid } + * worked properly (especially since IGIF FIDs use mds_inum as + * the FID SEQ), but unfortunately that didn't happen. + * + * Print it to look like an IGIF FID, even though the fields + * are reversed on disk, so that it makes sense to userspace. + * + * Don't use ostid_id() and ostid_seq(), since they assume the + * oi_fid fields are in the right order. This is why there are + * separate lmm_oi_seq() and lmm_oi_id() routines for this. + * + * For newer layout types hopefully this will be a real FID. */ + seq = lmm_oi_seq(&lum->lmm_oi) == 0 ? + lmm_oi_id(&lum->lmm_oi) : lmm_oi_seq(&lum->lmm_oi); + oid = lmm_oi_seq(&lum->lmm_oi) == 0 ? + 0 : (__u32)lmm_oi_id(&lum->lmm_oi); + ver = (__u32)(lmm_oi_id(&lum->lmm_oi) >> 32); + if (yaml) + llapi_printf(LLAPI_MSG_NORMAL, DFID_NOBRACE"\n", + seq, oid, ver); + else + llapi_printf(LLAPI_MSG_NORMAL, DFID"\n", + seq, oid, ver); + } + + if (verbose & VERBOSE_STRIPE_COUNT) { + if (verbose & ~VERBOSE_STRIPE_COUNT) + llapi_printf(LLAPI_MSG_NORMAL, "%s%sstripe_count: ", + space, prefix); + if (is_dir) { + if (!is_raw && lum->lmm_stripe_count == 0 && + lov_pattern(lum->lmm_pattern) != LOV_PATTERN_MDT) { + unsigned int scount; + rc = sattr_cache_get_defaults(NULL, path, + &scount, NULL, + NULL); + if (rc == 0) + 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", - lum->lmm_stripe_count == - (typeof(lum->lmm_stripe_count))(-1) + lum->lmm_stripe_count == + (typeof(lum->lmm_stripe_count))(-1) ? -1 : lum->lmm_stripe_count); - } - } else { + } + } else { llapi_printf(LLAPI_MSG_NORMAL, "%hd", (__s16)lum->lmm_stripe_count); - } - separator = is_dir ? " " : "\n"; - } + } + if (!yaml && is_dir) + separator = " "; + else + separator = "\n"; + } - if (verbose & VERBOSE_SIZE) { + if (verbose & VERBOSE_STRIPE_SIZE) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_SIZE) - llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_size: ", - prefix); - if (is_dir && !raw && lum->lmm_stripe_size == 0) { - unsigned int ssize; - rc = sattr_cache_get_defaults(NULL, path, NULL, &ssize, - NULL); - if (rc == 0) + if (verbose & ~VERBOSE_STRIPE_SIZE) + llapi_printf(LLAPI_MSG_NORMAL, "%s%sstripe_size: ", + space, prefix); + if (is_dir && !is_raw && lum->lmm_stripe_size == 0) { + unsigned int ssize; + rc = sattr_cache_get_defaults(NULL, path, NULL, &ssize, + NULL); + if (rc == 0) llapi_printf(LLAPI_MSG_NORMAL, "%u", ssize); - else - llapi_error(LLAPI_MSG_ERROR, rc, - "Cannot determine default" - " stripe size."); - } else { + else + llapi_error(LLAPI_MSG_ERROR, rc, + "Cannot determine default" + " stripe size."); + } else { llapi_printf(LLAPI_MSG_NORMAL, "%u", lum->lmm_stripe_size); - } - separator = is_dir ? " " : "\n"; - } + } + if (!yaml && is_dir) + separator = " "; + else + separator = "\n"; + } - if ((verbose & VERBOSE_LAYOUT) && !is_dir) { + if ((verbose & VERBOSE_PATTERN)) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_LAYOUT) - llapi_printf(LLAPI_MSG_NORMAL, "%spattern: ", - prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%.x", lum->lmm_pattern); - separator = "\n"; + if (verbose & ~VERBOSE_PATTERN) + llapi_printf(LLAPI_MSG_NORMAL, "%s%spattern: ", + space, prefix); + if (lov_pattern_supported(lum->lmm_pattern)) + llapi_printf(LLAPI_MSG_NORMAL, "%s", + layout2name(lum->lmm_pattern)); + else + llapi_printf(LLAPI_MSG_NORMAL, "%x", lum->lmm_pattern); + separator = (!yaml && is_dir) ? " " : "\n"; } - if ((verbose & VERBOSE_GENERATION) && !is_dir) { + if ((verbose & VERBOSE_GENERATION) && !is_dir) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_GENERATION) - llapi_printf(LLAPI_MSG_NORMAL, "%slayout_gen: ", - prefix); + if (verbose & ~VERBOSE_GENERATION) + llapi_printf(LLAPI_MSG_NORMAL, "%s%slayout_gen: ", + space, prefix); llapi_printf(LLAPI_MSG_NORMAL, "%u", - (int)lum->lmm_layout_gen); + skip_objs ? 0 : (int)lum->lmm_layout_gen); separator = "\n"; - } + } - if (verbose & VERBOSE_OFFSET) { + if (verbose & VERBOSE_STRIPE_OFFSET) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_OFFSET) - llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ", - prefix); - if (is_dir) + if (verbose & ~VERBOSE_STRIPE_OFFSET) + llapi_printf(LLAPI_MSG_NORMAL, "%s%sstripe_offset: ", + space, prefix); + if (is_dir || skip_objs) llapi_printf(LLAPI_MSG_NORMAL, "%d", - lum->lmm_stripe_offset == - (typeof(lum->lmm_stripe_offset))(-1) ? -1 : + lum->lmm_stripe_offset == + (typeof(lum->lmm_stripe_offset))(-1) ? -1 : lum->lmm_stripe_offset); - else + else if (lov_pattern(lum->lmm_pattern) == LOV_PATTERN_MDT) + llapi_printf(LLAPI_MSG_NORMAL, "0"); + else llapi_printf(LLAPI_MSG_NORMAL, "%u", objects[0].l_ost_idx); - separator = is_dir ? " " : "\n"; - } + if (!yaml && is_dir) + separator = " "; + else + separator = "\n"; + } - if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) { + if ((verbose & VERBOSE_POOL) && pool_name && (pool_name[0] != '\0')) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_POOL) - llapi_printf(LLAPI_MSG_NORMAL, "%spool: ", - prefix); + if (verbose & ~VERBOSE_POOL) + llapi_printf(LLAPI_MSG_NORMAL, "%s%spool: ", + space, prefix); llapi_printf(LLAPI_MSG_NORMAL, "%s", pool_name); - } + if (!yaml && is_dir) + separator = " "; + else + separator = "\n"; + } - if (!is_dir || (is_dir && (verbose != VERBOSE_OBJID))) - llapi_printf(LLAPI_MSG_NORMAL, "\n"); + if (strlen(separator) != 0) + llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, - struct lov_user_ost_data_v1 *objects, - char *path, int is_dir, int obdindex, - int depth, int header, int raw) -{ - int i, obdstripe = (obdindex != OBD_NOT_FOUND) ? 0 : 1; + struct lov_user_ost_data_v1 *objects, + char *path, int obdindex, int depth, + enum llapi_layout_verbose verbose, + enum lov_dump_flags flags) +{ + bool is_dir = flags & LDF_IS_DIR; + bool indent = flags & LDF_INDENT; + bool skip_objs = flags & LDF_SKIP_OBJS; + bool yaml = flags & LDF_YAML; + bool obdstripe = obdindex == OBD_NOT_FOUND; + int i; - if (!obdstripe) { - for (i = 0; !is_dir && i < lum->lmm_stripe_count; i++) { - if (obdindex == objects[i].l_ost_idx) { - obdstripe = 1; - break; - } - } - } + if (!obdstripe && !skip_objs) { + for (i = 0; !is_dir && i < lum->lmm_stripe_count; i++) { + if (obdindex == objects[i].l_ost_idx) { + obdstripe = true; + break; + } + } + } - if (obdstripe == 1) - lov_dump_user_lmm_header(lum, path, objects, is_dir, header, - depth, raw, pool_name); - - 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"); - - for (i = 0; i < lum->lmm_stripe_count; i++) { - int idx = objects[i].l_ost_idx; - long long oid = ostid_id(&objects[i].l_ost_oi); - long long gr = ostid_seq(&objects[i].l_ost_oi); - if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) { + if (!obdstripe) + return; + + lov_dump_user_lmm_header(lum, path, objects, verbose, depth, pool_name, + flags); + + if (!is_dir && !skip_objs && (verbose & VERBOSE_OBJID) && + !(lum->lmm_pattern & LOV_PATTERN_F_RELEASED || + lov_pattern(lum->lmm_pattern) == LOV_PATTERN_MDT)) { + char *space = " - "; + + if (indent) + llapi_printf(LLAPI_MSG_NORMAL, + "%6slmm_objects:\n", " "); + else if (yaml) + llapi_printf(LLAPI_MSG_NORMAL, "lmm_objects:\n"); + else + llapi_printf(LLAPI_MSG_NORMAL, + "\tobdidx\t\t objid\t\t objid\t\t group\n"); + + for (i = 0; i < lum->lmm_stripe_count; i++) { + int idx = objects[i].l_ost_idx; + long long oid = ostid_id(&objects[i].l_ost_oi); + long long gr = ostid_seq(&objects[i].l_ost_oi); + + if (obdindex != OBD_NOT_FOUND && obdindex != idx) + continue; + + if (yaml) { + struct lu_fid fid = { 0 }; + + ostid_to_fid(&fid, &objects[i].l_ost_oi, idx); + llapi_printf(LLAPI_MSG_NORMAL, + "%sl_ost_idx: %d\n", space, idx); + llapi_printf(LLAPI_MSG_NORMAL, + "%8sl_fid: "DFID_NOBRACE"\n", + " ", PFID(&fid)); + } else if (indent) { + struct lu_fid fid = { 0 }; + + ostid_to_fid(&fid, &objects[i].l_ost_oi, idx); + llapi_printf(LLAPI_MSG_NORMAL, + "%s%d: { l_ost_idx: %d, l_fid: "DFID" }\n", + space, i, idx, PFID(&fid)); + } else { char fmt[48]; sprintf(fmt, "%s%s%s\n", "\t%6u\t%14llu\t%#13llx\t", @@ -2563,37 +2766,40 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, oid, gr, obdindex == idx ? " *" : ""); } - - } - llapi_printf(LLAPI_MSG_NORMAL, "\n"); - } + } + } + llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, - char *path, int obdindex, int depth, int verbose) + char *path, int obdindex, int depth, + enum llapi_layout_verbose verbose, + enum lov_dump_flags flags) { struct lmv_user_mds_data *objects = lum->lum_objects; char *prefix = lum->lum_magic == LMV_USER_MAGIC ? "(Default)" : ""; - int i, obdstripe = 0; char *separator = ""; + bool yaml = flags & LDF_YAML; + bool obdstripe = false; + int i; if (obdindex != OBD_NOT_FOUND) { if (lum->lum_stripe_count == 0) { if (obdindex == lum->lum_stripe_offset) - obdstripe = 1; + obdstripe = true; } 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; + obdstripe = true; break; } } } } else { - obdstripe = 1; + obdstripe = true; } if (!obdstripe) @@ -2602,7 +2808,8 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, /* show all information default */ if (!verbose) { if (lum->lum_magic == LMV_USER_MAGIC) - verbose = VERBOSE_POOL | VERBOSE_COUNT | VERBOSE_OFFSET; + verbose = VERBOSE_POOL | VERBOSE_STRIPE_COUNT | + VERBOSE_STRIPE_OFFSET | VERBOSE_HASH_TYPE; else verbose = VERBOSE_OBJID; } @@ -2610,30 +2817,58 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, if (depth && path && ((verbose != VERBOSE_OBJID))) llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, path); - if (verbose & VERBOSE_COUNT) { + if (verbose & VERBOSE_STRIPE_COUNT) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_COUNT) + if (verbose & ~VERBOSE_STRIPE_COUNT) llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_count: "); llapi_printf(LLAPI_MSG_NORMAL, "%u", (int)lum->lum_stripe_count); - if (verbose & VERBOSE_OFFSET) + if ((verbose & VERBOSE_STRIPE_OFFSET) && !yaml) separator = " "; else separator = "\n"; } - if (verbose & VERBOSE_OFFSET) { + if (verbose & VERBOSE_STRIPE_OFFSET) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (verbose & ~VERBOSE_OFFSET) + if (verbose & ~VERBOSE_STRIPE_OFFSET) llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_offset: "); llapi_printf(LLAPI_MSG_NORMAL, "%d", (int)lum->lum_stripe_offset); + if (verbose & VERBOSE_HASH_TYPE && !yaml) + separator = " "; + else + separator = "\n"; + } + + if (verbose & VERBOSE_HASH_TYPE) { + unsigned int type = lum->lum_hash_type & LMV_HASH_TYPE_MASK; + unsigned int flags = lum->lum_hash_type & ~LMV_HASH_TYPE_MASK; + + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_HASH_TYPE) + llapi_printf(LLAPI_MSG_NORMAL, "lmv_hash_type: "); + if (type < LMV_HASH_TYPE_MAX) + llapi_printf(LLAPI_MSG_NORMAL, "%s", + mdt_hash_name[type]); + else + llapi_printf(LLAPI_MSG_NORMAL, "%#x", type); + + if (flags & LMV_HASH_FLAG_MIGRATION) + llapi_printf(LLAPI_MSG_NORMAL, ",migrating"); + if (flags & LMV_HASH_FLAG_DEAD) + llapi_printf(LLAPI_MSG_NORMAL, ",dead"); + if (flags & LMV_HASH_FLAG_BAD_TYPE) + llapi_printf(LLAPI_MSG_NORMAL, ",bad_type"); + if (flags & LMV_HASH_FLAG_LOST_LMV) + llapi_printf(LLAPI_MSG_NORMAL, ",lost_lmv"); separator = "\n"; + } 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) + if (lum->lum_stripe_count > 0) llapi_printf(LLAPI_MSG_NORMAL, "mdtidx\t\t FID[seq:oid:ver]\n"); for (i = 0; i < lum->lum_stripe_count; i++) { @@ -2662,50 +2897,658 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, llapi_printf(LLAPI_MSG_NORMAL, "\n"); } -void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) +static void lov_dump_comp_v1_header(struct find_param *param, char *path, + enum lov_dump_flags flags) { - __u32 magic; + struct lov_comp_md_v1 *comp_v1 = (void *)¶m->fp_lmd->lmd_lmm; + int depth = param->fp_max_depth; + enum llapi_layout_verbose verbose = param->fp_verbose; + bool yaml = flags & LDF_YAML; - if (param->fp_get_lmv || param->fp_get_default_lmv) - magic = (__u32)param->fp_lmv_md->lum_magic; + if (depth && path && ((verbose != VERBOSE_OBJID) || + !(flags & LDF_IS_DIR)) && !yaml) + llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); + + if (verbose & VERBOSE_DETAIL) { + llapi_printf(LLAPI_MSG_NORMAL, "composite_header:\n"); + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_magic: 0x%08X\n", + " ", comp_v1->lcm_magic); + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_size: %u\n", + " ", comp_v1->lcm_size); + if (flags & LDF_IS_DIR) + llapi_printf(LLAPI_MSG_NORMAL, + "%2slcm_flags: %s\n", " ", + comp_v1->lcm_mirror_count > 0 ? + "mirrored" : ""); + else + llapi_printf(LLAPI_MSG_NORMAL, + "%2slcm_flags: %s\n", " ", + llapi_layout_flags_string(comp_v1->lcm_flags)); + } + + if (verbose & VERBOSE_GENERATION) { + if (verbose & ~VERBOSE_GENERATION) + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_layout_gen: ", + " "); + llapi_printf(LLAPI_MSG_NORMAL, "%u\n", comp_v1->lcm_layout_gen); + } + + if (verbose & VERBOSE_MIRROR_COUNT) { + if (verbose & ~VERBOSE_MIRROR_COUNT) + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_mirror_count: ", + " "); + llapi_printf(LLAPI_MSG_NORMAL, "%u\n", + comp_v1->lcm_magic == LOV_USER_MAGIC_COMP_V1 ? + comp_v1->lcm_mirror_count + 1 : 1); + } + + if (verbose & VERBOSE_COMP_COUNT) { + if (verbose & ~VERBOSE_COMP_COUNT) + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_entry_count: ", + " "); + llapi_printf(LLAPI_MSG_NORMAL, "%u\n", + comp_v1->lcm_magic == LOV_USER_MAGIC_COMP_V1 ? + comp_v1->lcm_entry_count : 0); + } + + if (verbose & VERBOSE_DETAIL && !yaml) + llapi_printf(LLAPI_MSG_NORMAL, "components:\n"); +} + +static void lcme_flags2str(__u32 comp_flags) +{ + bool found = false; + int i = 0; + + if (!comp_flags) { + llapi_printf(LLAPI_MSG_NORMAL, "0"); + return; + } + for (i = 0; i < ARRAY_SIZE(comp_flags_table); i++) { + if (comp_flags & comp_flags_table[i].cfn_flag) { + if (found) + llapi_printf(LLAPI_MSG_NORMAL, ","); + llapi_printf(LLAPI_MSG_NORMAL, "%s", + comp_flags_table[i].cfn_name); + comp_flags &= ~comp_flags_table[i].cfn_flag; + found = true; + } + } + if (comp_flags) { + if (found) + llapi_printf(LLAPI_MSG_NORMAL, ","); + llapi_printf(LLAPI_MSG_NORMAL, "%#x", comp_flags); + } +} + +static void lov_dump_comp_v1_entry(struct find_param *param, + enum lov_dump_flags flags, int index) +{ + struct lov_comp_md_v1 *comp_v1 = (void *)¶m->fp_lmd->lmd_lmm; + struct lov_comp_md_entry_v1 *entry; + char *separator = ""; + enum llapi_layout_verbose verbose = param->fp_verbose; + bool yaml = flags & LDF_YAML; + + entry = &comp_v1->lcm_entries[index]; + + if (yaml) + llapi_printf(LLAPI_MSG_NORMAL, "%2scomponent%d:\n", " ", index); + + if (verbose & VERBOSE_COMP_ID) { + if (verbose & VERBOSE_DETAIL && !yaml) + llapi_printf(LLAPI_MSG_NORMAL, + "%slcme_id: ", " - "); + else if (verbose & ~VERBOSE_COMP_ID) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_id: ", " "); + if (entry->lcme_id != LCME_ID_INVAL) + llapi_printf(LLAPI_MSG_NORMAL, "%u", entry->lcme_id); + else + llapi_printf(LLAPI_MSG_NORMAL, "N/A"); + separator = "\n"; + } + + if (verbose & VERBOSE_MIRROR_ID) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_MIRROR_ID) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_mirror_id: ", " "); + if (entry->lcme_id != LCME_ID_INVAL) + llapi_printf(LLAPI_MSG_NORMAL, "%u", + mirror_id_of(entry->lcme_id)); + else + llapi_printf(LLAPI_MSG_NORMAL, "N/A"); + separator = "\n"; + } + + if (verbose & VERBOSE_COMP_FLAGS) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_COMP_FLAGS) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_flags: ", " "); + lcme_flags2str(entry->lcme_flags); + separator = "\n"; + } + /* print snapshot timestamp if its a nosync comp */ + if ((verbose & VERBOSE_COMP_FLAGS) && + (entry->lcme_flags & LCME_FL_NOSYNC)) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_COMP_FLAGS) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_timestamp: ", " "); + if (yaml) { + llapi_printf(LLAPI_MSG_NORMAL, "%llu", + entry->lcme_timestamp); + } else { + time_t stamp = entry->lcme_timestamp; + char *date_str = asctime(localtime(&stamp)); + + date_str[strlen(date_str) - 1] = '\0'; + llapi_printf(LLAPI_MSG_NORMAL, "'%s'", date_str); + } + + separator = "\n"; + } + + if (verbose & VERBOSE_COMP_START) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_COMP_START) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_extent.e_start: ", " "); + llapi_printf(LLAPI_MSG_NORMAL, "%llu", + entry->lcme_extent.e_start); + separator = "\n"; + } + + if (verbose & VERBOSE_COMP_END) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_COMP_END) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_extent.e_end: ", " "); + if (entry->lcme_extent.e_end == LUSTRE_EOF) + llapi_printf(LLAPI_MSG_NORMAL, "%s", "EOF"); + else + llapi_printf(LLAPI_MSG_NORMAL, "%llu", + entry->lcme_extent.e_end); + separator = "\n"; + } + + if (yaml) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + llapi_printf(LLAPI_MSG_NORMAL, "%4ssub_layout:\n", " "); + } else if (verbose & VERBOSE_DETAIL) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + llapi_printf(LLAPI_MSG_NORMAL, "%4slcme_offset: %u\n", + " ", entry->lcme_offset); + llapi_printf(LLAPI_MSG_NORMAL, "%4slcme_size: %u\n", + " ", entry->lcme_size); + llapi_printf(LLAPI_MSG_NORMAL, "%4ssub_layout:\n", " "); + } else { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + } +} + +/* Check if the value matches 1 of the given criteria (e.g. --atime +/-N). + * @mds indicates if this is MDS timestamps and there are attributes on OSTs. + * + * The result is -1 if it does not match, 0 if not yet clear, 1 if matches. + * The table below gives the answers for the specified parameters (value and + * sign), 1st column is the answer for the MDS value, the 2nd is for the OST: + * -------------------------------------- + * 1 | file > limit; sign > 0 | -1 / -1 | + * 2 | file = limit; sign > 0 | -1 / -1 | + * 3 | file < limit; sign > 0 | ? / 1 | + * 4 | file > limit; sign = 0 | -1 / -1 | + * 5 | file = limit; sign = 0 | ? / 1 | <- (see the Note below) + * 6 | file < limit; sign = 0 | ? / -1 | + * 7 | file > limit; sign < 0 | 1 / 1 | + * 8 | file = limit; sign < 0 | ? / -1 | + * 9 | file < limit; sign < 0 | ? / -1 | + * -------------------------------------- + * Note: 5th actually means that the value is within the interval + * (limit - margin, limit]. */ +static int find_value_cmp(unsigned long long file, unsigned long long limit, + int sign, int negopt, unsigned long long margin, + int mds) +{ + int ret = -1; + + if (sign > 0) { + /* Drop the fraction of margin (of days). */ + if (file + margin <= limit) + ret = mds ? 0 : 1; + } else if (sign == 0) { + if (file <= limit && file + margin > limit) + ret = mds ? 0 : 1; + else if (file + margin <= limit) + ret = mds ? 0 : -1; + } else if (sign < 0) { + if (file > limit) + ret = 1; + else if (mds) + ret = 0; + } + + return negopt ? ~ret + 1 : ret; +} + +static inline struct lov_user_md * +lov_comp_entry(struct lov_comp_md_v1 *comp_v1, int ent_idx) +{ + return (struct lov_user_md *)((char *)comp_v1 + + comp_v1->lcm_entries[ent_idx].lcme_offset); +} + +static inline struct lov_user_ost_data_v1 * +lov_v1v3_objects(struct lov_user_md *v1) +{ + if (v1->lmm_magic == LOV_USER_MAGIC_V3) + return ((struct lov_user_md_v3 *)v1)->lmm_objects; else - magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; /* lum->lmm_magic */ + return v1->lmm_objects; +} - switch (magic) { - case LOV_USER_MAGIC_V1: +static inline void +lov_v1v3_pool_name(struct lov_user_md *v1, char *pool_name) +{ + if (v1->lmm_magic == LOV_USER_MAGIC_V3) + snprintf(pool_name, LOV_MAXPOOLNAME, "%s", + ((struct lov_user_md_v3 *)v1)->lmm_pool_name); + else + pool_name[0] = '\0'; +} + +static inline bool +print_last_init_comp(struct find_param *param) +{ + /* print all component info */ + if ((param->fp_verbose & VERBOSE_DEFAULT) == VERBOSE_DEFAULT) + return false; + + /* print specific component info */ + if (param->fp_check_comp_id || param->fp_check_comp_flags || + param->fp_check_comp_start || param->fp_check_comp_end || + param->fp_check_mirror_id || param->fp_check_mirror_index) + return false; + + return true; +} + +static int find_comp_end_cmp(unsigned long long end, struct find_param *param) +{ + int match; + + if (param->fp_comp_end == LUSTRE_EOF) { + if (param->fp_comp_end_sign == 0) /* equal to EOF */ + match = end == LUSTRE_EOF ? 1 : -1; + else if (param->fp_comp_end_sign > 0) /* at most EOF */ + match = end == LUSTRE_EOF ? -1 : 1; + else /* at least EOF */ + match = -1; + if (param->fp_exclude_comp_end) + match = ~match + 1; + } else { + unsigned long long margin; + + margin = end == LUSTRE_EOF ? 0 : param->fp_comp_end_units; + match = find_value_cmp(end, param->fp_comp_end, + param->fp_comp_end_sign, + param->fp_exclude_comp_end, margin, 0); + } + + return match; +} + +/** + * An example of "getstripe -v" for a two components PFL file: + * + * composite_header: + * lcm_magic: 0x0BD60BD0 + * lcm_size: 264 + * lcm_flags: 0 + * lcm_layout_gen: 2 + * lcm_entry_count: 2 + * components: + * - lcme_id: 1 + * lcme_flags: 0x10 + * lcme_extent.e_start: 0 + * lcme_extent.e_end: 1048576 + * lcme_offset: 128 + * lcme_size: 56 + * sub_layout: + * lmm_magic: 0x0BD10BD0 + * lmm_seq: 0x200000401 + * lmm_object_id: 0x1 + * lmm_fid: [0x200000401:0x1:0x0] + * lmm_stripe_count: 1 + * lmm_stripe_size: 1048576 + * lmm_pattern: raid0 + * lmm_layout_gen: 0 + * lmm_stripe_offset: 0 + * lmm_objects: + * - 0: { l_ost_idx: 0, l_fid: [0x100000000:0x2:0x0] } + * + * - lcme_id: 2 + * lcme_flags: 0x10 + * lcme_extent.e_start: 1048576 + * lcme_extent.e_end: EOF + * lcme_offset: 184 + * lcme_size: 80 + * sub_layout: + * lmm_magic: 0x0BD10BD0 + * lmm_seq: 0x200000401 + * lmm_object_id: 0x1 + * lmm_fid: [0x200000401:0x1:0x0] + * lmm_stripe_count: 2 + * lmm_stripe_size: 1048576 + * lmm_pattern: raid0 + * lmm_layout_gen: 0 + * lmm_stripe_offset: 1 + * lmm_objects: + * - 0: { l_ost_idx: 1, l_fid: [0x100010000:0x2:0x0] } + * - 1: { l_ost_idx: 0, l_fid: [0x100000000:0x3:0x0] } + */ +static void lov_dump_comp_v1(struct find_param *param, char *path, + enum lov_dump_flags flags) +{ + struct lov_comp_md_entry_v1 *entry; + struct lov_user_ost_data_v1 *objects; + struct lov_comp_md_v1 *comp_v1 = (void *)¶m->fp_lmd->lmd_lmm; + struct lov_user_md_v1 *v1; + char pool_name[LOV_MAXPOOLNAME + 1]; + int obdindex = param->fp_obd_index; + int i, j, match; + bool obdstripe = false; + __u16 mirror_index = 0; + __u16 mirror_id = 0; + + if (obdindex != OBD_NOT_FOUND) { + for (i = 0; !(flags & LDF_IS_DIR) && !obdstripe && + i < comp_v1->lcm_entry_count; i++) { + if (!(comp_v1->lcm_entries[i].lcme_flags & + LCME_FL_INIT)) + continue; + + v1 = lov_comp_entry(comp_v1, i); + objects = lov_v1v3_objects(v1); + + for (j = 0; j < v1->lmm_stripe_count; j++) { + if (obdindex == objects[j].l_ost_idx) { + obdstripe = true; + break; + } + } + } + } else { + obdstripe = true; + } + + if (!obdstripe) + return; + + lov_dump_comp_v1_header(param, path, flags); + + flags |= LDF_INDENT; + + for (i = 0; i < comp_v1->lcm_entry_count; i++) { + entry = &comp_v1->lcm_entries[i]; + + if (param->fp_check_comp_flags) { + if (((param->fp_comp_flags & entry->lcme_flags) != + param->fp_comp_flags) || + (param->fp_comp_neg_flags & entry->lcme_flags)) + continue; + } + + if (param->fp_check_comp_id && + param->fp_comp_id != entry->lcme_id) + continue; + + if (param->fp_check_comp_start) { + match = find_value_cmp(entry->lcme_extent.e_start, + param->fp_comp_start, + param->fp_comp_start_sign, + 0, + param->fp_comp_start_units, 0); + if (match == -1) + continue; + } + + if (param->fp_check_comp_end) { + match = find_comp_end_cmp(entry->lcme_extent.e_end, + param); + if (match == -1) + continue; + } + + if (param->fp_check_mirror_index) { + if (mirror_id != mirror_id_of(entry->lcme_id)) { + mirror_index++; + mirror_id = mirror_id_of(entry->lcme_id); + } + + match = find_value_cmp(mirror_index, + param->fp_mirror_index, + param->fp_mirror_index_sign, + param->fp_exclude_mirror_index, + 1, 0); + if (match == -1) + continue; + } else if (param->fp_check_mirror_id) { + if (mirror_id != mirror_id_of(entry->lcme_id)) + mirror_id = mirror_id_of(entry->lcme_id); + + match = find_value_cmp(mirror_id, + param->fp_mirror_id, + param->fp_mirror_id_sign, + param->fp_exclude_mirror_id, + 1, 0); + if (match == -1) + continue; + } + + if (print_last_init_comp(param)) { + /** + * if part of stripe info is needed, we'd print only + * the last instantiated component info. + */ + if (entry->lcme_flags & LCME_FL_INIT) + continue; + else + break; + } + + if (entry->lcme_flags & LCME_FL_INIT) { + if (obdindex != OBD_NOT_FOUND) { + flags |= LDF_SKIP_OBJS; + v1 = lov_comp_entry(comp_v1, i); + objects = lov_v1v3_objects(v1); + + for (j = 0; j < v1->lmm_stripe_count; j++) { + if (obdindex == objects[j].l_ost_idx) { + flags &= ~LDF_SKIP_OBJS; + break; + } + } + } else { + flags &= ~LDF_SKIP_OBJS; + } + } else { + flags |= LDF_SKIP_OBJS; + } + + if (obdindex != OBD_NOT_FOUND && (flags & LDF_SKIP_OBJS)) + continue; + lov_dump_comp_v1_entry(param, flags, i); + + v1 = lov_comp_entry(comp_v1, i); + objects = lov_v1v3_objects(v1); + lov_v1v3_pool_name(v1, pool_name); + + lov_dump_user_lmm_v1v3(v1, pool_name, objects, path, obdindex, + param->fp_max_depth, param->fp_verbose, + flags); + } + if (print_last_init_comp(param)) { + /** + * directory layout contains only layout template, print the + * last component. + */ + if (i == 0) + i = comp_v1->lcm_entry_count - 1; + else + i--; + flags &= ~LDF_SKIP_OBJS; + + lov_dump_comp_v1_entry(param, flags, i); + + v1 = lov_comp_entry(comp_v1, i); + objects = lov_v1v3_objects(v1); + lov_v1v3_pool_name(v1, pool_name); + + lov_dump_user_lmm_v1v3(v1, pool_name, objects, path, obdindex, + param->fp_max_depth, param->fp_verbose, + flags); + } +} + +#define VERBOSE_COMP_OPTS (VERBOSE_COMP_COUNT | VERBOSE_COMP_ID | \ + VERBOSE_COMP_START | VERBOSE_COMP_END | \ + VERBOSE_COMP_FLAGS) + +static inline bool has_any_comp_options(struct find_param *param) +{ + enum llapi_layout_verbose verbose = param->fp_verbose; + + if (param->fp_check_comp_id || param->fp_check_comp_count || + param->fp_check_comp_start || param->fp_check_comp_end || + param->fp_check_comp_flags) + return true; + + /* show full layout information, not component specific */ + if ((verbose & ~VERBOSE_DETAIL) == VERBOSE_DEFAULT) + return false; + + return verbose & VERBOSE_COMP_OPTS; +} + +struct lov_user_mds_data *lov_forge_comp_v1(struct lov_user_mds_data *orig, + bool is_dir) +{ + struct lov_user_md *lum = &orig->lmd_lmm; + struct lov_user_mds_data *new; + struct lov_comp_md_v1 *comp_v1; + struct lov_comp_md_entry_v1 *ent; + int lum_off = sizeof(*comp_v1) + sizeof(*ent); + int lum_size = lov_user_md_size(is_dir ? 0 : lum->lmm_stripe_count, + lum->lmm_magic); + + new = malloc(sizeof(lstat_t) + lum_off + lum_size); + if (new == NULL) { + llapi_printf(LLAPI_MSG_NORMAL, "out of memory\n"); + return new; + } + + memcpy(new, orig, sizeof(lstat_t)); + + comp_v1 = (struct lov_comp_md_v1 *)&new->lmd_lmm; + comp_v1->lcm_magic = lum->lmm_magic; + comp_v1->lcm_size = lum_off + lum_size; + comp_v1->lcm_layout_gen = is_dir ? 0 : lum->lmm_layout_gen; + comp_v1->lcm_flags = 0; + comp_v1->lcm_entry_count = 1; + + ent = &comp_v1->lcm_entries[0]; + ent->lcme_id = 0; + ent->lcme_flags = is_dir ? 0 : LCME_FL_INIT; + ent->lcme_extent.e_start = 0; + ent->lcme_extent.e_end = LUSTRE_EOF; + ent->lcme_offset = lum_off; + ent->lcme_size = lum_size; + + memcpy((char *)comp_v1 + lum_off, lum, lum_size); + + return new; +} + +static void lov_dump_plain_user_lmm(struct find_param *param, char *path, + enum lov_dump_flags flags) +{ + __u32 magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; + + if (has_any_comp_options(param)) { + struct lov_user_mds_data *new_lmd, *orig_lmd; + + orig_lmd = param->fp_lmd; + new_lmd = lov_forge_comp_v1(orig_lmd, flags & LDF_IS_DIR); + if (new_lmd != NULL) { + param->fp_lmd = new_lmd; + lov_dump_comp_v1(param, path, flags); + param->fp_lmd = orig_lmd; + free(new_lmd); + } + return; + } + + if (magic == LOV_USER_MAGIC_V1) { 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; + path, param->fp_obd_index, + param->fp_max_depth, param->fp_verbose, + flags); + } else { + char pool_name[LOV_MAXPOOLNAME + 1]; + struct lov_user_ost_data_v1 *objects; 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[0] == '\0' ? NULL : pool_name, - objects, path, is_dir, - param->fp_obd_index, param->fp_max_depth, - param->fp_verbose, param->fp_raw); - break; - } + snprintf(pool_name, sizeof(pool_name), "%s", + lmmv3->lmm_pool_name); + objects = lmmv3->lmm_objects; + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, pool_name, + objects, path, param->fp_obd_index, + param->fp_max_depth, param->fp_verbose, + flags); + } +} + +static void llapi_lov_dump_user_lmm(struct find_param *param, char *path, + enum lov_dump_flags flags) +{ + __u32 magic; + + if (param->fp_get_lmv || param->fp_get_default_lmv) + magic = (__u32)param->fp_lmv_md->lum_magic; + else + magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; /* lum->lmm_magic */ + + if (param->fp_raw) + flags |= LDF_IS_RAW; + if (param->fp_yaml) + flags |= LDF_YAML; + + switch (magic) { + case LOV_USER_MAGIC_V1: + case LOV_USER_MAGIC_V3: + case LOV_USER_MAGIC_SPECIFIC: + lov_dump_plain_user_lmm(param, path, flags); + break; case LMV_MAGIC_V1: case LMV_USER_MAGIC: { char pool_name[LOV_MAXPOOLNAME + 1]; struct lmv_user_md *lum; lum = (struct lmv_user_md *)param->fp_lmv_md; - strlcpy(pool_name, lum->lum_pool_name, sizeof(pool_name)); - lmv_dump_user_lmm(lum, - pool_name[0] == '\0' ? NULL : pool_name, - path, param->fp_obd_index, - param->fp_max_depth, param->fp_verbose); + snprintf(pool_name, sizeof(pool_name), "%s", + lum->lum_pool_name); + lmv_dump_user_lmm(lum, pool_name, path, param->fp_obd_index, + param->fp_max_depth, param->fp_verbose, + flags); break; } + case LOV_USER_MAGIC_COMP_V1: + lov_dump_comp_v1(param, path, flags); + break; default: llapi_printf(LLAPI_MSG_NORMAL, "unknown lmm_magic: %#x " "(expecting one of %#x %#x %#x %#x)\n", @@ -2718,44 +3561,44 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) int llapi_file_get_stripe(const char *path, struct lov_user_md *lum) { - const char *fname; - char *dname; - int fd, rc = 0; + const char *fname; + char *dname; + int fd, rc = 0; - fname = strrchr(path, '/'); + fname = strrchr(path, '/'); - /* It should be a file (or other non-directory) */ - if (fname == NULL) { - dname = (char *)malloc(2); - if (dname == NULL) - return -ENOMEM; - strcpy(dname, "."); - fname = (char *)path; - } else { - dname = (char *)malloc(fname - path + 1); - if (dname == NULL) - return -ENOMEM; - strncpy(dname, path, fname - path); - dname[fname - path] = '\0'; - fname++; - } + /* It should be a file (or other non-directory) */ + if (fname == NULL) { + dname = (char *)malloc(2); + if (dname == NULL) + return -ENOMEM; + strcpy(dname, "."); + fname = (char *)path; + } else { + dname = (char *)malloc(fname - path + 1); + if (dname == NULL) + return -ENOMEM; + strncpy(dname, path, fname - path); + dname[fname - path] = '\0'; + fname++; + } - fd = open(dname, O_RDONLY); - if (fd == -1) { - rc = -errno; - free(dname); - return rc; - } + fd = open(dname, O_RDONLY | O_NONBLOCK); + if (fd == -1) { + rc = -errno; + free(dname); + return rc; + } - strcpy((char *)lum, fname); - if (ioctl(fd, IOC_MDC_GETFILESTRIPE, (void *)lum) == -1) - rc = -errno; + strcpy((char *)lum, fname); + if (ioctl(fd, IOC_MDC_GETFILESTRIPE, (void *)lum) == -1) + rc = -errno; - if (close(fd) == -1 && rc == 0) - rc = -errno; + if (close(fd) == -1 && rc == 0) + rc = -errno; - free(dname); - return rc; + free(dname); + return rc; } int llapi_file_lookup(int dirfd, const char *name) @@ -2773,7 +3616,7 @@ int llapi_file_lookup(int dirfd, const char *name) data.ioc_inlbuf1 = (char *)name; data.ioc_inllen1 = strlen(name) + 1; - rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); + rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { llapi_error(LLAPI_MSG_ERROR, rc, "error: IOC_MDC_LOOKUP pack failed for '%s': rc %d", @@ -2787,50 +3630,6 @@ int llapi_file_lookup(int dirfd, const char *name) return rc; } -/* Check if the value matches 1 of the given criteria (e.g. --atime +/-N). - * @mds indicates if this is MDS timestamps and there are attributes on OSTs. - * - * The result is -1 if it does not match, 0 if not yet clear, 1 if matches. - * The table below gives the answers for the specified parameters (value and - * sign), 1st column is the answer for the MDS value, the 2nd is for the OST: - * -------------------------------------- - * 1 | file > limit; sign > 0 | -1 / -1 | - * 2 | file = limit; sign > 0 | -1 / -1 | - * 3 | file < limit; sign > 0 | ? / 1 | - * 4 | file > limit; sign = 0 | -1 / -1 | - * 5 | file = limit; sign = 0 | ? / 1 | <- (see the Note below) - * 6 | file < limit; sign = 0 | ? / -1 | - * 7 | file > limit; sign < 0 | 1 / 1 | - * 8 | file = limit; sign < 0 | ? / -1 | - * 9 | file < limit; sign < 0 | ? / -1 | - * -------------------------------------- - * Note: 5th actually means that the value is within the interval - * (limit - margin, limit]. */ -static int find_value_cmp(unsigned long long file, unsigned long long limit, - int sign, int negopt, unsigned long long margin, - int mds) -{ - int ret = -1; - - if (sign > 0) { - /* Drop the fraction of margin (of days). */ - if (file + margin <= limit) - ret = mds ? 0 : 1; - } else if (sign == 0) { - if (file <= limit && file + margin > limit) - ret = mds ? 0 : 1; - else if (file + margin <= limit) - ret = mds ? 0 : -1; - } else if (sign < 0) { - if (file > limit) - ret = 1; - else if (mds) - ret = 0; - } - - return negopt ? ~ret + 1 : ret; -} - /* Check if the file time matches all the given criteria (e.g. --atime +/-N). * Return -1 or 1 if file timestamp does not or does match the given criteria * correspondingly. Return 0 if the MDS time is being checked and there are @@ -2889,9 +3688,11 @@ static int find_time_check(lstat_t *st, struct find_param *param, int mds) */ static int check_obd_match(struct find_param *param) { + struct lov_user_ost_data_v1 *objects; + struct lov_comp_md_v1 *comp_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; lstat_t *st = ¶m->fp_lmd->lmd_st; - struct lov_user_ost_data_v1 *lmm_objects; - int i, j; + int i, j, k, count = 1; if (param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) return 0; @@ -2901,37 +3702,30 @@ static int check_obd_match(struct find_param *param) /* 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 (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + count = comp_v1->lcm_entry_count; + } - if (param->fp_lmd->lmd_lmm.lmm_magic == - LOV_USER_MAGIC_V3) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + for (i = 0; i < count; i++) { + if (comp_v1) + v1 = lov_comp_entry(comp_v1, i); - 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; - } + objects = lov_v1v3_objects(v1); - 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; + for (j = 0; j < v1->lmm_stripe_count; j++) { + if (comp_v1 && !(comp_v1->lcm_entries[i].lcme_flags & + LCME_FL_INIT)) + continue; + for (k = 0; k < param->fp_num_obds; k++) { + if (param->fp_obd_indexes[k] == + objects[j].l_ost_idx) + return !param->fp_exclude_obd; } } } - if (param->fp_exclude_obd) - return 1; - - return 0; + return param->fp_exclude_obd; } static int check_mdt_match(struct find_param *param) @@ -2962,9 +3756,10 @@ static int print_failed_tgt(struct find_param *param, char *path, int type) { struct obd_statfs stat_buf; struct obd_uuid uuid_buf; - int ret; + int ret; - LASSERT(type == LL_STATFS_LOV || type == LL_STATFS_LMV); + if (type != LL_STATFS_LOV && type != LL_STATFS_LMV) + return -EINVAL; memset(&stat_buf, 0, sizeof(struct obd_statfs)); memset(&uuid_buf, 0, sizeof(struct obd_uuid)); @@ -2981,20 +3776,286 @@ static int print_failed_tgt(struct find_param *param, char *path, int type) return ret; } +static int find_check_stripe_size(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + int ret, i, count = 1; + + if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + count = comp_v1->lcm_entry_count; + ret = param->fp_exclude_stripe_size ? 1 : -1; + } + + for (i = 0; i < count; i++) { + if (comp_v1) + v1 = lov_comp_entry(comp_v1, i); + + ret = find_value_cmp(v1->lmm_stripe_size, param->fp_stripe_size, + param->fp_stripe_size_sign, + param->fp_exclude_stripe_size, + param->fp_stripe_size_units, 0); + /* If any stripe_size matches */ + if (ret != -1) + break; + } + + return ret; +} + +static __u32 find_get_stripe_count(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + int i, count = 1; + __u32 stripe_count = 0; + + if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + count = comp_v1->lcm_entry_count; + } + + for (i = 0; i < count; i++) { + if (comp_v1) + v1 = lov_comp_entry(comp_v1, i); + stripe_count += v1->lmm_stripe_count; + } + + return stripe_count; +} + +#define LOV_PATTERN_INVALID 0xFFFFFFFF + +static int find_check_layout(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + int i, count = 1; + bool found = false, valid = false; + + if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + count = comp_v1->lcm_entry_count; + } + + for (i = 0; i < count; i++) { + if (comp_v1) + v1 = lov_comp_entry(comp_v1, i); + + if (v1->lmm_pattern == LOV_PATTERN_INVALID) + continue; + + valid = true; + if (v1->lmm_pattern & param->fp_layout) { + found = true; + break; + } + } + + if (!valid) + return -1; + + if ((found && !param->fp_exclude_layout) || + (!found && param->fp_exclude_layout)) + return 1; + + return -1; +} + +static int find_check_pool(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + struct lov_user_md_v3 *v3 = (void *)v1; + int i, count = 1; + bool found = false; + + if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + count = comp_v1->lcm_entry_count; + /* empty requested pool is taken as no pool search */ + if (count == 0 && param->fp_poolname[0] == '\0') + found = true; + } + + for (i = 0; i < count; i++) { + if (comp_v1 != NULL) + v1 = lov_comp_entry(comp_v1, i); + + if (((v1->lmm_magic == LOV_USER_MAGIC_V1) && + (param->fp_poolname[0] == '\0')) || + ((v1->lmm_magic == LOV_USER_MAGIC_V3) && + (strncmp(v3->lmm_pool_name, + param->fp_poolname, LOV_MAXPOOLNAME) == 0)) || + ((v1->lmm_magic == LOV_USER_MAGIC_V3) && + (strcmp(param->fp_poolname, "*") == 0))) { + found = true; + break; + } + } + + if ((found && !param->fp_exclude_pool) || + (!found && param->fp_exclude_pool)) + return 1; + + return -1; +} + +static int find_check_comp_options(struct find_param *param) +{ + lstat_t *st = ¶m->fp_lmd->lmd_st; + struct lov_comp_md_v1 *comp_v1, *forged_v1 = NULL; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + struct lov_comp_md_entry_v1 *entry; + int i, ret = 0; + + if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1) { + comp_v1 = (struct lov_comp_md_v1 *)v1; + } else { + forged_v1 = malloc(sizeof(*forged_v1) + sizeof(*entry)); + if (forged_v1 == NULL) + return -1; + comp_v1 = forged_v1; + comp_v1->lcm_entry_count = 1; + entry = &comp_v1->lcm_entries[0]; + entry->lcme_flags = S_ISDIR(st->st_mode) ? 0 : LCME_FL_INIT; + entry->lcme_extent.e_start = 0; + entry->lcme_extent.e_end = LUSTRE_EOF; + } + + /* invalid case, don't match for any kind of search. */ + if (comp_v1->lcm_entry_count == 0) { + ret = -1; + goto out; + } + + if (param->fp_check_comp_count) { + ret = find_value_cmp(forged_v1 ? 0 : comp_v1->lcm_entry_count, + param->fp_comp_count, + param->fp_comp_count_sign, + param->fp_exclude_comp_count, 1, 0); + if (ret == -1) + goto out; + } + + ret = 1; + for (i = 0; i < comp_v1->lcm_entry_count; i++) { + entry = &comp_v1->lcm_entries[i]; + + if (param->fp_check_comp_flags) { + ret = 1; + if (((param->fp_comp_flags & entry->lcme_flags) != + param->fp_comp_flags) || + (param->fp_comp_neg_flags & entry->lcme_flags)) { + ret = -1; + continue; + } + } + + if (param->fp_check_comp_start) { + ret = find_value_cmp(entry->lcme_extent.e_start, + param->fp_comp_start, + param->fp_comp_start_sign, + param->fp_exclude_comp_start, + param->fp_comp_start_units, 0); + if (ret == -1) + continue; + } + + if (param->fp_check_comp_end) { + ret = find_comp_end_cmp(entry->lcme_extent.e_end, + param); + if (ret == -1) + continue; + } + + /* the component matches all criteria */ + break; + } +out: + if (forged_v1 != NULL) + free(forged_v1); + return ret; +} + +static int find_check_mirror_options(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + int ret = 0; + + if (v1->lmm_magic != LOV_USER_MAGIC_COMP_V1) + return -1; + + comp_v1 = (struct lov_comp_md_v1 *)v1; + + if (param->fp_check_mirror_count) { + ret = find_value_cmp(comp_v1->lcm_mirror_count + 1, + param->fp_mirror_count, + param->fp_mirror_count_sign, + param->fp_exclude_mirror_count, 1, 0); + if (ret == -1) + return ret; + } + + if (param->fp_check_mirror_state) { + ret = 1; + __u16 file_state = comp_v1->lcm_flags & LCM_FL_FLR_MASK; + + if ((param->fp_mirror_state != 0 && + file_state != param->fp_mirror_state) || + file_state == param->fp_mirror_neg_state) + return -1; + } + + return ret; +} + +static bool find_check_lmm_info(struct find_param *param) +{ + return param->fp_check_pool || param->fp_check_stripe_count || + param->fp_check_stripe_size || param->fp_check_layout || + param->fp_check_comp_count || param->fp_check_comp_end || + param->fp_check_comp_start || param->fp_check_comp_flags || + param->fp_check_mirror_count || + param->fp_check_mirror_state || + param->fp_check_projid; +} + +/* + * Get file/directory project id. + * by the open fd resides on. + * Return 0 and project id on success, or -ve errno. + */ +static int fget_projid(int fd, int *projid) +{ + struct fsxattr fsx; + int rc; + + rc = ioctl(fd, LL_IOC_FSGETXATTR, &fsx); + if (rc) + return -errno; + + *projid = fsx.fsx_projid; + return 0; +} + static int cb_find_init(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { - struct find_param *param = (struct find_param *)data; + struct find_param *param = (struct find_param *)data; DIR *dir = dirp == NULL ? NULL : *dirp; - int decision = 1; /* 1 is accepted; -1 is rejected. */ + int decision = 1; /* 1 is accepted; -1 is rejected. */ lstat_t *st = ¶m->fp_lmd->lmd_st; - int lustre_fs = 1; - int checked_type = 0; - int ret = 0; + int lustre_fs = 1; + int checked_type = 0; + int ret = 0; + __u32 stripe_count = 0; + int fd = -2; - LASSERT(parent != NULL || dir != NULL); - - param->fp_lmd->lmd_lmm.lmm_stripe_count = 0; + if (parent == NULL && dir == NULL) + return -EINVAL; /* If a regular expression is presented, make the initial decision */ if (param->fp_pattern != NULL) { @@ -3026,26 +4087,33 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, 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) + param->fp_check_size || param->fp_check_blocks || + find_check_lmm_info(param) || + param->fp_check_mdt_count || param->fp_check_hash_type) decision = 0; if (param->fp_type != 0 && checked_type == 0) decision = 0; if (decision == 0) { + if (param->fp_check_mdt_count || param->fp_check_hash_type) { + param->fp_get_lmv = 1; + ret = cb_get_dirstripe(path, dir, param); + if (ret != 0) + return ret; + } + + param->fp_lmd->lmd_lmm.lmm_magic = 0; ret = get_lmd_info(path, parent, dir, param->fp_lmd, - param->fp_lum_size); + param->fp_lum_size, GET_LMD_INFO); if (ret == 0 && param->fp_lmd->lmd_lmm.lmm_magic == 0 && - (param->fp_check_pool || param->fp_check_stripe_count || - param->fp_check_stripe_size || param->fp_check_layout)) { + find_check_lmm_info(param)) { struct lov_user_md *lmm = ¶m->fp_lmd->lmd_lmm; /* We need to "fake" the "use the default" values * since the lmm struct is zeroed out at this point. */ lmm->lmm_magic = LOV_USER_MAGIC_V1; - lmm->lmm_pattern = 0xFFFFFFFF; + lmm->lmm_pattern = LOV_PATTERN_DEFAULT; if (!param->fp_raw) ostid_set_seq(&lmm->lmm_oi, FID_SEQ_LOV_DEFAULT); @@ -3058,8 +4126,6 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, 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 @@ -3070,7 +4136,6 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, if (fd > 0) { ret = llapi_file_fget_mdtidx(fd, ¶m->fp_file_mdt_index); - close(fd); } else { ret = -errno; } @@ -3087,7 +4152,9 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, if (ret == -ENOENT) goto decided; - return ret; + goto out; + } else { + stripe_count = find_get_stripe_count(param); } } @@ -3116,7 +4183,7 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, ret = setup_target_indexes(dir ? dir : parent, path, param); if (ret) - return ret; + goto out; param->fp_dev = st->st_dev; } else if (!lustre_fs && param->fp_got_uuids) { @@ -3128,33 +4195,41 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, } 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); + decision = find_check_stripe_size(param); if (decision == -1) goto decided; } if (param->fp_check_stripe_count) { + decision = find_value_cmp(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_mdt_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); + param->fp_lmv_md->lum_stripe_count, + param->fp_mdt_count, + param->fp_mdt_count_sign, + param->fp_exclude_mdt_count, 1, 0); if (decision == -1) goto decided; - } + } if (param->fp_check_layout) { + decision = find_check_layout(param); + if (decision == -1) + goto decided; + } + + if (param->fp_check_hash_type) { __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)) { + found = param->fp_lmv_md->lum_hash_type & param->fp_hash_type; + if ((found && param->fp_exclude_hash_type) || + (!found && !param->fp_exclude_hash_type)) { decision = -1; goto decided; } @@ -3209,33 +4284,53 @@ obd_matches: } } - if (param->fp_check_pool) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + if (param->fp_check_projid) { + int projid = 0; - /* 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) + if (fd == -2) + fd = open(path, O_RDONLY); + + if (fd > 0) + ret = fget_projid(fd, &projid); + else + ret = -errno; + if (ret) + goto out; + if (projid == param->fp_projid) { + if (param->fp_exclude_uid) goto decided; } else { - if (!param->fp_exclude_pool) + if (!param->fp_exclude_projid) goto decided; } } + if (param->fp_check_pool) { + decision = find_check_pool(param); + if (decision == -1) + goto decided; + } + + if (param->fp_check_comp_count || param->fp_check_comp_flags || + param->fp_check_comp_start || param->fp_check_comp_end) { + decision = find_check_comp_options(param); + if (decision == -1) + goto decided; + } + + if (param->fp_check_mirror_count || param->fp_check_mirror_state) { + decision = find_check_mirror_options(param); + if (decision == -1) + goto decided; + } + /* 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->fp_lmd->lmd_lmm.lmm_stripe_count) - : 0; + for_mds = lustre_fs ? + (S_ISREG(st->st_mode) && stripe_count) : 0; decision = find_time_check(st, param, for_mds); if (decision == -1) goto decided; @@ -3245,11 +4340,8 @@ obd_matches: The regular stat is almost of the same speed as some new 'glimpse-size-ioctl'. */ - if (param->fp_check_size && S_ISREG(st->st_mode) && - param->fp_lmd->lmd_lmm.lmm_stripe_count) - decision = 0; - - if (param->fp_check_size && S_ISDIR(st->st_mode)) + if ((param->fp_check_size || param->fp_check_blocks) && + ((S_ISREG(st->st_mode) && stripe_count) || S_ISDIR(st->st_mode))) decision = 0; if (!decision) { @@ -3276,63 +4368,85 @@ obd_matches: __func__, path); goto decided; } else { - ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "%s: IOC_LOV_GETINFO on %s failed", - __func__, path); - return ret; - } - } + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: IOC_LOV_GETINFO on %s failed", + __func__, path); + goto out; + } + } - /* Check the time on osc. */ - decision = find_time_check(st, param, 0); - if (decision == -1) - goto decided; - } + /* Check the time on osc. */ + decision = find_time_check(st, param, 0); + if (decision == -1) + goto decided; + } - if (param->fp_check_size) + 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) + goto decided; + } - if (decision != -1) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", path); - if (param->fp_zero_end) - llapi_printf(LLAPI_MSG_NORMAL, "%c", '\0'); - else - llapi_printf(LLAPI_MSG_NORMAL, "\n"); - } + if (param->fp_check_blocks) { /* convert st_blocks to bytes */ + decision = find_value_cmp(st->st_blocks * 512, param->fp_blocks, + param->fp_blocks_sign, + param->fp_exclude_blocks, + param->fp_blocks_units, 0); + if (decision == -1) + goto decided; + } -decided: - /* Do not get down anymore? */ - if (param->fp_depth == param->fp_max_depth) - return 1; + llapi_printf(LLAPI_MSG_NORMAL, "%s", path); + if (param->fp_zero_end) + llapi_printf(LLAPI_MSG_NORMAL, "%c", '\0'); + else + llapi_printf(LLAPI_MSG_NORMAL, "\n"); +decided: + ret = 0; + /* Do not get down anymore? */ + if (param->fp_depth == param->fp_max_depth) { + ret = 1; + goto out; + } param->fp_depth++; - - return 0; +out: + if (fd > 0) + close(fd); + return ret; } static int cb_migrate_mdt_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); + void *param_data, struct dirent64 *de) +{ + struct find_param *param = (struct find_param *)param_data; + struct lmv_user_md *lmu = param->fp_lmv_md; + DIR *tmp_parent = parent; + char raw[MAX_IOC_BUFLEN] = {'\0'}; + char *rawbuf = raw; + struct obd_ioctl_data data = { 0 }; + int fd; + int ret; + char *path_copy; + char *filename; + bool retry = false; + + if (parent == NULL && dirp == NULL) + return -EINVAL; + + if (!lmu) + return -EINVAL; + if (dirp != NULL) closedir(*dirp); if (parent == NULL) { - dir = opendir_parent(path); - if (dir == NULL) { + tmp_parent = opendir_parent(path); + if (tmp_parent == NULL) { *dirp = NULL; ret = -errno; llapi_error(LLAPI_MSG_ERROR, ret, @@ -3341,29 +4455,53 @@ static int cb_migrate_mdt_init(char *path, DIR *parent, DIR **dirp, } } - fd = dirfd(dir); + fd = dirfd(tmp_parent); + + path_copy = strdup(path); + filename = basename(path_copy); - 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)); + data.ioc_inlbuf2 = (char *)lmu; + data.ioc_inllen2 = lmv_user_md_size(lmu->lum_stripe_count, + lmu->lum_magic); + ret = llapi_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (ret != 0) { llapi_error(LLAPI_MSG_ERROR, ret, "llapi_obd_statfs: error packing ioctl data"); goto out; } +migrate: ret = ioctl(fd, LL_IOC_MIGRATE, rawbuf); if (ret != 0) { - ret = -errno; - fprintf(stderr, "%s migrate failed: %s (%d)\n", - path, strerror(-ret), ret); - goto out; + if (errno == EBUSY && !retry) { + /* because migrate may not be able to lock all involved + * objects in order, for some of them it try lock, while + * there may be conflicting COS locks and cause migrate + * fail with EBUSY, hope a sync() could cause + * transaction commit and release these COS locks. */ + sync(); + retry = true; + goto migrate; + } else if (errno == EALREADY) { + if (param->fp_verbose & VERBOSE_DETAIL) + llapi_printf(LLAPI_MSG_NORMAL, + "%s was migrated to MDT%d already\n", + path, lmu->lum_stripe_offset); + ret = 0; + } else { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s migrate failed: %s (%d)\n", + path, strerror(-ret), ret); + goto out; + } } else if (param->fp_verbose & VERBOSE_DETAIL) { - fprintf(stdout, "migrate %s to MDT%d\n", - path, param->fp_mdt_index); + llapi_printf(LLAPI_MSG_NORMAL, + "migrate %s to MDT%d stripe count %d\n", + path, lmu->lum_stripe_offset, + lmu->lum_stripe_count); } out: @@ -3374,28 +4512,61 @@ out: * on the client side, and re-open to get the * new directory handle */ *dirp = opendir(path); - if (dirp == NULL) { + 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); + closedir(tmp_parent); + + free(path_copy); + + return ret; +} + +/* dir migration finished, shrink its stripes */ +static int cb_migrate_mdt_fini(char *path, DIR *parent, DIR **dirp, void *data, + struct dirent64 *de) +{ + struct find_param *param = data; + struct lmv_user_md *lmu = param->fp_lmv_md; + int lmulen = lmv_user_md_size(lmu->lum_stripe_count, lmu->lum_magic); + int ret = 0; + + if (de && de->d_type != DT_DIR) + goto out; + + if (*dirp) { + /* + * close it before setxattr because the latter may destroy the + * original object, and cause close fail. + */ + ret = closedir(*dirp); + *dirp = NULL; + if (ret) + goto out; + } + ret = setxattr(path, XATTR_NAME_LMV, lmu, lmulen, 0); + if (ret == -EALREADY) + ret = 0; +out: + cb_common_fini(path, parent, dirp, data, de); return ret; } int llapi_migrate_mdt(char *path, struct find_param *param) { - return param_callback(path, cb_migrate_mdt_init, cb_common_fini, param); + return param_callback(path, cb_migrate_mdt_init, cb_migrate_mdt_fini, + param); } int llapi_mv(char *path, struct find_param *param) { -#if LUSTRE_VERSION_CODE > OBD_OCD_VERSION(2, 9, 53, 0) +#if LUSTRE_VERSION_CODE > OBD_OCD_VERSION(2, 9, 59, 0) static bool printed; if (!printed) { @@ -3432,7 +4603,8 @@ static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data, int ret; int mdtidx; - LASSERT(parent != NULL || d != NULL); + if (parent == NULL && d == NULL) + return -EINVAL; if (d != NULL) { ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); @@ -3494,35 +4666,24 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, DIR *d = dirp == NULL ? NULL : *dirp; int ret = 0; - LASSERT(parent != NULL || d != NULL); + if (parent == NULL && d == NULL) + return -EINVAL; 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->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->fp_lmd->lmd_lmm); - } - - } else if (parent && !param->fp_get_lmv && !param->fp_get_default_lmv) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - - strlcpy((char *)¶m->fp_lmd->lmd_lmm, fname, - param->fp_lum_size); + ret = setup_obd_uuid(d ? dirfd(d) : dirfd(parent), path, param); + if (ret) + return ret; + } - ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, - (void *)¶m->fp_lmd->lmd_lmm); - } else { + if (d && (param->fp_get_lmv || param->fp_get_default_lmv)) + ret = cb_get_dirstripe(path, d, param); + else if (d || + (parent && !param->fp_get_lmv && !param->fp_get_default_lmv)) + ret = get_lmd_info(path, parent, d, ¶m->fp_lmd->lmd_lmm, + param->fp_lum_size, GET_LMD_STRIPE); + else return 0; - } if (ret) { if (errno == ENODATA && d != NULL) { @@ -3592,7 +4753,7 @@ err_out: dump: if (!(param->fp_verbose & VERBOSE_MDTINDEX)) - llapi_lov_dump_user_lmm(param, path, d ? 1 : 0); + llapi_lov_dump_user_lmm(param, path, d ? LDF_IS_DIR : 0); out: /* Do not get down anymore? */ @@ -3611,12 +4772,10 @@ int llapi_getstripe(char *path, struct find_param *param) cb_common_fini, param); } -int llapi_obd_statfs(char *path, __u32 type, __u32 index, - struct obd_statfs *stat_buf, - struct obd_uuid *uuid_buf) +int llapi_obd_fstatfs(int fd, __u32 type, __u32 index, + struct obd_statfs *stat_buf, struct obd_uuid *uuid_buf) { - int fd; - char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; + char raw[MAX_IOC_BUFLEN] = {'\0'}; char *rawbuf = raw; struct obd_ioctl_data data = { 0 }; int rc = 0; @@ -3630,30 +4789,38 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, data.ioc_pbuf2 = (char *)uuid_buf; data.ioc_plen2 = sizeof(struct obd_uuid); - rc = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + rc = llapi_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (rc != 0) { llapi_error(LLAPI_MSG_ERROR, rc, "llapi_obd_statfs: error packing ioctl data"); return rc; } - fd = open(path, O_RDONLY); - if (errno == EISDIR) - fd = open(path, O_DIRECTORY | O_RDONLY); + rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf); + + return rc < 0 ? -errno : 0; +} + +int llapi_obd_statfs(char *path, __u32 type, __u32 index, + struct obd_statfs *stat_buf, struct obd_uuid *uuid_buf) +{ + int fd; + int rc; + fd = open(path, O_RDONLY); if (fd < 0) { - rc = errno ? -errno : -EBADF; + rc = -errno; 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; + + rc = llapi_obd_fstatfs(fd, type, index, stat_buf, uuid_buf); close(fd); + return rc; } @@ -3661,44 +4828,62 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, int llapi_ping(char *obd_type, char *obd_name) { - char path[MAX_STRING_SIZE]; - char buf[1]; - int rc, fd; + int flags = O_RDONLY; + char buf[1] = { 0 }; + glob_t path; + int rc, fd; - snprintf(path, MAX_STRING_SIZE, "/proc/fs/lustre/%s/%s/ping", - obd_type, obd_name); - - fd = open(path, O_WRONLY); - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); - return rc; - } + rc = cfs_get_param_paths(&path, "%s/%s/ping", + obd_type, obd_name); + if (rc != 0) + return -errno; +retry_open: + fd = open(path.gl_pathv[0], flags); + if (fd < 0) { + if (errno == EACCES && flags == O_RDONLY) { + flags = O_WRONLY; + goto retry_open; + } + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", + path.gl_pathv[0]); + goto failed; + } - /* The purpose is to send a byte as a ping, whatever this byte is. */ - /* coverity[uninit_use_in_call] */ - rc = write(fd, buf, 1); - if (rc < 0) - rc = -errno; - close(fd); + if (flags == O_RDONLY) + rc = read(fd, buf, sizeof(buf)); + else + rc = write(fd, buf, sizeof(buf)); + if (rc < 0) + rc = -errno; + close(fd); - if (rc == 1) - return 0; - return rc; + if (rc == 1) + rc = 0; +failed: + cfs_free_param_data(&path); + return rc; } int llapi_target_iterate(int type_num, char **obd_type, void *args, llapi_cb_t cb) { - char buf[MAX_STRING_SIZE]; - FILE *fp = fopen(DEVICES_LIST, "r"); - int i, rc = 0; + char buf[MAX_STRING_SIZE]; + int i, rc = 0; + glob_t param; + FILE *fp; - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); - return rc; - } + rc = cfs_get_param_paths(¶m, "devices"); + if (rc != 0) + return -ENOENT; + + fp = fopen(param.gl_pathv[0], "r"); + if (fp == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", + param.gl_pathv[0]); + goto free_path; + } while (fgets(buf, sizeof(buf), fp) != NULL) { char *obd_type_name = NULL; @@ -3724,375 +4909,71 @@ int llapi_target_iterate(int type_num, char **obd_type, cb(obd_type_name, obd_name, obd_uuid, args); } - } - fclose(fp); - return 0; -} - -static void do_target_check(char *obd_type_name, char *obd_name, - char *obd_uuid, void *args) -{ - int rc; - - rc = llapi_ping(obd_type_name, obd_name); - if (rc == ENOTCONN) { - llapi_printf(LLAPI_MSG_NORMAL, "%s inactive.\n", obd_name); - } else if (rc) { - llapi_error(LLAPI_MSG_ERROR, rc, "error: check '%s'", obd_name); - } else { - llapi_printf(LLAPI_MSG_NORMAL, "%s active.\n", obd_name); - } -} - -int llapi_target_check(int type_num, char **obd_type, char *dir) -{ - return llapi_target_iterate(type_num, obd_type, NULL, do_target_check); -} - -#undef MAX_STRING_SIZE - -/* Is this a lustre fs? */ -int llapi_is_lustre_mnttype(const char *type) -{ - return (strcmp(type, "lustre") == 0 || strcmp(type,"lustre_lite") == 0); -} - -/* Is this a lustre client fs? */ -int llapi_is_lustre_mnt(struct mntent *mnt) -{ - return (llapi_is_lustre_mnttype(mnt->mnt_type) && - strstr(mnt->mnt_fsname, ":/") != NULL); -} - -int llapi_quotactl(char *mnt, struct if_quotactl *qctl) -{ - DIR *root; - int rc; - - root = opendir(mnt); - if (!root) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); - return rc; - } - - rc = ioctl(dirfd(root), OBD_IOC_QUOTACTL, qctl); - if (rc < 0) - rc = -errno; - - closedir(root); - return rc; -} - -#include -#include -#include -#include -#include -#include - -static int rmtacl_notify(int ops) -{ - FILE *fp; - struct mntent *mnt; - int found = 0, fd = 0, rc = 0; - - fp = setmntent(MOUNTED, "r"); - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "error setmntent(%s)", MOUNTED); - return rc; - } - - while (1) { - mnt = getmntent(fp); - if (!mnt) - break; - - if (!llapi_is_lustre_mnt(mnt)) - continue; - - fd = open(mnt->mnt_dir, O_RDONLY | O_DIRECTORY); - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "Can't open '%s'", mnt->mnt_dir); - goto out; - } - - rc = ioctl(fd, LL_IOC_RMTACL, ops); - close(fd); - if (rc < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "ioctl RMTACL on '%s' err %d", - mnt->mnt_dir, rc); - goto out; - } - - found++; - } - -out: - endmntent(fp); - return ((rc != 0) ? rc : found); -} - -static char *next_token(char *p, int div) -{ - if (p == NULL) - return NULL; - - if (div) - while (*p && *p != ':' && !isspace(*p)) - p++; - else - while (*p == ':' || isspace(*p)) - p++; - - return *p ? p : NULL; -} - -static int rmtacl_name2id(char *name, int is_user) -{ - if (is_user) { - struct passwd *pw; - - pw = getpwnam(name); - if (pw == NULL) - return INVALID_ID; - else - return (int)(pw->pw_uid); - } else { - struct group *gr; - - gr = getgrnam(name); - if (gr == NULL) - return INVALID_ID; - else - return (int)(gr->gr_gid); - } -} - -static int isodigit(int c) -{ - return (c >= '0' && c <= '7') ? 1 : 0; -} - -/* - * Whether the name is just digits string (uid/gid) already or not. - * Return value: - * 1: str is id - * 0: str is not id - */ -static int str_is_id(char *str) -{ - if (str == NULL) - return 0; - - if (*str == '0') { - str++; - if (*str == 'x' || *str == 'X') { /* for Hex. */ - if (!isxdigit(*(++str))) - return 0; - - while (isxdigit(*(++str))); - } else if (isodigit(*str)) { /* for Oct. */ - while (isodigit(*(++str))); - } - } else if (isdigit(*str)) { /* for Dec. */ - while (isdigit(*(++str))); - } - - return (*str == 0) ? 1 : 0; -} - -typedef struct { - char *name; - int length; - int is_user; - int next_token; -} rmtacl_name_t; - -#define RMTACL_OPTNAME(name) name, sizeof(name) - 1 - -static rmtacl_name_t rmtacl_namelist[] = { - { RMTACL_OPTNAME("user:"), 1, 0 }, - { RMTACL_OPTNAME("group:"), 0, 0 }, - { RMTACL_OPTNAME("default:user:"), 1, 0 }, - { RMTACL_OPTNAME("default:group:"), 0, 0 }, - /* for --tabular option */ - { RMTACL_OPTNAME("user"), 1, 1 }, - { RMTACL_OPTNAME("group"), 0, 1 }, - { 0 } -}; - -static int rgetfacl_output(char *str) -{ - char *start = NULL, *end = NULL; - int is_user = 0, n, id; - char c; - rmtacl_name_t *rn; - - if (str == NULL) - return -1; - - for (rn = rmtacl_namelist; rn->name; rn++) { - if(strncmp(str, rn->name, rn->length) == 0) { - if (!rn->next_token) - start = str + rn->length; - else - start = next_token(str + rn->length, 0); - is_user = rn->is_user; - break; - } - } - - end = next_token(start, 1); - if (end == NULL || start == end) { - n = printf("%s", str); - return n; - } - - c = *end; - *end = 0; - id = rmtacl_name2id(start, is_user); - if (id == INVALID_ID) { - if (str_is_id(start)) { - *end = c; - n = printf("%s", str); - } else - return -1; - } else if ((id == NOBODY_UID && is_user) || - (id == NOBODY_GID && !is_user)) { - *end = c; - n = printf("%s", str); - } else { - *end = c; - *start = 0; - n = printf("%s%d%s", str, id, end); - } - return n; -} - -static int child_status(int status) -{ - return WIFEXITED(status) ? WEXITSTATUS(status) : -1; -} - -static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) -{ - pid_t pid = 0; - int fd[2], status, rc; - FILE *fp; - char buf[PIPE_BUF]; - - if (output_func) { - if (pipe(fd) < 0) { - rc = -errno; - 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"); - close(fd[0]); - close(fd[1]); - return rc; - } else if (!pid) { - /* child process redirects its output. */ - close(fd[0]); - close(1); - if (dup2(fd[1], 1) < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "Can't dup2 %d", fd[1]); - close(fd[1]); - return rc; - } - } else { - close(fd[1]); - } - } - - if (!pid) { - status = rmtacl_notify(ops); - if (status < 0) - return -errno; - - exit(execvp(argv[0], argv)); - } - - /* the following is parent process */ - fp = fdopen(fd[0], "r"); - if (fp == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "fdopen %d failed", fd[0]); - kill(pid, SIGKILL); - close(fd[0]); - return rc; - } - - while (fgets(buf, PIPE_BUF, fp) != NULL) { - if (output_func(buf) < 0) - fprintf(stderr, "WARNING: unexpected error!\n[%s]\n", - buf); - } - fclose(fp); - close(fd[0]); - - if (waitpid(pid, &status, 0) < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "waitpid %d failed", pid); - return rc; - } - - return child_status(status); + } + fclose(fp); +free_path: + cfs_free_param_data(¶m); + return 0; } -int llapi_lsetfacl(int argc, char *argv[]) +static void do_target_check(char *obd_type_name, char *obd_name, + char *obd_uuid, void *args) { - return do_rmtacl(argc, argv, RMT_LSETFACL, NULL); + int rc; + + rc = llapi_ping(obd_type_name, obd_name); + if (rc == ENOTCONN) { + llapi_printf(LLAPI_MSG_NORMAL, "%s inactive.\n", obd_name); + } else if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, "error: check '%s'", obd_name); + } else { + llapi_printf(LLAPI_MSG_NORMAL, "%s active.\n", obd_name); + } } -int llapi_lgetfacl(int argc, char *argv[]) +int llapi_target_check(int type_num, char **obd_type, char *dir) { - return do_rmtacl(argc, argv, RMT_LGETFACL, NULL); + return llapi_target_iterate(type_num, obd_type, NULL, do_target_check); } -int llapi_rsetfacl(int argc, char *argv[]) +#undef MAX_STRING_SIZE + +/* Is this a lustre fs? */ +int llapi_is_lustre_mnttype(const char *type) { - return do_rmtacl(argc, argv, RMT_RSETFACL, NULL); + return (strcmp(type, "lustre") == 0 || strcmp(type,"lustre_lite") == 0); } -int llapi_rgetfacl(int argc, char *argv[]) +/* Is this a lustre client fs? */ +int llapi_is_lustre_mnt(struct mntent *mnt) { - return do_rmtacl(argc, argv, RMT_RGETFACL, rgetfacl_output); + return (llapi_is_lustre_mnttype(mnt->mnt_type) && + strstr(mnt->mnt_fsname, ":/") != NULL); } -int llapi_cp(int argc, char *argv[]) +int llapi_quotactl(char *mnt, struct if_quotactl *qctl) { - int rc; - - rc = rmtacl_notify(RMT_RSETFACL); - if (rc < 0) - return rc; + char fsname[PATH_MAX + 1]; + int root; + int rc; - exit(execvp(argv[0], argv)); -} + rc = llapi_search_fsname(mnt, fsname); + if (rc) + return rc; -int llapi_ls(int argc, char *argv[]) -{ - int rc; + root = open(mnt, O_RDONLY | O_DIRECTORY); + if (root < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", mnt); + return rc; + } - rc = rmtacl_notify(RMT_LGETFACL); - if (rc < 0) - return rc; + rc = ioctl(root, OBD_IOC_QUOTACTL, qctl); + if (rc < 0) + rc = -errno; - exit(execvp(argv[0], argv)); + close(root); + return rc; } /* Print mdtname 'name' into 'buf' using 'format'. Add -MDT0000 if needed. @@ -4116,7 +4997,7 @@ static int get_mdtname(char *name, char *format, char *buf) } else { /* Not enough room to add suffix */ llapi_err_noerrno(LLAPI_MSG_ERROR, - "MDT name too long |%s|", name); + "Invalid MDT name |%s|", name); return -EINVAL; } } @@ -4132,259 +5013,52 @@ static int get_mdtname(char *name, char *format, char *buf) int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp, int want_error) { - char fsname[20]; - char *ptr; + char fsname[20]; + char *ptr; int fd, rc; long index; - /* Take path, fsname, or MDTname. Assume MDT0000 in the former cases. - Open root and parse mdt index. */ - if (mdtname[0] == '/') { - index = 0; - rc = get_root_path(WANT_FD | want_error, NULL, &fd, - (char *)mdtname, -1); - } else { - if (get_mdtname((char *)mdtname, "%s%s", fsname) < 0) - return -EINVAL; - ptr = fsname + strlen(fsname) - 8; - *ptr = '\0'; - index = strtol(ptr + 4, NULL, 10); - rc = get_root_path(WANT_FD | want_error, fsname, &fd, NULL, -1); - } - if (rc < 0) { - if (want_error) - llapi_err_noerrno(LLAPI_MSG_ERROR, - "Can't open %s: %d\n", mdtname, rc); - return rc; - } - - if (mdtidxp) - *mdtidxp = index; - - rc = ioctl(fd, opc, data); - if (rc == -1) - rc = -errno; - else - rc = 0; - if (rc && want_error) - llapi_error(LLAPI_MSG_ERROR, rc, "ioctl %d err %d", opc, rc); - - close(fd); - return rc; -} - -/****** Changelog API ********/ - -static int changelog_ioctl(const char *mdtname, int opc, int id, - long long recno, int flags) -{ - struct ioc_changelog data; - int *idx; - - data.icc_id = id; - data.icc_recno = recno; - data.icc_flags = flags; - idx = (int *)(&data.icc_mdtindex); - - return root_ioctl(mdtname, opc, &data, idx, WANT_ERROR); -} - -#define CHANGELOG_PRIV_MAGIC 0xCA8E1080 -struct changelog_private { - int magic; - enum changelog_send_flag flags; - struct lustre_kernelcomm kuc; -}; - -/** Start reading from a changelog - * @param priv Opaque private control structure - * @param flags Start flags (e.g. CHANGELOG_FLAG_BLOCK) - * @param device Report changes recorded on this MDT - * @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, enum changelog_send_flag flags, - const char *device, long long startrec) -{ - 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; - - cp->magic = CHANGELOG_PRIV_MAGIC; - cp->flags = flags; - - /* Set up the receiver */ - rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */, 0); - if (rc < 0) - goto out_free; - - *priv = cp; - - /* 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; + /* Take path, fsname, or MDTname. Assume MDT0000 in the former cases. + Open root and parse mdt index. */ + if (mdtname[0] == '/') { + index = 0; + rc = get_root_path(WANT_FD | want_error, NULL, &fd, + (char *)mdtname, -1); + } else { + if (get_mdtname((char *)mdtname, "%s%s", fsname) < 0) + return -EINVAL; + ptr = fsname + strlen(fsname) - 8; + *ptr = '\0'; + index = strtol(ptr + 4, NULL, 16); + rc = get_root_path(WANT_FD | want_error, fsname, &fd, NULL, -1); } - - /* 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); + if (want_error) + llapi_err_noerrno(LLAPI_MSG_ERROR, + "Can't open %s: %d\n", mdtname, rc); return rc; } - return 0; + if (mdtidxp) + *mdtidxp = index; -out_free: - free(cp); + rc = ioctl(fd, opc, data); + if (rc == -1) + rc = -errno; + else + rc = 0; + close(fd); return rc; } -/** Finish reading from a changelog */ -int llapi_changelog_fini(void **priv) -{ - struct changelog_private *cp = (struct changelog_private *)*priv; - - if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) - return -EINVAL; - - libcfs_ukuc_stop(&cp->kuc); - free(cp); - *priv = NULL; - return 0; -} - -/** - * 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. - */ -/** Read the next changelog entry - * @param priv Opaque private control structure - * @param rech Changelog record handle; record will be allocated here - * @return 0 valid message received; rec is set - * <0 error code - * 1 EOF - */ -#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; - 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->flags & CHANGELOG_FLAG_JOBID) - rec_fmt |= CLF_JOBID; - -repeat: - 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) && - (kuch->kuc_msgtype != CL_EOF))) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "Unknown changelog message type %d:%d\n", - kuch->kuc_transport, kuch->kuc_msgtype); - rc = -EPROTO; - goto out_free; - } - - if (kuch->kuc_msgtype == CL_EOF) { - if (cp->flags & CHANGELOG_FLAG_FOLLOW) { - /* Ignore EOFs */ - goto repeat; - } else { - rc = 1; - goto out_free; - } - } - - /* 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; - -out_free: - *rech = NULL; - free(kuch); - return rc; -} - -/** Release the changelog record when done with it. */ -int llapi_changelog_free(struct changelog_rec **rech) -{ - if (*rech) { - /* We allocated memory starting at the kuc_hdr, but passed - * the consumer a pointer to the payload. - * Use pointer math to get back to the header. - */ - struct kuc_hdr *kuch = (struct kuc_hdr *)*rech - 1; - free(kuch); - } - *rech = NULL; - return 0; -} - -int llapi_changelog_clear(const char *mdtname, const char *idstr, - long long endrec) -{ - long id; - - if (endrec < 0) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "can't purge negative records\n"); - return -EINVAL; - } - - id = strtol(idstr + strlen(CHANGELOG_USER_PREFIX), NULL, 10); - if ((id == 0) || (strncmp(idstr, CHANGELOG_USER_PREFIX, - strlen(CHANGELOG_USER_PREFIX)) != 0)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "expecting id of the form '" - CHANGELOG_USER_PREFIX - "'; got '%s'\n", idstr); - return -EINVAL; - } - - return changelog_ioctl(mdtname, OBD_IOC_CHANGELOG_CLEAR, id, endrec, 0); -} - int llapi_fid2path(const char *device, const char *fidstr, char *buf, int buflen, long long *recno, int *linkno) { + const char *fidstr_orig = fidstr; struct lu_fid fid; struct getinfo_fid2path *gf; + char *a; + char *b; int rc; while (*fidstr == '[') @@ -4393,8 +5067,8 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, sscanf(fidstr, SFID, RFID(&fid)); if (!fid_is_sane(&fid)) { llapi_err_noerrno(LLAPI_MSG_ERROR, - "bad FID format [%s], should be [seq:oid:ver]" - " (e.g. "DFID")\n", fidstr, + "bad FID format '%s', should be [seq:oid:ver]" + " (e.g. "DFID")\n", fidstr_orig, (unsigned long long)FID_SEQ_NORMAL, 2, 0); return -EINVAL; } @@ -4402,6 +5076,7 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, gf = malloc(sizeof(*gf) + buflen); if (gf == NULL) return -ENOMEM; + gf->gf_fid = fid; gf->gf_recno = *recno; gf->gf_linkno = *linkno; @@ -4409,24 +5084,33 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, /* Take path or fsname */ rc = root_ioctl(device, OBD_IOC_FID2PATH, gf, NULL, 0); - if (rc) { - if (rc != -ENOENT) - llapi_error(LLAPI_MSG_ERROR, rc, "ioctl err %d", rc); - } else { - 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; - } + if (rc) + goto out_free; - free(gf); - return rc; + b = buf; + /* strip out instances of // */ + for (a = gf->gf_u.gf_path; *a != '\0'; a++) { + if ((*a == '/') && (*(a + 1) == '/')) + continue; + *b = *a; + b++; + } + *b = '\0'; + + if (buf[0] == '\0') { /* ROOT path */ + buf[0] = '/'; + buf[1] = '\0'; + } + + *recno = gf->gf_recno; + *linkno = gf->gf_linkno; + +out_free: + free(gf); + return rc; } -static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) +static int fid_from_lma(const char *path, int fd, struct lu_fid *fid) { char buf[512]; struct lustre_mdt_attrs *lma; @@ -4443,7 +5127,7 @@ 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 llapi_get_mdt_index_by_fid(int fd, const struct lu_fid *fid, int *mdt_index) { int rc; @@ -4457,7 +5141,7 @@ int llapi_get_mdt_index_by_fid(int fd, const lustre_fid *fid, return rc; } -int llapi_fd2fid(const int fd, lustre_fid *fid) +int llapi_fd2fid(int fd, struct lu_fid *fid) { int rc; @@ -4470,7 +5154,7 @@ int llapi_fd2fid(const int fd, lustre_fid *fid) return rc; } -int llapi_path2fid(const char *path, lustre_fid *fid) +int llapi_path2fid(const char *path, struct lu_fid *fid) { int fd, rc; @@ -4490,7 +5174,7 @@ int llapi_path2fid(const char *path, lustre_fid *fid) return rc; } -int llapi_fd2parent(int fd, unsigned int linkno, lustre_fid *parent_fid, +int llapi_fd2parent(int fd, unsigned int linkno, struct lu_fid *parent_fid, char *name, size_t name_size) { struct getparent *gp; @@ -4520,7 +5204,7 @@ err_free: } int llapi_path2parent(const char *path, unsigned int linkno, - lustre_fid *parent_fid, char *name, size_t name_size) + struct lu_fid *parent_fid, char *name, size_t name_size) { int fd; int rc; @@ -4536,52 +5220,24 @@ int llapi_path2parent(const char *path, unsigned int linkno, int llapi_get_connect_flags(const char *mnt, __u64 *flags) { - DIR *root; - int rc; - - root = opendir(mnt); - if (!root) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); - return rc; - } - - rc = ioctl(dirfd(root), LL_IOC_GET_CONNECT_FLAGS, flags); - if (rc < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "ioctl on %s for getting connect flags failed", mnt); - } - closedir(root); - return rc; -} - -int llapi_get_version(char *buffer, int buffer_size, - char **version) -{ - int rc; - int fd; - struct obd_ioctl_data *data = (struct obd_ioctl_data *)buffer; - - fd = open(OBD_DEV_PATH, O_RDONLY); - if (fd == -1) - return -errno; + int root; + int rc; - memset(buffer, 0, buffer_size); - data->ioc_version = OBD_IOCTL_VERSION; - data->ioc_inllen1 = buffer_size - cfs_size_round(sizeof(*data)); - data->ioc_inlbuf1 = buffer + cfs_size_round(sizeof(*data)); - data->ioc_len = obd_ioctl_packlen(data); + root = open(mnt, O_RDONLY | O_DIRECTORY); + if (root < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; + } - rc = ioctl(fd, OBD_GET_VERSION, buffer); - if (rc == -1) { - rc = -errno; - close(fd); - return rc; - } - close(fd); - *version = data->ioc_bulk; - return 0; + rc = ioctl(root, LL_IOC_GET_CONNECT_FLAGS, flags); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "ioctl on %s for getting connect flags failed", mnt); + } + close(root); + return rc; } /** @@ -4603,90 +5259,170 @@ int llapi_get_version(char *buffer, int buffer_size, */ int llapi_get_data_version(int fd, __u64 *data_version, __u64 flags) { - int rc; - struct ioc_data_version idv; + int rc; + struct ioc_data_version idv; - idv.idv_flags = flags; + idv.idv_flags = (__u32)flags; - rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); - if (rc) - rc = -errno; - else - *data_version = idv.idv_version; + rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); + if (rc) + rc = -errno; + else + *data_version = idv.idv_version; - return rc; + return rc; +} + +/** + * Flush cached pages from all clients. + * + * \param fd File descriptor + * \retval 0 success + * \retval < 0 error + */ +int llapi_file_flush(int fd) +{ + __u64 dv; + + return llapi_get_data_version(fd, &dv, LL_DV_WR_FLUSH); } /* - * Create a file without any name open it for read/write + * Fetch layout version from OST objects. Layout version on OST objects are + * only set when the file is a mirrored file AND after the file has been + * written at least once. + * + * It actually fetches the least layout version from the objects. + */ +int llapi_get_ost_layout_version(int fd, __u32 *layout_version) +{ + int rc; + struct ioc_data_version idv = { 0 }; + + rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); + if (rc) + rc = -errno; + else + *layout_version = idv.idv_layout_version; + + return rc; +} + +/* + * Create a file without any name and 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. + * - file is destroyed at final close * * \param[in] directory directory from which to inherit layout/MDT idx - * \param[in] idx MDT index on which the file is created, + * \param[in] mdt_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 + * \param[in] mode standard open(2) mode + * \param[in] stripe_param stripe parameters. May be NULL. * - * \retval 0 on success. + * \retval a file descriptor on success. * \retval -errno on error. */ -int llapi_create_volatile_idx(char *directory, int idx, int open_flags) -{ - char file_path[PATH_MAX]; - char filename[PATH_MAX]; - int saved_errno = errno; - int fd; - int rnumber; - int rc; +int llapi_create_volatile_param(const char *directory, int mdt_idx, + int open_flags, mode_t mode, + const struct llapi_stripe_param *stripe_param) +{ + char file_path[PATH_MAX]; + int saved_errno = errno; + int fd; + unsigned int rnumber; + int rc; do { rnumber = random(); - if (idx == -1) - snprintf(filename, sizeof(filename), - LUSTRE_VOLATILE_HDR"::%.4X", rnumber); + if (mdt_idx == -1) + rc = snprintf(file_path, sizeof(file_path), + "%s/" LUSTRE_VOLATILE_HDR "::%.4X", + directory, rnumber); else - snprintf(filename, sizeof(filename), - LUSTRE_VOLATILE_HDR":%.4X:%.4X", idx, rnumber); - - 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 | O_EXCL | O_NOFOLLOW | open_flags, - S_IRUSR | S_IWUSR); - } while (fd < 0 && errno == EEXIST); + rc = snprintf(file_path, sizeof(file_path), + "%s/" LUSTRE_VOLATILE_HDR ":%.4X:%.4X", + directory, mdt_idx, rnumber); + + if (rc < 0 || rc >= sizeof(file_path)) + return -ENAMETOOLONG; + + /* + * Either open O_WRONLY or O_RDWR, creating RDONLY + * is non-sensical here + */ + if ((open_flags & O_ACCMODE) == O_RDONLY) + open_flags = O_RDWR | (open_flags & ~O_ACCMODE); + + open_flags |= O_CREAT | O_EXCL | O_NOFOLLOW; + + if (stripe_param != NULL) { + fd = llapi_file_open_param(file_path, open_flags, + mode, stripe_param); + if (fd < 0) + rc = fd; + } else { + fd = open(file_path, open_flags, mode); + if (fd < 0) + rc = -errno; + } + } while (fd < 0 && rc == -EEXIST); if (fd < 0) { - llapi_error(LLAPI_MSG_ERROR, errno, + llapi_error(LLAPI_MSG_ERROR, rc, "Cannot create volatile file '%s' in '%s'", - filename + LUSTRE_VOLATILE_HDR_LEN, + file_path + strlen(directory) + 1 + + LUSTRE_VOLATILE_HDR_LEN, directory); - return -errno; + return rc; } - /* 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. If volatile open was supported then we - * expect unlink() to return -ENOENT. */ + /* + * 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. If volatile open was supported then we expect unlink() to + * return -ENOENT. + */ (void)unlink(file_path); - /* Since we are returning successfully we restore errno (and - * mask out possible EEXIST from open() and ENOENT from - * unlink(). */ + /* + * Since we are returning successfully we restore errno (and + * mask out possible EEXIST from open() and ENOENT from unlink(). + */ errno = saved_errno; return fd; } +/* + * 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 a file descriptor on success. + * \retval -errno on error. + */ +int llapi_create_volatile_idx(const char *directory, int mdt_idx, + int open_flags) +{ + return llapi_create_volatile_param(directory, mdt_idx, open_flags, + S_IRUSR | S_IWUSR, NULL); +} + /** * Swap the layouts between 2 file descriptors * the 2 files must be open for writing @@ -4819,7 +5555,8 @@ out: * \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) +int llapi_open_by_fid(const char *lustre_dir, const struct lu_fid *fid, + int flags) { char mntdir[PATH_MAX]; char path[PATH_MAX];