1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * USBSS device controller driver. 4 * Trace support header file. 5 * 6 * Copyright (C) 2018-2019 Cadence. 7 * 8 * Author: Pawel Laszczak <pawell@cadence.com> 9 */ 10 11 #undef TRACE_SYSTEM 12 #define TRACE_SYSTEM cdns3 13 14 #if !defined(__LINUX_CDNS3_TRACE) || defined(TRACE_HEADER_MULTI_READ) 15 #define __LINUX_CDNS3_TRACE 16 17 #include <linux/types.h> 18 #include <linux/tracepoint.h> 19 #include <asm/byteorder.h> 20 #include <linux/usb/ch9.h> 21 #include "core.h" 22 #include "cdns3-gadget.h" 23 #include "cdns3-debug.h" 24 25 #define CDNS3_MSG_MAX 500 26 27 TRACE_EVENT(cdns3_halt, 28 TP_PROTO(struct cdns3_endpoint *ep_priv, u8 halt, u8 flush), 29 TP_ARGS(ep_priv, halt, flush), 30 TP_STRUCT__entry( 31 __string(name, ep_priv->name) 32 __field(u8, halt) 33 __field(u8, flush) 34 ), 35 TP_fast_assign( 36 __assign_str(name, ep_priv->name); 37 __entry->halt = halt; 38 __entry->flush = flush; 39 ), 40 TP_printk("Halt %s for %s: %s", __entry->flush ? " and flush" : "", 41 __get_str(name), __entry->halt ? "set" : "cleared") 42 ); 43 44 TRACE_EVENT(cdns3_wa1, 45 TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg), 46 TP_ARGS(ep_priv, msg), 47 TP_STRUCT__entry( 48 __string(ep_name, ep_priv->name) 49 __string(msg, msg) 50 ), 51 TP_fast_assign( 52 __assign_str(ep_name, ep_priv->name); 53 __assign_str(msg, msg); 54 ), 55 TP_printk("WA1: %s %s", __get_str(ep_name), __get_str(msg)) 56 ); 57 58 TRACE_EVENT(cdns3_wa2, 59 TP_PROTO(struct cdns3_endpoint *ep_priv, char *msg), 60 TP_ARGS(ep_priv, msg), 61 TP_STRUCT__entry( 62 __string(ep_name, ep_priv->name) 63 __string(msg, msg) 64 ), 65 TP_fast_assign( 66 __assign_str(ep_name, ep_priv->name); 67 __assign_str(msg, msg); 68 ), 69 TP_printk("WA2: %s %s", __get_str(ep_name), __get_str(msg)) 70 ); 71 72 DECLARE_EVENT_CLASS(cdns3_log_doorbell, 73 TP_PROTO(const char *ep_name, u32 ep_trbaddr), 74 TP_ARGS(ep_name, ep_trbaddr), 75 TP_STRUCT__entry( 76 __string(name, ep_name) 77 __field(u32, ep_trbaddr) 78 ), 79 TP_fast_assign( 80 __assign_str(name, ep_name); 81 __entry->ep_trbaddr = ep_trbaddr; 82 ), 83 TP_printk("%s, ep_trbaddr %08x", __get_str(name), 84 __entry->ep_trbaddr) 85 ); 86 87 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_ep0, 88 TP_PROTO(const char *ep_name, u32 ep_trbaddr), 89 TP_ARGS(ep_name, ep_trbaddr) 90 ); 91 92 DEFINE_EVENT(cdns3_log_doorbell, cdns3_doorbell_epx, 93 TP_PROTO(const char *ep_name, u32 ep_trbaddr), 94 TP_ARGS(ep_name, ep_trbaddr) 95 ); 96 97 DECLARE_EVENT_CLASS(cdns3_log_usb_irq, 98 TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists), 99 TP_ARGS(priv_dev, usb_ists), 100 TP_STRUCT__entry( 101 __field(enum usb_device_speed, speed) 102 __field(u32, usb_ists) 103 __dynamic_array(char, str, CDNS3_MSG_MAX) 104 ), 105 TP_fast_assign( 106 __entry->speed = cdns3_get_speed(priv_dev); 107 __entry->usb_ists = usb_ists; 108 ), 109 TP_printk("%s", cdns3_decode_usb_irq(__get_str(str), __entry->speed, 110 __entry->usb_ists)) 111 ); 112 113 DEFINE_EVENT(cdns3_log_usb_irq, cdns3_usb_irq, 114 TP_PROTO(struct cdns3_device *priv_dev, u32 usb_ists), 115 TP_ARGS(priv_dev, usb_ists) 116 ); 117 118 DECLARE_EVENT_CLASS(cdns3_log_epx_irq, 119 TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep), 120 TP_ARGS(priv_dev, priv_ep), 121 TP_STRUCT__entry( 122 __string(ep_name, priv_ep->name) 123 __field(u32, ep_sts) 124 __field(u32, ep_traddr) 125 __field(u32, ep_last_sid) 126 __field(u32, use_streams) 127 __dynamic_array(char, str, CDNS3_MSG_MAX) 128 ), 129 TP_fast_assign( 130 __assign_str(ep_name, priv_ep->name); 131 __entry->ep_sts = readl(&priv_dev->regs->ep_sts); 132 __entry->ep_traddr = readl(&priv_dev->regs->ep_traddr); 133 __entry->ep_last_sid = priv_ep->last_stream_id; 134 __entry->use_streams = priv_ep->use_streams; 135 ), 136 TP_printk("%s, ep_traddr: %08x ep_last_sid: %08x use_streams: %d", 137 cdns3_decode_epx_irq(__get_str(str), 138 __get_str(ep_name), 139 __entry->ep_sts), 140 __entry->ep_traddr, 141 __entry->ep_last_sid, 142 __entry->use_streams) 143 ); 144 145 DEFINE_EVENT(cdns3_log_epx_irq, cdns3_epx_irq, 146 TP_PROTO(struct cdns3_device *priv_dev, struct cdns3_endpoint *priv_ep), 147 TP_ARGS(priv_dev, priv_ep) 148 ); 149 150 DECLARE_EVENT_CLASS(cdns3_log_ep0_irq, 151 TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts), 152 TP_ARGS(priv_dev, ep_sts), 153 TP_STRUCT__entry( 154 __field(int, ep_dir) 155 __field(u32, ep_sts) 156 __dynamic_array(char, str, CDNS3_MSG_MAX) 157 ), 158 TP_fast_assign( 159 __entry->ep_dir = priv_dev->selected_ep; 160 __entry->ep_sts = ep_sts; 161 ), 162 TP_printk("%s", cdns3_decode_ep0_irq(__get_str(str), 163 __entry->ep_dir, 164 __entry->ep_sts)) 165 ); 166 167 DEFINE_EVENT(cdns3_log_ep0_irq, cdns3_ep0_irq, 168 TP_PROTO(struct cdns3_device *priv_dev, u32 ep_sts), 169 TP_ARGS(priv_dev, ep_sts) 170 ); 171 172 DECLARE_EVENT_CLASS(cdns3_log_ctrl, 173 TP_PROTO(struct usb_ctrlrequest *ctrl), 174 TP_ARGS(ctrl), 175 TP_STRUCT__entry( 176 __field(u8, bRequestType) 177 __field(u8, bRequest) 178 __field(u16, wValue) 179 __field(u16, wIndex) 180 __field(u16, wLength) 181 __dynamic_array(char, str, CDNS3_MSG_MAX) 182 ), 183 TP_fast_assign( 184 __entry->bRequestType = ctrl->bRequestType; 185 __entry->bRequest = ctrl->bRequest; 186 __entry->wValue = le16_to_cpu(ctrl->wValue); 187 __entry->wIndex = le16_to_cpu(ctrl->wIndex); 188 __entry->wLength = le16_to_cpu(ctrl->wLength); 189 ), 190 TP_printk("%s", usb_decode_ctrl(__get_str(str), CDNS3_MSG_MAX, 191 __entry->bRequestType, 192 __entry->bRequest, __entry->wValue, 193 __entry->wIndex, __entry->wLength) 194 ) 195 ); 196 197 DEFINE_EVENT(cdns3_log_ctrl, cdns3_ctrl_req, 198 TP_PROTO(struct usb_ctrlrequest *ctrl), 199 TP_ARGS(ctrl) 200 ); 201 202 DECLARE_EVENT_CLASS(cdns3_log_request, 203 TP_PROTO(struct cdns3_request *req), 204 TP_ARGS(req), 205 TP_STRUCT__entry( 206 __string(name, req->priv_ep->name) 207 __field(struct cdns3_request *, req) 208 __field(void *, buf) 209 __field(unsigned int, actual) 210 __field(unsigned int, length) 211 __field(int, status) 212 __field(int, zero) 213 __field(int, short_not_ok) 214 __field(int, no_interrupt) 215 __field(int, start_trb) 216 __field(int, end_trb) 217 __field(struct cdns3_trb *, start_trb_addr) 218 __field(int, flags) 219 __field(unsigned int, stream_id) 220 ), 221 TP_fast_assign( 222 __assign_str(name, req->priv_ep->name); 223 __entry->req = req; 224 __entry->buf = req->request.buf; 225 __entry->actual = req->request.actual; 226 __entry->length = req->request.length; 227 __entry->status = req->request.status; 228 __entry->zero = req->request.zero; 229 __entry->short_not_ok = req->request.short_not_ok; 230 __entry->no_interrupt = req->request.no_interrupt; 231 __entry->start_trb = req->start_trb; 232 __entry->end_trb = req->end_trb; 233 __entry->start_trb_addr = req->trb; 234 __entry->flags = req->flags; 235 __entry->stream_id = req->request.stream_id; 236 ), 237 TP_printk("%s: req: %p, req buff %p, length: %u/%u %s%s%s, status: %d," 238 " trb: [start:%d, end:%d: virt addr %pa], flags:%x SID: %u", 239 __get_str(name), __entry->req, __entry->buf, __entry->actual, 240 __entry->length, 241 __entry->zero ? "Z" : "z", 242 __entry->short_not_ok ? "S" : "s", 243 __entry->no_interrupt ? "I" : "i", 244 __entry->status, 245 __entry->start_trb, 246 __entry->end_trb, 247 __entry->start_trb_addr, 248 __entry->flags, 249 __entry->stream_id 250 ) 251 ); 252 253 DEFINE_EVENT(cdns3_log_request, cdns3_alloc_request, 254 TP_PROTO(struct cdns3_request *req), 255 TP_ARGS(req) 256 ); 257 258 DEFINE_EVENT(cdns3_log_request, cdns3_free_request, 259 TP_PROTO(struct cdns3_request *req), 260 TP_ARGS(req) 261 ); 262 263 DEFINE_EVENT(cdns3_log_request, cdns3_ep_queue, 264 TP_PROTO(struct cdns3_request *req), 265 TP_ARGS(req) 266 ); 267 268 DEFINE_EVENT(cdns3_log_request, cdns3_ep_dequeue, 269 TP_PROTO(struct cdns3_request *req), 270 TP_ARGS(req) 271 ); 272 273 DEFINE_EVENT(cdns3_log_request, cdns3_gadget_giveback, 274 TP_PROTO(struct cdns3_request *req), 275 TP_ARGS(req) 276 ); 277 278 TRACE_EVENT(cdns3_ep0_queue, 279 TP_PROTO(struct cdns3_device *dev_priv, struct usb_request *request), 280 TP_ARGS(dev_priv, request), 281 TP_STRUCT__entry( 282 __field(int, dir) 283 __field(int, length) 284 ), 285 TP_fast_assign( 286 __entry->dir = dev_priv->ep0_data_dir; 287 __entry->length = request->length; 288 ), 289 TP_printk("Queue to ep0%s length: %u", __entry->dir ? "in" : "out", 290 __entry->length) 291 ); 292 293 DECLARE_EVENT_CLASS(cdns3_stream_split_transfer_len, 294 TP_PROTO(struct cdns3_request *req), 295 TP_ARGS(req), 296 TP_STRUCT__entry( 297 __string(name, req->priv_ep->name) 298 __field(struct cdns3_request *, req) 299 __field(unsigned int, length) 300 __field(unsigned int, actual) 301 __field(unsigned int, stream_id) 302 ), 303 TP_fast_assign( 304 __assign_str(name, req->priv_ep->name); 305 __entry->req = req; 306 __entry->actual = req->request.length; 307 __entry->length = req->request.actual; 308 __entry->stream_id = req->request.stream_id; 309 ), 310 TP_printk("%s: req: %p,request length: %u actual length: %u SID: %u", 311 __get_str(name), __entry->req, __entry->length, 312 __entry->actual, __entry->stream_id) 313 ); 314 315 DEFINE_EVENT(cdns3_stream_split_transfer_len, cdns3_stream_transfer_split, 316 TP_PROTO(struct cdns3_request *req), 317 TP_ARGS(req) 318 ); 319 320 DEFINE_EVENT(cdns3_stream_split_transfer_len, 321 cdns3_stream_transfer_split_next_part, 322 TP_PROTO(struct cdns3_request *req), 323 TP_ARGS(req) 324 ); 325 326 DECLARE_EVENT_CLASS(cdns3_log_aligned_request, 327 TP_PROTO(struct cdns3_request *priv_req), 328 TP_ARGS(priv_req), 329 TP_STRUCT__entry( 330 __string(name, priv_req->priv_ep->name) 331 __field(struct usb_request *, req) 332 __field(void *, buf) 333 __field(dma_addr_t, dma) 334 __field(void *, aligned_buf) 335 __field(dma_addr_t, aligned_dma) 336 __field(u32, aligned_buf_size) 337 ), 338 TP_fast_assign( 339 __assign_str(name, priv_req->priv_ep->name); 340 __entry->req = &priv_req->request; 341 __entry->buf = priv_req->request.buf; 342 __entry->dma = priv_req->request.dma; 343 __entry->aligned_buf = priv_req->aligned_buf->buf; 344 __entry->aligned_dma = priv_req->aligned_buf->dma; 345 __entry->aligned_buf_size = priv_req->aligned_buf->size; 346 ), 347 TP_printk("%s: req: %p, req buf %p, dma %pad a_buf %p a_dma %pad, size %d", 348 __get_str(name), __entry->req, __entry->buf, &__entry->dma, 349 __entry->aligned_buf, &__entry->aligned_dma, 350 __entry->aligned_buf_size 351 ) 352 ); 353 354 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_free_aligned_request, 355 TP_PROTO(struct cdns3_request *req), 356 TP_ARGS(req) 357 ); 358 359 DEFINE_EVENT(cdns3_log_aligned_request, cdns3_prepare_aligned_request, 360 TP_PROTO(struct cdns3_request *req), 361 TP_ARGS(req) 362 ); 363 364 DECLARE_EVENT_CLASS(cdns3_log_map_request, 365 TP_PROTO(struct cdns3_request *priv_req), 366 TP_ARGS(priv_req), 367 TP_STRUCT__entry( 368 __string(name, priv_req->priv_ep->name) 369 __field(struct usb_request *, req) 370 __field(void *, buf) 371 __field(dma_addr_t, dma) 372 ), 373 TP_fast_assign( 374 __assign_str(name, priv_req->priv_ep->name); 375 __entry->req = &priv_req->request; 376 __entry->buf = priv_req->request.buf; 377 __entry->dma = priv_req->request.dma; 378 ), 379 TP_printk("%s: req: %p, req buf %p, dma %p", 380 __get_str(name), __entry->req, __entry->buf, &__entry->dma 381 ) 382 ); 383 DEFINE_EVENT(cdns3_log_map_request, cdns3_map_request, 384 TP_PROTO(struct cdns3_request *req), 385 TP_ARGS(req) 386 ); 387 DEFINE_EVENT(cdns3_log_map_request, cdns3_mapped_request, 388 TP_PROTO(struct cdns3_request *req), 389 TP_ARGS(req) 390 ); 391 392 DECLARE_EVENT_CLASS(cdns3_log_trb, 393 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb), 394 TP_ARGS(priv_ep, trb), 395 TP_STRUCT__entry( 396 __string(name, priv_ep->name) 397 __field(struct cdns3_trb *, trb) 398 __field(u32, buffer) 399 __field(u32, length) 400 __field(u32, control) 401 __field(u32, type) 402 __field(unsigned int, last_stream_id) 403 ), 404 TP_fast_assign( 405 __assign_str(name, priv_ep->name); 406 __entry->trb = trb; 407 __entry->buffer = le32_to_cpu(trb->buffer); 408 __entry->length = le32_to_cpu(trb->length); 409 __entry->control = le32_to_cpu(trb->control); 410 __entry->type = usb_endpoint_type(priv_ep->endpoint.desc); 411 __entry->last_stream_id = priv_ep->last_stream_id; 412 ), 413 TP_printk("%s: trb %p, dma buf: 0x%08x, size: %ld, burst: %d ctrl: 0x%08x (%s%s%s%s%s%s%s) SID:%lu LAST_SID:%u", 414 __get_str(name), __entry->trb, __entry->buffer, 415 TRB_LEN(__entry->length), 416 (u8)TRB_BURST_LEN_GET(__entry->length), 417 __entry->control, 418 __entry->control & TRB_CYCLE ? "C=1, " : "C=0, ", 419 __entry->control & TRB_TOGGLE ? "T=1, " : "T=0, ", 420 __entry->control & TRB_ISP ? "ISP, " : "", 421 __entry->control & TRB_FIFO_MODE ? "FIFO, " : "", 422 __entry->control & TRB_CHAIN ? "CHAIN, " : "", 423 __entry->control & TRB_IOC ? "IOC, " : "", 424 TRB_FIELD_TO_TYPE(__entry->control) == TRB_NORMAL ? "Normal" : "LINK", 425 TRB_FIELD_TO_STREAMID(__entry->control), 426 __entry->last_stream_id 427 ) 428 ); 429 430 DEFINE_EVENT(cdns3_log_trb, cdns3_prepare_trb, 431 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb), 432 TP_ARGS(priv_ep, trb) 433 ); 434 435 DEFINE_EVENT(cdns3_log_trb, cdns3_complete_trb, 436 TP_PROTO(struct cdns3_endpoint *priv_ep, struct cdns3_trb *trb), 437 TP_ARGS(priv_ep, trb) 438 ); 439 440 DECLARE_EVENT_CLASS(cdns3_log_ring, 441 TP_PROTO(struct cdns3_endpoint *priv_ep), 442 TP_ARGS(priv_ep), 443 TP_STRUCT__entry( 444 __dynamic_array(u8, ring, TRB_RING_SIZE) 445 __dynamic_array(u8, priv_ep, sizeof(struct cdns3_endpoint)) 446 __dynamic_array(char, buffer, 447 (TRBS_PER_SEGMENT * 65) + CDNS3_MSG_MAX) 448 ), 449 TP_fast_assign( 450 memcpy(__get_dynamic_array(priv_ep), priv_ep, 451 sizeof(struct cdns3_endpoint)); 452 memcpy(__get_dynamic_array(ring), priv_ep->trb_pool, 453 TRB_RING_SIZE); 454 ), 455 456 TP_printk("%s", 457 cdns3_dbg_ring((struct cdns3_endpoint *)__get_str(priv_ep), 458 (struct cdns3_trb *)__get_str(ring), 459 __get_str(buffer))) 460 ); 461 462 DEFINE_EVENT(cdns3_log_ring, cdns3_ring, 463 TP_PROTO(struct cdns3_endpoint *priv_ep), 464 TP_ARGS(priv_ep) 465 ); 466 467 DECLARE_EVENT_CLASS(cdns3_log_ep, 468 TP_PROTO(struct cdns3_endpoint *priv_ep), 469 TP_ARGS(priv_ep), 470 TP_STRUCT__entry( 471 __string(name, priv_ep->name) 472 __field(unsigned int, maxpacket) 473 __field(unsigned int, maxpacket_limit) 474 __field(unsigned int, max_streams) 475 __field(unsigned int, use_streams) 476 __field(unsigned int, maxburst) 477 __field(unsigned int, flags) 478 __field(unsigned int, dir) 479 __field(u8, enqueue) 480 __field(u8, dequeue) 481 ), 482 TP_fast_assign( 483 __assign_str(name, priv_ep->name); 484 __entry->maxpacket = priv_ep->endpoint.maxpacket; 485 __entry->maxpacket_limit = priv_ep->endpoint.maxpacket_limit; 486 __entry->max_streams = priv_ep->endpoint.max_streams; 487 __entry->use_streams = priv_ep->use_streams; 488 __entry->maxburst = priv_ep->endpoint.maxburst; 489 __entry->flags = priv_ep->flags; 490 __entry->dir = priv_ep->dir; 491 __entry->enqueue = priv_ep->enqueue; 492 __entry->dequeue = priv_ep->dequeue; 493 ), 494 TP_printk("%s: mps: %d/%d. streams: %d, stream enable: %d, burst: %d, " 495 "enq idx: %d, deq idx: %d, flags %s%s%s%s%s%s%s%s, dir: %s", 496 __get_str(name), __entry->maxpacket, 497 __entry->maxpacket_limit, __entry->max_streams, 498 __entry->use_streams, 499 __entry->maxburst, __entry->enqueue, 500 __entry->dequeue, 501 __entry->flags & EP_ENABLED ? "EN | " : "", 502 __entry->flags & EP_STALLED ? "STALLED | " : "", 503 __entry->flags & EP_WEDGE ? "WEDGE | " : "", 504 __entry->flags & EP_TRANSFER_STARTED ? "STARTED | " : "", 505 __entry->flags & EP_UPDATE_EP_TRBADDR ? "UPD TRB | " : "", 506 __entry->flags & EP_PENDING_REQUEST ? "REQ PEN | " : "", 507 __entry->flags & EP_RING_FULL ? "RING FULL |" : "", 508 __entry->flags & EP_CLAIMED ? "CLAIMED " : "", 509 __entry->dir ? "IN" : "OUT" 510 ) 511 ); 512 513 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_enable, 514 TP_PROTO(struct cdns3_endpoint *priv_ep), 515 TP_ARGS(priv_ep) 516 ); 517 518 DEFINE_EVENT(cdns3_log_ep, cdns3_gadget_ep_disable, 519 TP_PROTO(struct cdns3_endpoint *priv_ep), 520 TP_ARGS(priv_ep) 521 ); 522 523 DECLARE_EVENT_CLASS(cdns3_log_request_handled, 524 TP_PROTO(struct cdns3_request *priv_req, int current_index, 525 int handled), 526 TP_ARGS(priv_req, current_index, handled), 527 TP_STRUCT__entry( 528 __field(struct cdns3_request *, priv_req) 529 __field(unsigned int, dma_position) 530 __field(unsigned int, handled) 531 __field(unsigned int, dequeue_idx) 532 __field(unsigned int, enqueue_idx) 533 __field(unsigned int, start_trb) 534 __field(unsigned int, end_trb) 535 ), 536 TP_fast_assign( 537 __entry->priv_req = priv_req; 538 __entry->dma_position = current_index; 539 __entry->handled = handled; 540 __entry->dequeue_idx = priv_req->priv_ep->dequeue; 541 __entry->enqueue_idx = priv_req->priv_ep->enqueue; 542 __entry->start_trb = priv_req->start_trb; 543 __entry->end_trb = priv_req->end_trb; 544 ), 545 TP_printk("Req: %p %s, DMA pos: %d, ep deq: %d, ep enq: %d," 546 " start trb: %d, end trb: %d", 547 __entry->priv_req, 548 __entry->handled ? "handled" : "not handled", 549 __entry->dma_position, __entry->dequeue_idx, 550 __entry->enqueue_idx, __entry->start_trb, 551 __entry->end_trb 552 ) 553 ); 554 555 DEFINE_EVENT(cdns3_log_request_handled, cdns3_request_handled, 556 TP_PROTO(struct cdns3_request *priv_req, int current_index, 557 int handled), 558 TP_ARGS(priv_req, current_index, handled) 559 ); 560 #endif /* __LINUX_CDNS3_TRACE */ 561 562 /* this part must be outside header guard */ 563 564 #undef TRACE_INCLUDE_PATH 565 #define TRACE_INCLUDE_PATH . 566 567 #undef TRACE_INCLUDE_FILE 568 #define TRACE_INCLUDE_FILE cdns3-trace 569 570 #include <trace/define_trace.h> 571