From b216324689bd580c0d3d2fcdf36b4df942b02166 Mon Sep 17 00:00:00 2001 From: jcar Date: Wed, 30 Nov 2011 10:46:15 +0100 Subject: [PATCH] COM protection --- communication/Com/Com.c | 28 ++++++++---- communication/Com/Com_Com.c | 82 +++++++++++++++++++++++------------ communication/Com/Com_Sched.c | 11 +++++ communication/Com/Com_misc.c | 20 ++++++--- communication/Com/Com_misc.h | 6 --- 5 files changed, 98 insertions(+), 49 deletions(-) diff --git a/communication/Com/Com.c b/communication/Com/Com.c index 6a7b684f..241148ec 100644 --- a/communication/Com/Com.c +++ b/communication/Com/Com.c @@ -171,6 +171,7 @@ void Com_IpduGroupStart(Com_PduGroupIdType IpduGroupId,boolean Initialize) { for (uint16 i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) { Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 1; + break; } } } @@ -179,6 +180,7 @@ void Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId) { for (uint16 i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) { if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) { Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 0; + break; } } } @@ -193,11 +195,14 @@ void Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId) { */ BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, RetryInfoType* RetryInfoPtr, PduLengthType* TxDataCntPtr) { imask_t state; - Irq_Save(state); BufReq_ReturnType r = BUFREQ_OK; const ComIPdu_type *IPdu = GET_IPdu(PduId); boolean dirOk = ComConfig->ComIPdu[PduId].ComIPduDirection == SEND; - boolean sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength; + boolean sizeOk; + + Irq_Save(state); + + sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength; Com_BufferPduState[PduId].locked = true; if (dirOk && sizeOk) { void* source = (void *)IPdu->ComIPduDataPtr; @@ -212,12 +217,18 @@ BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, Retry } BufReq_ReturnType Com_CopyRxData(PduIdType PduId, const PduInfoType* PduInfoPtr, PduLengthType* RxBufferSizePtr) { imask_t state; - Irq_Save(state); BufReq_ReturnType r = BUFREQ_OK; - uint8 remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition; - boolean sizeOk = remainingBytes >= PduInfoPtr->SduLength; - boolean dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE; - boolean lockOk = isPduBufferLocked(PduId); + uint8 remainingBytes; + boolean sizeOk; + boolean dirOk; + boolean lockOk; + + Irq_Save(state); + + remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition; + sizeOk = remainingBytes >= PduInfoPtr->SduLength; + dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE; + lockOk = isPduBufferLocked(PduId); if (dirOk && lockOk && sizeOk) { memcpy((void *)(GET_IPdu(PduId)->ComIPduDataPtr+Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength); Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength; @@ -243,9 +254,10 @@ static void Com_SetDynSignalLength(PduIdType ComRxPduId,PduLengthType TpSduLengt BufReq_ReturnType Com_StartOfReception(PduIdType ComRxPduId, PduLengthType TpSduLength, PduLengthType* RxBufferSizePtr) { PduLengthType ComIPduSize; imask_t state; - Irq_Save(state); BufReq_ReturnType r = BUFREQ_OK; Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); + + Irq_Save(state); if (Arc_IPdu->Com_Arc_IpduStarted) { if (GET_IPdu(ComRxPduId)->ComIPduDirection == RECEIVE) { if (!Com_BufferPduState[ComRxPduId].locked) { diff --git a/communication/Com/Com_Com.c b/communication/Com/Com_Com.c index 467383bc..463a0120 100644 --- a/communication/Com/Com_Com.c +++ b/communication/Com/Com_Com.c @@ -46,8 +46,9 @@ uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) { } //DEBUG(DEBUG_LOW, "Com_SendSignal: id %d, nBytes %d, BitPosition %d, intVal %d\n", SignalId, nBytes, signal->ComBitPosition, (uint32)*(uint8 *)SignalDataPtr); - // TODO: CopyData - // Com_CopyData(IPdu->ComIPduDataPtr, dataPtr, Signal->ComBitSize, Signal->ComBitPosition, 0); + imask_t irq_state; + + Irq_Save(irq_state); Com_WriteSignalDataToPdu(Signal->ComHandleId, SignalDataPtr); // If the signal has an update bit. Set it! @@ -61,6 +62,8 @@ uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) { if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } + Irq_Restore(irq_state); + return E_OK; } @@ -74,12 +77,8 @@ uint8 Com_ReceiveSignal(Com_SignalIdType SignalId, void* SignalDataPtr) { return COM_BUSY; } - // Com_CopyFromSignal(&ComConfig->ComSignal[SignalId], SignalDataPtr); Com_ReadSignalDataFromPdu(SignalId, SignalDataPtr); - //uint16 val = *(uint16 *)SignalDataPtr; - //val = bswap16(val); - // Sign extend! return E_OK; } @@ -87,17 +86,23 @@ uint8 Com_ReceiveDynSignal(Com_SignalIdType SignalId, void* SignalDataPtr, uint1 const ComSignal_type * Signal = GET_Signal(SignalId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); + imask_t state; Com_SignalType signalType = Signal->ComSignalType; if (signalType != UINT8_DYN || isPduBufferLocked(getPduId(IPdu))) { return COM_SERVICE_NOT_AVAILABLE; } + Irq_Save(state); + if (*Length > Arc_IPdu->Com_Arc_DynSignalLength) { *Length = Arc_IPdu->Com_Arc_DynSignalLength; } uint8 startFromPduByte = (Signal->ComBitPosition) / 8; memcpy(SignalDataPtr, IPdu->ComIPduDataPtr + startFromPduByte, *Length); + + Irq_Restore(state); + return E_OK; } @@ -105,6 +110,7 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui const ComSignal_type * Signal = GET_Signal(SignalId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId); const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId); + imask_t state; Com_SignalType signalType = Signal->ComSignalType; if (signalType != UINT8_DYN) { @@ -119,6 +125,8 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui return E_NOT_OK; } uint8 startFromPduByte = bitPosition / 8; + + Irq_Save(state); memcpy((void *)(IPdu->ComIPduDataPtr + startFromPduByte), SignalDataPtr, Length); Arc_IPdu->Com_Arc_DynSignalLength = Length; // If the signal has an update bit. Set it! @@ -129,7 +137,9 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } - return E_OK; + Irq_Restore(state); + + return E_OK; } Std_ReturnType Com_TriggerTransmit(PduIdType ComTxPduId, PduInfoType *PduInfoPtr) { @@ -144,7 +154,13 @@ Std_ReturnType Com_TriggerTransmit(PduIdType ComTxPduId, PduInfoType *PduInfoPtr */ const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId); - memcpy(PduInfoPtr->SduDataPtr, IPdu->ComIPduDataPtr, IPdu->ComIPduSize); + imask_t state; + Irq_Save(state); + + memcpy(PduInfoPtr->SduDataPtr, IPdu->ComIPduDataPtr, IPdu->ComIPduSize); + + Irq_Restore(state); + PduInfoPtr->SduLength = IPdu->ComIPduSize; return E_OK; } @@ -156,14 +172,13 @@ void Com_TriggerIPduSend(PduIdType ComTxPduId) { const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComTxPduId); + imask_t state; + Irq_Save(state); // Is the IPdu ready for transmission? if (Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer == 0) { - imask_t state; - //lint --e(725) Suppress PC-Lint warning "Expected positive indentation...". What means? - Irq_Save(state); // Check callout status if (IPdu->ComIPduCallout != NULL) { if (!IPdu->ComIPduCallout(ComTxPduId, IPdu->ComIPduDataPtr)) { @@ -193,14 +208,13 @@ void Com_TriggerIPduSend(PduIdType ComTxPduId) { } else { UnlockTpBuffer(getPduId(IPdu)); } - Irq_Restore(state); // Reset miminum delay timer. Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer = IPdu->ComTxIPdu.ComTxIPduMinimumDelayFactor; - } else { //DEBUG(DEBUG_MEDIUM, "failed (MDT)!\n", ComTxPduId); } + Irq_Restore(state); } //lint -esym(904, Com_RxIndication) //PC-Lint Exception of rule 14.7 @@ -209,9 +223,12 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) { const ComIPdu_type *IPdu = GET_IPdu(ComRxPduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId); + imask_t state; + Irq_Save(state); // If Ipdu is stopped if (!Arc_IPdu->Com_Arc_IpduStarted) { + Irq_Restore(state); return; } @@ -220,6 +237,7 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) { if (!IPdu->ComIPduCallout(ComRxPduId, PduInfoPtr->SduDataPtr)) { // TODO Report error to DET. // Det_ReportError(); + Irq_Restore(state); return; } } @@ -229,6 +247,8 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) { Com_RxProcessSignals(IPdu,Arc_IPdu); + Irq_Restore(state); + return; } @@ -237,24 +257,30 @@ void Com_TpRxIndication(PduIdType PduId, NotifResultType Result) { const ComIPdu_type *IPdu = GET_IPdu(PduId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(PduId); + imask_t state; + + Irq_Save(state); // If Ipdu is stopped if (!Arc_IPdu->Com_Arc_IpduStarted) { + Irq_Restore(state); return; } + // unlock buffer - imask_t state; - Irq_Save(state); UnlockTpBuffer(getPduId(IPdu)); - Irq_Restore(state); if (Result == NTFRSLT_OK) { Com_RxProcessSignals(IPdu,Arc_IPdu); } + + Irq_Restore(state); } + void Com_TpTxConfirmation(PduIdType PduId, NotifResultType Result) { PDU_ID_CHECK(PduId, 0x15); const ComIPdu_type *IPdu = GET_IPdu(PduId); + (void)Result; // touch imask_t state; Irq_Save(state); @@ -280,10 +306,12 @@ Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) { // Copy shadow buffer to Ipdu data space const ComGroupSignal_type *groupSignal; + imask_t irq_state; + + Irq_Save(irq_state); for (uint8 i = 0; Signal->ComGroupSignal[i] != NULL; i++) { groupSignal = Signal->ComGroupSignal[i]; - // TODO CopyData - // Com_CopyData(IPdu->ComIPduDataPtr, Arc_Signal->Com_Arc_ShadowBuffer, groupSignal->ComBitSize, groupSignal->ComBitPosition, groupSignal->ComBitPosition); + Com_WriteGroupSignalDataToPdu(Signal->ComHandleId, groupSignal->ComHandleId, Signal->Com_Arc_ShadowBuffer); } @@ -292,12 +320,11 @@ Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) { SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition); } - /* - * If signal has triggered transmit property, trigger a transmission! - */ + // If signal has triggered transmit property, trigger a transmission! if (Signal->ComTransferProperty == TRIGGERED) { Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1; } + Irq_Restore(irq_state); return E_OK; } @@ -313,13 +340,15 @@ Std_ReturnType Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId) { } // Copy Ipdu data buffer to shadow buffer. const ComGroupSignal_type *groupSignal; + imask_t irq_state; + + Irq_Save(irq_state); for (uint8 i = 0; Signal->ComGroupSignal[i] != NULL; i++) { groupSignal = Signal->ComGroupSignal[i]; - // TODO: CopyData - // Com_CopyData(Arc_Signal->Com_Arc_ShadowBuffer, IPdu->ComIPduDataPtr, groupSignal->ComBitSize, groupSignal->ComBitPosition, groupSignal->ComBitPosition); + Com_ReadSignalDataFromPdu(groupSignal->ComHandleId, (void *)Signal->Com_Arc_ShadowBuffer); } - + Irq_Restore(irq_state); return E_OK; } @@ -327,16 +356,13 @@ Std_ReturnType Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId) { void Com_UpdateShadowSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) { Com_Arc_GroupSignal_type *Arc_GroupSignal = GET_ArcGroupSignal(SignalId); - // TODO: CopyData - // Com_CopyData(Arc_GroupSignal->Com_Arc_ShadowBuffer, SignalDataPtr, GroupSignal->ComBitSize, GroupSignal->ComBitPosition, 0); Com_WriteSignalDataToPduBuffer(SignalId, TRUE, SignalDataPtr, (void *)Arc_GroupSignal->Com_Arc_ShadowBuffer, 8); } void Com_ReceiveShadowSignal(Com_SignalIdType SignalId, void *SignalDataPtr) { Com_Arc_GroupSignal_type *Arc_GroupSignal = GET_ArcGroupSignal(SignalId); uint8 pduSize = GET_IPdu(GET_Signal(SignalId)->ComIPduHandleId)->ComIPduSize; - // TODO: CopyData - // Com_CopyData(SignalDataPtr, Arc_GroupSignal->Com_Arc_ShadowBuffer, GroupSignal->ComBitSize, 0, GroupSignal->ComBitPosition); + Com_ReadSignalDataFromPduBuffer(SignalId, TRUE, SignalDataPtr, (void *)Arc_GroupSignal->Com_Arc_ShadowBuffer,pduSize); } diff --git a/communication/Com/Com_Sched.c b/communication/Com/Com_Sched.c index 72f88c20..338a1957 100644 --- a/communication/Com/Com_Sched.c +++ b/communication/Com/Com_Sched.c @@ -39,6 +39,9 @@ void Com_MainFunctionRx(void) { signal = &ComConfig->ComSignal[i]; Com_Arc_Signal_type * Arc_Signal = GET_ArcSignal(signal->ComHandleId); Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(signal->ComIPduHandleId); + imask_t irq_state; + + Irq_Save(irq_state); // Monitor signal reception deadline if ( (Arc_IPdu->Com_Arc_IpduStarted) && (signal->ComTimeoutFactor > 0) ) { @@ -70,11 +73,15 @@ void Com_MainFunctionRx(void) { } Arc_Signal->ComSignalUpdated = 0; } + + Irq_Restore(irq_state); } } void Com_MainFunctionTx(void) { + imask_t irq_state; + //DEBUG(DEBUG_MEDIUM, "Com_MainFunctionTx() excecuting\n"); // Decrease timers. const ComIPdu_type *IPdu; @@ -82,6 +89,8 @@ void Com_MainFunctionTx(void) { IPdu = &ComConfig->ComIPdu[i]; Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(i); + Irq_Save(irq_state); + // Is this a IPdu that should be transmitted? if ( (IPdu->ComIPduDirection == SEND) && (Arc_IPdu->Com_Arc_IpduStarted) ) { // Decrease minimum delay timer @@ -145,5 +154,7 @@ void Com_MainFunctionTx(void) { // Don't send! } } + + Irq_Restore(irq_state); } } diff --git a/communication/Com/Com_misc.c b/communication/Com/Com_misc.c index c433347d..7e67cead 100644 --- a/communication/Com/Com_misc.c +++ b/communication/Com/Com_misc.c @@ -26,6 +26,11 @@ #include "debug.h" #include "Cpu.h" +static void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength, + Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput); + +static void Com_WriteDataSegment(uint8 *pdu, uint8 *pduSignalMask, const uint8 *signalDataPtr, uint8 destByteLength, + Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength); void Com_ReadSignalDataFromPdu( const Com_SignalIdType signalId, @@ -96,6 +101,8 @@ void Com_ReadSignalDataFromPduBuffer( uint8 signalDataBytesArray[8]; const uint8 *pduBufferBytes = (const uint8 *)pduBuffer + (bitPosition/8); Com_BitPositionType startBitOffset = 0; + imask_t state; + Irq_Save(state); if (signalEndianess == COM_OPAQUE || signalType == UINT8_N) { // Aligned opaque data -> straight copy @@ -144,6 +151,7 @@ void Com_ReadSignalDataFromPduBuffer( assert(0); } } + Irq_Restore(state); } @@ -218,6 +226,9 @@ void Com_WriteSignalDataToPduBuffer( uint8 signalDataBytesArray[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; const uint8 *signalDataBytes = (const uint8 *)signalData; + imask_t irq_state; + + Irq_Save(irq_state); if (endian == COM_OPAQUE || signalType == UINT8_N) { //assert(bitPosition % 8 == 0); //assert(bitSize % 8 == 0); @@ -253,13 +264,10 @@ void Com_WriteSignalDataToPduBuffer( // Straight copy into real pdu buffer (with mutex) uint8 *pduBufferBytes = ((uint8 *)pduBuffer)+(bitPosition/8); uint8 i; - imask_t irq_state; - Irq_Save(irq_state); for (i = 0; i < 8; i++) { pduBufferBytes[ i ] &= ~( pduSignalMask[ i ] ); pduBufferBytes[ i ] |= pduBufferBytesStraight[ i ]; } - Irq_Restore(irq_state); } else { uint8 startBitOffset = intelBitNrToPduOffset(bitPosition%8, bitSize, 64); @@ -271,16 +279,14 @@ void Com_WriteSignalDataToPduBuffer( // Swapped copy into real pdu buffer (with mutex) uint8 *pduBufferBytes = ((uint8 *)pduBuffer)+(bitPosition/8); uint8 i; - imask_t irq_state; - Irq_Save(irq_state); // actually it is only necessary to iterate through the bytes that are written. for (i = 0; i < 8; i++) { pduBufferBytes[ i ] &= ~( pduSignalMask[ (8 - 1) - i ] ); pduBufferBytes[ i ] |= pduBufferBytesSwapped[ (8 - 1) - i ]; } - Irq_Restore(irq_state); } } + Irq_Restore(irq_state); } @@ -308,7 +314,7 @@ void Com_WriteSignalDataToPduBuffer( * | -------- | -------A | BCDEFGHI | JKLMNOPQ | * */ -void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength, +static void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength, Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput) { Com_BitPositionType sourceEndBitOffset = segmentStartBitOffset + segmentBitLength - 1; diff --git a/communication/Com/Com_misc.h b/communication/Com/Com_misc.h index d185c86a..1316e0ca 100644 --- a/communication/Com/Com_misc.h +++ b/communication/Com/Com_misc.h @@ -70,12 +70,6 @@ void Com_WriteSignalDataToPduBuffer( //void Com_CopyData2(char *dest, const char *source, uint8 destByteLength, uint8 segmentStartBitOffset, uint8 segmentBitLength); -void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength, - Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput); - -void Com_WriteDataSegment(uint8 *pdu, uint8 *pduSignalMask, const uint8 *signalDataPtr, uint8 destByteLength, - Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength); - Com_BitPositionType motorolaBitNrToPduOffset (Com_BitPositionType motorolaBitNr); Com_BitPositionType intelBitNrToPduOffset (Com_BitPositionType intelBitNr, Com_BitPositionType segmentBitLength, Com_BitPositionType pduBitLength); void Com_RxProcessSignals(const ComIPdu_type *IPdu,Com_Arc_IPdu_type *Arc_IPdu); -- 2.39.2