/* Test named-log reopen; returns opened log on success */
static int llog_test_2(struct obd_device *obd, char *name,
struct llog_handle **llh)
{
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
int rc;
ENTRY;
CWARN("2a: re-open a log with name: %s\n", name);
rc = llog_create(ctxt, llh, NULL, name);
if (rc) {
CERROR("2a: re-open log with name %s failed: %d\n", name, rc);
GOTO(out, rc);
}
llog_init_handle(*llh, LLOG_F_IS_PLAIN, &uuid);
if ((rc = verify_handle("2", *llh, 1)))
GOTO(out, rc);
#if 0
CWARN("2b: create a log without specified NAME & LOGID\n");
rc = llog_create(ctxt, &loghandle, NULL, NULL);
if (rc) {
CERROR("2b: create log failed\n");
GOTO(out, rc);
}
llog_init_handle(loghandle, LLOG_F_IS_PLAIN, &uuid);
logid = loghandle->lgh_id;
llog_close(loghandle);
CWARN("2b: re-open the log by LOGID\n");
rc = llog_create(ctxt, &loghandle, &logid, NULL);
if (rc) {
CERROR("2b: re-open log by LOGID failed\n");
GOTO(out, rc);
}
llog_init_handle(loghandle, LLOG_F_IS_PLAIN, &uuid);
CWARN("2b: destroy this log\n");
rc = llog_destroy(loghandle);
if (rc) {
CERROR("2b: destroy log failed\n");
GOTO(out, rc);
}
llog_free_handle(loghandle);
#endif
out:
llog_ctxt_put(ctxt);
RETURN(rc);
}
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
struct llog_handle *loghandle;
struct llogd_body *body;
struct llogd_body *repbody;
struct llog_ctxt *ctxt;
__u32 flags;
void *ptr;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(err_serious(-EFAULT));
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
LLOG_MIN_CHUNK_SIZE);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(err_serious(-ENOMEM));
if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
RETURN(-EPROTO);
}
ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
&body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
if (rc)
GOTO(out_ctxt, rc);
flags = body->lgd_llh_flags;
rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
NULL);
if (rc)
GOTO(out_close, rc);
repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
*repbody = *body;
ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
rc = llog_next_block(req->rq_svc_thread->t_env, loghandle,
&repbody->lgd_saved_index, repbody->lgd_index,
&repbody->lgd_cur_offset, ptr,
LLOG_MIN_CHUNK_SIZE);
if (rc)
GOTO(out_close, rc);
EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
/* Test named-log create/open, close */
static int llog_test_1(struct obd_device *obd, char *name)
{
struct llog_handle *llh;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
int rc;
int rc2;
ENTRY;
CWARN("1a: create a log with name: %s\n", name);
LASSERT(ctxt);
rc = llog_create(ctxt, &llh, NULL, name);
if (rc) {
CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
llog_ctxt_put(ctxt);
RETURN(rc);
}
llog_init_handle(llh, LLOG_F_IS_PLAIN, &uuid);
if ((rc = verify_handle("1", llh, 1)))
GOTO(out, rc);
out:
CWARN("1b: close newly-created log\n");
rc2 = llog_close(llh);
llog_ctxt_put(ctxt);
if (rc2) {
CERROR("1b: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
}
RETURN(rc);
}
/**
* Helper function to delete existent llog.
*/
int llog_erase(const struct lu_env *env, struct llog_ctxt *ctxt,
struct llog_logid *logid, char *name)
{
struct llog_handle *handle;
int rc = 0, rc2;
ENTRY;
/* nothing to erase */
if (name == NULL && logid == NULL)
RETURN(0);
rc = llog_open(env, ctxt, &handle, logid, name, LLOG_OPEN_EXISTS);
if (rc < 0)
RETURN(rc);
rc = llog_init_handle(env, handle, LLOG_F_IS_PLAIN, NULL);
if (rc == 0)
rc = llog_destroy(env, handle);
rc2 = llog_close(env, handle);
if (rc == 0)
rc = rc2;
RETURN(rc);
}
/**
* Helper function to get the llog size in records. It is used by MGS
* mostly to check that config llog exists and contains data.
*
* \param[in] env execution environment
* \param[in] ctxt llog context
* \param[in] name llog name
*
* \retval true if there are records in llog besides a header
* \retval false on error or llog without records
*/
int llog_is_empty(const struct lu_env *env, struct llog_ctxt *ctxt,
char *name)
{
struct llog_handle *llh;
int rc = 0;
rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc < 0) {
if (likely(rc == -ENOENT))
rc = 0;
GOTO(out, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
rc = llog_get_size(llh);
out_close:
llog_close(env, llh);
out:
/* The header is record 1, the llog is still considered as empty
* if there is only header */
return (rc <= 1);
}
static int llog_catinfo_cb(struct llog_handle *cat,
struct llog_rec_hdr *rec, void *data)
{
static char *out = NULL;
static int remains = 0;
struct llog_ctxt *ctxt = NULL;
struct llog_handle *handle = NULL;
struct llog_logid *logid;
struct llog_logid_rec *lir;
int l, rc, index, count = 0;
struct cb_data *cbd = (struct cb_data*)data;
ENTRY;
if (cbd->init) {
out = cbd->out;
remains = cbd->remains;
cbd->init = 0;
}
if (!(cat->lgh_hdr->llh_flags & LLOG_F_IS_CAT))
RETURN(-EINVAL);
if (!cbd->ctxt)
RETURN(-ENODEV);
lir = (struct llog_logid_rec *)rec;
logid = &lir->lid_id;
rc = llog_create(ctxt, &handle, logid, NULL);
if (rc)
RETURN(-EINVAL);
rc = llog_init_handle(handle, 0, NULL);
if (rc)
GOTO(out_close, rc);
for (index = 1; index < (LLOG_BITMAP_BYTES * 8); index++) {
if (ext2_test_bit(index, handle->lgh_hdr->llh_bitmap))
count++;
}
l = snprintf(out, remains, "\t[Log ID]: #"LPX64"#"LPX64"#%08x\n"
"\tLog Size: %llu\n\tLast Index: %d\n"
"\tUncanceled Records: %d\n",
logid->lgl_oid, logid->lgl_oseq, logid->lgl_ogen,
i_size_read(handle->lgh_file->f_dentry->d_inode),
handle->lgh_last_idx, count);
out += l;
remains -= l;
cbd->out = out;
cbd->remains = remains;
if (remains <= 0) {
CWARN("Not enough memory\n");
rc = -ENOMEM;
}
EXIT;
out_close:
llog_close(handle);
return rc;
}
static int llog_catinfo_config(struct obd_device *obd, char *buf, int buf_len,
char *client)
{
struct mds_obd *mds = &obd->u.mds;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
struct lvfs_run_ctxt saved;
struct llog_handle *handle = NULL;
char name[4][64];
int rc, i, l, remains = buf_len;
char *out = buf;
ENTRY;
if (ctxt == NULL || mds == NULL)
GOTO(release_ctxt, rc = -ENODEV);
push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
sprintf(name[0], "%s", mds->mds_profile);
sprintf(name[1], "%s-clean", mds->mds_profile);
sprintf(name[2], "%s", client);
sprintf(name[3], "%s-clean", client);
for (i = 0; i < 4; i++) {
int index, uncanceled = 0;
rc = llog_create(ctxt, &handle, NULL, name[i]);
if (rc)
GOTO(out_pop, rc);
rc = llog_init_handle(handle, 0, NULL);
if (rc) {
llog_close(handle);
GOTO(out_pop, rc = -ENOENT);
}
for (index = 1; index < (LLOG_BITMAP_BYTES * 8); index ++) {
if (ext2_test_bit(index, handle->lgh_hdr->llh_bitmap))
uncanceled++;
}
l = snprintf(out, remains, "[Log Name]: %s\nLog Size: %llu\n"
"Last Index: %d\nUncanceled Records: %d\n\n",
name[i],
i_size_read(handle->lgh_file->f_dentry->d_inode),
handle->lgh_last_idx, uncanceled);
out += l;
remains -= l;
llog_close(handle);
if (remains <= 0)
break;
}
GOTO(out_pop, rc);
out_pop:
pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
release_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct obd_device *disk_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct lvfs_run_ctxt saved;
struct llog_logid *logid = NULL;
struct llog_ctxt *ctxt;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
if (body->lgd_logid.lgl_oid > 0)
logid = &body->lgd_logid;
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, logid, NULL);
if (rc)
GOTO(out_pop, rc);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
rc = llog_destroy(loghandle);
if (rc)
GOTO(out_close, rc);
llog_free_handle(loghandle);
GOTO(out_close, rc);
out_close:
if (rc)
llog_close(loghandle);
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
struct llog_handle *loghandle;
struct llogd_body *body;
struct llog_log_hdr *hdr;
struct llog_ctxt *ctxt;
__u32 flags;
int rc;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(err_serious(-EFAULT));
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(err_serious(-ENOMEM));
if (body->lgd_ctxt_idx >= LLOG_MAX_CTXTS) {
CDEBUG(D_WARNING, "%s: bad ctxt ID: idx=%d\n",
req->rq_export->exp_obd->obd_name, body->lgd_ctxt_idx);
RETURN(-EPROTO);
}
ctxt = llog_get_context(req->rq_export->exp_obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
rc = llog_open(req->rq_svc_thread->t_env, ctxt, &loghandle,
&body->lgd_logid, NULL, LLOG_OPEN_EXISTS);
if (rc)
GOTO(out_ctxt, rc);
/*
* llog_init_handle() reads the llog header
*/
flags = body->lgd_llh_flags;
rc = llog_init_handle(req->rq_svc_thread->t_env, loghandle, flags,
NULL);
if (rc)
GOTO(out_close, rc);
flags = loghandle->lgh_hdr->llh_flags;
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
*hdr = *loghandle->lgh_hdr;
EXIT;
out_close:
llog_origin_close(req->rq_svc_thread->t_env, loghandle);
out_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct obd_device *disk_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct llog_log_hdr *hdr;
struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
__u32 flags;
int rc, rc2;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
RETURN(-ENODEV);
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, &body->lgd_logid, NULL);
if (rc)
GOTO(out_pop, rc);
/*
* llog_init_handle() reads the llog header
*/
flags = body->lgd_llh_flags;
rc = llog_init_handle(loghandle, flags, NULL);
if (rc)
GOTO(out_close, rc);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
*hdr = *loghandle->lgh_hdr;
GOTO(out_close, rc);
out_close:
rc2 = llog_close(loghandle);
if (!rc)
rc = rc2;
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
return rc;
}
static int llog_test_7(struct obd_device *obd)
{
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
struct llog_handle *llh;
struct llog_create_rec lcr;
char name[10];
int rc;
ENTRY;
sprintf(name, "%x", llog_test_rand+2);
CWARN("7: create a log with name: %s\n", name);
LASSERT(ctxt);
rc = llog_create(ctxt, &llh, NULL, name);
if (rc) {
CERROR("7: llog_create with name %s failed: %d\n", name, rc);
GOTO(ctxt_release, rc);
}
llog_init_handle(llh, LLOG_F_IS_PLAIN, &uuid);
lcr.lcr_hdr.lrh_len = lcr.lcr_tail.lrt_len = sizeof(lcr);
lcr.lcr_hdr.lrh_type = OST_SZ_REC;
rc = llog_write_rec(llh, &lcr.lcr_hdr, NULL, 0, NULL, -1);
if (rc) {
CERROR("7: write one log record failed: %d\n", rc);
GOTO(ctxt_release, rc);
}
rc = llog_destroy(llh);
if (rc)
CERROR("7: llog_destroy failed: %d\n", rc);
else
llog_free_handle(llh);
ctxt_release:
llog_ctxt_put(ctxt);
RETURN(rc);
}
/* Test named-log create/open, close */
static int llog_test_1(const struct lu_env *env,
struct obd_device *obd, char *name)
{
struct llog_handle *llh;
struct llog_ctxt *ctxt;
int rc;
int rc2;
CWARN("1a: create a log with name: %s\n", name);
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
rc = llog_open_create(env, ctxt, &llh, NULL, name);
if (rc) {
CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
GOTO(out, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, &uuid);
if (rc) {
CERROR("1a: can't init llog handle: %d\n", rc);
GOTO(out_close, rc);
}
rc = verify_handle("1", llh, 1);
CWARN("1b: close newly-created log\n");
out_close:
rc2 = llog_close(env, llh);
if (rc2) {
CERROR("1b: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
}
out:
llog_ctxt_put(ctxt);
return rc;
}
int llog_is_empty(const struct lu_env *env, struct llog_ctxt *ctxt,
char *name)
{
struct llog_handle *llh;
int rc = 0;
rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc < 0) {
if (likely(rc == -ENOENT))
rc = 0;
goto out;
}
rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
goto out_close;
rc = llog_get_size(llh);
out_close:
llog_close(env, llh);
out:
/* header is record 1 */
return rc <= 1;
}
static int llog_test_8(const struct lu_env *env, struct obd_device *obd)
{
struct llog_handle *llh = NULL;
char name[10];
int rc, rc2, i;
int orig_counter;
struct llog_mini_rec lmr;
struct llog_ctxt *ctxt;
struct dt_object *obj = NULL;
ENTRY;
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
lmr.lmr_hdr.lrh_type = 0xf00f00;
CWARN("8a: fill the first plain llog\n");
rc = llog_open(env, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("8a: llog_create with logid failed: %d\n", rc);
GOTO(out_put, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_CAT, &uuid);
if (rc) {
CERROR("8a: can't init llog handle: %d\n", rc);
GOTO(out, rc);
}
plain_counter = 0;
rc = llog_cat_process(env, llh, test_8_cb, "foobar", 0, 0);
if (rc != 0) {
CERROR("5a: process with test_8_cb failed: %d\n", rc);
GOTO(out, rc);
}
orig_counter = plain_counter;
for (i = 0; i < 100; i++) {
rc = llog_cat_add(env, llh, &lmr.lmr_hdr, NULL);
if (rc) {
CERROR("5a: add record failed\n");
GOTO(out, rc);
}
}
/* grab the current plain llog, we'll corrupt it later */
obj = llh->u.chd.chd_current_log->lgh_obj;
LASSERT(obj);
lu_object_get(&obj->do_lu);
CWARN("8a: pin llog "DFID"\n", PFID(lu_object_fid(&obj->do_lu)));
rc2 = llog_cat_close(env, llh);
if (rc2) {
CERROR("8a: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
GOTO(out_put, rc);
}
CWARN("8b: fill the second plain llog\n");
rc = llog_open(env, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("8b: llog_create with logid failed: %d\n", rc);
GOTO(out_put, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_CAT, &uuid);
if (rc) {
CERROR("8b: can't init llog handle: %d\n", rc);
GOTO(out, rc);
}
for (i = 0; i < 100; i++) {
rc = llog_cat_add(env, llh, &lmr.lmr_hdr, NULL);
if (rc) {
CERROR("8b: add record failed\n");
GOTO(out, rc);
}
}
CWARN("8b: second llog "DFID"\n",
PFID(lu_object_fid(&llh->u.chd.chd_current_log->lgh_obj->do_lu)));
rc2 = llog_cat_close(env, llh);
if (rc2) {
CERROR("8b: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
GOTO(out_put, rc);
}
CWARN("8c: drop two records from the first plain llog\n");
llog_truncate(env, obj);
CWARN("8d: count survived records\n");
rc = llog_open(env, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("8d: llog_create with logid failed: %d\n", rc);
GOTO(out_put, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_CAT, &uuid);
if (rc) {
CERROR("8d: can't init llog handle: %d\n", rc);
GOTO(out, rc);
}
plain_counter = 0;
rc = llog_cat_process(env, llh, test_8_cb, "foobar", 0, 0);
if (rc != 0) {
CERROR("8d: process with test_8_cb failed: %d\n", rc);
GOTO(out, rc);
}
if (orig_counter + 200 - 2 != plain_counter) {
CERROR("found %d records (expected %d)\n", plain_counter,
orig_counter + 200 - 2);
rc = -EIO;
}
out:
CWARN("8d: close re-opened catalog\n");
rc2 = llog_cat_close(env, llh);
if (rc2) {
CERROR("8d: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
}
out_put:
llog_ctxt_put(ctxt);
if (obj != NULL)
lu_object_put(env, &obj->do_lu);
RETURN(rc);
}
static int llog_test_7_sub(const struct lu_env *env, struct llog_ctxt *ctxt)
{
struct llog_handle *llh;
int rc = 0, i, process_count;
int num_recs = 0;
rc = llog_open_create(env, ctxt, &llh, NULL, NULL);
if (rc) {
CERROR("7_sub: create log failed\n");
return rc;
}
rc = llog_init_handle(env, llh,
LLOG_F_IS_PLAIN | LLOG_F_ZAP_WHEN_EMPTY,
&uuid);
if (rc) {
CERROR("7_sub: can't init llog handle: %d\n", rc);
GOTO(out_close, rc);
}
for (i = 0; i < LLOG_BITMAP_SIZE(llh->lgh_hdr); i++) {
rc = llog_write(env, llh, &llog_records.lrh, NULL, 0,
NULL, -1);
if (rc == -ENOSPC) {
break;
} else if (rc < 0) {
CERROR("7_sub: write recs failed at #%d: %d\n",
i + 1, rc);
GOTO(out_close, rc);
}
num_recs++;
}
if (rc != -ENOSPC) {
CWARN("7_sub: write record more than BITMAP size!\n");
GOTO(out_close, rc = -EINVAL);
}
rc = verify_handle("7_sub", llh, num_recs + 1);
if (rc) {
CERROR("7_sub: verify handle failed: %d\n", rc);
GOTO(out_close, rc);
}
if (num_recs < LLOG_BITMAP_SIZE(llh->lgh_hdr) - 1)
CWARN("7_sub: records are not aligned, written %d from %u\n",
num_recs, LLOG_BITMAP_SIZE(llh->lgh_hdr) - 1);
plain_counter = 0;
rc = llog_process(env, llh, test_7_print_cb, "test 7", NULL);
if (rc) {
CERROR("7_sub: llog process failed: %d\n", rc);
GOTO(out_close, rc);
}
process_count = plain_counter;
if (process_count != num_recs) {
CERROR("7_sub: processed %d records from %d total\n",
process_count, num_recs);
GOTO(out_close, rc = -EINVAL);
}
plain_counter = 0;
rc = llog_reverse_process(env, llh, test_7_cancel_cb, "test 7", NULL);
if (rc) {
CERROR("7_sub: reverse llog process failed: %d\n", rc);
GOTO(out_close, rc);
}
if (process_count != plain_counter) {
CERROR("7_sub: Reverse/direct processing found different"
"number of records: %d/%d\n",
plain_counter, process_count);
GOTO(out_close, rc = -EINVAL);
}
if (llog_exist(llh)) {
CERROR("7_sub: llog exists but should be zapped\n");
GOTO(out_close, rc = -EEXIST);
}
rc = verify_handle("7_sub", llh, 1);
out_close:
if (rc)
llog_destroy(env, llh);
llog_close(env, llh);
return rc;
}
/* Test client api; open log by name and process */
static int llog_test_6(const struct lu_env *env, struct obd_device *obd,
char *name)
{
struct obd_device *mgc_obd;
struct llog_ctxt *ctxt;
struct obd_uuid *mgs_uuid;
struct obd_export *exp;
struct obd_uuid uuid = { "LLOG_TEST6_UUID" };
struct llog_handle *llh = NULL;
struct llog_ctxt *nctxt;
int rc, rc2;
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
mgs_uuid = &ctxt->loc_exp->exp_obd->obd_uuid;
CWARN("6a: re-open log %s using client API\n", name);
mgc_obd = class_find_client_obd(mgs_uuid, LUSTRE_MGC_NAME, NULL);
if (mgc_obd == NULL) {
CERROR("6a: no MGC devices connected to %s found.\n",
mgs_uuid->uuid);
GOTO(ctxt_release, rc = -ENOENT);
}
rc = obd_connect(NULL, &exp, mgc_obd, &uuid,
NULL /* obd_connect_data */, NULL);
if (rc != -EALREADY) {
CERROR("6a: connect on connected MGC (%s) failed to return"
" -EALREADY", mgc_obd->obd_name);
if (rc == 0)
obd_disconnect(exp);
GOTO(ctxt_release, rc = -EINVAL);
}
nctxt = llog_get_context(mgc_obd, LLOG_CONFIG_REPL_CTXT);
rc = llog_open(env, nctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("6a: llog_open failed %d\n", rc);
GOTO(nctxt_put, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc) {
CERROR("6a: llog_init_handle failed %d\n", rc);
GOTO(parse_out, rc);
}
plain_counter = 1; /* llog header is first record */
CWARN("6b: process log %s using client API\n", name);
rc = llog_process(env, llh, plain_print_cb, NULL, NULL);
if (rc)
CERROR("6b: llog_process failed %d\n", rc);
CWARN("6b: processed %d records\n", plain_counter);
rc = verify_handle("6b", llh, plain_counter);
if (rc)
GOTO(parse_out, rc);
plain_counter = 1; /* llog header is first record */
CWARN("6c: process log %s reversely using client API\n", name);
rc = llog_reverse_process(env, llh, plain_print_cb, NULL, NULL);
if (rc)
CERROR("6c: llog_reverse_process failed %d\n", rc);
CWARN("6c: processed %d records\n", plain_counter);
rc = verify_handle("6c", llh, plain_counter);
if (rc)
GOTO(parse_out, rc);
parse_out:
rc2 = llog_close(env, llh);
if (rc2) {
CERROR("6: llog_close failed: rc = %d\n", rc2);
if (rc == 0)
rc = rc2;
}
nctxt_put:
llog_ctxt_put(nctxt);
ctxt_release:
llog_ctxt_put(ctxt);
return rc;
}
/* Test log and catalogue processing */
static int llog_test_5(const struct lu_env *env, struct obd_device *obd)
{
struct llog_handle *llh = NULL;
char name[10];
int rc, rc2;
struct llog_mini_rec lmr;
struct llog_ctxt *ctxt;
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
lmr.lmr_hdr.lrh_type = 0xf00f00;
CWARN("5a: re-open catalog by id\n");
rc = llog_open(env, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("5a: llog_create with logid failed: %d\n", rc);
GOTO(out_put, rc);
}
rc = llog_init_handle(env, llh, LLOG_F_IS_CAT, &uuid);
if (rc) {
CERROR("5a: can't init llog handle: %d\n", rc);
GOTO(out, rc);
}
CWARN("5b: print the catalog entries.. we expect 2\n");
cat_counter = 0;
rc = llog_process(env, llh, cat_print_cb, "test 5", NULL);
if (rc) {
CERROR("5b: process with cat_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
if (cat_counter != 2) {
CERROR("5b: %d entries in catalog\n", cat_counter);
GOTO(out, rc = -EINVAL);
}
CWARN("5c: Cancel %d records, see one log zapped\n", LLOG_TEST_RECNUM);
cancel_count = 0;
rc = llog_cat_process(env, llh, llog_cancel_rec_cb, "foobar", 0, 0);
if (rc != -LLOG_EEMPTY) {
CERROR("5c: process with cat_cancel_cb failed: %d\n", rc);
GOTO(out, rc);
}
CWARN("5c: print the catalog entries.. we expect 1\n");
cat_counter = 0;
rc = llog_process(env, llh, cat_print_cb, "test 5", NULL);
if (rc) {
CERROR("5c: process with cat_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
if (cat_counter != 1) {
CERROR("5c: %d entries in catalog\n", cat_counter);
GOTO(out, rc = -EINVAL);
}
CWARN("5d: add 1 record to the log with many canceled empty pages\n");
rc = llog_cat_add(env, llh, &lmr.lmr_hdr, NULL, NULL);
if (rc) {
CERROR("5d: add record to the log with many canceled empty "
"pages failed\n");
GOTO(out, rc);
}
CWARN("5e: print plain log entries.. expect 6\n");
plain_counter = 0;
rc = llog_cat_process(env, llh, plain_print_cb, "foobar", 0, 0);
if (rc) {
CERROR("5e: process with plain_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
if (plain_counter != 6) {
CERROR("5e: found %d records\n", plain_counter);
GOTO(out, rc = -EINVAL);
}
CWARN("5f: print plain log entries reversely.. expect 6\n");
plain_counter = 0;
rc = llog_cat_reverse_process(env, llh, plain_print_cb, "foobar");
if (rc) {
CERROR("5f: reversely process with plain_print_cb failed:"
"%d\n", rc);
GOTO(out, rc);
}
if (plain_counter != 6) {
CERROR("5f: found %d records\n", plain_counter);
GOTO(out, rc = -EINVAL);
}
out:
CWARN("5g: close re-opened catalog\n");
rc2 = llog_cat_close(env, llh);
if (rc2) {
CERROR("5g: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
}
out_put:
llog_ctxt_put(ctxt);
return rc;
}
/* Test catalogue additions */
static int llog_test_4(const struct lu_env *env, struct obd_device *obd)
{
struct llog_handle *cath;
char name[10];
int rc, rc2, i, buflen;
struct llog_mini_rec lmr;
struct llog_cookie cookie;
struct llog_ctxt *ctxt;
int num_recs = 0;
char *buf;
struct llog_rec_hdr rec;
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
lmr.lmr_hdr.lrh_type = 0xf00f00;
sprintf(name, "%x", llog_test_rand + 1);
CWARN("4a: create a catalog log with name: %s\n", name);
rc = llog_open_create(env, ctxt, &cath, NULL, name);
if (rc) {
CERROR("4a: llog_create with name %s failed: %d\n", name, rc);
GOTO(ctxt_release, rc);
}
rc = llog_init_handle(env, cath, LLOG_F_IS_CAT, &uuid);
if (rc) {
CERROR("4a: can't init llog handle: %d\n", rc);
GOTO(out, rc);
}
num_recs++;
cat_logid = cath->lgh_id;
CWARN("4b: write 1 record into the catalog\n");
rc = llog_cat_add(env, cath, &lmr.lmr_hdr, &cookie, NULL);
if (rc != 1) {
CERROR("4b: write 1 catalog record failed at: %d\n", rc);
GOTO(out, rc);
}
num_recs++;
rc = verify_handle("4b", cath, 2);
if (rc)
GOTO(out, rc);
rc = verify_handle("4b", cath->u.chd.chd_current_log, num_recs);
if (rc)
GOTO(out, rc);
CWARN("4c: cancel 1 log record\n");
rc = llog_cat_cancel_records(env, cath, 1, &cookie);
if (rc) {
CERROR("4c: cancel 1 catalog based record failed: %d\n", rc);
GOTO(out, rc);
}
num_recs--;
rc = verify_handle("4c", cath->u.chd.chd_current_log, num_recs);
if (rc)
GOTO(out, rc);
CWARN("4d: write %d more log records\n", LLOG_TEST_RECNUM);
for (i = 0; i < LLOG_TEST_RECNUM; i++) {
rc = llog_cat_add(env, cath, &lmr.lmr_hdr, NULL, NULL);
if (rc) {
CERROR("4d: write %d records failed at #%d: %d\n",
LLOG_TEST_RECNUM, i + 1, rc);
GOTO(out, rc);
}
num_recs++;
}
/* make sure new plain llog appears */
rc = verify_handle("4d", cath, 3);
if (rc)
GOTO(out, rc);
CWARN("4e: add 5 large records, one record per block\n");
buflen = LLOG_CHUNK_SIZE - sizeof(struct llog_rec_hdr) -
sizeof(struct llog_rec_tail);
OBD_ALLOC(buf, buflen);
if (buf == NULL)
GOTO(out, rc = -ENOMEM);
for (i = 0; i < 5; i++) {
rec.lrh_len = buflen;
rec.lrh_type = OBD_CFG_REC;
rc = llog_cat_add(env, cath, &rec, NULL, buf);
if (rc) {
CERROR("4e: write 5 records failed at #%d: %d\n",
i + 1, rc);
GOTO(out_free, rc);
}
num_recs++;
}
out_free:
OBD_FREE(buf, buflen);
out:
CWARN("4f: put newly-created catalog\n");
rc2 = llog_cat_close(env, cath);
if (rc2) {
CERROR("4: close log %s failed: %d\n", name, rc2);
if (rc == 0)
rc = rc2;
}
ctxt_release:
llog_ctxt_put(ctxt);
return rc;
}
/* Test named-log reopen; returns opened log on success */
static int llog_test_2(const struct lu_env *env, struct obd_device *obd,
char *name, struct llog_handle **llh)
{
struct llog_ctxt *ctxt;
struct llog_handle *loghandle;
struct llog_logid logid;
int rc;
CWARN("2a: re-open a log with name: %s\n", name);
ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
LASSERT(ctxt);
rc = llog_open(env, ctxt, llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("2a: re-open log with name %s failed: %d\n", name, rc);
GOTO(out_put, rc);
}
rc = llog_init_handle(env, *llh, LLOG_F_IS_PLAIN, &uuid);
if (rc) {
CERROR("2a: can't init llog handle: %d\n", rc);
GOTO(out_close_llh, rc);
}
rc = verify_handle("2", *llh, 1);
if (rc)
GOTO(out_close_llh, rc);
/* XXX: there is known issue with tests 2b, MGS is not able to create
* anonymous llog, exit now to allow following tests run.
* It is fixed in upcoming llog over OSD code */
GOTO(out_put, rc);
CWARN("2b: create a log without specified NAME & LOGID\n");
rc = llog_open_create(env, ctxt, &loghandle, NULL, NULL);
if (rc) {
CERROR("2b: create log failed\n");
GOTO(out_close_llh, rc);
}
rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, &uuid);
if (rc) {
CERROR("2b: can't init llog handle: %d\n", rc);
GOTO(out_close, rc);
}
logid = loghandle->lgh_id;
llog_close(env, loghandle);
CWARN("2c: re-open the log by LOGID\n");
rc = llog_open(env, ctxt, &loghandle, &logid, NULL, LLOG_OPEN_EXISTS);
if (rc) {
CERROR("2c: re-open log by LOGID failed\n");
GOTO(out_close_llh, rc);
}
rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, &uuid);
if (rc) {
CERROR("2c: can't init llog handle: %d\n", rc);
GOTO(out_close, rc);
}
CWARN("2b: destroy this log\n");
rc = llog_destroy(env, loghandle);
if (rc)
CERROR("2d: destroy log failed\n");
out_close:
llog_close(env, loghandle);
out_close_llh:
if (rc)
llog_close(env, *llh);
out_put:
llog_ctxt_put(ctxt);
return rc;
}
/* backup plain llog */
int llog_backup(const struct lu_env *env, struct obd_device *obd,
struct llog_ctxt *ctxt, struct llog_ctxt *bctxt,
char *name, char *backup)
{
struct llog_handle *llh, *bllh;
int rc;
/* open original log */
rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc < 0) {
/* the -ENOENT case is also reported to the caller
* but silently so it should handle that if needed.
*/
if (rc != -ENOENT)
CERROR("%s: failed to open log %s: rc = %d\n",
obd->obd_name, name, rc);
return rc;
}
rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
/* Make sure there's no old backup log */
rc = llog_erase(env, bctxt, NULL, backup);
if (rc < 0 && rc != -ENOENT)
GOTO(out_close, rc);
/* open backup log */
rc = llog_open_create(env, bctxt, &bllh, NULL, backup);
if (rc) {
CERROR("%s: failed to open backup logfile %s: rc = %d\n",
obd->obd_name, backup, rc);
GOTO(out_close, rc);
}
/* check that backup llog is not the same object as original one */
if (llh->lgh_obj == bllh->lgh_obj) {
CERROR("%s: backup llog %s to itself (%s), objects %p/%p\n",
obd->obd_name, name, backup, llh->lgh_obj,
bllh->lgh_obj);
GOTO(out_backup, rc = -EEXIST);
}
rc = llog_init_handle(env, bllh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_backup, rc);
/* Copy log record by record */
rc = llog_process_or_fork(env, llh, llog_copy_handler, (void *)bllh,
NULL, false);
if (rc)
CERROR("%s: failed to backup log %s: rc = %d\n",
obd->obd_name, name, rc);
out_backup:
llog_close(env, bllh);
out_close:
llog_close(env, llh);
return rc;
}
int llog_ioctl(struct llog_ctxt *ctxt, int cmd, struct obd_ioctl_data *data)
{
struct llog_logid logid;
int err = 0;
struct llog_handle *handle = NULL;
ENTRY;
if (*data->ioc_inlbuf1 == '#') {
err = str2logid(&logid, data->ioc_inlbuf1, data->ioc_inllen1);
if (err)
GOTO(out, err);
err = llog_create(ctxt, &handle, &logid, NULL);
if (err)
GOTO(out, err);
} else if (*data->ioc_inlbuf1 == '$') {
char *name = data->ioc_inlbuf1 + 1;
err = llog_create(ctxt, &handle, NULL, name);
if (err)
GOTO(out, err);
} else {
GOTO(out, err = -EINVAL);
}
err = llog_init_handle(handle, 0, NULL);
if (err)
GOTO(out_close, err = -ENOENT);
switch (cmd) {
case OBD_IOC_LLOG_INFO: {
int l;
int remains = data->ioc_inllen2 +
cfs_size_round(data->ioc_inllen1);
char *out = data->ioc_bulk;
l = snprintf(out, remains,
"logid: #"LPX64"#"LPX64"#%08x\n"
"flags: %x (%s)\n"
"records count: %d\n"
"last index: %d\n",
handle->lgh_id.lgl_oid, handle->lgh_id.lgl_oseq,
handle->lgh_id.lgl_ogen,
handle->lgh_hdr->llh_flags,
handle->lgh_hdr->llh_flags &
LLOG_F_IS_CAT ? "cat" : "plain",
handle->lgh_hdr->llh_count,
handle->lgh_last_idx);
out += l;
remains -= l;
if (remains <= 0)
CERROR("not enough space for log header info\n");
GOTO(out_close, err);
}
case OBD_IOC_LLOG_CHECK: {
LASSERT(data->ioc_inllen1);
err = llog_process(handle, llog_check_cb, data, NULL);
if (err == -LLOG_EEMPTY)
err = 0;
GOTO(out_close, err);
}
case OBD_IOC_LLOG_PRINT: {
LASSERT(data->ioc_inllen1);
err = llog_process(handle, class_config_dump_handler,data,NULL);
if (err == -LLOG_EEMPTY)
err = 0;
else
err = llog_process(handle, llog_print_cb, data, NULL);
GOTO(out_close, err);
}
case OBD_IOC_LLOG_CANCEL: {
struct llog_cookie cookie;
struct llog_logid plain;
char *endp;
cookie.lgc_index = simple_strtoul(data->ioc_inlbuf3, &endp, 0);
if (*endp != '\0')
GOTO(out_close, err = -EINVAL);
if (handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT) {
cfs_down_write(&handle->lgh_lock);
err = llog_cancel_rec(handle, cookie.lgc_index);
cfs_up_write(&handle->lgh_lock);
GOTO(out_close, err);
}
err = str2logid(&plain, data->ioc_inlbuf2, data->ioc_inllen2);
if (err)
GOTO(out_close, err);
cookie.lgc_lgl = plain;
if (!(handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT))
GOTO(out_close, err = -EINVAL);
err = llog_cat_cancel_records(handle, 1, &cookie);
GOTO(out_close, err);
}
case OBD_IOC_LLOG_REMOVE: {
struct llog_logid plain;
if (handle->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN) {
err = llog_destroy(handle);
if (!err)
llog_free_handle(handle);
GOTO(out, err);
}
if (!(handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT))
GOTO(out_close, err = -EINVAL);
if (data->ioc_inlbuf2) {
/*remove indicate log from the catalog*/
err = str2logid(&plain, data->ioc_inlbuf2,
data->ioc_inllen2);
if (err)
GOTO(out_close, err);
err = llog_remove_log(handle, &plain);
} else {
/*remove all the log of the catalog*/
llog_process(handle, llog_delete_cb, NULL, NULL);
}
GOTO(out_close, err);
}
}
out_close:
if (handle->lgh_hdr &&
handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)
llog_cat_put(handle);
else
llog_close(handle);
out:
RETURN(err);
}
int llog_ioctl(const struct lu_env *env, struct llog_ctxt *ctxt, int cmd,
struct obd_ioctl_data *data)
{
struct llog_logid logid;
int rc = 0;
struct llog_handle *handle = NULL;
if (*data->ioc_inlbuf1 == '#') {
rc = str2logid(&logid, data->ioc_inlbuf1, data->ioc_inllen1);
if (rc)
return rc;
rc = llog_open(env, ctxt, &handle, &logid, NULL,
LLOG_OPEN_EXISTS);
if (rc)
return rc;
} else if (*data->ioc_inlbuf1 == '$') {
char *name = data->ioc_inlbuf1 + 1;
rc = llog_open(env, ctxt, &handle, NULL, name,
LLOG_OPEN_EXISTS);
if (rc)
return rc;
} else {
return -EINVAL;
}
rc = llog_init_handle(env, handle, 0, NULL);
if (rc)
GOTO(out_close, rc = -ENOENT);
switch (cmd) {
case OBD_IOC_LLOG_INFO: {
int l;
int remains = data->ioc_inllen2 +
cfs_size_round(data->ioc_inllen1);
char *out = data->ioc_bulk;
l = snprintf(out, remains,
"logid: #"DOSTID"#%08x\n"
"flags: %x (%s)\n"
"records count: %d\n"
"last index: %d\n",
POSTID(&handle->lgh_id.lgl_oi),
handle->lgh_id.lgl_ogen,
handle->lgh_hdr->llh_flags,
handle->lgh_hdr->llh_flags &
LLOG_F_IS_CAT ? "cat" : "plain",
handle->lgh_hdr->llh_count,
handle->lgh_last_idx);
out += l;
remains -= l;
if (remains <= 0) {
CERROR("%s: not enough space for log header info\n",
ctxt->loc_obd->obd_name);
rc = -ENOSPC;
}
break;
}
case OBD_IOC_LLOG_CHECK:
LASSERT(data->ioc_inllen1 > 0);
rc = llog_process(env, handle, llog_check_cb, data, NULL);
if (rc == -LLOG_EEMPTY)
rc = 0;
else if (rc)
GOTO(out_close, rc);
break;
case OBD_IOC_LLOG_PRINT:
LASSERT(data->ioc_inllen1 > 0);
rc = llog_process(env, handle, llog_print_cb, data, NULL);
if (rc == -LLOG_EEMPTY)
rc = 0;
else if (rc)
GOTO(out_close, rc);
break;
case OBD_IOC_LLOG_CANCEL: {
struct llog_cookie cookie;
struct llog_logid plain;
char *endp;
cookie.lgc_index = simple_strtoul(data->ioc_inlbuf3, &endp, 0);
if (*endp != '\0')
GOTO(out_close, rc = -EINVAL);
if (handle->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN) {
rc = llog_cancel_rec(NULL, handle, cookie.lgc_index);
GOTO(out_close, rc);
} else if (!(handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) {
GOTO(out_close, rc = -EINVAL);
}
if (data->ioc_inlbuf2 == NULL) /* catalog but no logid */
GOTO(out_close, rc = -ENOTTY);
rc = str2logid(&plain, data->ioc_inlbuf2, data->ioc_inllen2);
if (rc)
GOTO(out_close, rc);
cookie.lgc_lgl = plain;
rc = llog_cat_cancel_records(env, handle, 1, &cookie);
if (rc)
GOTO(out_close, rc);
break;
}
case OBD_IOC_LLOG_REMOVE: {
struct llog_logid plain;
if (handle->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN) {
rc = llog_destroy(env, handle);
GOTO(out_close, rc);
} else if (!(handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)) {
GOTO(out_close, rc = -EINVAL);
}
if (data->ioc_inlbuf2 > 0) {
/* remove indicate log from the catalog */
rc = str2logid(&plain, data->ioc_inlbuf2,
data->ioc_inllen2);
if (rc)
GOTO(out_close, rc);
rc = llog_remove_log(env, handle, &plain);
} else {
/* remove all the log of the catalog */
rc = llog_process(env, handle, llog_delete_cb, NULL,
NULL);
if (rc)
GOTO(out_close, rc);
}
break;
}
default:
CERROR("%s: Unknown ioctl cmd %#x\n",
ctxt->loc_obd->obd_name, cmd);
GOTO(out_close, rc = -ENOTTY);
}
out_close:
if (handle->lgh_hdr &&
handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT)
llog_cat_close(env, handle);
else
llog_close(env, handle);
return rc;
}
/* Test catalogue additions */
static int llog_test_4(struct obd_device *obd)
{
struct llog_handle *cath;
char name[10];
int rc, i, buflen;
struct llog_mini_rec lmr;
struct llog_cookie cookie;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
int num_recs = 0;
char *buf;
struct llog_rec_hdr rec;
ENTRY;
lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
lmr.lmr_hdr.lrh_type = 0xf00f00;
sprintf(name, "%x", llog_test_rand+1);
CWARN("4a: create a catalog log with name: %s\n", name);
rc = llog_create(ctxt, &cath, NULL, name);
if (rc) {
CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
GOTO(out, rc);
}
llog_init_handle(cath, LLOG_F_IS_CAT, &uuid);
num_recs++;
cat_logid = cath->lgh_id;
CWARN("4b: write 1 record into the catalog\n");
rc = llog_cat_add_rec(cath, &lmr.lmr_hdr, &cookie, NULL);
if (rc != 1) {
CERROR("4b: write 1 catalog record failed at: %d\n", rc);
GOTO(out, rc);
}
num_recs++;
if ((rc = verify_handle("4b", cath, 2)))
GOTO(ctxt_release, rc);
if ((rc = verify_handle("4b", cath->u.chd.chd_current_log, num_recs)))
GOTO(ctxt_release, rc);
CWARN("4c: cancel 1 log record\n");
rc = llog_cat_cancel_records(cath, 1, &cookie);
if (rc) {
CERROR("4c: cancel 1 catalog based record failed: %d\n", rc);
GOTO(out, rc);
}
num_recs--;
if ((rc = verify_handle("4c", cath->u.chd.chd_current_log, num_recs)))
GOTO(ctxt_release, rc);
CWARN("4d: write 40,000 more log records\n");
for (i = 0; i < 40000; i++) {
rc = llog_cat_add_rec(cath, &lmr.lmr_hdr, NULL, NULL);
if (rc) {
CERROR("4d: write 40000 records failed at #%d: %d\n",
i + 1, rc);
GOTO(out, rc);
}
num_recs++;
}
CWARN("4e: add 5 large records, one record per block\n");
buflen = LLOG_CHUNK_SIZE - sizeof(struct llog_rec_hdr)
- sizeof(struct llog_rec_tail);
OBD_ALLOC(buf, buflen);
if (buf == NULL)
GOTO(out, rc = -ENOMEM);
for (i = 0; i < 5; i++) {
rec.lrh_len = buflen;
rec.lrh_type = OBD_CFG_REC;
rc = llog_cat_add_rec(cath, &rec, NULL, buf);
if (rc) {
CERROR("4e: write 5 records failed at #%d: %d\n",
i + 1, rc);
OBD_FREE(buf, buflen);
GOTO(out, rc);
}
num_recs++;
}
OBD_FREE(buf, buflen);
out:
CWARN("4f: put newly-created catalog\n");
rc = llog_cat_put(cath);
ctxt_release:
llog_ctxt_put(ctxt);
if (rc)
CERROR("1b: close log %s failed: %d\n", name, rc);
RETURN(rc);
}
/* Test log and catalogue processing */
static int llog_test_5(struct obd_device *obd)
{
struct llog_handle *llh = NULL;
char name[10];
int rc;
struct llog_mini_rec lmr;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
ENTRY;
lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
lmr.lmr_hdr.lrh_type = 0xf00f00;
CWARN("5a: re-open catalog by id\n");
rc = llog_create(ctxt, &llh, &cat_logid, NULL);
if (rc) {
CERROR("5a: llog_create with logid failed: %d\n", rc);
GOTO(out, rc);
}
llog_init_handle(llh, LLOG_F_IS_CAT, &uuid);
CWARN("5b: print the catalog entries.. we expect 2\n");
rc = llog_process(llh, cat_print_cb, "test 5", NULL);
if (rc) {
CERROR("5b: process with cat_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
CWARN("5c: Cancel 40000 records, see one log zapped\n");
rc = llog_cat_process(llh, llog_cancel_rec_cb, "foobar", 0, 0);
if (rc != -4711) {
CERROR("5c: process with cat_cancel_cb failed: %d\n", rc);
GOTO(out, rc);
}
CWARN("5d: add 1 record to the log with many canceled empty pages\n");
rc = llog_cat_add_rec(llh, &lmr.lmr_hdr, NULL, NULL);
if (rc) {
CERROR("5d: add record to the log with many canceled empty\
pages failed\n");
GOTO(out, rc);
}
CWARN("5b: print the catalog entries.. we expect 1\n");
rc = llog_process(llh, cat_print_cb, "test 5", NULL);
if (rc) {
CERROR("5b: process with cat_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
CWARN("5e: print plain log entries.. expect 6\n");
rc = llog_cat_process(llh, plain_print_cb, "foobar", 0, 0);
if (rc) {
CERROR("5e: process with plain_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
CWARN("5f: print plain log entries reversely.. expect 6\n");
rc = llog_cat_reverse_process(llh, plain_print_cb, "foobar");
if (rc) {
CERROR("5f: reversely process with plain_print_cb failed: %d\n", rc);
GOTO(out, rc);
}
out:
CWARN("5: close re-opened catalog\n");
if (llh)
rc = llog_cat_put(llh);
if (rc)
CERROR("1b: close log %s failed: %d\n", name, rc);
llog_ctxt_put(ctxt);
RETURN(rc);
}
static int llog_catinfo_deletions(struct obd_device *obd, char *buf,
int buf_len)
{
struct mds_obd *mds = &obd->u.mds;
struct llog_handle *handle;
struct lvfs_run_ctxt saved;
int size, i, count;
struct llog_catid *idarray;
char name[32] = CATLIST;
struct cb_data data;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
int rc;
ENTRY;
if (ctxt == NULL || mds == NULL)
GOTO(release_ctxt, rc = -ENODEV);
count = mds->mds_lov_desc.ld_tgt_count;
size = sizeof(*idarray) * count;
OBD_ALLOC_LARGE(idarray, size);
if (!idarray)
GOTO(release_ctxt, rc = -ENOMEM);
cfs_mutex_lock(&obd->obd_olg.olg_cat_processing);
rc = llog_get_cat_list(obd, name, 0, count, idarray);
if (rc)
GOTO(out_free, rc);
push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
data.ctxt = ctxt;
data.out = buf;
data.remains = buf_len;
for (i = 0; i < count; i++) {
int l, index, uncanceled = 0;
rc = llog_create(ctxt, &handle, &idarray[i].lci_logid, NULL);
if (rc)
GOTO(out_pop, rc);
rc = llog_init_handle(handle, 0, NULL);
if (rc) {
llog_close(handle);
GOTO(out_pop, rc = -ENOENT);
}
for (index = 1; index < (LLOG_BITMAP_BYTES * 8); index++) {
if (ext2_test_bit(index, handle->lgh_hdr->llh_bitmap))
uncanceled++;
}
l = snprintf(data.out, data.remains,
"\n[Catlog ID]: #"LPX64"#"LPX64"#%08x "
"[Log Count]: %d\n",
idarray[i].lci_logid.lgl_oid,
idarray[i].lci_logid.lgl_oseq,
idarray[i].lci_logid.lgl_ogen, uncanceled);
data.out += l;
data.remains -= l;
data.init = 1;
llog_process(handle, llog_catinfo_cb, &data, NULL);
llog_close(handle);
if (data.remains <= 0)
break;
}
EXIT;
out_pop:
pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
out_free:
cfs_mutex_unlock(&obd->obd_olg.olg_cat_processing);
OBD_FREE_LARGE(idarray, size);
release_ctxt:
llog_ctxt_put(ctxt);
return rc;
}
/* Test client api; open log by name and process */
static int llog_test_6(struct obd_device *obd, char *name)
{
struct obd_device *mgc_obd;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
struct obd_uuid *mgs_uuid = &ctxt->loc_exp->exp_obd->obd_uuid;
struct obd_export *exp;
struct obd_uuid uuid = {"LLOG_TEST6_UUID"};
struct llog_handle *llh = NULL;
struct llog_ctxt *nctxt;
int rc;
CWARN("6a: re-open log %s using client API\n", name);
mgc_obd = class_find_client_obd(mgs_uuid, LUSTRE_MGC_NAME, NULL);
if (mgc_obd == NULL) {
CERROR("6: no MGC devices connected to %s found.\n",
mgs_uuid->uuid);
GOTO(ctxt_release, rc = -ENOENT);
}
rc = obd_connect(NULL, &exp, mgc_obd, &uuid,
NULL /* obd_connect_data */, NULL);
if (rc != -EALREADY) {
CERROR("6: connect on connected MDC (%s) failed to return"
" -EALREADY", mgc_obd->obd_name);
if (rc == 0)
obd_disconnect(exp);
GOTO(ctxt_release, rc = -EINVAL);
}
nctxt = llog_get_context(mgc_obd, LLOG_CONFIG_REPL_CTXT);
rc = llog_create(nctxt, &llh, NULL, name);
if (rc) {
CERROR("6: llog_create failed %d\n", rc);
llog_ctxt_put(nctxt);
GOTO(ctxt_release, rc);
}
rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
if (rc) {
CERROR("6: llog_init_handle failed %d\n", rc);
GOTO(parse_out, rc);
}
rc = llog_process(llh, plain_print_cb, NULL, NULL);
if (rc)
CERROR("6: llog_process failed %d\n", rc);
rc = llog_reverse_process(llh, plain_print_cb, NULL, NULL);
if (rc)
CERROR("6: llog_reverse_process failed %d\n", rc);
parse_out:
rc = llog_close(llh);
llog_ctxt_put(nctxt);
if (rc) {
CERROR("6: llog_close failed: rc = %d\n", rc);
}
ctxt_release:
llog_ctxt_put(ctxt);
RETURN(rc);
}
int llog_origin_handle_prev_block(struct ptlrpc_request *req)
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
struct llog_handle *loghandle;
struct llogd_body *body;
struct llogd_body *repbody;
struct obd_device *disk_obd;
struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
__u32 flags;
__u8 *buf;
void *ptr;
int rc, rc2;
ENTRY;
body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (body == NULL)
RETURN(-EFAULT);
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (!buf)
RETURN(-ENOMEM);
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
GOTO(out_free, rc = -ENODEV);
disk_obd = ctxt->loc_exp->exp_obd;
push_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
rc = llog_create(ctxt, &loghandle, &body->lgd_logid, NULL);
if (rc)
GOTO(out_pop, rc);
flags = body->lgd_llh_flags;
rc = llog_init_handle(loghandle, flags, NULL);
if (rc)
GOTO(out_close, rc);
memset(buf, 0, LLOG_CHUNK_SIZE);
rc = llog_prev_block(loghandle, body->lgd_index,
buf, LLOG_CHUNK_SIZE);
if (rc)
GOTO(out_close, rc);
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
LLOG_CHUNK_SIZE);
rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
*repbody = *body;
ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
memcpy(ptr, buf, LLOG_CHUNK_SIZE);
GOTO(out_close, rc);
out_close:
rc2 = llog_close(loghandle);
if (!rc)
rc = rc2;
out_pop:
pop_ctxt(&saved, &disk_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
out_free:
OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}