/* command processing for pipe get operation */ /* * Copyright (c) 1997-2014 Wind River Systems, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1) Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2) Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * 3) Neither the name of Wind River Systems nor the names of its contributors * may be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include /******************************************************************************* * * K_ChRecvReq - process request command for a pipe get operation * * RETURNS: N/A */ void K_ChRecvReq(struct k_args *RequestOrig) { struct k_args *Request; struct k_args *RequestProc; kpipe_t pipeId = RequestOrig->Args.ChReq.ReqInfo.ChRef.Id; /* If it's a poster, then don't deschedule the task */ /* First we save the pointer to the task's TCB for rescheduling later */ RequestOrig->Ctxt.proc = _k_current_task; _k_state_bit_set(_k_current_task, TF_RECV); mycopypacket(&Request, RequestOrig); /* if we end up here, we arrived at destination node and the packet Request is not local */ /* Now, we need a new packet for processing of the request; the Request package is too small b/c of space lost due to possible embedded local data */ mycopypacket(&RequestProc, Request); RequestProc->Args.ChProc.ReqInfo.ChRef.pPipe = &(_k_pipe_list[OBJ_INDEX(pipeId)]); switch (ChxxxGetReqType(&(RequestProc->Args))) { case _SYNCREQ: RequestProc->Args.ChProc.pData = Request->Args.ChReq.ReqType.Sync.pData; RequestProc->Args.ChProc.iSizeTotal = Request->Args.ChReq.ReqType.Sync.iSizeTotal; break; default: break; } RequestProc->Args.ChProc.Status = XFER_IDLE; RequestProc->Args.ChProc.iNbrPendXfers = 0; RequestProc->Args.ChProc.iSizeXferred = 0; RequestProc->Forw = NULL; RequestProc->Head = NULL; switch (RequestProc->Time.ticks) { case TICKS_NONE: ChxxxSetTimeType((K_ARGS_ARGS *)&(RequestProc->Args), _TIME_NB); break; case TICKS_UNLIMITED: ChxxxSetTimeType((K_ARGS_ARGS *)&(RequestProc->Args), _TIME_B); break; default: ChxxxSetTimeType((K_ARGS_ARGS *)&(RequestProc->Args), _TIME_BT); break; } /* start processing */ struct pipe_struct *pPipe; struct k_chproc *pChProcArgs; pChProcArgs = &(RequestProc->Args.ChProc); pPipe = pChProcArgs->ReqInfo.ChRef.pPipe; do { int iData2ReadFromWriters; int iAvailBufferData; int iTotalData2Read; int32_t ticks; iData2ReadFromWriters = CalcAvailWriterData(pPipe->Writers); iAvailBufferData = pPipe->Buff.iAvailDataCont +pPipe->Buff.iAvailDataAWA; iTotalData2Read = iAvailBufferData + iData2ReadFromWriters; if (0 == iTotalData2Read) break; /* special case b/c even not good enough for 1_TO_N */ /* (possibly) do some processing */ ticks = RequestProc->Time.ticks; RequestProc->Time.timer = NULL; K_ChProc(pPipe, NULL /* writer */, RequestProc /* reader */); RequestProc->Time.ticks = ticks; /* check if request was processed */ if (TERM_XXX & ChReqGetStatus(&(RequestProc->Args.ChProc))) { RequestProc->Time.timer = NULL; /* not really required */ return; /* not listed anymore --> completely processed */ } } while (0); /* * if we got up to here, we did none or SOME (partial) * processing on the request */ if (_TIME_NB != ChxxxGetTimeType((K_ARGS_ARGS *)&(RequestProc->Args))) { /* call is blocking */ INSERT_ELM(pPipe->Readers, RequestProc); /* * NOTE: It is both faster and simpler to blindly assign the * CHDEQ_TMO microkernel command to the packet even though it * is only useful to the finite timeout case. */ RequestProc->Comm = CHDEQ_TMO; if (_TIME_B == ChxxxGetTimeType((K_ARGS_ARGS *)&(RequestProc->Args))) { /* * The writer specified TICKS_UNLIMITED, so NULL the timer. */ RequestProc->Time.timer = NULL; return; } else { /* { TIME_BT } */ #ifdef CANCEL_TIMERS if (ChReqSizeXferred(&(RequestProc->Args.ChProc))) { RequestProc->Time.timer = NULL; } else #endif /* enlist a new timer into the timeout chain */ _k_timeout_alloc(RequestProc); return; } } else { /* call is non-blocking; Check if we don't have to queue it b/c it could not be processed at once */ RequestProc->Time.timer = NULL; if (XFER_BUSY == ChReqGetStatus(&(RequestProc->Args.ChProc))) { INSERT_ELM(pPipe->Readers, RequestProc); } else { __ASSERT_NO_MSG(XFER_IDLE == ChReqGetStatus(&(RequestProc->Args.ChProc))); __ASSERT_NO_MSG(0 == ChReqSizeXferred(&(RequestProc->Args.ChProc))); RequestProc->Comm = CHDEQ_RPL; K_ChRecvRpl(RequestProc); } return; } } /******************************************************************************* * * K_ChRecvTmo - process timeout command for a pipe get operation * * RETURNS: N/A */ void K_ChRecvTmo(struct k_args *ReqProc) { __ASSERT_NO_MSG(NULL != ReqProc->Time.timer); myfreetimer(&(ReqProc->Time.timer)); ChReqSetStatus(&(ReqProc->Args.ChProc), TERM_TMO); DeListWaiter(ReqProc); if (0 == ReqProc->Args.ChProc.iNbrPendXfers) { K_ChRecvRpl(ReqProc); } } /******************************************************************************* * * K_ChRecvRpl - process reply command for a pipe get operation * * RETURNS: N/A */ void K_ChRecvRpl(struct k_args *ReqProc) { __ASSERT_NO_MSG( (0 == ReqProc->Args.ChProc.iNbrPendXfers) /* no pending Xfers */ && (NULL == ReqProc->Time.timer) /* no pending timer */ && (NULL == ReqProc->Head)); /* not in list */ /* orig packet must be sent back, not ReqProc */ struct k_args *ReqOrig = ReqProc->Ctxt.args; CHREQ_STATUS ChReqStatus; ReqOrig->Comm = CHDEQ_ACK; /* determine return value */ ChReqStatus = ChReqGetStatus(&(ReqProc->Args.ChProc)); if (TERM_TMO == ChReqStatus) { ReqOrig->Time.rcode = RC_TIME; } else if ((TERM_XXX | XFER_IDLE) & ChReqStatus) { K_PIPE_OPTION Option = ChxxxGetChOpt(&(ReqProc->Args)); if (likely(0 == ChReqSizeLeft(&(ReqProc->Args.ChProc)))) { /* All data has been transferred */ ReqOrig->Time.rcode = RC_OK; } else if (ChReqSizeXferred(&(ReqProc->Args.ChProc))) { /* Some but not all data has been transferred */ ReqOrig->Time.rcode = (Option == _ALL_N) ? RC_INCOMPLETE : RC_OK; } else { /* No data has been transferred */ ReqOrig->Time.rcode = (Option == _0_TO_N) ? RC_OK : RC_FAIL; } } else { /* unknown (invalid) status */ __ASSERT_NO_MSG(1 == 0); /* should not come here */ } ReqOrig->Args.ChAck.iSizeXferred = ReqProc->Args.ChProc.iSizeXferred; SENDARGS(ReqOrig); FREEARGS(ReqProc); } /******************************************************************************* * * K_ChRecvAck - process acknowledgement command for a pipe get operation * * RETURNS: N/A */ void K_ChRecvAck(struct k_args *Request) { struct k_args *LocalReq; LocalReq = Request->Ctxt.args; LocalReq->Time.rcode = Request->Time.rcode; LocalReq->Args.ChAck = Request->Args.ChAck; /* Reschedule the sender task */ _k_state_bit_reset(LocalReq->Ctxt.proc, TF_RECV | TF_RECVDATA); FREEARGS(Request); }