comp_v1 = (struct lov_comp_md_v1 *)lum;
if (comp_v1 != NULL) {
- __swab32s(&comp_v1->lcm_magic);
- __swab32s(&comp_v1->lcm_size);
- __swab32s(&comp_v1->lcm_layout_gen);
- __swab16s(&comp_v1->lcm_flags);
- __swab16s(&comp_v1->lcm_entry_count);
+ comp_v1->lcm_magic = __swab32(comp_v1->lcm_magic);
+ comp_v1->lcm_size = __swab32(comp_v1->lcm_size);
+ comp_v1->lcm_layout_gen = __swab32(comp_v1->lcm_layout_gen);
+ comp_v1->lcm_flags = __swab16(comp_v1->lcm_flags);
+ comp_v1->lcm_entry_count = __swab16(comp_v1->lcm_entry_count);
ent_count = comp_v1->lcm_entry_count;
} else {
ent_count = 1;
for (i = 0; i < ent_count; i++) {
if (comp_v1 != NULL) {
ent = &comp_v1->lcm_entries[i];
- __swab32s(&ent->lcme_id);
- __swab32s(&ent->lcme_flags);
- __swab64s(&ent->lcme_timestamp);
- __swab64s(&ent->lcme_extent.e_start);
- __swab64s(&ent->lcme_extent.e_end);
- __swab32s(&ent->lcme_offset);
- __swab32s(&ent->lcme_size);
+ ent->lcme_id = __swab32(ent->lcme_id);
+ ent->lcme_flags = __swab32(ent->lcme_flags);
+ ent->lcme_timestamp = __swab64(ent->lcme_timestamp);
+ ent->lcme_extent.e_start = __swab64(ent->lcme_extent.e_start);
+ ent->lcme_extent.e_end = __swab64(ent->lcme_extent.e_end);
+ ent->lcme_offset = __swab32(ent->lcme_offset);
+ ent->lcme_size = __swab32(ent->lcme_size);
lum = (struct lov_user_md *)((char *)comp_v1 +
ent->lcme_offset);
}
obj_count = llapi_layout_objects_in_lum(lum, lum_size);
- __swab32s(&lum->lmm_magic);
- __swab32s(&lum->lmm_pattern);
- __swab32s(&lum->lmm_stripe_size);
- __swab16s(&lum->lmm_stripe_count);
- __swab16s(&lum->lmm_stripe_offset);
+ lum->lmm_magic = __swab32(lum->lmm_magic);
+ lum->lmm_pattern = __swab32(lum->lmm_pattern);
+ lum->lmm_stripe_size = __swab32(lum->lmm_stripe_size);
+ lum->lmm_stripe_count = __swab16(lum->lmm_stripe_count);
+ lum->lmm_stripe_offset = __swab16(lum->lmm_stripe_offset);
if (lum->lmm_magic != LOV_MAGIC_V1) {
struct lov_user_md_v3 *v3;
}
for (j = 0; j < obj_count; j++)
- __swab32s(&lod[j].l_ost_idx);
+ lod[j].l_ost_idx = __swab32(lod[j].l_ost_idx);
}
}
else if (v1->lmm_pattern == (LOV_PATTERN_RAID0 |
LOV_PATTERN_OVERSTRIPING))
comp->llc_pattern = LLAPI_LAYOUT_OVERSTRIPING;
+ else if (v1->lmm_pattern == LOV_PATTERN_MDT)
+ comp->llc_pattern = LLAPI_LAYOUT_MDT;
else
- /* Lustre only supports RAID0 for now. */
+ /* Lustre only supports RAID0, overstripping
+ * and DoM for now.
+ */
comp->llc_pattern = v1->lmm_pattern;
if (v1->lmm_stripe_size == 0)
return -1;
}
- if (layout && llapi_layout_sanity((struct llapi_layout *)layout, false,
- !!(layout->llot_mirror_count > 1)))
- return -1;
+ if (layout) {
+ rc = llapi_layout_sanity((struct llapi_layout *)layout, false,
+ !!(layout->llot_mirror_count > 1));
+ if (rc) {
+ llapi_layout_sanity_perror(rc);
+ return -1;
+ }
+ }
/* Object creation must be postponed until after layout attributes
* have been applied. */
goto out;
}
- if (llapi_layout_sanity(existing_layout, false, false)) {
+ rc = llapi_layout_sanity(existing_layout, false, false);
+ if (rc) {
tmp_errno = errno;
+ llapi_layout_sanity_perror(rc);
rc = -1;
goto out;
}
goto out;
}
- if (llapi_layout_sanity(existing_layout, false, false)) {
+ rc = llapi_layout_sanity(existing_layout, false, false);
+ if (rc) {
tmp_errno = errno;
+ llapi_layout_sanity_perror(rc);
rc = -1;
goto out;
}
goto out;
}
- if (llapi_layout_sanity(existing_layout, false, false)) {
+ rc = llapi_layout_sanity(existing_layout, false, false);
+ if (rc) {
tmp_errno = errno;
+ llapi_layout_sanity_perror(rc);
rc = -1;
goto out;
}
}
/**
+ * Get the last initialized component
+ *
+ * \param[in] layout component layout list.
+ *
+ * \retval 0 found
+ * \retval -EINVAL not found
+ * \retval -EISDIR directory layout
+ */
+int llapi_layout_get_last_init_comp(struct llapi_layout *layout)
+{
+ struct llapi_layout_comp *comp = NULL, *head = NULL;
+
+ if (!layout->llot_is_composite)
+ return 0;
+
+ head = list_entry(layout->llot_comp_list.next, typeof(*comp), llc_list);
+ if (head == NULL)
+ return -EINVAL;
+ if (head->llc_id == 0 && !(head->llc_flags & LCME_FL_INIT))
+ /* a directory */
+ return -EISDIR;
+
+ /* traverse the components from the tail to find the last init one */
+ comp = list_entry(layout->llot_comp_list.prev, typeof(*comp), llc_list);
+ while (comp != head) {
+ if (comp->llc_flags & LCME_FL_INIT)
+ break;
+ comp = list_entry(comp->llc_list.prev, typeof(*comp), llc_list);
+ }
+
+ layout->llot_cur_comp = comp;
+
+ return comp->llc_flags & LCME_FL_INIT ? 0 : -EINVAL;
+}
+
+/**
+ * Interit stripe info from the file's component to the mirror
+ *
+ * \param[in] layout file component layout list.
+ * \param[in] layout mirro component layout list.
+ *
+ * \retval 0 on success
+ * \retval -EINVAL on error
+ */
+int llapi_layout_mirror_inherit(struct llapi_layout *f_layout,
+ struct llapi_layout *m_layout)
+{
+ struct llapi_layout_comp *m_comp = NULL;
+ struct llapi_layout_comp *f_comp = NULL;
+ int rc = 0;
+
+ f_comp = __llapi_layout_cur_comp(f_layout);
+ if (f_comp == NULL)
+ return -EINVAL;
+ m_comp = __llapi_layout_cur_comp(m_layout);
+ if (m_comp == NULL)
+ return -EINVAL;
+
+ m_comp->llc_stripe_size = f_comp->llc_stripe_size;
+ m_comp->llc_stripe_count = f_comp->llc_stripe_count;
+
+ return rc;
+}
+
+/**
* Find all stale components.
*
* \param[in] layout component layout list.
uint64_t pos = start;
int i;
int rc;
+ int rc2 = 0;
rc = posix_memalign(&buf, page_size, buflen);
if (rc)
* meanings.
*/
comp_array[i].lrc_synced = true;
+ llapi_error(LLAPI_MSG_ERROR, written,
+ "component %u not synced",
+ comp_array[i].lrc_id);
+ if (rc2 == 0)
+ rc2 = (int)written;
continue;
}
assert(written == to_write2);
free(buf);
if (rc < 0) {
+ /* fatal error happens */
for (i = 0; i < comp_size; i++)
comp_array[i].lrc_synced = false;
return rc;
}
+ /**
+ * no fatal error happens, each lrc_synced tells whether the component
+ * has been resync successfully (note: we'd reverse the value to
+ * reflect its true meaning.
+ */
for (i = 0; i < comp_size; i++) {
comp_array[i].lrc_synced = !comp_array[i].lrc_synced;
if (comp_array[i].lrc_synced && pos & (page_size - 1)) {
}
}
- /* partially successful is successful */
- return 0;
+ /**
+ * returns the first error code for partially successful resync if
+ * possible.
+ */
+ return rc2;
}
enum llapi_layout_comp_sanity_error {
LSE_FLAGS,
LSE_DOM_EXTENSION,
LSE_DOM_EXTENSION_FOLLOWING,
- LSE_DOM_FLR,
+ LSE_DOM_FIRST,
LSE_SET_COMP_START,
LSE_NOT_ZERO_LENGTH_EXTENDABLE,
LSE_END_NOT_GREATER,
LSE_START_GT_END,
LSE_ALIGN_END,
LSE_ALIGN_EXT,
+ LSE_LAST,
+};
+
+const char *llapi_layout_strerror[] =
+{
+ [LSE_OK] = "",
+ [LSE_INCOMPLETE_MIRROR] =
+ "Incomplete mirror - must go to EOF",
+ [LSE_ADJACENT_EXTENSION] =
+ "No adjacent extension space components",
+ [LSE_INIT_EXTENSION] =
+ "Cannot apply extension flag to init components",
+ [LSE_FLAGS] =
+ "Wrong flags",
+ [LSE_DOM_EXTENSION] =
+ "DoM components can't be extension space",
+ [LSE_DOM_EXTENSION_FOLLOWING] =
+ "DoM components cannot be followed by extension space",
+ [LSE_DOM_FIRST] =
+ "DoM component should be the first one in a file/mirror",
+ [LSE_SET_COMP_START] =
+ "Must set previous component extent before adding next",
+ [LSE_NOT_ZERO_LENGTH_EXTENDABLE] =
+ "Extendable component must start out zero-length",
+ [LSE_END_NOT_GREATER] =
+ "Component end is before end of previous component",
+ [LSE_ZERO_LENGTH_NORMAL] =
+ "Zero length components must be followed by extension",
+ [LSE_NOT_ADJACENT_PREV] =
+ "Components not adjacent (end != next->start",
+ [LSE_START_GT_END] =
+ "Component start is > end",
+ [LSE_ALIGN_END] =
+ "The component end must be aligned by the stripe size",
+ [LSE_ALIGN_EXT] =
+ "The extension size must be aligned by the stripe size",
};
struct llapi_layout_sanity_args {
int lsa_rc;
};
+/* The component flags can be set by users at creation/modification time. */
+#define LCME_USER_COMP_FLAGS (LCME_FL_PREF_RW | LCME_FL_NOSYNC | \
+ LCME_FL_EXTENSION)
+
static int llapi_layout_sanity_cb(struct llapi_layout *layout,
void *arg)
{
goto out_err;
}
- /* DoM and FLR are not supported together */
- if (args->lsa_flr && first_comp) {
- args->lsa_rc = LSE_DOM_FLR;
- errno = ENOTSUP;
+ /* DoM should be the first component in a mirror */
+ if (!first_comp) {
+ args->lsa_rc = LSE_DOM_FIRST;
+ errno = EINVAL;
goto out_err;
}
}
/* Components not followed by ext space must have length > 0. */
if (comp->llc_extent.e_start == comp->llc_extent.e_end &&
- next && !(next->llc_flags & LCME_FL_EXTENSION)) {
+ (next == NULL || !(next->llc_flags & LCME_FL_EXTENSION))) {
args->lsa_rc = LSE_ZERO_LENGTH_NORMAL;
goto out_err;
}
/* Print explanation of layout error */
void llapi_layout_sanity_perror(int error)
{
- char *msg = NULL;
-
- switch (error) {
- case LSE_OK:
- break;
- case LSE_INCOMPLETE_MIRROR:
- msg = "Incomplete mirror - must go to EOF";
- break;
- case LSE_ADJACENT_EXTENSION:
- msg = "No adjacent extension space components";
- break;
- case LSE_INIT_EXTENSION:
- msg = "Cannot apply extension flag to init components";
- break;
- case LSE_FLAGS:
- msg = "Wrong flags";
- break;
- case LSE_DOM_EXTENSION:
- msg = "DoM components can't be extension space";
- break;
- case LSE_DOM_EXTENSION_FOLLOWING:
- msg = "DoM components cannot be followed by extension space";
- break;
- case LSE_DOM_FLR:
- msg = "FLR and DoM are not supported together";
- break;
- case LSE_SET_COMP_START:
- msg = "Must set previous component extent before adding next";
- break;
- case LSE_NOT_ZERO_LENGTH_EXTENDABLE:
- msg = "Extendable component must start out zero-length";
- break;
- case LSE_END_NOT_GREATER:
- msg = "Component end is before end of previous component";
- break;
- case LSE_ZERO_LENGTH_NORMAL:
- msg = "Zero length components must be followed by extension";
- break;
- case LSE_NOT_ADJACENT_PREV:
- msg = "Components not adjacent (end != next->start";
- break;
- case LSE_START_GT_END:
- msg = "Component start is > end";
- case LSE_ALIGN_END:
- msg = "The component end must be aligned by the stripe size";
- break;
- case LSE_ALIGN_EXT:
- msg = "The extension size must be aligned by the stripe size";
- break;
- default:
+ if (error >= LSE_LAST || error < 0) {
fprintf(stdout, "Invalid layout, unrecognized error: %d\n",
error);
+ } else {
+ fprintf(stdout, "Invalid layout: %s\n",
+ llapi_layout_strerror[error]);
}
-
- if (msg)
- fprintf(stdout, "Invalid layout: %s\n", msg);
}
/* Walk a layout and enforce sanity checks that apply to > 1 component
return rc;
}
+
+int llapi_layout_dom_size(struct llapi_layout *layout, uint64_t *size)
+{
+ uint64_t pattern, start;
+ int rc;
+
+ if (!layout || !llapi_layout_is_composite(layout)) {
+ *size = 0;
+ return 0;
+ }
+
+ rc = llapi_layout_comp_use(layout, LLAPI_LAYOUT_COMP_USE_FIRST);
+ if (rc)
+ return -errno;
+
+ rc = llapi_layout_pattern_get(layout, &pattern);
+ if (rc)
+ return -errno;
+
+ if (pattern != LOV_PATTERN_MDT && pattern != LLAPI_LAYOUT_MDT) {
+ *size = 0;
+ return 0;
+ }
+
+ rc = llapi_layout_comp_extent_get(layout, &start, size);
+ if (rc)
+ return -errno;
+ if (start)
+ return -ERANGE;
+ return 0;
+}
+
+int lov_comp_md_size(struct lov_comp_md_v1 *lcm)
+{
+ if (lcm->lcm_magic == LOV_MAGIC_V1 || lcm->lcm_magic == LOV_MAGIC_V3) {
+ struct lov_user_md *lum = (void *)lcm;
+
+ return lov_user_md_size(lum->lmm_stripe_count, lum->lmm_magic);
+ }
+
+ if (lcm->lcm_magic == LOV_MAGIC_FOREIGN) {
+ struct lov_foreign_md *lfm = (void *)lcm;
+
+ return lfm->lfm_length;
+ }
+
+ if (lcm->lcm_magic != LOV_MAGIC_COMP_V1)
+ return -EOPNOTSUPP;
+
+ return lcm->lcm_size;
+}
+
+int llapi_get_lum_file_fd(int dir_fd, const char *fname, __u64 *valid,
+ lstatx_t *statx, struct lov_user_md *lum,
+ size_t lumsize)
+{
+ struct lov_user_mds_data *lmd;
+ char buf[65536 + offsetof(typeof(*lmd), lmd_lmm)];
+ int parent_fd = -1;
+ int rc;
+
+ if (lum && lumsize < sizeof(*lum))
+ return -EINVAL;
+
+ /* If a file name is provided, it is relative to the parent directory */
+ if (fname) {
+ parent_fd = dir_fd;
+ dir_fd = -1;
+ }
+
+ lmd = (struct lov_user_mds_data *)buf;
+ rc = get_lmd_info_fd(fname, parent_fd, dir_fd, buf, sizeof(buf),
+ GET_LMD_INFO);
+ if (rc)
+ return rc;
+
+ if (valid)
+ *valid = lmd->lmd_flags;
+
+ if (statx)
+ memcpy(statx, &lmd->lmd_stx, sizeof(*statx));
+
+ if (lum) {
+ if (lmd->lmd_lmmsize > lumsize)
+ return -EOVERFLOW;
+ memcpy(lum, &lmd->lmd_lmm, lmd->lmd_lmmsize);
+ }
+
+ return 0;
+}
+
+int llapi_get_lum_dir_fd(int dir_fd, __u64 *valid, lstatx_t *statx,
+ struct lov_user_md *lum, size_t lumsize)
+{
+ return llapi_get_lum_file_fd(dir_fd, NULL, valid, statx, lum, lumsize);
+}
+
+int llapi_get_lum_file(const char *path, __u64 *valid, lstatx_t *statx,
+ struct lov_user_md *lum, size_t lumsize)
+{
+ char parent[PATH_MAX];
+ const char *fname;
+ char *tmp;
+ int offset;
+ int dir_fd;
+ int rc;
+
+ tmp = strrchr(path, '/');
+ if (!tmp) {
+ strncpy(parent, ".", sizeof(parent) - 1);
+ offset = -1;
+ } else {
+ strncpy(parent, path, tmp - path);
+ offset = tmp - path - 1;
+ parent[tmp - path] = 0;
+ }
+
+ fname = path;
+ if (offset >= 0)
+ fname += offset + 2;
+
+ dir_fd = open(parent, O_RDONLY);
+ if (dir_fd < 0) {
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", path);
+ return rc;
+ }
+
+ rc = llapi_get_lum_file_fd(dir_fd, fname, valid, statx, lum, lumsize);
+ close(dir_fd);
+ return rc;
+}
+
+int llapi_get_lum_dir(const char *path, __u64 *valid, lstatx_t *statx,
+ struct lov_user_md *lum, size_t lumsize)
+{
+ int dir_fd;
+ int rc;
+
+ dir_fd = open(path, O_RDONLY);
+ if (dir_fd < 0) {
+ rc = -errno;
+ llapi_error(LLAPI_MSG_ERROR, rc, "cannot open '%s'", path);
+ return rc;
+ }
+
+ rc = llapi_get_lum_dir_fd(dir_fd, valid, statx, lum, lumsize);
+ close(dir_fd);
+ return rc;
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff