static int lfsck_bookmark_load(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
loff_t pos = 0;
int len = sizeof(struct lfsck_bookmark);
int rc;
rc = dt_record_read(env, lfsck->li_bookmark_obj,
lfsck_buf_get(env, &lfsck->li_bookmark_disk, len),
&pos);
if (rc == 0) {
struct lfsck_bookmark *bm = &lfsck->li_bookmark_ram;
lfsck_bookmark_le_to_cpu(bm, &lfsck->li_bookmark_disk);
if (bm->lb_magic != LFSCK_BOOKMARK_MAGIC) {
CWARN("%.16s: invalid lfsck_bookmark magic "
"0x%x != 0x%x\n", lfsck_lfsck2name(lfsck),
bm->lb_magic, LFSCK_BOOKMARK_MAGIC);
/* Process it as new lfsck_bookmark. */
rc = -ENODATA;
}
} else {
if (rc == -EFAULT && pos == 0)
/* return -ENODATA for empty lfsck_bookmark. */
rc = -ENODATA;
else
CERROR("%.16s: fail to load lfsck_bookmark, "
"expected = %d, rc = %d\n",
lfsck_lfsck2name(lfsck), len, rc);
}
return rc;
}
static int read_capa_keys(const struct lu_env *env,
struct mdt_device *mdt,
struct lustre_capa_key *keys)
{
struct mdt_thread_info *mti;
struct lustre_capa_key *tmp;
loff_t off = 0;
int i, rc;
mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
tmp = &mti->mti_capa_key;
for (i = 0; i < 2; i++) {
rc = dt_record_read(env, mdt->mdt_ck_obj,
mdt_buf(env, tmp, sizeof(*tmp)), &off);
if (rc)
return rc;
lck_le_to_cpu(&keys[i], tmp);
DEBUG_CAPA_KEY(D_SEC, &keys[i], "read");
}
return 0;
}
/**
* Implementation of the llog_operations::lop_read_header
*
* This function reads the current llog header from the bottom storage
* device.
*
* \param[in] env execution environment
* \param[in] handle llog handle of the current llog
*
* \retval 0 on successful header read
* \retval negative error if read failed
*/
static int llog_osd_read_header(const struct lu_env *env,
struct llog_handle *handle)
{
struct llog_rec_hdr *llh_hdr;
struct dt_object *o;
struct llog_thread_info *lgi;
int rc;
ENTRY;
LASSERT(sizeof(*handle->lgh_hdr) == LLOG_CHUNK_SIZE);
o = handle->lgh_obj;
LASSERT(o);
lgi = llog_info(env);
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
RETURN(rc);
LASSERT(lgi->lgi_attr.la_valid & LA_SIZE);
if (lgi->lgi_attr.la_size == 0) {
CDEBUG(D_HA, "not reading header from 0-byte log\n");
RETURN(LLOG_EEMPTY);
}
lgi->lgi_off = 0;
lgi->lgi_buf.lb_buf = handle->lgh_hdr;
lgi->lgi_buf.lb_len = LLOG_CHUNK_SIZE;
rc = dt_record_read(env, o, &lgi->lgi_buf, &lgi->lgi_off);
if (rc) {
CERROR("%s: error reading log header from "DFID": rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), rc);
RETURN(rc);
}
llh_hdr = &handle->lgh_hdr->llh_hdr;
if (LLOG_REC_HDR_NEEDS_SWABBING(llh_hdr))
lustre_swab_llog_hdr(handle->lgh_hdr);
if (llh_hdr->lrh_type != LLOG_HDR_MAGIC) {
CERROR("%s: bad log %s "DFID" header magic: %#x "
"(expected %#x)\n", o->do_lu.lo_dev->ld_obd->obd_name,
handle->lgh_name ? handle->lgh_name : "",
PFID(lu_object_fid(&o->do_lu)),
llh_hdr->lrh_type, LLOG_HDR_MAGIC);
RETURN(-EIO);
} else if (llh_hdr->lrh_len != LLOG_CHUNK_SIZE) {
CERROR("%s: incorrectly sized log %s "DFID" header: "
"%#x (expected %#x)\n"
"you may need to re-run lconf --write_conf.\n",
o->do_lu.lo_dev->ld_obd->obd_name,
handle->lgh_name ? handle->lgh_name : "",
PFID(lu_object_fid(&o->do_lu)),
llh_hdr->lrh_len, LLOG_CHUNK_SIZE);
RETURN(-EIO);
}
handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index;
RETURN(0);
}
/**
* Read the special file which contains the list of llog catalogs IDs
*
* This function reads the CATALOGS file which contains the array of llog
* catalogs IDs. The main purpose of this file is to store OSP llogs indexed
* by OST/MDT number.
*
* \param[in] env execution environment
* \param[in] d corresponding storage device
* \param[in] idx position to start from, usually OST/MDT index
* \param[in] count how many catalog IDs to read
* \param[out] idarray the buffer for the data. If it is NULL then
* function returns just number of catalog IDs
* in the file.
* \param[in] fid LLOG_CATALOGS_OID for CATALOG object
*
* \retval 0 on successful read of catalog IDs
* \retval negative value on error
* \retval positive value which is number of records in
* the file if \a idarray is NULL
*/
int llog_osd_get_cat_list(const struct lu_env *env, struct dt_device *d,
int idx, int count, struct llog_catid *idarray,
const struct lu_fid *fid)
{
struct llog_thread_info *lgi = llog_info(env);
struct dt_object *o = NULL;
struct thandle *th;
int rc, size;
ENTRY;
LASSERT(d);
size = sizeof(*idarray) * count;
lgi->lgi_off = idx * sizeof(*idarray);
lgi->lgi_fid = *fid;
o = dt_locate(env, d, &lgi->lgi_fid);
if (IS_ERR(o))
RETURN(PTR_ERR(o));
if (!dt_object_exists(o)) {
th = dt_trans_create(env, d);
if (IS_ERR(th))
GOTO(out, rc = PTR_ERR(th));
lgi->lgi_attr.la_valid = LA_MODE;
lgi->lgi_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
lgi->lgi_dof.dof_type = dt_mode_to_dft(S_IFREG);
rc = dt_declare_create(env, o, &lgi->lgi_attr, NULL,
&lgi->lgi_dof, th);
if (rc)
GOTO(out_trans, rc);
rc = dt_trans_start_local(env, d, th);
if (rc)
GOTO(out_trans, rc);
dt_write_lock(env, o, 0);
if (!dt_object_exists(o))
rc = dt_create(env, o, &lgi->lgi_attr, NULL,
&lgi->lgi_dof, th);
dt_write_unlock(env, o);
out_trans:
dt_trans_stop(env, d, th);
if (rc)
GOTO(out, rc);
}
rc = dt_attr_get(env, o, &lgi->lgi_attr, BYPASS_CAPA);
if (rc)
GOTO(out, rc);
if (!S_ISREG(lgi->lgi_attr.la_mode)) {
CERROR("%s: CATALOGS is not a regular file!: mode = %o\n",
o->do_lu.lo_dev->ld_obd->obd_name,
lgi->lgi_attr.la_mode);
GOTO(out, rc = -ENOENT);
}
CDEBUG(D_CONFIG, "cat list: disk size=%d, read=%d\n",
(int)lgi->lgi_attr.la_size, size);
/* return just number of llogs */
if (idarray == NULL) {
rc = lgi->lgi_attr.la_size / sizeof(*idarray);
GOTO(out, rc);
}
/* read for new ost index or for empty file */
memset(idarray, 0, size);
if (lgi->lgi_attr.la_size <= lgi->lgi_off)
GOTO(out, rc = 0);
if (lgi->lgi_attr.la_size < lgi->lgi_off + size)
size = lgi->lgi_attr.la_size - lgi->lgi_off;
lgi->lgi_buf.lb_buf = idarray;
lgi->lgi_buf.lb_len = size;
rc = dt_record_read(env, o, &lgi->lgi_buf, &lgi->lgi_off);
if (rc) {
CERROR("%s: error reading CATALOGS: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out, rc);
}
EXIT;
out:
lu_object_put(env, &o->do_lu);
RETURN(rc);
}