* 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.
*/
/*
return 0;
}
-static int poolpath(char *fsname, char *pathname, char *pool_pathname);
+static int find_target_obdpath(char *fsname, char *path)
+{
+ glob_t glob_info;
+ char pattern[PATH_MAX + 1];
+ int rc;
+
+ snprintf(pattern, PATH_MAX,
+ "/proc/fs/lustre/lov/%s-*/target_obd",
+ fsname);
+ rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
+ if (rc == GLOB_NOMATCH)
+ return -ENODEV;
+ else if (rc)
+ return -EINVAL;
+
+ strcpy(path, glob_info.gl_pathv[0]);
+ globfree(&glob_info);
+ return 0;
+}
+
+static int find_poolpath(char *fsname, char *poolname, char *poolpath)
+{
+ glob_t glob_info;
+ char pattern[PATH_MAX + 1];
+ int rc;
+
+ snprintf(pattern, PATH_MAX,
+ "/proc/fs/lustre/lov/%s-*/pools/%s",
+ fsname, poolname);
+ rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
+ /* If no pools, make sure the lov is available */
+ if ((rc == GLOB_NOMATCH) &&
+ (find_target_obdpath(fsname, poolpath) == -ENODEV))
+ return -ENODEV;
+ if (rc)
+ return -EINVAL;
+
+ strcpy(poolpath, glob_info.gl_pathv[0]);
+ globfree(&glob_info);
+ return 0;
+}
+
+/*
+ * if pool is NULL, search ostname in target_obd
+ * if pool is not NULL:
+ * if pool not found returns errno < 0
+ * if ostname is NULL, returns 1 if pool is not empty and 0 if pool empty
+ * if ostname is not NULL, returns 1 if OST is in pool and 0 if not
+ */
+int llapi_search_ost(char *fsname, char *poolname, char *ostname)
+{
+ FILE *fd;
+ char buffer[PATH_MAX + 1];
+ int len = 0, rc;
+
+ if (ostname != NULL)
+ len = strlen(ostname);
+
+ if (poolname == NULL)
+ 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;
+
+ while (fgets(buffer, sizeof(buffer), fd) != NULL) {
+ if (poolname == NULL) {
+ char *ptr;
+ /* Search for an ostname in the list of OSTs
+ Line format is IDX: fsname-OSTxxxx_UUID STATUS */
+ ptr = strchr(buffer, ' ');
+ if ((ptr != NULL) &&
+ (strncmp(ptr + 1, ostname, len) == 0)) {
+ fclose(fd);
+ return 1;
+ }
+ } else {
+ /* Search for an ostname in a pool,
+ (or an existing non-empty pool if no ostname) */
+ if ((ostname == NULL) ||
+ (strncmp(buffer, ostname, len) == 0)) {
+ fclose(fd);
+ return 1;
+ }
+ }
+ }
+ fclose(fd);
+ return 0;
+}
int llapi_file_open_pool(const char *name, int flags, int mode,
unsigned long long stripe_size, int stripe_offset,
struct lov_user_md_v3 lum = { 0 };
int fd, rc = 0;
int isdir = 0;
- char fsname[MAX_OBD_NAME + 1], *ptr;
+
+ /* 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;
+ }
+
+ /* in case user gives the full pool name <fsname>.<poolname>,
+ * strip the fsname */
+ ptr = strchr(pool_name, '.');
+ if (ptr != NULL) {
+ *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);
+ 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");
+ return -EINVAL;
+ }
+ }
fd = open(name, flags | O_LOV_DELAY_CREATE, mode);
if (fd < 0 && errno == EISDIR) {
lum.lmm_stripe_size = stripe_size;
lum.lmm_stripe_count = stripe_count;
lum.lmm_stripe_offset = stripe_offset;
-
- /* in case user give the full pool name <fsname>.<poolname>, skip
- * the fsname */
if (pool_name != NULL) {
- ptr = strchr(pool_name, '.');
- if (ptr != NULL) {
- strncpy(fsname, pool_name, ptr - pool_name);
- *ptr = '\0';
- /* if fsname matches a filesystem skip it
- * if not keep the poolname as is */
- if (poolpath(fsname, NULL, NULL) == 0)
- pool_name = ptr + 1;
- }
strncpy(lum.lmm_pool_name, pool_name, LOV_MAXPOOLNAME);
} else {
/* If no pool is specified at all, use V1 request */
{
struct mntent mnt;
char buf[PATH_MAX], mntdir[PATH_MAX];
- char *name = NULL, *ptr;
+ char *ptr;
FILE *fp;
int idx = 0, len = 0, mntlen, fd;
int rc = -ENODEV;
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) {
}
ptr++;
- if ((want & WANT_INDEX) && (idx++ != index))
- continue;
-
- /* Check the fsname for a match */
+ /* Check the fsname for a match, if given */
if (!(want & WANT_FSNAME) && fsname != NULL &&
(strlen(fsname) > 0) && (strcmp(ptr, fsname) != 0))
continue;
/* If the path isn't set return the first one we find */
if (path == NULL || strlen(path) == 0) {
strcpy(mntdir, mnt.mnt_dir);
- name = ptr;
+ if ((want & WANT_FSNAME) && fsname != NULL)
+ strcpy(fsname, ptr);
rc = 0;
break;
/* Otherwise find the longest matching path */
} else if ((strlen(path) >= mntlen) && (mntlen >= len) &&
(strncmp(mnt.mnt_dir, path, mntlen) == 0)) {
strcpy(mntdir, mnt.mnt_dir);
- mntlen = len;
- name = ptr;
+ len = mntlen;
+ if ((want & WANT_FSNAME) && fsname != NULL)
+ strcpy(fsname, ptr);
rc = 0;
}
}
/* Found it */
if (rc == 0) {
- if ((want & WANT_FSNAME) && fsname != NULL)
- strcpy(fsname, name);
if ((want & WANT_PATH) && path != NULL)
strcpy(path, mntdir);
if (want & WANT_FD) {
{
int want = WANT_PATH, idx = -1;
- if (!pathname) {
+ if (!pathname || pathname[0] == '\0') {
want |= WANT_INDEX;
idx = index;
} else
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) {
+ llapi_err(LLAPI_MSG_ERROR,
+ "pathname '%s' cannot expand",
+ pathname);
+ return -errno;
+ }
+ }
+ }
+ rc = get_root_path(WANT_FSNAME | WANT_ERROR, fsname, NULL, path, -1);
+ free(path);
+ return rc;
}
/* return the first file matching this pattern */
free(param->lmd);
}
-int llapi_file_fget_lov_uuid(int fd, struct obd_uuid *lov_name)
+static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data,
+ cfs_dirent_t *de)
{
- int rc = ioctl(fd, OBD_IOC_GETNAME, lov_name);
- if (rc) {
- rc = errno;
- llapi_err(LLAPI_MSG_ERROR, "error: can't get lov name.");
- }
- return rc;
+ struct find_param *param = (struct find_param *)data;
+ param->depth--;
+ return 0;
}
-int llapi_file_get_lov_uuid(const char *path, struct obd_uuid *lov_uuid)
+static DIR *opendir_parent(char *path)
{
- int fd, rc;
-
- fd = open(path, O_RDONLY);
- if (fd < 0) {
- rc = errno;
- llapi_err(LLAPI_MSG_ERROR, "error opening %s", path);
- return rc;
- }
-
- rc = llapi_file_fget_lov_uuid(fd, lov_uuid);
+ DIR *parent;
+ char *fname;
+ char c;
- close(fd);
+ fname = strrchr(path, '/');
+ if (fname == NULL)
+ return opendir(".");
- return rc;
+ c = fname[1];
+ fname[1] = '\0';
+ parent = opendir(path);
+ fname[1] = c;
+ return parent;
}
-/*
- * 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)
+int llapi_mds_getfileinfo(char *path, DIR *parent,
+ struct lov_user_mds_data *lmd)
{
- struct obd_uuid lov_name;
- char buf[1024];
- FILE *fp;
- int rc = 0, index = 0;
+ lstat_t *st = &lmd->lmd_st;
+ char *fname = strrchr(path, '/');
+ int ret = 0;
- /* Get the lov name */
- rc = llapi_file_fget_lov_uuid(fd, &lov_name);
- if (rc)
- return rc;
+ if (parent == NULL)
+ return -EINVAL;
- /* Now get the ost uuids from /proc */
- snprintf(buf, sizeof(buf), "/proc/fs/lustre/lov/%s/target_obd",
- lov_name.uuid);
- fp = fopen(buf, "r");
- if (fp == NULL) {
- rc = errno;
- llapi_err(LLAPI_MSG_ERROR, "error: opening '%s'", buf);
- return rc;
- }
+ 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);
- while (fgets(buf, sizeof(buf), fp) != NULL) {
- if (uuidp && (index < *ost_count)) {
- if (sscanf(buf, "%d: %s", &index, uuidp[index].uuid) <2)
- break;
+ 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;
+ }
+ } 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;
}
- index++;
}
- fclose(fp);
-
- if (uuidp && (index >= *ost_count))
- return -EOVERFLOW;
-
- *ost_count = index;
- return rc;
+ return 0;
}
-int llapi_get_obd_count(char *mnt, int *count, int is_mdt)
+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)
{
- DIR *root;
- int rc;
+ cfs_dirent_t *dent;
+ int len, ret;
+ DIR *d, *p = NULL;
- root = opendir(mnt);
- if (!root) {
- llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt);
- return -1;
- }
+ ret = 0;
+ len = strlen(path);
- *count = is_mdt;
- rc = ioctl(dirfd(root), LL_IOC_GETOBDCOUNT, count);
+ d = opendir(path);
+ if (!d && errno != ENOTDIR) {
+ llapi_err(LLAPI_MSG_ERROR, "%s: Failed to open '%s'",
+ __func__, path);
+ return -EINVAL;
+ } else if (!d && !parent) {
+ /* ENOTDIR. Open the parent dir. */
+ p = opendir_parent(path);
+ if (!p)
+ GOTO(out, ret = -EINVAL);
+ }
- closedir(root);
- return rc;
-}
+ if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de)))
+ goto err;
-/* Check if user specified value matches a real uuid. Ignore _UUID,
- * -osc-4ba41334, other trailing gunk in comparison.
- * @param real_uuid ends in "_UUID"
- * @param search_uuid may or may not end in "_UUID"
- */
-int llapi_uuid_match(char *real_uuid, char *search_uuid)
-{
- int cmplen = strlen(real_uuid) - 5;
+ if (!d)
+ GOTO(out, ret = 0);
- 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);
- return 0;
- }
+ while ((dent = readdir64(d)) != NULL) {
+ ((struct find_param *)data)->have_fileinfo = 0;
- return (strncmp(search_uuid, real_uuid, cmplen) == 0);
-}
+ if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
+ continue;
-/* Here, param->obduuid points to a single obduuid, the index of which is
- * returned in param->obdindex */
-static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param)
-{
- struct obd_uuid lov_uuid;
- char uuid[sizeof(struct obd_uuid)];
- char buf[1024];
- FILE *fp;
- int rc = 0, index;
+ /* Don't traverse .lustre directory */
+ if (!(strcmp(dent->d_name, dot_lustre_name)))
+ continue;
- /* Get the lov name */
- rc = llapi_file_fget_lov_uuid(dirfd(dir), &lov_uuid);
- if (rc) {
- if (errno != ENOTTY) {
- rc = errno;
+ path[len] = 0;
+ if ((len + dent->d_reclen + 2) > size) {
llapi_err(LLAPI_MSG_ERROR,
- "error: can't get lov name: %s", dname);
+ "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];
+ }
+ 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);
+ 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);
+ }
+ }
+
+out:
+ path[len] = 0;
+
+ if (sem_fini)
+ sem_fini(path, parent, d, data, de);
+err:
+ if (d)
+ closedir(d);
+ if (p)
+ closedir(p);
+ return ret;
+}
+
+static int param_callback(char *path, semantic_func_t sem_init,
+ semantic_func_t sem_fini, struct find_param *param)
+{
+ int ret, len = strlen(path);
+ char *buf;
+
+ if (len > PATH_MAX) {
+ llapi_err(LLAPI_MSG_ERROR, "Path name '%s' is too long", path);
+ return -EINVAL;
+ }
+
+ buf = (char *)malloc(PATH_MAX + 1);
+ if (!buf)
+ return -ENOMEM;
+
+ ret = common_param_init(param);
+ if (ret)
+ goto out;
+ param->depth = 0;
+
+ strncpy(buf, path, PATH_MAX + 1);
+ ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, sem_init,
+ sem_fini, param, NULL);
+out:
+ find_param_fini(param);
+ free(buf);
+ return ret < 0 ? ret : 0;
+}
+
+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.");
+ }
+ return rc;
+}
+
+int llapi_file_get_lov_uuid(const char *path, struct obd_uuid *lov_uuid)
+{
+ int fd, rc;
+
+ fd = open(path, O_RDONLY);
+ if (fd < 0) {
+ rc = errno;
+ llapi_err(LLAPI_MSG_ERROR, "error opening %s", path);
+ return rc;
+ }
+
+ rc = llapi_file_fget_lov_uuid(fd, lov_uuid);
+
+ close(fd);
+
+ return rc;
+}
+
+/*
+ * 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)
+{
+ struct obd_uuid lov_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;
+
+ /* Now get the ost uuids from /proc */
+ snprintf(buf, sizeof(buf), "/proc/fs/lustre/lov/%s/target_obd",
+ lov_name.uuid);
+ fp = fopen(buf, "r");
+ if (fp == NULL) {
+ rc = errno;
+ llapi_err(LLAPI_MSG_ERROR, "error: opening '%s'", buf);
+ return rc;
+ }
+
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ if (uuidp && (index < *ost_count)) {
+ if (sscanf(buf, "%d: %s", &index, uuidp[index].uuid) <2)
+ break;
+ }
+ index++;
+ }
+
+ fclose(fp);
+
+ if (uuidp && (index >= *ost_count))
+ return -EOVERFLOW;
+
+ *ost_count = index;
+ return rc;
+}
+
+int llapi_get_obd_count(char *mnt, int *count, int is_mdt)
+{
+ DIR *root;
+ int rc;
+
+ root = opendir(mnt);
+ if (!root) {
+ llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt);
+ return -1;
+ }
+
+ *count = is_mdt;
+ rc = ioctl(dirfd(root), LL_IOC_GETOBDCOUNT, count);
+
+ closedir(root);
+ return rc;
+}
+
+/* Check if user specified value matches a real uuid. Ignore _UUID,
+ * -osc-4ba41334, other trailing gunk in comparison.
+ * @param real_uuid ends in "_UUID"
+ * @param search_uuid may or may not end in "_UUID"
+ */
+int llapi_uuid_match(char *real_uuid, char *search_uuid)
+{
+ int cmplen = strlen(real_uuid);
+ int searchlen = strlen(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);
+}
+
+/* Here, param->obduuid points to a single obduuid, the index of which is
+ * returned in param->obdindex */
+static int setup_obd_uuid(DIR *dir, char *dname, struct find_param *param)
+{
+ struct obd_uuid lov_uuid;
+ char uuid[sizeof(struct obd_uuid)];
+ char buf[1024];
+ FILE *fp;
+ int rc = 0, index;
+
+ if (param->got_uuids)
+ return rc;
+
+ /* Get the lov name */
+ rc = llapi_file_fget_lov_uuid(dirfd(dir), &lov_uuid);
+ if (rc) {
+ if (errno != ENOTTY) {
+ rc = errno;
+ llapi_err(LLAPI_MSG_ERROR,
+ "error: can't get lov name: %s", dname);
} else {
rc = 0;
}
fclose(fp);
- if (!param->quiet && param->obduuid &&
- (param->obdindex == OBD_NOT_FOUND)) {
+ if (param->obduuid && (param->obdindex == OBD_NOT_FOUND)) {
llapi_err_noerrno(LLAPI_MSG_ERROR,
"error: %s: unknown obduuid: %s",
- __FUNCTION__, param->obduuid->uuid);
+ __func__, param->obduuid->uuid);
rc = -EINVAL;
}
param->obdindexes[obdnum] = OBD_NOT_FOUND;
llapi_err_noerrno(LLAPI_MSG_ERROR,
"error: %s: unknown obduuid: %s",
- __FUNCTION__,
+ __func__,
param->obduuid[obdnum].uuid);
ret = -EINVAL;
}
return ret;
}
+int llapi_ostlist(char *path, struct find_param *param)
+{
+ DIR *dir;
+ int ret;
+
+ dir = opendir(path);
+ if (dir == NULL)
+ return -errno;
+
+ ret = setup_obd_uuid(dir, path, param);
+ closedir(dir);
+
+ return ret;
+}
+
+/*
+ * Given a filesystem name, or a pathname of a file on a lustre filesystem,
+ * tries to determine the path to the filesystem's clilov directory under /proc
+ *
+ * fsname is limited to MTI_NAME_MAXLEN in lustre_idl.h
+ * The NUL terminator is compensated by the additional "%s" bytes. */
+#define LOV_LEN (sizeof("/proc/fs/lustre/lov/%s-clilov-*") + MTI_NAME_MAXLEN)
+static int clilovpath(const char *fsname, const char *const pathname,
+ char *clilovpath)
+{
+ int rc;
+ char pattern[LOV_LEN];
+ char buffer[PATH_MAX + 1];
+
+ if (fsname == NULL) {
+ if ((rc = llapi_search_fsname(pathname, buffer)) != 0)
+ return rc;
+ fsname = buffer;
+ }
+
+ snprintf(pattern, sizeof(pattern), "/proc/fs/lustre/lov/%s-clilov-*",
+ fsname);
+
+ if ((rc = first_match(pattern, buffer)) != 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)
+{
+
+ FILE *f;
+ char line[PATH_MAX + 1];
+ int rc = 0;
+
+ if ((f = fopen(fpath, "r")) == NULL) {
+ llapi_err(LLAPI_MSG_ERROR, "Cannot open '%s'", fpath);
+ return errno;
+ }
+
+ if (fgets(line, sizeof(line), f) != NULL) {
+ *attr = atoi(line);
+ } else {
+ llapi_err(LLAPI_MSG_ERROR, "Cannot read from '%s'", fpath);
+ rc = 1;
+ }
+
+ fclose(f);
+ return rc;
+}
+
+/*
+ * 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)
+{
+ int rc;
+ char dpath[PATH_MAX + 1];
+ char fpath[PATH_MAX + 1];
+
+ if ((rc = clilovpath(fsname, pathname, dpath)) != 0)
+ return rc;
+
+ if (scount) {
+ snprintf(fpath, PATH_MAX, "%s/stripecount", dpath);
+ if ((rc = sattr_read_attr(fpath, scount)) != 0)
+ return rc;
+ }
+
+ if (ssize) {
+ snprintf(fpath, PATH_MAX, "%s/stripesize", dpath);
+ if ((rc = sattr_read_attr(fpath, ssize)) != 0)
+ return rc;
+ }
+
+ if (soffset) {
+ snprintf(fpath, PATH_MAX, "%s/stripeoffset", dpath);
+ if ((rc = sattr_read_attr(fpath, soffset)) != 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)
+ llapi_search_fsname(pathname, fsname_buf);
+ 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.
+ */
+ if ((rc = sattr_get_defaults(fsname_buf, NULL, &tmp[0],
+ &tmp[1], &tmp[2])) != 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,
- int is_dir, int verbose, int quiet,
- char *pool_name)
+ struct lov_user_ost_data_v1 *objects,
+ int is_dir, int verbose, int depth,
+ int raw, char *pool_name)
{
char *prefix = is_dir ? "" : "lmm_";
char nl = is_dir ? ' ' : '\n';
- if (verbose && path)
+ if (is_dir && lum->lmm_object_seq == LOV_OBJECT_GROUP_DEFAULT) {
+ lum->lmm_object_seq = LOV_OBJECT_GROUP_CLEAR;
+ 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_seq: "LPX64"\n",
+ lum->lmm_object_seq);
llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n",
lum->lmm_object_id);
}
if (verbose & VERBOSE_COUNT) {
- if (!quiet)
+ 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;
+ if (sattr_cache_get_defaults(NULL, path,
+ &scount, NULL,
+ NULL) == 0)
+ llapi_printf(LLAPI_MSG_NORMAL, "%u%c",
+ scount, nl);
+ else
+ llapi_err(LLAPI_MSG_ERROR,
+ "Cannot determine default"
+ " stripe count.");
+ } else {
+ llapi_printf(LLAPI_MSG_NORMAL, "%d%c",
+ lum->lmm_stripe_count ==
+ (typeof(lum->lmm_stripe_count))(-1)
+ ? -1 : lum->lmm_stripe_count, nl);
+ }
+ } else {
+ llapi_printf(LLAPI_MSG_NORMAL, "%hd%c",
+ (__s16)lum->lmm_stripe_count, nl);
+ }
}
if (verbose & VERBOSE_SIZE) {
- if (!quiet)
+ 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 (is_dir && !raw && lum->lmm_stripe_size == 0) {
+ unsigned int ssize;
+ if (sattr_cache_get_defaults(NULL, path, NULL, &ssize,
+ NULL) == 0)
+ llapi_printf(LLAPI_MSG_NORMAL, "%u%c", ssize,
+ nl);
+ else
+ llapi_err(LLAPI_MSG_ERROR,
+ "Cannot determine default"
+ " stripe size.");
+ } else {
+ llapi_printf(LLAPI_MSG_NORMAL, "%u%c",
+ lum->lmm_stripe_size, nl);
+ }
}
if ((verbose & VERBOSE_DETAIL) && !is_dir) {
}
if (verbose & VERBOSE_OFFSET) {
- if (!quiet)
- llapi_printf(LLAPI_MSG_NORMAL, "%sstripe_offset: ",
+ 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%c",
+ lum->lmm_stripe_offset ==
+ (typeof(lum->lmm_stripe_offset))(-1) ? -1 :
+ lum->lmm_stripe_offset, nl);
+ else
+ llapi_printf(LLAPI_MSG_NORMAL, "%u%c",
+ objects[0].l_ost_idx, nl);
}
- if ((verbose & VERBOSE_POOL) && (pool_name != NULL))
- llapi_printf(LLAPI_MSG_NORMAL, "pool: %s%c", pool_name, nl);
+ if ((verbose & VERBOSE_POOL) && (pool_name != NULL)) {
+ if (verbose & ~VERBOSE_POOL)
+ llapi_printf(LLAPI_MSG_NORMAL, "%spool: ",
+ prefix);
+ llapi_printf(LLAPI_MSG_NORMAL, "%s%c", pool_name, nl);
+ }
- if (is_dir)
+ if (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 quiet, int header, int body)
+ int obdindex, int depth, int header, int raw)
{
- int i, obdstripe = 0;
+ int i, obdstripe = (obdindex != OBD_NOT_FOUND) ? 0 : 1;
- if (obdindex != OBD_NOT_FOUND) {
+ if (!obdstripe) {
for (i = 0; !is_dir && i < lum->lmm_stripe_count; i++) {
if (obdindex == objects[i].l_ost_idx) {
- llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path);
obdstripe = 1;
break;
}
}
- } else {
- if (!quiet)
- llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path);
- obdstripe = 1;
- }
-
- /* if it's a directory */
- if (is_dir) {
- if (obdstripe == 1) {
- if (lum->lmm_object_gr == LOV_OBJECT_GROUP_DEFAULT) {
- llapi_printf(LLAPI_MSG_NORMAL, "(Default) ");
- lum->lmm_object_gr = LOV_OBJECT_GROUP_CLEAR;
- }
- /* maintain original behavior */
- if (!header)
- header |= VERBOSE_ALL;
- lov_dump_user_lmm_header(lum, path, is_dir, header,
- quiet, pool_name);
- }
- return;
}
- if (header && (obdstripe == 1))
- lov_dump_user_lmm_header(lum, NULL, is_dir, header, quiet,
- pool_name);
+ if (obdstripe == 1)
+ lov_dump_user_lmm_header(lum, path, objects, is_dir, header,
+ depth, raw, pool_name);
- if (body) {
- if ((!quiet) && (obdstripe == 1))
+ if (!is_dir && (header & VERBOSE_OBJID)) {
+ if (obdstripe == 1)
llapi_printf(LLAPI_MSG_NORMAL,
"\tobdidx\t\t objid\t\tobjid\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;
+ long long gr = objects[i].l_object_seq;
if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx))
llapi_printf(LLAPI_MSG_NORMAL,
"\t%6u\t%14llu\t%#13llx\t%14llu%s\n",
lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, NULL,
param->lmd->lmd_lmm.lmm_objects,
path, is_dir,
- param->obdindex, param->quiet,
- param->verbose,
- (param->verbose || !param->obduuid));
+ param->obdindex, param->maxdepth,
+ param->verbose, param->raw);
break;
case LOV_USER_MAGIC_V3: {
char pool_name[LOV_MAXPOOLNAME + 1];
objects = lmmv3->lmm_objects;
lov_dump_user_lmm_v1v3(¶m->lmd->lmd_lmm, pool_name,
objects, path, is_dir,
- param->obdindex, param->quiet,
- param->verbose,
- (param->verbose || !param->obduuid));
+ param->obdindex, param->maxdepth,
+ param->verbose, param->raw);
break;
}
default:
llapi_err(LLAPI_MSG_ERROR,
"error: IOC_MDC_LOOKUP pack failed for '%s': rc %d",
name, rc);
- return rc;
- }
-
- return ioctl(dirfd, IOC_MDC_LOOKUP, buf);
-}
-
-int llapi_mds_getfileinfo(char *path, DIR *parent,
- struct lov_user_mds_data *lmd)
-{
- lstat_t *st = &lmd->lmd_st;
- char *fname = strrchr(path, '/');
- int ret = 0;
-
- if (parent == 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 (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",
- __FUNCTION__, path);
- return ret;
- }
- } else if (errno == ENOENT) {
- llapi_err(LLAPI_MSG_WARN,
- "warning: %s: %s does not exist",
- __FUNCTION__, path);
- return -ENOENT;
- } else {
- llapi_err(LLAPI_MSG_ERROR,
- "error: %s: IOC_MDC_GETFILEINFO failed for %s",
- __FUNCTION__, path);
- return ret;
- }
- }
-
- return 0;
-}
-
-static DIR *opendir_parent(char *path)
-{
- DIR *parent;
- char *fname;
- char c;
-
- fname = strrchr(path, '/');
- if (fname == NULL)
- return opendir(".");
-
- c = fname[1];
- fname[1] = '\0';
- parent = opendir(path);
- fname[1] = c;
- return parent;
-}
-
-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)
-{
- cfs_dirent_t *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'",
- __FUNCTION__, path);
- return -EINVAL;
- } else if (!d && !parent) {
- /* ENOTDIR. Open the parent dir. */
- p = opendir_parent(path);
- if (!p)
- GOTO(out, ret = -EINVAL);
- }
-
- if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de)))
- goto err;
-
- if (!d)
- GOTO(out, ret = 0);
-
- while ((dent = readdir64(d)) != NULL) {
- ((struct find_param *)data)->have_fileinfo = 0;
-
- if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
- continue;
-
- /* Don't traverse .lustre directory */
- if (!(strcmp(dent->d_name, dot_lustre_name)))
- continue;
-
- path[len] = 0;
- if ((len + dent->d_reclen + 2) > size) {
- llapi_err(LLAPI_MSG_ERROR,
- "error: %s: string buffer is too small",
- __FUNCTION__);
- 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];
- }
- if (ret == -ENOENT)
- continue;
- }
-
- switch (dent->d_type) {
- case DT_UNKNOWN:
- llapi_err(LLAPI_MSG_ERROR,
- "error: %s: '%s' is UNKNOWN type %d",
- __FUNCTION__, 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);
- }
- }
-
-out:
- path[len] = 0;
+ return rc;
+ }
- if (sem_fini)
- sem_fini(path, parent, d, data, de);
-err:
- if (d)
- closedir(d);
- if (p)
- closedir(p);
- return ret;
+ return ioctl(dirfd, IOC_MDC_LOOKUP, buf);
}
/* Check if the value matches 1 of the given criteria (e.g. --atime +/-N).
* 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)
+ int negopt, unsigned long long margin, int mds)
{
+ int ret = -1;
+
if (sign > 0) {
- if (file < limit)
- return mds ? 0 : 1;
- }
-
- if (sign == 0) {
- if (file <= limit && file + margin > limit)
- return mds ? 0 : 1;
- if (file + margin <= limit)
- return mds ? 0 : -1;
- }
-
- if (sign < 0) {
- if (file > limit)
- return 1;
- if (mds)
- return 0;
+ if (file <= limit)
+ 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)
+ 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).
/* Check if file is accepted. */
if (param->atime) {
ret = find_value_cmp(st->st_atime, param->atime,
- param->asign, 24 * 60 * 60, mds);
+ 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, 24 * 60 * 60, mds);
+ param->msign, param->exclude_mtime,
+ 24 * 60 * 60, mds);
if (ret < 0)
return ret;
if (param->ctime) {
ret = find_value_cmp(st->st_ctime, param->ctime,
- param->csign, 24 * 60 * 60, mds);
+ param->csign, param->exclude_ctime,
+ 24 * 60 * 60, mds);
if (ret < 0)
return ret;
/* 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)
+ param->check_size)
decision = 0;
ret = 0;
if (ret) {
llapi_err(LLAPI_MSG_ERROR,
"error: %s: lstat failed for %s",
- __FUNCTION__, path);
+ __func__, path);
return ret;
}
} else if (errno == ENOENT) {
llapi_err(LLAPI_MSG_WARN,
"warning: %s: %s does not exist",
- __FUNCTION__, path);
+ __func__, path);
goto decided;
} else {
llapi_err(LLAPI_MSG_ERROR,"error: %s: %s failed for %s",
- __FUNCTION__, dir ? "LL_IOC_MDC_GETINFO" :
+ __func__, dir ? "LL_IOC_MDC_GETINFO" :
"IOC_MDC_GETFILEINFO", path);
return ret;
}
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)
+ lmm_objects[i].l_ost_idx) {
+ if (param->exclude_obd)
+ goto decided;
goto obd_matches;
+ }
}
}
- if (i == param->lmd->lmd_lmm.lmm_stripe_count)
+ if (i == param->lmd->lmd_lmm.lmm_stripe_count) {
+ if (param->exclude_obd)
+ goto obd_matches;
goto decided;
+ }
}
}
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)) {
+ param->lmd->lmd_lmm.lmm_stripe_count &&
+ (param->check_size ||param->atime || param->mtime || param->ctime)) {
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
if (errno == ENOENT) {
llapi_err(LLAPI_MSG_ERROR,
"warning: %s: %s does not exist",
- __FUNCTION__, path);
+ __func__, path);
goto decided;
} else {
llapi_err(LLAPI_MSG_ERROR,
"%s: IOC_LOV_GETINFO on %s failed",
- __FUNCTION__, path);
+ __func__, path);
return ret;
}
}
goto decided;
}
- 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) {
return 0;
}
-static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data,
- cfs_dirent_t *de)
+int llapi_find(char *path, struct find_param *param)
{
- struct find_param *param = (struct find_param *)data;
- param->depth--;
+ return param_callback(path, cb_find_init, cb_common_fini, param);
+}
+
+/*
+ * Get MDT number that the file/directory inode referenced
+ * by the open fd resides on.
+ * Return 0 and mdtidx on success, or -ve errno.
+ */
+int llapi_file_fget_mdtidx(int fd, int *mdtidx)
+{
+ if (ioctl(fd, LL_IOC_GET_MDTIDX, &mdtidx) < 0)
+ return -errno;
return 0;
}
-int llapi_find(char *path, struct find_param *param)
+static int cb_get_mdt_index(char *path, DIR *parent, DIR *d, void *data,
+ cfs_dirent_t *de)
{
- char *buf;
- int ret, len = strlen(path);
+ struct find_param *param = (struct find_param *)data;
+ int ret = 0;
+ int mdtidx;
- if (len > PATH_MAX) {
- llapi_err(LLAPI_MSG_ERROR, "%s: Path name '%s' is too long",
- __FUNCTION__, path);
- return -EINVAL;
- }
+ LASSERT(parent != NULL || d != NULL);
- buf = (char *)malloc(PATH_MAX + 1);
- if (!buf)
- return -ENOMEM;
+ if (d) {
+ ret = llapi_file_fget_mdtidx(dirfd(d), &mdtidx);
+ } else if (parent) {
+ int fd;
+
+ fd = open(path, O_RDONLY);
+ if (fd > 0) {
+ ret = llapi_file_fget_mdtidx(fd, &mdtidx);
+ close(fd);
+ } else {
+ ret = fd;
+ }
+ }
- ret = common_param_init(param);
if (ret) {
- free(buf);
+ if (errno == 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);
+ goto out;
+ } else {
+ llapi_err(LLAPI_MSG_ERROR,
+ "error: %s: LL_IOC_GET_MDTIDX failed for %s",
+ __func__, path);
+ }
return ret;
}
- param->depth = 0;
+ if (param->quiet)
+ llapi_printf(LLAPI_MSG_NORMAL, "%d\n", mdtidx);
+ else
+ llapi_printf(LLAPI_MSG_NORMAL, "%s MDT index: %d\n",
+ path, mdtidx);
- strncpy(buf, path, PATH_MAX + 1);
- ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, cb_find_init,
- cb_common_fini, param, NULL);
+out:
+ /* Do not get down anymore? */
+ if (param->depth == param->maxdepth)
+ return 1;
- find_param_fini(param);
- free(buf);
- return ret < 0 ? ret : 0;
+ param->depth++;
+ return 0;
}
static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data,
LASSERT(parent != NULL || d != NULL);
- /* Prepare odb. */
- if (!param->got_uuids) {
+ if (param->obduuid) {
+ param->quiet = 1;
ret = setup_obd_uuid(d ? d : parent, path, param);
if (ret)
return ret;
fname = (fname == NULL ? path : fname + 1);
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 && !param->quiet)
+ 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. */
+ struct lov_user_md *lmm = ¶m->lmd->lmd_lmm;
+ lmm->lmm_magic = LOV_MAGIC_V1;
+ if (!param->raw)
+ lmm->lmm_object_seq = LOV_OBJECT_GROUP_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)
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?",
- __FUNCTION__, path);
+ __func__, path);
} else if (errno == ENOENT) {
llapi_err(LLAPI_MSG_WARN,
"warning: %s: %s does not exist",
- __FUNCTION__, path);
+ __func__, path);
goto out;
} else {
llapi_err(LLAPI_MSG_ERROR,
"error: %s: %s failed for %s",
- __FUNCTION__, d ? "LL_IOC_LOV_GETSTRIPE" :
+ __func__, d ? "LL_IOC_LOV_GETSTRIPE" :
"IOC_MDC_GETFILESTRIPE", path);
}
return ret;
}
- llapi_lov_dump_user_lmm(param, path, d ? 1 : 0);
+dump:
+ if (!param->get_mdt_index)
+ llapi_lov_dump_user_lmm(param, path, d ? 1 : 0);
+
out:
/* Do not get down anymore? */
if (param->depth == param->maxdepth)
int llapi_getstripe(char *path, struct find_param *param)
{
- char *buf;
- int ret = 0, len = strlen(path);
-
- if (len > PATH_MAX) {
- llapi_err(LLAPI_MSG_ERROR,
- "%s: Path name '%s' is too long",
- __FUNCTION__, path);
- return -EINVAL;
- }
-
- buf = (char *)malloc(PATH_MAX + 1);
- if (!buf)
- return -ENOMEM;
-
- ret = common_param_init(param);
- if (ret) {
- free(buf);
- return ret;
- }
-
- param->depth = 0;
-
- strncpy(buf, path, PATH_MAX + 1);
- ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, cb_getstripe,
- cb_common_fini, param, NULL);
- find_param_fini(param);
- free(buf);
- return ret < 0 ? ret : 0;
+ return param_callback(path, param->get_mdt_index ?
+ cb_get_mdt_index : cb_getstripe,
+ cb_common_fini, param);
}
int llapi_obd_statfs(char *path, __u32 type, __u32 index,
if (fd < 0) {
rc = errno ? -errno : -EBADF;
llapi_err(LLAPI_MSG_ERROR, "error: %s: opening '%s'",
- __FUNCTION__, path);
+ __func__, path);
return rc;
}
rc = ioctl(fd, IOC_OBD_STATFS, (void *)rawbuf);
} else if (errno == ENOENT) {
llapi_err(LLAPI_MSG_ERROR,
"warning: %s: %s does not exist",
- __FUNCTION__, path);
+ __func__, path);
rc = 0;
} else if (errno != EISDIR) {
rc = errno;
int llapi_quotachown(char *path, int flag)
{
struct find_param param;
- char *buf;
- int ret = 0, len = strlen(path);
-
- if (len > PATH_MAX) {
- llapi_err(LLAPI_MSG_ERROR, "%s: Path name '%s' is too long",
- __FUNCTION__, path);
- return -EINVAL;
- }
-
- buf = (char *)malloc(PATH_MAX + 1);
- if (!buf)
- return -ENOMEM;
memset(¶m, 0, sizeof(param));
param.recursive = 1;
param.verbose = 0;
param.quiet = 1;
- ret = common_param_init(¶m);
- if (ret)
- goto out;
-
- strncpy(buf, path, PATH_MAX + 1);
- ret = llapi_semantic_traverse(buf, PATH_MAX + 1, NULL, cb_quotachown,
- NULL, ¶m, NULL);
-out:
- find_param_fini(¶m);
- free(buf);
- return ret;
+ return param_callback(path, cb_quotachown, NULL, ¶m);
}
#include <pwd.h>
/* 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)
{
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.
+ */
+static int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp,
+ int want_error)
+{
+ char fsname[20];
+ char *ptr;
+ int fd, index, rc;
+
+ /* 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(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO,
+ "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_err(LLAPI_MSG_ERROR, "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
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 = 0;
+ 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;
}
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;
int llapi_changelog_recv(void *priv, struct changelog_rec **rech)
{
struct changelog_private *cp = (struct changelog_private *)priv;
- struct lnl_hdr *lnlh;
+ struct kuc_hdr *kuch;
int rc = 0;
if (!cp || (cp->magic != CHANGELOG_PRIV_MAGIC))
return -EINVAL;
if (rech == NULL)
return -EINVAL;
+ kuch = malloc(CR_MAXSIZE + sizeof(*kuch));
+ if (kuch == NULL)
+ return -ENOMEM;
repeat:
- rc = libcfs_ulnl_msg_get(&cp->lnl, CR_MAXSIZE, LNL_TRANSPORT_CHANGELOG,
- &lnlh);
+ rc = libcfs_ukuc_msg_get(&cp->kuc, (char *)kuch,
+ CR_MAXSIZE + sizeof(*kuch),
+ KUC_TRANSPORT_CHANGELOG);
if (rc < 0)
- return rc;
+ goto out_free;
- if ((lnlh->lnl_transport != LNL_TRANSPORT_CHANGELOG) ||
- ((lnlh->lnl_msgtype != CL_RECORD) &&
- (lnlh->lnl_msgtype != CL_EOF))) {
+ if ((kuch->kuc_transport != KUC_TRANSPORT_CHANGELOG) ||
+ ((kuch->kuc_msgtype != CL_RECORD) &&
+ (kuch->kuc_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);
+ 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;
}
}
- /* Our message is a changelog_rec */
- *rech = (struct changelog_rec *)(lnlh + 1);
+ /* Our message is a changelog_rec. Use pointer math to skip
+ * kuch_hdr and point directly to the message payload.
+ */
+ *rech = (struct changelog_rec *)(kuch + 1);
return 0;
out_free:
- libcfs_ulnl_msg_free(&lnlh);
*rech = NULL;
+ free(kuch);
return rc;
}
int llapi_changelog_free(struct changelog_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;
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;
+ int id;
if (endrec < 0) {
llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO,
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++;
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_err(LLAPI_MSG_ERROR, "ioctl err %d", rc);
} else {
memcpy(buf, gf->gf_path, gf->gf_pathlen);
*recno = gf->gf_recno;
}
free(gf);
- close(fd);
return rc;
}
#define CT_PRIV_MAGIC 0xC0BE2001
struct copytool_private {
int magic;
- lustre_netlink lnl;
- int archive_num_count;
- int archive_nums[0];
+ char *fsname;
+ lustre_kernelcomm kuc;
+ __u32 archives;
};
#include <libcfs/libcfs.h>
/** Register a copytool
- * @param priv Opaque private control structure
+ * @param[out] priv Opaque private control structure
+ * @param fsname Lustre filesystem
* @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
+ * @param archive_count
+ * @param archives 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_copytool_start(void **priv, char *fsname, int flags,
+ int archive_count, int *archives)
{
struct copytool_private *ct;
int rc;
- if (archive_num_count > 0 && archive_nums == NULL) {
+ if (archive_count > 0 && archives == NULL) {
llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO,
"NULL archive numbers");
return -EINVAL;
}
- ct = malloc(sizeof(*ct) +
- archive_num_count * sizeof(ct->archive_nums[0]));
+ ct = calloc(1, sizeof(*ct));
if (ct == NULL)
return -ENOMEM;
+ ct->fsname = malloc(strlen(fsname) + 1);
+ if (ct->fsname == NULL) {
+ rc = -ENOMEM;
+ goto out_err;
+ }
+ strcpy(ct->fsname, fsname);
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]));
+ ct->archives = 0;
+ for (rc = 0; rc < archive_count; rc++) {
+ if (archives[rc] > sizeof(ct->archives)) {
+ llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO,
+ "Maximum of %d archives supported",
+ sizeof(ct->archives));
+ goto out_err;
+ }
+ ct->archives |= 1 << archives[rc];
+ }
+ /* special case: if no archives specified, default to archive #0. */
+ if (ct->archives == 0)
+ ct->archives = 1;
+
+ rc = libcfs_ukuc_start(&ct->kuc, KUC_GRP_HSM);
+ if (rc < 0)
+ goto out_err;
- rc = libcfs_ulnl_start(&ct->lnl, LNL_GRP_HSM);
+ /* Storing archive(s) in lk_data; see mdc_ioc_hsm_ct_start */
+ ct->kuc.lk_data = ct->archives;
+ rc = root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL,
+ WANT_ERROR);
+ /* Only the kernel reference keeps the write side open */
+ close(ct->kuc.lk_wfd);
+ ct->kuc.lk_wfd = 0;
if (rc < 0)
goto out_err;
return 0;
out_err:
+ if (ct->fsname)
+ free(ct->fsname);
free(ct);
return rc;
}
if (!ct || (ct->magic != CT_PRIV_MAGIC))
return -EINVAL;
- libcfs_ulnl_stop(&ct->lnl);
+ /* Tell the kernel to stop sending us messages */
+ ct->kuc.lk_flags = LK_FLG_STOP;
+ root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL, 0);
+
+ /* Shut down the kernelcomms */
+ libcfs_ukuc_stop(&ct->kuc);
+
+ free(ct->fsname);
free(ct);
*priv = NULL;
return 0;
int llapi_copytool_recv(void *priv, struct hsm_action_list **halh, int *msgsize)
{
struct copytool_private *ct = (struct copytool_private *)priv;
- struct lnl_hdr *lnlh;
+ struct kuc_hdr *kuch;
struct hsm_action_list *hal;
int rc = 0;
if (halh == NULL || msgsize == NULL)
return -EINVAL;
- rc = libcfs_ulnl_msg_get(&ct->lnl, HAL_MAXSIZE,
- LNL_TRANSPORT_HSM, &lnlh);
+ kuch = malloc(HAL_MAXSIZE + sizeof(*kuch));
+ if (kuch == NULL)
+ return -ENOMEM;
+
+ rc = libcfs_ukuc_msg_get(&ct->kuc, (char *)kuch,
+ HAL_MAXSIZE + sizeof(*kuch),
+ KUC_TRANSPORT_HSM);
if (rc < 0)
- return rc;
+ goto out_free;
/* Handle generic messages */
- if (lnlh->lnl_transport == LNL_TRANSPORT_GENERIC &&
- lnlh->lnl_msgtype == LNL_MSG_SHUTDOWN) {
+ if (kuch->kuc_transport == KUC_TRANSPORT_GENERIC &&
+ kuch->kuc_msgtype == KUC_MSG_SHUTDOWN) {
rc = -ESHUTDOWN;
goto out_free;
}
- if (lnlh->lnl_transport != LNL_TRANSPORT_HSM ||
- lnlh->lnl_msgtype != HMT_ACTION_LIST) {
+ if (kuch->kuc_transport != KUC_TRANSPORT_HSM ||
+ kuch->kuc_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);
+ kuch->kuc_transport, kuch->kuc_msgtype);
rc = -EPROTO;
goto out_free;
}
- /* Our message is an hsm_action_list */
-
- hal = (struct hsm_action_list *)(lnlh + 1);
+ /* Our message is a hsm_action_list. Use pointer math to skip
+ * kuch_hdr and point directly to the message payload.
+ */
+ hal = (struct hsm_action_list *)(kuch + 1);
/* 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);
+ if (((1 << hal->hal_archive_num) & ct->archives) == 0) {
+ llapi_err(LLAPI_MSG_INFO | LLAPI_MSG_NO_ERRNO,
+ "Ignoring request for archive #%d (bitmask %#x)\n",
+ hal->hal_archive_num, ct->archives);
rc = 0;
goto out_free;
}
*halh = hal;
- *msgsize = lnlh->lnl_msglen - sizeof(*lnlh);
+ *msgsize = kuch->kuc_msglen - sizeof(*kuch);
return 0;
out_free:
- libcfs_ulnl_msg_free(&lnlh);
*halh = NULL;
*msgsize = 0;
+ free(kuch);
return rc;
}
/** Release the action list when done with it. */
int llapi_copytool_free(struct hsm_action_list **hal)
{
- if (*hal) {
- struct lnl_hdr *lnlh = (struct lnl_hdr *)*hal - 1;
- libcfs_ulnl_msg_free(&lnlh);
+ /* Reuse the llapi_changelog_free function */
+ return llapi_changelog_free((struct changelog_rec **)hal);
+}
+
+int llapi_get_connect_flags(const char *mnt, __u64 *flags)
+{
+ DIR *root;
+ int rc;
+
+ root = opendir(mnt);
+ if (!root) {
+ llapi_err(LLAPI_MSG_ERROR, "open %s failed", mnt);
+ return -1;
}
- *hal = NULL;
- return 0;
+
+ rc = ioctl(dirfd(root), LL_IOC_GET_CONNECT_FLAGS, flags);
+ closedir(root);
+ if (rc < 0)
+ llapi_err(LLAPI_MSG_ERROR,
+ "ioctl on %s for getting connect flags failed", mnt);
+ return rc;
}
+int llapi_get_version(char *buffer, int buffer_size,
+ char **version)
+{
+ int rc;
+ int fd;
+ struct obd_ioctl_data *data = (struct obd_ioctl_data *)buffer;
+
+ fd = open(OBD_DEV_PATH, O_RDONLY);
+ if (fd == -1)
+ return -errno;
+ memset(buffer, 0, buffer_size);
+ data->ioc_version = OBD_IOCTL_VERSION;
+ data->ioc_inllen1 = buffer_size - cfs_size_round(sizeof(*data));
+ data->ioc_inlbuf1 = buffer + cfs_size_round(sizeof(*data));
+ data->ioc_len = obd_ioctl_packlen(data);
+ rc = ioctl(fd, OBD_GET_VERSION, buffer);
+ if (rc == -1) {
+ rc = errno;
+ close(fd);
+ return -rc;
+ }
+ close(fd);
+ *version = data->ioc_bulk;
+ return 0;
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff