1 /*
2 * \file ocsd_dcd_mngr.h
3 * \brief OpenCSD : Decoder manager base class.
4 *
5 * \copyright Copyright (c) 2016, ARM Limited. All Rights Reserved.
6 */
7
8 /*
9 * Redistribution and use in source and binary forms, with or without modification,
10 * are permitted provided that the following conditions are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the copyright holder nor the names of its contributors
20 * may be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
27 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
30 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #ifndef ARM_OCSD_DCD_MNGR_H_INCLUDED
36 #define ARM_OCSD_DCD_MNGR_H_INCLUDED
37
38 #include "opencsd/ocsd_if_types.h"
39 #include "common/ocsd_dcd_mngr_i.h"
40 #include "common/ocsd_lib_dcd_register.h"
41 #include "common/trc_pkt_decode_base.h"
42 #include "common/trc_pkt_proc_base.h"
43
44 template <class P, class Pt, class Pc>
45 class DecoderMngrBase : public IDecoderMngr
46 {
47 public:
48 DecoderMngrBase(const std::string &decoderTypeName, ocsd_trace_protocol_t builtInProtocol);
~DecoderMngrBase()49 virtual ~DecoderMngrBase() {};
50
51 // create decoder interface.
52 virtual ocsd_err_t createDecoder(const int create_flags, const int instID, const CSConfig *p_config, TraceComponent **p_component);
53 virtual ocsd_err_t destroyDecoder(TraceComponent *p_component);
54
getProtocolType()55 virtual const ocsd_trace_protocol_t getProtocolType() const { return m_builtInProtocol; }
56
57 // common
58 virtual ocsd_err_t attachErrorLogger(TraceComponent *pComponent, ITraceErrorLog *pIErrorLog);
59
60 // pkt decoder
61 virtual ocsd_err_t attachInstrDecoder(TraceComponent *pComponent, IInstrDecode *pIInstrDec);
62 virtual ocsd_err_t attachMemAccessor(TraceComponent *pComponent, ITargetMemAccess *pMemAccessor);
63 virtual ocsd_err_t attachOutputSink(TraceComponent *pComponent, ITrcGenElemIn *pOutSink);
64
65 // pkt processor
66 virtual ocsd_err_t attachPktMonitor(TraceComponent *pComponent, ITrcTypedBase *pPktRawDataMon);
67 virtual ocsd_err_t attachPktIndexer(TraceComponent *pComponent, ITrcTypedBase *pPktIndexer);
68 virtual ocsd_err_t attachPktSink(TraceComponent *pComponent, ITrcTypedBase *pPktDataInSink);
69
70 // data input connection interface
71 virtual ocsd_err_t getDataInputI(TraceComponent *pComponent, ITrcDataIn **ppDataIn);
72
73 // generate a Config object from opaque config struct pointer.
74 virtual ocsd_err_t createConfigFromDataStruct(CSConfig **pConfigBase, const void *pDataStruct);
75
76 // implemented by decoder handler derived classes
77 virtual TraceComponent *createPktProc(const bool useInstID, const int instID) = 0;
createPktDecode(const bool useInstID,const int instID)78 virtual TraceComponent *createPktDecode(const bool useInstID, const int instID) { return 0; };
79 virtual CSConfig *createConfig(const void *pDataStruct) = 0;
80
81
82 private:
83 const ocsd_trace_protocol_t m_builtInProtocol; //!< Protocol ID if built in type.
84 };
85
86 template <class P, class Pt, class Pc>
DecoderMngrBase(const std::string & decoderTypeName,ocsd_trace_protocol_t builtInProtocol)87 DecoderMngrBase<P,Pt,Pc>::DecoderMngrBase(const std::string &decoderTypeName, ocsd_trace_protocol_t builtInProtocol) :
88 m_builtInProtocol(builtInProtocol)
89 {
90 OcsdLibDcdRegister *pDcdReg = OcsdLibDcdRegister::getDecoderRegister();
91 if(pDcdReg)
92 pDcdReg->registerDecoderTypeByName(decoderTypeName,this);
93 }
94
95 template <class P, class Pt, class Pc>
createDecoder(const int create_flags,const int instID,const CSConfig * pConfig,TraceComponent ** ppTrcComp)96 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::createDecoder(const int create_flags, const int instID, const CSConfig *pConfig, TraceComponent **ppTrcComp)
97 {
98 TraceComponent *pkt_proc = 0;
99 TraceComponent *pkt_dcd = 0;
100 bool bUseInstID = (create_flags & OCSD_CREATE_FLG_INST_ID) != 0;
101 bool bDecoder = (create_flags & OCSD_CREATE_FLG_FULL_DECODER) != 0;
102 bool bUnConfigured = (pConfig == 0);
103
104 const Pc *pConf = dynamic_cast< const Pc * >(pConfig);
105
106 // check inputs valid...
107 if((pConf == 0) && !bUnConfigured)
108 return OCSD_ERR_INVALID_PARAM_TYPE;
109
110 if((create_flags & (OCSD_CREATE_FLG_PACKET_PROC | OCSD_CREATE_FLG_FULL_DECODER)) == 0)
111 return OCSD_ERR_INVALID_PARAM_VAL;
112
113 // always need a packet processor
114 pkt_proc = createPktProc(bUseInstID, instID);
115 if(!pkt_proc)
116 return OCSD_ERR_MEM;
117
118 // set the op mode flags
119 pkt_proc->setComponentOpMode(create_flags & (OCSD_OPFLG_COMP_MODE_MASK | OCSD_OPFLG_PKTPROC_COMMON));
120
121 // set the configuration
122 TrcPktProcBase<P,Pt,Pc> *pProcBase = dynamic_cast< TrcPktProcBase<P,Pt,Pc> *>(pkt_proc);
123 if(pProcBase == 0)
124 return OCSD_ERR_INVALID_PARAM_TYPE;
125
126 if(!bUnConfigured)
127 pProcBase->setProtocolConfig(pConf);
128
129 *ppTrcComp = pkt_proc;
130
131 // may need a packet decoder
132 if(bDecoder)
133 {
134 // create the decoder
135 pkt_dcd = createPktDecode(bUseInstID, instID);
136 if(!pkt_dcd)
137 return OCSD_ERR_MEM;
138
139 // set the op mode flags
140 pkt_dcd->setComponentOpMode(create_flags & (OCSD_OPFLG_COMP_MODE_MASK | OCSD_OPFLG_PKTDEC_COMMON));
141
142 // get the decoder base
143 TrcPktDecodeBase<P,Pc> *pBase = dynamic_cast< TrcPktDecodeBase<P,Pc> *>(pkt_dcd);
144 if(pBase == 0)
145 return OCSD_ERR_INVALID_PARAM_TYPE;
146
147 if(!bUnConfigured)
148 pBase->setProtocolConfig(pConf);
149
150 // associate decoder with packet processor
151 // -> this means a TraceComponent with an associated component is a packet decoder.
152 // the associated component is the connected packet processor.
153 pkt_dcd->setAssocComponent(pkt_proc);
154
155 // connect packet processor and decoder
156 pProcBase->getPacketOutAttachPt()->attach(pBase);
157
158 *ppTrcComp = pkt_dcd;
159 }
160 return OCSD_OK;
161 }
162
163 template <class P, class Pt, class Pc>
destroyDecoder(TraceComponent * pComponent)164 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::destroyDecoder(TraceComponent *pComponent)
165 {
166 if(pComponent->getAssocComponent() != 0)
167 delete pComponent->getAssocComponent();
168 delete pComponent;
169 return OCSD_OK;
170 }
171
172 template <class P, class Pt, class Pc>
attachErrorLogger(TraceComponent * pComponent,ITraceErrorLog * pIErrorLog)173 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachErrorLogger(TraceComponent *pComponent, ITraceErrorLog *pIErrorLog)
174 {
175 return pComponent->getErrorLogAttachPt()->replace_first(pIErrorLog);
176 }
177
178 template <class P, class Pt, class Pc>
attachInstrDecoder(TraceComponent * pComponent,IInstrDecode * pIInstrDec)179 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachInstrDecoder(TraceComponent *pComponent, IInstrDecode *pIInstrDec)
180 {
181 ocsd_err_t err = OCSD_ERR_DCD_INTERFACE_UNUSED;
182
183 if(pComponent->getAssocComponent() == 0) // no associated component - so this is a packet processor
184 return OCSD_ERR_INVALID_PARAM_TYPE;
185
186 TrcPktDecodeI *pDcdI = dynamic_cast< TrcPktDecodeI * >(pComponent);
187 if(pDcdI == 0)
188 return OCSD_ERR_INVALID_PARAM_TYPE;
189
190 if(pDcdI->getUsesIDecode())
191 err = pDcdI->getInstrDecodeAttachPt()->replace_first(pIInstrDec);
192
193 return err;
194 }
195
196 template <class P, class Pt, class Pc>
attachMemAccessor(TraceComponent * pComponent,ITargetMemAccess * pMemAccessor)197 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachMemAccessor(TraceComponent *pComponent, ITargetMemAccess *pMemAccessor)
198 {
199 ocsd_err_t err = OCSD_ERR_DCD_INTERFACE_UNUSED;
200
201 if(pComponent->getAssocComponent() == 0) // no associated component - so this is a packet processor
202 return OCSD_ERR_INVALID_PARAM_TYPE;
203
204 TrcPktDecodeI *pDcdI = dynamic_cast< TrcPktDecodeI * >(pComponent);
205 if(pDcdI == 0)
206 return OCSD_ERR_INVALID_PARAM_TYPE;
207
208 if(pDcdI->getUsesMemAccess())
209 err = pDcdI->getMemoryAccessAttachPt()->replace_first(pMemAccessor);
210
211 return err;
212 }
213
214 template <class P, class Pt, class Pc>
attachOutputSink(TraceComponent * pComponent,ITrcGenElemIn * pOutSink)215 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachOutputSink(TraceComponent *pComponent, ITrcGenElemIn *pOutSink)
216 {
217 ocsd_err_t err = OCSD_ERR_INVALID_PARAM_TYPE;
218
219 if(pComponent->getAssocComponent() == 0) // no associated component - so this is a packet processor
220 return err;
221
222 TrcPktDecodeI *pDcdI = dynamic_cast< TrcPktDecodeI * >(pComponent);
223 if(pDcdI == 0)
224 return OCSD_ERR_INVALID_PARAM_TYPE;
225
226 err = pDcdI->getTraceElemOutAttachPt()->replace_first(pOutSink);
227
228 return err;
229 }
230
231 template <class P, class Pt, class Pc>
getDataInputI(TraceComponent * pComponent,ITrcDataIn ** ppDataIn)232 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::getDataInputI(TraceComponent *pComponent, ITrcDataIn **ppDataIn)
233 {
234 // find the packet processor
235 TraceComponent *pPktProc = pComponent;
236 if(pComponent->getAssocComponent() != 0)
237 pPktProc = pComponent->getAssocComponent();
238
239 TrcPktProcI *pPPI = dynamic_cast< TrcPktProcI * >(pPktProc);
240 if(pPPI == 0)
241 return OCSD_ERR_INVALID_PARAM_TYPE;
242
243 *ppDataIn = pPPI;
244
245 return OCSD_OK;
246 }
247
248 template <class P, class Pt, class Pc>
attachPktMonitor(TraceComponent * pComponent,ITrcTypedBase * pPktRawDataMon)249 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachPktMonitor(TraceComponent *pComponent, ITrcTypedBase *pPktRawDataMon)
250 {
251 // find the packet processor
252 TraceComponent *pPktProc = pComponent;
253 if(pComponent->getAssocComponent() != 0)
254 pPktProc = pComponent->getAssocComponent();
255
256 // get the packet processor
257 TrcPktProcBase<P,Pt,Pc> *pPktProcBase = dynamic_cast< TrcPktProcBase<P,Pt,Pc> * >(pPktProc);
258 if(pPktProcBase == 0)
259 return OCSD_ERR_INVALID_PARAM_TYPE;
260
261 // get the interface
262 IPktRawDataMon<P> *p_If = dynamic_cast< IPktRawDataMon<P> * >(pPktRawDataMon);
263 if(p_If == 0)
264 return OCSD_ERR_INVALID_PARAM_TYPE;
265
266 return pPktProcBase->getRawPacketMonAttachPt()->replace_first(p_If);
267 }
268
269 template <class P, class Pt, class Pc>
attachPktIndexer(TraceComponent * pComponent,ITrcTypedBase * pPktIndexer)270 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachPktIndexer(TraceComponent *pComponent, ITrcTypedBase *pPktIndexer)
271 {
272 // find the packet processor
273 TraceComponent *pPktProc = pComponent;
274 if(pComponent->getAssocComponent() != 0)
275 pPktProc = pComponent->getAssocComponent();
276
277 // get the packet processor
278 TrcPktProcBase<P,Pt,Pc> *pPktProcBase = dynamic_cast< TrcPktProcBase<P,Pt,Pc> * >(pPktProc);
279 if(pPktProcBase == 0)
280 return OCSD_ERR_INVALID_PARAM_TYPE;
281
282 // get the interface
283 ITrcPktIndexer<Pt> *p_If = dynamic_cast< ITrcPktIndexer<Pt> * >(pPktIndexer);
284 if(p_If == 0)
285 return OCSD_ERR_INVALID_PARAM_TYPE;
286
287 return pPktProcBase->getTraceIDIndexerAttachPt()->replace_first(p_If);
288 }
289
290 template <class P, class Pt, class Pc>
attachPktSink(TraceComponent * pComponent,ITrcTypedBase * pPktDataInSink)291 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::attachPktSink(TraceComponent *pComponent, ITrcTypedBase *pPktDataInSink)
292 {
293 // must be solo packet processor
294 if(pComponent->getAssocComponent() != 0)
295 return OCSD_ERR_INVALID_PARAM_TYPE;
296
297 // interface must be the correct one.
298 IPktDataIn<P> *pkt_in_i = dynamic_cast< IPktDataIn<P> * >(pPktDataInSink);
299 if(pkt_in_i == 0)
300 return OCSD_ERR_INVALID_PARAM_TYPE;
301
302 // get the packet processor
303 TrcPktProcBase<P,Pt,Pc> *pPktProcBase = dynamic_cast< TrcPktProcBase<P,Pt,Pc> * >(pComponent);
304 if(pPktProcBase == 0)
305 return OCSD_ERR_INVALID_PARAM_TYPE;
306
307 // attach
308 return pPktProcBase->getPacketOutAttachPt()->replace_first(pkt_in_i);
309 }
310
311 template <class P, class Pt, class Pc>
createConfigFromDataStruct(CSConfig ** pConfigBase,const void * pDataStruct)312 ocsd_err_t DecoderMngrBase<P,Pt,Pc>::createConfigFromDataStruct(CSConfig **pConfigBase, const void *pDataStruct)
313 {
314 CSConfig *pConfig = createConfig(pDataStruct);
315 if(!pConfig)
316 return OCSD_ERR_MEM;
317 *pConfigBase = pConfig;
318 return OCSD_OK;
319 }
320
321 /****************************************************************************************************/
322 /* Full decoder / packet process pair, templated base for creating decoder objects */
323 /****************************************************************************************************/
324
325 template< class P, // Packet class.
326 class Pt, // Packet enum type ID.
327 class Pc, // Processor config class.
328 class PcSt, // Processor config struct type
329 class PktProc, // Packet processor class.
330 class PktDcd> // Packet decoder class.
331 class DecodeMngrFullDcd : public DecoderMngrBase<P,Pt,Pc>
332 {
333 public:
DecodeMngrFullDcd(const std::string & name,ocsd_trace_protocol_t builtInProtocol)334 DecodeMngrFullDcd (const std::string &name, ocsd_trace_protocol_t builtInProtocol)
335 : DecoderMngrBase<P,Pt,Pc>(name,builtInProtocol) {};
336
~DecodeMngrFullDcd()337 virtual ~DecodeMngrFullDcd() {};
338
createPktProc(const bool useInstID,const int instID)339 virtual TraceComponent *createPktProc(const bool useInstID, const int instID)
340 {
341 TraceComponent *pComp;
342 if(useInstID)
343 pComp = new (std::nothrow) PktProc(instID);
344 else
345 pComp = new (std::nothrow) PktProc();
346 return pComp;
347 }
348
createPktDecode(const bool useInstID,const int instID)349 virtual TraceComponent *createPktDecode(const bool useInstID, const int instID)
350 {
351 TraceComponent *pComp;
352 if(useInstID)
353 pComp = new (std::nothrow)PktDcd(instID);
354 else
355 pComp = new (std::nothrow)PktDcd();
356 return pComp;
357 }
358
createConfig(const void * pDataStruct)359 virtual CSConfig *createConfig(const void *pDataStruct)
360 {
361 return new (std::nothrow) Pc((PcSt *)pDataStruct);
362 }
363 };
364
365 /* full decode - extended config object - base + derived. */
366 template< class P, // Packet class.
367 class Pt, // Packet enum type ID.
368 class Pc, // Processor config base class.
369 class PcEx, // Processor config derived class
370 class PcSt, // Processor config struct type
371 class PktProc, // Packet processor class.
372 class PktDcd> // Packet decoder class.
373 class DecodeMngrFullDcdExCfg : public DecoderMngrBase<P, Pt, Pc>
374 {
375 public:
DecodeMngrFullDcdExCfg(const std::string & name,ocsd_trace_protocol_t builtInProtocol)376 DecodeMngrFullDcdExCfg(const std::string &name, ocsd_trace_protocol_t builtInProtocol)
377 : DecoderMngrBase<P, Pt, Pc>(name, builtInProtocol) {};
378
~DecodeMngrFullDcdExCfg()379 virtual ~DecodeMngrFullDcdExCfg() {};
380
createPktProc(const bool useInstID,const int instID)381 virtual TraceComponent *createPktProc(const bool useInstID, const int instID)
382 {
383 TraceComponent *pComp;
384 if (useInstID)
385 pComp = new (std::nothrow) PktProc(instID);
386 else
387 pComp = new (std::nothrow) PktProc();
388 return pComp;
389 }
390
createPktDecode(const bool useInstID,const int instID)391 virtual TraceComponent *createPktDecode(const bool useInstID, const int instID)
392 {
393 TraceComponent *pComp;
394 if (useInstID)
395 pComp = new (std::nothrow)PktDcd(instID);
396 else
397 pComp = new (std::nothrow)PktDcd();
398 return pComp;
399 }
400
createConfig(const void * pDataStruct)401 virtual CSConfig *createConfig(const void *pDataStruct)
402 {
403 return new (std::nothrow) PcEx((PcSt *)pDataStruct);
404 }
405 };
406
407
408 /****************************************************************************************************/
409 /* Packet processor only, templated base for creating decoder objects */
410 /****************************************************************************************************/
411
412 template< class P, // Packet class.
413 class Pt, // Packet enum type ID.
414 class Pc, // Processor config class.
415 class PcSt, // Processor config struct type
416 class PktProc> // Packet processor class.
417 class DecodeMngrPktProc : public DecoderMngrBase<P,Pt,Pc>
418 {
419 public:
DecodeMngrPktProc(const std::string & name,ocsd_trace_protocol_t builtInProtocol)420 DecodeMngrPktProc (const std::string &name, ocsd_trace_protocol_t builtInProtocol)
421 : DecoderMngrBase<P,Pt,Pc>(name,builtInProtocol) {};
422
~DecodeMngrPktProc()423 virtual ~DecodeMngrPktProc() {};
424
createPktProc(const bool useInstID,const int instID)425 virtual TraceComponent *createPktProc(const bool useInstID, const int instID)
426 {
427 TraceComponent *pComp;
428 if(useInstID)
429 pComp = new (std::nothrow) PktProc(instID);
430 else
431 pComp = new (std::nothrow) PktProc();
432 return pComp;
433 }
434
createConfig(const void * pDataStruct)435 virtual CSConfig *createConfig(const void *pDataStruct)
436 {
437 return new (std::nothrow) Pc((PcSt *)pDataStruct);
438 }
439 };
440
441
442
443 #endif // ARM_OCSD_DCD_MNGR_H_INCLUDED
444
445 /* End of File ocsd_dcd_mngr.h */
446