X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=44747e6d135e9f22b3ed02a00e16fda60f00f7d3;hb=44b6af40f70cf065e8198b6b438d6c953063d003;hp=75810546627f3a49ffb92aa8fd24b8f8328671d5;hpb=21d716e6c16424d9deb646456758ebbaa9c70fec;p=fs%2Flustre-release.git diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 7581054..44747e6 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, 2013, Intel Corporation. + * Copyright (c) 2011, 2016, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -45,6 +41,7 @@ #define _GNU_SOURCE #endif +#include #include #include #include @@ -56,11 +53,13 @@ #include #include #include -#include +#include #include +#include +#include #include +#include #include -#include #include /* for dirname() */ #ifdef HAVE_LINUX_UNISTD_H #include @@ -69,7 +68,8 @@ #endif #include -#include +#include +#include #include #include #include @@ -88,6 +88,11 @@ void llapi_msg_set_level(int level) llapi_msg_level = level; } +int llapi_msg_get_level(void) +{ + return llapi_msg_level; +} + static void error_callback_default(enum llapi_message_level level, int err, const char *fmt, va_list ap) { @@ -180,55 +185,67 @@ llapi_log_callback_t llapi_info_callback_set(llapi_log_callback_t cb) int llapi_parse_size(const char *optarg, unsigned long long *size, unsigned long long *size_units, int bytes_spec) { - char *end; - - if (strncmp(optarg, "-", 1) == 0) - return -1; - - if (*size_units == 0) - *size_units = 1; - - *size = strtoull(optarg, &end, 0); - - if (*end != '\0') { - if ((*end == 'b') && *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 9))) == 0 && - !bytes_spec) { - *size_units = 1 << 9; - } else if ((*end == 'b') && - *(end + 1) == '\0' && - bytes_spec) { - *size_units = 1; - } else if ((*end == 'k' || *end == 'K') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 10))) == 0) { - *size_units = 1 << 10; - } else if ((*end == 'm' || *end == 'M') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 20))) == 0) { - *size_units = 1 << 20; - } else if ((*end == 'g' || *end == 'G') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 30))) == 0) { - *size_units = 1 << 30; - } else if ((*end == 't' || *end == 'T') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 40))) == 0) { - *size_units = 1ULL << 40; - } else if ((*end == 'p' || *end == 'P') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 50))) == 0) { - *size_units = 1ULL << 50; - } else if ((*end == 'e' || *end == 'E') && - *(end + 1) == '\0' && - (*size & (~0ULL << (64 - 60))) == 0) { - *size_units = 1ULL << 60; - } else { - return -1; - } - } - *size *= *size_units; - return 0; + char *end; + char *argbuf = (char *)optarg; + unsigned long long frac = 0, frac_d = 1; + + if (strncmp(optarg, "-", 1) == 0) + return -1; + + if (*size_units == 0) + *size_units = 1; + + *size = strtoull(argbuf, &end, 0); + if (end != NULL && *end == '.') { + int i; + + argbuf = end + 1; + frac = strtoull(argbuf, &end, 10); + /* count decimal places */ + for (i = 0; i < (end - argbuf); i++) + frac_d *= 10; + } + + if (*end != '\0') { + if ((*end == 'b') && *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 9))) == 0 && + !bytes_spec) { + *size_units = 1 << 9; + } else if ((*end == 'b') && + *(end + 1) == '\0' && + bytes_spec) { + *size_units = 1; + } else if ((*end == 'k' || *end == 'K') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 10))) == 0) { + *size_units = 1 << 10; + } else if ((*end == 'm' || *end == 'M') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 20))) == 0) { + *size_units = 1 << 20; + } else if ((*end == 'g' || *end == 'G') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 30))) == 0) { + *size_units = 1 << 30; + } else if ((*end == 't' || *end == 'T') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 40))) == 0) { + *size_units = 1ULL << 40; + } else if ((*end == 'p' || *end == 'P') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 50))) == 0) { + *size_units = 1ULL << 50; + } else if ((*end == 'e' || *end == 'E') && + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 60))) == 0) { + *size_units = 1ULL << 60; + } else { + return -1; + } + } + *size = *size * *size_units + frac * *size_units / frac_d; + + return 0; } /* XXX: llapi_xxx() functions return negative values upon failure */ @@ -248,26 +265,26 @@ int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, "larger than expected (%u)", page_size, LOV_MIN_STRIPE_SIZE); } - if ((stripe_size & (LOV_MIN_STRIPE_SIZE - 1))) { + if (!llapi_stripe_size_is_aligned(stripe_size)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe_size %llu, " "must be an even multiple of %d bytes", stripe_size, page_size); return rc; } - if (stripe_offset < -1) { + if (!llapi_stripe_index_is_valid(stripe_offset)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe offset %d", stripe_offset); return rc; } - if (stripe_count < -1 || stripe_count > LOV_MAX_STRIPE_COUNT) { + if (!llapi_stripe_count_is_valid(stripe_count)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe count %d", stripe_count); return rc; } - if (stripe_size >= (1ULL << 32)) { + if (llapi_stripe_size_is_too_big(stripe_size)) { rc = -EINVAL; llapi_error(LLAPI_MSG_ERROR, rc, "warning: stripe size 4G or larger " @@ -277,67 +294,6 @@ 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) -{ - glob_t glob_info; - char pattern[PATH_MAX + 1]; - 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; - - strcpy(poolpath, glob_info.gl_pathv[0]); - globfree(&glob_info); - return 0; -} - /* * Trim a trailing newline from a string, if it exists. */ @@ -356,190 +312,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, rc); - } - - if (fsname == NULL && file_path != NULL) { - rc = llapi_search_fsname(file_path, fs); - if (rc) { - llapi_error(LLAPI_MSG_ERROR, rc, - "'%s' is not on a Lustre filesystem", - file_path); - GOTO(out, rc); - } - } else if (fsname != NULL) { - rc = strlcpy(fs, fsname, sizeof(fs)); - if (rc >= sizeof(fs)) - GOTO(out, rc = -E2BIG); - } - - 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)) - GOTO(out, rc = -E2BIG); - 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)) - GOTO(out, rc = -E2BIG); - } - rc = snprintf(devices, sizeof(devices), "%s/%s/%s", obd_type, dev, - param_name); - if (rc >= sizeof(devices)) - GOTO(out, rc = -E2BIG); - 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; @@ -548,11 +325,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; @@ -561,26 +342,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) + return md_size; + + /* 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) - goto out; + return md_size; 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) @@ -597,23 +381,43 @@ int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) */ int llapi_search_ost(char *fsname, char *poolname, char *ostname) { - 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; + + /* You need one or the other */ + if (poolname == NULL && fsname == NULL) + return -EINVAL; - if (ostname != NULL) - len = strlen(ostname); + if (ostname != NULL) + len = strlen(ostname); - if (poolname == NULL) { - if (len == 0) - rc = -EINVAL; - else - rc = find_target_obdpath(fsname, buffer); + 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("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) @@ -644,49 +448,114 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) return 0; } -int llapi_file_open_pool(const char *name, int flags, int mode, - unsigned long long stripe_size, int stripe_offset, - int stripe_count, int stripe_pattern, char *pool_name) +/** + * Open a Lustre file. + * + * \param name the name of the file to be opened + * \param flags access mode, see flags in open(2) + * \param mode permission of the file if it is created, see mode in open(2) + * \param param stripe pattern of the newly created file + * + * \retval file descriptor of opened file + * \retval negative errno on failure + */ +int llapi_file_open_param(const char *name, int flags, mode_t mode, + const struct llapi_stripe_param *param) { - struct lov_user_md_v3 lum = { 0 }; - int fd, rc = 0; + char fsname[MAX_OBD_NAME + 1] = { 0 }; + char *pool_name = param->lsp_pool; + struct lov_user_md *lum = NULL; + size_t lum_size = sizeof(*lum); + int fd, rc; - /* Make sure we have a good pool */ - if (pool_name != NULL) { - char fsname[MAX_OBD_NAME + 1], *ptr; + /* Make sure we are on a Lustre file system */ + rc = llapi_search_fsname(name, fsname); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "'%s' is not on a Lustre filesystem", + name); + return rc; + } - rc = llapi_search_fsname(name, fsname); - if (rc) { - llapi_error(LLAPI_MSG_ERROR, rc, - "'%s' is not on a Lustre filesystem", - name); - return rc; - } + /* Check if the stripe pattern is sane. */ + rc = llapi_stripe_limit_check(param->lsp_stripe_size, + param->lsp_stripe_offset, + param->lsp_stripe_count, + param->lsp_stripe_pattern); + if (rc != 0) + return rc; - /* in case user gives the full pool name ., - * strip the fsname */ - ptr = strchr(pool_name, '.'); - if (ptr != NULL) { - *ptr = '\0'; - if (strcmp(pool_name, fsname) != 0) { - *ptr = '.'; - llapi_err_noerrno(LLAPI_MSG_ERROR, - "Pool '%s' is not on filesystem '%s'", - pool_name, fsname); - return -EINVAL; - } - pool_name = ptr + 1; - } + /* Make sure we have a good pool */ + if (pool_name != NULL) { + /* in case user gives the full pool name ., + * strip the fsname */ + char *ptr = strchr(pool_name, '.'); + if (ptr != NULL) { + *ptr = '\0'; + if (strcmp(pool_name, fsname) != 0) { + *ptr = '.'; + llapi_err_noerrno(LLAPI_MSG_ERROR, + "Pool '%s' is not on filesystem '%s'", + pool_name, fsname); + return -EINVAL; + } + pool_name = ptr + 1; + } - /* Make sure the pool exists and is non-empty */ - rc = llapi_search_ost(fsname, pool_name, NULL); - if (rc < 1) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "pool '%s.%s' %s", fsname, pool_name, - rc == 0 ? "has no OSTs" : "does not exist"); - return -EINVAL; - } - } + /* Make sure the pool exists and is non-empty */ + rc = llapi_search_ost(fsname, pool_name, NULL); + if (rc < 1) { + char *err = rc == 0 ? "has no OSTs" : "does not exist"; + + llapi_err_noerrno(LLAPI_MSG_ERROR, "pool '%s.%s' %s", + fsname, pool_name, err); + return -EINVAL; + } + + lum_size = sizeof(struct lov_user_md_v3); + } + + /* sanity check of target list */ + if (param->lsp_is_specific) { + char ostname[MAX_OBD_NAME + 1]; + bool found = false; + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) { + snprintf(ostname, sizeof(ostname), "%s-OST%04x_UUID", + fsname, param->lsp_osts[i]); + rc = llapi_search_ost(fsname, pool_name, ostname); + if (rc <= 0) { + if (rc == 0) + rc = -ENODEV; + + llapi_error(LLAPI_MSG_ERROR, rc, + "%s: cannot find OST %s in %s", + __func__, ostname, + pool_name != NULL ? + "pool" : "system"); + return rc; + } + + /* Make sure stripe offset is in OST list. */ + if (param->lsp_osts[i] == param->lsp_stripe_offset) + found = true; + } + if (!found) { + llapi_error(LLAPI_MSG_ERROR, -EINVAL, + "%s: stripe offset '%d' is not in the " + "target list", + __func__, param->lsp_stripe_offset); + return -EINVAL; + } + + lum_size = lov_user_md_size(param->lsp_stripe_count, + LOV_USER_MAGIC_SPECIFIC); + } + + lum = calloc(1, lum_size); + if (lum == NULL) + return -ENOMEM; retry_open: fd = open(name, flags | O_LOV_DELAY_CREATE, mode); @@ -697,48 +566,74 @@ retry_open: } } - if (fd < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); - return rc; - } + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + free(lum); + return rc; + } - rc = llapi_stripe_limit_check(stripe_size, stripe_offset, stripe_count, - stripe_pattern); - if (rc != 0) - goto out; + /* Initialize IOCTL striping pattern structure */ + lum->lmm_magic = LOV_USER_MAGIC_V1; + lum->lmm_pattern = param->lsp_stripe_pattern; + lum->lmm_stripe_size = param->lsp_stripe_size; + lum->lmm_stripe_count = param->lsp_stripe_count; + lum->lmm_stripe_offset = param->lsp_stripe_offset; + if (pool_name != NULL) { + struct lov_user_md_v3 *lumv3 = (void *)lum; - /* Initialize IOCTL striping pattern structure */ - lum.lmm_magic = LOV_USER_MAGIC_V3; - lum.lmm_pattern = stripe_pattern; - lum.lmm_stripe_size = stripe_size; - lum.lmm_stripe_count = stripe_count; - lum.lmm_stripe_offset = stripe_offset; - if (pool_name != NULL) { - strlcpy(lum.lmm_pool_name, pool_name, - sizeof(lum.lmm_pool_name)); - } else { - /* If no pool is specified at all, use V1 request */ - lum.lmm_magic = LOV_USER_MAGIC_V1; - } + lumv3->lmm_magic = LOV_USER_MAGIC_V3; + strncpy(lumv3->lmm_pool_name, pool_name, LOV_MAXPOOLNAME); + } + if (param->lsp_is_specific) { + struct lov_user_md_v3 *lumv3 = (void *)lum; + int i; + + lumv3->lmm_magic = LOV_USER_MAGIC_SPECIFIC; + if (pool_name == NULL) { + /* LOV_USER_MAGIC_SPECIFIC uses v3 format plus specified + * OST list, therefore if pool is not specified we have + * to pack a null pool name for placeholder. */ + memset(lumv3->lmm_pool_name, 0, LOV_MAXPOOLNAME); + } - if (ioctl(fd, LL_IOC_LOV_SETSTRIPE, &lum)) { - char *errmsg = "stripe already set"; - rc = -errno; - if (errno != EEXIST && errno != EALREADY) - errmsg = strerror(errno); + for (i = 0; i < param->lsp_stripe_count; i++) + lumv3->lmm_objects[i].l_ost_idx = param->lsp_osts[i]; + } - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error on ioctl "LPX64" for '%s' (%d): %s", - (__u64)LL_IOC_LOV_SETSTRIPE, name, fd,errmsg); - } -out: - if (rc) { - close(fd); - fd = rc; - } + if (ioctl(fd, LL_IOC_LOV_SETSTRIPE, lum) != 0) { + char *errmsg = "stripe already set"; + + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error on ioctl %#jx for '%s' (%d): %s", + (uintmax_t)LL_IOC_LOV_SETSTRIPE, name, fd, + errmsg); + + close(fd); + fd = rc; + } + + free(lum); - return fd; + return fd; +} + +int llapi_file_open_pool(const char *name, int flags, int mode, + unsigned long long stripe_size, int stripe_offset, + int stripe_count, int stripe_pattern, char *pool_name) +{ + const struct llapi_stripe_param param = { + .lsp_stripe_size = stripe_size, + .lsp_stripe_count = stripe_count, + .lsp_stripe_pattern = stripe_pattern, + .lsp_stripe_offset = stripe_offset, + .lsp_pool = pool_name + }; + return llapi_file_open_param(name, flags, mode, ¶m); } int llapi_file_open(const char *name, int flags, int mode, @@ -851,7 +746,7 @@ int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, lmu.lum_stripe_count = stripe_count; lmu.lum_hash_type = stripe_pattern; if (pool_name != NULL) { - if (strlen(pool_name) >= LOV_MAXPOOLNAME) { + if (strlen(pool_name) > LOV_MAXPOOLNAME) { llapi_err_noerrno(LLAPI_MSG_ERROR, "error LL_IOC_LMV_SETSTRIPE '%s' : too large" "pool name: %s", name, pool_name); @@ -930,8 +825,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: @@ -948,21 +843,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, + "setmntent(%s) failed", PROC_MOUNTS); + return rc; + } while (1) { if (getmntent_r(fp, &mnt, buf, sizeof(buf)) == NULL) break; @@ -974,58 +869,71 @@ 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, + "error opening '%s'", mntdir); + + } 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; } /* @@ -1038,7 +946,7 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) * the value of the index will be ignored. The pathname will return data if * the pathname is located on a lustre mount. Index is used to pick which * mount point you want in the case of multiple mounted lustre file systems. - * See function lfs_osts in lfs.c for a example of the index use. + * See function lfs_osts in lfs.c for an example of the index use. */ int llapi_search_mounts(const char *pathname, int index, char *mntdir, char *fsname) @@ -1131,37 +1039,6 @@ int llapi_getname(const char *path, char *buf, size_t size) 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); - } - - snprintf(pattern, PATH_MAX, "/proc/fs/lustre/lov/%s-*/pools", fsname); - rc = first_match(pattern, buffer); - if (rc) - return rc; - - /* in fsname test mode, pool_pathname is NULL */ - if (pool_pathname != NULL) - strcpy(pool_pathname, buffer); - - return 0; -} - /** * Get the list of pool members. * \param poolname string of format \.\ @@ -1178,43 +1055,43 @@ 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 = strchr(fsname, '.'); + if (pool == NULL) + return -EINVAL; - *pool = '\0'; - pool++; + *pool = '\0'; + pool++; - rc = poolpath(fsname, NULL, pathname); - if (rc != 0) { - llapi_error(LLAPI_MSG_ERROR, rc, - "Lustre filesystem '%s' not found", - fsname); - return rc; - } + 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) { @@ -1257,7 +1134,9 @@ 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; @@ -1267,7 +1146,7 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, unsigned int used = 0; unsigned int i; - /* initilize output array */ + /* initialize output array */ for (i = 0; i < list_size; i++) poollist[i] = NULL; @@ -1285,50 +1164,45 @@ 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); + llapi_printf(LLAPI_MSG_NORMAL, "Pools from %s:\n", fsname); + 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; - } + while(1) { + rc = readdir_r(dir, &pool, &cookie); + if (rc != 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "Error reading pool list for '%s'", name); + goto free_path; + } else if ((rc == 0) && (cookie == NULL)) { + /* end of directory */ + break; + } /* ignore . and .. */ if (!strcmp(pool.d_name, ".") || !strcmp(pool.d_name, "..")) @@ -1337,14 +1211,14 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, /* check output bounds */ if (nb_entries >= list_size) { rc = -EOVERFLOW; - goto out; + goto free_dir; } /* +2 for '.' and final '\0' */ if (used + strlen(pool.d_name) + strlen(fsname) + 2 > buffer_size) { rc = -EOVERFLOW; - goto out; + goto free_dir; } sprintf(buffer + used, "%s.%s", fsname, pool.d_name); @@ -1353,19 +1227,24 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, nb_entries++; } -out: - closedir(dir); - return ((rc != 0) ? rc : nb_entries); +free_dir: + 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; @@ -1375,18 +1254,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 @@ -1422,9 +1300,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, @@ -1434,44 +1312,47 @@ typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d, static int common_param_init(struct find_param *param, char *path) { - int lumlen = get_mds_md_size(path); + int lum_size = get_mds_md_size(path); - if (lumlen < PATH_MAX + 1) - lumlen = PATH_MAX + 1; + if (lum_size < PATH_MAX + 1) + lum_size = PATH_MAX + 1; - param->lumlen = lumlen; - param->lmd = malloc(sizeof(lstat_t) + param->lumlen); - if (param->lmd == NULL) { + param->fp_lum_size = lum_size; + param->fp_lmd = calloc(1, sizeof(lstat_t) + param->fp_lum_size); + if (param->fp_lmd == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %zu bytes for ioctl", - sizeof(lstat_t) + param->lumlen); + sizeof(lstat_t) + param->fp_lum_size); return -ENOMEM; } - param->fp_lmv_count = 256; - param->fp_lmv_md = malloc(lmv_user_md_size(256, LMV_MAGIC_V1)); + param->fp_lmv_stripe_count = 256; + param->fp_lmv_md = calloc(1, + lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); if (param->fp_lmv_md == NULL) { llapi_error(LLAPI_MSG_ERROR, -ENOMEM, "error: allocation of %d bytes for ioctl", - lmv_user_md_size(256, LMV_MAGIC_V1)); + lmv_user_md_size(param->fp_lmv_stripe_count, + LMV_MAGIC_V1)); return -ENOMEM; } - param->got_uuids = 0; - param->obdindexes = NULL; - param->obdindex = OBD_NOT_FOUND; - if (!param->migrate) - param->mdtindex = OBD_NOT_FOUND; + param->fp_got_uuids = 0; + param->fp_obd_indexes = NULL; + param->fp_obd_index = OBD_NOT_FOUND; + if (!param->fp_migrate) + param->fp_mdt_index = OBD_NOT_FOUND; return 0; } static void find_param_fini(struct find_param *param) { - if (param->obdindexes) - free(param->obdindexes); + if (param->fp_obd_indexes) + free(param->fp_obd_indexes); - if (param->lmd) - free(param->lmd); + if (param->fp_lmd) + free(param->fp_lmd); if (param->fp_lmv_md) free(param->fp_lmv_md); @@ -1487,35 +1368,56 @@ 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; - - fname = strrchr(path, '/'); - if (fname == NULL) - return opendir("."); - - c = fname[1]; - fname[1] = '\0'; - parent = opendir(path); - fname[1] = c; - return parent; + char *path_copy; + char *parent_path; + DIR *parent; + + path_copy = strdup(path); + if (path_copy == NULL) + return NULL; + + 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) { - struct lmv_user_md *lmv = (struct lmv_user_md *)param->fp_lmv_md; - int ret = 0; + int ret; - lmv->lum_stripe_count = param->fp_lmv_count; - if (param->get_default_lmv) - lmv->lum_magic = LMV_USER_MAGIC; +again: + param->fp_lmv_md->lum_stripe_count = param->fp_lmv_stripe_count; + if (param->fp_get_default_lmv) + param->fp_lmv_md->lum_magic = LMV_USER_MAGIC; else - lmv->lum_magic = LMV_MAGIC_V1; - ret = ioctl(dirfd(d), LL_IOC_LMV_GETSTRIPE, lmv); + param->fp_lmv_md->lum_magic = LMV_MAGIC_V1; + + ret = ioctl(dirfd(d), LL_IOC_LMV_GETSTRIPE, param->fp_lmv_md); + if (errno == E2BIG && ret != 0) { + int stripe_count; + int lmv_size; + stripe_count = (__u32)param->fp_lmv_md->lum_stripe_count; + if (stripe_count <= param->fp_lmv_stripe_count) + return ret; + + free(param->fp_lmv_md); + param->fp_lmv_stripe_count = stripe_count; + lmv_size = lmv_user_md_size(stripe_count, LMV_MAGIC_V1); + 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)); + return -ENOMEM; + } + goto again; + } return ret; } @@ -1531,12 +1433,18 @@ static int get_lmd_info(char *path, DIR *parent, DIR *dir, if (dir) { ret = ioctl(dirfd(dir), LL_IOC_MDC_GETINFO, (void *)lmd); } else if (parent) { - char *fname = strrchr(path, '/'); + char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - /* retrieve needed file info */ + /* To avoid opening, locking, and closing each file on the + * client if that is not needed. The GETFILEINFO ioctl can + * be done on the patent dir with a single open for all + * files in that directory, and it also doesn't pollute the + * client dcache with millions of dentries when traversing + * a large filesystem. */ + fname = (fname == NULL ? path : fname + 1); + /* retrieve needed file info */ strlcpy((char *)lmd, fname, lumlen); - ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); + ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); } if (ret) { @@ -1608,8 +1516,6 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, while ((dent = readdir64(d)) != NULL) { int rc; - param->have_fileinfo = 0; - if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; @@ -1628,10 +1534,10 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, strcat(path, dent->d_name); if (dent->d_type == DT_UNKNOWN) { - lstat_t *st = ¶m->lmd->lmd_st; + lstat_t *st = ¶m->fp_lmd->lmd_st; - rc = get_lmd_info(path, d, NULL, param->lmd, - param->lumlen); + rc = get_lmd_info(path, d, NULL, param->fp_lmd, + param->fp_lum_size); if (rc == 0) dent->d_type = IFTODT(st->st_mode); else if (ret == 0) @@ -1731,26 +1637,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, "error opening %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); @@ -1767,44 +1673,49 @@ 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 - * there are more OSTs then allocated to uuidp, then an error is returned with + * there are more OSTs than allocated to uuidp, then an error is returned with * the ost_count set to number of available obd uuids. */ static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, int *ost_count, enum tgt_type type) { - struct obd_uuid name; - char buf[1024]; - FILE *fp; - int rc = 0, index = 0; - - /* 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; - } + char buf[PATH_MAX], format[32]; + int rc = 0, index = 0; + struct obd_uuid name; + glob_t param; + FILE *fp; - /* 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; - } + /* 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; - while (fgets(buf, sizeof(buf), fp) != NULL) { - if (uuidp && (index < *ost_count)) { - if (sscanf(buf, "%d: %s", &index, uuidp[index].uuid) <2) + /* 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); + while (fgets(buf, sizeof(buf), fp) != NULL) { + if (uuidp && (index < *ost_count)) { + if (sscanf(buf, format, &index, uuidp[index].uuid) < 2) break; } index++; @@ -1815,8 +1726,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) @@ -1826,23 +1739,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, @@ -1868,81 +1781,95 @@ int llapi_uuid_match(char *real_uuid, char *search_uuid) return (strncmp(search_uuid, real_uuid, cmplen) == 0); } -/* Here, param->obduuid points to a single obduuid, the index of which is - * returned in param->obdindex */ -static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) +/* 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(int fd, char *dname, struct find_param *param) { - struct obd_uuid obd_uuid; - char uuid[sizeof(struct obd_uuid)]; - char buf[1024]; - FILE *fp; - int rc = 0, index; + struct obd_uuid obd_uuid; + char buf[PATH_MAX]; + glob_t param_data; + char format[32]; + int rc = 0; + FILE *fp; - if (param->got_uuids) - return rc; + if (param->fp_got_uuids) + return rc; - /* Get the lov/lmv name */ - if (param->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; - } + /* Get the lov/lmv name */ + if (param->fp_get_lmv) + 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->got_uuids = 1; + param->fp_got_uuids = 1; - /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/%s/%s/target_obd", - param->get_lmv ? "lmv" : "lov", obd_uuid.uuid); - 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->obduuid && !param->quiet && !param->obds_printed) - llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", - param->get_lmv ? "MDTS" : "OBDS:"); + if (!param->fp_obd_uuid && !param->fp_quiet && !param->fp_obds_printed) + llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", + param->fp_get_lmv ? "MDTS" : "OBDS"); - while (fgets(buf, sizeof(buf), fp) != NULL) { - if (sscanf(buf, "%d: %s", &index, uuid) < 2) - break; + snprintf(format, sizeof(format), + "%%d: %%%zus", sizeof(obd_uuid.uuid) - 1); + while (fgets(buf, sizeof(buf), fp) != NULL) { + int index; - if (param->obduuid) { - if (llapi_uuid_match(uuid, param->obduuid->uuid)) { - param->obdindex = index; - break; - } - } else if (!param->quiet && !param->obds_printed) { - /* Print everything */ - llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); - } - } - param->obds_printed = 1; + if (sscanf(buf, format, &index, obd_uuid.uuid) < 2) + break; - fclose(fp); + if (param->fp_obd_uuid) { + if (llapi_uuid_match(obd_uuid.uuid, + param->fp_obd_uuid->uuid)) { + param->fp_obd_index = index; + break; + } + } else if (!param->fp_quiet && !param->fp_obds_printed) { + /* Print everything */ + llapi_printf(LLAPI_MSG_NORMAL, "%s", buf); + } + } + param->fp_obds_printed = 1; - if (param->obduuid && (param->obdindex == OBD_NOT_FOUND)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: unknown obduuid: %s", - __func__, param->obduuid->uuid); - rc = -EINVAL; - } + fclose(fp); - return (rc); + if (param->fp_obd_uuid && (param->fp_obd_index == OBD_NOT_FOUND)) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: unknown obduuid: %s", + __func__, param->fp_obd_uuid->uuid); + rc = -EINVAL; + } +free_param: + cfs_free_param_data(¶m_data); + return rc; } -/* In this case, param->obduuid will be an array of obduuids and +/* In this case, param->fp_obd_uuid will be an array of obduuids and * obd index for all these obduuids will be returned in - * param->obdindexes */ + * param->fp_obd_indexes */ static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, int num_obds, int **obdindexes, int *obdindex, enum tgt_type type) @@ -1960,27 +1887,25 @@ 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; @@ -2036,98 +1961,42 @@ static int setup_target_indexes(DIR *dir, char *path, struct find_param *param) { int ret = 0; - if (param->mdtuuid) { - ret = setup_indexes(dir, path, param->mdtuuid, param->num_mdts, - ¶m->mdtindexes, ¶m->mdtindex, LMV_TYPE); - if (ret) - return ret; - } - if (param->obduuid) { - ret = setup_indexes(dir, path, param->obduuid, param->num_obds, - ¶m->obdindexes, ¶m->obdindex, LOV_TYPE); - if (ret) - return ret; - } - param->got_uuids = 1; - return ret; -} - -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); + if (param->fp_mdt_uuid) { + ret = setup_indexes(dir, path, param->fp_mdt_uuid, + param->fp_num_mdts, + ¶m->fp_mdt_indexes, + ¶m->fp_mdt_index, LMV_TYPE); + if (ret) + return ret; + } - rc = first_match(pattern, buffer); - if (rc != 0) - return rc; + if (param->fp_obd_uuid) { + ret = setup_indexes(dir, path, param->fp_obd_uuid, + param->fp_num_obds, + ¶m->fp_obd_indexes, + ¶m->fp_obd_index, LOV_TYPE); + if (ret) + return ret; + } - strlcpy(clilovpath, buffer, sizeof(buffer)); + param->fp_got_uuids = 1; - return 0; + return ret; } -/* - * 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) +int llapi_ostlist(char *path, struct find_param *param) { + int fd; + int ret; - FILE *f; - char line[PATH_MAX + 1]; - int rc = 0; - - 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; } /* @@ -2136,41 +2005,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; } /* @@ -2212,8 +2078,7 @@ 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; @@ -2234,13 +2099,13 @@ static int sattr_cache_get_defaults(const char *const fsname, } 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) + struct lov_user_ost_data_v1 *objects, + int is_dir, int verbose, int depth, + int raw, char *pool_name) { - char *prefix = is_dir ? "" : "lmm_"; - char *seperator = ""; - int rc; + char *prefix = is_dir ? "" : "lmm_"; + char *separator = ""; + int rc; if (is_dir && lmm_oi_seq(&lum->lmm_oi) == FID_SEQ_LOV_DEFAULT) { lmm_oi_set_seq(&lum->lmm_oi, 0); @@ -2248,115 +2113,143 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); } - if (depth && path && ((verbose != VERBOSE_OBJID) || !is_dir)) - llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); + if (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)); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_seq: %#jx\n", + (uintmax_t)lmm_oi_seq(&lum->lmm_oi)); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: %#jx\n", + (uintmax_t)lmm_oi_id(&lum->lmm_oi)); + } + if ((verbose & (VERBOSE_DETAIL | VERBOSE_DFID)) && !is_dir) { + if (verbose & ~VERBOSE_DFID) + llapi_printf(LLAPI_MSG_NORMAL, "lmm_fid: "); + /* 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. */ + llapi_printf(LLAPI_MSG_NORMAL, DFID"\n", + lmm_oi_seq(&lum->lmm_oi) == 0 ? + lmm_oi_id(&lum->lmm_oi) : + lmm_oi_seq(&lum->lmm_oi), + lmm_oi_seq(&lum->lmm_oi) == 0 ? + 0 : (__u32)lmm_oi_id(&lum->lmm_oi), + (__u32)(lmm_oi_id(&lum->lmm_oi) >> 32)); } - 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) + 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 { + 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); - } - seperator = is_dir ? " " : "\n"; - } + } + separator = is_dir ? " " : "\n"; + } - if (verbose & VERBOSE_SIZE) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); - if (verbose & ~VERBOSE_SIZE) - llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_size: ", - prefix); - 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_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) 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); - } - seperator = is_dir ? " " : "\n"; - } + } + separator = is_dir ? " " : "\n"; + } if ((verbose & VERBOSE_LAYOUT) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + 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); - seperator = "\n"; + separator = "\n"; } - if ((verbose & VERBOSE_GENERATION) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); - if (verbose & ~VERBOSE_GENERATION) - llapi_printf(LLAPI_MSG_NORMAL, "%slayout_gen: ", - prefix); + 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); llapi_printf(LLAPI_MSG_NORMAL, "%u", (int)lum->lmm_layout_gen); - seperator = "\n"; - } + separator = "\n"; + } - if (verbose & VERBOSE_OFFSET) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); - if (verbose & ~VERBOSE_OFFSET) - llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ", - prefix); - if (is_dir) + if (verbose & VERBOSE_OFFSET) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_OFFSET) + llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ", + prefix); + if (is_dir) 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 llapi_printf(LLAPI_MSG_NORMAL, "%u", objects[0].l_ost_idx); - seperator = is_dir ? " " : "\n"; - } + separator = is_dir ? " " : "\n"; + } - if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) { - llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); - if (verbose & ~VERBOSE_POOL) - llapi_printf(LLAPI_MSG_NORMAL, "%spool: ", - prefix); + if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_POOL) + llapi_printf(LLAPI_MSG_NORMAL, "%spool: ", + prefix); llapi_printf(LLAPI_MSG_NORMAL, "%s", pool_name); - } + } - if (!is_dir || (is_dir && (verbose != VERBOSE_OBJID))) - llapi_printf(LLAPI_MSG_NORMAL, "\n"); + if (!is_dir || (is_dir && (verbose != VERBOSE_OBJID))) + llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, @@ -2485,7 +2378,8 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, } - if ((verbose & VERBOSE_POOL) && (pool_name[0] != '\0')) { + if ((verbose & VERBOSE_POOL) && pool_name != NULL && + pool_name[0] != '\0') { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_POOL) llapi_printf(LLAPI_MSG_NORMAL, "%slmv_pool: ", @@ -2502,30 +2396,31 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) { __u32 magic; - if (param->get_lmv || param->get_default_lmv) + if (param->fp_get_lmv || param->fp_get_default_lmv) magic = (__u32)param->fp_lmv_md->lum_magic; else - magic = *(__u32 *)¶m->lmd->lmd_lmm; /* lum->lmm_magic */ + magic = *(__u32 *)¶m->fp_lmd->lmd_lmm; /* lum->lmm_magic */ switch (magic) { case LOV_USER_MAGIC_V1: - lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL, - param->lmd->lmd_lmm.lmm_objects, - path, is_dir, - param->obdindex, param->fp_max_depth, - param->verbose, param->raw); + lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, NULL, + param->fp_lmd->lmd_lmm.lmm_objects, + path, is_dir, + param->fp_obd_index, param->fp_max_depth, + param->fp_verbose, param->fp_raw); break; case LOV_USER_MAGIC_V3: { char pool_name[LOV_MAXPOOLNAME + 1]; struct lov_user_ost_data_v1 *objects; - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; + 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->lmd->lmd_lmm, pool_name, - objects, path, is_dir, - param->obdindex, param->fp_max_depth, - param->verbose, param->raw); + 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; } case LMV_MAGIC_V1: @@ -2535,15 +2430,16 @@ void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) 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, path, - param->obdindex, param->fp_max_depth, - param->verbose); + lmv_dump_user_lmm(lum, + pool_name[0] == '\0' ? NULL : pool_name, + path, param->fp_obd_index, + param->fp_max_depth, param->fp_verbose); break; } default: llapi_printf(LLAPI_MSG_NORMAL, "unknown lmm_magic: %#x " "(expecting one of %#x %#x %#x %#x)\n", - *(__u32 *)¶m->lmd->lmd_lmm, + *(__u32 *)¶m->fp_lmd->lmd_lmm, LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3, LMV_USER_MAGIC, LMV_MAGIC_V1); return; @@ -2552,44 +2448,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; - - 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++; - } + const char *fname; + char *dname; + int fd, rc = 0; - fd = open(dname, O_RDONLY); - if (fd == -1) { - rc = -errno; - free(dname); - return rc; - } + fname = strrchr(path, '/'); - strcpy((char *)lum, fname); - if (ioctl(fd, IOC_MDC_GETFILESTRIPE, (void *)lum) == -1) - rc = -errno; + /* 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++; + } - if (close(fd) == -1 && rc == 0) - rc = -errno; + fd = open(dname, O_RDONLY | O_NONBLOCK); + if (fd == -1) { + rc = -errno; + free(dname); + return rc; + } - free(dname); - return rc; + strcpy((char *)lum, fname); + if (ioctl(fd, IOC_MDC_GETFILESTRIPE, (void *)lum) == -1) + rc = -errno; + + if (close(fd) == -1 && rc == 0) + rc = -errno; + + free(dname); + return rc; } int llapi_file_lookup(int dirfd, const char *name) @@ -2723,66 +2619,68 @@ static int find_time_check(lstat_t *st, struct find_param *param, int mds) */ static int check_obd_match(struct find_param *param) { - lstat_t *st = ¶m->lmd->lmd_st; - struct lov_user_ost_data_v1 *lmm_objects; - int i, j; + lstat_t *st = ¶m->fp_lmd->lmd_st; + struct lov_user_ost_data_v1 *lmm_objects; + int i, j; - if (param->obduuid && param->obdindex == OBD_NOT_FOUND) - return 0; + if (param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) + return 0; - if (!S_ISREG(st->st_mode)) - return 0; + if (!S_ISREG(st->st_mode)) + return 0; - /* Only those files should be accepted, which have a - * stripe on the specified OST. */ - if (!param->lmd->lmd_lmm.lmm_stripe_count) - return 0; + /* Only those files should be accepted, which have a + * stripe on the specified OST. */ + if (!param->fp_lmd->lmd_lmm.lmm_stripe_count) + return 0; - if (param->lmd->lmd_lmm.lmm_magic == - LOV_USER_MAGIC_V3) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; + if (param->fp_lmd->lmd_lmm.lmm_magic == + LOV_USER_MAGIC_V3) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; - lmm_objects = lmmv3->lmm_objects; - } else if (param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { - lmm_objects = param->lmd->lmd_lmm.lmm_objects; - } else { - llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", - __func__, param->lmd->lmd_lmm.lmm_magic); - return -EINVAL; - } + lmm_objects = lmmv3->lmm_objects; + } else if (param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) { + lmm_objects = param->fp_lmd->lmd_lmm.lmm_objects; + } else { + llapi_err_noerrno(LLAPI_MSG_ERROR, "%s:Unknown magic: 0x%08X\n", + __func__, param->fp_lmd->lmd_lmm.lmm_magic); + return -EINVAL; + } - for (i = 0; i < param->lmd->lmd_lmm.lmm_stripe_count; i++) { - for (j = 0; j < param->num_obds; j++) { - if (param->obdindexes[j] == - lmm_objects[i].l_ost_idx) { - if (param->exclude_obd) - return 0; - return 1; - } - } - } + for (i = 0; i < param->fp_lmd->lmd_lmm.lmm_stripe_count; i++) { + for (j = 0; j < param->fp_num_obds; j++) { + if (param->fp_obd_indexes[j] == + lmm_objects[i].l_ost_idx) { + if (param->fp_exclude_obd) + return 0; + return 1; + } + } + } - if (param->exclude_obd) + if (param->fp_exclude_obd) return 1; - return 0; + + return 0; } static int check_mdt_match(struct find_param *param) { - int i; + int i; - if (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND) - return 0; + if (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND) + return 0; - /* FIXME: For striped dir, we should get stripe information and check */ - for (i = 0; i < param->num_mdts; i++) { - if (param->mdtindexes[i] == param->file_mdtindex) - return !param->exclude_mdt; + /* FIXME: For striped dir, we should get stripe information and check */ + for (i = 0; i < param->fp_num_mdts; i++) { + if (param->fp_mdt_indexes[i] == param->fp_file_mdt_index) + return !param->fp_exclude_mdt; } - if (param->exclude_mdt) - return 1; - return 0; + if (param->fp_exclude_mdt) + return 1; + + return 0; } /** @@ -2800,16 +2698,17 @@ static int print_failed_tgt(struct find_param *param, char *path, int type) memset(&stat_buf, 0, sizeof(struct obd_statfs)); memset(&uuid_buf, 0, sizeof(struct obd_uuid)); - ret = llapi_obd_statfs(path, type, - param->obdindex, &stat_buf, - &uuid_buf); - if (ret) { - llapi_printf(LLAPI_MSG_NORMAL, - "obd_uuid: %s failed %s ", - param->obduuid->uuid, - strerror(errno)); - } - return ret; + ret = llapi_obd_statfs(path, type, + param->fp_obd_index, &stat_buf, + &uuid_buf); + if (ret) { + llapi_printf(LLAPI_MSG_NORMAL, + "obd_uuid: %s failed %s ", + param->fp_obd_uuid->uuid, + strerror(errno)); + } + + return ret; } static int cb_find_init(char *path, DIR *parent, DIR **dirp, @@ -2818,25 +2717,24 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, struct find_param *param = (struct find_param *)data; DIR *dir = dirp == NULL ? NULL : *dirp; int decision = 1; /* 1 is accepted; -1 is rejected. */ - lstat_t *st = ¶m->lmd->lmd_st; + lstat_t *st = ¶m->fp_lmd->lmd_st; int lustre_fs = 1; int checked_type = 0; int ret = 0; LASSERT(parent != NULL || dir != NULL); - if (param->have_fileinfo == 0) - param->lmd->lmd_lmm.lmm_stripe_count = 0; + param->fp_lmd->lmd_lmm.lmm_stripe_count = 0; - /* If a regular expression is presented, make the initial decision */ - if (param->pattern != NULL) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - ret = fnmatch(param->pattern, fname, 0); - if ((ret == FNM_NOMATCH && !param->exclude_pattern) || - (ret == 0 && param->exclude_pattern)) - goto decided; - } + /* If a regular expression is presented, make the initial decision */ + if (param->fp_pattern != NULL) { + char *fname = strrchr(path, '/'); + fname = (fname == NULL ? path : fname + 1); + ret = fnmatch(param->fp_pattern, fname, 0); + if ((ret == FNM_NOMATCH && !param->fp_exclude_pattern) || + (ret == 0 && param->fp_exclude_pattern)) + goto decided; + } /* See if we can check the file type from the dirent. */ if (param->fp_type != 0 && de != NULL && de->d_type != DT_UNKNOWN) { @@ -2851,67 +2749,77 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, } } - ret = 0; + ret = 0; - /* Request MDS for the stat info if some of these parameters need - * to be compared. */ - if (param->obduuid || param->mdtuuid || + /* Request MDS for the stat info if some of these parameters need + * to be compared. */ + if (param->fp_obd_uuid || param->fp_mdt_uuid || param->fp_check_uid || param->fp_check_gid || param->fp_atime || param->fp_mtime || param->fp_ctime || - param->check_pool || param->check_size || - param->check_stripecount || param->check_stripesize || - param->check_layout) + param->fp_check_pool || param->fp_check_size || + param->fp_check_stripe_count || param->fp_check_stripe_size || + param->fp_check_layout) decision = 0; if (param->fp_type != 0 && checked_type == 0) decision = 0; - if (param->have_fileinfo == 0 && decision == 0) { - ret = get_lmd_info(path, parent, dir, param->lmd, - param->lumlen); - if (ret == 0) { - if (dir) { - ret = llapi_file_fget_mdtidx(dirfd(dir), - ¶m->file_mdtindex); - } else { - int fd; - lstat_t tmp_st; - - ret = lstat_f(path, &tmp_st); - if (ret) { - ret = -errno; - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: lstat failed" - "for %s", __func__, path); - return ret; - } - if (S_ISREG(tmp_st.st_mode)) { - fd = open(path, O_RDONLY); - if (fd > 0) { - ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); - close(fd); - } else { - ret = fd; - } - } else { - /* For special inode, it assumes to - * reside on the same MDT with the - * parent */ - fd = dirfd(parent); - ret = llapi_file_fget_mdtidx(fd, - ¶m->file_mdtindex); - } - } - } - if (ret) { - if (ret == -ENOTTY) - lustre_fs = 0; - if (ret == -ENOENT) - goto decided; - return ret; - } - } + if (decision == 0) { + ret = get_lmd_info(path, parent, dir, param->fp_lmd, + param->fp_lum_size); + if (ret == 0 && param->fp_lmd->lmd_lmm.lmm_magic == 0 && + (param->fp_check_pool || param->fp_check_stripe_count || + param->fp_check_stripe_size || param->fp_check_layout)) { + 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; + if (!param->fp_raw) + ostid_set_seq(&lmm->lmm_oi, + FID_SEQ_LOV_DEFAULT); + lmm->lmm_stripe_size = 0; + lmm->lmm_stripe_count = 0; + lmm->lmm_stripe_offset = -1; + } + if (ret == 0 && param->fp_mdt_uuid != NULL) { + if (dir != NULL) { + ret = llapi_file_fget_mdtidx(dirfd(dir), + ¶m->fp_file_mdt_index); + } else if (S_ISREG(st->st_mode)) { + int fd; + + /* FIXME: we could get the MDT index from the + * file's FID in lmd->lmd_lmm.lmm_oi without + * opening the file, once we are sure that + * LFSCK2 (2.6) has fixed up pre-2.0 LOV EAs. + * That would still be an ioctl() to map the + * FID to the MDT, but not an open RPC. */ + fd = open(path, O_RDONLY); + if (fd > 0) { + ret = llapi_file_fget_mdtidx(fd, + ¶m->fp_file_mdt_index); + close(fd); + } else { + ret = -errno; + } + } else { + /* For a special file, we assume it resides on + * the same MDT as the parent directory. */ + ret = llapi_file_fget_mdtidx(dirfd(parent), + ¶m->fp_file_mdt_index); + } + } + if (ret != 0) { + if (ret == -ENOTTY) + lustre_fs = 0; + if (ret == -ENOENT) + goto decided; + + return ret; + } + } if (param->fp_type && !checked_type) { if ((st->st_mode & S_IFMT) == param->fp_type) { @@ -2924,96 +2832,102 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, } /* Prepare odb. */ - if (param->obduuid || param->mdtuuid) { - if (lustre_fs && param->got_uuids && + if (param->fp_obd_uuid || param->fp_mdt_uuid) { + if (lustre_fs && param->fp_got_uuids && param->fp_dev != st->st_dev) { - /* A lustre/lustre mount point is crossed. */ - param->got_uuids = 0; - param->obds_printed = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; - } + /* A lustre/lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_obds_printed = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; + } - if (lustre_fs && !param->got_uuids) { - ret = setup_target_indexes(dir ? dir : parent, path, - param); - if (ret) - return ret; + if (lustre_fs && !param->fp_got_uuids) { + ret = setup_target_indexes(dir ? dir : parent, path, + param); + if (ret) + return ret; param->fp_dev = st->st_dev; - } else if (!lustre_fs && param->got_uuids) { - /* A lustre/non-lustre mount point is crossed. */ - param->got_uuids = 0; - param->obdindex = param->mdtindex = OBD_NOT_FOUND; + } else if (!lustre_fs && param->fp_got_uuids) { + /* A lustre/non-lustre mount point is crossed. */ + param->fp_got_uuids = 0; + param->fp_mdt_index = OBD_NOT_FOUND; + param->fp_obd_index = OBD_NOT_FOUND; } } - if (param->check_stripesize) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_size, - param->stripesize, - param->stripesize_sign, - param->exclude_stripesize, - param->stripesize_units, 0); - if (decision == -1) - goto decided; - } + if (param->fp_check_stripe_size) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_size, + param->fp_stripe_size, + param->fp_stripe_size_sign, + param->fp_exclude_stripe_size, + param->fp_stripe_size_units, 0); + if (decision == -1) + goto decided; + } - if (param->check_stripecount) { - decision = find_value_cmp(param->lmd->lmd_lmm.lmm_stripe_count, - param->stripecount, - param->stripecount_sign, - param->exclude_stripecount, 1, 0); - if (decision == -1) - goto decided; + if (param->fp_check_stripe_count) { + decision = find_value_cmp( + param->fp_lmd->lmd_lmm.lmm_stripe_count, + param->fp_stripe_count, + param->fp_stripe_count_sign, + param->fp_exclude_stripe_count, 1, 0); + if (decision == -1) + goto decided; } - if (param->check_layout) { + if (param->fp_check_layout) { __u32 found; - found = (param->lmd->lmd_lmm.lmm_pattern & param->layout); - if ((param->lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) || - (found && param->exclude_layout) || - (!found && !param->exclude_layout)) { + found = (param->fp_lmd->lmd_lmm.lmm_pattern & param->fp_layout); + if ((param->fp_lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) || + (found && param->fp_exclude_layout) || + (!found && !param->fp_exclude_layout)) { decision = -1; goto decided; } } - /* If an OBD UUID is specified but none matches, skip this file. */ - if ((param->obduuid && param->obdindex == OBD_NOT_FOUND) || - (param->mdtuuid && param->mdtindex == OBD_NOT_FOUND)) - goto decided; - - /* If a OST or MDT UUID is given, and some OST matches, - * check it here. */ - if (param->obdindex != OBD_NOT_FOUND || - param->mdtindex != OBD_NOT_FOUND) { - if (param->obduuid) { - if (check_obd_match(param)) { - /* If no mdtuuid is given, we are done. - * Otherwise, fall through to the mdtuuid - * check below. */ - if (!param->mdtuuid) - goto obd_matches; - } else { - goto decided; - } - } - if (param->mdtuuid) { - if (check_mdt_match(param)) - goto obd_matches; - goto decided; - } - } + /* If an OBD UUID is specified but none matches, skip this file. */ + if ((param->fp_obd_uuid && param->fp_obd_index == OBD_NOT_FOUND) || + (param->fp_mdt_uuid && param->fp_mdt_index == OBD_NOT_FOUND)) + goto decided; + + /* If an OST or MDT UUID is given, and some OST matches, + * check it here. */ + if (param->fp_obd_index != OBD_NOT_FOUND || + param->fp_mdt_index != OBD_NOT_FOUND) { + if (param->fp_obd_uuid) { + if (check_obd_match(param)) { + /* If no mdtuuid is given, we are done. + * Otherwise, fall through to the mdtuuid + * check below. */ + if (!param->fp_mdt_uuid) + goto obd_matches; + } else { + goto decided; + } + } + + if (param->fp_mdt_uuid) { + if (check_mdt_match(param)) + goto obd_matches; + goto decided; + } + } + obd_matches: if (param->fp_check_uid) { if (st->st_uid == param->fp_uid) { if (param->fp_exclude_uid) goto decided; - } else { + } else { if (!param->fp_exclude_uid) goto decided; - } - } + } + } if (param->fp_check_gid) { if (st->st_gid == param->fp_gid) { @@ -3025,33 +2939,33 @@ obd_matches: } } - if (param->check_pool) { - struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; - - /* empty requested pool is taken as no pool search => V1 */ - if (((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && - (param->poolname[0] == '\0')) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strncmp(lmmv3->lmm_pool_name, - param->poolname, LOV_MAXPOOLNAME) == 0)) || - ((param->lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && - (strcmp(param->poolname, "*") == 0))) { - if (param->exclude_pool) - goto decided; - } else { - if (!param->exclude_pool) - goto decided; - } - } + if (param->fp_check_pool) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; + + /* empty requested pool is taken as no pool search => V1 */ + if (((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V1) && + (param->fp_poolname[0] == '\0')) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strncmp(lmmv3->lmm_pool_name, + param->fp_poolname, LOV_MAXPOOLNAME) == 0)) || + ((param->fp_lmd->lmd_lmm.lmm_magic == LOV_USER_MAGIC_V3) && + (strcmp(param->fp_poolname, "*") == 0))) { + if (param->fp_exclude_pool) + goto decided; + } else { + if (!param->fp_exclude_pool) + goto decided; + } + } /* Check the time on mds. */ decision = 1; if (param->fp_atime || param->fp_mtime || param->fp_ctime) { int for_mds; - for_mds = lustre_fs ? (S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) - : 0; + for_mds = lustre_fs ? (S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) + : 0; decision = find_time_check(st, param, for_mds); if (decision == -1) goto decided; @@ -3061,30 +2975,29 @@ obd_matches: The regular stat is almost of the same speed as some new 'glimpse-size-ioctl'. */ - if (param->check_size && S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) + if (param->fp_check_size && S_ISREG(st->st_mode) && + param->fp_lmd->lmd_lmm.lmm_stripe_count) decision = 0; - while (!decision) { + if (param->fp_check_size && S_ISDIR(st->st_mode)) + decision = 0; + + if (!decision) { /* For regular files with the stripe the decision may have not * been taken yet if *time or size is to be checked. */ - LASSERT((S_ISREG(st->st_mode) && - param->lmd->lmd_lmm.lmm_stripe_count) || - param->mdtindex != OBD_NOT_FOUND); - - if (param->obdindex != OBD_NOT_FOUND) + if (param->fp_obd_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LOV); - if (param->mdtindex != OBD_NOT_FOUND) + if (param->fp_mdt_index != OBD_NOT_FOUND) print_failed_tgt(param, path, LL_STATFS_LMV); - if (dir) { - ret = ioctl(dirfd(dir), IOC_LOV_GETINFO, - (void *)param->lmd); - } else if (parent) { - ret = ioctl(dirfd(parent), IOC_LOV_GETINFO, - (void *)param->lmd); - } + if (dir != NULL) + ret = fstat_f(dirfd(dir), st); + else if (de != NULL) + ret = fstatat_f(dirfd(parent), de->d_name, st, + AT_SYMLINK_NOFOLLOW); + else + ret = lstat_f(path, st); if (ret) { if (errno == ENOENT) { @@ -3105,18 +3018,17 @@ obd_matches: decision = find_time_check(st, param, 0); if (decision == -1) goto decided; - - break; } - if (param->check_size) - decision = find_value_cmp(st->st_size, param->size, - param->size_sign, param->exclude_size, - param->size_units, 0); + if (param->fp_check_size) + decision = find_value_cmp(st->st_size, param->fp_size, + param->fp_size_sign, + param->fp_exclude_size, + param->fp_size_units, 0); if (decision != -1) { llapi_printf(LLAPI_MSG_NORMAL, "%s", path); - if (param->zeroend) + if (param->fp_zero_end) llapi_printf(LLAPI_MSG_NORMAL, "%c", '\0'); else llapi_printf(LLAPI_MSG_NORMAL, "\n"); @@ -3132,40 +3044,43 @@ decided: return 0; } -static int cb_mv_init(char *path, DIR *parent, DIR **dirp, - void *param_data, struct dirent64 *de) +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; + DIR *tmp_parent = parent; char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; char *rawbuf = raw; struct obd_ioctl_data data = { 0 }; int fd; int ret; + char *path_copy; char *filename; + bool retry = false; LASSERT(parent != NULL || dirp != NULL); 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, - "can not open %s\n", path); + "can not open %s", path); return ret; } } - fd = dirfd(dir); + fd = dirfd(tmp_parent); - filename = basename(path); + path_copy = strdup(path); + filename = basename(path_copy); data.ioc_inlbuf1 = (char *)filename; data.ioc_inllen1 = strlen(filename) + 1; - data.ioc_inlbuf2 = (char *)¶m->mdtindex; - data.ioc_inllen2 = sizeof(param->mdtindex); + data.ioc_inlbuf2 = (char *)¶m->fp_mdt_index; + data.ioc_inllen2 = sizeof(param->fp_mdt_index); ret = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (ret != 0) { llapi_error(LLAPI_MSG_ERROR, ret, @@ -3173,13 +3088,26 @@ static int cb_mv_init(char *path, DIR *parent, DIR **dirp, goto out; } +migrate: ret = ioctl(fd, LL_IOC_MIGRATE, rawbuf); if (ret != 0) { + 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; + } ret = -errno; - fprintf(stderr, "%s migrate failed %d\n", path, ret); + fprintf(stderr, "%s migrate failed: %s (%d)\n", + path, strerror(-ret), ret); goto out; - } else if (param->verbose & VERBOSE_DETAIL) { - fprintf(stdout, "migrate %s to MDT%d\n", path, param->mdtindex); + } else if (param->fp_verbose & VERBOSE_DETAIL) { + fprintf(stdout, "migrate %s to MDT%d\n", + path, param->fp_mdt_index); } out: @@ -3190,23 +3118,38 @@ 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; } +int llapi_migrate_mdt(char *path, struct find_param *param) +{ + return param_callback(path, cb_migrate_mdt_init, cb_common_fini, param); +} + int llapi_mv(char *path, struct find_param *param) { - return param_callback(path, cb_mv_init, cb_common_fini, param); +#if LUSTRE_VERSION_CODE > OBD_OCD_VERSION(2, 9, 53, 0) + static bool printed; + + if (!printed) { + llapi_error(LLAPI_MSG_ERROR, -ESTALE, + "llapi_mv() is deprecated, use llapi_migrate_mdt()\n"); + printed = true; + } +#endif + return llapi_migrate_mdt(path, param); } int llapi_find(char *path, struct find_param *param) @@ -3229,64 +3172,58 @@ int llapi_file_fget_mdtidx(int fd, int *mdtidx) static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data, struct dirent64 *de) { - struct find_param *param = (struct find_param *)data; + struct find_param *param = (struct find_param *)data; DIR *d = dirp == NULL ? NULL : *dirp; - int ret = 0; - int mdtidx; + int ret; + int mdtidx; - LASSERT(parent != NULL || d != NULL); + LASSERT(parent != NULL || d != NULL); - if (d) { - ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); - } else if (parent) { - int fd; + if (d != NULL) { + ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); + } else /* if (parent) */ { + int fd; - fd = open(path, O_RDONLY); - if (fd > 0) { - ret = llapi_file_fget_mdtidx(fd, &mdtidx); - close(fd); - } else { - ret = -errno; - } - } + fd = open(path, O_RDONLY | O_NOCTTY); + if (fd > 0) { + ret = llapi_file_fget_mdtidx(fd, &mdtidx); + close(fd); + } else { + ret = -errno; + } + } - if (ret) { - if (ret == -ENODATA) { - if (!param->obduuid) - llapi_printf(LLAPI_MSG_NORMAL, - "%s has no stripe info\n", path); - goto out; - } else if (ret == -ENOENT) { - llapi_error(LLAPI_MSG_WARN, ret, - "warning: %s: %s does not exist", - __func__, path); - goto out; - } else if (ret == -ENOTTY) { - llapi_error(LLAPI_MSG_ERROR, ret, - "%s: '%s' not on a Lustre fs?", - __func__, path); - } else { - llapi_error(LLAPI_MSG_ERROR, ret, - "error: %s: LL_IOC_GET_MDTIDX failed for %s", - __func__, path); - } - return ret; - } + if (ret != 0) { + if (ret == -ENODATA) { + if (!param->fp_obd_uuid) + llapi_printf(LLAPI_MSG_NORMAL, + "'%s' has no stripe info\n", path); + goto out; + } else if (ret == -ENOENT) { + llapi_error(LLAPI_MSG_WARN, ret, + "warning: %s: '%s' does not exist", + __func__, path); + goto out; + } else if (ret == -ENOTTY) { + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: '%s' not on a Lustre fs", + __func__, path); + } else { + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: '%s' failed get_mdtidx", + __func__, path); + } + return ret; + } - /* The 'LASSERT(parent != NULL || d != NULL);' guarantees - * that either 'd' or 'parent' is not null. - * So in all cases llapi_file_fget_mdtidx() is called, - * thus initializing 'mdtidx'. */ - if (param->quiet || !(param->verbose & VERBOSE_DETAIL)) - /* coverity[uninit_use_in_call] */ - llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx); - else - /* coverity[uninit_use_in_call] */ - llapi_printf(LLAPI_MSG_NORMAL, "%s\nmdt_index:\t%d\n", - path, mdtidx); + if (param->fp_quiet || !(param->fp_verbose & VERBOSE_DETAIL)) + llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx); + else + llapi_printf(LLAPI_MSG_NORMAL, "%s\nmdt_index:\t%d\n", + path, mdtidx); out: - /* Do not get down anymore? */ + /* Do not go down anymore? */ if (param->fp_depth == param->fp_max_depth) return 1; @@ -3304,29 +3241,32 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, LASSERT(parent != NULL || d != NULL); - if (param->obduuid) { - param->quiet = 1; - ret = setup_obd_uuid(d ? d : parent, path, param); - if (ret) - return ret; - } + if (param->fp_obd_uuid) { + param->fp_quiet = 1; + ret = setup_obd_uuid(d ? dirfd(d) : dirfd(parent), path, param); + if (ret) + return ret; + } if (d) { - if (param->get_lmv || param->get_default_lmv) { + if (param->fp_get_lmv || param->fp_get_default_lmv) { ret = cb_get_dirstripe(path, d, param); } else { ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); } - } else if (parent && !param->get_lmv && !param->get_default_lmv) { + } 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->lmd->lmd_lmm, fname, param->lumlen); + strlcpy((char *)¶m->fp_lmd->lmd_lmm, fname, + param->fp_lum_size); ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, - (void *)¶m->lmd->lmd_lmm); + (void *)¶m->fp_lmd->lmd_lmm); + } else { + return 0; } if (ret) { @@ -3337,14 +3277,14 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, * a check later on in the code path. * The object_seq needs to be set for the "(Default)" * prefix to be displayed. */ - if (param->get_default_lmv) { + if (param->fp_get_default_lmv) { struct lmv_user_md *lum = param->fp_lmv_md; lum->lum_magic = LMV_USER_MAGIC; lum->lum_stripe_count = 0; lum->lum_stripe_offset = -1; goto dump; - } else if (param->get_lmv) { + } else if (param->fp_get_lmv) { struct lmv_user_md *lum = param->fp_lmv_md; int mdtidx; @@ -3356,9 +3296,11 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, lum->lum_stripe_offset = mdtidx; goto dump; } else { - struct lov_user_md *lmm = ¶m->lmd->lmd_lmm; + struct lov_user_md *lmm = + ¶m->fp_lmd->lmd_lmm; + lmm->lmm_magic = LOV_USER_MAGIC_V1; - if (!param->raw) + if (!param->fp_raw) ostid_set_seq(&lmm->lmm_oi, FID_SEQ_LOV_DEFAULT); lmm->lmm_stripe_count = 0; @@ -3367,7 +3309,7 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, goto dump; } } else if (errno == ENODATA && parent != NULL) { - if (!param->obduuid && !param->mdtuuid) + if (!param->fp_obd_uuid && !param->fp_mdt_uuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; @@ -3394,7 +3336,7 @@ err_out: } dump: - if (!(param->verbose & VERBOSE_MDTINDEX)) + if (!(param->fp_verbose & VERBOSE_MDTINDEX)) llapi_lov_dump_user_lmm(param, path, d ? 1 : 0); out: @@ -3409,16 +3351,14 @@ out: int llapi_getstripe(char *path, struct find_param *param) { - return param_callback(path, (param->verbose & VERBOSE_MDTINDEX) ? + return param_callback(path, (param->fp_verbose & VERBOSE_MDTINDEX) ? cb_get_mdt_index : cb_getstripe, cb_common_fini, param); } -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 *rawbuf = raw; struct obd_ioctl_data data = { 0 }; @@ -3440,23 +3380,31 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, 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; } @@ -3464,44 +3412,56 @@ 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; - - snprintf(path, MAX_STRING_SIZE, "/proc/fs/lustre/%s/%s/ping", - obd_type, obd_name); + glob_t path; + char buf[1]; + int rc, fd; - 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; - /* The purpose is to send a byte as a ping, whatever this byte is. */ + fd = open(path.gl_pathv[0], O_WRONLY); + if (fd < 0) { + 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); + rc = write(fd, buf, 1); + 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; @@ -3527,9 +3487,11 @@ int llapi_target_iterate(int type_num, char **obd_type, cb(obd_type_name, obd_name, obd_uuid, args); } - } - fclose(fp); - return 0; + } + fclose(fp); +free_path: + cfs_free_param_data(¶m); + return 0; } static void do_target_check(char *obd_type_name, char *obd_name, @@ -3567,436 +3529,32 @@ int llapi_is_lustre_mnt(struct mntent *mnt) strstr(mnt->mnt_fsname, ":/") != NULL); } -int llapi_quotacheck(char *mnt, int check_type) -{ - 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_QUOTACHECK, check_type); - if (rc < 0) - rc = -errno; - - closedir(root); - return rc; -} - -int llapi_poll_quotacheck(char *mnt, struct if_quotacheck *qchk) -{ - DIR *root; - int poll_intvl = 2; - int rc; - - root = opendir(mnt); - if (!root) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); - return rc; - } - - while (1) { - rc = ioctl(dirfd(root), OBD_IOC_POLL_QUOTACHECK, qchk); - if (!rc) - break; - sleep(poll_intvl); - if (poll_intvl < 30) - poll_intvl *= 2; - } - - closedir(root); - return 0; -} - 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; -} - -static int cb_quotachown(char *path, DIR *parent, DIR **dirp, void *data, - struct dirent64 *de) -{ - struct find_param *param = (struct find_param *)data; - DIR *d = dirp == NULL ? NULL : *dirp; - lstat_t *st; - int rc; - - LASSERT(parent != NULL || d != NULL); - - rc = get_lmd_info(path, parent, d, param->lmd, param->lumlen); - if (rc) { - if (rc == -ENODATA) { - if (!param->obduuid && !param->quiet) - llapi_error(LLAPI_MSG_ERROR, -ENODATA, - "%s has no stripe info", path); - rc = 0; - } else if (rc == -ENOENT) { - rc = 0; - } - return rc; - } - - st = ¶m->lmd->lmd_st; - - /* libc chown() will do extra check, and if the real owner is - * the same as the ones to set, it won't fall into kernel, so - * invoke syscall directly. */ - rc = syscall(SYS_chown, path, -1, -1); - if (rc) - llapi_error(LLAPI_MSG_ERROR, errno, - "error: chown %s", path); - - rc = chmod(path, st->st_mode); - if (rc) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "error: chmod %s (%hu)", - path, st->st_mode); - } - - return rc; -} - -int llapi_quotachown(char *path, int flag) -{ - struct find_param param; - - memset(¶m, 0, sizeof(param)); - param.recursive = 1; - param.verbose = 0; - param.quiet = 1; - - return param_callback(path, cb_quotachown, NULL, ¶m); -} - -#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'\n", 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\n", - 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\n"); - return rc; - } - - pid = fork(); - if (pid < 0) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "Can't fork\n"); - 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\n", 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\n", 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\n", pid); - return rc; - } - - return child_status(status); -} - -int llapi_lsetfacl(int argc, char *argv[]) -{ - return do_rmtacl(argc, argv, RMT_LSETFACL, NULL); -} - -int llapi_lgetfacl(int argc, char *argv[]) -{ - return do_rmtacl(argc, argv, RMT_LGETFACL, NULL); -} - -int llapi_rsetfacl(int argc, char *argv[]) -{ - return do_rmtacl(argc, argv, RMT_RSETFACL, NULL); -} - -int llapi_rgetfacl(int argc, char *argv[]) -{ - return do_rmtacl(argc, argv, RMT_RGETFACL, rgetfacl_output); -} - -int llapi_cp(int argc, char *argv[]) -{ - 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) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "'%s' isn't on Lustre filesystem", mnt); + 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, "open %s failed", 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. @@ -4070,9 +3628,6 @@ int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp, 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; } @@ -4095,9 +3650,9 @@ static int changelog_ioctl(const char *mdtname, int opc, int id, #define CHANGELOG_PRIV_MAGIC 0xCA8E1080 struct changelog_private { - int magic; - int flags; - lustre_kernelcomm kuc; + int magic; + enum changelog_send_flag flags; + struct lustre_kernelcomm kuc; }; /** Start reading from a changelog @@ -4107,44 +3662,53 @@ struct changelog_private { * @param startrec Report changes beginning with this record number * (just call llapi_changelog_fini when done; don't need an endrec) */ -int llapi_changelog_start(void **priv, int flags, const char *device, - long long startrec) +int llapi_changelog_start(void **priv, enum changelog_send_flag flags, + const char *device, long long startrec) { - struct changelog_private *cp; - int rc; + struct changelog_private *cp; + static bool warned; + int rc; - /* Set up the receiver control struct */ - cp = calloc(1, sizeof(*cp)); - if (cp == NULL) - return -ENOMEM; + /* Set up the receiver control struct */ + cp = calloc(1, sizeof(*cp)); + if (cp == NULL) + return -ENOMEM; - cp->magic = CHANGELOG_PRIV_MAGIC; - cp->flags = flags; + cp->magic = CHANGELOG_PRIV_MAGIC; + cp->flags = flags; - /* Set up the receiver */ - rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */); - if (rc < 0) - goto out_free; + /* Set up the receiver */ + rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */, 0); + if (rc < 0) + goto out_free; - *priv = cp; + *priv = cp; - /* Tell the kernel to start sending */ - rc = changelog_ioctl(device, OBD_IOC_CHANGELOG_SEND, cp->kuc.lk_wfd, - startrec, flags); - /* Only the kernel reference keeps the write side open */ - close(cp->kuc.lk_wfd); - cp->kuc.lk_wfd = LK_NOFD; - if (rc < 0) { - /* frees and clears priv */ - llapi_changelog_fini(priv); - return rc; - } + /* CHANGELOG_FLAG_JOBID will eventually become mandatory. Display a + * warning if it's missing. */ + if (!(flags & CHANGELOG_FLAG_JOBID) && !warned) { + llapi_err_noerrno(LLAPI_MSG_WARN, "warning: %s() called " + "w/o CHANGELOG_FLAG_JOBID", __func__); + warned = true; + } - return 0; + /* Tell the kernel to start sending */ + rc = changelog_ioctl(device, OBD_IOC_CHANGELOG_SEND, cp->kuc.lk_wfd, + startrec, flags); + /* Only the kernel reference keeps the write side open */ + close(cp->kuc.lk_wfd); + cp->kuc.lk_wfd = LK_NOFD; + if (rc < 0) { + /* frees and clears priv */ + llapi_changelog_fini(priv); + return rc; + } + + return 0; out_free: - free(cp); - return rc; + free(cp); + return rc; } /** Finish reading from a changelog */ @@ -4161,24 +3725,15 @@ int llapi_changelog_fini(void **priv) return 0; } -/** Convert a changelog_rec to changelog_ext_rec, in this way client can treat - * all records in the format of changelog_ext_rec, this can make record - * analysis simpler. +/** + * Convert all records to a same format according to the caller's wishes. + * Default is CLF_VERSION | CLF_RENAME. + * Add CLF_JOBID if explicitely requested. + * + * \param rec The record to remap. It is expected to be big enough to + * properly handle the final format. + * \return 1 if anything changed. 0 otherwise. */ -static inline int changelog_extend_rec(struct changelog_ext_rec *ext) -{ - if (!CHANGELOG_REC_EXTENDED(ext)) { - struct changelog_rec *rec = (struct changelog_rec *)ext; - - memmove(ext->cr_name, rec->cr_name, rec->cr_namelen); - fid_zero(&ext->cr_sfid); - fid_zero(&ext->cr_spfid); - return 1; - } - - return 0; -} - /** Read the next changelog entry * @param priv Opaque private control structure * @param rech Changelog record handle; record will be allocated here @@ -4186,11 +3741,13 @@ static inline int changelog_extend_rec(struct changelog_ext_rec *ext) * <0 error code * 1 EOF */ -int llapi_changelog_recv(void *priv, struct changelog_ext_rec **rech) +#define DEFAULT_RECORD_FMT (CLF_VERSION | CLF_RENAME) +int llapi_changelog_recv(void *priv, struct changelog_rec **rech) { - struct changelog_private *cp = (struct changelog_private *)priv; - struct kuc_hdr *kuch; - int rc = 0; + struct changelog_private *cp = (struct changelog_private *)priv; + struct kuc_hdr *kuch; + enum changelog_rec_flags rec_fmt = DEFAULT_RECORD_FMT; + int rc = 0; if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) return -EINVAL; @@ -4200,6 +3757,9 @@ int llapi_changelog_recv(void *priv, struct changelog_ext_rec **rech) 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, @@ -4227,11 +3787,10 @@ repeat: } } - /* Our message is a changelog_ext_rec. Use pointer math to skip - * kuch_hdr and point directly to the message payload. - */ - *rech = (struct changelog_ext_rec *)(kuch + 1); - changelog_extend_rec(*rech); + /* Our message is a changelog_rec. Use pointer math to skip + * kuch_hdr and point directly to the message payload. */ + *rech = (struct changelog_rec *)(kuch + 1); + changelog_remap_rec(*rech, rec_fmt); return 0; @@ -4242,7 +3801,7 @@ out_free: } /** Release the changelog record when done with it. */ -int llapi_changelog_free(struct changelog_ext_rec **rech) +int llapi_changelog_free(struct changelog_rec **rech) { if (*rech) { /* We allocated memory starting at the kuc_hdr, but passed @@ -4281,48 +3840,50 @@ int llapi_changelog_clear(const char *mdtname, const char *idstr, } int llapi_fid2path(const char *device, const char *fidstr, char *buf, - int buflen, long long *recno, int *linkno) + int buflen, long long *recno, int *linkno) { - struct lu_fid fid; - struct getinfo_fid2path *gf; - int rc; + const char *fidstr_orig = fidstr; + struct lu_fid fid; + struct getinfo_fid2path *gf; + int rc; - while (*fidstr == '[') - fidstr++; + while (*fidstr == '[') + fidstr++; - sscanf(fidstr, SFID, RFID(&fid)); - if (!fid_is_sane(&fid)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "bad FID format [%s], should be "DFID"\n", - fidstr, (__u64)1, 2, 0); - return -EINVAL; - } + 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_orig, + (unsigned long long)FID_SEQ_NORMAL, 2, 0); + return -EINVAL; + } - gf = malloc(sizeof(*gf) + buflen); - if (gf == NULL) - return -ENOMEM; - gf->gf_fid = fid; - gf->gf_recno = *recno; - gf->gf_linkno = *linkno; - gf->gf_pathlen = buflen; + gf = malloc(sizeof(*gf) + buflen); + if (gf == NULL) + return -ENOMEM; - /* 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; - } + gf->gf_fid = fid; + gf->gf_recno = *recno; + gf->gf_linkno = *linkno; + gf->gf_pathlen = buflen; - free(gf); - return rc; + /* Take path or fsname */ + rc = root_ioctl(device, OBD_IOC_FID2PATH, gf, NULL, 0); + if (rc) + goto out_free; + + memcpy(buf, gf->gf_u.gf_path, gf->gf_pathlen); + 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) @@ -4342,6 +3903,20 @@ static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) return 0; } +int llapi_get_mdt_index_by_fid(int fd, const lustre_fid *fid, + int *mdt_index) +{ + int rc; + + rc = ioctl(fd, LL_IOC_FID2MDTIDX, fid); + if (rc < 0) + return -errno; + + *mdt_index = rc; + + return rc; +} + int llapi_fd2fid(const int fd, lustre_fid *fid) { int rc; @@ -4375,54 +3950,70 @@ int llapi_path2fid(const char *path, lustre_fid *fid) return rc; } -int llapi_get_connect_flags(const char *mnt, __u64 *flags) +int llapi_fd2parent(int fd, unsigned int linkno, lustre_fid *parent_fid, + char *name, size_t name_size) { - DIR *root; - int rc; + struct getparent *gp; + int rc; - root = opendir(mnt); - if (!root) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); - return rc; - } + gp = malloc(sizeof(*gp) + name_size); + if (gp == NULL) + return -ENOMEM; - 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; + gp->gp_linkno = linkno; + gp->gp_name_size = name_size; + + rc = ioctl(fd, LL_IOC_GETPARENT, gp); + if (rc < 0) { + rc = -errno; + goto err_free; + } + + *parent_fid = gp->gp_fid; + + strncpy(name, gp->gp_name, name_size); + name[name_size - 1] = '\0'; + +err_free: + free(gp); + return rc; } -int llapi_get_version(char *buffer, int buffer_size, - char **version) +int llapi_path2parent(const char *path, unsigned int linkno, + lustre_fid *parent_fid, char *name, size_t name_size) { - int rc; - int fd; - struct obd_ioctl_data *data = (struct obd_ioctl_data *)buffer; + int fd; + int rc; - fd = open(OBD_DEV_PATH, O_RDONLY); - if (fd == -1) - return -errno; + fd = open(path, O_RDONLY | O_NONBLOCK | O_NOFOLLOW); + if (fd < 0) + return -errno; - 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); + rc = llapi_fd2parent(fd, linkno, parent_fid, name, name_size); + close(fd); + 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; +int llapi_get_connect_flags(const char *mnt, __u64 *flags) +{ + int root; + int 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; + } + + 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; } /** @@ -4482,73 +4073,133 @@ 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 random; + int rnumber; int rc; - fd = open("/dev/urandom", O_RDONLY); - if (fd < 0) { - llapi_error(LLAPI_MSG_ERROR, errno, - "Cannot open /dev/urandom\n"); - return -errno; - } - rc = read(fd, &random, sizeof(random)); - close(fd); - if (rc < sizeof(random)) { - llapi_error(LLAPI_MSG_ERROR, errno, - "cannot read %zu bytes from /dev/urandom", - sizeof(random)); - return -errno; - } - if (idx == -1) - snprintf(filename, sizeof(filename), - LUSTRE_VOLATILE_HDR"::%.4X", random); - else - snprintf(filename, sizeof(filename), - LUSTRE_VOLATILE_HDR":%.4X:%.4X", idx, random); + do { + rnumber = random(); + if (idx == -1) + snprintf(filename, sizeof(filename), + LUSTRE_VOLATILE_HDR"::%.4X", 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; + 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); - fd = open(file_path, O_RDWR | O_CREAT | open_flags, S_IRUSR | S_IWUSR); if (fd < 0) { llapi_error(LLAPI_MSG_ERROR, errno, - "Cannot create volatile file '%s' in '%s'\n", + "Cannot create volatile file '%s' in '%s'", filename + LUSTRE_VOLATILE_HDR_LEN, directory); return -errno; } - /* unlink file in case this wasn't a Lustre filesystem, and the - * magic volatile filename wasn't handled as intended. The effect - * is the same. */ - unlink(file_path); + + /* 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(). */ + errno = saved_errno; return fd; } /** * Swap the layouts between 2 file descriptors - * the 2 files must be open in write + * the 2 files must be open for writing * first fd received the ioctl, second fd is passed as arg * this is assymetric but avoid use of root path for ioctl */ -int llapi_fswap_layouts(int fd1, int fd2, __u64 dv1, __u64 dv2, __u64 flags) +int llapi_fswap_layouts_grouplock(int fd1, int fd2, __u64 dv1, __u64 dv2, + int gid, __u64 flags) { - struct lustre_swap_layouts lsl; - int rc; - - srandom(time(NULL)); + struct lustre_swap_layouts lsl; + struct stat st1; + struct stat st2; + int rc; + + if (flags & (SWAP_LAYOUTS_KEEP_ATIME | SWAP_LAYOUTS_KEEP_MTIME)) { + rc = fstat(fd1, &st1); + if (rc < 0) + return -errno; + + rc = fstat(fd2, &st2); + if (rc < 0) + return -errno; + } lsl.sl_fd = fd2; lsl.sl_flags = flags; - lsl.sl_gid = random(); + lsl.sl_gid = gid; lsl.sl_dv1 = dv1; lsl.sl_dv2 = dv2; rc = ioctl(fd1, LL_IOC_LOV_SWAP_LAYOUTS, &lsl); - if (rc) - rc = -errno; - return rc; + if (rc < 0) + return -errno; + + if (flags & (SWAP_LAYOUTS_KEEP_ATIME | SWAP_LAYOUTS_KEEP_MTIME)) { + struct timeval tv1[2]; + struct timeval tv2[2]; + + memset(tv1, 0, sizeof(tv1)); + memset(tv2, 0, sizeof(tv2)); + + if (flags & SWAP_LAYOUTS_KEEP_ATIME) { + tv1[0].tv_sec = st1.st_atime; + tv2[0].tv_sec = st2.st_atime; + } else { + tv1[0].tv_sec = st2.st_atime; + tv2[0].tv_sec = st1.st_atime; + } + + if (flags & SWAP_LAYOUTS_KEEP_MTIME) { + tv1[1].tv_sec = st1.st_mtime; + tv2[1].tv_sec = st2.st_mtime; + } else { + tv1[1].tv_sec = st2.st_mtime; + tv2[1].tv_sec = st1.st_mtime; + } + + rc = futimes(fd1, tv1); + if (rc < 0) + return -errno; + + rc = futimes(fd2, tv2); + if (rc < 0) + return -errno; + } + + return 0; +} + +int llapi_fswap_layouts(int fd1, int fd2, __u64 dv1, __u64 dv2, __u64 flags) +{ + int rc; + int grp_id; + + do + grp_id = random(); + while (grp_id == 0); + + rc = llapi_fswap_layouts_grouplock(fd1, fd2, dv1, dv2, grp_id, flags); + if (rc < 0) + return rc; + + return 0; } /** @@ -4579,7 +4230,7 @@ int llapi_swap_layouts(const char *path1, const char *path2, rc = llapi_fswap_layouts(fd1, fd2, dv1, dv2, flags); if (rc < 0) llapi_error(LLAPI_MSG_ERROR, rc, - "error: cannot swap layout between '%s' and '%s'\n", + "error: cannot swap layout between '%s' and '%s'", path1, path2); close(fd2); @@ -4588,3 +4239,70 @@ out_close: out: return rc; } + +/** + * Attempt to open a file with Lustre file identifier \a fid + * and return an open file descriptor. + * + * \param[in] lustre_dir path within Lustre filesystem containing \a fid + * \param[in] fid Lustre file identifier of file to open + * \param[in] flags open() flags + * + * \retval non-negative file descriptor on successful open + * \retval -1 if an error occurred + */ +int llapi_open_by_fid(const char *lustre_dir, const lustre_fid *fid, int flags) +{ + char mntdir[PATH_MAX]; + char path[PATH_MAX]; + int rc; + + rc = llapi_search_mounts(lustre_dir, 0, mntdir, NULL); + if (rc != 0) + return -1; + + snprintf(path, sizeof(path), "%s/.lustre/fid/"DFID, mntdir, PFID(fid)); + return open(path, flags); +} + +/** + * Take group lock. + * + * \param fd File to lock. + * \param gid Group Identifier. + * + * \retval 0 on success. + * \retval -errno on failure. + */ +int llapi_group_lock(int fd, int gid) +{ + int rc; + + rc = ioctl(fd, LL_IOC_GROUP_LOCK, gid); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot get group lock"); + } + return rc; +} + +/** + * Put group lock. + * + * \param fd File to unlock. + * \param gid Group Identifier. + * + * \retval 0 on success. + * \retval -errno on failure. + */ +int llapi_group_unlock(int fd, int gid) +{ + int rc; + + rc = ioctl(fd, LL_IOC_GROUP_UNLOCK, gid); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "cannot put group lock"); + } + return rc; +}