X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=1e678b691c763536a07e55cc2625a2765248c1e9;hp=2df30c6438a3aedf919559bf3be2522316ea5e27;hb=e83f6e4fc7c3e2681bee744563d80cd45db95a4d;hpb=26b710a536dc58c9fa0320cdbf5f6b7ce4dc1a68 diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 2df30c6..1e678b6 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -23,7 +23,7 @@ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2016, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -72,13 +72,14 @@ #include #include #include -#include +#include #include -#include -#include +#include +#include #include "lustreapi_internal.h" static int llapi_msg_level = LLAPI_MSG_MAX; +const char *liblustreapi_cmd; char *mdt_hash_name[] = { "none", LMV_HASH_NAME_ALL_CHARS, @@ -100,9 +101,24 @@ int llapi_msg_get_level(void) return llapi_msg_level; } +void llapi_set_command_name(const char *cmd) +{ + liblustreapi_cmd = cmd; +} + +void llapi_clear_command_name(void) +{ + liblustreapi_cmd = NULL; +} + static void error_callback_default(enum llapi_message_level level, int err, const char *fmt, va_list ap) { + if (liblustreapi_cmd != NULL) + fprintf(stderr, "%s %s: ", program_invocation_short_name, + liblustreapi_cmd); + else + fprintf(stderr, "%s: ", program_invocation_short_name); vfprintf(stderr, fmt, ap); if (level & LLAPI_MSG_NO_ERRNO) fprintf(stderr, "\n"); @@ -113,6 +129,15 @@ static void error_callback_default(enum llapi_message_level level, int err, static void info_callback_default(enum llapi_message_level level, int err, const char *fmt, va_list ap) { + if (err != 0) { + if (liblustreapi_cmd != NULL) { + fprintf(stdout, "%s %s: ", + program_invocation_short_name, + liblustreapi_cmd); + } else { + fprintf(stdout, "%s: ", program_invocation_short_name); + } + } vfprintf(stdout, fmt, ap); } @@ -255,7 +280,7 @@ int llapi_parse_size(const char *optarg, unsigned long long *size, return 0; } -int obd_ioctl_pack(struct obd_ioctl_data *data, char **pbuf, int max_len) +int llapi_ioctl_pack(struct obd_ioctl_data *data, char **pbuf, int max_len) { struct obd_ioctl_data *overlay; char *ptr; @@ -281,28 +306,28 @@ int obd_ioctl_pack(struct obd_ioctl_data *data, char **pbuf, int max_len) ptr = overlay->ioc_bulk; if (data->ioc_inlbuf1) { memcpy(ptr, data->ioc_inlbuf1, data->ioc_inllen1); - ptr += cfs_size_round(data->ioc_inllen1); + ptr += __ALIGN_KERNEL(data->ioc_inllen1, 8); } if (data->ioc_inlbuf2) { memcpy(ptr, data->ioc_inlbuf2, data->ioc_inllen2); - ptr += cfs_size_round(data->ioc_inllen2); + ptr += __ALIGN_KERNEL(data->ioc_inllen2, 8); } if (data->ioc_inlbuf3) { memcpy(ptr, data->ioc_inlbuf3, data->ioc_inllen3); - ptr += cfs_size_round(data->ioc_inllen3); + ptr += __ALIGN_KERNEL(data->ioc_inllen3, 8); } if (data->ioc_inlbuf4) { memcpy(ptr, data->ioc_inlbuf4, data->ioc_inllen4); - ptr += cfs_size_round(data->ioc_inllen4); + ptr += __ALIGN_KERNEL(data->ioc_inllen4, 8); } return 0; } -int obd_ioctl_unpack(struct obd_ioctl_data *data, char *pbuf, int max_len) +int llapi_ioctl_unpack(struct obd_ioctl_data *data, char *pbuf, int max_len) { struct obd_ioctl_data *overlay; char *ptr; @@ -323,22 +348,22 @@ int obd_ioctl_unpack(struct obd_ioctl_data *data, char *pbuf, int max_len) ptr = overlay->ioc_bulk; if (data->ioc_inlbuf1) { memcpy(data->ioc_inlbuf1, ptr, data->ioc_inllen1); - ptr += cfs_size_round(data->ioc_inllen1); + ptr += __ALIGN_KERNEL(data->ioc_inllen1, 8); } if (data->ioc_inlbuf2) { memcpy(data->ioc_inlbuf2, ptr, data->ioc_inllen2); - ptr += cfs_size_round(data->ioc_inllen2); + ptr += __ALIGN_KERNEL(data->ioc_inllen2, 8); } if (data->ioc_inlbuf3) { memcpy(data->ioc_inlbuf3, ptr, data->ioc_inllen3); - ptr += cfs_size_round(data->ioc_inllen3); + ptr += __ALIGN_KERNEL(data->ioc_inllen3, 8); } if (data->ioc_inlbuf4) { memcpy(data->ioc_inlbuf4, ptr, data->ioc_inllen4); - ptr += cfs_size_round(data->ioc_inllen4); + ptr += __ALIGN_KERNEL(data->ioc_inllen4, 8); } return 0; @@ -390,6 +415,33 @@ int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, return 0; } +int llapi_dir_stripe_limit_check(int stripe_offset, int stripe_count, + int hash_type) +{ + int rc; + + if (!llapi_dir_stripe_index_is_valid(stripe_offset)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe offset %d", + stripe_offset); + return rc; + } + if (!llapi_dir_stripe_count_is_valid(stripe_count)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe count %d", + stripe_count); + return rc; + } + + if (!llapi_dir_hash_type_is_valid(hash_type)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad hash type %d", + hash_type); + return rc; + } + return 0; +} + /* * Trim a trailing newline from a string, if it exists. */ @@ -469,13 +521,13 @@ int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) } /* - * if pool is NULL, search ostname in target_obd + * if pool is NULL, search tgtname in target_obd * if pool is not NULL: * if pool not found returns errno < 0 - * if ostname is NULL, returns 1 if pool is not empty and 0 if pool empty - * if ostname is not NULL, returns 1 if OST is in pool and 0 if not + * if tgtname is NULL, returns 1 if pool is not empty and 0 if pool empty + * if tgtname is not NULL, returns 1 if OST is in pool and 0 if not */ -int llapi_search_ost(char *fsname, char *poolname, char *ostname) +int llapi_search_tgt(char *fsname, char *poolname, char *tgtname, bool is_mdt) { char buffer[PATH_MAX]; size_t len = 0; @@ -487,8 +539,8 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) if (poolname == NULL && fsname == NULL) return -EINVAL; - if (ostname != NULL) - len = strlen(ostname); + if (tgtname != NULL) + len = strlen(tgtname); if (poolname == NULL && len == 0) return -EINVAL; @@ -501,7 +553,7 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) param.gl_pathv[0], poolname); } } else if (fsname != NULL) { - rc = get_lustre_param_path("lov", fsname, + rc = get_lustre_param_path(is_mdt ? "lmv" : "lov", fsname, FILTER_BY_FS_NAME, "target_obd", ¶m); if (rc == 0) { @@ -515,33 +567,38 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) if (rc) return rc; - fd = fopen(buffer, "r"); - if (fd == NULL) - return -errno; + fd = fopen(buffer, "r"); + if (fd == NULL) + return -errno; - while (fgets(buffer, sizeof(buffer), fd) != NULL) { - if (poolname == NULL) { - char *ptr; - /* Search for an ostname in the list of OSTs - Line format is IDX: fsname-OSTxxxx_UUID STATUS */ - ptr = strchr(buffer, ' '); - if ((ptr != NULL) && - (strncmp(ptr + 1, ostname, len) == 0)) { - fclose(fd); - return 1; - } - } else { - /* Search for an ostname in a pool, - (or an existing non-empty pool if no ostname) */ - if ((ostname == NULL) || - (strncmp(buffer, ostname, len) == 0)) { - fclose(fd); - return 1; - } - } - } - fclose(fd); - return 0; + while (fgets(buffer, sizeof(buffer), fd) != NULL) { + if (poolname == NULL) { + char *ptr; + /* Search for an tgtname in the list of targets + * Line format is IDX: fsname-OST/MDTxxxx_UUID STATUS */ + ptr = strchr(buffer, ' '); + if ((ptr != NULL) && + (strncmp(ptr + 1, tgtname, len) == 0)) { + fclose(fd); + return 1; + } + } else { + /* Search for an tgtname in a pool, + * (or an existing non-empty pool if no tgtname) */ + if ((tgtname == NULL) || + (strncmp(buffer, tgtname, len) == 0)) { + fclose(fd); + return 1; + } + } + } + fclose(fd); + return 0; +} + +int llapi_search_ost(char *fsname, char *poolname, char *ostname) +{ + return llapi_search_tgt(fsname, poolname, ostname, false); } /** @@ -772,28 +829,130 @@ int llapi_file_create_pool(const char *name, unsigned long long stripe_size, return 0; } -int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, - int stripe_count, int stripe_pattern, - const char *pool_name) +static int verify_dir_param(const char *name, + const struct llapi_stripe_param *param) { - struct lmv_user_md lum = { 0 }; - int fd; - int rc = 0; + char fsname[MAX_OBD_NAME + 1] = { 0 }; + char *pool_name = param->lsp_pool; + int rc; + + /* 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; + } - lum.lum_magic = LMV_USER_MAGIC; - lum.lum_stripe_offset = stripe_offset; - lum.lum_stripe_count = stripe_count; - lum.lum_hash_type = stripe_pattern; + /* Check if the stripe pattern is sane. */ + rc = llapi_dir_stripe_limit_check(param->lsp_stripe_offset, + param->lsp_stripe_count, + param->lsp_stripe_pattern); + if (rc != 0) + return rc; + + /* Make sure we have a good pool */ if (pool_name != NULL) { - if (strlen(pool_name) >= sizeof(lum.lum_pool_name)) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error LL_IOC_LMV_SET_DEFAULT_STRIPE '%s'" - ": too large pool name: %s", name, pool_name); - return -E2BIG; + /* 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; } - strncpy(lum.lum_pool_name, pool_name, - sizeof(lum.lum_pool_name)); + + /* Make sure the pool exists and is non-empty */ + rc = llapi_search_tgt(fsname, pool_name, NULL, true); + if (rc < 1) { + char *err = rc == 0 ? "has no OSTs" : "does not exist"; + + llapi_err_noerrno(LLAPI_MSG_ERROR, "pool '%s.%s' %s", + fsname, pool_name, err); + return -EINVAL; + } + } + + /* sanity check of target list */ + if (param->lsp_is_specific) { + char mdtname[MAX_OBD_NAME + 1]; + bool found = false; + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) { + snprintf(mdtname, sizeof(mdtname), "%s-MDT%04x_UUID", + fsname, param->lsp_tgts[i]); + rc = llapi_search_tgt(fsname, pool_name, mdtname, true); + if (rc <= 0) { + if (rc == 0) + rc = -ENODEV; + + llapi_error(LLAPI_MSG_ERROR, rc, + "%s: cannot find MDT %s in %s", + __func__, mdtname, + pool_name != NULL ? + "pool" : "system"); + return rc; + } + + /* Make sure stripe offset is in MDT list. */ + if (param->lsp_tgts[i] == param->lsp_stripe_offset) + found = true; + } + if (!found) { + llapi_error(LLAPI_MSG_ERROR, -EINVAL, + "%s: stripe offset '%d' is not in the " + "target list", + __func__, param->lsp_stripe_offset); + return -EINVAL; + } + } + + return 0; +} + +static inline void param2lmu(struct lmv_user_md *lmu, + const struct llapi_stripe_param *param) +{ + lmu->lum_magic = param->lsp_is_specific ? LMV_USER_MAGIC_SPECIFIC : + LMV_USER_MAGIC; + lmu->lum_stripe_count = param->lsp_stripe_count; + lmu->lum_stripe_offset = param->lsp_stripe_offset; + lmu->lum_hash_type = param->lsp_stripe_pattern; + if (param->lsp_pool != NULL) + strncpy(lmu->lum_pool_name, param->lsp_pool, LOV_MAXPOOLNAME); + if (param->lsp_is_specific) { + int i; + + for (i = 0; i < param->lsp_stripe_count; i++) + lmu->lum_objects[i].lum_mds = param->lsp_tgts[i]; } +} + +int llapi_dir_set_default_lmv(const char *name, + const struct llapi_stripe_param *param) +{ + struct lmv_user_md lmu = { 0 }; + int fd; + int rc = 0; + + rc = verify_dir_param(name, param); + if (rc) + return rc; + + /* TODO: default lmv doesn't support specific targets yet */ + if (param->lsp_is_specific) + return -EINVAL; + + param2lmu(&lmu, param); fd = open(name, O_DIRECTORY | O_RDONLY); if (fd < 0) { @@ -802,7 +961,7 @@ int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, return rc; } - rc = ioctl(fd, LL_IOC_LMV_SET_DEFAULT_STRIPE, &lum); + rc = ioctl(fd, LL_IOC_LMV_SET_DEFAULT_STRIPE, &lmu); if (rc < 0) { char *errmsg = "stripe already set"; rc = -errno; @@ -817,11 +976,35 @@ int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, return rc; } -int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, - int stripe_count, int stripe_pattern, - const char *pool_name) +int llapi_dir_set_default_lmv_stripe(const char *name, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) { - struct lmv_user_md lmu = { 0 }; + const struct llapi_stripe_param param = { + .lsp_stripe_count = stripe_count, + .lsp_stripe_offset = stripe_offset, + .lsp_stripe_pattern = stripe_pattern, + .lsp_pool = (char *)pool_name + }; + + return llapi_dir_set_default_lmv(name, ¶m); +} + +/** + * Create a Lustre directory. + * + * \param name the name of the directory to be created + * \param mode permission of the file if it is created, see mode in open(2) + * \param param stripe pattern of the newly created directory + * + * \retval 0 on success + * \retval negative errno on failure + */ +int llapi_dir_create(const char *name, mode_t mode, + const struct llapi_stripe_param *param) +{ + struct lmv_user_md *lmu = NULL; + size_t lmu_size = sizeof(*lmu); struct obd_ioctl_data data = { 0 }; char rawbuf[8192]; char *buf = rawbuf; @@ -829,38 +1012,44 @@ int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, char *namepath = NULL; char *dir; char *filename; - int fd = -1; - int rc; + int fd, rc; + + rc = verify_dir_param(name, param); + if (rc) + return rc; + + if (param->lsp_is_specific) + lmu_size = lmv_user_md_size(param->lsp_stripe_count, + LMV_USER_MAGIC_SPECIFIC); + + lmu = calloc(1, lmu_size); + if (lmu == NULL) + return -ENOMEM; dirpath = strdup(name); - namepath = strdup(name); - if (!dirpath || !namepath) + if (!dirpath) { + free(lmu); return -ENOMEM; + } - lmu.lum_magic = LMV_USER_MAGIC; - lmu.lum_stripe_offset = stripe_offset; - lmu.lum_stripe_count = stripe_count; - lmu.lum_hash_type = stripe_pattern; - if (pool_name != NULL) { - if (strlen(pool_name) > LOV_MAXPOOLNAME) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error LL_IOC_LMV_SETSTRIPE '%s' : too large" - "pool name: %s", name, pool_name); - rc = -E2BIG; - goto out; - } - memcpy(lmu.lum_pool_name, pool_name, strlen(pool_name)); + namepath = strdup(name); + if (!namepath) { + free(namepath); + free(lmu); + return -ENOMEM; } + param2lmu(lmu, param); + filename = basename(namepath); dir = dirname(dirpath); data.ioc_inlbuf1 = (char *)filename; data.ioc_inllen1 = strlen(filename) + 1; - data.ioc_inlbuf2 = (char *)&lmu; - data.ioc_inllen2 = sizeof(struct lmv_user_md); + data.ioc_inlbuf2 = (char *)lmu; + data.ioc_inllen2 = lmu_size; data.ioc_type = mode; - rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); + rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { llapi_error(LLAPI_MSG_ERROR, rc, "error: LL_IOC_LMV_SETSTRIPE pack failed '%s'.", @@ -887,11 +1076,27 @@ int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, } close(fd); out: - free(dirpath); free(namepath); + free(dirpath); + free(lmu); return rc; } + +int llapi_dir_create_pool(const char *name, int mode, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) +{ + const struct llapi_stripe_param param = { + .lsp_stripe_count = stripe_count, + .lsp_stripe_offset = stripe_offset, + .lsp_stripe_pattern = stripe_pattern, + .lsp_pool = (char *)pool_name + }; + + return llapi_dir_create(name, mode, ¶m); +} + int llapi_direntry_remove(char *dname) { char *dirpath = NULL; @@ -951,7 +1156,7 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) if (fp == NULL) { rc = -EIO; llapi_error(LLAPI_MSG_ERROR, rc, - "setmntent(%s) failed", PROC_MOUNTS); + "cannot retrieve filesystem mount point"); return rc; } while (1) { @@ -1019,7 +1224,8 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) if (fd < 0) { rc = -errno; llapi_error(LLAPI_MSG_ERROR, rc, - "error opening '%s'", mntdir); + "cannot open '%s': %s", mntdir, + strerror(-rc)); } else { *outfd = fd; @@ -1027,8 +1233,8 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) } } 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); + "'%s' not on a mounted Lustre filesystem", + (want & WANT_PATH) ? fsname : path); return rc; } @@ -1068,42 +1274,67 @@ int llapi_search_fsname(const char *pathname, char *fsname) path = realpath(pathname, NULL); if (path == NULL) { - char buf[PATH_MAX], *ptr; + char tmp[PATH_MAX - 1]; + char buf[PATH_MAX]; + char *ptr; + tmp[0] = '\0'; buf[0] = '\0'; if (pathname[0] != '/') { /* Need an absolute path, but realpath() only works for * pathnames that actually exist. We go through the * extra hurdle of dirname(getcwd() + pathname) in * case the relative pathname contains ".." in it. */ - if (getcwd(buf, sizeof(buf) - 2) == NULL) - return -errno; - rc = strlcat(buf, "/", sizeof(buf)); - if (rc >= sizeof(buf)) - return -E2BIG; + char realpath[PATH_MAX - 1]; + + if (getcwd(realpath, sizeof(realpath) - 2) == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot get current working directory"); + return rc; + } + + rc = snprintf(tmp, sizeof(tmp), "%s/", realpath); + if (rc >= sizeof(tmp)) { + rc = -E2BIG; + llapi_error(LLAPI_MSG_ERROR, rc, + "invalid parent path '%s'", + tmp); + return rc; + } } - rc = strlcat(buf, pathname, sizeof(buf)); - if (rc >= sizeof(buf)) - return -E2BIG; - path = realpath(buf, NULL); - if (path == NULL) { - ptr = strrchr(buf, '/'); - if (ptr == NULL) - return -ENOENT; - *ptr = '\0'; - path = realpath(buf, NULL); - if (path == NULL) { - rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, - "pathname '%s' cannot expand", - pathname); - return rc; - } - } - } - rc = get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, path, -1); - free(path); - return rc; + + rc = snprintf(buf, sizeof(buf), "%s%s", tmp, pathname); + if (rc >= sizeof(buf)) { + rc = -E2BIG; + llapi_error(LLAPI_MSG_ERROR, rc, + "invalid path '%s'", pathname); + return rc; + } + path = realpath(buf, NULL); + if (path == NULL) { + ptr = strrchr(buf, '/'); + if (ptr == NULL) { + llapi_error(LLAPI_MSG_ERROR | + LLAPI_MSG_NO_ERRNO, 0, + "cannot resolve path '%s'", + buf); + return -ENOENT; + } + *ptr = '\0'; + path = realpath(buf, NULL); + if (path == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot resolve path '%s'", + pathname); + return rc; + } + } + } + rc = get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, path, -1); + free(path); + return rc; } int llapi_search_rootpath(char *pathname, const char *fsname) @@ -1161,7 +1392,8 @@ int llapi_get_poolmembers(const char *poolname, char **members, /* name is FSNAME.POOLNAME */ if (strlen(poolname) >= sizeof(fsname)) return -EOVERFLOW; - strlcpy(fsname, poolname, sizeof(fsname)); + + snprintf(fsname, sizeof(fsname), "%s", poolname); pool = strchr(fsname, '.'); if (pool == NULL) return -EINVAL; @@ -1537,7 +1769,7 @@ static int get_lmd_info(char *path, DIR *parent, DIR *dir, * a large filesystem. */ fname = (fname == NULL ? path : fname + 1); /* retrieve needed file info */ - strlcpy((char *)lmd, fname, lumlen); + snprintf((char *)lmd, lumlen, "%s", fname); ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); } @@ -1610,24 +1842,20 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, while ((dent = readdir64(d)) != NULL) { int rc; - if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) - continue; - - /* Don't traverse .lustre directory */ - if (!(strcmp(dent->d_name, dot_lustre_name))) - continue; + if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) + continue; - path[len] = 0; - if ((len + dent->d_reclen + 2) > size) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "error: %s: string buffer is too small", - __func__); - break; - } - strcat(path, "/"); - strcat(path, dent->d_name); + path[len] = 0; + if ((len + dent->d_reclen + 2) > size) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: string buffer too small", + __func__); + break; + } + strcat(path, "/"); + strcat(path, dent->d_name); - if (dent->d_type == DT_UNKNOWN) { + if (dent->d_type == DT_UNKNOWN) { lstat_t *st = ¶m->fp_lmd->lmd_st; rc = get_lmd_info(path, d, NULL, param->fp_lmd, @@ -1694,7 +1922,7 @@ static int param_callback(char *path, semantic_func_t sem_init, if (!buf) return -ENOMEM; - strlcpy(buf, path, PATH_MAX + 1); + snprintf(buf, PATH_MAX + 1, "%s", path); ret = common_param_init(param, buf); if (ret) goto out; @@ -2161,7 +2389,7 @@ int sattr_cache_get_defaults(const char *const fsname, if (rc) return rc; } else { - strlcpy(fsname_buf, fsname, sizeof(fsname_buf)); + snprintf(fsname_buf, sizeof(fsname_buf), "%s", fsname); } if (strncmp(fsname_buf, cache.fsname, sizeof(fsname_buf) - 1) != 0) { @@ -2177,7 +2405,7 @@ int sattr_cache_get_defaults(const char *const fsname, cache.stripecount = tmp[0]; cache.stripesize = tmp[1]; cache.stripeoffset = tmp[2]; - strlcpy(cache.fsname, fsname_buf, sizeof(cache.fsname)); + snprintf(cache.fsname, sizeof(cache.fsname), "%s", fsname_buf); } if (scount) @@ -2190,6 +2418,18 @@ int sattr_cache_get_defaults(const char *const fsname, return 0; } +static char *layout2name(__u32 layout_pattern) +{ + if (layout_pattern == LOV_PATTERN_MDT) + return "mdt"; + else if (layout_pattern == LOV_PATTERN_RAID0) + return "raid0"; + else if (layout_pattern == (LOV_PATTERN_RAID0 | LOV_PATTERN_F_RELEASED)) + return "released"; + else + return "unknown"; +} + enum lov_dump_flags { LDF_IS_DIR = 0x0001, LDF_IS_RAW = 0x0002, @@ -2276,7 +2516,8 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, llapi_printf(LLAPI_MSG_NORMAL, "%s%sstripe_count: ", space, prefix); if (is_dir) { - if (!is_raw && lum->lmm_stripe_count == 0) { + if (!is_raw && lum->lmm_stripe_count == 0 && + lov_pattern(lum->lmm_pattern) != LOV_PATTERN_MDT) { unsigned int scount; rc = sattr_cache_get_defaults(NULL, path, &scount, NULL, @@ -2329,13 +2570,17 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, separator = "\n"; } - if ((verbose & VERBOSE_LAYOUT) && !is_dir) { + if ((verbose & VERBOSE_LAYOUT)) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_LAYOUT) llapi_printf(LLAPI_MSG_NORMAL, "%s%spattern: ", space, prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%.x", lum->lmm_pattern); - separator = "\n"; + if (lov_pattern_supported(lum->lmm_pattern)) + llapi_printf(LLAPI_MSG_NORMAL, "%s", + layout2name(lum->lmm_pattern)); + else + llapi_printf(LLAPI_MSG_NORMAL, "%x", lum->lmm_pattern); + separator = (!yaml && is_dir) ? " " : "\n"; } if ((verbose & VERBOSE_GENERATION) && !is_dir) { @@ -2344,7 +2589,7 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, llapi_printf(LLAPI_MSG_NORMAL, "%s%slayout_gen: ", space, prefix); llapi_printf(LLAPI_MSG_NORMAL, "%u", - (int)lum->lmm_layout_gen); + skip_objs ? 0 : (int)lum->lmm_layout_gen); separator = "\n"; } @@ -2392,18 +2637,19 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, bool indent = flags & LDF_INDENT; bool skip_objs = flags & LDF_SKIP_OBJS; bool yaml = flags & LDF_YAML; - int i, obdstripe = (obdindex != OBD_NOT_FOUND) ? 0 : 1; + bool obdstripe = obdindex == OBD_NOT_FOUND; + int i; - if (!obdstripe) { + if (!obdstripe && !skip_objs) { for (i = 0; !is_dir && i < lum->lmm_stripe_count; i++) { if (obdindex == objects[i].l_ost_idx) { - obdstripe = 1; + obdstripe = true; break; } } } - if (obdstripe == 0) + if (!obdstripe) return; lov_dump_user_lmm_header(lum, path, objects, header, depth, pool_name, @@ -2458,8 +2704,8 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, obdindex == idx ? " *" : ""); } } - llapi_printf(LLAPI_MSG_NORMAL, "\n"); } + llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, @@ -2468,27 +2714,28 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, { struct lmv_user_mds_data *objects = lum->lum_objects; char *prefix = lum->lum_magic == LMV_USER_MAGIC ? "(Default)" : ""; - int i, obdstripe = 0; char *separator = ""; bool yaml = flags & LDF_YAML; + bool obdstripe = false; + int i; if (obdindex != OBD_NOT_FOUND) { if (lum->lum_stripe_count == 0) { if (obdindex == lum->lum_stripe_offset) - obdstripe = 1; + obdstripe = true; } else { for (i = 0; i < lum->lum_stripe_count; i++) { if (obdindex == objects[i].lum_mds) { llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, path); - obdstripe = 1; + obdstripe = true; break; } } } } else { - obdstripe = 1; + obdstripe = true; } if (!obdstripe) @@ -2547,7 +2794,7 @@ void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, if (verbose & VERBOSE_OBJID && lum->lum_magic != LMV_USER_MAGIC) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); - if (obdstripe == 1 && lum->lum_stripe_count > 0) + if (lum->lum_stripe_count > 0) llapi_printf(LLAPI_MSG_NORMAL, "mdtidx\t\t FID[seq:oid:ver]\n"); for (i = 0; i < lum->lum_stripe_count; i++) { @@ -2590,24 +2837,40 @@ static void lov_dump_comp_v1_header(struct find_param *param, char *path, if (verbose & VERBOSE_DETAIL) { llapi_printf(LLAPI_MSG_NORMAL, "composite_header:\n"); - llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_magic: 0x%08X\n", + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_magic: 0x%08X\n", " ", comp_v1->lcm_magic); - llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_size: %u\n", + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_size: %u\n", " ", comp_v1->lcm_size); - llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_flags: %u\n", - " ", comp_v1->lcm_flags); + if (flags & LDF_IS_DIR) + llapi_printf(LLAPI_MSG_NORMAL, + "%2slcm_flags: %s\n", " ", + comp_v1->lcm_mirror_count > 0 ? + "mirrored" : ""); + else + llapi_printf(LLAPI_MSG_NORMAL, + "%2slcm_flags: %s\n", " ", + llapi_layout_flags_string(comp_v1->lcm_flags)); } if (verbose & VERBOSE_GENERATION) { if (verbose & ~VERBOSE_GENERATION) - llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_layout_gen: ", + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_layout_gen: ", " "); llapi_printf(LLAPI_MSG_NORMAL, "%u\n", comp_v1->lcm_layout_gen); } + if (verbose & VERBOSE_MIRROR_COUNT) { + if (verbose & ~VERBOSE_MIRROR_COUNT) + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_mirror_count: ", + " "); + llapi_printf(LLAPI_MSG_NORMAL, "%u\n", + comp_v1->lcm_magic == LOV_USER_MAGIC_COMP_V1 ? + comp_v1->lcm_mirror_count + 1 : 1); + } + if (verbose & VERBOSE_COMP_COUNT) { if (verbose & ~VERBOSE_COMP_COUNT) - llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_entry_count: ", + llapi_printf(LLAPI_MSG_NORMAL, "%2slcm_entry_count: ", " "); llapi_printf(LLAPI_MSG_NORMAL, "%u\n", comp_v1->lcm_magic == LOV_USER_MAGIC_COMP_V1 ? @@ -2618,7 +2881,7 @@ static void lov_dump_comp_v1_header(struct find_param *param, char *path, llapi_printf(LLAPI_MSG_NORMAL, "components:\n"); } -static void comp_flags2str(__u32 comp_flags) +static void lcme_flags2str(__u32 comp_flags) { bool found = false; int i = 0; @@ -2672,12 +2935,25 @@ static void lov_dump_comp_v1_entry(struct find_param *param, separator = "\n"; } + if (verbose & VERBOSE_MIRROR_ID) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); + if (verbose & ~VERBOSE_MIRROR_ID) + llapi_printf(LLAPI_MSG_NORMAL, + "%4slcme_mirror_id: ", " "); + if (entry->lcme_id != LCME_ID_INVAL) + llapi_printf(LLAPI_MSG_NORMAL, "%u", + mirror_id_of(entry->lcme_id)); + else + llapi_printf(LLAPI_MSG_NORMAL, "N/A"); + separator = "\n"; + } + if (verbose & VERBOSE_COMP_FLAGS) { llapi_printf(LLAPI_MSG_NORMAL, "%s", separator); if (verbose & ~VERBOSE_COMP_FLAGS) llapi_printf(LLAPI_MSG_NORMAL, "%4slcme_flags: ", " "); - comp_flags2str(entry->lcme_flags); + lcme_flags2str(entry->lcme_flags); separator = "\n"; } @@ -2783,8 +3059,8 @@ static inline void lov_v1v3_pool_name(struct lov_user_md *v1, char *pool_name) { if (v1->lmm_magic == LOV_USER_MAGIC_V3) - strlcpy(pool_name, ((struct lov_user_md_v3 *)v1)->lmm_pool_name, - LOV_MAXPOOLNAME); + snprintf(pool_name, LOV_MAXPOOLNAME, "%s", + ((struct lov_user_md_v3 *)v1)->lmm_pool_name); else pool_name[0] = '\0'; } @@ -2852,7 +3128,7 @@ static int find_comp_end_cmp(unsigned long long end, struct find_param *param) * lmm_fid: [0x200000401:0x1:0x0] * lmm_stripe_count: 1 * lmm_stripe_size: 1048576 - * lmm_pattern: 1 + * lmm_pattern: raid0 * lmm_layout_gen: 0 * lmm_stripe_offset: 0 * lmm_objects: @@ -2871,7 +3147,7 @@ static int find_comp_end_cmp(unsigned long long end, struct find_param *param) * lmm_fid: [0x200000401:0x1:0x0] * lmm_stripe_count: 2 * lmm_stripe_size: 1048576 - * lmm_pattern: 1 + * lmm_pattern: raid0 * lmm_layout_gen: 0 * lmm_stripe_offset: 1 * lmm_objects: @@ -2887,10 +3163,11 @@ static void lov_dump_comp_v1(struct find_param *param, char *path, struct lov_user_md_v1 *v1; char pool_name[LOV_MAXPOOLNAME + 1]; int obdindex = param->fp_obd_index; - int i, j, match, obdstripe = 0; + int i, j, match; + bool obdstripe = false; if (obdindex != OBD_NOT_FOUND) { - for (i = 0; !(flags & LDF_IS_DIR) && + for (i = 0; !(flags & LDF_IS_DIR) && !obdstripe && i < comp_v1->lcm_entry_count; i++) { if (!(comp_v1->lcm_entries[i].lcme_flags & LCME_FL_INIT)) @@ -2901,16 +3178,16 @@ static void lov_dump_comp_v1(struct find_param *param, char *path, for (j = 0; j < v1->lmm_stripe_count; j++) { if (obdindex == objects[j].l_ost_idx) { - obdstripe = 1; + obdstripe = true; break; } } } } else { - obdstripe = 1; + obdstripe = true; } - if (obdstripe == 0) + if (!obdstripe) return; lov_dump_comp_v1_header(param, path, flags); @@ -2921,10 +3198,9 @@ static void lov_dump_comp_v1(struct find_param *param, char *path, entry = &comp_v1->lcm_entries[i]; if (param->fp_check_comp_flags) { - if ((param->fp_exclude_comp_flags && - (param->fp_comp_flags & entry->lcme_flags)) || - (!param->fp_exclude_comp_flags && - !(param->fp_comp_flags & entry->lcme_flags))) + if (((param->fp_comp_flags & entry->lcme_flags) != + param->fp_comp_flags) || + (param->fp_comp_neg_flags & entry->lcme_flags)) continue; } @@ -2960,11 +3236,27 @@ static void lov_dump_comp_v1(struct find_param *param, char *path, break; } - if (entry->lcme_flags & LCME_FL_INIT) - flags &= ~LDF_SKIP_OBJS; - else + if (entry->lcme_flags & LCME_FL_INIT) { + if (obdindex != OBD_NOT_FOUND) { + flags |= LDF_SKIP_OBJS; + v1 = lov_comp_entry(comp_v1, i); + objects = lov_v1v3_objects(v1); + + for (j = 0; j < v1->lmm_stripe_count; j++) { + if (obdindex == objects[j].l_ost_idx) { + flags &= ~LDF_SKIP_OBJS; + break; + } + } + } else { + flags &= ~LDF_SKIP_OBJS; + } + } else { flags |= LDF_SKIP_OBJS; + } + if (obdindex != OBD_NOT_FOUND && (flags & LDF_SKIP_OBJS)) + continue; lov_dump_comp_v1_entry(param, flags, i); v1 = lov_comp_entry(comp_v1, i); @@ -3087,7 +3379,8 @@ static void lov_dump_plain_user_lmm(struct find_param *param, char *path, struct lov_user_ost_data_v1 *objects; struct lov_user_md_v3 *lmmv3 = (void *)¶m->fp_lmd->lmd_lmm; - strlcpy(pool_name, lmmv3->lmm_pool_name, sizeof(pool_name)); + snprintf(pool_name, sizeof(pool_name), "%s", + lmmv3->lmm_pool_name); objects = lmmv3->lmm_objects; lov_dump_user_lmm_v1v3(¶m->fp_lmd->lmd_lmm, pool_name, objects, path, param->fp_obd_index, @@ -3122,7 +3415,8 @@ static void llapi_lov_dump_user_lmm(struct find_param *param, char *path, struct lmv_user_md *lum; lum = (struct lmv_user_md *)param->fp_lmv_md; - strlcpy(pool_name, lum->lum_pool_name, sizeof(pool_name)); + snprintf(pool_name, sizeof(pool_name), "%s", + lum->lum_pool_name); lmv_dump_user_lmm(lum, pool_name, path, param->fp_obd_index, param->fp_max_depth, param->fp_verbose, flags); @@ -3198,7 +3492,7 @@ int llapi_file_lookup(int dirfd, const char *name) data.ioc_inlbuf1 = (char *)name; data.ioc_inllen1 = strlen(name) + 1; - rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); + rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { llapi_error(LLAPI_MSG_ERROR, rc, "error: IOC_MDC_LOOKUP pack failed for '%s': rc %d", @@ -3296,6 +3590,9 @@ static int check_obd_match(struct find_param *param) objects = lov_v1v3_objects(v1); for (j = 0; j < v1->lmm_stripe_count; j++) { + if (comp_v1 && !(comp_v1->lcm_entries[i].lcme_flags & + LCME_FL_INIT)) + continue; for (k = 0; k < param->fp_num_obds; k++) { if (param->fp_obd_indexes[k] == objects[j].l_ost_idx) @@ -3523,16 +3820,13 @@ static int find_check_comp_options(struct find_param *param) entry = &comp_v1->lcm_entries[i]; if (param->fp_check_comp_flags) { - if (((entry->lcme_flags & param->fp_comp_flags) && - param->fp_exclude_comp_flags) || - (!(entry->lcme_flags & param->fp_comp_flags) && - !param->fp_exclude_comp_flags)) + ret = 1; + if (((param->fp_comp_flags & entry->lcme_flags) != + param->fp_comp_flags) || + (param->fp_comp_neg_flags & entry->lcme_flags)) { ret = -1; - else - ret = 1; - - if (ret == -1) continue; + } } if (param->fp_check_comp_start) { @@ -3561,12 +3855,47 @@ out: return ret; } +static int find_check_mirror_options(struct find_param *param) +{ + struct lov_comp_md_v1 *comp_v1; + struct lov_user_md_v1 *v1 = ¶m->fp_lmd->lmd_lmm; + int ret = 0; + + if (v1->lmm_magic != LOV_USER_MAGIC_COMP_V1) + return -1; + + comp_v1 = (struct lov_comp_md_v1 *)v1; + + if (param->fp_check_mirror_count) { + ret = find_value_cmp(comp_v1->lcm_mirror_count + 1, + param->fp_mirror_count, + param->fp_mirror_count_sign, + param->fp_exclude_mirror_count, 1, 0); + if (ret == -1) + return ret; + } + + if (param->fp_check_mirror_state) { + ret = 1; + __u16 file_state = comp_v1->lcm_flags & LCM_FL_FLR_MASK; + + if ((param->fp_mirror_state != 0 && + file_state != param->fp_mirror_state) || + file_state == param->fp_mirror_neg_state) + return -1; + } + + return ret; +} + static bool find_check_lmm_info(struct find_param *param) { return param->fp_check_pool || param->fp_check_stripe_count || param->fp_check_stripe_size || param->fp_check_layout || param->fp_check_comp_count || param->fp_check_comp_end || param->fp_check_comp_start || param->fp_check_comp_flags || + param->fp_check_mirror_count || + param->fp_check_mirror_state || param->fp_check_projid; } @@ -3659,7 +3988,7 @@ static int cb_find_init(char *path, DIR *parent, DIR **dirp, /* We need to "fake" the "use the default" values * since the lmm struct is zeroed out at this point. */ lmm->lmm_magic = LOV_USER_MAGIC_V1; - lmm->lmm_pattern = 0xFFFFFFFF; + lmm->lmm_pattern = LOV_PATTERN_DEFAULT; if (!param->fp_raw) ostid_set_seq(&lmm->lmm_oi, FID_SEQ_LOV_DEFAULT); @@ -3864,6 +4193,12 @@ obd_matches: goto decided; } + if (param->fp_check_mirror_count || param->fp_check_mirror_state) { + decision = find_check_mirror_options(param); + if (decision == -1) + goto decided; + } + /* Check the time on mds. */ decision = 1; if (param->fp_atime || param->fp_mtime || param->fp_ctime) { @@ -3957,7 +4292,7 @@ static int cb_migrate_mdt_init(char *path, DIR *parent, DIR **dirp, { struct find_param *param = (struct find_param *)param_data; DIR *tmp_parent = parent; - char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; + char raw[MAX_IOC_BUFLEN] = {'\0'}; char *rawbuf = raw; struct obd_ioctl_data data = { 0 }; int fd; @@ -3991,7 +4326,7 @@ static int cb_migrate_mdt_init(char *path, DIR *parent, DIR **dirp, data.ioc_inllen1 = strlen(filename) + 1; data.ioc_inlbuf2 = (char *)¶m->fp_mdt_index; data.ioc_inllen2 = sizeof(param->fp_mdt_index); - ret = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + ret = llapi_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (ret != 0) { llapi_error(LLAPI_MSG_ERROR, ret, "llapi_obd_statfs: error packing ioctl data"); @@ -4172,8 +4507,8 @@ static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, char *fname = strrchr(path, '/'); fname = (fname == NULL ? path : fname + 1); - strlcpy((char *)¶m->fp_lmd->lmd_lmm, fname, - param->fp_lum_size); + snprintf((char *)¶m->fp_lmd->lmd_lmm, param->fp_lum_size, + "%s", fname); ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, (void *)¶m->fp_lmd->lmd_lmm); @@ -4271,7 +4606,7 @@ int llapi_getstripe(char *path, struct find_param *param) int llapi_obd_fstatfs(int fd, __u32 type, __u32 index, struct obd_statfs *stat_buf, struct obd_uuid *uuid_buf) { - char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; + char raw[MAX_IOC_BUFLEN] = {'\0'}; char *rawbuf = raw; struct obd_ioctl_data data = { 0 }; int rc = 0; @@ -4285,7 +4620,7 @@ int llapi_obd_fstatfs(int fd, __u32 type, __u32 index, data.ioc_pbuf2 = (char *)uuid_buf; data.ioc_plen2 = sizeof(struct obd_uuid); - rc = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + rc = llapi_ioctl_pack(&data, &rawbuf, sizeof(raw)); if (rc != 0) { llapi_error(LLAPI_MSG_ERROR, rc, "llapi_obd_statfs: error packing ioctl data"); @@ -4448,16 +4783,13 @@ int llapi_quotactl(char *mnt, struct if_quotactl *qctl) int rc; rc = llapi_search_fsname(mnt, fsname); - if (rc) { - llapi_err_noerrno(LLAPI_MSG_ERROR, - "'%s' isn't on Lustre filesystem", mnt); + if (rc) return rc; - } root = open(mnt, O_RDONLY | O_DIRECTORY); if (root < 0) { rc = -errno; - llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", mnt); return rc; } @@ -4490,7 +4822,7 @@ static int get_mdtname(char *name, char *format, char *buf) } else { /* Not enough room to add suffix */ llapi_err_noerrno(LLAPI_MSG_ERROR, - "MDT name too long |%s|", name); + "Invalid MDT name |%s|", name); return -EINVAL; } } @@ -4550,6 +4882,8 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, const char *fidstr_orig = fidstr; struct lu_fid fid; struct getinfo_fid2path *gf; + char *a; + char *b; int rc; while (*fidstr == '[') @@ -4578,11 +4912,21 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, if (rc) goto out_free; - memcpy(buf, gf->gf_u.gf_path, gf->gf_pathlen); + b = buf; + /* strip out instances of // */ + for (a = gf->gf_u.gf_path; *a != '\0'; a++) { + if ((*a == '/') && (*(a + 1) == '/')) + continue; + *b = *a; + b++; + } + *b = '\0'; + if (buf[0] == '\0') { /* ROOT path */ buf[0] = '/'; buf[1] = '\0'; } + *recno = gf->gf_recno; *linkno = gf->gf_linkno; @@ -4591,7 +4935,7 @@ out_free: return rc; } -static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) +static int fid_from_lma(const char *path, int fd, struct lu_fid *fid) { char buf[512]; struct lustre_mdt_attrs *lma; @@ -4608,7 +4952,7 @@ static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) return 0; } -int llapi_get_mdt_index_by_fid(int fd, const lustre_fid *fid, +int llapi_get_mdt_index_by_fid(int fd, const struct lu_fid *fid, int *mdt_index) { int rc; @@ -4622,7 +4966,7 @@ int llapi_get_mdt_index_by_fid(int fd, const lustre_fid *fid, return rc; } -int llapi_fd2fid(const int fd, lustre_fid *fid) +int llapi_fd2fid(int fd, struct lu_fid *fid) { int rc; @@ -4635,7 +4979,7 @@ int llapi_fd2fid(const int fd, lustre_fid *fid) return rc; } -int llapi_path2fid(const char *path, lustre_fid *fid) +int llapi_path2fid(const char *path, struct lu_fid *fid) { int fd, rc; @@ -4655,7 +4999,7 @@ int llapi_path2fid(const char *path, lustre_fid *fid) return rc; } -int llapi_fd2parent(int fd, unsigned int linkno, lustre_fid *parent_fid, +int llapi_fd2parent(int fd, unsigned int linkno, struct lu_fid *parent_fid, char *name, size_t name_size) { struct getparent *gp; @@ -4685,7 +5029,7 @@ err_free: } int llapi_path2parent(const char *path, unsigned int linkno, - lustre_fid *parent_fid, char *name, size_t name_size) + struct lu_fid *parent_fid, char *name, size_t name_size) { int fd; int rc; @@ -4740,18 +5084,53 @@ int llapi_get_connect_flags(const char *mnt, __u64 *flags) */ int llapi_get_data_version(int fd, __u64 *data_version, __u64 flags) { - int rc; - struct ioc_data_version idv; + int rc; + struct ioc_data_version idv; - idv.idv_flags = flags; + idv.idv_flags = (__u32)flags; - rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); - if (rc) - rc = -errno; - else - *data_version = idv.idv_version; + rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); + if (rc) + rc = -errno; + else + *data_version = idv.idv_version; - return rc; + return rc; +} + +/** + * Flush cached pages from all clients. + * + * \param fd File descriptor + * \retval 0 success + * \retval < 0 error + */ +int llapi_file_flush(int fd) +{ + __u64 dv; + + return llapi_get_data_version(fd, &dv, LL_DV_WR_FLUSH); +} + +/* + * Fetch layout version from OST objects. Layout version on OST objects are + * only set when the file is a mirrored file AND after the file has been + * written at least once. + * + * It actually fetches the least layout version from the objects. + */ +int llapi_get_ost_layout_version(int fd, __u32 *layout_version) +{ + int rc; + struct ioc_data_version idv = { 0 }; + + rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); + if (rc) + rc = -errno; + else + *layout_version = idv.idv_layout_version; + + return rc; } /* @@ -4956,7 +5335,8 @@ out: * \retval non-negative file descriptor on successful open * \retval -1 if an error occurred */ -int llapi_open_by_fid(const char *lustre_dir, const lustre_fid *fid, int flags) +int llapi_open_by_fid(const char *lustre_dir, const struct lu_fid *fid, + int flags) { char mntdir[PATH_MAX]; char path[PATH_MAX];