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);
}
/* reads the catalog list */
int llog_osd_get_cat_list(const struct lu_env *env, struct dt_device *d,
int idx, int count, struct llog_catid *idarray)
{
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);
lu_local_obj_fid(&lgi->lgi_fid, LLOG_CATALOGS_OID);
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 + size)
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);
}
static int llog_osd_write_blob(const struct lu_env *env, struct dt_object *o,
struct llog_rec_hdr *rec, void *buf,
loff_t *off, struct thandle *th)
{
struct llog_thread_info *lgi = llog_info(env);
int buflen = rec->lrh_len;
int rc;
ENTRY;
LASSERT(env);
LASSERT(o);
if (buflen == 0)
CWARN("0-length record\n");
CDEBUG(D_OTHER, "write blob with type %x, buf %p/%u at off %llu\n",
rec->lrh_type, buf, buflen, *off);
if (!buf) {
lgi->lgi_buf.lb_len = buflen;
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc)
CERROR("%s: error writing log record: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
RETURN(rc);
}
/* the buf case */
/* protect the following 3 writes from concurrent read */
dt_write_lock(env, o, 0);
rec->lrh_len = sizeof(*rec) + buflen + sizeof(lgi->lgi_tail);
lgi->lgi_buf.lb_len = sizeof(*rec);
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc) {
CERROR("%s: error writing log hdr: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out, rc);
}
lgi->lgi_buf.lb_len = buflen;
lgi->lgi_buf.lb_buf = buf;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc) {
CERROR("%s: error writing log buffer: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out, rc);
}
lgi->lgi_tail.lrt_len = rec->lrh_len;
lgi->lgi_tail.lrt_index = rec->lrh_index;
lgi->lgi_buf.lb_len = sizeof(lgi->lgi_tail);
lgi->lgi_buf.lb_buf = &lgi->lgi_tail;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc)
CERROR("%s: error writing log tail: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
out:
dt_write_unlock(env, o);
RETURN(rc);
}
/**
* Implementation of the llog_operations::lop_open
*
* This function opens the llog by its logid or by name, it may open also
* non existent llog and assing then new id to it.
* The llog_open/llog_close pair works similar to lu_object_find/put,
* the object may not exist prior open. The result of open is just dt_object
* in the llog header.
*
* \param[in] env execution environment
* \param[in] handle llog handle of the current llog
* \param[in] logid logid of llog to open (nameless llog)
* \param[in] name name of llog to open (named llog)
* \param[in] open_param
* LLOG_OPEN_NEW - new llog, may not exist
* LLOG_OPEN_EXIST - old llog, must exist
*
* \retval 0 on successful open, llog_handle::lgh_obj
* contains the dt_object of the llog.
* \retval negative value on error
*/
static int llog_osd_open(const struct lu_env *env, struct llog_handle *handle,
struct llog_logid *logid, char *name,
enum llog_open_param open_param)
{
struct llog_thread_info *lgi = llog_info(env);
struct llog_ctxt *ctxt = handle->lgh_ctxt;
struct dt_object *o;
struct dt_device *dt;
struct ls_device *ls;
struct local_oid_storage *los;
int rc = 0;
ENTRY;
LASSERT(env);
LASSERT(ctxt);
LASSERT(ctxt->loc_exp);
LASSERT(ctxt->loc_exp->exp_obd);
dt = ctxt->loc_exp->exp_obd->obd_lvfs_ctxt.dt;
LASSERT(dt);
ls = ls_device_get(dt);
if (IS_ERR(ls))
RETURN(PTR_ERR(ls));
mutex_lock(&ls->ls_los_mutex);
los = dt_los_find(ls, name != NULL ? FID_SEQ_LLOG_NAME : FID_SEQ_LLOG);
mutex_unlock(&ls->ls_los_mutex);
LASSERT(los);
ls_device_put(env, ls);
LASSERT(handle);
if (logid != NULL) {
logid_to_fid(logid, &lgi->lgi_fid);
} else if (name) {
struct dt_object *llog_dir;
llog_dir = llog_osd_dir_get(env, ctxt);
if (IS_ERR(llog_dir))
GOTO(out, rc = PTR_ERR(llog_dir));
dt_read_lock(env, llog_dir, 0);
rc = dt_lookup_dir(env, llog_dir, name, &lgi->lgi_fid);
dt_read_unlock(env, llog_dir);
lu_object_put(env, &llog_dir->do_lu);
if (rc == -ENOENT && open_param == LLOG_OPEN_NEW) {
/* generate fid for new llog */
rc = local_object_fid_generate(env, los,
&lgi->lgi_fid);
}
if (rc < 0)
GOTO(out, rc);
OBD_ALLOC(handle->lgh_name, strlen(name) + 1);
if (handle->lgh_name)
strcpy(handle->lgh_name, name);
else
GOTO(out, rc = -ENOMEM);
} else {
LASSERTF(open_param & LLOG_OPEN_NEW, "%#x\n", open_param);
/* generate fid for new llog */
rc = local_object_fid_generate(env, los, &lgi->lgi_fid);
if (rc < 0)
GOTO(out, rc);
}
o = ls_locate(env, ls, &lgi->lgi_fid, NULL);
if (IS_ERR(o))
GOTO(out_name, rc = PTR_ERR(o));
/* No new llog is expected but doesn't exist */
if (open_param != LLOG_OPEN_NEW && !dt_object_exists(o))
GOTO(out_put, rc = -ENOENT);
fid_to_logid(&lgi->lgi_fid, &handle->lgh_id);
handle->lgh_obj = o;
handle->private_data = los;
LASSERT(handle->lgh_ctxt);
RETURN(rc);
out_put:
lu_object_put(env, &o->do_lu);
out_name:
if (handle->lgh_name != NULL)
OBD_FREE(handle->lgh_name, strlen(name) + 1);
out:
dt_los_put(los);
RETURN(rc);
}
/* returns negative on error; 0 if success; 1 if success & log destroyed */
int llog_cancel_rec(const struct lu_env *env, struct llog_handle *loghandle,
int index)
{
struct llog_thread_info *lgi = llog_info(env);
struct dt_device *dt;
struct llog_log_hdr *llh = loghandle->lgh_hdr;
struct thandle *th;
int rc;
int rc1;
bool subtract_count = false;
ENTRY;
CDEBUG(D_RPCTRACE, "Canceling %d in log "DOSTID"\n", index,
POSTID(&loghandle->lgh_id.lgl_oi));
if (index == 0) {
CERROR("Can't cancel index 0 which is header\n");
RETURN(-EINVAL);
}
LASSERT(loghandle != NULL);
LASSERT(loghandle->lgh_ctxt != NULL);
LASSERT(loghandle->lgh_obj != NULL);
dt = lu2dt_dev(loghandle->lgh_obj->do_lu.lo_dev);
th = dt_trans_create(env, dt);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
rc = llog_declare_write_rec(env, loghandle, &llh->llh_hdr, index, th);
if (rc < 0)
GOTO(out_trans, rc);
if ((llh->llh_flags & LLOG_F_ZAP_WHEN_EMPTY))
rc = llog_declare_destroy(env, loghandle, th);
th->th_wait_submit = 1;
rc = dt_trans_start_local(env, dt, th);
if (rc < 0)
GOTO(out_trans, rc);
down_write(&loghandle->lgh_lock);
/* clear bitmap */
mutex_lock(&loghandle->lgh_hdr_mutex);
if (!ext2_clear_bit(index, LLOG_HDR_BITMAP(llh))) {
CDEBUG(D_RPCTRACE, "Catalog index %u already clear?\n", index);
GOTO(out_unlock, rc);
}
loghandle->lgh_hdr->llh_count--;
subtract_count = true;
/* Pass this index to llog_osd_write_rec(), which will use the index
* to only update the necesary bitmap. */
lgi->lgi_cookie.lgc_index = index;
/* update header */
rc = llog_write_rec(env, loghandle, &llh->llh_hdr, &lgi->lgi_cookie,
LLOG_HEADER_IDX, th);
if (rc != 0)
GOTO(out_unlock, rc);
if ((llh->llh_flags & LLOG_F_ZAP_WHEN_EMPTY) &&
(llh->llh_count == 1) &&
((loghandle->lgh_last_idx == LLOG_HDR_BITMAP_SIZE(llh) - 1) ||
(loghandle->u.phd.phd_cat_handle != NULL &&
loghandle->u.phd.phd_cat_handle->u.chd.chd_current_log !=
loghandle))) {
/* never try to destroy it again */
llh->llh_flags &= ~LLOG_F_ZAP_WHEN_EMPTY;
rc = llog_trans_destroy(env, loghandle, th);
if (rc < 0) {
/* Sigh, can not destroy the final plain llog, but
* the bitmap has been clearly, so the record can not
* be accessed anymore, let's return 0 for now, and
* the orphan will be handled by LFSCK. */
CERROR("%s: can't destroy empty llog #"DOSTID
"#%08x: rc = %d\n",
loghandle->lgh_ctxt->loc_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, rc);
GOTO(out_unlock, rc);
}
rc = LLOG_DEL_PLAIN;
}
out_unlock:
mutex_unlock(&loghandle->lgh_hdr_mutex);
up_write(&loghandle->lgh_lock);
out_trans:
rc1 = dt_trans_stop(env, dt, th);
if (rc == 0)
rc = rc1;
if (rc < 0 && subtract_count) {
mutex_lock(&loghandle->lgh_hdr_mutex);
loghandle->lgh_hdr->llh_count++;
ext2_set_bit(index, LLOG_HDR_BITMAP(llh));
mutex_unlock(&loghandle->lgh_hdr_mutex);
}
RETURN(rc);
}
/**
* Implementation of the llog_operations::lop_prev_block
*
* This function finds the llog block to return which contains
* record with required index but in reverse order - from end of llog
* to the beginning.
* It is main part of reverse llog processing.
*
* \param[in] env execution environment
* \param[in] loghandle llog handle of the current llog
* \param[in] prev_idx target index to find
* \param[in] buf pointer to data buffer to fill
* \param[in] len required len to read, it is LLOG_CHUNK_SIZE usually.
*
* \retval 0 on successful buffer read
* \retval negative value on error
*/
static int llog_osd_prev_block(const struct lu_env *env,
struct llog_handle *loghandle,
int prev_idx, void *buf, int len)
{
struct llog_thread_info *lgi = llog_info(env);
struct dt_object *o;
struct dt_device *dt;
loff_t cur_offset;
int rc;
ENTRY;
if (len == 0 || len & (LLOG_CHUNK_SIZE - 1))
RETURN(-EINVAL);
CDEBUG(D_OTHER, "looking for log index %u\n", prev_idx);
LASSERT(loghandle);
LASSERT(loghandle->lgh_ctxt);
o = loghandle->lgh_obj;
LASSERT(o);
LASSERT(dt_object_exists(o));
dt = lu2dt_dev(o->do_lu.lo_dev);
LASSERT(dt);
cur_offset = LLOG_CHUNK_SIZE;
llog_skip_over(&cur_offset, 0, prev_idx);
rc = dt_attr_get(env, o, &lgi->lgi_attr, BYPASS_CAPA);
if (rc)
GOTO(out, rc);
while (cur_offset < lgi->lgi_attr.la_size) {
struct llog_rec_hdr *rec, *last_rec;
struct llog_rec_tail *tail;
lgi->lgi_buf.lb_len = len;
lgi->lgi_buf.lb_buf = buf;
rc = dt_read(env, o, &lgi->lgi_buf, &cur_offset);
if (rc < 0) {
CERROR("%s: can't read llog block from log "DFID
" offset "LPU64": rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), cur_offset, rc);
GOTO(out, rc);
}
if (rc == 0) /* end of file, nothing to do */
GOTO(out, rc);
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
"offset "LPU64"\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
GOTO(out, rc = -EINVAL);
}
rec = buf;
if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
lustre_swab_llog_rec(rec);
tail = (struct llog_rec_tail *)((char *)buf + rc -
sizeof(struct llog_rec_tail));
/* get the last record in block */
last_rec = (struct llog_rec_hdr *)((char *)buf + rc -
le32_to_cpu(tail->lrt_len));
if (LLOG_REC_HDR_NEEDS_SWABBING(last_rec))
lustre_swab_llog_rec(last_rec);
LASSERT(last_rec->lrh_index == tail->lrt_index);
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
"offset "LPU64"\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
GOTO(out, rc = -EINVAL);
}
if (tail->lrt_index < prev_idx)
continue;
/* sanity check that the start of the new buffer is no farther
* than the record that we wanted. This shouldn't happen. */
if (rec->lrh_index > prev_idx) {
CERROR("%s: missed desired record? %u > %u\n",
o->do_lu.lo_dev->ld_obd->obd_name,
rec->lrh_index, prev_idx);
GOTO(out, rc = -ENOENT);
}
/* Trim unsupported extensions for compat w/ older clients */
if (!(loghandle->lgh_hdr->llh_flags & LLOG_F_EXT_JOBID))
changelog_block_trim_ext(rec, last_rec,
CLF_VERSION | CLF_RENAME);
GOTO(out, rc = 0);
}
GOTO(out, rc = -EIO);
out:
return rc;
}
/**
* Implementation of the llog_operations::lop_write
*
* This function writes the new record in the llog or modify the existed one.
*
* \param[in] env execution environment
* \param[in] loghandle llog handle of the current llog
* \param[in] rec llog record header. This is a real header of
* the full llog record to write. This is
* the beginning of buffer to write, the length
* of buffer is stored in \a rec::lrh_len
* \param[out] reccookie pointer to the cookie to return back if needed.
* It is used for further cancel of this llog
* record.
* \param[in] idx index of the llog record. If \a idx == -1 then
* this is append case, otherwise \a idx is
* the index of record to modify
* \param[in] th current transaction handle
*
* \retval 0 on successful write && \a reccookie == NULL
* 1 on successful write && \a reccookie != NULL
* \retval negative error if write failed
*/
static int llog_osd_write_rec(const struct lu_env *env,
struct llog_handle *loghandle,
struct llog_rec_hdr *rec,
struct llog_cookie *reccookie,
int idx, struct thandle *th)
{
struct llog_thread_info *lgi = llog_info(env);
struct llog_log_hdr *llh;
int reclen = rec->lrh_len;
int index, rc;
struct llog_rec_tail *lrt;
struct dt_object *o;
size_t left;
bool header_is_updated = false;
ENTRY;
LASSERT(env);
llh = loghandle->lgh_hdr;
LASSERT(llh);
o = loghandle->lgh_obj;
LASSERT(o);
LASSERT(th);
CDEBUG(D_OTHER, "new record %x to "DFID"\n",
rec->lrh_type, PFID(lu_object_fid(&o->do_lu)));
/* record length should not bigger than LLOG_CHUNK_SIZE */
if (reclen > LLOG_CHUNK_SIZE)
RETURN(-E2BIG);
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
RETURN(rc);
/**
* The modification case.
* If idx set then the record with that index must be modified.
* There are three cases possible:
* 1) the common case is the llog header update (idx == 0)
* 2) the llog record modification during llog process.
* This is indicated by the \a loghandle::lgh_cur_idx > 0.
* In that case the \a loghandle::lgh_cur_offset
* 3) otherwise this is assumed that llog consist of records of
* fixed size, i.e. catalog. The llog header must has llh_size
* field equal to record size. The record offset is calculated
* just by /a idx value
*
* During modification we don't need extra header update because
* the bitmap and record count are not changed. The record header
* and tail remains the same too.
*/
if (idx != LLOG_NEXT_IDX) {
/* llog can be empty only when first record is being written */
LASSERT(ergo(idx > 0, lgi->lgi_attr.la_size > 0));
if (!ext2_test_bit(idx, llh->llh_bitmap)) {
CERROR("%s: modify unset record %u\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx);
RETURN(-ENOENT);
}
if (idx != rec->lrh_index) {
CERROR("%s: modify index mismatch %d %u\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx,
rec->lrh_index);
RETURN(-EFAULT);
}
if (idx == LLOG_HEADER_IDX) {
/* llog header update */
LASSERT(reclen == sizeof(struct llog_log_hdr));
LASSERT(rec == &llh->llh_hdr);
lgi->lgi_off = 0;
lgi->lgi_buf.lb_len = reclen;
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf,
&lgi->lgi_off, th);
RETURN(rc);
} else if (loghandle->lgh_cur_idx > 0) {
/**
* The lgh_cur_offset can be used only if index is
* the same.
*/
if (idx != loghandle->lgh_cur_idx) {
CERROR("%s: modify index mismatch %d %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx,
loghandle->lgh_cur_idx);
RETURN(-EFAULT);
}
lgi->lgi_off = loghandle->lgh_cur_offset;
CDEBUG(D_OTHER, "modify record "DOSTID": idx:%d, "
"len:%u offset %llu\n",
POSTID(&loghandle->lgh_id.lgl_oi), idx,
rec->lrh_len, (long long)lgi->lgi_off);
} else if (llh->llh_size > 0) {
if (llh->llh_size != rec->lrh_len) {
CERROR("%s: wrong record size, llh_size is %u"
" but record size is %u\n",
o->do_lu.lo_dev->ld_obd->obd_name,
llh->llh_size, rec->lrh_len);
RETURN(-EINVAL);
}
lgi->lgi_off = sizeof(*llh) + (idx - 1) * reclen;
} else {
/* This can be result of lgh_cur_idx is not set during
* llog processing or llh_size is not set to proper
* record size for fixed records llog. Therefore it is
* impossible to get record offset. */
CERROR("%s: can't get record offset, idx:%d, "
"len:%u.\n", o->do_lu.lo_dev->ld_obd->obd_name,
idx, rec->lrh_len);
RETURN(-EFAULT);
}
/* update only data, header and tail remain the same */
lgi->lgi_off += sizeof(struct llog_rec_hdr);
lgi->lgi_buf.lb_len = REC_DATA_LEN(rec);
lgi->lgi_buf.lb_buf = REC_DATA(rec);
rc = dt_record_write(env, o, &lgi->lgi_buf, &lgi->lgi_off, th);
if (rc == 0 && reccookie) {
reccookie->lgc_lgl = loghandle->lgh_id;
reccookie->lgc_index = idx;
rc = 1;
}
RETURN(rc);
}
/**
* The append case.
* The most common case of using llog. The new index is assigned to
* the new record, new bit is set in llog bitmap and llog count is
* incremented.
*
* Make sure that records don't cross a chunk boundary, so we can
* process them page-at-a-time if needed. If it will cross a chunk
* boundary, write in a fake (but referenced) entry to pad the chunk.
*/
LASSERT(lgi->lgi_attr.la_valid & LA_SIZE);
lgi->lgi_off = lgi->lgi_attr.la_size;
left = LLOG_CHUNK_SIZE - (lgi->lgi_off & (LLOG_CHUNK_SIZE - 1));
/* NOTE: padding is a record, but no bit is set */
if (left != 0 && left != reclen &&
left < (reclen + LLOG_MIN_REC_SIZE)) {
index = loghandle->lgh_last_idx + 1;
rc = llog_osd_pad(env, o, &lgi->lgi_off, left, index, th);
if (rc)
RETURN(rc);
loghandle->lgh_last_idx++; /* for pad rec */
}
/* if it's the last idx in log file, then return -ENOSPC */
if (loghandle->lgh_last_idx >= LLOG_BITMAP_SIZE(llh) - 1)
RETURN(-ENOSPC);
/* increment the last_idx along with llh_tail index, they should
* be equal for a llog lifetime */
loghandle->lgh_last_idx++;
index = loghandle->lgh_last_idx;
llh->llh_tail.lrt_index = index;
/**
* NB: the caller should make sure only 1 process access
* the lgh_last_idx, e.g. append should be exclusive.
* Otherwise it might hit the assert.
*/
LASSERT(index < LLOG_BITMAP_SIZE(llh));
rec->lrh_index = index;
lrt = rec_tail(rec);
lrt->lrt_len = rec->lrh_len;
lrt->lrt_index = rec->lrh_index;
/* the lgh_hdr_lock protects llog header data from concurrent
* update/cancel, the llh_count and llh_bitmap are protected */
spin_lock(&loghandle->lgh_hdr_lock);
if (ext2_set_bit(index, llh->llh_bitmap)) {
CERROR("%s: index %u already set in log bitmap\n",
o->do_lu.lo_dev->ld_obd->obd_name, index);
spin_unlock(&loghandle->lgh_hdr_lock);
LBUG(); /* should never happen */
}
llh->llh_count++;
spin_unlock(&loghandle->lgh_hdr_lock);
lgi->lgi_off = 0;
lgi->lgi_buf.lb_len = llh->llh_hdr.lrh_len;
lgi->lgi_buf.lb_buf = &llh->llh_hdr;
rc = dt_record_write(env, o, &lgi->lgi_buf, &lgi->lgi_off, th);
if (rc)
GOTO(out, rc);
header_is_updated = true;
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
GOTO(out, rc);
LASSERT(lgi->lgi_attr.la_valid & LA_SIZE);
lgi->lgi_off = lgi->lgi_attr.la_size;
lgi->lgi_buf.lb_len = reclen;
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf, &lgi->lgi_off, th);
if (rc < 0)
GOTO(out, rc);
CDEBUG(D_OTHER, "added record "DOSTID": idx: %u, %u\n",
POSTID(&loghandle->lgh_id.lgl_oi), index, rec->lrh_len);
if (reccookie != NULL) {
reccookie->lgc_lgl = loghandle->lgh_id;
reccookie->lgc_index = index;
if ((rec->lrh_type == MDS_UNLINK_REC) ||
(rec->lrh_type == MDS_SETATTR64_REC))
reccookie->lgc_subsys = LLOG_MDS_OST_ORIG_CTXT;
else if (rec->lrh_type == OST_SZ_REC)
reccookie->lgc_subsys = LLOG_SIZE_ORIG_CTXT;
else
reccookie->lgc_subsys = -1;
rc = 1;
}
RETURN(rc);
out:
/* cleanup llog for error case */
spin_lock(&loghandle->lgh_hdr_lock);
ext2_clear_bit(index, llh->llh_bitmap);
llh->llh_count--;
spin_unlock(&loghandle->lgh_hdr_lock);
/* restore llog last_idx */
loghandle->lgh_last_idx--;
llh->llh_tail.lrt_index = loghandle->lgh_last_idx;
/* restore the header on disk if it was written */
if (header_is_updated) {
lgi->lgi_off = 0;
lgi->lgi_buf.lb_len = llh->llh_hdr.lrh_len;
lgi->lgi_buf.lb_buf = &llh->llh_hdr;
dt_record_write(env, o, &lgi->lgi_buf, &lgi->lgi_off, th);
}
RETURN(rc);
}
/* sets:
* - cur_offset to the furthest point read in the log file
* - cur_idx to the log index preceeding cur_offset
* returns -EIO/-EINVAL on error
*/
static int llog_osd_next_block(const struct lu_env *env,
struct llog_handle *loghandle, int *cur_idx,
int next_idx, __u64 *cur_offset, void *buf,
int len)
{
struct llog_thread_info *lgi = llog_info(env);
struct dt_object *o;
struct dt_device *dt;
int rc;
ENTRY;
LASSERT(env);
LASSERT(lgi);
if (len == 0 || len & (LLOG_CHUNK_SIZE - 1))
RETURN(-EINVAL);
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off "LPU64")\n",
next_idx, *cur_idx, *cur_offset);
LASSERT(loghandle);
LASSERT(loghandle->lgh_ctxt);
o = loghandle->lgh_obj;
LASSERT(o);
LASSERT(dt_object_exists(o));
dt = lu2dt_dev(o->do_lu.lo_dev);
LASSERT(dt);
rc = dt_attr_get(env, o, &lgi->lgi_attr, BYPASS_CAPA);
if (rc)
GOTO(out, rc);
while (*cur_offset < lgi->lgi_attr.la_size) {
struct llog_rec_hdr *rec, *last_rec;
struct llog_rec_tail *tail;
llog_skip_over(cur_offset, *cur_idx, next_idx);
/* read up to next LLOG_CHUNK_SIZE block */
lgi->lgi_buf.lb_len = LLOG_CHUNK_SIZE -
(*cur_offset & (LLOG_CHUNK_SIZE - 1));
lgi->lgi_buf.lb_buf = buf;
/* Note: read lock is not needed around la_size get above at
* the time of dt_attr_get(). There are only two cases that
* matter. Either la_size == cur_offset, in which case the
* entire read is skipped, or la_size > cur_offset and the loop
* is entered and this thread is blocked at dt_read_lock()
* until the write is completed. When the write completes, then
* the dt_read() will be done with the full length, and will
* get the full data.
*/
dt_read_lock(env, o, 0);
rc = dt_read(env, o, &lgi->lgi_buf, cur_offset);
dt_read_unlock(env, o);
if (rc < 0) {
CERROR("%s: can't read llog block from log "DFID
" offset "LPU64": rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), *cur_offset,
rc);
GOTO(out, rc);
}
if (rc < len) {
/* signal the end of the valid buffer to
* llog_process */
memset(buf + rc, 0, len - rc);
}
if (rc == 0) /* end of file, nothing to do */
GOTO(out, rc);
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
"offset "LPU64"\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
GOTO(out, rc = -EINVAL);
}
rec = buf;
if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
lustre_swab_llog_rec(rec);
tail = (struct llog_rec_tail *)((char *)buf + rc -
sizeof(struct llog_rec_tail));
/* get the last record in block */
last_rec = (struct llog_rec_hdr *)((char *)buf + rc -
le32_to_cpu(tail->lrt_len));
if (LLOG_REC_HDR_NEEDS_SWABBING(last_rec))
lustre_swab_llog_rec(last_rec);
LASSERT(last_rec->lrh_index == tail->lrt_index);
*cur_idx = tail->lrt_index;
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
"offset "LPU64"\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
GOTO(out, rc = -EINVAL);
}
if (tail->lrt_index < next_idx)
continue;
/* sanity check that the start of the new buffer is no farther
* than the record that we wanted. This shouldn't happen. */
if (rec->lrh_index > next_idx) {
CERROR("%s: missed desired record? %u > %u\n",
o->do_lu.lo_dev->ld_obd->obd_name,
rec->lrh_index, next_idx);
GOTO(out, rc = -ENOENT);
}
GOTO(out, rc = 0);
}
GOTO(out, rc = -EIO);
out:
return rc;
}
/* appends if idx == -1, otherwise overwrites record idx. */
static int llog_osd_write_rec(const struct lu_env *env,
struct llog_handle *loghandle,
struct llog_rec_hdr *rec,
struct llog_cookie *reccookie, int cookiecount,
void *buf, int idx, struct thandle *th)
{
struct llog_thread_info *lgi = llog_info(env);
struct llog_log_hdr *llh;
int reclen = rec->lrh_len;
int index, rc, old_tail_idx;
struct llog_rec_tail *lrt;
struct dt_object *o;
size_t left;
ENTRY;
LASSERT(env);
llh = loghandle->lgh_hdr;
LASSERT(llh);
o = loghandle->lgh_obj;
LASSERT(o);
LASSERT(th);
CDEBUG(D_OTHER, "new record %x to "DFID"\n",
rec->lrh_type, PFID(lu_object_fid(&o->do_lu)));
/* record length should not bigger than LLOG_CHUNK_SIZE */
if (buf)
rc = (reclen > LLOG_CHUNK_SIZE - sizeof(struct llog_rec_hdr) -
sizeof(struct llog_rec_tail)) ? -E2BIG : 0;
else
rc = (reclen > LLOG_CHUNK_SIZE) ? -E2BIG : 0;
if (rc)
RETURN(rc);
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
RETURN(rc);
if (buf)
/* write_blob adds header and tail to lrh_len. */
reclen = sizeof(*rec) + rec->lrh_len +
sizeof(struct llog_rec_tail);
if (idx != -1) {
/* no header: only allowed to insert record 1 */
if (idx != 1 && lgi->lgi_attr.la_size == 0)
LBUG();
if (idx && llh->llh_size && llh->llh_size != rec->lrh_len)
RETURN(-EINVAL);
if (!ext2_test_bit(idx, llh->llh_bitmap))
CERROR("%s: modify unset record %u\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx);
if (idx != rec->lrh_index)
CERROR("%s: index mismatch %d %u\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx,
rec->lrh_index);
lgi->lgi_off = 0;
rc = llog_osd_write_blob(env, o, &llh->llh_hdr, NULL,
&lgi->lgi_off, th);
/* we are done if we only write the header or on error */
if (rc || idx == 0)
RETURN(rc);
if (buf) {
/* We assume that caller has set lgh_cur_* */
lgi->lgi_off = loghandle->lgh_cur_offset;
CDEBUG(D_OTHER,
"modify record "DOSTID": idx:%d/%u/%d, len:%u "
"offset %llu\n",
POSTID(&loghandle->lgh_id.lgl_oi), idx,
rec->lrh_index,
loghandle->lgh_cur_idx, rec->lrh_len,
(long long)(lgi->lgi_off - sizeof(*llh)));
if (rec->lrh_index != loghandle->lgh_cur_idx) {
CERROR("%s: modify idx mismatch %u/%d\n",
o->do_lu.lo_dev->ld_obd->obd_name, idx,
loghandle->lgh_cur_idx);
RETURN(-EFAULT);
}
} else {
/* Assumes constant lrh_len */
lgi->lgi_off = sizeof(*llh) + (idx - 1) * reclen;
}
rc = llog_osd_write_blob(env, o, rec, buf, &lgi->lgi_off, th);
if (rc == 0 && reccookie) {
reccookie->lgc_lgl = loghandle->lgh_id;
reccookie->lgc_index = idx;
rc = 1;
}
RETURN(rc);
}
/* Make sure that records don't cross a chunk boundary, so we can
* process them page-at-a-time if needed. If it will cross a chunk
* boundary, write in a fake (but referenced) entry to pad the chunk.
*
* We know that llog_current_log() will return a loghandle that is
* big enough to hold reclen, so all we care about is padding here.
*/
LASSERT(lgi->lgi_attr.la_valid & LA_SIZE);
lgi->lgi_off = lgi->lgi_attr.la_size;
left = LLOG_CHUNK_SIZE - (lgi->lgi_off & (LLOG_CHUNK_SIZE - 1));
/* NOTE: padding is a record, but no bit is set */
if (left != 0 && left != reclen &&
left < (reclen + LLOG_MIN_REC_SIZE)) {
index = loghandle->lgh_last_idx + 1;
rc = llog_osd_pad(env, o, &lgi->lgi_off, left, index, th);
if (rc)
RETURN(rc);
loghandle->lgh_last_idx++; /*for pad rec*/
}
/* if it's the last idx in log file, then return -ENOSPC */
if (loghandle->lgh_last_idx >= LLOG_BITMAP_SIZE(llh) - 1)
RETURN(-ENOSPC);
loghandle->lgh_last_idx++;
index = loghandle->lgh_last_idx;
LASSERT(index < LLOG_BITMAP_SIZE(llh));
rec->lrh_index = index;
if (buf == NULL) {
lrt = (struct llog_rec_tail *)((char *)rec + rec->lrh_len -
sizeof(*lrt));
lrt->lrt_len = rec->lrh_len;
lrt->lrt_index = rec->lrh_index;
}
/* The caller should make sure only 1 process access the lgh_last_idx,
* Otherwise it might hit the assert.*/
LASSERT(index < LLOG_BITMAP_SIZE(llh));
spin_lock(&loghandle->lgh_hdr_lock);
if (ext2_set_bit(index, llh->llh_bitmap)) {
CERROR("%s: index %u already set in log bitmap\n",
o->do_lu.lo_dev->ld_obd->obd_name, index);
spin_unlock(&loghandle->lgh_hdr_lock);
LBUG(); /* should never happen */
}
llh->llh_count++;
spin_unlock(&loghandle->lgh_hdr_lock);
old_tail_idx = llh->llh_tail.lrt_index;
llh->llh_tail.lrt_index = index;
lgi->lgi_off = 0;
rc = llog_osd_write_blob(env, o, &llh->llh_hdr, NULL, &lgi->lgi_off,
th);
if (rc)
GOTO(out, rc);
rc = dt_attr_get(env, o, &lgi->lgi_attr, NULL);
if (rc)
GOTO(out, rc);
LASSERT(lgi->lgi_attr.la_valid & LA_SIZE);
lgi->lgi_off = lgi->lgi_attr.la_size;
rc = llog_osd_write_blob(env, o, rec, buf, &lgi->lgi_off, th);
out:
/* cleanup llog for error case */
if (rc) {
spin_lock(&loghandle->lgh_hdr_lock);
ext2_clear_bit(index, llh->llh_bitmap);
llh->llh_count--;
spin_unlock(&loghandle->lgh_hdr_lock);
/* restore the header */
loghandle->lgh_last_idx--;
llh->llh_tail.lrt_index = old_tail_idx;
lgi->lgi_off = 0;
llog_osd_write_blob(env, o, &llh->llh_hdr, NULL,
&lgi->lgi_off, th);
}
CDEBUG(D_RPCTRACE, "added record "DOSTID": idx: %u, %u\n",
POSTID(&loghandle->lgh_id.lgl_oi), index, rec->lrh_len);
if (rc == 0 && reccookie) {
reccookie->lgc_lgl = loghandle->lgh_id;
reccookie->lgc_index = index;
if ((rec->lrh_type == MDS_UNLINK_REC) ||
(rec->lrh_type == MDS_SETATTR64_REC))
reccookie->lgc_subsys = LLOG_MDS_OST_ORIG_CTXT;
else if (rec->lrh_type == OST_SZ_REC)
reccookie->lgc_subsys = LLOG_SIZE_ORIG_CTXT;
else
reccookie->lgc_subsys = -1;
rc = 1;
}
RETURN(rc);
}
static int llog_osd_write_blob(const struct lu_env *env, struct dt_object *o,
struct llog_rec_hdr *rec, void *buf,
loff_t *off, struct thandle *th)
{
struct llog_thread_info *lgi = llog_info(env);
int buflen = rec->lrh_len;
int rc;
LASSERT(env);
LASSERT(o);
if (buflen == 0)
CWARN("0-length record\n");
CDEBUG(D_OTHER, "write blob with type %x, buf %p/%u at off %llu\n",
rec->lrh_type, buf, buflen, *off);
lgi->lgi_attr.la_valid = LA_SIZE;
lgi->lgi_attr.la_size = *off;
if (!buf) {
lgi->lgi_buf.lb_len = buflen;
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc)
CERROR("%s: error writing log record: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out, rc);
}
/* the buf case */
/* protect the following 3 writes from concurrent read */
dt_write_lock(env, o, 0);
rec->lrh_len = sizeof(*rec) + buflen + sizeof(lgi->lgi_tail);
lgi->lgi_buf.lb_len = sizeof(*rec);
lgi->lgi_buf.lb_buf = rec;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc) {
CERROR("%s: error writing log hdr: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out_unlock, rc);
}
lgi->lgi_buf.lb_len = buflen;
lgi->lgi_buf.lb_buf = buf;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc) {
CERROR("%s: error writing log buffer: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out_unlock, rc);
}
lgi->lgi_tail.lrt_len = rec->lrh_len;
lgi->lgi_tail.lrt_index = rec->lrh_index;
lgi->lgi_buf.lb_len = sizeof(lgi->lgi_tail);
lgi->lgi_buf.lb_buf = &lgi->lgi_tail;
rc = dt_record_write(env, o, &lgi->lgi_buf, off, th);
if (rc)
CERROR("%s: error writing log tail: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
out_unlock:
dt_write_unlock(env, o);
out:
/* cleanup the content written above */
if (rc) {
dt_punch(env, o, lgi->lgi_attr.la_size, OBD_OBJECT_EOF, th,
BYPASS_CAPA);
dt_attr_set(env, o, &lgi->lgi_attr, th, BYPASS_CAPA);
}
return rc;
}
