/*
* release clearance
*/
int
_nscd_release_clearance(sema_t *sema) {
int which;
(void) thr_getspecific(lookup_state_key, (void**)&which);
if (which == 0) /* from common pool */ {
(void) sema_post(&common_sema);
return (0);
}
(void) sema_post(sema);
return (1);
}
static void
free_pagelist(PAGELIST_T *pagelist, int actual)
{
vm_page_t *pages;
unsigned int num_pages, i;
vcos_log_trace("free_pagelist - %x, %d", (unsigned int)pagelist, actual);
num_pages =
(pagelist->length + pagelist->offset + PAGE_SIZE - 1) / PAGE_SIZE;
pages = (vm_page_t *)(pagelist->addrs + num_pages);
/* Deal with any partial cache lines (fragments) */
if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS) {
FRAGMENTS_T *fragments =
g_fragments_base + (pagelist->type -
PAGELIST_READ_WITH_FRAGMENTS);
int head_bytes, tail_bytes;
if (actual >= 0)
{
/* XXXBSD: might be inefficient */
void *page_address = pmap_mapdev(VM_PAGE_TO_PHYS(pages[0]), PAGE_SIZE*num_pages);
if ((head_bytes = (CACHE_LINE_SIZE - pagelist->offset) & (CACHE_LINE_SIZE - 1)) != 0) {
if (head_bytes > actual)
head_bytes = actual;
memcpy((char *)page_address +
pagelist->offset, fragments->headbuf,
head_bytes);
}
if ((head_bytes < actual) &&
(tail_bytes =
(pagelist->offset + actual) & (CACHE_LINE_SIZE -
1)) != 0) {
memcpy((char *)page_address + PAGE_SIZE*(num_pages - 1) +
((pagelist->offset + actual) & (PAGE_SIZE -
1) & ~(CACHE_LINE_SIZE - 1)),
fragments->tailbuf, tail_bytes);
}
pmap_qremove((vm_offset_t)page_address, PAGE_SIZE*num_pages);
}
mtx_lock(&g_free_fragments_mutex);
*(FRAGMENTS_T **) fragments = g_free_fragments;
g_free_fragments = fragments;
mtx_unlock(&g_free_fragments_mutex);
sema_post(&g_free_fragments_sema);
}
for (i = 0; i < num_pages; i++) {
if (pagelist->type != PAGELIST_WRITE)
vm_page_dirty(pages[i]);
}
vm_page_unhold_pages(pages, num_pages);
free(pagelist, M_VCPAGELIST);
}
void
resolve_symbols()
{
void *foo;
global_cond_flag = TRUE;
#ifdef SOLARIS
mutex_lock(&queue_lock);
mutex_trylock(&queue_lock);
mutex_unlock(&queue_lock);
foo = (void *)&cond_signal;
foo = (void *)&cond_wait;
foo = (void *)&cond_timedwait;
sema_post(&global_sema_lock);
sema_wait(&global_sema_lock);
rw_rdlock(&global_rw_lock);
rw_unlock(&global_rw_lock);
rw_wrlock(&global_rw_lock);
rw_unlock(&global_rw_lock);
#endif
#ifdef POSIX
pthread_mutex_lock(&queue_lock);
pthread_mutex_trylock(&queue_lock);
pthread_mutex_unlock(&queue_lock);
foo = (void *)&pthread_cond_signal;
foo = (void *)&pthread_cond_wait;
foo = (void *)&pthread_cond_timedwait;
sem_post(&global_sema_lock);
sem_wait(&global_sema_lock);
#endif
}
int
barrier_wait(barrier_t *bar)
{
pthread_mutex_lock(&bar->bar_lock);
if (++bar->bar_numin < bar->bar_nthr) {
pthread_mutex_unlock(&bar->bar_lock);
#if defined(sun)
sema_wait(&bar->bar_sem);
#else
sem_wait(&bar->bar_sem);
#endif
return (0);
} else {
int i;
/* reset for next use */
bar->bar_numin = 0;
for (i = 1; i < bar->bar_nthr; i++)
#if defined(sun)
sema_post(&bar->bar_sem);
#else
sem_post(&bar->bar_sem);
#endif
pthread_mutex_unlock(&bar->bar_lock);
return (1);
}
}
/* sema_global: use a global semaphore to process array's data */
void
sema_global(Workblk *array, struct scripttab *k)
{
#ifdef SOLARIS
sema_wait(&global_sema_lock);
#endif
#ifdef POSIX
sem_wait(&global_sema_lock);
#endif
array->ready = gethrtime();
array->vready = gethrvtime();
array->compute_ready = array->ready;
array->compute_vready = array->vready;
/* do some work on the current array */
(k->called_func)(&array->list[0]);
array->compute_done = gethrtime();
array->compute_vdone = gethrvtime();
#ifdef SOLARIS
sema_post(&global_sema_lock);
#endif
#ifdef POSIX
sem_post(&global_sema_lock);
#endif
/* make another call to preclude tail-call optimization on the unlock */
(void) gethrtime();
}
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
u32_t time_needed = 0;
unsigned int idx;
LWIP_ASSERT("invalid mbox", sys_mbox_valid(mbox));
mutex_lock(&mbox->mutex);
while (cib_avail(&mbox->cib) == 0) {
sys_sem_t *not_empty = (sys_sem_t *)(&mbox->not_empty);
mutex_unlock(&mbox->mutex);
if (timeout != 0) {
time_needed = sys_arch_sem_wait(not_empty, timeout);
if (time_needed == SYS_ARCH_TIMEOUT) {
return SYS_ARCH_TIMEOUT;
}
}
else {
sys_arch_sem_wait(not_empty, 0);
}
mutex_lock(&mbox->mutex);
}
idx = cib_get(&mbox->cib);
if (msg != NULL) {
*msg = mbox->msgs[idx];
}
if (mbox->waiting) {
sema_post(&mbox->not_full);
}
mutex_unlock(&mbox->mutex);
return time_needed;
}
hot_err_t hot_sema_Inc(hot_sema_t sema) {
assert(sema) ;
if (sema_post(&sema->sema))
return hot_err_Create(0, "hot_sema_Inc: sema_post");
return HOT_OK;
}
/*
* Net VSC on send completion
*/
static void
hv_nv_on_send_completion(netvsc_dev *net_dev, struct vmbus_channel *chan,
const struct vmbus_chanpkt_hdr *pkt)
{
const nvsp_msg *nvsp_msg_pkt;
netvsc_packet *net_vsc_pkt;
nvsp_msg_pkt = VMBUS_CHANPKT_CONST_DATA(pkt);
if (nvsp_msg_pkt->hdr.msg_type == nvsp_msg_type_init_complete
|| nvsp_msg_pkt->hdr.msg_type
== nvsp_msg_1_type_send_rx_buf_complete
|| nvsp_msg_pkt->hdr.msg_type
== nvsp_msg_1_type_send_send_buf_complete
|| nvsp_msg_pkt->hdr.msg_type
== nvsp_msg5_type_subchannel) {
/* Copy the response back */
memcpy(&net_dev->channel_init_packet, nvsp_msg_pkt,
sizeof(nvsp_msg));
sema_post(&net_dev->channel_init_sema);
} else if (nvsp_msg_pkt->hdr.msg_type ==
nvsp_msg_1_type_send_rndis_pkt_complete) {
/* Get the send context */
net_vsc_pkt =
(netvsc_packet *)(unsigned long)pkt->cph_xactid;
if (NULL != net_vsc_pkt) {
if (net_vsc_pkt->send_buf_section_idx !=
NVSP_1_CHIMNEY_SEND_INVALID_SECTION_INDEX) {
u_long mask;
int idx;
idx = net_vsc_pkt->send_buf_section_idx /
BITS_PER_LONG;
KASSERT(idx < net_dev->bitsmap_words,
("invalid section index %u",
net_vsc_pkt->send_buf_section_idx));
mask = 1UL <<
(net_vsc_pkt->send_buf_section_idx %
BITS_PER_LONG);
KASSERT(net_dev->send_section_bitsmap[idx] &
mask,
("index bitmap 0x%lx, section index %u, "
"bitmap idx %d, bitmask 0x%lx",
net_dev->send_section_bitsmap[idx],
net_vsc_pkt->send_buf_section_idx,
idx, mask));
atomic_clear_long(
&net_dev->send_section_bitsmap[idx], mask);
}
/* Notify the layer above us */
net_vsc_pkt->compl.send.on_send_completion(chan,
net_vsc_pkt->compl.send.send_completion_context);
}
}
}
void FLMAPI f_semSignal(
F_SEM hSem)
{
#if defined( FLM_SOLARIS)
sema_post( (sema_t *)hSem);
#else
sema_signal( (sema_t *)hSem);
#endif
}
/*
* This is the main kvp kernel process that interacts with both user daemon
* and the host
*/
static void
hv_kvp_send_msg_to_daemon(void)
{
/* Prepare kvp_msg to be sent to user */
hv_kvp_convert_hostmsg_to_usermsg();
/* Send the msg to user via function deamon_read - setting sema */
sema_post(&kvp_globals.dev_sema);
}
int
sem_post(sem_t *sem)
{
int error;
if (sem_invalid(sem))
return (-1);
if ((error = sema_post((sema_t *)sem)) != 0) {
errno = error;
return (-1);
}
return (0);
}
int
release_clearance(int callnumber)
{
int which;
sema_t *table_sema = NULL;
(void) thr_getspecific(lookup_state_key, (void**)&which);
if (which == 0) /* from common pool */ {
(void) sema_post(&common_sema);
return (0);
}
switch (callnumber) {
case GETLDAPCONFIG:
table_sema = &ldap_sema;
break;
default:
logit("Internal Error: release_clearance\n");
break;
}
(void) sema_post(table_sema);
return (0);
}
/*
* This is the main kvp kernel process that interacts with both user daemon
* and the host
*/
static void
hv_kvp_send_msg_to_daemon(hv_kvp_sc *sc)
{
struct hv_kvp_msg *hmsg = sc->host_kvp_msg;
struct hv_kvp_msg *umsg = &sc->daemon_kvp_msg;
/* Prepare kvp_msg to be sent to user */
hv_kvp_convert_hostmsg_to_usermsg(hmsg, umsg);
/* Send the msg to user via function deamon_read - setting sema */
sema_post(&sc->dev_sema);
/* We should wake up the daemon, in case it's doing poll() */
selwakeup(&sc->hv_kvp_selinfo);
}
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
int idx;
LWIP_ASSERT("invalid mbox", sys_mbox_valid(mbox));
mutex_lock(&mbox->mutex);
if ((idx = cib_put(&mbox->cib)) < 0) {
mutex_unlock(&mbox->mutex);
return ERR_MEM;
}
mbox->msgs[idx] = msg;
if (cib_avail(&mbox->cib) == 1) {
sema_post(&mbox->not_empty);
}
mutex_unlock(&mbox->mutex);
return ERR_OK;
}
void sys_mbox_post(sys_mbox_t *mbox, void *msg)
{
int idx;
LWIP_ASSERT("invalid mbox", sys_mbox_valid(mbox));
mutex_lock(&mbox->mutex);
while ((idx = cib_put(&mbox->cib)) < 0) {
mbox->waiting++;
mutex_unlock(&mbox->mutex);
sema_wait_timed(&mbox->not_full, 0);
mutex_lock(&mbox->mutex);
mbox->waiting--;
}
mbox->msgs[idx] = msg;
if (cib_avail(&mbox->cib) == 1) {
sema_post(&mbox->not_empty);
}
mutex_unlock(&mbox->mutex);
}
/*
* RNDIS filter receive response
*/
static void
hv_rf_receive_response(rndis_device *device, rndis_msg *response)
{
rndis_request *request = NULL;
rndis_request *next_request;
boolean_t found = FALSE;
mtx_lock_spin(&device->req_lock);
request = STAILQ_FIRST(&device->myrequest_list);
while (request != NULL) {
/*
* All request/response message contains request_id as the
* first field
*/
if (request->request_msg.msg.init_request.request_id ==
response->msg.init_complete.request_id) {
found = TRUE;
break;
}
next_request = STAILQ_NEXT(request, mylist_entry);
request = next_request;
}
mtx_unlock_spin(&device->req_lock);
if (found) {
if (response->msg_len <= sizeof(rndis_msg)) {
memcpy(&request->response_msg, response,
response->msg_len);
} else {
if (response->ndis_msg_type == REMOTE_NDIS_RESET_CMPLT) {
/* Does not have a request id field */
request->response_msg.msg.reset_complete.status =
STATUS_BUFFER_OVERFLOW;
} else {
request->response_msg.msg.init_complete.status =
STATUS_BUFFER_OVERFLOW;
}
}
sema_post(&request->wait_sema);
}
}
void _rtw_up_sema(_sema *sema)
{
#ifdef PLATFORM_LINUX
up(sema);
#endif
#ifdef PLATFORM_FREEBSD
sema_post(sema);
#endif
#ifdef PLATFORM_OS_XP
KeReleaseSemaphore(sema, IO_NETWORK_INCREMENT, 1, FALSE );
#endif
#ifdef PLATFORM_OS_CE
ReleaseSemaphore(*sema, 1, NULL );
#endif
}
int my_sema_post(void *semptr) {
if (semptr != NULL)
return (sema_post((sema_t *)semptr));
else
return (-1);
}
void sys_sem_signal(sys_sem_t *sem)
{
LWIP_ASSERT("invalid semaphor", sys_sem_valid(sem));
sema_post((sema_t *)sem);
}
/*
* This is an interrupt callback. It is called from
* interrupt context when the adapter has completed the
* command. This very generic callback simply stores
* the command's return value in command->arg and wake's
* up anyone waiting on the command.
*/
static void ips_wakeup_callback(ips_command_t *command)
{
bus_dmamap_sync(command->sc->command_dmatag, command->command_dmamap,
BUS_DMASYNC_POSTWRITE);
sema_post(&command->sc->cmd_sema);
}
