int
archiver_close(void *ctx)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
pctx->arc_closed = 1;
pctx->arc_buf = NULL;
pctx->arc_buf_size = 0;
Sem_Post(&(pctx->write_sem));
Sem_Post(&(pctx->read_sem));
return (0);
}
static ssize_t
extract_read_callback(struct archive *arc, void *ctx, const void **buf)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
if (pctx->arc_closed) {
pctx->arc_buf_size = 0;
log_msg(LOG_WARN, 0, "End of file.");
archive_set_error(arc, ARCHIVE_EOF, "End of file.");
return (-1);
}
if (!pctx->arc_writing) {
Sem_Wait(&(pctx->read_sem));
} else {
Sem_Post(&(pctx->write_sem));
Sem_Wait(&(pctx->read_sem));
}
if (pctx->arc_buf == NULL || pctx->arc_buf_size == 0) {
pctx->arc_buf_size = 0;
log_msg(LOG_ERR, 0, "End of file when extracting archive.");
archive_set_error(arc, ARCHIVE_EOF, "End of file when extracting archive.");
return (-1);
}
pctx->arc_writing = 1;
*buf = pctx->arc_buf;
return (pctx->arc_buf_size);
}
void MI_CALL _L_LifecycleC1_Callback(
_In_ MI_Uint32 types,
_In_opt_ void* callbackData)
{
Config* config = (Config*)callbackData;
config->currentSubscriptionTypes = types;
/* signal firing thread to fire indication */
Sem_Post(&config->sem, 1);
}
static int
extract_close_callback(struct archive *arc, void *ctx)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
pctx->arc_closed = 1;
if (pctx->arc_buf) {
Sem_Post(&(pctx->write_sem));
} else {
pctx->arc_buf_size = 0;
}
return (ARCHIVE_OK);
}
static int
creat_close_callback(struct archive *arc, void *ctx)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
pctx->arc_closed = 1;
if (pctx->arc_buf) {
Sem_Post(&(pctx->read_sem));
} else {
pctx->arc_buf_pos = 0;
}
return (ARCHIVE_OK);
}
static void *barber_work(void *arg)
{
struct barber *barber = arg;
struct chairs *chairs = &barber->simulator->chairs;
struct customer *customer = 0;
/* Main barber loop */
while (true) {
Sem_Wait(&chairs->barber);
Sem_Wait(&chairs->mutex);
/* Incrementing rear by one and modulo max to return back to 0 if
* the que is at max index */
customer = chairs->customer[chairs->r++ % chairs->max];
thrlab_prepare_customer(customer, barber->room);
Sem_Post(&chairs->mutex);
Sem_Post(&chairs->chair);
thrlab_sleep(5 * (customer->hair_length - customer->hair_goal));
thrlab_dismiss_customer(customer, barber->room);
Sem_Post(&customer->mutex);
}
return NULL;
}
/**
* Called in a new thread each time a customer has arrived.
*/
static void customer_arrived(struct customer *customer, void *arg)
{
struct simulator *simulator = arg;
struct chairs *chairs = &simulator->chairs;
Sem_Init(&customer->mutex, 0, 0);
/* If a chair is available we let the customer in, else we turn the
* customer away. */
if (sem_trywait(&chairs->chair) == 0) {
Sem_Wait(&chairs->mutex);
thrlab_accept_customer(customer);
/* Incrementing front by one and modulo max to return back to 0 if
* the que is at max index. */
chairs->customer[chairs->f++ % chairs->max] = customer;
Sem_Post(&chairs->mutex);
Sem_Post(&chairs->barber);
Sem_Wait(&customer->mutex);
} else {
thrlab_reject_customer(customer);
}
/* Destroying the customer semaphore */
Sem_Destroy(&customer->mutex);
}
int64_t
archiver_write(void *ctx, void *buf, uint64_t count)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
if (pctx->arc_closed) {
log_msg(LOG_WARN, 0, "Archive extractor closed unexpectedly");
return (0);
}
if (pctx->arc_buf != NULL) {
log_msg(LOG_ERR, 0, "Incorrect sequencing of archiver_read() call.");
return (-1);
}
pctx->arc_buf = buf;
pctx->arc_buf_size = count;
Sem_Post(&(pctx->read_sem));
Sem_Wait(&(pctx->write_sem));
pctx->arc_buf = NULL;
return (pctx->arc_buf_size);
}
int64_t
archiver_read(void *ctx, void *buf, uint64_t count)
{
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
if (pctx->arc_closed)
return (0);
if (pctx->arc_buf != NULL) {
log_msg(LOG_ERR, 0, "Incorrect sequencing of archiver_read() call.");
return (-1);
}
pctx->arc_buf = buf;
pctx->arc_buf_size = count;
pctx->arc_buf_pos = 0;
pctx->btype = TYPE_UNKNOWN;
Sem_Post(&(pctx->write_sem));
Sem_Wait(&(pctx->read_sem));
pctx->arc_buf = NULL;
return (pctx->arc_buf_pos);
}
static ssize_t
creat_write_callback(struct archive *arc, void *ctx, const void *buf, size_t len)
{
uchar_t *buff = (uchar_t *)buf;
pc_ctx_t *pctx = (pc_ctx_t *)ctx;
size_t remaining;
if (pctx->arc_closed) {
archive_set_error(arc, ARCHIVE_EOF, "End of file when writing archive.");
return (-1);
}
if (!pctx->arc_writing) {
Sem_Wait(&(pctx->write_sem));
}
if (pctx->arc_buf == NULL || pctx->arc_buf_size == 0) {
archive_set_error(arc, ARCHIVE_EOF, "End of file when writing archive.");
return (-1);
}
pctx->arc_writing = 1;
remaining = len;
while (remaining && !pctx->arc_closed) {
uchar_t *tbuf;
tbuf = pctx->arc_buf + pctx->arc_buf_pos;
/*
* Determine if we should return the accumulated data to the caller.
* This is done if the data type changes and at least some minimum amount
* of data has accumulated in the buffer.
*/
if (pctx->btype != pctx->ctype) {
if (pctx->btype == TYPE_UNKNOWN || pctx->arc_buf_pos == 0) {
pctx->btype = pctx->ctype;
} else {
if (pctx->arc_buf_pos < pctx->min_chunk) {
uint32_t diff = pctx->min_chunk - pctx->arc_buf_pos;
if (len > diff)
pctx->btype = pctx->ctype;
else
pctx->ctype = pctx->btype;
} else {
pctx->arc_writing = 0;
Sem_Post(&(pctx->read_sem));
Sem_Wait(&(pctx->write_sem));
tbuf = pctx->arc_buf + pctx->arc_buf_pos;
pctx->arc_writing = 1;
if (remaining > 0)
pctx->btype = pctx->ctype;
}
}
}
if (remaining > pctx->arc_buf_size - pctx->arc_buf_pos) {
size_t nlen = pctx->arc_buf_size - pctx->arc_buf_pos;
memcpy(tbuf, buff, nlen);
remaining -= nlen;
pctx->arc_buf_pos += nlen;
buff += nlen;
pctx->arc_writing = 0;
Sem_Post(&(pctx->read_sem));
Sem_Wait(&(pctx->write_sem));
pctx->arc_writing = 1;
} else {
memcpy(tbuf, buff, remaining);
pctx->arc_buf_pos += remaining;
remaining = 0;
if (pctx->arc_buf_pos == pctx->arc_buf_size) {
pctx->arc_writing = 0;
Sem_Post(&(pctx->read_sem));
}
break;
}
}
return (len - remaining);
}
/// <summary>
/// End the operation of the method.
/// </summar>
void EndLcmOperation()
{
int waitResult = 0;
Atomic_Swap(&g_activeOperationMethodName, (ptrdiff_t)NULL);
waitResult = Sem_Post(&g_h_ConfigurationStoppedEvent, 1); //Ignore the result
}
