X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi.c;h=05e9929baa03958b42bc5a3a1011453bafabf418;hb=233576b564b713ad765d908629b5b290acdabc1e;hp=fb1e69fb349b8667c81bd81562d5501628113084;hpb=ead6f5b2b5d3e151b4f98404bb0d253ccb992d6a;p=fs%2Flustre-release.git diff --git a/lustre/utils/liblustreapi.c b/lustre/utils/liblustreapi.c index fb1e69f..05e9929 100644 --- a/lustre/utils/liblustreapi.c +++ b/lustre/utils/liblustreapi.c @@ -27,7 +27,7 @@ * 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/ @@ -170,8 +170,8 @@ void llapi_printf(int level, char *fmt, ...) /** * 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; @@ -450,16 +450,95 @@ static int get_param_obdvar(const char *fsname, const char *file_path, 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; + } - /* Now get the maxea from llite proc */ - if (!get_param_obdvar(NULL, path, "llite", "max_easize", - buf, sizeof(buf))) - lumlen = atoi(buf); - return lumlen; + rc = 0; +out: + if (param_file != NULL) + fclose(param_file); + + return rc; +} + +static int get_param_llite(const char *path, + const char *param, char *buf, size_t buf_size) +{ + char inst[80]; + int rc; + + rc = llapi_getname(path, inst, sizeof(inst)); + if (rc != 0) + return rc; + + return get_param_cli("llite", inst, param, buf, buf_size); +} + +static int get_param_lov(const char *path, + const char *param, char *buf, size_t buf_size) +{ + struct obd_uuid uuid; + int rc; + + rc = llapi_file_get_lov_uuid(path, &uuid); + if (rc != 0) + return rc; + + return get_param_cli("lov", uuid.uuid, param, buf, buf_size); +} + +static int get_param_lmv(const char *path, + const char *param, char *buf, size_t buf_size) +{ + struct obd_uuid uuid; + int rc; + + rc = llapi_file_get_lmv_uuid(path, &uuid); + if (rc != 0) + return rc; + + return get_param_cli("lmv", uuid.uuid, param, buf, buf_size); +} + +static int get_mds_md_size(const char *path) +{ + int md_size = lov_user_md_size(LOV_MAX_STRIPE_COUNT, LOV_USER_MAGIC_V3); + char buf[80]; + int rc; + + /* Get the max ea size from llite proc. */ + rc = get_param_llite(path, "max_easize", buf, sizeof(buf)); + if (rc != 0) + goto out; + + rc = atoi(buf); + if (rc > 0) + md_size = rc; + +out: + return md_size; } /* @@ -680,7 +759,8 @@ int llapi_dir_create_pool(const char *name, int flags, int stripe_offset, 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)); } @@ -698,14 +778,14 @@ int llapi_dir_create_pool(const char *name, int flags, int stripe_offset, 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)) { @@ -748,7 +828,7 @@ int llapi_direntry_remove(char *dname) 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)) { @@ -799,10 +879,11 @@ int get_root_path(int want, char *fsname, int *outfd, char *path, int index) 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 */ @@ -1240,7 +1321,12 @@ typedef int (semantic_func_t)(char *path, DIR *parent, DIR *d, 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, @@ -1368,14 +1454,6 @@ static int get_lmd_info(char *path, DIR *parent, DIR *dir, 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, @@ -1398,15 +1476,19 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, } 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; @@ -1431,7 +1513,8 @@ static int llapi_semantic_traverse(char *path, int size, DIR *parent, 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 & @@ -1545,6 +1628,23 @@ int llapi_file_get_lov_uuid(const char *path, struct obd_uuid *lov_uuid) 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 @@ -1729,15 +1829,18 @@ static int setup_indexes(DIR *dir, char *path, struct obd_uuid *obduuids, int num_obds, int **obdindexes, int *obdindex, enum tgt_type type) { - int ret, obdcount, obd_valid = 0, obdnum, 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 * @@ -2021,23 +2124,23 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, char nl = is_dir ? ' ' : '\n'; int rc; - if (is_dir && lum->lmm_object_seq == FID_SEQ_LOV_DEFAULT) { - lum->lmm_object_seq = FID_SEQ_OST_MDT0; - if (verbose & VERBOSE_DETAIL) - llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); - } + if (is_dir && lmm_oi_seq(&lum->lmm_oi) == FID_SEQ_LOV_DEFAULT) { + lmm_oi_set_seq(&lum->lmm_oi, 0); + if (verbose & VERBOSE_DETAIL) + llapi_printf(LLAPI_MSG_NORMAL, "(Default) "); + } if (depth && path && ((verbose != VERBOSE_OBJID) || !is_dir)) llapi_printf(LLAPI_MSG_NORMAL, "%s\n", path); - if ((verbose & VERBOSE_DETAIL) && !is_dir) { - llapi_printf(LLAPI_MSG_NORMAL, "lmm_magic: 0x%08X\n", - lum->lmm_magic); - llapi_printf(LLAPI_MSG_NORMAL, "lmm_seq: "LPX64"\n", - lum->lmm_object_seq); - llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n", - lum->lmm_object_id); - } + if ((verbose & VERBOSE_DETAIL) && !is_dir) { + llapi_printf(LLAPI_MSG_NORMAL, "lmm_magic: 0x%08X\n", + lum->lmm_magic); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_seq: "LPX64"\n", + lmm_oi_seq(&lum->lmm_oi)); + llapi_printf(LLAPI_MSG_NORMAL, "lmm_object_id: "LPX64"\n", + lmm_oi_id(&lum->lmm_oi)); + } if (verbose & VERBOSE_COUNT) { if (verbose & ~VERBOSE_COUNT) @@ -2089,10 +2192,12 @@ static void lov_dump_user_lmm_header(struct lov_user_md *lum, char *path, } } - 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) @@ -2147,15 +2252,16 @@ void lov_dump_user_lmm_v1v3(struct lov_user_md *lum, char *pool_name, lov_dump_user_lmm_header(lum, path, objects, is_dir, header, depth, raw, pool_name); - if (!is_dir && (header & VERBOSE_OBJID)) { + if (!is_dir && (header & VERBOSE_OBJID) && + !(lum->lmm_pattern & LOV_PATTERN_F_RELEASED)) { if (obdstripe == 1) llapi_printf(LLAPI_MSG_NORMAL, "\tobdidx\t\t objid\t\t objid\t\t group\n"); for (i = 0; i < lum->lmm_stripe_count; i++) { int idx = objects[i].l_ost_idx; - long long oid = objects[i].l_object_id; - long long gr = objects[i].l_object_seq; + long long oid = ostid_id(&objects[i].l_ost_oi); + long long gr = ostid_seq(&objects[i].l_ost_oi); if ((obdindex == OBD_NOT_FOUND) || (obdindex == idx)) { char fmt[48]; sprintf(fmt, "%s%s%s\n", @@ -2605,11 +2711,12 @@ static int cb_find_init(char *path, DIR *parent, DIR *dir, /* 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; @@ -2714,6 +2821,18 @@ static int cb_find_init(char *path, DIR *parent, DIR *dir, 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)) @@ -2993,21 +3112,21 @@ static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data, if (ret) { 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 = FID_SEQ_LOV_DEFAULT; - lmm->lmm_stripe_count = 0; - lmm->lmm_stripe_size = 0; - lmm->lmm_stripe_offset = -1; - goto dump; - + /* 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_USER_MAGIC_V1; + if (!param->raw) + ostid_set_seq(&lmm->lmm_oi, + FID_SEQ_LOV_DEFAULT); + lmm->lmm_stripe_count = 0; + lmm->lmm_stripe_size = 0; + lmm->lmm_stripe_offset = -1; + goto dump; } else if (errno == ENODATA && parent != NULL) { if (!param->obduuid && !param->mdtuuid) llapi_printf(LLAPI_MSG_NORMAL, @@ -3366,7 +3485,9 @@ static int rmtacl_notify(int ops) 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; } @@ -3673,7 +3794,8 @@ int root_ioctl(const char *mdtname, int opc, void *data, int *mdtidxp, { 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. */ @@ -3893,7 +4015,7 @@ int llapi_changelog_free(struct changelog_ext_rec **rech) 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, @@ -4121,13 +4243,18 @@ int llapi_create_volatile_idx(char *directory, int idx, int mode) 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", @@ -4170,7 +4297,7 @@ int llapi_swap_layouts(const char *path1, const char *path2, { 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", @@ -4178,7 +4305,7 @@ int llapi_swap_layouts(const char *path1, const char *path2, 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",