void send_at_command_sci1(char* str){
long i;
status = 'c';
for (i = 0; str[i] != '\0'; i++) outchar1(str[i]);
outchar1('\n');
at_timeout = 10 * 100; // set at_timeout to ~10 sec
while(at_timeout){
while(qempty() && at_timeout);
c = getq();
if (c == 'O'){
while(qempty() && at_timeout);
c = getq();
if (c == 'K')
break;
else
continue;
}
}
// XXX: maybe clearing out nXXXXXXXXXX?
//empty_queue(); // clear the queue of any part of the message we may have ignored.
if (at_timeout)
status = 'i';
else{
status = 'e';
set_lcd_addr(0);
type_lcd("writing timed");
set_lcd_addr(0x40);
type_lcd("out.");
}
}
static void xnselector_destroy_loop(void *cookie)
{
struct xnselector *selector;
xnholder_t *holder;
int resched;
spl_t s;
xnlock_get_irqsave(&nklock, s);
while ((holder = getq(&xnselectors))) {
selector = container_of(holder, struct xnselector, destroy_link);
while ((holder = getq(&selector->bindings))) {
struct xnselect_binding *binding;
struct xnselect *fd;
binding = link2binding(holder, slink);
fd = binding->fd;
removeq(&fd->bindings, &binding->link);
xnlock_put_irqrestore(&nklock, s);
xnfree(binding);
xnlock_get_irqsave(&nklock, s);
}
resched =
xnsynch_destroy(&selector->synchbase) == XNSYNCH_RESCHED;
xnlock_put_irqrestore(&nklock, s);
xnfree(selector);
if (resched)
xnpod_schedule();
xnlock_get_irqsave(&nklock, s);
}
xnlock_put_irqrestore(&nklock, s);
}
static void size_conv_process(MSFilter *f){
SizeConvState *s=(SizeConvState*)f->data;
YuvBuf inbuf;
mblk_t *im;
int cur_frame;
ms_filter_lock(f);
if (s->frame_count==-1){
s->start_time=(float)f->ticker->time;
s->frame_count=0;
}
while((im=ms_queue_get(f->inputs[0]))!=NULL ){
putq(&s->rq, im);
}
cur_frame=(int)((f->ticker->time-s->start_time)*s->fps/1000.0);
if (cur_frame<=s->frame_count && s->fps>=0) {
/* too much frame */
while(s->rq.q_mcount>1){
ms_message("MSSizeConv: extra frame removed.");
im=getq(&s->rq);
freemsg(im);
}
ms_filter_unlock(f);
return;
}
if (cur_frame>s->frame_count && s->fps>=0) {
/*keep the most recent frame if several frames have been captured */
while(s->rq.q_mcount>1){
ms_message("MSSizeConv: extra frame removed.");
im=getq(&s->rq);
freemsg(im);
}
}
while((im=getq(&s->rq))!=NULL ){
if (ms_yuv_buf_init_from_mblk(&inbuf,im)==0){
if (inbuf.w==s->target_vsize.width &&
inbuf.h==s->target_vsize.height){
ms_queue_put(f->outputs[0],im);
}else{
struct ms_SwsContext *sws_ctx=get_resampler(s,inbuf.w,inbuf.h);
mblk_t *om=size_conv_alloc_mblk(s);
if (ms_sws_scale(sws_ctx,inbuf.planes,inbuf.strides, 0,
inbuf.h, s->outbuf.planes, s->outbuf.strides)<0){
ms_error("MSSizeConv: error in ms_sws_scale().");
}
ms_queue_put(f->outputs[0],om);
freemsg(im);
}
s->frame_count++;
}else freemsg(im);
}
ms_filter_unlock(f);
}
static mblk_t *simulate_bandwidth_limit_and_jitter(RtpSession *session, mblk_t *input){
OrtpNetworkSimulatorCtx *sim=session->net_sim_ctx;
struct timeval current;
int64_t elapsed;
int bits;
int budget_increase;
mblk_t *output=NULL;
int overhead=(session->rtp.gs.sockfamily==AF_INET6) ? IP6_UDP_OVERHEAD : IP_UDP_OVERHEAD;
ortp_gettimeofday(¤t,NULL);
if (sim->last_check.tv_sec==0){
sim->last_check=current;
sim->bit_budget=0;
}
/*update the budget */
elapsed=elapsed_us(&sim->last_check,¤t);
budget_increase=(elapsed*(int64_t)sim->params.max_bandwidth)/1000000LL;
sim->bit_budget+=budget_increase;
sim->bit_budget+=simulate_jitter_by_bit_budget_reduction(sim,budget_increase);
sim->last_check=current;
/* queue the packet for sending*/
if (input){
putq(&sim->q,input);
bits=(msgdsize(input)+overhead)*8;
sim->qsize+=bits;
}
/*flow control*/
while (sim->qsize>=sim->params.max_buffer_size){
// ortp_message("rtp_session_network_simulate(): discarding packets.");
output=getq(&sim->q);
if (output){
bits=(msgdsize(output)+overhead)*8;
sim->qsize-=bits;
sim->drop_by_congestion++;
freemsg(output);
}
}
output=NULL;
/*see if we can output a packet*/
if (sim->bit_budget>=0){
output=getq(&sim->q);
if (output){
bits=(msgdsize(output)+overhead)*8;
sim->bit_budget-=bits;
sim->qsize-=bits;
}
}
if (output==NULL && input==NULL && sim->bit_budget>=0){
/* unused budget is lost...*/
sim->last_check.tv_sec=0;
}
return output;
}
/*
* dm2s_rsrv - Streams read side service procedure.
*
* All messages are received in the service procedure
* only. This is done to simplify the streams synchronization.
*/
int
dm2s_rsrv(queue_t *rq)
{
mblk_t *mp;
dm2s_t *dm2sp = (dm2s_t *)rq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_rsrv: called\n"));
ASSERT(dm2sp != NULL);
mutex_enter(&dm2sp->ms_lock);
/* Receive if there are any messages waiting in the mailbox. */
dm2s_receive(dm2sp);
mutex_exit(&dm2sp->ms_lock);
/* Send the received messages up the stream. */
while ((mp = getq(rq)) != NULL) {
if (canputnext(rq)) {
putnext(rq, mp);
} else {
putbq(rq, mp);
break;
}
}
DPRINTF(DBG_DRV, ("dm2s_rsrv: return\n"));
return (0);
}
int Processer::svc(void)
{
char ch[SIZE] = { };
while(loop)
{
try
{
msg_ = 0;
getq(msg_);
//change to mongo::BSONObj
//handle it
if(msg_)
{
memset(ch,0,SIZE);
memcpy(ch,msg_->rd_ptr(),SIZE);
if(!(*ch))
throw "EMPTY BSONOBJ";
mongo::BSONObj bson(ch);
std::cout << bson << std::endl;
Handle(bson);
delete [] msg_->rd_ptr();
msg_ ->release();
}
}
catch(const char* ch)
{
LOG4CXX_ERROR(log_,ch);
}
}
return 0;
}
/**
* Destroy the @a xnselect structure associated with a file descriptor.
*
* Any binding with a @a xnselector block is destroyed.
*
* @param select_block pointer to the @a xnselect structure associated with a file descriptor
*/
void xnselect_destroy(struct xnselect *select_block)
{
xnholder_t *holder;
int resched = 0;
spl_t s;
xnlock_get_irqsave(&nklock, s);
while ((holder = getq(&select_block->bindings))) {
struct xnselect_binding *binding;
struct xnselector *selector;
binding = link2binding(holder, link);
selector = binding->selector;
__FD_CLR__(binding->bit_index,
&selector->fds[binding->type].expected);
if (!__FD_ISSET__(binding->bit_index,
&selector->fds[binding->type].pending)) {
__FD_SET__(binding->bit_index,
&selector->fds[binding->type].pending);
if (xnselect_wakeup(selector))
resched = 1;
}
removeq(&selector->bindings, &binding->slink);
xnlock_put_irqrestore(&nklock, s);
xnfree(binding);
xnlock_get_irqsave(&nklock, s);
}
if (resched)
xnpod_schedule();
xnlock_put_irqrestore(&nklock, s);
}
static bool_t queue_packet(queue_t *q, int maxrqsz, mblk_t *mp, rtp_header_t *rtp, int *discarded, int *duplicate)
{
mblk_t *tmp;
int header_size;
*discarded=0;
*duplicate=0;
header_size=RTP_FIXED_HEADER_SIZE+ (4*rtp->cc);
if ((mp->b_wptr - mp->b_rptr)==header_size){
ortp_debug("Rtp packet contains no data.");
(*discarded)++;
freemsg(mp);
return FALSE;
}
/* and then add the packet to the queue */
if (rtp_putq(q,mp) < 0) {
/* It was a duplicate packet */
(*duplicate)++;
}
/* make some checks: q size must not exceed RtpStream::max_rq_size */
while (q->q_mcount > maxrqsz)
{
/* remove the oldest mblk_t */
tmp=getq(q);
if (mp!=NULL)
{
ortp_warning("rtp_putq: Queue is full. Discarding message with ts=%u",((rtp_header_t*)mp->b_rptr)->timestamp);
freemsg(tmp);
(*discarded)++;
}
}
return TRUE;
}
/**
\brief Called from ACEReactor when there are events in our queue()
*/
int AuthLink::handle_output( ACE_HANDLE /*= ACE_INVALID_HANDLE*/ )
{
SEGSEvent *ev;
ACE_Time_Value nowait (ACE_OS::gettimeofday ());
while (-1 != getq(ev, &nowait))
{
if(ev->type()==SEGS_EventTypes::evFinish)
{
ACE_DEBUG ((LM_DEBUG,ACE_TEXT ("(%P|%t) Error sent, closing connection\n")));
return -1;
}
if(ev->type()==evContinue) // we have asked ourselves to send leftovers
{
assert(m_unsent_bytes_storage.GetReadableDataSize() > 0); // be sure we have some
}
else
{
size_t start_offset=m_unsent_bytes_storage.GetReadableDataSize();
encode_buffer(static_cast<AuthLinkEvent *>(ev),start_offset);
}
if(!send_buffer()) // trying to send the contents of the buffer
{
ev->release(); // we have failed somehow
break;
}
ev->release();
}
if (msg_queue()->is_empty ()) // we don't want to be woken up
reactor()->cancel_wakeup(this, ACE_Event_Handler::WRITE_MASK);
else // unless there is something to send still
reactor()->schedule_wakeup(this, ACE_Event_Handler::WRITE_MASK);
return 0;
}
int net32_get_msgqueue(point_info *p)
// ----------------------------------------------------------------------------
// DATA GET NET32_MESSAGE_QUEUE
// Description : net32_message_queue에서 data를 꺼내온다.
// Arguments : p Is a point-value pointer.
// Returns : n_ret Is a queue status type.
{
int n_ret;
STATUS_QUEUE_T *p_net32msg_q = (STATUS_QUEUE_T *) &gp_status->st_net32msg;
memset( p, 0, sizeof(point_info) );
pthread_mutex_lock( &net32MessageQ_mutex );
n_ret = getq( &net32_message_queue, p );
// status change
if ( n_ret == QUEUE_FULL ) {
p_net32msg_q->n_full++;
}
else if ( n_ret == QUEUE_EMPTY ) {
p_net32msg_q->n_empty++;
}
else if ( n_ret == SUCCESS ) {
p_net32msg_q->n_outdata++;
}
pthread_mutex_unlock( &net32MessageQ_mutex );
return n_ret;
}
static void v4l_process(MSFilter * obj){
V4lState *s=(V4lState*)obj->data;
uint32_t timestamp;
int cur_frame;
if (s->frame_count==-1){
s->start_time=obj->ticker->time;
s->frame_count=0;
}
cur_frame=((obj->ticker->time-s->start_time)*s->fps/1000.0);
if (cur_frame>=s->frame_count){
mblk_t *om=NULL;
ms_mutex_lock(&s->mutex);
/*keep the most recent frame if several frames have been captured */
if (s->fd!=-1){
om=getq(&s->rq);
}else{
if (s->usemire){
om=dupmsg(v4l_make_mire(s));
}else {
mblk_t *tmpm=v4l_make_nowebcam(s);
if (tmpm) om=dupmsg(tmpm);
}
}
ms_mutex_unlock(&s->mutex);
if (om!=NULL){
timestamp=obj->ticker->time*90;/* rtp uses a 90000 Hz clockrate for video*/
mblk_set_timestamp_info(om,timestamp);
mblk_set_marker_info(om,TRUE);
ms_queue_put(obj->outputs[0],om);
/*ms_message("picture sent");*/
s->frame_count++;
}
}else flushq(&s->rq,0);
}
static mblk_t *ca_get(CAData *d){
mblk_t *m;
ms_mutex_lock(&d->mutex);
m=getq(&d->rq);
ms_mutex_unlock(&d->mutex);
return m;
}
int Sub_Thread::handle_input(ACE_HANDLE fd /* = ACE_INVALID_HANDLE */)
{
printf("Sub_Thread::handle_input thread_id[%d]\n", GetCurrentThreadId() );
while(1)
{
//if (msg_queue_.is_empty())
//{
// break;
//}
ACE_Message_Block* message = NULL;
if (getq(message, NULL) == -1)
{
ACE_DEBUG((LM_ERROR, "%T (%t)getq(message,NULL) == -1\n"));
return 0;
}
//分发数据包
this->collect_msg(message);
ACE_Message_Block::release(message);
message = NULL;
}
return 0;
}
void split_and_queue(queue_t *q, int maxrqsz, mblk_t *mp, rtp_header_t *rtp, int *discarded)
{
mblk_t *mdata,*tmp;
int header_size;
*discarded=0;
header_size=RTP_FIXED_HEADER_SIZE+ (4*rtp->cc);
if ((mp->b_wptr - mp->b_rptr)==header_size){
ortp_debug("Rtp packet contains no data.");
(*discarded)++;
freemsg(mp);
return;
}
/* creates a new mblk_t to be linked with the rtp header*/
mdata=dupb(mp);
mp->b_wptr=mp->b_rptr+header_size;
mdata->b_rptr+=header_size;
/* link proto with data */
mp->b_cont=mdata;
/* and then add the packet to the queue */
rtp_putq(q,mp);
/* make some checks: q size must not exceed RtpStream::max_rq_size */
while (q->q_mcount > maxrqsz)
{
/* remove the oldest mblk_t */
tmp=getq(q);
if (mp!=NULL)
{
ortp_debug("rtp_putq: Queue is full. Discarding message with ts=%i",((rtp_header_t*)mp->b_rptr)->timestamp);
freemsg(tmp);
(*discarded)++;
}
}
}
static mblk_t * simulate_latency(RtpSession *session, mblk_t *input){
OrtpNetworkSimulatorCtx *sim=session->net_sim_ctx;
struct timeval current;
mblk_t *output=NULL;
uint32_t current_ts;
ortp_gettimeofday(¤t,NULL);
/*since we must store expiration date in reserved2(32bits) only(reserved1
already used), we need to reduce time stamp to milliseconds only*/
current_ts = 1000*current.tv_sec + current.tv_usec/1000;
/*queue the packet - store expiration timestamps in reserved fields*/
if (input){
input->reserved2 = current_ts + sim->params.latency;
putq(&sim->latency_q,input);
}
if ((output=peekq(&sim->latency_q))!=NULL){
if (TIME_IS_NEWER_THAN(current_ts, output->reserved2)){
output->reserved2=0;
getq(&sim->latency_q);
/*return the first dequeued packet*/
return output;
}
}
return NULL;
}
void xntslave_adjust(xntslave_t *slave, xnsticks_t delta)
{
int nr_cpus, cpu, n;
xnqueue_t adjq;
initq(&adjq);
for (cpu = 0, nr_cpus = xnarch_num_online_cpus(); cpu < nr_cpus; cpu++) {
struct percpu_cascade *pc = &slave->cascade[cpu];
xnholder_t *adjholder;
for (n = 0; n < XNTIMER_WHEELSIZE; n++) {
xnqueue_t *q = &pc->wheel[n];
xntlholder_t *holder;
for (holder = xntlist_head(q); holder;
holder = xntlist_next(q, holder)) {
xntimer_t *timer = plink2timer(holder);
if (testbits(timer->status, XNTIMER_REALTIME)) {
inith(&timer->adjlink);
appendq(&adjq, &timer->adjlink);
}
}
}
while ((adjholder = getq(&adjq))) {
xntimer_t *timer = adjlink2timer(adjholder);
xntimer_dequeue_periodic(timer);
xntimer_adjust_periodic(timer, delta);
}
}
}
void
rfsim_timer()
{
ip_addr hop;
struct ip * pip;
PACKET pkt;
/* send al packets which have timed out */
while(((PACKET)(simq.q_head))->nb_tstamp < cticks)
{
pkt = (PACKET)getq(&simq); /* get pkt to send */
hop = pkt->fhost; /* get hop from host field */
pip = ip_head(pkt); /* get real host address */
pkt->fhost = pip->ip_dest; /* restore host field */
simpkts++;
/* see if it's time to drop a packet */
if((lossrate) &&
((simpkts - simlastloss) > lossrate) &&
((cticks & deviation) == 1))
{
LOCK_NET_RESOURCE(FREEQ_RESID);
pk_free(pkt); /* drop instead of send */
UNLOCK_NET_RESOURCE(FREEQ_RESID);
simlastloss = simpkts; /* reset drop timer */
simdrops++; /* count drops */
}
else
ip2mac(pkt, hop); /* send pkt to hardware */
}
return;
}
void xntimer_adjust_all_aperiodic(xnsticks_t delta)
{
unsigned cpu, nr_cpus;
xnqueue_t adjq;
initq(&adjq);
delta = xnarch_ns_to_tsc(delta);
for (cpu = 0, nr_cpus = xnarch_num_online_cpus(); cpu < nr_cpus; cpu++) {
xnsched_t *sched = xnpod_sched_slot(cpu);
xntimerq_t *q = &sched->timerqueue;
xnholder_t *adjholder;
xntimerh_t *holder;
xntimerq_it_t it;
for (holder = xntimerq_it_begin(q, &it); holder;
holder = xntimerq_it_next(q, &it, holder)) {
xntimer_t *timer = aplink2timer(holder);
if (testbits(timer->status, XNTIMER_REALTIME)) {
inith(&timer->adjlink);
appendq(&adjq, &timer->adjlink);
}
}
while ((adjholder = getq(&adjq))) {
xntimer_t *timer = adjlink2timer(adjholder);
xntimer_dequeue_aperiodic(timer);
xntimer_adjust_aperiodic(timer, delta);
}
if (sched != xnpod_current_sched())
xntimer_next_remote_shot(sched);
else
xntimer_next_local_shot(sched);
}
}
static mblk_t *au_read_get(AURead *d) {
mblk_t *m;
ms_mutex_lock(&d->common.mutex);
m=getq(&d->rq);
ms_mutex_unlock(&d->common.mutex);
return m;
}
int
simquit(void * pio)
{
PACKET pkt;
ip_addr hop;
struct ip * pip;
if(simtimer)
{
in_timerkill(simtimer);
simtimer = 0;
}
/* send all queued packets */
while(simq.q_head)
{
pkt = (PACKET)getq(&simq); /* get pkt to send */
hop = pkt->fhost; /* get hop from host field */
pip = ip_head(pkt); /* get real host address */
pkt->fhost = pip->ip_dest; /* restore host field */
ip2mac(pkt, hop); /* send pkt to hardware */
}
rfsim_routing = FALSE;
ns_printf(pio, "rfsim stopped\n");
return 0;
}
static void vfw_process(MSFilter * obj){
VfwState *s=(VfwState*)obj->data;
mblk_t *m;
uint32_t timestamp;
int cur_frame;
if (s->frame_count==-1){
s->start_time=(float)obj->ticker->time;
s->frame_count=0;
}
cur_frame=(int)((obj->ticker->time-s->start_time)*s->fps/1000.0);
if (cur_frame>s->frame_count){
mblk_t *om=NULL;
/*keep the most recent frame if several frames have been captured */
if (s->eng!=NULL){
ms_mutex_lock(&s->mutex);
while((m=getq(&s->rq))!=NULL){
ms_mutex_unlock(&s->mutex);
if (om!=NULL) freemsg(om);
om=m;
ms_mutex_lock(&s->mutex);
}
ms_mutex_unlock(&s->mutex);
}
if (om!=NULL){
timestamp=(uint32_t)(obj->ticker->time*90);/* rtp uses a 90000 Hz clockrate for video*/
mblk_set_timestamp_info(om,timestamp);
ms_queue_put(obj->outputs[0],om);
}
s->frame_count++;
}
}
OrtpEvent * ortp_ev_queue_get(OrtpEvQueue *q){
OrtpEvent *ev;
ortp_mutex_lock(&q->mutex);
ev=getq(&q->q);
ortp_mutex_unlock(&q->mutex);
return ev;
}
static int
log_rsrv(queue_t *q)
{
mblk_t *mp;
char *msg, *msgid_start, *msgid_end;
size_t idlen;
while (canputnext(q) && (mp = getq(q)) != NULL) {
if (log_msgid == 0) {
/*
* Strip out the message ID. If it's a kernel
* SL_CONSOLE message, replace msgid with "unix: ".
*/
msg = (char *)mp->b_cont->b_rptr;
if ((msgid_start = strstr(msg, "[ID ")) != NULL &&
(msgid_end = strstr(msgid_start, "] ")) != NULL) {
log_ctl_t *lc = (log_ctl_t *)mp->b_rptr;
if ((lc->flags & SL_CONSOLE) &&
(lc->pri & LOG_FACMASK) == LOG_KERN)
msgid_start = msg + snprintf(msg,
7, "unix: ");
idlen = msgid_end + 2 - msgid_start;
ovbcopy(msg, msg + idlen, msgid_start - msg);
mp->b_cont->b_rptr += idlen;
}
}
mp->b_band = 0;
putnext(q, mp);
}
return (0);
}
/* Must be called nklock locked, irq off. */
static void pse51_shm_destroy(pse51_shm_t * shm, int force)
{
spl_t ignored;
removeq(&pse51_shmq, &shm->link);
xnlock_clear_irqon(&nklock);
down(&shm->maplock);
if (shm->addr) {
xnheap_free(&shm->heapbase, shm->addr);
xnheap_destroy_mapped(&shm->heapbase, NULL, NULL);
shm->addr = NULL;
shm->size = 0;
}
if (force) {
xnholder_t *holder;
while ((holder = getq(&shm->mappings))) {
up(&shm->maplock);
xnfree(link2map(holder));
down(&shm->maplock);
}
}
up(&shm->maplock);
xnlock_get_irqsave(&nklock, ignored);
}
static mblk_t *winsnd_get(MSSndCard *card){
WinSndData *d=(WinSndData*)card->data;
mblk_t *m;
ms_mutex_lock(&d->mutex);
m=getq(&d->rq);
ms_mutex_unlock(&d->mutex);
return m;
}
static mblk_t *oss_get(MSSndCard *card){
OssData *d=(OssData*)card->data;
mblk_t *m;
ms_mutex_lock(&d->mutex);
m=getq(&d->rq);
ms_mutex_unlock(&d->mutex);
return m;
}
static int
intcmp (const char *s1, const char *s2)
{
intmax_t q1, q2;
q1 = getq(s1);
q2 = getq(s2);
if (q1 > q2)
return 1;
if (q1 < q2)
return -1;
return 0;
}
static void
q_drain(struct queue * qsrc, struct queue * qdest)
{
while(qsrc->q_len)
{
putq(qdest, getq(qsrc));
}
}
static int __wind_wd_wait(struct task_struct *curr, struct pt_regs *regs)
{
xnholder_t *holder;
wind_rholder_t *rh;
WIND_TCB *pTcb;
wind_wd_t *wd;
int err = 0;
spl_t s;
if (!__xn_access_ok
(curr, VERIFY_WRITE, __xn_reg_arg1(regs), sizeof(wd->wdt)))
return -EFAULT;
rh = wind_get_rholder();
xnlock_get_irqsave(&nklock, s);
pTcb = __wind_task_current(curr);
if (xnthread_base_priority(&pTcb->threadbase) != XNCORE_IRQ_PRIO)
/* Renice the waiter above all regular tasks if needed. */
xnpod_renice_thread(&pTcb->threadbase, XNCORE_IRQ_PRIO);
if (!emptyq_p(&rh->wdpending))
goto pull_event;
xnsynch_sleep_on(&rh->wdsynch, XN_INFINITE, XN_RELATIVE);
if (xnthread_test_info(&pTcb->threadbase, XNBREAK)) {
err = -EINTR; /* Unblocked. */
goto unlock_and_exit;
}
if (xnthread_test_info(&pTcb->threadbase, XNRMID)) {
err = -EIDRM; /* Watchdog deleted while pending. */
goto unlock_and_exit;
}
pull_event:
holder = getq(&rh->wdpending);
if (holder) {
wd = link2wind_wd(holder);
/* We need the following to mark the watchdog as unqueued. */
inith(holder);
xnlock_put_irqrestore(&nklock, s);
__xn_copy_to_user(curr, (void __user *)__xn_reg_arg1(regs),
&wd->wdt, sizeof(wd->wdt));
return 0;
}
unlock_and_exit:
xnlock_put_irqrestore(&nklock, s);
return err;
}
/* remove and free all messages in the q */
void flushq(queue_t *q, int how)
{
mblk_t *mp;
while ((mp=getq(q))!=NULL)
{
freemsg(mp);
}
}
