* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
/**
* size_units is to be initialized (or zeroed) by caller.
*/
-int parse_size(char *optarg, unsigned long long *size,
- unsigned long long *size_units, int bytes_spec)
+int llapi_parse_size(const char *optarg, unsigned long long *size,
+ unsigned long long *size_units, int bytes_spec)
{
char *end;
return get_param(devices, value, val_len);
}
-static int get_mds_md_size(char *path)
+/*
+ * TYPE one of llite, lmv, lov.
+ * /proc/fs/lustre/TYPE/INST the directory of interest.
+ */
+static int get_param_cli(const char *type, const char *inst,
+ const char *param, char *buf, size_t buf_size)
{
- int lumlen = lov_mds_md_size(LOV_MAX_STRIPE_COUNT, LOV_MAGIC_V3);
- char buf[16];
+ char param_path[PATH_MAX + 1];
+ FILE *param_file = NULL;
+ int rc;
+
+ snprintf(param_path, sizeof(param_path),
+ "/proc/fs/lustre/%s/%s/%s", type, inst, param);
+
+ param_file = fopen(param_path, "r");
+ if (param_file == NULL) {
+ rc = -errno;
+ goto out;
+ }
+
+ if (fgets(buf, buf_size, param_file) == NULL) {
+ rc = -errno;
+ goto out;
+ }
+
+ rc = 0;
+out:
+ if (param_file != NULL)
+ fclose(param_file);
+
+ return rc;
+}
+
+static int get_param_llite(const char *path,
+ const char *param, char *buf, size_t buf_size)
+{
+ char inst[80];
+ int rc;
+
+ rc = llapi_getname(path, inst, sizeof(inst));
+ if (rc != 0)
+ return rc;
- /* Now get the maxea from llite proc */
- if (!get_param_obdvar(NULL, path, "llite", "max_easize",
- buf, sizeof(buf)))
- lumlen = atoi(buf);
- return lumlen;
+ return get_param_cli("llite", inst, param, buf, buf_size);
+}
+
+static int get_param_lov(const char *path,
+ const char *param, char *buf, size_t buf_size)
+{
+ struct obd_uuid uuid;
+ int rc;
+
+ rc = llapi_file_get_lov_uuid(path, &uuid);
+ if (rc != 0)
+ return rc;
+
+ return get_param_cli("lov", uuid.uuid, param, buf, buf_size);
+}
+
+static int get_param_lmv(const char *path,
+ const char *param, char *buf, size_t buf_size)
+{
+ struct obd_uuid uuid;
+ int rc;
+
+ rc = llapi_file_get_lmv_uuid(path, &uuid);
+ if (rc != 0)
+ return rc;
+
+ return get_param_cli("lmv", uuid.uuid, param, buf, buf_size);
+}
+
+static int get_mds_md_size(const char *path)
+{
+ int md_size = lov_user_md_size(LOV_MAX_STRIPE_COUNT, LOV_USER_MAGIC_V3);
+ char buf[80];
+ int rc;
+
+ /* Get the max ea size from llite proc. */
+ rc = get_param_llite(path, "max_easize", buf, sizeof(buf));
+ if (rc != 0)
+ goto out;
+
+ rc = atoi(buf);
+ if (rc > 0)
+ md_size = rc;
+
+out:
+ return md_size;
}
/*
llapi_err_noerrno(LLAPI_MSG_ERROR,
"error LL_IOC_LMV_SETSTRIPE '%s' : too large"
"pool name: %s", name, pool_name);
- GOTO(out, rc = -E2BIG);
+ rc = -E2BIG;
+ goto out;
}
memcpy(lmu.lum_pool_name, pool_name, strlen(pool_name));
}
llapi_error(LLAPI_MSG_ERROR, rc,
"error: LL_IOC_LMV_SETSTRIPE pack failed '%s'.",
name);
- GOTO(out, rc);
+ goto out;
}
fd = open(dir, O_DIRECTORY | O_RDONLY);
if (fd < 0) {
rc = -errno;
llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name);
- GOTO(out, rc);
+ goto out;
}
if (ioctl(fd, LL_IOC_LMV_SETSTRIPE, buf)) {
rc = -errno;
llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'",
filename);
- GOTO(out, rc);
+ goto out;
}
if (ioctl(fd, LL_IOC_REMOVE_ENTRY, filename)) {
mntlen = strlen(mnt.mnt_dir);
ptr = strrchr(mnt.mnt_fsname, '/');
- if (!ptr && !len) {
- rc = -EINVAL;
- break;
- }
+ /* thanks to the call to llapi_is_lustre_mnt() above,
+ * we are sure that mnt.mnt_fsname contains ":/",
+ * so ptr should never be NULL */
+ if (ptr == NULL)
+ continue;
ptr++;
/* Check the fsname for a match, if given */
static int common_param_init(struct find_param *param, char *path)
{
- param->lumlen = get_mds_md_size(path);
+ int lumlen = get_mds_md_size(path);
+
+ if (lumlen < PATH_MAX + 1)
+ lumlen = PATH_MAX + 1;
+
+ param->lumlen = lumlen;
param->lmd = malloc(sizeof(lstat_t) + param->lumlen);
if (param->lmd == NULL) {
llapi_error(LLAPI_MSG_ERROR, -ENOMEM,
return ret;
}
-int llapi_mds_getfileinfo(char *path, DIR *parent,
- struct lov_user_mds_data *lmd)
-{
- int lumlen = get_mds_md_size(path);
-
- return get_lmd_info(path, parent, NULL, lmd, lumlen);
-}
-
static int llapi_semantic_traverse(char *path, int size, DIR *parent,
semantic_func_t sem_init,
semantic_func_t sem_fini, void *data,
} else if (!d && !parent) {
/* ENOTDIR. Open the parent dir. */
p = opendir_parent(path);
- if (!p)
- GOTO(out, ret = -errno);
+ if (!p) {
+ ret = -errno;
+ goto out;
+ }
}
if (sem_init && (ret = sem_init(path, parent ?: p, d, data, de)))
goto err;
- if (!d || (param->get_lmv && !param->recursive))
- GOTO(out, ret = 0);
+ if (!d || (param->get_lmv && !param->recursive)) {
+ ret = 0;
+ goto out;
+ }
while ((dent = readdir64(d)) != NULL) {
param->have_fileinfo = 0;
if (dent->d_type == DT_UNKNOWN) {
lstat_t *st = ¶m->lmd->lmd_st;
- ret = llapi_mds_getfileinfo(path, d, param->lmd);
+ ret = get_lmd_info(path, d, NULL, param->lmd,
+ param->lumlen);
if (ret == 0) {
dent->d_type =
llapi_filetype_dir_table[st->st_mode &
return rc;
}
+int llapi_file_get_lmv_uuid(const char *path, struct obd_uuid *lov_uuid)
+{
+ int fd, rc;
+
+ fd = open(path, O_RDONLY);
+ if (fd < 0) {
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc, "error opening %s", path);
+ return rc;
+ }
+
+ rc = llapi_file_fget_lmv_uuid(fd, lov_uuid);
+
+ close(fd);
+ return rc;
+}
+
enum tgt_type {
LOV_TYPE = 1,
LMV_TYPE
int num_obds, int **obdindexes, int *obdindex,
enum tgt_type type)
{
- int ret, obdcount, obd_valid = 0, obdnum, i;
+ int ret, obdcount, obd_valid = 0, obdnum;
+ long i;
struct obd_uuid *uuids = NULL;
char buf[16];
int *indexes;
- ret = get_param_obdvar(NULL, path, type == LOV_TYPE ? "lov" : "lmv",
- "numobd", buf, sizeof(buf));
- if (ret)
- return ret;
+ if (type == LOV_TYPE)
+ ret = get_param_lov(path, "numobd", buf, sizeof(buf));
+ else
+ ret = get_param_lmv(path, "numobd", buf, sizeof(buf));
+ if (ret != 0)
+ return ret;
obdcount = atoi(buf);
uuids = (struct obd_uuid *)malloc(obdcount *
}
}
- if ((verbose & VERBOSE_DETAIL) && !is_dir) {
- llapi_printf(LLAPI_MSG_NORMAL, "lmm_stripe_pattern: %x%c",
- lum->lmm_pattern, nl);
- }
+ if ((verbose & VERBOSE_LAYOUT) && !is_dir) {
+ if (verbose & ~VERBOSE_LAYOUT)
+ llapi_printf(LLAPI_MSG_NORMAL, "%spattern: ",
+ prefix);
+ llapi_printf(LLAPI_MSG_NORMAL, "%.x%c", lum->lmm_pattern, nl);
+ }
if ((verbose & VERBOSE_GENERATION) && !is_dir) {
if (verbose & ~VERBOSE_GENERATION)
lov_dump_user_lmm_header(lum, path, objects, is_dir, header,
depth, raw, pool_name);
- if (!is_dir && (header & VERBOSE_OBJID)) {
+ if (!is_dir && (header & VERBOSE_OBJID) &&
+ !(lum->lmm_pattern & LOV_PATTERN_F_RELEASED)) {
if (obdstripe == 1)
llapi_printf(LLAPI_MSG_NORMAL,
"\tobdidx\t\t objid\t\t objid\t\t group\n");
/* 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 ||
- param->check_stripecount || param->check_stripesize)
- decision = 0;
+ if (param->obduuid || param->mdtuuid || param->check_uid ||
+ param->check_gid || param->check_pool || param->atime ||
+ param->ctime || param->mtime || param->check_size ||
+ param->check_stripecount || param->check_stripesize ||
+ param->check_layout)
+ decision = 0;
if (param->type && checked_type == 0)
decision = 0;
goto decided;
}
+ if (param->check_layout) {
+ __u32 found;
+
+ found = (param->lmd->lmd_lmm.lmm_pattern & param->layout);
+ if ((param->lmd->lmd_lmm.lmm_pattern == 0xFFFFFFFF) ||
+ (found && param->exclude_layout) ||
+ (!found && !param->exclude_layout)) {
+ decision = -1;
+ goto decided;
+ }
+ }
+
/* If an OBD UUID is specified but none matches, skip this file. */
if ((param->obduuid && param->obdindex == OBD_NOT_FOUND) ||
(param->mdtuuid && param->mdtindex == OBD_NOT_FOUND))
* 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;
+ lmm->lmm_magic = LOV_USER_MAGIC_V1;
if (!param->raw)
ostid_set_seq(&lmm->lmm_oi,
FID_SEQ_LOV_DEFAULT);
close(fd);
if (rc < 0) {
rc = -errno;
- llapi_error(LLAPI_MSG_ERROR, rc, "ioctl %d\n", fd);
+ llapi_error(LLAPI_MSG_ERROR, rc,
+ "ioctl RMTACL on '%s' err %d\n",
+ mnt->mnt_dir, rc);
goto out;
}
{
char fsname[20];
char *ptr;
- int fd, index, rc;
+ int fd, rc;
+ long index;
/* Take path, fsname, or MDTname. Assume MDT0000 in the former cases.
Open root and parse mdt index. */
int llapi_changelog_clear(const char *mdtname, const char *idstr,
long long endrec)
{
- int id;
+ long id;
if (endrec < 0) {
llapi_err_noerrno(LLAPI_MSG_ERROR,
return -errno;
}
if (idx == -1)
- sprintf(filename, LUSTRE_VOLATILE_HDR"::%.4X", random);
+ snprintf(filename, sizeof(filename),
+ LUSTRE_VOLATILE_HDR"::%.4X", random);
else
- sprintf(filename, LUSTRE_VOLATILE_IDX"%.4X", 0, random);
+ snprintf(filename, sizeof(filename),
+ LUSTRE_VOLATILE_IDX"%.4X", 0, random);
- sprintf(file_path, "%s/%s", directory, filename);
+ rc = snprintf(file_path, sizeof(file_path),
+ "%s/%s", directory, filename);
+ if (rc >= sizeof(file_path))
+ return -E2BIG;
- fd = open(file_path, O_RDWR|O_CREAT|mode, S_IRUSR|S_IWUSR);
+ fd = open(file_path, (O_RDWR | O_CREAT | mode), (S_IRUSR | S_IWUSR));
if (fd < 0) {
llapi_error(LLAPI_MSG_ERROR, errno,
"Cannot create volatile file %s in %s\n",
{
int fd1, fd2, rc;
- fd1 = open(path1, O_WRONLY);
+ fd1 = open(path1, O_WRONLY | O_LOV_DELAY_CREATE);
if (fd1 < 0) {
llapi_error(LLAPI_MSG_ERROR, -errno,
"error: cannot open for write %s",
return -errno;
}
- fd2 = open(path2, O_WRONLY);
+ fd2 = open(path2, O_WRONLY | O_LOV_DELAY_CREATE);
if (fd2 < 0) {
llapi_error(LLAPI_MSG_ERROR, -errno,
"error: cannot open for write %s",
git://git.whamcloud.com / fs / lustre-release.git / blobdiff