X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=d3c99c65808b6591acb136ef30db00251c8eb33d;hp=96d31e652b203746d9e6799862db9d6a2688e897;hb=281671b5ee43c2aea5d5b708aadf10fd1df45b16;hpb=00d783456c551aa990e911c075f8cc0db0c45f96 diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index 96d31e6..d3c99c6 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -61,6 +61,7 @@ #include #include #include +#include /* for dirname() */ #ifdef HAVE_LINUX_UNISTD_H #include #else @@ -68,54 +69,12 @@ #endif #include -#include +#include #include -#include -#include -#include -#include - -static unsigned llapi_dir_filetype_table[] = { - [DT_UNKNOWN]= 0, - [DT_FIFO]= S_IFIFO, - [DT_CHR] = S_IFCHR, - [DT_DIR] = S_IFDIR, - [DT_BLK] = S_IFBLK, - [DT_REG] = S_IFREG, - [DT_LNK] = S_IFLNK, - [DT_SOCK]= S_IFSOCK, -#if defined(DT_DOOR) && defined(S_IFDOOR) - [DT_DOOR]= S_IFDOOR, -#endif -}; - -#if defined(DT_DOOR) && defined(S_IFDOOR) -static const int DT_MAX = DT_DOOR; -#else -static const int DT_MAX = DT_SOCK; -#endif - -static unsigned llapi_filetype_dir_table[] = { - [0]= DT_UNKNOWN, - [S_IFIFO]= DT_FIFO, - [S_IFCHR] = DT_CHR, - [S_IFDIR] = DT_DIR, - [S_IFBLK] = DT_BLK, - [S_IFREG] = DT_REG, - [S_IFLNK] = DT_LNK, - [S_IFSOCK]= DT_SOCK, -#if defined(DT_DOOR) && defined(S_IFDOOR) - [S_IFDOOR]= DT_DOOR, -#endif -}; +#include +#include +#include "lustreapi_internal.h" -#if defined(DT_DOOR) && defined(S_IFDOOR) -static const int S_IFMAX = DT_DOOR; -#else -static const int S_IFMAX = DT_SOCK; -#endif - -/* liblustreapi message level */ static int llapi_msg_level = LLAPI_MSG_MAX; void llapi_msg_set_level(int level) @@ -129,135 +88,211 @@ void llapi_msg_set_level(int level) llapi_msg_level = level; } -void llapi_err(int level, char *fmt, ...) +static void error_callback_default(enum llapi_message_level level, int err, + const char *fmt, va_list ap) +{ + vfprintf(stderr, fmt, ap); + if (level & LLAPI_MSG_NO_ERRNO) + fprintf(stderr, "\n"); + else + fprintf(stderr, ": %s (%d)\n", strerror(err), err); +} + +static void info_callback_default(enum llapi_message_level level, int err, + const char *fmt, va_list ap) { - va_list args; - int tmp_errno = abs(errno); + vfprintf(stdout, fmt, ap); +} - if ((level & LLAPI_MSG_MASK) > llapi_msg_level) - return; +static llapi_log_callback_t llapi_error_callback = error_callback_default; +static llapi_log_callback_t llapi_info_callback = info_callback_default; - va_start(args, fmt); - vfprintf(stderr, fmt, args); - va_end(args); - if (level & LLAPI_MSG_NO_ERRNO) - fprintf(stderr, "\n"); - else - fprintf(stderr, ": %s (%d)\n", strerror(tmp_errno), tmp_errno); +/* llapi_error will preserve errno */ +void llapi_error(enum llapi_message_level level, int err, const char *fmt, ...) +{ + va_list args; + int tmp_errno = errno; + + if ((level & LLAPI_MSG_MASK) > llapi_msg_level) + return; + + va_start(args, fmt); + llapi_error_callback(level, abs(err), fmt, args); + va_end(args); + errno = tmp_errno; +} + +/* llapi_printf will preserve errno */ +void llapi_printf(enum llapi_message_level level, const char *fmt, ...) +{ + va_list args; + int tmp_errno = errno; + + if ((level & LLAPI_MSG_MASK) > llapi_msg_level) + return; + + va_start(args, fmt); + llapi_info_callback(level, 0, fmt, args); + va_end(args); + errno = tmp_errno; } -#define llapi_err_noerrno(level, fmt, a...) \ - llapi_err((level) | LLAPI_MSG_NO_ERRNO, fmt, ## a) +/** + * Set a custom error logging function. Passing in NULL will reset the logging + * callback to its default value. + * + * This function returns the value of the old callback. + */ +llapi_log_callback_t llapi_error_callback_set(llapi_log_callback_t cb) +{ + llapi_log_callback_t old = llapi_error_callback; + + if (cb != NULL) + llapi_error_callback = cb; + else + llapi_error_callback = error_callback_default; + + return old; +} -void llapi_printf(int level, char *fmt, ...) +/** + * Set a custom info logging function. Passing in NULL will reset the logging + * callback to its default value. + * + * This function returns the value of the old callback. + */ +llapi_log_callback_t llapi_info_callback_set(llapi_log_callback_t cb) { - va_list args; + llapi_log_callback_t old = llapi_info_callback; - if ((level & LLAPI_MSG_MASK) > llapi_msg_level) - return; + if (cb != NULL) + llapi_info_callback = cb; + else + llapi_info_callback = info_callback_default; - va_start(args, fmt); - vfprintf(stdout, fmt, args); - va_end(args); + return old; } /** - * size_units is unchanged if no specifier used + * size_units is to be initialized (or zeroed) by caller. */ -int parse_size(char *optarg, unsigned long long *size, - unsigned long long *size_units, int bytes_spec) +int llapi_parse_size(const char *optarg, unsigned long long *size, + unsigned long long *size_units, int bytes_spec) { char *end; + 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' && + if ((*end == 'b') && *(end + 1) == '\0' && (*size & (~0ULL << (64 - 9))) == 0 && !bytes_spec) { - *size <<= 9; *size_units = 1 << 9; - } else if ((*end == 'b') && *(end+1) == '\0' && + } 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 <<= 10; + *(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 <<= 20; + *(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 <<= 30; + *(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 <<= 40; + *(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 <<= 50; + *(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 <<= 60; + *(end + 1) == '\0' && + (*size & (~0ULL << (64 - 60))) == 0) { *size_units = 1ULL << 60; } else { return -1; } } - + *size *= *size_units; return 0; } +/* XXX: llapi_xxx() functions return negative values upon failure */ + int llapi_stripe_limit_check(unsigned long long stripe_size, int stripe_offset, - int stripe_count, int stripe_pattern) -{ - int page_size; - - /* 64 KB is the largest common page size I'm aware of (on ia64), but - * check the local page size just in case. */ - page_size = LOV_MIN_STRIPE_SIZE; - if (getpagesize() > page_size) { - page_size = getpagesize(); - llapi_err_noerrno(LLAPI_MSG_WARN, - "warning: your page size (%u) is " - "larger than expected (%u)", page_size, - LOV_MIN_STRIPE_SIZE); - } - if (stripe_size < 0 || (stripe_size & (LOV_MIN_STRIPE_SIZE - 1))) { - llapi_err(LLAPI_MSG_ERROR, "error: bad stripe_size %lu, " - "must be an even multiple of %d bytes", - stripe_size, page_size); - return -EINVAL; - } - if (stripe_offset < -1 || stripe_offset > MAX_OBD_DEVICES) { - errno = -EINVAL; - llapi_err(LLAPI_MSG_ERROR, "error: bad stripe offset %d", - stripe_offset); - return -EINVAL; - } - if (stripe_count < -1 || stripe_count > LOV_MAX_STRIPE_COUNT) { - errno = -EINVAL; - llapi_err(LLAPI_MSG_ERROR, "error: bad stripe count %d", - stripe_count); - return -EINVAL; - } - if (stripe_size >= (1ULL << 32)){ - errno = -EINVAL; - llapi_err(LLAPI_MSG_ERROR, "warning: stripe size larger than 4G" - " is not currently supported and would wrap"); - return -EINVAL; + int stripe_count, int stripe_pattern) +{ + int page_size, rc; + + /* 64 KB is the largest common page size I'm aware of (on ia64), but + * check the local page size just in case. */ + page_size = LOV_MIN_STRIPE_SIZE; + if (getpagesize() > page_size) { + page_size = getpagesize(); + llapi_err_noerrno(LLAPI_MSG_WARN, + "warning: your page size (%u) is " + "larger than expected (%u)", page_size, + LOV_MIN_STRIPE_SIZE); + } + if ((stripe_size & (LOV_MIN_STRIPE_SIZE - 1))) { + 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) { + 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) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe count %d", + stripe_count); + return rc; + } + if (stripe_size >= (1ULL << 32)) { + rc = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, rc, + "warning: stripe size 4G or larger " + "is not currently supported and would wrap"); + return rc; + } + 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; } @@ -304,6 +339,249 @@ static int find_poolpath(char *fsname, char *poolname, char *poolpath) } /* + * Trim a trailing newline from a string, if it exists. + */ +int llapi_chomp_string(char *buf) +{ + if (!buf || !*buf) + return 0; + + while (buf[1]) + buf++; + + if (*buf != '\n') + return 0; + + *buf = '\0'; + return '\n'; +} + +/** + * return a parameter string for a specific device type or mountpoint + * + * \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 + 1], dev[PATH_MAX + 1] = "*", fs[PATH_MAX + 1]; + FILE *fp = fopen(DEVICES_LIST, "r"); + int rc = 0; + + if (!fsname && file_path) { + rc = llapi_search_fsname(file_path, fs); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "'%s' is not on a Lustre filesystem", + file_path); + if (fp != NULL) + fclose(fp); + return rc; + } + } else if (fsname) { + if (strlen(fsname) > sizeof(fs)-1) { + if (fp != NULL) + fclose(fp); + return -E2BIG; + } + strncpy(fs, fsname, sizeof(fs)); + } + + if (fp == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); + return rc; + } + + while (fgets(devices, sizeof(devices), fp) != NULL) { + char *bufp = devices, *tmp; + + while (bufp[0] == ' ') + ++bufp; + + tmp = strstr(bufp, obd_type); + if (tmp) { + tmp += strlen(obd_type) + 1; + if (strcmp(tmp, fs)) + continue; + if (strlen(tmp) > sizeof(dev)-1) { + fclose(fp); + return -E2BIG; + } + strncpy(dev, tmp, sizeof(dev)); + tmp = strchr(dev, ' '); + if (tmp != NULL) + *tmp = '\0'; + break; + } + } + + if (dev[0] == '*' && strlen(fs)) + snprintf(dev, PATH_MAX, "%s-*", fs); + snprintf(devices, PATH_MAX, "%s/%s/%s", obd_type, dev, param_name); + fclose(fp); + return get_param(devices, value, val_len); +} + +/* + * TYPE one of llite, lmv, lov. + * /proc/fs/lustre/TYPE/INST the directory of interest. + */ +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) +{ + struct obd_uuid uuid; + int rc; + + rc = llapi_file_get_lov_uuid(path, &uuid); + if (rc != 0) + return rc; + + return get_param_cli("lov", uuid.uuid, param, buf, buf_size); +} + +static int get_param_lmv(const char *path, + const char *param, char *buf, size_t buf_size) +{ + struct obd_uuid uuid; + int rc; + + rc = llapi_file_get_lmv_uuid(path, &uuid); + if (rc != 0) + return rc; + + return get_param_cli("lmv", uuid.uuid, param, buf, buf_size); +} + +static int get_mds_md_size(const char *path) +{ + 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)); + if (rc != 0) + goto out; + + rc = atoi(buf); + if (rc > 0) + md_size = rc; + +out: + return md_size; +} + +int llapi_get_agent_uuid(char *path, char *buf, size_t bufsize) +{ + return get_param_lmv(path, "uuid", buf, bufsize); +} + +/* * if pool is NULL, search ostname in target_obd * if pool is not NULL: * if pool not found returns errno < 0 @@ -319,15 +597,20 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) if (ostname != NULL) len = strlen(ostname); - if (poolname == NULL) - rc = find_target_obdpath(fsname, buffer); - else + if (poolname == NULL) { + if (len == 0) + rc = -EINVAL; + else + rc = find_target_obdpath(fsname, buffer); + } else { rc = find_poolpath(fsname, poolname, buffer); + } if (rc) return rc; - if ((fd = fopen(buffer, "r")) == NULL) - return -EINVAL; + fd = fopen(buffer, "r"); + if (fd == NULL) + return -errno; while (fgets(buffer, sizeof(buffer), fd) != NULL) { if (poolname == NULL) { @@ -355,21 +638,22 @@ int llapi_search_ost(char *fsname, char *poolname, char *ostname) } 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) + unsigned long long stripe_size, int stripe_offset, + int stripe_count, int stripe_pattern, char *pool_name) { - struct lov_user_md_v3 lum = { 0 }; - int fd, rc = 0; - int isdir = 0; + struct lov_user_md_v3 lum = { 0 }; + int fd, rc = 0; /* Make sure we have a good pool */ if (pool_name != NULL) { char fsname[MAX_OBD_NAME + 1], *ptr; - if (llapi_search_fsname(name, fsname)) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "'%s' is not on a Lustre filesystem", name); - return -EINVAL; + rc = llapi_search_fsname(name, fsname); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "'%s' is not on a Lustre filesystem", + name); + return rc; } /* in case user gives the full pool name ., @@ -379,40 +663,43 @@ int llapi_file_open_pool(const char *name, int flags, int mode, *ptr = '\0'; if (strcmp(pool_name, fsname) != 0) { *ptr = '.'; - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "Pool '%s' is not on filesystem '%s'", - pool_name, fsname); + 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 */ - if ((rc = llapi_search_ost(fsname, pool_name, NULL)) < 1) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "pool '%s.%s' %s", fsname, pool_name, - rc == 0 ? "has no OSTs" : "does not exist"); + 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; } } - fd = open(name, flags | O_LOV_DELAY_CREATE, mode); - if (fd < 0 && errno == EISDIR) { - fd = open(name, O_DIRECTORY | O_RDONLY); - isdir++; - } +retry_open: + fd = open(name, flags | O_LOV_DELAY_CREATE, mode); + if (fd < 0) { + if (errno == EISDIR && !(flags & O_DIRECTORY)) { + flags = O_DIRECTORY | O_RDONLY; + goto retry_open; + } + } if (fd < 0) { rc = -errno; - llapi_err(LLAPI_MSG_ERROR, "unable to open '%s'", name); + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); return rc; } - if ((rc = llapi_stripe_limit_check(stripe_size, stripe_offset, - stripe_count, stripe_pattern)) != 0){ - errno = 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_V3; @@ -486,17 +773,170 @@ 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) +{ + struct lmv_user_md lum = { 0 }; + int fd; + int rc = 0; + + lum.lum_magic = LMV_USER_MAGIC; + lum.lum_stripe_offset = stripe_offset; + lum.lum_stripe_count = stripe_count; + lum.lum_hash_type = stripe_pattern; + if (pool_name != NULL) { + if (strlen(pool_name) >= sizeof(lum.lum_pool_name)) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error LL_IOC_LMV_SET_DEFAULT_STRIPE '%s'" + ": too large pool name: %s", name, pool_name); + return -E2BIG; + } + strncpy(lum.lum_pool_name, pool_name, strlen(pool_name)); + } + + fd = open(name, O_DIRECTORY | O_RDONLY); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + return rc; + } + + rc = ioctl(fd, LL_IOC_LMV_SET_DEFAULT_STRIPE, &lum); + if (rc < 0) { + char *errmsg = "stripe already set"; + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error on LL_IOC_LMV_SETSTRIPE '%s' (%d): %s", + name, fd, errmsg); + } + close(fd); + return rc; +} + +int llapi_dir_create_pool(const char *name, int flags, int stripe_offset, + int stripe_count, int stripe_pattern, + const char *pool_name) +{ + struct lmv_user_md lmu = { 0 }; + struct obd_ioctl_data data = { 0 }; + char rawbuf[8192]; + char *buf = rawbuf; + char *dirpath = NULL; + char *namepath = NULL; + char *dir; + char *filename; + int fd = -1; + int rc; + + dirpath = strdup(name); + namepath = strdup(name); + if (!dirpath || !namepath) + 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)); + } + + 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); + rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); + if (rc) { + llapi_error(LLAPI_MSG_ERROR, rc, + "error: LL_IOC_LMV_SETSTRIPE pack failed '%s'.", + name); + goto out; + } + + fd = open(dir, O_DIRECTORY | O_RDONLY); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name); + goto out; + } + + if (ioctl(fd, LL_IOC_LMV_SETSTRIPE, buf)) { + char *errmsg = "stripe already set"; + rc = -errno; + if (errno != EEXIST && errno != EALREADY) + errmsg = strerror(errno); + + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error on LL_IOC_LMV_SETSTRIPE '%s' (%d): %s", + name, fd, errmsg); + } + close(fd); +out: + free(dirpath); + free(namepath); + return rc; +} + +int llapi_direntry_remove(char *dname) +{ + char *dirpath = NULL; + char *namepath = NULL; + char *dir; + char *filename; + int fd = -1; + int rc = 0; + + dirpath = strdup(dname); + namepath = strdup(dname); + if (!dirpath || !namepath) + return -ENOMEM; + + filename = basename(namepath); + + dir = dirname(dirpath); + + fd = open(dir, O_DIRECTORY | O_RDONLY); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", + filename); + goto out; + } + + 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, + fd, errmsg); + } +out: + free(dirpath); + free(namepath); + if (fd != -1) + close(fd); + return rc; +} + /* * Find the fsname, the full path, and/or an open fd. * Either the fsname or path must not be NULL */ -#define WANT_PATH 0x1 -#define WANT_FSNAME 0x2 -#define WANT_FD 0x4 -#define WANT_INDEX 0x8 -#define WANT_ERROR 0x10 -static int get_root_path(int want, char *fsname, int *outfd, char *path, - int index) +int get_root_path(int want, char *fsname, int *outfd, char *path, int index) { struct mntent mnt; char buf[PATH_MAX], mntdir[PATH_MAX]; @@ -508,10 +948,10 @@ static int get_root_path(int want, char *fsname, int *outfd, char *path, /* get the mount point */ fp = setmntent(MOUNTED, "r"); if (fp == NULL) { - llapi_err(LLAPI_MSG_ERROR, - "setmntent(%s) failed: %s:", MOUNTED, - strerror (errno)); - return -EIO; + rc = -EIO; + llapi_error(LLAPI_MSG_ERROR, rc, + "setmntent(%s) failed", MOUNTED); + return rc; } while (1) { if (getmntent_r(fp, &mnt, buf, sizeof(buf)) == NULL) @@ -520,17 +960,18 @@ static int get_root_path(int want, char *fsname, int *outfd, char *path, if (!llapi_is_lustre_mnt(&mnt)) continue; + if ((want & WANT_INDEX) && (idx++ != index)) + continue; + mntlen = strlen(mnt.mnt_dir); ptr = strrchr(mnt.mnt_fsname, '/'); - if (!ptr && !len) { - rc = -EINVAL; - break; - } + /* thanks to the call to llapi_is_lustre_mnt() above, + * we are sure that mnt.mnt_fsname contains ":/", + * so ptr should never be NULL */ + if (ptr == NULL) + continue; ptr++; - if ((want & WANT_INDEX) && (idx++ != index)) - continue; - /* Check the fsname for a match, if given */ if (!(want & WANT_FSNAME) && fsname != NULL && (strlen(fsname) > 0) && (strcmp(ptr, fsname) != 0)) @@ -562,16 +1003,18 @@ static int get_root_path(int want, char *fsname, int *outfd, char *path, if (want & WANT_FD) { fd = open(mntdir, O_RDONLY | O_DIRECTORY | O_NONBLOCK); if (fd < 0) { - perror("open"); rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error opening '%s'", mntdir); + } else { *outfd = fd; } } } else if (want & WANT_ERROR) - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "can't find fs root for '%s': %d", - (want & WANT_PATH) ? fsname : path, rc); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "can't find fs root for '%s': %d", + (want & WANT_PATH) ? fsname : path, rc); return rc; } @@ -592,7 +1035,7 @@ int llapi_search_mounts(const char *pathname, int index, char *mntdir, { int want = WANT_PATH, idx = -1; - if (!pathname) { + if (!pathname || pathname[0] == '\0') { want |= WANT_INDEX; idx = index; } else @@ -603,31 +1046,78 @@ int llapi_search_mounts(const char *pathname, int index, char *mntdir, return get_root_path(want, fsname, NULL, mntdir, idx); } +/* Given a path, find the corresponding Lustre fsname */ int llapi_search_fsname(const char *pathname, char *fsname) { - return get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, - (char *)pathname, -1); + char *path; + int rc; + + path = realpath(pathname, NULL); + if (path == NULL) { + char buf[PATH_MAX + 1], *ptr; + + buf[0] = 0; + if (pathname[0] != '/') { + /* Need an absolute path, but realpath() only works for + * pathnames that actually exist. We go through the + * extra hurdle of dirname(getcwd() + pathname) in + * case the relative pathname contains ".." in it. */ + if (getcwd(buf, sizeof(buf) - 1) == NULL) + return -errno; + strcat(buf, "/"); + } + strncat(buf, pathname, sizeof(buf) - strlen(buf)); + 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; } -/* return the first file matching this pattern */ -static int first_match(char *pattern, char *buffer) +int llapi_search_rootpath(char *pathname, const char *fsname) { - glob_t glob_info; + return get_root_path(WANT_PATH, (char *)fsname, NULL, pathname, -1); +} - if (glob(pattern, GLOB_BRACE, NULL, &glob_info)) - return -ENOENT; +int llapi_getname(const char *path, char *buf, size_t size) +{ + struct obd_uuid uuid_buf; + char *uuid = uuid_buf.uuid; + int rc, nr; - if (glob_info.gl_pathc < 1) { - globfree(&glob_info); - return -ENOENT; - } + memset(&uuid_buf, 0, sizeof(uuid_buf)); + rc = llapi_file_get_lov_uuid(path, &uuid_buf); + if (rc) + return rc; - strcpy(buffer, glob_info.gl_pathv[0]); + /* We want to turn lustre-clilov-ffff88002738bc00 into + * lustre-ffff88002738bc00. */ - globfree(&glob_info); - return 0; + nr = snprintf(buf, size, "%.*s-%s", + (int) (strlen(uuid) - 24), uuid, + uuid + strlen(uuid) - 16); + + if (nr >= size) + rc = -ENAMETOOLONG; + + return rc; } + /* * find the pool directory path under /proc * (can be also used to test if a fsname is known) @@ -695,17 +1185,19 @@ int llapi_get_poolmembers(const char *poolname, char **members, rc = poolpath(fsname, NULL, pathname); if (rc != 0) { - errno = -rc; - llapi_err(LLAPI_MSG_ERROR, "Lustre filesystem '%s' not found", - fsname); + 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); sprintf(path, "%s/%s", pathname, pool); - if ((fd = fopen(path, "r")) == NULL) { - llapi_err(LLAPI_MSG_ERROR, "Cannot open %s", path); - return -EINVAL; + fd = fopen(path, "r"); + if (fd == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "Cannot open %s", path); + return rc; } rc = 0; @@ -715,7 +1207,8 @@ int llapi_get_poolmembers(const char *poolname, char **members, break; } /* remove '\n' */ - if ((tmp = strchr(buf, '\n')) != NULL) + tmp = strchr(buf, '\n'); + if (tmp != NULL) *tmp='\0'; if (used + strlen(buf) + 1 > buffer_size) { rc = -EOVERFLOW; @@ -767,62 +1260,75 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, /* only absolute pathname is supported */ if (*name != '/') return -EINVAL; + if (!realpath(name, rname)) { rc = -errno; - llapi_err(LLAPI_MSG_ERROR, "invalid path '%s'", name); + llapi_error(LLAPI_MSG_ERROR, rc, "invalid path '%s'", + name); return rc; } rc = poolpath(NULL, rname, pathname); if (rc != 0) { - errno = -rc; - llapi_err(LLAPI_MSG_ERROR, "'%s' is not" - " a Lustre filesystem", name); + llapi_error(LLAPI_MSG_ERROR, rc, "'%s' is not" + " a Lustre filesystem", name); return rc; } - strcpy(fsname, rname); + if (strlen(rname) > sizeof(fsname)-1) + return -E2BIG; + strncpy(fsname, rname, sizeof(fsname)); } else { /* name is FSNAME */ - strcpy(fsname, name); + if (strlen(name) > sizeof(fsname)-1) + return -E2BIG; + strncpy(fsname, name, sizeof(fsname)); rc = poolpath(fsname, NULL, pathname); } if (rc != 0) { - errno = -rc; - llapi_err(LLAPI_MSG_ERROR, "Lustre filesystem '%s' not found", - name); + llapi_error(LLAPI_MSG_ERROR, rc, + "Lustre filesystem '%s' not found", name); return rc; } llapi_printf(LLAPI_MSG_NORMAL, "Pools from %s:\n", fsname); - if ((dir = opendir(pathname)) == NULL) { - llapi_err(LLAPI_MSG_ERROR, "Could not open pool list for '%s'", - name); - return -errno; + dir = opendir(pathname); + if (dir == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "Could not open pool list for '%s'", + name); + return rc; } while(1) { rc = readdir_r(dir, &pool, &cookie); if (rc != 0) { - llapi_err(LLAPI_MSG_ERROR, - "Error reading pool list for '%s'", name); - return -errno; - } else if ((rc == 0) && (cookie == NULL)) + 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; + } /* ignore . and .. */ if (!strcmp(pool.d_name, ".") || !strcmp(pool.d_name, "..")) continue; /* check output bounds */ - if (nb_entries >= list_size) - return -EOVERFLOW; + if (nb_entries >= list_size) { + rc = -EOVERFLOW; + goto out; + } /* +2 for '.' and final '\0' */ - if (used + strlen(pool.d_name) + strlen(fsname) + 2 - > buffer_size) - return -EOVERFLOW; + if (used + strlen(pool.d_name) + strlen(fsname) + 2 + > buffer_size) { + rc = -EOVERFLOW; + goto out; + } sprintf(buffer + used, "%s.%s", fsname, pool.d_name); poollist[nb_entries] = buffer + used; @@ -830,8 +1336,9 @@ int llapi_get_poollist(const char *name, char **poollist, int list_size, nb_entries++; } +out: closedir(dir); - return nb_entries; + return ((rc != 0) ? rc : nb_entries); } /* wrapper for lfs.c and obd.c */ @@ -839,72 +1346,124 @@ int llapi_poollist(const char *name) { /* list of pool names (assume that pool count is smaller than OST count) */ - char *list[FIND_MAX_OSTS]; - char *buffer; - /* fsname-OST0000_UUID < 32 char, 1 per OST */ - int bufsize = FIND_MAX_OSTS * 32; - int i, nb; - - buffer = malloc(bufsize); - if (buffer == NULL) - return -ENOMEM; + char **list, *buffer = NULL, *path = NULL, *fsname = NULL; + int obdcount, bufsize, rc, nb, i; + char *poolname = NULL, *tmp = NULL, data[16]; + + if (name[0] != '/') { + fsname = strdup(name); + poolname = strchr(fsname, '.'); + if (poolname) + *poolname = '\0'; + } else { + path = (char *) name; + } - if ((name[0] == '/') || (strchr(name, '.') == NULL)) + rc = get_param_obdvar(fsname, path, "lov", "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 + * allocated space. */ +retry_get_pools: + bufsize = sizeof(struct obd_uuid) * obdcount; + buffer = realloc(tmp, bufsize + sizeof(*list) * obdcount); + if (buffer == NULL) { + rc = -ENOMEM; + goto err; + } + list = (char **) (buffer + bufsize); + + if (!poolname) { /* name is a path or fsname */ - nb = llapi_get_poollist(name, list, FIND_MAX_OSTS, buffer, - bufsize); - else + nb = llapi_get_poollist(name, list, obdcount, + buffer, bufsize); + } else { /* name is a pool name (.) */ - nb = llapi_get_poolmembers(name, list, FIND_MAX_OSTS, buffer, - bufsize); + nb = llapi_get_poolmembers(name, list, obdcount, + buffer, bufsize); + } + + if (nb == -EOVERFLOW) { + obdcount *= 2; + tmp = buffer; + goto retry_get_pools; + } for (i = 0; i < nb; i++) llapi_printf(LLAPI_MSG_NORMAL, "%s\n", list[i]); - - free(buffer); - return (nb < 0 ? nb : 0); + rc = (nb < 0 ? nb : 0); +err: + if (buffer) + free(buffer); + if (fsname) + free(fsname); + return rc; } +typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d, + void *data, struct dirent64 *de); -typedef int (semantic_func_t)(char *path, DIR *parent, DIR *d, - void *data, cfs_dirent_t *de); - -#define MAX_LOV_UUID_COUNT max(LOV_MAX_STRIPE_COUNT, 1000) #define OBD_NOT_FOUND (-1) -static int common_param_init(struct find_param *param) +static int common_param_init(struct find_param *param, char *path) { - param->lumlen = lov_mds_md_size(MAX_LOV_UUID_COUNT, LOV_MAGIC_V3); - if ((param->lmd = malloc(sizeof(lstat_t) + param->lumlen)) == NULL) { - llapi_err(LLAPI_MSG_ERROR, - "error: allocation of %d bytes for ioctl", - sizeof(lstat_t) + param->lumlen); - return -ENOMEM; - } - - param->got_uuids = 0; - param->obdindexes = NULL; - param->obdindex = OBD_NOT_FOUND; - return 0; + int lumlen = get_mds_md_size(path); + + if (lumlen < PATH_MAX + 1) + lumlen = PATH_MAX + 1; + + param->lumlen = lumlen; + param->lmd = malloc(sizeof(lstat_t) + param->lumlen); + if (param->lmd == NULL) { + llapi_error(LLAPI_MSG_ERROR, -ENOMEM, + "error: allocation of %zu bytes for ioctl", + sizeof(lstat_t) + param->lumlen); + return -ENOMEM; + } + + param->fp_lmv_count = 256; + param->fp_lmv_md = malloc(lmv_user_md_size(256, 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)); + return -ENOMEM; + } + + param->got_uuids = 0; + param->obdindexes = NULL; + param->obdindex = OBD_NOT_FOUND; + if (!param->migrate) + param->mdtindex = OBD_NOT_FOUND; + return 0; } static void find_param_fini(struct find_param *param) { - if (param->obdindexes) - free(param->obdindexes); + if (param->obdindexes) + free(param->obdindexes); + + if (param->lmd) + free(param->lmd); - if (param->lmd) - free(param->lmd); + if (param->fp_lmv_md) + free(param->fp_lmv_md); } -static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data, - cfs_dirent_t *de) +static int cb_common_fini(char *path, DIR *parent, DIR **dirp, void *data, + struct dirent64 *de) { - struct find_param *param = (struct find_param *)data; - param->depth--; - return 0; + struct find_param *param = data; + param->fp_depth--; + + return 0; } +/* set errno upon failure */ static DIR *opendir_parent(char *path) { DIR *parent; @@ -922,81 +1481,111 @@ static DIR *opendir_parent(char *path) return parent; } -int llapi_mds_getfileinfo(char *path, DIR *parent, - struct lov_user_mds_data *lmd) +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; + + lmv->lum_stripe_count = param->fp_lmv_count; + if (param->get_default_lmv) + lmv->lum_magic = LMV_USER_MAGIC; + else + lmv->lum_magic = LMV_MAGIC_V1; + ret = ioctl(dirfd(d), LL_IOC_LMV_GETSTRIPE, lmv); + + return ret; +} + +static int get_lmd_info(char *path, DIR *parent, DIR *dir, + struct lov_user_mds_data *lmd, int lumlen) { lstat_t *st = &lmd->lmd_st; - char *fname = strrchr(path, '/'); int ret = 0; - if (parent == NULL) + if (parent == NULL && dir == NULL) return -EINVAL; - fname = (fname == NULL ? path : fname + 1); - /* retrieve needed file info */ - strncpy((char *)lmd, fname, - lov_mds_md_size(MAX_LOV_UUID_COUNT, LOV_MAGIC)); - ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); + if (dir) { + ret = ioctl(dirfd(dir), LL_IOC_MDC_GETINFO, (void *)lmd); + } else if (parent) { + char *fname = strrchr(path, '/'); - if (ret) { - if (errno == ENOTTY) { + fname = (fname == NULL ? path : fname + 1); + /* retrieve needed file info */ + strncpy((char *)lmd, fname, lumlen); + ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd); + } + + if (ret) { + if (errno == ENOTTY) { /* ioctl is not supported, it is not a lustre fs. * Do the regular lstat(2) instead. */ ret = lstat_f(path, st); if (ret) { - llapi_err(LLAPI_MSG_ERROR, - "error: %s: lstat failed for %s", - __func__, path); - return ret; + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: lstat failed for %s", + __func__, path); } } else if (errno == ENOENT) { - llapi_err(LLAPI_MSG_WARN, - "warning: %s: %s does not exist", - __func__, path); - return -ENOENT; - } else { - llapi_err(LLAPI_MSG_ERROR, - "error: %s: IOC_MDC_GETFILEINFO failed for %s", - __func__, path); - return ret; - } - } - - return 0; + ret = -errno; + llapi_error(LLAPI_MSG_WARN, ret, + "warning: %s: %s does not exist", + __func__, path); + } else if (errno != EISDIR) { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s ioctl failed for %s.", + dir ? "LL_IOC_MDC_GETINFO" : + "IOC_MDC_GETFILEINFO", path); + } else { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: IOC_MDC_GETFILEINFO failed for %s", + __func__, path); + } + } + return ret; } static int llapi_semantic_traverse(char *path, int size, DIR *parent, - semantic_func_t sem_init, - semantic_func_t sem_fini, void *data, - cfs_dirent_t *de) + semantic_func_t sem_init, + semantic_func_t sem_fini, void *data, + struct dirent64 *de) { - cfs_dirent_t *dent; - int len, ret; - DIR *d, *p = NULL; + struct find_param *param = (struct find_param *)data; + struct dirent64 *dent; + int len, ret; + DIR *d, *p = NULL; ret = 0; len = strlen(path); d = opendir(path); if (!d && errno != ENOTDIR) { - llapi_err(LLAPI_MSG_ERROR, "%s: Failed to open '%s'", - __func__, path); - return -EINVAL; + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, "%s: Failed to open '%s'", + __func__, path); + return ret; } else if (!d && !parent) { /* ENOTDIR. Open the parent dir. */ p = opendir_parent(path); - if (!p) - GOTO(out, ret = -EINVAL); + if (!p) { + ret = -errno; + goto out; + } } - if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de))) - goto err; + if (sem_init && (ret = sem_init(path, parent ?: p, &d, data, de))) + goto err; - if (!d) - GOTO(out, ret = 0); + if (!d || (param->get_lmv && !param->recursive)) { + ret = 0; + goto out; + } - while ((dent = readdir64(d)) != NULL) { - ((struct find_param *)data)->have_fileinfo = 0; + while ((dent = readdir64(d)) != NULL) { + param->have_fileinfo = 0; if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; @@ -1007,34 +1596,30 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, path[len] = 0; if ((len + dent->d_reclen + 2) > size) { - llapi_err(LLAPI_MSG_ERROR, - "error: %s: string buffer is too small", - __func__); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: string buffer is too small", + __func__); break; } strcat(path, "/"); strcat(path, dent->d_name); if (dent->d_type == DT_UNKNOWN) { - lstat_t *st = &((struct find_param *)data)->lmd->lmd_st; - - ret = llapi_mds_getfileinfo(path, d, - ((struct find_param *)data)->lmd); - if (ret == 0) { - ((struct find_param *)data)->have_fileinfo = 1; - dent->d_type = - llapi_filetype_dir_table[st->st_mode & - S_IFMT]; - } + lstat_t *st = ¶m->lmd->lmd_st; + + ret = get_lmd_info(path, d, NULL, param->lmd, + param->lumlen); + if (ret == 0) + dent->d_type = IFTODT(st->st_mode); + if (ret == -ENOENT) continue; - } - + } switch (dent->d_type) { case DT_UNKNOWN: - llapi_err(LLAPI_MSG_ERROR, - "error: %s: '%s' is UNKNOWN type %d", - __func__, dent->d_name, dent->d_type); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "error: %s: '%s' is UNKNOWN type %d", + __func__, dent->d_name, dent->d_type); break; case DT_DIR: ret = llapi_semantic_traverse(path, size, d, sem_init, @@ -1057,8 +1642,8 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, out: path[len] = 0; - if (sem_fini) - sem_fini(path, parent, d, data, de); + if (sem_fini) + sem_fini(path, parent, &d, data, de); err: if (d) closedir(d); @@ -1074,20 +1659,23 @@ static int param_callback(char *path, semantic_func_t sem_init, char *buf; if (len > PATH_MAX) { - llapi_err(LLAPI_MSG_ERROR, "Path name '%s' is too long", path); - return -EINVAL; + ret = -EINVAL; + llapi_error(LLAPI_MSG_ERROR, ret, + "Path name '%s' is too long", path); + return ret; } buf = (char *)malloc(PATH_MAX + 1); if (!buf) return -ENOMEM; - ret = common_param_init(param); + strncpy(buf, path, PATH_MAX + 1); + ret = common_param_init(param, buf); if (ret) goto out; - param->depth = 0; - strncpy(buf, path, PATH_MAX + 1); + param->fp_depth = 0; + ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, sem_init, sem_fini, param, NULL); out: @@ -1100,8 +1688,18 @@ int llapi_file_fget_lov_uuid(int fd, struct obd_uuid *lov_name) { int rc = ioctl(fd, OBD_IOC_GETNAME, lov_name); if (rc) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "error: can't get lov name."); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: can't get lov name."); + } + return rc; +} + +int llapi_file_fget_lmv_uuid(int fd, struct obd_uuid *lov_name) +{ + int rc = ioctl(fd, OBD_IOC_GETMDNAME, lov_name); + if (rc) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: can't get lmv name."); } return rc; } @@ -1112,43 +1710,70 @@ int llapi_file_get_lov_uuid(const char *path, struct obd_uuid *lov_uuid) fd = open(path, O_RDONLY); if (fd < 0) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "error opening %s", path); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); return rc; } rc = llapi_file_fget_lov_uuid(fd, lov_uuid); 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); + if (fd < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); + return rc; + } + + rc = llapi_file_fget_lmv_uuid(fd, lov_uuid); + + close(fd); + return rc; +} + +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 * the ost_count set to number of available obd uuids. */ -int llapi_lov_get_uuids(int fd, struct obd_uuid *uuidp, int *ost_count) +static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp, + int *ost_count, enum tgt_type type) { - struct obd_uuid lov_name; + struct obd_uuid name; char buf[1024]; FILE *fp; int rc = 0, index = 0; /* Get the lov name */ - rc = llapi_file_fget_lov_uuid(fd, &lov_name); - if (rc) - return rc; + 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; + } /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/lov/%s/target_obd", - lov_name.uuid); + 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_err(LLAPI_MSG_ERROR, "error: opening '%s'", buf); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", buf); return rc; } @@ -1162,13 +1787,18 @@ int llapi_lov_get_uuids(int fd, struct obd_uuid *uuidp, int *ost_count) fclose(fp); - if (uuidp && (index >= *ost_count)) - return -EOVERFLOW; + if (uuidp && (index > *ost_count)) + rc = -EOVERFLOW; *ost_count = index; return rc; } +int llapi_lov_get_uuids(int fd, struct obd_uuid *uuidp, int *ost_count) +{ + return llapi_get_target_uuids(fd, uuidp, ost_count, LOV_TYPE); +} + int llapi_get_obd_count(char *mnt, int *count, int is_mdt) { DIR *root; @@ -1176,12 +1806,15 @@ int llapi_get_obd_count(char *mnt, int *count, int is_mdt) root = opendir(mnt); if (!root) { - llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt); - return -1; + 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; closedir(root); return rc; @@ -1194,13 +1827,18 @@ int llapi_get_obd_count(char *mnt, int *count, int is_mdt) */ int llapi_uuid_match(char *real_uuid, char *search_uuid) { - int cmplen = strlen(real_uuid) - 5; + int cmplen = strlen(real_uuid); + int searchlen = strlen(search_uuid); - if ((strlen(search_uuid) > cmplen) && isxdigit(search_uuid[cmplen])) { - /* OST00000003 doesn't match OST0000 */ - llapi_err(LLAPI_MSG_ERROR, "Bad UUID format '%s'", search_uuid); + if (cmplen > 5 && strcmp(real_uuid + cmplen - 5, "_UUID") == 0) + cmplen -= 5; + if (searchlen > 5 && strcmp(search_uuid + searchlen - 5, "_UUID") == 0) + searchlen -= 5; + + /* The UUIDs may legitimately be different lengths, if + * the system was upgraded from an older version. */ + if (cmplen != searchlen) return 0; - } return (strncmp(search_uuid, real_uuid, cmplen) == 0); } @@ -1209,7 +1847,7 @@ int llapi_uuid_match(char *real_uuid, char *search_uuid) * returned in param->obdindex */ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) { - struct obd_uuid lov_uuid; + struct obd_uuid obd_uuid; char uuid[sizeof(struct obd_uuid)]; char buf[1024]; FILE *fp; @@ -1218,13 +1856,15 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) if (param->got_uuids) return rc; - /* Get the lov name */ - rc = llapi_file_fget_lov_uuid(dirfd(dir), &lov_uuid); + /* 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 (errno != ENOTTY) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, - "error: can't get lov name: %s", dname); + if (rc != -ENOTTY) { + llapi_error(LLAPI_MSG_ERROR, rc, + "error: can't get lov name: %s", dname); } else { rc = 0; } @@ -1234,17 +1874,18 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) param->got_uuids = 1; /* Now get the ost uuids from /proc */ - snprintf(buf, sizeof(buf), "/proc/fs/lustre/lov/%s/target_obd", - lov_uuid.uuid); + 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_err(LLAPI_MSG_ERROR, "error: opening '%s'", buf); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening '%s'", buf); return rc; } if (!param->obduuid && !param->quiet && !param->obds_printed) - llapi_printf(LLAPI_MSG_NORMAL, "OBDS:\n"); + llapi_printf(LLAPI_MSG_NORMAL, "%s:\n", + param->get_lmv ? "MDTS" : "OBDS:"); while (fgets(buf, sizeof(buf), fp) != NULL) { if (sscanf(buf, "%d: %s", &index, uuid) < 2) @@ -1277,152 +1918,426 @@ static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param) /* In this case, param->obduuid will be an array of obduuids and * obd index for all these obduuids will be returned in * param->obdindexes */ -static int setup_obd_indexes(DIR *dir, struct find_param *param) +static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, + int num_obds, int **obdindexes, int *obdindex, + enum tgt_type type) { + int ret, obdcount, obd_valid = 0, obdnum; + long i; struct obd_uuid *uuids = NULL; - int obdcount = INIT_ALLOC_NUM_OSTS; - int ret, obd_valid = 0, obdnum, i; - - uuids = (struct obd_uuid *)malloc(INIT_ALLOC_NUM_OSTS * + char buf[16]; + int *indexes; + + if (type == LOV_TYPE) + ret = get_param_lov(path, "numobd", buf, sizeof(buf)); + else + ret = get_param_lmv(path, "numobd", buf, sizeof(buf)); + if (ret != 0) + return ret; + + obdcount = atoi(buf); + uuids = (struct obd_uuid *)malloc(obdcount * sizeof(struct obd_uuid)); if (uuids == NULL) return -ENOMEM; retry_get_uuids: - ret = llapi_lov_get_uuids(dirfd(dir), uuids, - &obdcount); + ret = llapi_get_target_uuids(dirfd(dir), uuids, &obdcount, type); if (ret) { struct obd_uuid *uuids_temp; if (ret == -EOVERFLOW) { uuids_temp = realloc(uuids, obdcount * sizeof(struct obd_uuid)); - if (uuids_temp != NULL) + if (uuids_temp != NULL) { + uuids = uuids_temp; goto retry_get_uuids; + } else ret = -ENOMEM; } - llapi_err(LLAPI_MSG_ERROR, "get ost uuid failed"); - return ret; + llapi_error(LLAPI_MSG_ERROR, ret, "get ost uuid failed"); + goto out_free; } - param->obdindexes = malloc(param->num_obds * sizeof(param->obdindex)); - if (param->obdindexes == NULL) - return -ENOMEM; + indexes = malloc(num_obds * sizeof(*obdindex)); + if (indexes == NULL) { + ret = -ENOMEM; + goto out_free; + } - for (obdnum = 0; obdnum < param->num_obds; obdnum++) { - for (i = 0; i < obdcount; i++) { - if (llapi_uuid_match(uuids[i].uuid, - param->obduuid[obdnum].uuid)) { - param->obdindexes[obdnum] = i; - obd_valid++; - break; + for (obdnum = 0; obdnum < num_obds; obdnum++) { + char *end = NULL; + + /* The user may have specified a simple index */ + i = strtol(obduuids[obdnum].uuid, &end, 0); + if (end && *end == '\0' && i < obdcount) { + indexes[obdnum] = i; + obd_valid++; + } else { + for (i = 0; i < obdcount; i++) { + if (llapi_uuid_match(uuids[i].uuid, + obduuids[obdnum].uuid)) { + indexes[obdnum] = i; + obd_valid++; + break; + } } } if (i >= obdcount) { - param->obdindexes[obdnum] = OBD_NOT_FOUND; + indexes[obdnum] = OBD_NOT_FOUND; llapi_err_noerrno(LLAPI_MSG_ERROR, "error: %s: unknown obduuid: %s", - __func__, - param->obduuid[obdnum].uuid); + __func__, obduuids[obdnum].uuid); ret = -EINVAL; } } if (obd_valid == 0) - param->obdindex = OBD_NOT_FOUND; + *obdindex = OBD_NOT_FOUND; else - param->obdindex = obd_valid; + *obdindex = obd_valid; + + *obdindexes = indexes; +out_free: + if (uuids) + free(uuids); + + return ret; +} + +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; } -static int cb_ostlist(char *path, DIR *parent, DIR *d, void *data, - struct dirent64 *de) +/* + * Given a filesystem name, or a pathname of a file on a lustre filesystem, + * tries to determine the path to the filesystem's clilov directory under /proc + * + * fsname is limited to MTI_NAME_MAXLEN in lustre_idl.h + * The NUL terminator is compensated by the additional "%s" bytes. */ +#define LOV_LEN (sizeof("/proc/fs/lustre/lov/%s-clilov-*") + MTI_NAME_MAXLEN) +static int clilovpath(const char *fsname, const char *const pathname, + char *clilovpath) +{ + int rc; + char pattern[LOV_LEN]; + char buffer[PATH_MAX + 1]; + + if (fsname == NULL) { + rc = llapi_search_fsname(pathname, buffer); + if (rc != 0) + return rc; + fsname = buffer; + } + + snprintf(pattern, sizeof(pattern), "/proc/fs/lustre/lov/%s-clilov-*", + fsname); + + rc = first_match(pattern, buffer); + if (rc != 0) + return rc; + + strncpy(clilovpath, buffer, sizeof(buffer)); + + return 0; +} + +/* + * Given the path to a stripe attribute proc file, tries to open and + * read the attribute and return the value using the attr parameter + */ +static int sattr_read_attr(const char *const fpath, + unsigned int *attr) { - struct find_param *param = (struct find_param *)data; - LASSERT(parent != NULL || d != NULL); + FILE *f; + char line[PATH_MAX + 1]; + int rc = 0; - /* Prepare odb. */ - return setup_obd_uuid(d ? d : parent, path, param); + f = fopen(fpath, "r"); + if (f == NULL) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "Cannot open '%s'", fpath); + return rc; + } + + if (fgets(line, sizeof(line), f) != NULL) { + *attr = atoi(line); + } else { + llapi_error(LLAPI_MSG_ERROR, errno, "Cannot read from '%s'", fpath); + rc = 1; + } + + fclose(f); + return rc; } -int llapi_ostlist(char *path, struct find_param *param) +/* + * Tries to determine the default stripe attributes for a given filesystem. The + * filesystem to check should be specified by fsname, or will be determined + * using pathname. + */ +static int sattr_get_defaults(const char *const fsname, + const char *const pathname, + unsigned int *scount, + unsigned int *ssize, + unsigned int *soffset) { - return param_callback(path, cb_ostlist, cb_common_fini, param); + int rc; + char dpath[PATH_MAX + 1]; + char fpath[PATH_MAX + 1]; + + rc = clilovpath(fsname, pathname, dpath); + if (rc != 0) + return rc; + + if (scount) { + snprintf(fpath, PATH_MAX, "%s/stripecount", dpath); + rc = sattr_read_attr(fpath, scount); + if (rc != 0) + return rc; + } + + if (ssize) { + snprintf(fpath, PATH_MAX, "%s/stripesize", dpath); + rc = sattr_read_attr(fpath, ssize); + if (rc != 0) + return rc; + } + + if (soffset) { + snprintf(fpath, PATH_MAX, "%s/stripeoffset", dpath); + rc = sattr_read_attr(fpath, soffset); + if (rc != 0) + return rc; + } + + return 0; +} + +/* + * Tries to gather the default stripe attributes for a given filesystem. If + * the attributes can be determined, they are cached for easy retreival the + * next time they are needed. Only a single filesystem's attributes are + * cached at a time. + */ +static int sattr_cache_get_defaults(const char *const fsname, + const char *const pathname, + unsigned int *scount, + unsigned int *ssize, + unsigned int *soffset) +{ + static struct { + char fsname[PATH_MAX + 1]; + unsigned int stripecount; + unsigned int stripesize; + unsigned int stripeoffset; + } cache = { + .fsname = {'\0'} + }; + + int rc; + char fsname_buf[PATH_MAX + 1]; + unsigned int tmp[3]; + + if (fsname == NULL) { + rc = llapi_search_fsname(pathname, fsname_buf); + if (rc) + return rc; + } else { + strncpy(fsname_buf, fsname, PATH_MAX); + } + + if (strncmp(fsname_buf, cache.fsname, PATH_MAX) != 0) { + /* + * Ensure all 3 sattrs (count, size, and offset) are + * successfully retrieved and stored in tmp before writing to + * cache. + */ + rc = sattr_get_defaults(fsname_buf, NULL, &tmp[0], &tmp[1], + &tmp[2]); + if (rc != 0) + return rc; + + cache.stripecount = tmp[0]; + cache.stripesize = tmp[1]; + cache.stripeoffset = tmp[2]; + strncpy(cache.fsname, fsname_buf, PATH_MAX); + } + + if (scount) + *scount = cache.stripecount; + if (ssize) + *ssize = cache.stripesize; + if (soffset) + *soffset = cache.stripeoffset; + + return 0; } static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, + struct lov_user_ost_data_v1 *objects, int is_dir, int verbose, int depth, - char *pool_name) + int raw, char *pool_name) { char *prefix = is_dir ? "" : "lmm_"; - char nl = is_dir ? ' ' : '\n'; + char *seperator = ""; + int rc; - if (is_dir && lum->lmm_object_gr == LOV_OBJECT_GROUP_DEFAULT) { - lum->lmm_object_gr = LOV_OBJECT_GROUP_CLEAR; - if (verbose & VERBOSE_DETAIL) - llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); - } + if (is_dir && lmm_oi_seq(&lum->lmm_oi) == FID_SEQ_LOV_DEFAULT) { + lmm_oi_set_seq(&lum->lmm_oi, 0); + if (verbose & VERBOSE_DETAIL) + llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); + } if (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_object_gr: "LPX64"\n", - lum->lmm_object_gr); - llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n", - lum->lmm_object_id); - } + if ((verbose & VERBOSE_DETAIL) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "lmm_magic: 0x%08X\n", + lum->lmm_magic); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_seq: "LPX64"\n", + lmm_oi_seq(&lum->lmm_oi)); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n", + lmm_oi_id(&lum->lmm_oi)); + } if (verbose & VERBOSE_COUNT) { if (verbose & ~VERBOSE_COUNT) llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_count: ", prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%hd%c", - (__s16)lum->lmm_stripe_count, nl); + if (is_dir) { + if (!raw && lum->lmm_stripe_count == 0) { + unsigned int scount; + rc = sattr_cache_get_defaults(NULL, path, + &scount, NULL, + NULL); + if (rc == 0) + llapi_printf(LLAPI_MSG_NORMAL, "%d", + scount); + else + llapi_error(LLAPI_MSG_ERROR, rc, + "Cannot determine default" + " stripe count."); + } else { + llapi_printf(LLAPI_MSG_NORMAL, "%d", + lum->lmm_stripe_count == + (typeof(lum->lmm_stripe_count))(-1) + ? -1 : lum->lmm_stripe_count); + } + } else { + llapi_printf(LLAPI_MSG_NORMAL, "%hd", + (__s16)lum->lmm_stripe_count); + } + seperator = is_dir ? " " : "\n"; } if (verbose & VERBOSE_SIZE) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_SIZE) llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_size: ", prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", lum->lmm_stripe_size, - nl); - } - - if ((verbose & VERBOSE_DETAIL) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "lmm_stripe_pattern: %x%c", - lum->lmm_pattern, nl); + 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 { + llapi_printf(LLAPI_MSG_NORMAL, "%u", + lum->lmm_stripe_size); + } + seperator = is_dir ? " " : "\n"; + } + + if ((verbose & VERBOSE_LAYOUT) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_LAYOUT) + llapi_printf(LLAPI_MSG_NORMAL, "%spattern: ", + prefix); + llapi_printf(LLAPI_MSG_NORMAL, "%.x", lum->lmm_pattern); + seperator = "\n"; + } + + if ((verbose & VERBOSE_GENERATION) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_GENERATION) + llapi_printf(LLAPI_MSG_NORMAL, "%slayout_gen: ", + prefix); + llapi_printf(LLAPI_MSG_NORMAL, "%u", + (int)lum->lmm_layout_gen); + seperator = "\n"; } if (verbose & VERBOSE_OFFSET) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); if (verbose & ~VERBOSE_OFFSET) llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ", prefix); - llapi_printf(LLAPI_MSG_NORMAL, "%u%c", - lum->lmm_objects[0].l_ost_idx, nl); + if (is_dir) + llapi_printf(LLAPI_MSG_NORMAL, "%d", + lum->lmm_stripe_offset == + (typeof(lum->lmm_stripe_offset))(-1) ? -1 : + lum->lmm_stripe_offset); + else + llapi_printf(LLAPI_MSG_NORMAL, "%u", + objects[0].l_ost_idx); + seperator = is_dir ? " " : "\n"; } if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) { - llapi_printf(LLAPI_MSG_NORMAL, "pool: %s", pool_name); - is_dir = 1; + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_POOL) + llapi_printf(LLAPI_MSG_NORMAL, "%spool: ", + prefix); + llapi_printf(LLAPI_MSG_NORMAL, "%s", pool_name); } - if (is_dir && (verbose != VERBOSE_OBJID)) + if (!is_dir || (is_dir && (verbose != VERBOSE_OBJID))) llapi_printf(LLAPI_MSG_NORMAL, "\n"); } void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, struct lov_user_ost_data_v1 *objects, - char *path, int is_dir, - int obdindex, int depth, int header) + char *path, int is_dir, int obdindex, + int depth, int header, int raw) { int i, obdstripe = (obdindex != OBD_NOT_FOUND) ? 0 : 1; @@ -1436,38 +2351,132 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, } if (obdstripe == 1) - lov_dump_user_lmm_header(lum, path, is_dir, header, depth, - pool_name); + lov_dump_user_lmm_header(lum, path, objects, is_dir, header, + depth, raw, pool_name); - if (!is_dir && (header & VERBOSE_OBJID)) { + if (!is_dir && (header & VERBOSE_OBJID) && + !(lum->lmm_pattern & LOV_PATTERN_F_RELEASED)) { if (obdstripe == 1) llapi_printf(LLAPI_MSG_NORMAL, - "\tobdidx\t\t objid\t\tobjid\t\t group\n"); + "\tobdidx\t\t objid\t\t objid\t\t group\n"); for (i = 0; i < lum->lmm_stripe_count; i++) { int idx = objects[i].l_ost_idx; - long long oid = objects[i].l_object_id; - long long gr = objects[i].l_object_gr; - if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) - llapi_printf(LLAPI_MSG_NORMAL, - "\t%6u\t%14llu\t%#13llx\t%14llu%s\n", - idx, oid, oid, gr, - obdindex == idx ? " *" : ""); + long long oid = ostid_id(&objects[i].l_ost_oi); + long long gr = ostid_seq(&objects[i].l_ost_oi); + if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) { + char fmt[48]; + sprintf(fmt, "%s%s%s\n", + "\t%6u\t%14llu\t%#13llx\t", + (fid_seq_is_rsvd(gr) || + fid_seq_is_mdt0(gr)) ? + "%14llu" : "%#14llx", "%s"); + llapi_printf(LLAPI_MSG_NORMAL, fmt, idx, oid, + oid, gr, + obdindex == idx ? " *" : ""); + } + } llapi_printf(LLAPI_MSG_NORMAL, "\n"); } } -void llapi_lov_dump_user_lmm(struct find_param *param, - char *path, int is_dir) +void lmv_dump_user_lmm(struct lmv_user_md *lum, char *pool_name, + char *path, int obdindex, int depth, int verbose) { - switch(*(__u32 *)¶m->lmd->lmd_lmm) { /* lum->lmm_magic */ + struct lmv_user_mds_data *objects = lum->lum_objects; + char *prefix = lum->lum_magic == LMV_USER_MAGIC ? "(Default)" : ""; + int i, obdstripe = 0; + char *seperator = ""; + + if (obdindex != OBD_NOT_FOUND) { + for (i = 0; i < lum->lum_stripe_count; i++) { + if (obdindex == objects[i].lum_mds) { + llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, + path); + obdstripe = 1; + break; + } + } + } else { + obdstripe = 1; + } + + /* show all information default */ + if (!verbose) { + if (lum->lum_magic == LMV_USER_MAGIC) + verbose = VERBOSE_POOL | VERBOSE_COUNT | VERBOSE_OFFSET; + else + verbose = VERBOSE_OBJID; + } + + if (depth && path && ((verbose != VERBOSE_OBJID))) + llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, path); + + if (verbose & VERBOSE_COUNT) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_COUNT) + llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_count: "); + llapi_printf(LLAPI_MSG_NORMAL, "%u", + (int)lum->lum_stripe_count); + seperator = "\n"; + } + + if (verbose & VERBOSE_OFFSET) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_OFFSET) + llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_offset: "); + llapi_printf(LLAPI_MSG_NORMAL, "%d", + (int)lum->lum_stripe_offset); + seperator = "\n"; + } + + if (verbose & VERBOSE_OBJID && lum->lum_magic != LMV_USER_MAGIC) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (obdstripe == 1 && 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++) { + int idx = objects[i].lum_mds; + struct lu_fid *fid = &objects[i].lum_fid; + if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) + llapi_printf(LLAPI_MSG_NORMAL, + "%6u\t\t "DFID"\t\t%s\n", + idx, PFID(fid), + obdindex == idx ? " *" : ""); + } + + } + + if ((verbose & VERBOSE_POOL) && (pool_name[0] != '\0')) { + llapi_printf(LLAPI_MSG_NORMAL, "%s", seperator); + if (verbose & ~VERBOSE_POOL) + llapi_printf(LLAPI_MSG_NORMAL, "%slmv_pool: ", + prefix); + llapi_printf(LLAPI_MSG_NORMAL, "%s%c ", pool_name, ' '); + seperator = "\n"; + } + + if (!(verbose & VERBOSE_OBJID)) + llapi_printf(LLAPI_MSG_NORMAL, "\n"); +} + +void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir) +{ + __u32 magic; + + if (param->get_lmv || param->get_default_lmv) + magic = (__u32)param->fp_lmv_md->lum_magic; + else + magic = *(__u32 *)¶m->lmd->lmd_lmm; /* lum->lmm_magic */ + + switch (magic) { case LOV_USER_MAGIC_V1: lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL, param->lmd->lmd_lmm.lmm_objects, path, is_dir, - param->obdindex, param->maxdepth, - param->verbose); + param->obdindex, param->fp_max_depth, + param->verbose, param->raw); break; case LOV_USER_MAGIC_V3: { char pool_name[LOV_MAXPOOLNAME + 1]; @@ -1479,17 +2488,30 @@ void llapi_lov_dump_user_lmm(struct find_param *param, objects = lmmv3->lmm_objects; lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name, objects, path, is_dir, - param->obdindex, param->maxdepth, - param->verbose); + param->obdindex, param->fp_max_depth, + param->verbose, param->raw); break; } - default: - llapi_printf(LLAPI_MSG_NORMAL, "unknown lmm_magic: %#x " - "(expecting one of %#x %#x %#x)\n", - *(__u32 *)¶m->lmd->lmd_lmm, - LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3); - return; - } + case LMV_MAGIC_V1: + case LMV_USER_MAGIC: { + char pool_name[LOV_MAXPOOLNAME + 1]; + struct lmv_user_md *lum; + + lum = (struct lmv_user_md *)param->fp_lmv_md; + strncpy(pool_name, lum->lum_pool_name, LOV_MAXPOOLNAME); + lmv_dump_user_lmm(lum, pool_name, path, + param->obdindex, param->fp_max_depth, + param->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, + LOV_USER_MAGIC_V1, LOV_USER_MAGIC_V3, + LMV_USER_MAGIC, LMV_MAGIC_V1); + return; + } } int llapi_file_get_stripe(const char *path, struct lov_user_md *lum) @@ -1504,33 +2526,33 @@ int llapi_file_get_stripe(const char *path, struct lov_user_md *lum) if (fname == NULL) { dname = (char *)malloc(2); if (dname == NULL) - return ENOMEM; + return -ENOMEM; strcpy(dname, "."); fname = (char *)path; } else { dname = (char *)malloc(fname - path + 1); if (dname == NULL) - return ENOMEM; + return -ENOMEM; strncpy(dname, path, fname - path); dname[fname - path] = '\0'; fname++; } - if ((fd = open(dname, O_RDONLY)) == -1) { - rc = errno; + fd = open(dname, O_RDONLY); + if (fd == -1) { + rc = -errno; free(dname); return rc; } strcpy((char *)lum, fname); if (ioctl(fd, IOC_MDC_GETFILESTRIPE, (void *)lum) == -1) - rc = errno; + rc = -errno; if (close(fd) == -1 && rc == 0) - rc = errno; + rc = -errno; free(dname); - return rc; } @@ -1551,13 +2573,16 @@ int llapi_file_lookup(int dirfd, const char *name) rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf)); if (rc) { - llapi_err(LLAPI_MSG_ERROR, - "error: IOC_MDC_LOOKUP pack failed for '%s': rc %d", - name, rc); + llapi_error(LLAPI_MSG_ERROR, rc, + "error: IOC_MDC_LOOKUP pack failed for '%s': rc %d", + name, rc); return rc; } - return ioctl(dirfd, IOC_MDC_LOOKUP, buf); + rc = ioctl(dirfd, IOC_MDC_LOOKUP, buf); + if (rc < 0) + rc = -errno; + return rc; } /* Check if the value matches 1 of the given criteria (e.g. --atime +/-N). @@ -1568,7 +2593,7 @@ int llapi_file_lookup(int dirfd, const char *name) * sign), 1st column is the answer for the MDS value, the 2nd is for the OST: * -------------------------------------- * 1 | file > limit; sign > 0 | -1 / -1 | - * 2 | file = limit; sign > 0 | ? / 1 | + * 2 | file = limit; sign > 0 | -1 / -1 | * 3 | file < limit; sign > 0 | ? / 1 | * 4 | file > limit; sign = 0 | -1 / -1 | * 5 | file = limit; sign = 0 | ? / 1 | <- (see the Note below) @@ -1579,29 +2604,29 @@ int llapi_file_lookup(int dirfd, const char *name) * -------------------------------------- * Note: 5th actually means that the value is within the interval * (limit - margin, limit]. */ -static int find_value_cmp(unsigned int file, unsigned int limit, int sign, - unsigned long long margin, int mds) +static int find_value_cmp(unsigned long long file, unsigned long long limit, + int sign, int negopt, unsigned long long margin, + int mds) { - if (sign > 0) { - if (file < limit) - return mds ? 0 : 1; - } + int ret = -1; - if (sign == 0) { - if (file <= limit && file + margin > limit) - return mds ? 0 : 1; + if (sign > 0) { + /* Drop the fraction of margin (of days). */ if (file + margin <= limit) - return mds ? 0 : -1; - } - - if (sign < 0) { + ret = mds ? 0 : 1; + } else if (sign == 0) { + if (file <= limit && file + margin > limit) + ret = mds ? 0 : 1; + else if (file + margin <= limit) + ret = mds ? 0 : -1; + } else if (sign < 0) { if (file > limit) - return 1; - if (mds) - return 0; + ret = 1; + else if (mds) + ret = 0; } - return -1; + return negopt ? ~ret + 1 : ret; } /* Check if the file time matches all the given criteria (e.g. --atime +/-N). @@ -1613,49 +2638,149 @@ static int find_value_cmp(unsigned int file, unsigned int limit, int sign, * updated timestamps. */ static int find_time_check(lstat_t *st, struct find_param *param, int mds) { - int ret; - int rc = 0; + int rc = 1; + int rc2; + + /* Check if file is accepted. */ + if (param->fp_atime) { + rc2 = find_value_cmp(st->st_atime, param->fp_atime, + param->fp_asign, param->fp_exclude_atime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + rc = rc2; + } + + if (param->fp_mtime) { + rc2 = find_value_cmp(st->st_mtime, param->fp_mtime, + param->fp_msign, param->fp_exclude_mtime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + + /* If the previous check matches, but this one is not yet clear, + * we should return 0 to do an RPC on OSTs. */ + if (rc == 1) + rc = rc2; + } + + if (param->fp_ctime) { + rc2 = find_value_cmp(st->st_ctime, param->fp_ctime, + param->fp_csign, param->fp_exclude_ctime, + 24 * 60 * 60, mds); + if (rc2 < 0) + return rc2; + + /* If the previous check matches, but this one is not yet clear, + * we should return 0 to do an RPC on OSTs. */ + if (rc == 1) + rc = rc2; + } + + return rc; +} - /* Check if file is accepted. */ - if (param->atime) { - ret = find_value_cmp(st->st_atime, param->atime, - param->asign, 24 * 60 * 60, mds); - if (ret < 0) - return ret; - rc = ret; - } +/** + * Check whether the stripes matches the indexes user provided + * 1 : matched + * 0 : Unmatched + */ +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; - if (param->mtime) { - ret = find_value_cmp(st->st_mtime, param->mtime, - param->msign, 24 * 60 * 60, mds); - if (ret < 0) - return ret; + if (param->obduuid && param->obdindex == OBD_NOT_FOUND) + return 0; - /* If the previous check matches, but this one is not yet clear, - * we should return 0 to do an RPC on OSTs. */ - if (rc == 1) - rc = ret; - } + if (!S_ISREG(st->st_mode)) + return 0; - if (param->ctime) { - ret = find_value_cmp(st->st_ctime, param->ctime, - param->csign, 24 * 60 * 60, mds); - if (ret < 0) - return ret; + /* Only those files should be accepted, which have a + * stripe on the specified OST. */ + if (!param->lmd->lmd_lmm.lmm_stripe_count) + return 0; - /* If the previous check matches, but this one is not yet clear, - * we should return 0 to do an RPC on OSTs. */ - if (rc == 1) - rc = ret; + if (param->lmd->lmd_lmm.lmm_magic == + LOV_USER_MAGIC_V3) { + struct lov_user_md_v3 *lmmv3 = (void *)¶m->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; } - return rc; + 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; + } + } + } + + if (param->exclude_obd) + return 1; + return 0; +} + +static int check_mdt_match(struct find_param *param) +{ + int i; + + if (param->mdtuuid && param->mdtindex == 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; + } + + if (param->exclude_mdt) + return 1; + return 0; } -static int cb_find_init(char *path, DIR *parent, DIR *dir, - void *data, cfs_dirent_t *de) +/** + * Check whether the obd is active or not, if it is + * not active, just print the object affected by this + * failed target + **/ +static int print_failed_tgt(struct find_param *param, char *path, int type) +{ + struct obd_statfs stat_buf; + struct obd_uuid uuid_buf; + int ret; + + LASSERT(type == LL_STATFS_LOV || type == LL_STATFS_LMV); + + 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; +} + +static int cb_find_init(char *path, DIR *parent, DIR **dirp, + void *data, struct dirent64 *de) { struct find_param *param = (struct find_param *)data; + DIR *dir = dirp == NULL ? NULL : *dirp; int decision = 1; /* 1 is accepted; -1 is rejected. */ lstat_t *st = ¶m->lmd->lmd_st; int lustre_fs = 1; @@ -1664,7 +2789,8 @@ static int cb_find_init(char *path, DIR *parent, DIR *dir, LASSERT(parent != NULL || dir != NULL); - param->lmd->lmd_lmm.lmm_stripe_count = 0; + if (param->have_fileinfo == 0) + param->lmd->lmd_lmm.lmm_stripe_count = 0; /* If a regular expression is presented, make the initial decision */ if (param->pattern != NULL) { @@ -1676,162 +2802,193 @@ static int cb_find_init(char *path, DIR *parent, DIR *dir, goto decided; } - /* See if we can check the file type from the dirent. */ - if (param->type && de != NULL && de->d_type != DT_UNKNOWN && - de->d_type < DT_MAX) { - checked_type = 1; - if (llapi_dir_filetype_table[de->d_type] == param->type) { - if (param->exclude_type) - goto decided; - } else { - if (!param->exclude_type) - goto decided; - } - } + /* See if we can check the file type from the dirent. */ + if (param->fp_type != 0 && de != NULL && de->d_type != DT_UNKNOWN) { + checked_type = 1; - - /* If a time or OST should be checked, the decision is not taken yet. */ - if (param->atime || param->ctime || param->mtime || param->obduuid || - param->size) - decision = 0; + if (DTTOIF(de->d_type) == param->fp_type) { + if (param->fp_exclude_type) + goto decided; + } else { + if (!param->fp_exclude_type) + goto decided; + } + } ret = 0; - /* Request MDS for the stat info. */ - if (param->have_fileinfo == 0) { - if (dir) { - /* retrieve needed file info */ - ret = ioctl(dirfd(dir), LL_IOC_MDC_GETINFO, - (void *)param->lmd); - } else { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - /* retrieve needed file info */ - strncpy((char *)param->lmd, fname, param->lumlen); - ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, - (void *)param->lmd); - } - } + /* Request MDS for the stat info if some of these parameters need + * to be compared. */ + if (param->obduuid || param->mdtuuid || + 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) + decision = 0; + + if (param->fp_type != 0 && checked_type == 0) + decision = 0; - if (ret) { - if (errno == ENOTTY) { - /* ioctl is not supported, it is not a lustre fs. - * Do the regular lstat(2) instead. */ - lustre_fs = 0; - ret = lstat_f(path, st); - if (ret) { - llapi_err(LLAPI_MSG_ERROR, - "error: %s: lstat failed for %s", - __func__, path); - return ret; + 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); + } } - } else if (errno == ENOENT) { - llapi_err(LLAPI_MSG_WARN, - "warning: %s: %s does not exist", - __func__, path); - goto decided; - } else { - llapi_err(LLAPI_MSG_ERROR,"error: %s: %s failed for %s", - __func__, dir ? "LL_IOC_MDC_GETINFO" : - "IOC_MDC_GETFILEINFO", path); - return ret; } - } - - if (param->type && !checked_type) { - if ((st->st_mode & S_IFMT) == param->type) { - if (param->exclude_type) - goto decided; - } else { - if (!param->exclude_type) + if (ret) { + 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) { + if (param->fp_exclude_type) + goto decided; + } else { + if (!param->fp_exclude_type) + goto decided; + } + } + /* Prepare odb. */ - if (param->obduuid) { + if (param->obduuid || param->mdtuuid) { if (lustre_fs && param->got_uuids && - param->st_dev != st->st_dev) { + param->fp_dev != st->st_dev) { /* A lustre/lustre mount point is crossed. */ param->got_uuids = 0; param->obds_printed = 0; - param->obdindex = OBD_NOT_FOUND; + param->obdindex = param->mdtindex = OBD_NOT_FOUND; } if (lustre_fs && !param->got_uuids) { - ret = setup_obd_indexes(dir ? dir : parent, param); + ret = setup_target_indexes(dir ? dir : parent, path, + param); if (ret) return ret; - param->st_dev = st->st_dev; + 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 = OBD_NOT_FOUND; + param->obdindex = param->mdtindex = OBD_NOT_FOUND; } } - /* If an OBD UUID is specified but no one matches, skip this file. */ - if (param->obduuid && param->obdindex == OBD_NOT_FOUND) - goto decided; - - /* If a OST UUID is given, and some OST matches, check it here. */ - if (param->obdindex != OBD_NOT_FOUND) { - if (!S_ISREG(st->st_mode)) + 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; + } - /* Only those files should be accepted, which have a - * stripe on the specified OST. */ - if (!param->lmd->lmd_lmm.lmm_stripe_count) { + 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; - } else { - int i, j; - struct lov_user_ost_data_v1 *lmm_objects; + } - if (param->lmd->lmd_lmm.lmm_magic == - LOV_USER_MAGIC_V3) { - struct lov_user_md_v3 *lmmv3 = - (void *)¶m->lmd->lmd_lmm; + if (param->check_layout) { + __u32 found; - lmm_objects = lmmv3->lmm_objects; - } else { - lmm_objects = param->lmd->lmd_lmm.lmm_objects; - } + 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)) { + decision = -1; + goto decided; + } + } - 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) - goto obd_matches; - } - } + /* 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 (i == param->lmd->lmd_lmm.lmm_stripe_count) + /* 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->check_uid) { - if (st->st_uid == param->uid) { - if (param->exclude_uid) - goto decided; - } else { - if (!param->exclude_uid) - goto decided; + if (param->mdtuuid) { + if (check_mdt_match(param)) + goto obd_matches; + goto decided; } } - - if (param->check_gid) { - if (st->st_gid == param->gid) { - if (param->exclude_gid) - goto decided; - } else { - if (!param->exclude_gid) - goto decided; +obd_matches: + if (param->fp_check_uid) { + if (st->st_uid == param->fp_uid) { + if (param->fp_exclude_uid) + goto decided; + } else { + if (!param->fp_exclude_uid) + goto decided; } } + if (param->fp_check_gid) { + if (st->st_gid == param->fp_gid) { + if (param->fp_exclude_gid) + goto decided; + } else { + if (!param->fp_exclude_gid) + goto decided; + } + } + if (param->check_pool) { struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm; @@ -1851,46 +3008,40 @@ static int cb_find_init(char *path, DIR *parent, DIR *dir, } } - /* Check the time on mds. */ - if (!decision) { + /* 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; decision = find_time_check(st, param, for_mds); + if (decision == -1) + goto decided; } -obd_matches: /* If file still fits the request, ask ost for updated info. The regular stat is almost of the same speed as some new 'glimpse-size-ioctl'. */ - if (!decision && S_ISREG(st->st_mode) && - (param->lmd->lmd_lmm.lmm_stripe_count || param->size)) { - if (param->obdindex != OBD_NOT_FOUND) { - /* Check whether the obd is active or not, if it is - * not active, just print the object affected by this - * failed ost - * */ - struct obd_statfs stat_buf; - struct obd_uuid uuid_buf; - - memset(&stat_buf, 0, sizeof(struct obd_statfs)); - memset(&uuid_buf, 0, sizeof(struct obd_uuid)); - ret = llapi_obd_statfs(path, LL_STATFS_LOV, - param->obdindex, &stat_buf, - &uuid_buf); - if (ret) { - if (ret == -ENODATA || ret == -ENODEV - || ret == -EIO) - errno = EIO; - llapi_printf(LLAPI_MSG_NORMAL, - "obd_uuid: %s failed %s ", - param->obduuid->uuid, - strerror(errno)); - goto print_path; - } - } + + if (param->check_size && S_ISREG(st->st_mode) && + param->lmd->lmd_lmm.lmm_stripe_count) + decision = 0; + + while (!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) + print_failed_tgt(param, path, LL_STATFS_LOV); + + if (param->mdtindex != OBD_NOT_FOUND) + print_failed_tgt(param, path, LL_STATFS_LMV); + if (dir) { ret = ioctl(dirfd(dir), IOC_LOV_GETINFO, (void *)param->lmd); @@ -1901,14 +3052,15 @@ obd_matches: if (ret) { if (errno == ENOENT) { - llapi_err(LLAPI_MSG_ERROR, - "warning: %s: %s does not exist", - __func__, path); + llapi_error(LLAPI_MSG_ERROR, -ENOENT, + "warning: %s: %s does not exist", + __func__, path); goto decided; } else { - llapi_err(LLAPI_MSG_ERROR, - "%s: IOC_LOV_GETINFO on %s failed", - __func__, path); + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: IOC_LOV_GETINFO on %s failed", + __func__, path); return ret; } } @@ -1917,14 +3069,15 @@ obd_matches: decision = find_time_check(st, param, 0); if (decision == -1) goto decided; + + break; } - if (param->size) + if (param->check_size) decision = find_value_cmp(st->st_size, param->size, - param->size_sign, param->size_units, - 0); + param->size_sign, param->exclude_size, + param->size_units, 0); -print_path: if (decision != -1) { llapi_printf(LLAPI_MSG_NORMAL, "%s", path); if (param->zeroend) @@ -1935,11 +3088,89 @@ print_path: decided: /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; +} + +static int cb_mv_init(char *path, DIR *parent, DIR **dirp, + void *param_data, struct dirent64 *de) +{ + struct find_param *param = (struct find_param *)param_data; + DIR *dir = parent; + char raw[OBD_MAX_IOCTL_BUFFER] = {'\0'}; + char *rawbuf = raw; + struct obd_ioctl_data data = { 0 }; + int fd; + int ret; + char *filename; + + LASSERT(parent != NULL || dirp != NULL); + if (dirp != NULL) + closedir(*dirp); + + if (parent == NULL) { + dir = opendir_parent(path); + if (dir == NULL) { + *dirp = NULL; + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "can not open %s\n", path); + return ret; + } + } + + fd = dirfd(dir); + + filename = basename(path); + data.ioc_inlbuf1 = (char *)filename; + data.ioc_inllen1 = strlen(filename) + 1; + data.ioc_inlbuf2 = (char *)¶m->mdtindex; + data.ioc_inllen2 = sizeof(param->mdtindex); + ret = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + if (ret != 0) { + llapi_error(LLAPI_MSG_ERROR, ret, + "llapi_obd_statfs: error packing ioctl data"); + goto out; + } + + ret = ioctl(fd, LL_IOC_MIGRATE, rawbuf); + if (ret != 0) { + ret = -errno; + fprintf(stderr, "%s migrate failed %d\n", path, ret); + goto out; + } else if (param->verbose & VERBOSE_DETAIL) { + fprintf(stdout, "migrate %s to MDT%d\n", path, param->mdtindex); + } + +out: + if (dirp != NULL) { + /* If the directory is being migration, we need + * close the directory after migration, + * so the old directory cache will be cleanup + * on the client side, and re-open to get the + * new directory handle */ + *dirp = opendir(path); + if (dirp == NULL) { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: Failed to open '%s'", __func__, path); + return ret; + } + } + + if (parent == NULL) + closedir(dir); + + return ret; +} + +int llapi_mv(char *path, struct find_param *param) +{ + return param_callback(path, cb_mv_init, cb_common_fini, param); } int llapi_find(char *path, struct find_param *param) @@ -1954,15 +3185,16 @@ int llapi_find(char *path, struct find_param *param) */ int llapi_file_fget_mdtidx(int fd, int *mdtidx) { - if (ioctl(fd, LL_IOC_GET_MDTIDX, &mdtidx) < 0) + if (ioctl(fd, LL_IOC_GET_MDTIDX, mdtidx) < 0) return -errno; return 0; } -static int cb_get_mdt_index(char *path, DIR *parent, DIR *d, void *data, - cfs_dirent_t *de) +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; + DIR *d = dirp == NULL ? NULL : *dirp; int ret = 0; int mdtidx; @@ -1978,52 +3210,60 @@ static int cb_get_mdt_index(char *path, DIR *parent, DIR *d, void *data, ret = llapi_file_fget_mdtidx(fd, &mdtidx); close(fd); } else { - ret = fd; + ret = -errno; } } if (ret) { - if (errno == ENODATA) { + if (ret == -ENODATA) { if (!param->obduuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; - } else if (errno == ENOTTY) { - llapi_err(LLAPI_MSG_ERROR, - "%s: '%s' not on a Lustre fs?", - __func__, path); - } else if (errno == ENOENT) { - llapi_err(LLAPI_MSG_WARN, - "warning: %s: %s does not exist", - __func__, path); + } 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_err(LLAPI_MSG_ERROR, - "error: %s: LL_IOC_GET_MDTIDX failed for %s", - __func__, path); + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: LL_IOC_GET_MDTIDX failed for %s", + __func__, path); } return ret; } - if (param->quiet) + /* 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 - llapi_printf(LLAPI_MSG_NORMAL, "%s MDT index: %d\n", + /* coverity[uninit_use_in_call] */ + llapi_printf(LLAPI_MSG_NORMAL, "%s\nmdt_index:\t%d\n", path, mdtidx); out: - /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + /* Do not get down anymore? */ + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; } -static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, - cfs_dirent_t *de) +static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data, + struct dirent64 *de) { struct find_param *param = (struct find_param *)data; + DIR *d = dirp == NULL ? NULL : *dirp; int ret = 0; LASSERT(parent != NULL || d != NULL); @@ -2035,59 +3275,112 @@ static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, return ret; } - if (d) { - ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE, - (void *)¶m->lmd->lmd_lmm); - } else if (parent) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); + if (d) { + if (param->get_lmv || param->get_default_lmv) { + ret = cb_get_dirstripe(path, d, param); + } else { + ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE, + (void *)¶m->lmd->lmd_lmm); + } - strncpy((char *)¶m->lmd->lmd_lmm, fname, param->lumlen); + } else if (parent) { + char *fname = strrchr(path, '/'); + fname = (fname == NULL ? path : fname + 1); - ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, - (void *)¶m->lmd->lmd_lmm); - } + if (param->get_lmv) { + llapi_printf(LLAPI_MSG_NORMAL, + "%s get dirstripe information for file\n", + path); + goto out; + } + + strncpy((char *)¶m->lmd->lmd_lmm, fname, param->lumlen); + + ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE, + (void *)¶m->lmd->lmd_lmm); + } if (ret) { - if (errno == ENODATA) { - if (!param->obduuid) + if (errno == ENODATA && d != NULL) { + /* We need to "fake" the "use the default" values + * since the lmm struct is zeroed out at this point. + * The magic needs to be set in order to satisfy + * 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) { + 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) { + struct lmv_user_md *lum = param->fp_lmv_md; + int mdtidx; + + ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx); + if (ret != 0) + goto err_out; + lum->lum_magic = LMV_MAGIC_V1; + lum->lum_stripe_count = 0; + lum->lum_stripe_offset = mdtidx; + goto dump; + } else { + struct lov_user_md *lmm = ¶m->lmd->lmd_lmm; + lmm->lmm_magic = LOV_USER_MAGIC_V1; + if (!param->raw) + ostid_set_seq(&lmm->lmm_oi, + FID_SEQ_LOV_DEFAULT); + lmm->lmm_stripe_count = 0; + lmm->lmm_stripe_size = 0; + lmm->lmm_stripe_offset = -1; + goto dump; + } + } else if (errno == ENODATA && parent != NULL) { + if (!param->obduuid && !param->mdtuuid) llapi_printf(LLAPI_MSG_NORMAL, "%s has no stripe info\n", path); goto out; - } else if (errno == ENOTTY) { - llapi_err(LLAPI_MSG_ERROR, - "%s: '%s' not on a Lustre fs?", - __func__, path); } else if (errno == ENOENT) { - llapi_err(LLAPI_MSG_WARN, - "warning: %s: %s does not exist", - __func__, path); + llapi_error(LLAPI_MSG_WARN, -ENOENT, + "warning: %s: %s does not exist", + __func__, path); goto out; + } else if (errno == ENOTTY) { + ret = -errno; + llapi_error(LLAPI_MSG_ERROR, ret, + "%s: '%s' not on a Lustre fs?", + __func__, path); } else { - llapi_err(LLAPI_MSG_ERROR, - "error: %s: %s failed for %s", - __func__, d ? "LL_IOC_LOV_GETSTRIPE" : - "IOC_MDC_GETFILESTRIPE", path); - } + ret = -errno; +err_out: + llapi_error(LLAPI_MSG_ERROR, ret, + "error: %s: %s failed for %s", + __func__, d ? "LL_IOC_LOV_GETSTRIPE" : + "IOC_MDC_GETFILESTRIPE", path); + } return ret; } - if (!param->get_mdt_index) +dump: + if (!(param->verbose & VERBOSE_MDTINDEX)) llapi_lov_dump_user_lmm(param, path, d ? 1 : 0); out: - /* Do not get down anymore? */ - if (param->depth == param->maxdepth) - return 1; + /* Do not get down anymore? */ + if (param->fp_depth == param->fp_max_depth) + return 1; - param->depth++; - return 0; + param->fp_depth++; + + return 0; } int llapi_getstripe(char *path, struct find_param *param) { - return param_callback(path, param->get_mdt_index ? + return param_callback(path, (param->verbose & VERBOSE_MDTINDEX) ? cb_get_mdt_index : cb_getstripe, cb_common_fini, param); } @@ -2111,9 +3404,10 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, data.ioc_pbuf2 = (char *)uuid_buf; data.ioc_plen2 = sizeof(struct obd_uuid); - if ((rc = obd_ioctl_pack(&data, &rawbuf, sizeof(raw))) != 0) { - llapi_err(LLAPI_MSG_ERROR, - "llapi_obd_statfs: error packing ioctl data"); + rc = obd_ioctl_pack(&data, &rawbuf, sizeof(raw)); + if (rc != 0) { + llapi_error(LLAPI_MSG_ERROR, rc, + "llapi_obd_statfs: error packing ioctl data"); return rc; } @@ -2121,22 +3415,23 @@ int llapi_obd_statfs(char *path, __u32 type, __u32 index, if (errno == EISDIR) fd = open(path, O_DIRECTORY | O_RDONLY); - if (fd < 0) { - rc = errno ? -errno : -EBADF; - llapi_err(LLAPI_MSG_ERROR, "error: %s: opening '%s'", - __func__, path); - return rc; - } - rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf); - if (rc) - rc = errno ? -errno : -EINVAL; - - close(fd); - return rc; + if (fd < 0) { + rc = errno ? -errno : -EBADF; + llapi_error(LLAPI_MSG_ERROR, rc, "error: %s: opening '%s'", + __func__, path); + /* If we can't even open a file on the filesystem (e.g. with + * -ESHUTDOWN), force caller to exit or it will loop forever. */ + return -ENODEV; + } + rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf); + if (rc) + rc = errno ? -errno : -EINVAL; + + close(fd); + return rc; } #define MAX_STRING_SIZE 128 -#define DEVICES_LIST "/proc/fs/lustre/devices" int llapi_ping(char *obd_type, char *obd_name) { @@ -2149,12 +3444,16 @@ int llapi_ping(char *obd_type, char *obd_name) fd = open(path, O_WRONLY); if (fd < 0) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "error opening %s", path); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path); return rc; } + /* The purpose is to send a byte as a ping, whatever this byte is. */ + /* coverity[uninit_use_in_call] */ rc = write(fd, buf, 1); + if (rc < 0) + rc = -errno; close(fd); if (rc == 1) @@ -2162,15 +3461,16 @@ int llapi_ping(char *obd_type, char *obd_name) return rc; } -int llapi_target_iterate(int type_num, char **obd_type,void *args,llapi_cb_t cb) +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; if (fp == NULL) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "error: opening "DEVICES_LIST); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST); return rc; } @@ -2179,7 +3479,6 @@ int llapi_target_iterate(int type_num, char **obd_type,void *args,llapi_cb_t cb) char *obd_name = NULL; char *obd_uuid = NULL; char *bufp = buf; - struct obd_ioctl_data datal = { 0, }; struct obd_statfs osfs_buffer; while(bufp[0] == ' ') @@ -2193,9 +3492,6 @@ int llapi_target_iterate(int type_num, char **obd_type,void *args,llapi_cb_t cb) memset(&osfs_buffer, 0, sizeof (osfs_buffer)); - datal.ioc_pbuf1 = (char *)&osfs_buffer; - datal.ioc_plen1 = sizeof(osfs_buffer); - for (i = 0; i < type_num; i++) { if (strcmp(obd_type_name, obd_type[i]) != 0) continue; @@ -2204,7 +3500,7 @@ int llapi_target_iterate(int type_num, char **obd_type,void *args,llapi_cb_t cb) } } fclose(fp); - return rc; + return 0; } static void do_target_check(char *obd_type_name, char *obd_name, @@ -2216,7 +3512,7 @@ static void do_target_check(char *obd_type_name, char *obd_name, if (rc == ENOTCONN) { llapi_printf(LLAPI_MSG_NORMAL, "%s inactive.\n", obd_name); } else if (rc) { - llapi_err(LLAPI_MSG_ERROR, "error: check '%s'", obd_name); + llapi_error(LLAPI_MSG_ERROR, rc, "error: check '%s'", obd_name); } else { llapi_printf(LLAPI_MSG_NORMAL, "%s active.\n", obd_name); } @@ -2229,48 +3525,6 @@ int llapi_target_check(int type_num, char **obd_type, char *dir) #undef MAX_STRING_SIZE -int llapi_catinfo(char *dir, char *keyword, char *node_name) -{ - char raw[OBD_MAX_IOCTL_BUFFER]; - char out[LLOG_CHUNK_SIZE]; - char *buf = raw; - struct obd_ioctl_data data = { 0 }; - char key[30]; - DIR *root; - int rc; - - sprintf(key, "%s", keyword); - memset(raw, 0, sizeof(raw)); - memset(out, 0, sizeof(out)); - data.ioc_inlbuf1 = key; - data.ioc_inllen1 = strlen(key) + 1; - if (node_name) { - data.ioc_inlbuf2 = node_name; - data.ioc_inllen2 = strlen(node_name) + 1; - } - data.ioc_pbuf1 = out; - data.ioc_plen1 = sizeof(out); - rc = obd_ioctl_pack(&data, &buf, sizeof(raw)); - if (rc) - return rc; - - root = opendir(dir); - if (root == NULL) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "open %s failed", dir); - return rc; - } - - rc = ioctl(dirfd(root), OBD_IOC_LLOG_CATINFO, buf); - if (rc) - llapi_err(LLAPI_MSG_ERROR, "ioctl OBD_IOC_CATINFO failed"); - else - llapi_printf(LLAPI_MSG_NORMAL, "%s", data.ioc_pbuf1); - - closedir(root); - return rc; -} - /* Is this a lustre fs? */ int llapi_is_lustre_mnttype(const char *type) { @@ -2291,11 +3545,14 @@ int llapi_quotacheck(char *mnt, int check_type) root = opendir(mnt); if (!root) { - llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; } - rc = ioctl(dirfd(root), LL_IOC_QUOTACHECK, check_type); + rc = ioctl(dirfd(root), OBD_IOC_QUOTACHECK, check_type); + if (rc < 0) + rc = -errno; closedir(root); return rc; @@ -2309,12 +3566,13 @@ int llapi_poll_quotacheck(char *mnt, struct if_quotacheck *qchk) root = opendir(mnt); if (!root) { - llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; } while (1) { - rc = ioctl(dirfd(root), LL_IOC_POLL_QUOTACHECK, qchk); + rc = ioctl(dirfd(root), OBD_IOC_POLL_QUOTACHECK, qchk); if (!rc) break; sleep(poll_intvl); @@ -2323,7 +3581,7 @@ int llapi_poll_quotacheck(char *mnt, struct if_quotacheck *qchk) } closedir(root); - return rc; + return 0; } int llapi_quotactl(char *mnt, struct if_quotactl *qctl) @@ -2333,55 +3591,38 @@ int llapi_quotactl(char *mnt, struct if_quotactl *qctl) root = opendir(mnt); if (!root) { - llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; } - rc = ioctl(dirfd(root), LL_IOC_QUOTACTL, qctl); + 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 *d, void *data, - cfs_dirent_t *de) +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); - if (d) { - rc = ioctl(dirfd(d), LL_IOC_MDC_GETINFO, - (void *)param->lmd); - } else if (parent) { - char *fname = strrchr(path, '/'); - fname = (fname == NULL ? path : fname + 1); - - strncpy((char *)param->lmd, fname, param->lumlen); - rc = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, - (void *)param->lmd); - } else { - return 0; - } - + rc = get_lmd_info(path, parent, d, param->lmd, param->lumlen); if (rc) { - if (errno == ENODATA) { + if (rc == -ENODATA) { if (!param->obduuid && !param->quiet) - llapi_err(LLAPI_MSG_ERROR, + llapi_error(LLAPI_MSG_ERROR, -ENODATA, "%s has no stripe info", path); rc = 0; - } else if (errno == ENOENT) { - llapi_err(LLAPI_MSG_ERROR, - "warning: %s: %s does not exist", - __func__, path); + } else if (rc == -ENOENT) { rc = 0; - } else if (errno != EISDIR) { - rc = errno; - llapi_err(LLAPI_MSG_ERROR, "%s ioctl failed for %s.", - d ? "LL_IOC_MDC_GETINFO" : - "IOC_MDC_GETFILEINFO", path); } return rc; } @@ -2393,12 +3634,15 @@ static int cb_quotachown(char *path, DIR *parent, DIR *d, void *data, * invoke syscall directly. */ rc = syscall(SYS_chown, path, -1, -1); if (rc) - llapi_err(LLAPI_MSG_ERROR,"error: chown %s (%u,%u)", path); + llapi_error(LLAPI_MSG_ERROR, errno, + "error: chown %s", path); rc = chmod(path, st->st_mode); - if (rc) - llapi_err(LLAPI_MSG_ERROR, "error: chmod %s (%hu)", - path, st->st_mode); + if (rc) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "error: chmod %s (%hu)", + path, st->st_mode); + } return rc; } @@ -2426,12 +3670,14 @@ static int rmtacl_notify(int ops) { FILE *fp; struct mntent *mnt; - int found = 0, fd, rc; + int found = 0, fd = 0, rc = 0; fp = setmntent(MOUNTED, "r"); if (fp == NULL) { - perror("setmntent"); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error setmntent(%s)", MOUNTED); + return rc; } while (1) { @@ -2439,25 +3685,33 @@ static int rmtacl_notify(int ops) if (!mnt) break; - if (!llapi_is_lustre_mnt(mnt)) + if (!llapi_is_lustre_mnt(mnt)) continue; fd = open(mnt->mnt_dir, O_RDONLY | O_DIRECTORY); if (fd < 0) { - perror("open"); - return -1; + 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) { - perror("ioctl"); - return -1; + 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 found; + return ((rc != 0) ? rc : found); } static char *next_token(char *p, int div) @@ -2480,14 +3734,16 @@ static int rmtacl_name2id(char *name, int is_user) if (is_user) { struct passwd *pw; - if ((pw = getpwnam(name)) == NULL) + pw = getpwnam(name); + if (pw == NULL) return INVALID_ID; else return (int)(pw->pw_uid); } else { struct group *gr; - if ((gr = getgrnam(name)) == NULL) + gr = getgrnam(name); + if (gr == NULL) return INVALID_ID; else return (int)(gr->gr_gid); @@ -2603,29 +3859,34 @@ static int child_status(int status) static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) { pid_t pid = 0; - int fd[2], status; + int fd[2], status, rc; FILE *fp; char buf[PIPE_BUF]; if (output_func) { if (pipe(fd) < 0) { - perror("pipe"); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "Can't create pipe\n"); + return rc; } - if ((pid = fork()) < 0) { - perror("fork"); + pid = fork(); + if (pid < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "Can't fork\n"); close(fd[0]); close(fd[1]); - return -1; + return rc; } else if (!pid) { /* child process redirects its output. */ close(fd[0]); close(1); if (dup2(fd[1], 1) < 0) { - perror("dup2"); + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "Can't dup2 %d\n", fd[1]); close(fd[1]); - return -1; + return rc; } } else { close(fd[1]); @@ -2635,17 +3896,19 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) if (!pid) { status = rmtacl_notify(ops); if (status < 0) - return -1; + return -errno; exit(execvp(argv[0], argv)); } /* the following is parent process */ - if ((fp = fdopen(fd[0], "r")) == NULL) { - perror("fdopen"); + 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 -1; + return rc; } while (fgets(buf, PIPE_BUF, fp) != NULL) { @@ -2657,8 +3920,9 @@ static int do_rmtacl(int argc, char *argv[], int ops, int (output_func)(char *)) close(fd[0]); if (waitpid(pid, &status, 0) < 0) { - perror("waitpid"); - return -1; + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "waitpid %d failed\n", pid); + return rc; } return child_status(status); @@ -2690,7 +3954,7 @@ int llapi_cp(int argc, char *argv[]) rc = rmtacl_notify(RMT_RSETFACL); if (rc < 0) - return -1; + return rc; exit(execvp(argv[0], argv)); } @@ -2701,13 +3965,15 @@ int llapi_ls(int argc, char *argv[]) rc = rmtacl_notify(RMT_LGETFACL); if (rc < 0) - return -1; + return rc; exit(execvp(argv[0], argv)); } /* Print mdtname 'name' into 'buf' using 'format'. Add -MDT0000 if needed. * format must have %s%s, buf must be > 16 + * Eg: if name = "lustre-MDT0000", "lustre", or "lustre-MDT0000_UUID" + * then buf = "lustre-MDT0000" */ static int get_mdtname(char *name, char *format, char *buf) { @@ -2724,8 +3990,8 @@ static int get_mdtname(char *name, char *format, char *buf) suffix[0] = '\0'; } else { /* Not enough room to add suffix */ - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "MDT name too long |%s|", name); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "MDT name too long |%s|", name); return -EINVAL; } } @@ -2733,12 +3999,76 @@ static int get_mdtname(char *name, char *format, char *buf) return sprintf(buf, format, name, suffix); } +/** ioctl on filsystem root, with mdtindex sent as data + * \param mdtname path, fsname, or mdtname (lutre-MDT0004) + * \param mdtidxp pointer to integer within data to be filled in with the + * mdt index (0 if no mdt is specified). NULL won't be filled. + */ +int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp, + int want_error) +{ + char fsname[20]; + char *ptr; + int fd, rc; + long index; + + /* Take path, fsname, or MDTname. Assume MDT0000 in the former cases. + Open root and parse mdt index. */ + if (mdtname[0] == '/') { + index = 0; + rc = get_root_path(WANT_FD | want_error, NULL, &fd, + (char *)mdtname, -1); + } else { + if (get_mdtname((char *)mdtname, "%s%s", fsname) < 0) + return -EINVAL; + ptr = fsname + strlen(fsname) - 8; + *ptr = '\0'; + index = strtol(ptr + 4, NULL, 10); + rc = get_root_path(WANT_FD | want_error, fsname, &fd, NULL, -1); + } + if (rc < 0) { + if (want_error) + llapi_err_noerrno(LLAPI_MSG_ERROR, + "Can't open %s: %d\n", mdtname, rc); + return rc; + } + + if (mdtidxp) + *mdtidxp = index; + + rc = ioctl(fd, opc, data); + if (rc == -1) + rc = -errno; + else + rc = 0; + if (rc && want_error) + llapi_error(LLAPI_MSG_ERROR, rc, "ioctl %d err %d", opc, rc); + + close(fd); + return rc; +} + /****** Changelog API ********/ + +static int changelog_ioctl(const char *mdtname, int opc, int id, + long long recno, int flags) +{ + struct ioc_changelog data; + int *idx; + + data.icc_id = id; + data.icc_recno = recno; + data.icc_flags = flags; + idx = (int *)(&data.icc_mdtindex); + + return root_ioctl(mdtname, opc, &data, idx, WANT_ERROR); +} + #define CHANGELOG_PRIV_MAGIC 0xCA8E1080 struct changelog_private { int magic; int flags; - lustre_netlink lnl; + lustre_kernelcomm kuc; }; /** Start reading from a changelog @@ -2752,75 +4082,39 @@ int llapi_changelog_start(void **priv, int flags, const char *device, long long startrec) { struct changelog_private *cp; - struct changelog_show cs = {}; - char mdtname[20]; - char pattern[PATH_MAX]; - char trigger[PATH_MAX]; - int fd, rc, pid; - - /* Find mdtname from path, fsname, mdtname, or mdtname_UUID */ - if (device[0] == '/') { - if ((rc = llapi_search_fsname(device, mdtname))) - return rc; - if ((rc = get_mdtname(mdtname, "%s%s", mdtname)) < 0) - return rc; - } else { - if ((rc = get_mdtname((char *)device, "%s%s", mdtname)) < 0) - return rc; - } - - /* Find corresponding mdc trigger */ - snprintf(pattern, PATH_MAX, - "/proc/fs/lustre/mdc/%s-*/changelog_trigger", mdtname); - rc = first_match(pattern, trigger); - if (rc) - return rc; - - /* Make sure we can write the trigger */ - fd = open(trigger, O_WRONLY); - if (fd < 0) - return -errno; + int rc; /* Set up the receiver control struct */ - cp = malloc(sizeof(*cp)); - if (cp == NULL) { - close(fd); + cp = calloc(1, sizeof(*cp)); + if (cp == NULL) return -ENOMEM; - } cp->magic = CHANGELOG_PRIV_MAGIC; cp->flags = flags; - /* Start the receiver */ - rc = libcfs_ulnl_start(&cp->lnl, 0 /* unicast */); + + /* Set up the receiver */ + rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */); if (rc < 0) goto out_free; - /* We need to trigger Lustre to start sending messages now. - We could send a lnl message to a kernel listener, - or write into proc. Proc has the advantage of running in this - context, avoiding the need for a kernel thread. */ - cs.cs_pid = getpid(); - cs.cs_startrec = startrec; - cs.cs_flags = flags & CHANGELOG_FLAG_BLOCK ? LNL_FL_BLOCK : 0; - if ((pid = fork()) < 0) { - goto out_free; - } else if (!pid) { - /* Write triggers Lustre to start sending, but it - won't return until it is complete, meaning everything - got shipped through lnl (or error). So we trigger it - from a child process here, allowing the llapi call to - return and wait for the lnl messages. */ - rc = write(fd, &cs, sizeof(cs)); - exit(rc); + *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; } - close(fd); - *priv = cp; return 0; out_free: free(cp); - close(fd); return rc; } @@ -2832,12 +4126,30 @@ int llapi_changelog_fini(void **priv) if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) return -EINVAL; - libcfs_ulnl_stop(&cp->lnl); + libcfs_ukuc_stop(&cp->kuc); free(cp); *priv = NULL; 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. + */ +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 @@ -2845,34 +4157,38 @@ int llapi_changelog_fini(void **priv) * <0 error code * 1 EOF */ -int llapi_changelog_recv(void *priv, struct changelog_rec **rech) +int llapi_changelog_recv(void *priv, struct changelog_ext_rec **rech) { - struct changelog_private *cp = (struct changelog_private *)priv; - struct lnl_hdr *lnlh; - int rc = 0; - - if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) - return -EINVAL; - if (rech == NULL) - return -EINVAL; + struct changelog_private *cp = (struct changelog_private *)priv; + struct kuc_hdr *kuch; + int rc = 0; + + if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC)) + return -EINVAL; + if (rech == NULL) + return -EINVAL; + kuch = malloc(KUC_CHANGELOG_MSG_MAXSIZE); + if (kuch == NULL) + return -ENOMEM; repeat: - rc = libcfs_ulnl_msg_get(&cp->lnl, CR_MAXSIZE, LNL_TRANSPORT_CHANGELOG, - &lnlh); - if (rc < 0) - return rc; - - if ((lnlh->lnl_transport != LNL_TRANSPORT_CHANGELOG) || - ((lnlh->lnl_msgtype != CL_RECORD) && - (lnlh->lnl_msgtype != CL_EOF))) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "Unknown changelog message type %d:%d\n", - lnlh->lnl_transport, lnlh->lnl_msgtype); + rc = libcfs_ukuc_msg_get(&cp->kuc, (char *)kuch, + KUC_CHANGELOG_MSG_MAXSIZE, + KUC_TRANSPORT_CHANGELOG); + if (rc < 0) + goto out_free; + + if ((kuch->kuc_transport != KUC_TRANSPORT_CHANGELOG) || + ((kuch->kuc_msgtype != CL_RECORD) && + (kuch->kuc_msgtype != CL_EOF))) { + llapi_err_noerrno(LLAPI_MSG_ERROR, + "Unknown changelog message type %d:%d\n", + kuch->kuc_transport, kuch->kuc_msgtype); rc = -EPROTO; goto out_free; } - if (lnlh->lnl_msgtype == CL_EOF) { + if (kuch->kuc_msgtype == CL_EOF) { if (cp->flags & CHANGELOG_FLAG_FOLLOW) { /* Ignore EOFs */ goto repeat; @@ -2882,23 +4198,30 @@ repeat: } } - /* Our message is a changelog_rec */ - *rech = (struct changelog_rec *)(lnlh + 1); + /* 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); return 0; out_free: - libcfs_ulnl_msg_free(&lnlh); *rech = NULL; + free(kuch); return rc; } /** Release the changelog record when done with it. */ -int llapi_changelog_free(struct changelog_rec **rech) +int llapi_changelog_free(struct changelog_ext_rec **rech) { if (*rech) { - struct lnl_hdr *lnlh = (struct lnl_hdr *)*rech - 1; - libcfs_ulnl_msg_free(&lnlh); + /* We allocated memory starting at the kuc_hdr, but passed + * the consumer a pointer to the payload. + * Use pointer math to get back to the header. + */ + struct kuc_hdr *kuch = (struct kuc_hdr *)*rech - 1; + free(kuch); } *rech = NULL; return 0; @@ -2907,97 +4230,58 @@ int llapi_changelog_free(struct changelog_rec **rech) int llapi_changelog_clear(const char *mdtname, const char *idstr, long long endrec) { - struct ioc_changelog_clear data; - char fsname[17]; - char *ptr; - int id, fd, index, rc; + long id; if (endrec < 0) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "can't purge negative records\n"); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "can't purge negative records\n"); return -EINVAL; } id = strtol(idstr + strlen(CHANGELOG_USER_PREFIX), NULL, 10); if ((id == 0) || (strncmp(idstr, CHANGELOG_USER_PREFIX, strlen(CHANGELOG_USER_PREFIX)) != 0)) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "expecting id of the form '"CHANGELOG_USER_PREFIX - "'; got '%s'\n", idstr); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "expecting id of the form '" + CHANGELOG_USER_PREFIX + "'; got '%s'\n", idstr); return -EINVAL; } - /* Take path, fsname, or MDTNAME. Assume MDT0000 in the former cases */ - if (mdtname[0] == '/') { - index = 0; - fd = open(mdtname, O_RDONLY | O_DIRECTORY | O_NONBLOCK); - rc = fd < 0 ? -errno : 0; - } else { - if (get_mdtname((char *)mdtname, "%s%s", fsname) < 0) - return -EINVAL; - ptr = fsname + strlen(fsname) - 8; - *ptr = '\0'; - index = strtol(ptr + 4, NULL, 10); - rc = get_root_path(WANT_FD | WANT_ERROR, fsname, &fd, NULL, -1); - } - if (rc < 0) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "Can't open %s: %d\n", mdtname, rc); - return rc; - } - - data.icc_mdtindex = index; - data.icc_id = id; - data.icc_recno = endrec; - rc = ioctl(fd, OBD_IOC_CHANGELOG_CLEAR, &data); - if (rc) - llapi_err(LLAPI_MSG_ERROR, "ioctl err %d", rc); - - close(fd); - return rc; + return changelog_ioctl(mdtname, OBD_IOC_CHANGELOG_CLEAR, id, endrec, 0); } int llapi_fid2path(const char *device, const char *fidstr, char *buf, int buflen, long long *recno, int *linkno) { - char path[PATH_MAX]; struct lu_fid fid; struct getinfo_fid2path *gf; - int fd, rc; + int rc; while (*fidstr == '[') fidstr++; sscanf(fidstr, SFID, RFID(&fid)); if (!fid_is_sane(&fid)) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "bad FID format [%s], should be "DFID"\n", - fidstr, (__u64)1, 2, 0); + llapi_err_noerrno(LLAPI_MSG_ERROR, + "bad FID format [%s], should be "DFID"\n", + fidstr, (__u64)1, 2, 0); return -EINVAL; } - /* Take path or fsname */ - if (device[0] == '/') { - strcpy(path, device); - } else { - rc = get_root_path(WANT_PATH | WANT_ERROR, (char *)device, - NULL, path, -1); - if (rc < 0) - return rc; - } - sprintf(path, "%s/%s/fid/%s", path, dot_lustre_name, fidstr); - fd = open(path, O_RDONLY | O_NONBLOCK); - if (fd < 0) - return -errno; - 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; - rc = ioctl(fd, OBD_IOC_FID2PATH, gf); + + /* Take path or fsname */ + rc = root_ioctl(device, OBD_IOC_FID2PATH, gf, NULL, 0); if (rc) { - llapi_err(LLAPI_MSG_ERROR, "ioctl err %d", rc); + if (rc != -ENOENT) + llapi_error(LLAPI_MSG_ERROR, rc, "ioctl err %d", rc); } else { memcpy(buf, gf->gf_path, gf->gf_pathlen); *recno = gf->gf_recno; @@ -3005,187 +4289,257 @@ int llapi_fid2path(const char *device, const char *fidstr, char *buf, } free(gf); - close(fd); return rc; } -static int path2fid_from_lma(const char *path, lustre_fid *fid) +static int fid_from_lma(const char *path, const int fd, lustre_fid *fid) { - char buf[512]; - struct lustre_mdt_attrs *lma; - int rc; - - rc = lgetxattr(path, XATTR_NAME_LMA, buf, sizeof(buf)); - if (rc < 0) - return -errno; - lma = (struct lustre_mdt_attrs *)buf; - fid_le_to_cpu(fid, &lma->lma_self_fid); - return 0; + char buf[512]; + struct lustre_mdt_attrs *lma; + int rc; + + if (path == NULL) + rc = fgetxattr(fd, XATTR_NAME_LMA, buf, sizeof(buf)); + else + rc = lgetxattr(path, XATTR_NAME_LMA, buf, sizeof(buf)); + if (rc < 0) + return -errno; + lma = (struct lustre_mdt_attrs *)buf; + fid_le_to_cpu(fid, &lma->lma_self_fid); + return 0; } -int llapi_path2fid(const char *path, lustre_fid *fid) +int llapi_fd2fid(const int fd, lustre_fid *fid) { - int fd, rc; + int rc; - memset(fid, 0, sizeof(*fid)); - fd = open(path, O_RDONLY | O_NONBLOCK | O_NOFOLLOW); - if (fd < 0) { - if (errno == ELOOP) /* symbolic link */ - return path2fid_from_lma(path, fid); - return -errno; - } + memset(fid, 0, sizeof(*fid)); - rc = ioctl(fd, LL_IOC_PATH2FID, fid) < 0 ? -errno : 0; - if (rc == -EINVAL) /* char special device */ - rc = path2fid_from_lma(path, fid); + rc = ioctl(fd, LL_IOC_PATH2FID, fid) < 0 ? -errno : 0; + if (rc == -EINVAL || rc == -ENOTTY) + rc = fid_from_lma(NULL, fd, fid); - close(fd); - return rc; + return rc; } -/****** HSM Copytool API ********/ -#define CT_PRIV_MAGIC 0xC0BE2001 -struct copytool_private { - int magic; - lustre_netlink lnl; - int archive_num_count; - int archive_nums[0]; -}; - -#include +int llapi_path2fid(const char *path, lustre_fid *fid) +{ + int fd, rc; + + memset(fid, 0, sizeof(*fid)); + fd = open(path, O_RDONLY | O_NONBLOCK | O_NOFOLLOW); + if (fd < 0) { + if (errno == ELOOP || errno == ENXIO) + return fid_from_lma(path, -1, fid); + return -errno; + } + + rc = llapi_fd2fid(fd, fid); + if (rc == -EINVAL || rc == -ENOTTY) + rc = fid_from_lma(path, -1, fid); + + close(fd); + return rc; +} -/** Register a copytool - * @param priv Opaque private control structure - * @param flags Open flags, currently unused (e.g. O_NONBLOCK) - * @param archive_num_count - * @param archive_nums Which archive numbers this copytool is responsible for - */ -int llapi_copytool_start(void **priv, int flags, int archive_num_count, - int *archive_nums) +int llapi_get_connect_flags(const char *mnt, __u64 *flags) { - struct copytool_private *ct; + DIR *root; int rc; - if (archive_num_count > 0 && archive_nums == NULL) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "NULL archive numbers"); - return -EINVAL; + root = opendir(mnt); + if (!root) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, "open %s failed", mnt); + return rc; } - ct = malloc(sizeof(*ct) + - archive_num_count * sizeof(ct->archive_nums[0])); - if (ct == NULL) - return -ENOMEM; - - ct->magic = CT_PRIV_MAGIC; - ct->archive_num_count = archive_num_count; - if (ct->archive_num_count > 0) - memcpy(ct->archive_nums, archive_nums, archive_num_count * - sizeof(ct->archive_nums[0])); - - rc = libcfs_ulnl_start(&ct->lnl, LNL_GRP_HSM); - if (rc < 0) - goto out_err; - - *priv = ct; - return 0; - -out_err: - free(ct); + 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; } -/** Deregister a copytool */ -int llapi_copytool_fini(void **priv) +int llapi_get_version(char *buffer, int buffer_size, + char **version) { - struct copytool_private *ct = (struct copytool_private *)*priv; + int rc; + int fd; + struct obd_ioctl_data *data = (struct obd_ioctl_data *)buffer; - if (!ct || (ct->magic != CT_PRIV_MAGIC)) - return -EINVAL; + fd = open(OBD_DEV_PATH, O_RDONLY); + if (fd == -1) + return -errno; - libcfs_ulnl_stop(&ct->lnl); - free(ct); - *priv = NULL; + 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 = ioctl(fd, OBD_GET_VERSION, buffer); + if (rc == -1) { + rc = -errno; + close(fd); + return rc; + } + close(fd); + *version = data->ioc_bulk; return 0; } -/** Wait for the next hsm_action_list - * @param priv Opaque private control structure - * @param halh Action list handle, will be allocated here - * @param msgsize Number of bytes in the message, will be set here - * @return 0 valid message received; halh and msgsize are set - * <0 error code +/** + * Get a 64-bit value representing the version of file data pointed by fd. + * + * Each write or truncate, flushed on OST, will change this value. You can use + * this value to verify if file data was modified. This only checks the file + * data, not metadata. + * + * \param flags 0: no flush pages, usually used it the process has already + * taken locks; + * LL_DV_RD_FLUSH: OSTs will take LCK_PR to flush dirty pages + * from clients; + * LL_DV_WR_FLUSH: OSTs will take LCK_PW to flush all caching + * pages from clients. + * + * \retval 0 on success. + * \retval -errno on error. */ -int llapi_copytool_recv(void *priv, struct hsm_action_list **halh, int *msgsize) +int llapi_get_data_version(int fd, __u64 *data_version, __u64 flags) { - struct copytool_private *ct = (struct copytool_private *)priv; - struct lnl_hdr *lnlh; - struct hsm_action_list *hal; - int rc = 0; - - if (!ct || (ct->magic != CT_PRIV_MAGIC)) - return -EINVAL; - if (halh == NULL || msgsize == NULL) - return -EINVAL; - - rc = libcfs_ulnl_msg_get(&ct->lnl, HAL_MAXSIZE, - LNL_TRANSPORT_HSM, &lnlh); - if (rc < 0) - return rc; - - /* Handle generic messages */ - if (lnlh->lnl_transport == LNL_TRANSPORT_GENERIC && - lnlh->lnl_msgtype == LNL_MSG_SHUTDOWN) { - rc = -ESHUTDOWN; - goto out_free; - } - - if (lnlh->lnl_transport != LNL_TRANSPORT_HSM || - lnlh->lnl_msgtype != HMT_ACTION_LIST) { - llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO, - "Unknown HSM message type %d:%d\n", - lnlh->lnl_transport, lnlh->lnl_msgtype); - rc = -EPROTO; - goto out_free; - } - - /* Our message is an hsm_action_list */ - - hal = (struct hsm_action_list *)(lnlh + 1); + int rc; + struct ioc_data_version idv; - /* Check that we have registered for this archive # */ - for (rc = 0; rc < ct->archive_num_count; rc++) { - if (hal->hal_archive_num == ct->archive_nums[rc]) - break; - } - if (rc >= ct->archive_num_count) { - CDEBUG(D_INFO, "This copytool does not service archive #%d, " - "ignoring this request.\n", hal->hal_archive_num); - rc = 0; - goto out_free; - } + idv.idv_flags = flags; - *halh = hal; - *msgsize = lnlh->lnl_msglen - sizeof(*lnlh); - return 0; + rc = ioctl(fd, LL_IOC_DATA_VERSION, &idv); + if (rc) + rc = -errno; + else + *data_version = idv.idv_version; -out_free: - libcfs_ulnl_msg_free(&lnlh); - *halh = NULL; - *msgsize = 0; return rc; } -/** Release the action list when done with it. */ -int llapi_copytool_free(struct hsm_action_list **hal) +/* + * Create a volatile file and open it for write: + * - file is created as a standard file in the directory + * - file does not appears in directory and directory mtime does not change + * - file is removed at close + * - file modes are rw-------, if user wants another one it must use fchmod() + * \param directory Directory where the file is created + * \param idx MDT index on which the file is created + * \param open_flags Standard open flags + * + * \retval 0 on success. + * \retval -errno on error. + */ +int llapi_create_volatile_idx(char *directory, int idx, int open_flags) { - if (*hal) { - struct lnl_hdr *lnlh = (struct lnl_hdr *)*hal - 1; - libcfs_ulnl_msg_free(&lnlh); - } - *hal = NULL; - return 0; + char file_path[PATH_MAX]; + char filename[PATH_MAX]; + int fd; + int random; + 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); + + 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 | open_flags, S_IRUSR | S_IWUSR); + if (fd < 0) { + llapi_error(LLAPI_MSG_ERROR, errno, + "Cannot create volatile file %s in %s\n", + filename + LUSTRE_VOLATILE_HDR_LEN, + directory); + return -errno; + } + return fd; } +/** + * Swap the layouts between 2 file descriptors + * the 2 files must be open in write + * 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) +{ + struct lustre_swap_layouts lsl; + int rc; + + srandom(time(NULL)); + lsl.sl_fd = fd2; + lsl.sl_flags = flags; + lsl.sl_gid = random(); + lsl.sl_dv1 = dv1; + lsl.sl_dv2 = dv2; + rc = ioctl(fd1, LL_IOC_LOV_SWAP_LAYOUTS, &lsl); + if (rc) + rc = -errno; + return rc; +} - +/** + * Swap the layouts between 2 files + * the 2 files are open in write + */ +int llapi_swap_layouts(const char *path1, const char *path2, + __u64 dv1, __u64 dv2, __u64 flags) +{ + int fd1, fd2, rc; + + fd1 = open(path1, O_WRONLY | O_LOV_DELAY_CREATE); + if (fd1 < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error: cannot open '%s' for write", path1); + goto out; + } + + fd2 = open(path2, O_WRONLY | O_LOV_DELAY_CREATE); + if (fd2 < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "error: cannot open '%s' for write", path2); + goto out_close; + } + + rc = llapi_fswap_layouts(fd1, fd2, dv1, dv2, flags); + if (rc < 0) + llapi_error(LLAPI_MSG_ERROR, rc, + "error: cannot swap layout between '%s' and '%s'\n", + path1, path2); + + close(fd2); +out_close: + close(fd1); +out: + return rc; +}