init_rwsem(&loghandle->lgh_lock);
spin_lock_init(&loghandle->lgh_hdr_lock);
CFS_INIT_LIST_HEAD(&loghandle->u.phd.phd_entry);
- cfs_atomic_set(&loghandle->lgh_refcount, 1);
+ atomic_set(&loghandle->lgh_refcount, 1);
return loghandle;
}
void llog_handle_get(struct llog_handle *loghandle)
{
- cfs_atomic_inc(&loghandle->lgh_refcount);
+ atomic_inc(&loghandle->lgh_refcount);
}
void llog_handle_put(struct llog_handle *loghandle)
{
- LASSERT(cfs_atomic_read(&loghandle->lgh_refcount) > 0);
- if (cfs_atomic_dec_and_test(&loghandle->lgh_refcount))
+ LASSERT(atomic_read(&loghandle->lgh_refcount) > 0);
+ if (atomic_dec_and_test(&loghandle->lgh_refcount))
llog_free_handle(loghandle);
}
loghandle->lgh_id.lgl_ogen, rc);
GOTO(out_err, rc);
}
- RETURN(1);
+ RETURN(LLOG_DEL_PLAIN);
}
spin_unlock(&loghandle->lgh_hdr_lock);
- rc = llog_write(env, loghandle, &llh->llh_hdr, NULL, 0, NULL, 0);
+ rc = llog_write(env, loghandle, &llh->llh_hdr, LLOG_HEADER_IDX);
if (rc < 0) {
CERROR("%s: fail to write header for llog #"DOSTID
"#%08x: rc = %d\n",
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;
+ rc = llog_cancel_rec(lpi->lpi_env,
+ loghandle,
+ rec->lrh_index);
}
if (rc)
GOTO(out, rc);
if (cd != NULL)
cd->lpcd_last_idx = last_called_index;
+ if (unlikely(rc == -EIO)) {
+ /* something bad happened to the processing, 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("llog found corrupted\n");
+ while (index <= last_index) {
+ if (ext2_test_bit(index, llh->llh_bitmap) != 0)
+ llog_cancel_rec(lpi->lpi_env, loghandle, index);
+ index++;
+ }
+ rc = 0;
+ }
+
OBD_FREE(buf, LLOG_CHUNK_SIZE);
lpi->lpi_rc = rc;
return 0;
#ifdef __KERNEL__
if (fork) {
+ struct task_struct *task;
+
/* The new thread can't use parent env,
* init the new one in llog_process_thread_daemonize. */
lpi->lpi_env = NULL;
init_completion(&lpi->lpi_completion);
- rc = PTR_ERR(kthread_run(llog_process_thread_daemonize, lpi,
- "llog_process_thread"));
- if (IS_ERR_VALUE(rc)) {
+ task = kthread_run(llog_process_thread_daemonize, lpi,
+ "llog_process_thread");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
CERROR("%s: cannot start thread: rc = %d\n",
loghandle->lgh_ctxt->loc_obd->obd_name, rc);
- OBD_FREE_PTR(lpi);
- RETURN(rc);
+ GOTO(out_lpi, rc);
}
wait_for_completion(&lpi->lpi_completion);
} else {
lpi->lpi_env = env;
llog_process_thread(lpi);
#endif
- rc = lpi->lpi_rc;
- OBD_FREE_PTR(lpi);
- RETURN(rc);
+ rc = lpi->lpi_rc;
+
+#ifdef __KERNEL__
+out_lpi:
+#endif
+ OBD_FREE_PTR(lpi);
+ RETURN(rc);
}
EXPORT_SYMBOL(llog_process_or_fork);
int llog_process(const struct lu_env *env, struct llog_handle *loghandle,
llog_cb_t cb, void *data, void *catdata)
{
- return llog_process_or_fork(env, loghandle, cb, data, catdata, true);
+ int rc;
+ rc = llog_process_or_fork(env, loghandle, cb, data, catdata, true);
+ return rc == LLOG_DEL_PLAIN ? 0 : rc;
}
EXPORT_SYMBOL(llog_process);
if (rc == LLOG_PROC_BREAK) {
GOTO(out, rc);
} else if (rc == LLOG_DEL_RECORD) {
- llog_cancel_rec(env, loghandle,
- tail->lrt_index);
- rc = 0;
+ rc = llog_cancel_rec(env, loghandle,
+ tail->lrt_index);
}
if (rc)
GOTO(out, rc);
int llog_write_rec(const struct lu_env *env, struct llog_handle *handle,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
- int numcookies, void *buf, int idx, struct thandle *th)
+ int idx, struct thandle *th)
{
struct llog_operations *lop;
int raised, rc, buflen;
if (lop->lop_write_rec == NULL)
RETURN(-EOPNOTSUPP);
- if (buf)
- buflen = rec->lrh_len + sizeof(struct llog_rec_hdr) +
- sizeof(struct llog_rec_tail);
- else
- buflen = rec->lrh_len;
+ buflen = rec->lrh_len;
LASSERT(cfs_size_round(buflen) == buflen);
raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
if (!raised)
cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
- rc = lop->lop_write_rec(env, handle, rec, logcookies, numcookies,
- buf, idx, th);
+ rc = lop->lop_write_rec(env, handle, rec, logcookies, idx, th);
if (!raised)
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
int llog_add(const struct lu_env *env, struct llog_handle *lgh,
struct llog_rec_hdr *rec, struct llog_cookie *logcookies,
- void *buf, struct thandle *th)
+ struct thandle *th)
{
int raised, rc;
raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
if (!raised)
cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
- rc = lgh->lgh_logops->lop_add(env, lgh, rec, logcookies, buf, th);
+ rc = lgh->lgh_logops->lop_add(env, lgh, rec, logcookies, th);
if (!raised)
cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
RETURN(rc);
* Valid only with local llog.
*/
int llog_write(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 llog_rec_hdr *rec, int idx)
{
struct dt_device *dt;
struct thandle *th;
GOTO(out_trans, rc);
down_write(&loghandle->lgh_lock);
- rc = llog_write_rec(env, loghandle, rec, reccookie,
- cookiecount, buf, idx, th);
+ rc = llog_write_rec(env, loghandle, rec, NULL, idx, th);
up_write(&loghandle->lgh_lock);
out_trans:
dt_trans_stop(env, dt, th);
struct llog_handle *copy_llh = data;
/* Append all records */
- return llog_write(env, copy_llh, rec, NULL, 0, NULL, -1);
+ return llog_write(env, copy_llh, rec, LLOG_NEXT_IDX);
}
EXPORT_SYMBOL(llog_copy_handler);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff