#endif
#include <poll.h>
-#include <liblustre.h>
+#include <libcfs/libcfs.h>
#include <lnet/lnetctl.h>
-#include <obd.h>
-#include <obd_lov.h>
#include <lustre/lustreapi.h>
+#include <lustre_ioctl.h>
#include "lustreapi_internal.h"
-static unsigned llapi_dir_filetype_table[] = {
- [DT_UNKNOWN]= 0,
- [DT_FIFO]= S_IFIFO,
- [DT_CHR] = S_IFCHR,
- [DT_DIR] = S_IFDIR,
- [DT_BLK] = S_IFBLK,
- [DT_REG] = S_IFREG,
- [DT_LNK] = S_IFLNK,
- [DT_SOCK]= S_IFSOCK,
-#if defined(DT_DOOR) && defined(S_IFDOOR)
- [DT_DOOR]= S_IFDOOR,
-#endif
-};
-
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-static const int DT_MAX = DT_DOOR;
-#else
-static const int DT_MAX = DT_SOCK;
-#endif
-
-static unsigned llapi_filetype_dir_table[] = {
- [0]= DT_UNKNOWN,
- [S_IFIFO]= DT_FIFO,
- [S_IFCHR] = DT_CHR,
- [S_IFDIR] = DT_DIR,
- [S_IFBLK] = DT_BLK,
- [S_IFREG] = DT_REG,
- [S_IFLNK] = DT_LNK,
- [S_IFSOCK]= DT_SOCK,
-#if defined(DT_DOOR) && defined(S_IFDOOR)
- [S_IFDOOR]= DT_DOOR,
-#endif
-};
-
-#if defined(DT_DOOR) && defined(S_IFDOOR)
-static const int S_IFMAX = DT_DOOR;
-#else
-static const int S_IFMAX = DT_SOCK;
-#endif
-
-/* liblustreapi message level */
static int llapi_msg_level = LLAPI_MSG_MAX;
void llapi_msg_set_level(int level)
stripe_size, page_size);
return rc;
}
- if (stripe_offset < -1 || stripe_offset > MAX_OBD_DEVICES) {
+ if (stripe_offset < -1) {
rc = -EINVAL;
llapi_error(LLAPI_MSG_ERROR, rc, "error: bad stripe offset %d",
stripe_offset);
return 0;
}
+/*
+ * Trim a trailing newline from a string, if it exists.
+ */
+int llapi_chomp_string(char *buf)
+{
+ if (!buf || !*buf)
+ return 0;
+
+ while (buf[1])
+ buf++;
+
+ if (*buf != '\n')
+ return 0;
+
+ *buf = '\0';
+ return '\n';
+}
+
/**
* return a parameter string for a specific device type or mountpoint
*
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:
}
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) {
}
}
- 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;
return 0;
}
-/**
- * In DNE phase I, only stripe_offset will be used in this function.
- * stripe_count, stripe_pattern and pool_name will be supported later.
- */
+int llapi_dir_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, char *pool_name)
+ int stripe_count, int stripe_pattern,
+ const char *pool_name)
{
struct lmv_user_md lmu = { 0 };
struct obd_ioctl_data data = { 0 };
}
filename = basename(namepath);
- lmu.lum_type = LMV_STRIPE_TYPE;
dir = dirname(dirpath);
data.ioc_inlbuf1 = (char *)filename;
return rc;
}
-typedef int (semantic_func_t)(char *path, DIR *parent, DIR *d,
+typedef int (semantic_func_t)(char *path, DIR *parent, DIR **d,
void *data, struct dirent64 *de);
#define OBD_NOT_FOUND (-1)
param->got_uuids = 0;
param->obdindexes = NULL;
param->obdindex = OBD_NOT_FOUND;
- param->mdtindex = OBD_NOT_FOUND;
+ if (!param->migrate)
+ param->mdtindex = OBD_NOT_FOUND;
return 0;
}
free(param->fp_lmv_md);
}
-static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data,
+static int cb_common_fini(char *path, DIR *parent, DIR **dirp, void *data,
struct dirent64 *de)
{
- struct find_param *param = (struct find_param *)data;
- param->depth--;
- return 0;
+ struct find_param *param = data;
+ param->fp_depth--;
+
+ return 0;
}
/* set errno upon failure */
int ret = 0;
lmv->lum_stripe_count = param->fp_lmv_count;
- lmv->lum_magic = LMV_MAGIC_V1;
+ 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;
}
}
}
- if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de)))
- goto err;
+ if (sem_init && (ret = sem_init(path, parent ?: p, &d, data, de)))
+ goto err;
if (!d || (param->get_lmv && !param->recursive)) {
ret = 0;
ret = get_lmd_info(path, d, NULL, param->lmd,
param->lumlen);
- if (ret == 0) {
- dent->d_type =
- llapi_filetype_dir_table[st->st_mode &
- S_IFMT];
- }
+ if (ret == 0)
+ dent->d_type = IFTODT(st->st_mode);
+
if (ret == -ENOENT)
continue;
}
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);
ret = common_param_init(param, buf);
if (ret)
goto out;
- param->depth = 0;
+
+ param->fp_depth = 0;
ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, sem_init,
sem_fini, param, NULL);
struct lmv_user_mds_data *objects = lum->lum_objects;
char *prefix = lum->lum_magic == LMV_USER_MAGIC ? "(Default)" : "";
int i, obdstripe = 0;
+ char *separator = "";
if (obdindex != OBD_NOT_FOUND) {
for (i = 0; i < lum->lum_stripe_count; i++) {
verbose = VERBOSE_OBJID;
}
- if (lum->lum_magic == LMV_USER_MAGIC)
- verbose &= ~VERBOSE_OBJID;
-
if (depth && path && ((verbose != VERBOSE_OBJID)))
- llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path);
+ llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix, path);
if (verbose & VERBOSE_COUNT) {
+ llapi_printf(LLAPI_MSG_NORMAL, "%s", separator);
if (verbose & ~VERBOSE_COUNT)
llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_count: ");
- llapi_printf(LLAPI_MSG_NORMAL, "%u\n",
+ llapi_printf(LLAPI_MSG_NORMAL, "%u",
(int)lum->lum_stripe_count);
+ separator = "\n";
}
if (verbose & VERBOSE_OFFSET) {
+ llapi_printf(LLAPI_MSG_NORMAL, "%s", separator);
if (verbose & ~VERBOSE_OFFSET)
llapi_printf(LLAPI_MSG_NORMAL, "lmv_stripe_offset: ");
- llapi_printf(LLAPI_MSG_NORMAL, "%d\n",
+ llapi_printf(LLAPI_MSG_NORMAL, "%d",
(int)lum->lum_stripe_offset);
+ separator = "\n";
}
- if (verbose & VERBOSE_OBJID) {
- if ((obdstripe == 1))
+ if (verbose & VERBOSE_OBJID && lum->lum_magic != LMV_USER_MAGIC) {
+ llapi_printf(LLAPI_MSG_NORMAL, "%s", separator);
+ if (obdstripe == 1 && lum->lum_stripe_count > 0)
llapi_printf(LLAPI_MSG_NORMAL,
- "\tmdtidx\t\t FID[seq:oid:ver]\n");
+ "mdtidx\t\t FID[seq:oid:ver]\n");
for (i = 0; i < lum->lum_stripe_count; i++) {
int idx = objects[i].lum_mds;
struct lu_fid *fid = &objects[i].lum_fid;
if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx))
llapi_printf(LLAPI_MSG_NORMAL,
- "\t%6u\t\t "DFID"\t\t%s\n",
+ "%6u\t\t "DFID"\t\t%s\n",
idx, PFID(fid),
obdindex == idx ? " *" : "");
}
}
if ((verbose & VERBOSE_POOL) && (pool_name[0] != '\0')) {
+ llapi_printf(LLAPI_MSG_NORMAL, "%s", separator);
if (verbose & ~VERBOSE_POOL)
llapi_printf(LLAPI_MSG_NORMAL, "%slmv_pool: ",
prefix);
llapi_printf(LLAPI_MSG_NORMAL, "%s%c ", pool_name, ' ');
+ separator = "\n";
}
- llapi_printf(LLAPI_MSG_NORMAL, "\n");
+
+ if (!(verbose & VERBOSE_OBJID))
+ llapi_printf(LLAPI_MSG_NORMAL, "\n");
}
void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir)
{
__u32 magic;
- if (param->get_lmv)
+ if (param->get_lmv || param->get_default_lmv)
magic = (__u32)param->fp_lmv_md->lum_magic;
else
magic = *(__u32 *)¶m->lmd->lmd_lmm; /* lum->lmm_magic */
lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL,
param->lmd->lmd_lmm.lmm_objects,
path, is_dir,
- param->obdindex, param->maxdepth,
+ param->obdindex, param->fp_max_depth,
param->verbose, param->raw);
break;
case LOV_USER_MAGIC_V3: {
objects = lmmv3->lmm_objects;
lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name,
objects, path, is_dir,
- param->obdindex, param->maxdepth,
+ param->obdindex, param->fp_max_depth,
param->verbose, param->raw);
break;
}
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->maxdepth,
+ param->obdindex, param->fp_max_depth,
param->verbose);
break;
}
* updated timestamps. */
static int find_time_check(lstat_t *st, struct find_param *param, int mds)
{
- int ret;
- int rc = 1;
-
- /* Check if file is accepted. */
- if (param->atime) {
- ret = find_value_cmp(st->st_atime, param->atime,
- param->asign, param->exclude_atime,
- 24 * 60 * 60, mds);
- if (ret < 0)
- return ret;
- rc = ret;
- }
-
- if (param->mtime) {
- ret = find_value_cmp(st->st_mtime, param->mtime,
- param->msign, param->exclude_mtime,
- 24 * 60 * 60, mds);
- if (ret < 0)
- return ret;
-
- /* If the previous check matches, but this one is not yet clear,
- * we should return 0 to do an RPC on OSTs. */
- if (rc == 1)
- rc = ret;
- }
+ int rc = 1;
+ int rc2;
+
+ /* Check if file is accepted. */
+ if (param->fp_atime) {
+ rc2 = find_value_cmp(st->st_atime, param->fp_atime,
+ param->fp_asign, param->fp_exclude_atime,
+ 24 * 60 * 60, mds);
+ if (rc2 < 0)
+ return rc2;
+ rc = rc2;
+ }
- if (param->ctime) {
- ret = find_value_cmp(st->st_ctime, param->ctime,
- param->csign, param->exclude_ctime,
- 24 * 60 * 60, mds);
- if (ret < 0)
- return ret;
+ if (param->fp_mtime) {
+ rc2 = find_value_cmp(st->st_mtime, param->fp_mtime,
+ param->fp_msign, param->fp_exclude_mtime,
+ 24 * 60 * 60, mds);
+ if (rc2 < 0)
+ return rc2;
+
+ /* If the previous check matches, but this one is not yet clear,
+ * we should return 0 to do an RPC on OSTs. */
+ if (rc == 1)
+ rc = rc2;
+ }
- /* If the previous check matches, but this one is not yet clear,
- * we should return 0 to do an RPC on OSTs. */
- if (rc == 1)
- rc = ret;
- }
+ if (param->fp_ctime) {
+ rc2 = find_value_cmp(st->st_ctime, param->fp_ctime,
+ param->fp_csign, param->fp_exclude_ctime,
+ 24 * 60 * 60, mds);
+ if (rc2 < 0)
+ return rc2;
+
+ /* If the previous check matches, but this one is not yet clear,
+ * we should return 0 to do an RPC on OSTs. */
+ if (rc == 1)
+ rc = rc2;
+ }
- return rc;
+ return rc;
}
/**
return ret;
}
-static int cb_find_init(char *path, DIR *parent, DIR *dir,
+static int cb_find_init(char *path, DIR *parent, DIR **dirp,
void *data, struct dirent64 *de)
{
struct find_param *param = (struct find_param *)data;
+ DIR *dir = dirp == NULL ? NULL : *dirp;
int decision = 1; /* 1 is accepted; -1 is rejected. */
lstat_t *st = ¶m->lmd->lmd_st;
int lustre_fs = 1;
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 (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 some of these parameters need
* to be compared. */
- if (param->obduuid || param->mdtuuid || param->check_uid ||
- param->check_gid || param->check_pool || param->atime ||
- param->ctime || param->mtime || param->check_size ||
+ 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->type && checked_type == 0)
+ if (param->fp_type != 0 && checked_type == 0)
decision = 0;
if (param->have_fileinfo == 0 && decision == 0) {
}
}
- if (param->type && !checked_type) {
- if ((st->st_mode & S_IFMT) == param->type) {
- if (param->exclude_type)
- goto decided;
- } else {
- if (!param->exclude_type)
- goto decided;
- }
- }
+ 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 || 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;
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;
}
}
obd_matches:
- if (param->check_uid) {
- if (st->st_uid == param->uid) {
- if (param->exclude_uid)
- goto decided;
- } else {
- if (!param->exclude_uid)
- goto decided;
+ if (param->fp_check_uid) {
+ if (st->st_uid == param->fp_uid) {
+ if (param->fp_exclude_uid)
+ goto decided;
+ } else {
+ if (!param->fp_exclude_uid)
+ goto decided;
}
}
- if (param->check_gid) {
- if (st->st_gid == param->gid) {
- if (param->exclude_gid)
- goto decided;
- } else {
- if (!param->exclude_gid)
- goto decided;
- }
- }
+ if (param->fp_check_gid) {
+ if (st->st_gid == param->fp_gid) {
+ if (param->fp_exclude_gid)
+ goto decided;
+ } else {
+ if (!param->fp_exclude_gid)
+ goto decided;
+ }
+ }
if (param->check_pool) {
struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm;
}
}
- /* Check the time on mds. */
- decision = 1;
- if (param->atime || param->ctime || param->mtime) {
+ /* Check the time on mds. */
+ decision = 1;
+ if (param->fp_atime || param->fp_mtime || param->fp_ctime) {
int for_mds;
for_mds = lustre_fs ? (S_ISREG(st->st_mode) &&
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)
return 0;
}
-static int cb_get_mdt_index(char *path, DIR *parent, DIR *d, void *data,
+static int cb_get_mdt_index(char *path, DIR *parent, DIR **dirp, void *data,
struct dirent64 *de)
{
struct find_param *param = (struct find_param *)data;
+ DIR *d = dirp == NULL ? NULL : *dirp;
int ret = 0;
int mdtidx;
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,
+static int cb_getstripe(char *path, DIR *parent, DIR **dirp, void *data,
struct dirent64 *de)
{
struct find_param *param = (struct find_param *)data;
+ DIR *d = dirp == NULL ? NULL : *dirp;
int ret = 0;
LASSERT(parent != NULL || d != NULL);
}
if (d) {
- if (param->get_lmv) {
+ if (param->get_lmv || param->get_default_lmv) {
ret = cb_get_dirstripe(path, d, param);
} else {
ret = ioctl(dirfd(d), LL_IOC_LOV_GETSTRIPE,
* a check later on in the code path.
* The object_seq needs to be set for the "(Default)"
* prefix to be displayed. */
- struct lov_user_md *lmm = ¶m->lmd->lmd_lmm;
- lmm->lmm_magic = LOV_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;
+ 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,
__func__, path);
} else {
ret = -errno;
- llapi_error(LLAPI_MSG_ERROR, ret,
- "error: %s: %s failed for %s",
- __func__, d ? "LL_IOC_LOV_GETSTRIPE" :
- "IOC_MDC_GETFILESTRIPE", path);
- }
+err_out:
+ llapi_error(LLAPI_MSG_ERROR, ret,
+ "error: %s: %s failed for %s",
+ __func__, d ? "LL_IOC_LOV_GETSTRIPE" :
+ "IOC_MDC_GETFILESTRIPE", path);
+ }
return ret;
}
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)
if (errno == EISDIR)
fd = open(path, O_DIRECTORY | O_RDONLY);
- if (fd < 0) {
- rc = errno ? -errno : -EBADF;
- llapi_error(LLAPI_MSG_ERROR, rc, "error: %s: opening '%s'",
- __func__, path);
- return rc;
- }
- rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf);
- if (rc)
- rc = errno ? -errno : -EINVAL;
+ if (fd < 0) {
+ rc = errno ? -errno : -EBADF;
+ llapi_error(LLAPI_MSG_ERROR, rc, "error: %s: opening '%s'",
+ __func__, path);
+ /* If we can't even open a file on the filesystem (e.g. with
+ * -ESHUTDOWN), force caller to exit or it will loop forever. */
+ return -ENODEV;
+ }
+ rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf);
+ if (rc)
+ rc = errno ? -errno : -EINVAL;
- close(fd);
- return rc;
+ close(fd);
+ return rc;
}
#define MAX_STRING_SIZE 128
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;
}
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);
return rc;
}
- rc = ioctl(dirfd(root), LL_IOC_QUOTACTL, qctl);
+ rc = ioctl(dirfd(root), OBD_IOC_QUOTACTL, qctl);
if (rc < 0)
rc = -errno;
return rc;
}
-static int cb_quotachown(char *path, DIR *parent, DIR *d, void *data,
+static int cb_quotachown(char *path, DIR *parent, DIR **dirp, void *data,
struct dirent64 *de)
{
struct find_param *param = (struct find_param *)data;
+ DIR *d = dirp == NULL ? NULL : *dirp;
lstat_t *st;
int rc;
if (rc != -ENOENT)
llapi_error(LLAPI_MSG_ERROR, rc, "ioctl err %d", rc);
} else {
- memcpy(buf, gf->gf_path, gf->gf_pathlen);
- *recno = gf->gf_recno;
- *linkno = gf->gf_linkno;
+ memcpy(buf, gf->gf_path, gf->gf_pathlen);
+ if (buf[0] == '\0') { /* ROOT path */
+ buf[0] = '/';
+ buf[1] = '\0';
+ }
+ *recno = gf->gf_recno;
+ *linkno = gf->gf_linkno;
}
free(gf);
* - file modes are rw-------, if user wants another one it must use fchmod()
* \param directory Directory where the file is created
* \param idx MDT index on which the file is created
- * \param flags Std open flags
+ * \param open_flags Standard open flags
*
* \retval 0 on success.
* \retval -errno on error.
*/
-int llapi_create_volatile_idx(char *directory, int idx, int mode)
+int llapi_create_volatile_idx(char *directory, int idx, int open_flags)
{
char file_path[PATH_MAX];
char filename[PATH_MAX];
if (rc >= sizeof(file_path))
return -E2BIG;
- fd = open(file_path, (O_RDWR | O_CREAT | mode), (S_IRUSR | S_IWUSR));
+ fd = open(file_path, O_RDWR | O_CREAT | open_flags, S_IRUSR | S_IWUSR);
if (fd < 0) {
llapi_error(LLAPI_MSG_ERROR, errno,
"Cannot create volatile file %s in %s\n",
fd1 = open(path1, O_WRONLY | O_LOV_DELAY_CREATE);
if (fd1 < 0) {
- llapi_error(LLAPI_MSG_ERROR, -errno,
- "error: cannot open for write %s",
- path1);
- return -errno;
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc,
+ "error: cannot open '%s' for write", path1);
+ goto out;
}
fd2 = open(path2, O_WRONLY | O_LOV_DELAY_CREATE);
if (fd2 < 0) {
- llapi_error(LLAPI_MSG_ERROR, -errno,
- "error: cannot open for write %s",
- path2);
- close(fd1);
- return -errno;
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc,
+ "error: cannot open '%s' for write", path2);
+ goto out_close;
}
rc = llapi_fswap_layouts(fd1, fd2, dv1, dv2, flags);
if (rc < 0)
llapi_error(LLAPI_MSG_ERROR, rc,
- "error: cannot swap layouts between %s and %s\n",
- path1, path2);
+ "error: cannot swap layout between '%s' and '%s'\n",
+ path1, path2);
- close(fd1);
close(fd2);
+out_close:
+ close(fd1);
+out:
return rc;
}