#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
*
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;
- }
+ char devices[PATH_MAX];
+ char dev[PATH_MAX] = "*";
+ char fs[PATH_MAX];
+ FILE *fp = NULL;
+ int rc = 0;
- while (fgets(devices, sizeof(devices), fp) != NULL) {
- char *bufp = devices, *tmp;
+ fp = fopen(DEVICES_LIST, "r");
+ if (fp == NULL) {
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc, "error: opening "DEVICES_LIST);
+ GOTO(out, rc);
+ }
- while (bufp[0] == ' ')
- ++bufp;
+ if (fsname == NULL && file_path != NULL) {
+ rc = llapi_search_fsname(file_path, fs);
+ if (rc) {
+ llapi_error(LLAPI_MSG_ERROR, rc,
+ "'%s' is not on a Lustre filesystem",
+ file_path);
+ GOTO(out, rc);
+ }
+ } else if (fsname != NULL) {
+ rc = strlcpy(fs, fsname, sizeof(fs));
+ if (rc >= sizeof(fs))
+ GOTO(out, rc = -E2BIG);
+ }
- 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, ' ');
+ while (fgets(devices, sizeof(devices) - 1, fp) != NULL) {
+ char *bufp = devices, *tmp;
+
+ devices[sizeof(devices) - 1] = '\0';
+ while (bufp[0] == ' ')
+ ++bufp;
+
+ tmp = strstr(bufp, obd_type);
+ if (tmp != NULL) {
+ tmp += strlen(obd_type) + 1;
+ if (strcmp(tmp, fs))
+ continue;
+ rc = strlcpy(dev, tmp, sizeof(dev));
+ if (rc >= sizeof(dev))
+ GOTO(out, rc = -E2BIG);
+ tmp = strchr(dev, ' ');
if (tmp != NULL)
*tmp = '\0';
- break;
- }
- }
+ 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);
+ if (dev[0] == '*' && strlen(fs)) {
+ rc = snprintf(dev, sizeof(dev), "%s-*", fs);
+ if (rc >= sizeof(dev))
+ GOTO(out, rc = -E2BIG);
+ }
+ rc = snprintf(devices, sizeof(devices), "%s/%s/%s", obd_type, dev,
+ param_name);
+ if (rc >= sizeof(devices))
+ GOTO(out, rc = -E2BIG);
+ fclose(fp);
+ return get_param(devices, value, val_len);
+out:
+ if (fp != NULL)
+ fclose(fp);
+ return rc;
}
/*
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:
lum.lmm_stripe_count = stripe_count;
lum.lmm_stripe_offset = stripe_offset;
if (pool_name != NULL) {
- strncpy(lum.lmm_pool_name, pool_name, LOV_MAXPOOLNAME);
+ strlcpy(lum.lmm_pool_name, pool_name,
+ sizeof(lum.lmm_pool_name));
} else {
/* If no pool is specified at all, use V1 request */
lum.lmm_magic = LOV_USER_MAGIC_V1;
": too large pool name: %s", name, pool_name);
return -E2BIG;
}
- strncpy(lum.lum_pool_name, pool_name, strlen(pool_name));
+ strncpy(lum.lum_pool_name, pool_name,
+ sizeof(lum.lum_pool_name));
}
fd = open(name, O_DIRECTORY | O_RDONLY);
return rc;
}
-int llapi_dir_create_pool(const char *name, int flags, int stripe_offset,
+int llapi_dir_create_pool(const char *name, int mode, int stripe_offset,
int stripe_count, int stripe_pattern,
const char *pool_name)
{
data.ioc_inllen1 = strlen(filename) + 1;
data.ioc_inlbuf2 = (char *)&lmu;
data.ioc_inllen2 = sizeof(struct lmv_user_md);
+ data.ioc_type = mode;
rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
if (rc) {
llapi_error(LLAPI_MSG_ERROR, 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));
+ char buf[PATH_MAX], *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) - 2) == NULL)
+ return -errno;
+ rc = strlcat(buf, "/", sizeof(buf));
+ if (rc >= sizeof(buf))
+ return -E2BIG;
+ }
+ rc = strlcat(buf, pathname, sizeof(buf));
+ if (rc >= sizeof(buf))
+ return -E2BIG;
path = realpath(buf, NULL);
if (path == NULL) {
ptr = strrchr(buf, '/');
int llapi_get_poolmembers(const char *poolname, char **members,
int list_size, char *buffer, int buffer_size)
{
- char fsname[PATH_MAX + 1];
- char *pool, *tmp;
- char pathname[PATH_MAX + 1];
- char path[PATH_MAX + 1];
- char buf[1024];
+ char fsname[PATH_MAX];
+ char *pool, *tmp;
+ char pathname[PATH_MAX];
+ char path[PATH_MAX];
+ char buf[1024];
FILE *fd;
int rc = 0;
int nb_entries = 0;
int used = 0;
/* name is FSNAME.POOLNAME */
- if (strlen(poolname) > PATH_MAX)
- return -EOVERFLOW;
- strcpy(fsname, poolname);
+ if (strlen(poolname) >= sizeof(fsname))
+ return -EOVERFLOW;
+ strlcpy(fsname, poolname, sizeof(fsname));
pool = strchr(fsname, '.');
if (pool == NULL)
return -EINVAL;
}
llapi_printf(LLAPI_MSG_NORMAL, "Pool: %s.%s\n", fsname, pool);
- sprintf(path, "%s/%s", pathname, pool);
+ rc = snprintf(path, sizeof(path), "%s/%s", pathname, pool);
+ if (rc >= sizeof(path))
+ return -EOVERFLOW;
fd = fopen(path, "r");
if (fd == NULL) {
rc = -errno;
rc = -EOVERFLOW;
break;
}
+ buf[sizeof(buf) - 1] = '\0';
/* remove '\n' */
tmp = strchr(buf, '\n');
if (tmp != NULL)
int obdcount, bufsize, rc, nb, i;
char *poolname = NULL, *tmp = NULL, data[16];
- if (name[0] != '/') {
- fsname = strdup(name);
+ if (name == NULL)
+ return -EINVAL;
+
+ if (name[0] != '/') {
+ fsname = strdup(name);
+ if (fsname == NULL)
+ return -ENOMEM;
+
poolname = strchr(fsname, '.');
if (poolname)
*poolname = '\0';
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 */
fname = (fname == NULL ? path : fname + 1);
/* retrieve needed file info */
- strncpy((char *)lmd, fname, lumlen);
+ strlcpy((char *)lmd, fname, lumlen);
ret = ioctl(dirfd(parent), IOC_MDC_GETFILEINFO, (void *)lmd);
}
int len, ret;
DIR *d, *p = NULL;
- ret = 0;
- len = strlen(path);
+ ret = 0;
+ len = strlen(path);
d = opendir(path);
if (!d && errno != ENOTDIR) {
if (sem_init && (ret = sem_init(path, parent ?: p, &d, data, de)))
goto err;
- if (!d || (param->get_lmv && !param->recursive)) {
- ret = 0;
+ if (d == NULL)
goto out;
- }
while ((dent = readdir64(d)) != NULL) {
+ int rc;
+
param->have_fileinfo = 0;
if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
if (dent->d_type == DT_UNKNOWN) {
lstat_t *st = ¶m->lmd->lmd_st;
- ret = get_lmd_info(path, d, NULL, param->lmd,
+ rc = 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 == -ENOENT)
- continue;
+ if (rc == 0)
+ dent->d_type = IFTODT(st->st_mode);
+ else if (ret == 0)
+ ret = rc;
+
+ if (rc == -ENOENT)
+ continue;
}
switch (dent->d_type) {
case DT_UNKNOWN:
"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,
- sem_fini, data, dent);
- if (ret < 0)
- goto out;
- break;
- default:
- ret = 0;
- if (sem_init) {
- ret = sem_init(path, d, NULL, data, dent);
- if (ret < 0)
- goto out;
- }
- if (sem_fini && ret == 0)
- sem_fini(path, d, NULL, data, dent);
+ case DT_DIR:
+ rc = llapi_semantic_traverse(path, size, d, sem_init,
+ sem_fini, data, dent);
+ if (rc != 0 && ret == 0)
+ ret = rc;
+ break;
+ default:
+ rc = 0;
+ if (sem_init) {
+ rc = sem_init(path, d, NULL, data, dent);
+ if (rc < 0 && ret == 0)
+ ret = rc;
+ }
+ if (sem_fini && rc == 0)
+ sem_fini(path, d, NULL, data, dent);
}
}
closedir(d);
if (p)
closedir(p);
- return ret;
+ return ret;
}
static int param_callback(char *path, semantic_func_t sem_init,
if (!buf)
return -ENOMEM;
- strncpy(buf, path, PATH_MAX + 1);
+ strlcpy(buf, path, PATH_MAX + 1);
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);
static int llapi_get_target_uuids(int fd, struct obd_uuid *uuidp,
int *ost_count, enum tgt_type type)
{
- struct obd_uuid name;
- char buf[1024];
- FILE *fp;
- int rc = 0, index = 0;
+ struct obd_uuid name;
+ char buf[1024];
+ char format[32];
+ FILE *fp;
+ int rc = 0, index = 0;
/* Get the lov name */
if (type == LOV_TYPE) {
return rc;
}
- while (fgets(buf, sizeof(buf), fp) != NULL) {
- if (uuidp && (index < *ost_count)) {
- if (sscanf(buf, "%d: %s", &index, uuidp[index].uuid) <2)
+ snprintf(format, sizeof(format),
+ "%%d: %%%zus", sizeof(uuidp[0].uuid) - 1);
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ if (uuidp && (index < *ost_count)) {
+ if (sscanf(buf, format, &index, uuidp[index].uuid) < 2)
break;
}
index++;
* returned in param->obdindex */
static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param)
{
- struct obd_uuid obd_uuid;
- char uuid[sizeof(struct obd_uuid)];
- char buf[1024];
- FILE *fp;
- int rc = 0, index;
+ struct obd_uuid obd_uuid;
+ char buf[1024];
+ char format[32];
+ FILE *fp;
+ int rc = 0;
if (param->got_uuids)
return rc;
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)
- break;
+ snprintf(format, sizeof(format),
+ "%%d: %%%zus", sizeof(obd_uuid.uuid) - 1);
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ int index;
- if (param->obduuid) {
- if (llapi_uuid_match(uuid, param->obduuid->uuid)) {
+ if (sscanf(buf, format, &index, obd_uuid.uuid) < 2)
+ break;
+
+ if (param->obduuid) {
+ if (llapi_uuid_match(obd_uuid.uuid,
+ param->obduuid->uuid)) {
param->obdindex = index;
break;
}
if (rc != 0)
return rc;
- strncpy(clilovpath, buffer, sizeof(buffer));
+ strlcpy(clilovpath, buffer, sizeof(buffer));
return 0;
}
if (rc)
return rc;
} else {
- strncpy(fsname_buf, fsname, PATH_MAX);
+ strlcpy(fsname_buf, fsname, sizeof(fsname_buf));
}
- if (strncmp(fsname_buf, cache.fsname, PATH_MAX) != 0) {
+ if (strncmp(fsname_buf, cache.fsname, sizeof(fsname_buf) - 1) != 0) {
/*
* Ensure all 3 sattrs (count, size, and offset) are
* successfully retrieved and stored in tmp before writing to
cache.stripecount = tmp[0];
cache.stripesize = tmp[1];
cache.stripeoffset = tmp[2];
- strncpy(cache.fsname, fsname_buf, PATH_MAX);
+ strlcpy(cache.fsname, fsname_buf, sizeof(cache.fsname));
}
if (scount)
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++) {
- if (obdindex == objects[i].lum_mds) {
- llapi_printf(LLAPI_MSG_NORMAL, "%s%s\n", prefix,
- path);
+ if (lum->lum_stripe_count == 0) {
+ if (obdindex == lum->lum_stripe_offset)
obdstripe = 1;
- break;
+ } else {
+ for (i = 0; i < lum->lum_stripe_count; i++) {
+ if (obdindex == objects[i].lum_mds) {
+ llapi_printf(LLAPI_MSG_NORMAL,
+ "%s%s\n", prefix,
+ path);
+ obdstripe = 1;
+ break;
+ }
}
}
} else {
obdstripe = 1;
}
+ if (!obdstripe)
+ return;
+
/* show all information default */
if (!verbose) {
if (lum->lum_magic == LMV_USER_MAGIC)
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);
+ if (verbose & VERBOSE_OFFSET)
+ separator = " ";
+ else
+ 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 && lum->lum_magic != LMV_USER_MAGIC) {
- if ((obdstripe == 1))
+ llapi_printf(LLAPI_MSG_NORMAL, "%s", separator);
+ 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++) {
}
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) || lum->lum_magic == LMV_USER_MAGIC)
+ llapi_printf(LLAPI_MSG_NORMAL, "\n");
}
void llapi_lov_dump_user_lmm(struct find_param *param, char *path, int is_dir)
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: {
struct lov_user_ost_data_v1 *objects;
struct lov_user_md_v3 *lmmv3 = (void *)¶m->lmd->lmd_lmm;
- strncpy(pool_name, lmmv3->lmm_pool_name, LOV_MAXPOOLNAME);
- pool_name[LOV_MAXPOOLNAME] = '\0';
+ strlcpy(pool_name, lmmv3->lmm_pool_name, sizeof(pool_name));
objects = lmmv3->lmm_objects;
lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name,
objects, path, is_dir,
- param->obdindex, param->maxdepth,
+ param->obdindex, param->fp_max_depth,
param->verbose, param->raw);
break;
}
struct lmv_user_md *lum;
lum = (struct lmv_user_md *)param->fp_lmv_md;
- strncpy(pool_name, lum->lum_pool_name, LOV_MAXPOOLNAME);
+ strlcpy(pool_name, lum->lum_pool_name, sizeof(pool_name));
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;
}
/**
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,
if (parent == NULL) {
dir = opendir_parent(path);
if (dir == NULL) {
+ *dirp = NULL;
ret = -errno;
- fprintf(stderr, "can not open %s ret %d\n",
- path, ret);
+ llapi_error(LLAPI_MSG_ERROR, ret,
+ "can not open %s\n", path);
return ret;
}
}
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 **dirp, void *data,
(void *)¶m->lmd->lmd_lmm);
}
- } else if (parent) {
+ } else if (parent && !param->get_lmv && !param->get_default_lmv) {
char *fname = strrchr(path, '/');
fname = (fname == NULL ? path : fname + 1);
- 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);
+ strlcpy((char *)¶m->lmd->lmd_lmm, fname, param->lumlen);
ret = ioctl(dirfd(parent), IOC_MDC_GETFILESTRIPE,
(void *)¶m->lmd->lmd_lmm);
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;
__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;
cp->flags = flags;
/* Set up the receiver */
- rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */);
+ rc = libcfs_ukuc_start(&cp->kuc, 0 /* no group registration */, 0);
if (rc < 0)
goto out_free;
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);
}
/*
- * 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
+ * Create a file without any name open it for read/write
+ *
+ * - file is created as if it were a standard file in the given \a directory
+ * - file does not appear in \a directory and mtime does not change because
+ * the filename is handled specially by the Lustre MDS.
+ * - file is removed at final close
+ * - file modes are rw------- since it doesn't make sense to have a read-only
+ * or write-only file that cannot be opened again.
+ * - if user wants another mode it must use fchmod() on the open file, no
+ * security problems arise because it cannot be opened by another process.
+ *
+ * \param[in] directory directory from which to inherit layout/MDT idx
+ * \param[in] idx MDT index on which the file is created,
+ * \a idx == -1 means no specific MDT is requested
+ * \param[in] open_flags standard open(2) flags
*
* \retval 0 on success.
* \retval -errno on error.
fd = open(file_path, O_RDWR | O_CREAT | open_flags, S_IRUSR | S_IWUSR);
if (fd < 0) {
llapi_error(LLAPI_MSG_ERROR, errno,
- "Cannot create volatile file %s in %s\n",
+ "Cannot create volatile file '%s' in '%s'\n",
filename + LUSTRE_VOLATILE_HDR_LEN,
directory);
return -errno;
}
+ /* unlink file in case this wasn't a Lustre filesystem, and the
+ * magic volatile filename wasn't handled as intended. The effect
+ * is the same. */
+ unlink(file_path);
+
return fd;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff