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;
}
static int llog_process_thread(void *arg)
{
struct llog_process_info *lpi = arg;
struct llog_handle *loghandle = lpi->lpi_loghandle;
struct llog_log_hdr *llh = loghandle->lgh_hdr;
struct llog_process_cat_data *cd = lpi->lpi_catdata;
char *buf;
__u64 cur_offset = LLOG_CHUNK_SIZE;
__u64 last_offset;
int rc = 0, index = 1, last_index;
int saved_index = 0;
int last_called_index = 0;
LASSERT(llh);
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (!buf) {
lpi->lpi_rc = -ENOMEM;
return 0;
}
if (cd != NULL) {
last_called_index = cd->lpcd_first_idx;
index = cd->lpcd_first_idx + 1;
}
if (cd != NULL && cd->lpcd_last_idx)
last_index = cd->lpcd_last_idx;
else
last_index = LLOG_BITMAP_BYTES * 8 - 1;
while (rc == 0) {
struct llog_rec_hdr *rec;
/* skip records not set in bitmap */
while (index <= last_index &&
!ext2_test_bit(index, llh->llh_bitmap))
++index;
LASSERT(index <= last_index + 1);
if (index == last_index + 1)
break;
repeat:
CDEBUG(D_OTHER, "index: %d last_index %d\n",
index, last_index);
/* get the buf with our target record; avoid old garbage */
memset(buf, 0, LLOG_CHUNK_SIZE);
last_offset = cur_offset;
rc = llog_next_block(lpi->lpi_env, loghandle, &saved_index,
index, &cur_offset, buf, LLOG_CHUNK_SIZE);
if (rc)
GOTO(out, rc);
/* NB: when rec->lrh_len is accessed it is already swabbed
* since it is used at the "end" of the loop and the rec
* swabbing is done at the beginning of the loop. */
for (rec = (struct llog_rec_hdr *)buf;
(char *)rec < buf + LLOG_CHUNK_SIZE;
rec = (struct llog_rec_hdr *)((char *)rec + rec->lrh_len)){
CDEBUG(D_OTHER, "processing rec 0x%p type %#x\n",
rec, rec->lrh_type);
if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
lustre_swab_llog_rec(rec);
CDEBUG(D_OTHER, "after swabbing, type=%#x idx=%d\n",
rec->lrh_type, rec->lrh_index);
if (rec->lrh_index == 0) {
/* probably another rec just got added? */
if (index <= loghandle->lgh_last_idx)
GOTO(repeat, rc = 0);
GOTO(out, rc = 0); /* no more records */
}
if (rec->lrh_len == 0 ||
rec->lrh_len > LLOG_CHUNK_SIZE) {
CWARN("invalid length %d in llog record for "
"index %d/%d\n", rec->lrh_len,
rec->lrh_index, index);
GOTO(out, rc = -EINVAL);
}
if (rec->lrh_index < index) {
CDEBUG(D_OTHER, "skipping lrh_index %d\n",
rec->lrh_index);
continue;
}
CDEBUG(D_OTHER,
"lrh_index: %d lrh_len: %d (%d remains)\n",
rec->lrh_index, rec->lrh_len,
(int)(buf + LLOG_CHUNK_SIZE - (char *)rec));
loghandle->lgh_cur_idx = rec->lrh_index;
loghandle->lgh_cur_offset = (char *)rec - (char *)buf +
last_offset;
/* if set, process the callback on this record */
if (ext2_test_bit(index, llh->llh_bitmap)) {
rc = lpi->lpi_cb(lpi->lpi_env, loghandle, rec,
lpi->lpi_cbdata);
last_called_index = index;
if (rc == LLOG_PROC_BREAK) {
GOTO(out, rc);
} else if (rc == LLOG_DEL_RECORD) {
llog_cancel_rec(lpi->lpi_env,
loghandle,
rec->lrh_index);
rc = 0;
}
if (rc)
GOTO(out, rc);
} else {
CDEBUG(D_OTHER, "Skipped index %d\n", index);
}
/* next record, still in buffer? */
++index;
if (index > last_index)
GOTO(out, rc = 0);
}
}
out:
if (cd != NULL)
cd->lpcd_last_idx = last_called_index;
OBD_FREE(buf, LLOG_CHUNK_SIZE);
lpi->lpi_rc = rc;
return 0;
}
static int llog_process_thread(void *arg)
{
struct llog_process_info *lpi = arg;
struct llog_handle *loghandle = lpi->lpi_loghandle;
struct llog_log_hdr *llh = loghandle->lgh_hdr;
struct llog_process_cat_data *cd = lpi->lpi_catdata;
char *buf;
size_t chunk_size;
__u64 cur_offset, tmp_offset;
int rc = 0, index = 1, last_index;
int saved_index = 0;
int last_called_index = 0;
ENTRY;
if (llh == NULL)
RETURN(-EINVAL);
cur_offset = chunk_size = llh->llh_hdr.lrh_len;
/* expect chunk_size to be power of two */
LASSERT(is_power_of_2(chunk_size));
OBD_ALLOC_LARGE(buf, chunk_size);
if (buf == NULL) {
lpi->lpi_rc = -ENOMEM;
RETURN(0);
}
if (cd != NULL) {
last_called_index = cd->lpcd_first_idx;
index = cd->lpcd_first_idx + 1;
}
if (cd != NULL && cd->lpcd_last_idx)
last_index = cd->lpcd_last_idx;
else
last_index = LLOG_HDR_BITMAP_SIZE(llh) - 1;
while (rc == 0) {
struct llog_rec_hdr *rec;
off_t chunk_offset;
unsigned int buf_offset = 0;
bool partial_chunk;
/* skip records not set in bitmap */
while (index <= last_index &&
!ext2_test_bit(index, LLOG_HDR_BITMAP(llh)))
++index;
/* There are no indices prior the last_index */
if (index > last_index)
break;
CDEBUG(D_OTHER, "index: %d last_index %d\n", index,
last_index);
repeat:
/* get the buf with our target record; avoid old garbage */
memset(buf, 0, chunk_size);
rc = llog_next_block(lpi->lpi_env, loghandle, &saved_index,
index, &cur_offset, buf, chunk_size);
if (rc != 0)
GOTO(out, rc);
/* NB: after llog_next_block() call the cur_offset is the
* offset of the next block after read one.
* The absolute offset of the current chunk is calculated
* from cur_offset value and stored in chunk_offset variable.
*/
tmp_offset = cur_offset;
if (do_div(tmp_offset, chunk_size) != 0) {
partial_chunk = true;
chunk_offset = cur_offset & ~(chunk_size - 1);
} else {
partial_chunk = false;
chunk_offset = cur_offset - chunk_size;
}
/* NB: when rec->lrh_len is accessed it is already swabbed
* since it is used at the "end" of the loop and the rec
* swabbing is done at the beginning of the loop. */
for (rec = (struct llog_rec_hdr *)(buf + buf_offset);
(char *)rec < buf + chunk_size;
rec = llog_rec_hdr_next(rec)) {
CDEBUG(D_OTHER, "processing rec 0x%p type %#x\n",
rec, rec->lrh_type);
if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
lustre_swab_llog_rec(rec);
CDEBUG(D_OTHER, "after swabbing, type=%#x idx=%d\n",
rec->lrh_type, rec->lrh_index);
/* for partial chunk the end of it is zeroed, check
* for index 0 to distinguish it. */
if (partial_chunk && rec->lrh_index == 0) {
/* concurrent llog_add() might add new records
* while llog_processing, check this is not
* the case and re-read the current chunk
* otherwise. */
if (index > loghandle->lgh_last_idx)
GOTO(out, rc = 0);
CDEBUG(D_OTHER, "Re-read last llog buffer for "
"new records, index %u, last %u\n",
index, loghandle->lgh_last_idx);
/* save offset inside buffer for the re-read */
buf_offset = (char *)rec - (char *)buf;
cur_offset = chunk_offset;
goto repeat;
}
if (rec->lrh_len == 0 || rec->lrh_len > chunk_size) {
CWARN("invalid length %d in llog record for "
"index %d/%d\n", rec->lrh_len,
rec->lrh_index, index);
GOTO(out, rc = -EINVAL);
}
if (rec->lrh_index < index) {
CDEBUG(D_OTHER, "skipping lrh_index %d\n",
rec->lrh_index);
continue;
}
if (rec->lrh_index != index) {
CERROR("%s: Invalid record: index %u but "
"expected %u\n",
loghandle->lgh_ctxt->loc_obd->obd_name,
rec->lrh_index, index);
GOTO(out, rc = -ERANGE);
}
CDEBUG(D_OTHER,
"lrh_index: %d lrh_len: %d (%d remains)\n",
rec->lrh_index, rec->lrh_len,
(int)(buf + chunk_size - (char *)rec));
loghandle->lgh_cur_idx = rec->lrh_index;
loghandle->lgh_cur_offset = (char *)rec - (char *)buf +
chunk_offset;
/* if set, process the callback on this record */
if (ext2_test_bit(index, LLOG_HDR_BITMAP(llh))) {
rc = lpi->lpi_cb(lpi->lpi_env, loghandle, rec,
lpi->lpi_cbdata);
last_called_index = index;
if (rc == LLOG_PROC_BREAK) {
GOTO(out, rc);
} else if (rc == LLOG_DEL_RECORD) {
rc = llog_cancel_rec(lpi->lpi_env,
loghandle,
rec->lrh_index);
}
if (rc)
GOTO(out, rc);
}
/* exit if the last index is reached */
if (index >= last_index)
GOTO(out, rc = 0);
++index;
}
}
out:
if (cd != NULL)
cd->lpcd_last_idx = last_called_index;
if (unlikely(rc == -EIO && loghandle->lgh_obj != NULL)) {
if (dt_object_remote(loghandle->lgh_obj)) {
/* If it is remote object, then -EIO might means
* disconnection or eviction, let's return -EAGAIN,
* so for update recovery log processing, it will
* retry until the umount or abort recovery, see
* lod_sub_recovery_thread() */
CERROR("%s retry remote llog process\n",
loghandle->lgh_ctxt->loc_obd->obd_name);
rc = -EAGAIN;
} else {
/* something bad happened to the processing of a local
* llog file, probably I/O error or the log got
* corrupted to be able to finally release the log we
* discard any remaining bits in the header */
CERROR("Local llog found corrupted\n");
while (index <= last_index) {
if (ext2_test_bit(index,
LLOG_HDR_BITMAP(llh)) != 0)
llog_cancel_rec(lpi->lpi_env, loghandle,
index);
index++;
}
rc = 0;
}
}
OBD_FREE_LARGE(buf, chunk_size);
lpi->lpi_rc = rc;
return 0;
}
int llog_origin_handle_next_block(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 llogd_body *repbody;
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_next_block(loghandle, &body->lgd_saved_index,
body->lgd_index,
&body->lgd_cur_offset, 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;
}
static int llog_process_thread(void *arg)
{
struct llog_process_info *lpi = arg;
struct llog_handle *loghandle = lpi->lpi_loghandle;
struct llog_log_hdr *llh = loghandle->lgh_hdr;
struct llog_process_cat_data *cd = lpi->lpi_catdata;
char *buf;
u64 cur_offset, tmp_offset;
int chunk_size;
int rc = 0, index = 1, last_index;
int saved_index = 0;
int last_called_index = 0;
if (!llh)
return -EINVAL;
cur_offset = llh->llh_hdr.lrh_len;
chunk_size = llh->llh_hdr.lrh_len;
/* expect chunk_size to be power of two */
LASSERT(is_power_of_2(chunk_size));
buf = libcfs_kvzalloc(chunk_size, GFP_NOFS);
if (!buf) {
lpi->lpi_rc = -ENOMEM;
return 0;
}
if (cd) {
last_called_index = cd->lpcd_first_idx;
index = cd->lpcd_first_idx + 1;
}
if (cd && cd->lpcd_last_idx)
last_index = cd->lpcd_last_idx;
else
last_index = LLOG_HDR_BITMAP_SIZE(llh) - 1;
while (rc == 0) {
unsigned int buf_offset = 0;
struct llog_rec_hdr *rec;
bool partial_chunk;
off_t chunk_offset;
/* skip records not set in bitmap */
while (index <= last_index &&
!ext2_test_bit(index, LLOG_HDR_BITMAP(llh)))
++index;
if (index > last_index)
break;
CDEBUG(D_OTHER, "index: %d last_index %d\n",
index, last_index);
repeat:
/* get the buf with our target record; avoid old garbage */
memset(buf, 0, chunk_size);
rc = llog_next_block(lpi->lpi_env, loghandle, &saved_index,
index, &cur_offset, buf, chunk_size);
if (rc)
goto out;
/*
* NB: after llog_next_block() call the cur_offset is the
* offset of the next block after read one.
* The absolute offset of the current chunk is calculated
* from cur_offset value and stored in chunk_offset variable.
*/
tmp_offset = cur_offset;
if (do_div(tmp_offset, chunk_size)) {
partial_chunk = true;
chunk_offset = cur_offset & ~(chunk_size - 1);
} else {
partial_chunk = false;
chunk_offset = cur_offset - chunk_size;
}
/* NB: when rec->lrh_len is accessed it is already swabbed
* since it is used at the "end" of the loop and the rec
* swabbing is done at the beginning of the loop.
*/
for (rec = (struct llog_rec_hdr *)(buf + buf_offset);
(char *)rec < buf + chunk_size;
rec = llog_rec_hdr_next(rec)) {
CDEBUG(D_OTHER, "processing rec 0x%p type %#x\n",
rec, rec->lrh_type);
if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
lustre_swab_llog_rec(rec);
CDEBUG(D_OTHER, "after swabbing, type=%#x idx=%d\n",
rec->lrh_type, rec->lrh_index);
/*
* for partial chunk the end of it is zeroed, check
* for index 0 to distinguish it.
*/
if (partial_chunk && !rec->lrh_index) {
/* concurrent llog_add() might add new records
* while llog_processing, check this is not
* the case and re-read the current chunk
* otherwise.
*/
if (index > loghandle->lgh_last_idx) {
rc = 0;
goto out;
}
CDEBUG(D_OTHER, "Re-read last llog buffer for new records, index %u, last %u\n",
index, loghandle->lgh_last_idx);
/* save offset inside buffer for the re-read */
buf_offset = (char *)rec - (char *)buf;
cur_offset = chunk_offset;
goto repeat;
}
if (!rec->lrh_len || rec->lrh_len > chunk_size) {
CWARN("invalid length %d in llog record for index %d/%d\n",
rec->lrh_len,
rec->lrh_index, index);
rc = -EINVAL;
goto out;
}
if (rec->lrh_index < index) {
CDEBUG(D_OTHER, "skipping lrh_index %d\n",
rec->lrh_index);
continue;
}
if (rec->lrh_index != index) {
CERROR("%s: Invalid record: index %u but expected %u\n",
loghandle->lgh_ctxt->loc_obd->obd_name,
rec->lrh_index, index);
rc = -ERANGE;
goto out;
}
CDEBUG(D_OTHER,
"lrh_index: %d lrh_len: %d (%d remains)\n",
rec->lrh_index, rec->lrh_len,
(int)(buf + chunk_size - (char *)rec));
loghandle->lgh_cur_idx = rec->lrh_index;
loghandle->lgh_cur_offset = (char *)rec - (char *)buf +
chunk_offset;
/* if set, process the callback on this record */
if (ext2_test_bit(index, LLOG_HDR_BITMAP(llh))) {
rc = lpi->lpi_cb(lpi->lpi_env, loghandle, rec,
lpi->lpi_cbdata);
last_called_index = index;
if (rc)
goto out;
}
/* exit if the last index is reached */
if (index >= last_index) {
rc = 0;
goto out;
}
index++;
}
}
out:
if (cd)
cd->lpcd_last_idx = last_called_index;
kfree(buf);
lpi->lpi_rc = rc;
return 0;
}
