/* Mark the log entry as committed and sync the memory mapped log to file. */
krb5_error_code
ulog_finish_update(krb5_context context, kdb_incr_update_t *upd)
{
krb5_error_code retval;
kdb_ent_header_t *indx_log;
unsigned int i;
kdb_log_context *log_ctx;
kdb_hlog_t *ulog = NULL;
uint32_t ulogentries;
INIT_ULOG(context);
ulogentries = log_ctx->ulogentries;
i = (upd->kdb_entry_sno - 1) % ulogentries;
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
indx_log->kdb_commit = TRUE;
ulog->kdb_state = KDB_STABLE;
retval = ulog_sync_update(ulog, indx_log);
if (retval)
return retval;
ulog_sync_header(ulog);
return 0;
}
/*
* Validate the log file and resync any uncommitted update entries
* to the principal database.
*
* Must be called with lock held.
*/
static krb5_error_code
ulog_check(krb5_context context, kdb_hlog_t *ulog, char **db_args)
{
XDR xdrs;
krb5_error_code retval = 0;
unsigned int i;
kdb_ent_header_t *indx_log;
kdb_incr_update_t *upd = NULL;
kdb_incr_result_t *incr_ret = NULL;
ulog->kdb_state = KDB_STABLE;
for (i = 0; i < ulog->kdb_num; i++) {
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
if (indx_log->kdb_umagic != KDB_ULOG_MAGIC) {
/*
* Update entry corrupted we should scream and die
*/
ulog->kdb_state = KDB_CORRUPT;
retval = KRB5_LOG_CORRUPT;
break;
}
if (indx_log->kdb_commit == FALSE) {
ulog->kdb_state = KDB_UNSTABLE;
incr_ret = (kdb_incr_result_t *)
malloc(sizeof (kdb_incr_result_t));
if (incr_ret == NULL) {
retval = errno;
goto error;
}
upd = (kdb_incr_update_t *)
malloc(sizeof (kdb_incr_update_t));
if (upd == NULL) {
retval = errno;
goto error;
}
(void) memset(upd, 0, sizeof (kdb_incr_update_t));
xdrmem_create(&xdrs, (char *)indx_log->entry_data,
indx_log->kdb_entry_size, XDR_DECODE);
if (!xdr_kdb_incr_update_t(&xdrs, upd)) {
retval = KRB5_LOG_CONV;
goto error;
}
incr_ret->updates.kdb_ulog_t_len = 1;
incr_ret->updates.kdb_ulog_t_val = upd;
upd->kdb_commit = TRUE;
/*
* We don't want to readd this update and just use the
* existing update to be propagated later on
*/
ulog_set_role(context, IPROP_NULL);
retval = ulog_replay(context, incr_ret, db_args);
/*
* upd was freed by ulog_replay, we NULL
* the pointer in case we subsequently break from loop.
*/
upd = NULL;
if (incr_ret) {
free(incr_ret);
incr_ret = NULL;
}
ulog_set_role(context, IPROP_MASTER);
if (retval)
goto error;
/*
* We flag this as committed since this was
* the last entry before kadmind crashed, ergo
* the slaves have not seen this update before
*/
indx_log->kdb_commit = TRUE;
retval = ulog_sync_update(ulog, indx_log);
if (retval)
goto error;
ulog->kdb_state = KDB_STABLE;
}
}
error:
if (upd)
ulog_free_entries(upd, 1);
free(incr_ret);
ulog_sync_header(ulog);
return (retval);
}
/*
* Add an entry to the update log. The layout of the update log looks like:
*
* header log -> [ update header -> xdr(kdb_incr_update_t) ], ...
*/
krb5_error_code
ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
{
XDR xdrs;
kdbe_time_t ktime;
kdb_ent_header_t *indx_log;
unsigned int i, recsize;
unsigned long upd_size;
krb5_error_code retval;
kdb_sno_t cur_sno;
kdb_log_context *log_ctx;
kdb_hlog_t *ulog = NULL;
uint32_t ulogentries;
int ulogfd;
INIT_ULOG(context);
ulogentries = log_ctx->ulogentries;
ulogfd = log_ctx->ulogfd;
if (upd == NULL)
return KRB5_LOG_ERROR;
time_current(&ktime);
upd_size = xdr_sizeof((xdrproc_t)xdr_kdb_incr_update_t, upd);
recsize = sizeof(kdb_ent_header_t) + upd_size;
if (recsize > ulog->kdb_block) {
retval = ulog_resize(ulog, ulogentries, ulogfd, recsize);
if (retval)
return retval;
}
cur_sno = ulog->kdb_last_sno;
/*
* If we need to, wrap our sno around to 1. A slaves will do a full resync
* since its sno will be out of range of the ulog (or in extreme cases,
* its timestamp won't match).
*/
if (cur_sno == (kdb_sno_t)-1)
cur_sno = 1;
else
cur_sno++;
/* Squirrel this away for finish_update() to index. */
upd->kdb_entry_sno = cur_sno;
i = (cur_sno - 1) % ulogentries;
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
memset(indx_log, 0, ulog->kdb_block);
indx_log->kdb_umagic = KDB_ULOG_MAGIC;
indx_log->kdb_entry_size = upd_size;
indx_log->kdb_entry_sno = cur_sno;
indx_log->kdb_time = upd->kdb_time = ktime;
indx_log->kdb_commit = upd->kdb_commit = FALSE;
ulog->kdb_state = KDB_UNSTABLE;
xdrmem_create(&xdrs, (char *)indx_log->entry_data,
indx_log->kdb_entry_size, XDR_ENCODE);
if (!xdr_kdb_incr_update_t(&xdrs, upd))
return KRB5_LOG_CONV;
retval = ulog_sync_update(ulog, indx_log);
if (retval)
return retval;
if (ulog->kdb_num < ulogentries)
ulog->kdb_num++;
ulog->kdb_last_sno = cur_sno;
ulog->kdb_last_time = ktime;
if (cur_sno > ulogentries) {
/* Once we've circled, kdb_first_sno is the sno of the next entry. */
i = upd->kdb_entry_sno % ulogentries;
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
ulog->kdb_first_sno = indx_log->kdb_entry_sno;
ulog->kdb_first_time = indx_log->kdb_time;
} else if (cur_sno == 1) {
/* This is the first update, or we wrapped. */
ulog->kdb_first_sno = 1;
ulog->kdb_first_time = indx_log->kdb_time;
}
ulog_sync_header(ulog);
return 0;
}
/*
* Adds an entry to the update log.
* The layout of the update log looks like:
*
* header log -> [ update header -> xdr(kdb_incr_update_t) ], ...
*/
krb5_error_code
ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
{
XDR xdrs;
kdbe_time_t ktime;
struct timeval timestamp;
kdb_ent_header_t *indx_log;
uint_t i, recsize;
ulong_t upd_size;
krb5_error_code retval;
kdb_sno_t cur_sno;
kdb_log_context *log_ctx;
kdb_hlog_t *ulog = NULL;
uint32_t ulogentries;
int ulogfd;
INIT_ULOG(context);
ulogentries = log_ctx->ulogentries;
ulogfd = log_ctx->ulogfd;
if (upd == NULL)
return (KRB5_LOG_ERROR);
(void) gettimeofday(×tamp, NULL);
ktime.seconds = timestamp.tv_sec;
ktime.useconds = timestamp.tv_usec;
upd_size = xdr_sizeof((xdrproc_t)xdr_kdb_incr_update_t, upd);
recsize = sizeof (kdb_ent_header_t) + upd_size;
if (recsize > ulog->kdb_block) {
if ((retval = ulog_resize(ulog, ulogentries, ulogfd, recsize))) {
/* Resize element array failed */
return (retval);
}
}
cur_sno = ulog->kdb_last_sno;
/*
* We need to overflow our sno, replicas will do full
* resyncs once they see their sno > than the masters.
*/
if (cur_sno == (kdb_sno_t)-1)
cur_sno = 1;
else
cur_sno++;
/*
* We squirrel this away for finish_update() to index
*/
upd->kdb_entry_sno = cur_sno;
i = (cur_sno - 1) % ulogentries;
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
(void) memset(indx_log, 0, ulog->kdb_block);
indx_log->kdb_umagic = KDB_ULOG_MAGIC;
indx_log->kdb_entry_size = upd_size;
indx_log->kdb_entry_sno = cur_sno;
indx_log->kdb_time = upd->kdb_time = ktime;
indx_log->kdb_commit = upd->kdb_commit = FALSE;
ulog->kdb_state = KDB_UNSTABLE;
xdrmem_create(&xdrs, (char *)indx_log->entry_data,
indx_log->kdb_entry_size, XDR_ENCODE);
if (!xdr_kdb_incr_update_t(&xdrs, upd))
return (KRB5_LOG_CONV);
if ((retval = ulog_sync_update(ulog, indx_log)))
return (retval);
if (ulog->kdb_num < ulogentries)
ulog->kdb_num++;
ulog->kdb_last_sno = cur_sno;
ulog->kdb_last_time = ktime;
/*
* Since this is a circular array, once we circled, kdb_first_sno is
* always kdb_entry_sno + 1.
*/
if (cur_sno > ulogentries) {
i = upd->kdb_entry_sno % ulogentries;
indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
ulog->kdb_first_sno = indx_log->kdb_entry_sno;
ulog->kdb_first_time = indx_log->kdb_time;
} else if (cur_sno == 1) {
ulog->kdb_first_sno = 1;
ulog->kdb_first_time = indx_log->kdb_time;
}
ulog_sync_header(ulog);
return (0);
}