static void emit_user_trace64(struct perf_record *pr, struct perfconv_context *cctx) { struct proftype_user_trace64 *rec = (struct proftype_user_trace64 *) pr->data; size_t size = sizeof(struct perf_record_sample) + (rec->num_traces - 1) * sizeof(uint64_t); struct perf_record_sample *xrec = xzmalloc(size); xrec->header.type = PERF_RECORD_SAMPLE; xrec->header.misc = PERF_RECORD_MISC_USER; xrec->header.size = size; xrec->ip = rec->trace[0]; xrec->pid = xrec->tid = rec->pid; xrec->time = rec->tstamp; xrec->addr = rec->trace[0]; xrec->id = perfconv_get_event_id(cctx, rec->info); xrec->cpu = rec->cpu; xrec->nr = rec->num_traces - 1; memcpy(xrec->ips, rec->trace + 1, (rec->num_traces - 1) * sizeof(uint64_t)); mem_file_write(&cctx->data, xrec, size, 0); free(xrec); }
/**@brief Function for processing ANTFS upload data event. * * @param[in] p_event The event extracted from the queue to be processed. */ static void event_upload_data_handle(const antfs_event_return_t * p_event) { // This example does not interact with a file system, and it does not account for latency for // reading or writing a file from EEPROM/flash. Buffering and other strategies might be useful // to handle a received upload, while maintaining the burst timing. if (m_upload_success && (m_file_index == p_event->file_index)) { // Offset requested for upload. const uint32_t offset = p_event->offset; // Size of current block of data. const uint32_t data_bytes = p_event->bytes; // Write data to file. if (!mem_file_write(m_file_index, offset, p_event->data, data_bytes)) { // Failed to write the data to system; do not attempt to write any more data after this, // and set upload response as FAIL. m_upload_success = false; printf("Failed to write file to system\n"); printf("Current offset %u, ", offset); } else { // Data was written successfully: // - update offset // - update current CRC. m_file_offset = offset + data_bytes; m_current_crc = p_event->crc; } } }
static int mem_file_putchar(MXFFileSysData *sysData, int c) { unsigned char data = (unsigned char)c; if (mem_file_write(sysData, &data, 1) == 0) return EOF; return c; }
static void add_attribute(struct mem_file *amf, struct mem_file *mmf, const struct perf_event_attr *attr, const uint64_t *ids, size_t nids) { struct perf_file_section *psids; struct perf_file_section sids; mem_file_write(amf, attr, sizeof(*attr), 0); sids.offset = mmf->size; sids.size = nids * sizeof(uint64_t); mem_file_write(mmf, ids, nids * sizeof(uint64_t), 0); psids = mem_file_write(amf, &sids, sizeof(sids), MBWR_SOLID); mem_file_add_reloc(amf, &psids->offset); }
static void add_event_type(struct mem_file *mf, uint64_t id, const char *name) { struct perf_trace_event_type evt; ZERO_DATA(evt); evt.event_id = id; strncpy(evt.name, name, sizeof(evt.name)); evt.name[sizeof(evt.name) - 1] = 0; mem_file_write(mf, &evt, sizeof(evt), 0); }
static void headers_write(struct perf_headers *hdrs, struct perf_header *ph, struct mem_file *mf) { size_t i; for (i = 0; i < HEADER_FEAT_BITS; i++) { struct mem_block *mb = hdrs->headers[i]; if (mb) { mem_file_write(mf, mb->base, mb->wptr - mb->base, 0); set_bitno(ph->adds_features, i); } } }
static void emit_comm(uint32_t pid, const char *comm, struct perfconv_context *cctx) { size_t size = sizeof(struct perf_record_comm) + strlen(comm) + 1; struct perf_record_comm *xrec = xzmalloc(size); xrec->header.type = PERF_RECORD_COMM; xrec->header.misc = PERF_RECORD_MISC_USER; xrec->header.size = size; xrec->pid = xrec->tid = pid; strcpy(xrec->comm, comm); mem_file_write(&cctx->data, xrec, size, 0); free(xrec); }
static void emit_pid_mmap64(struct perf_record *pr, struct perfconv_context *cctx) { struct proftype_pid_mmap64 *rec = (struct proftype_pid_mmap64 *) pr->data; size_t size = sizeof(struct perf_record_mmap) + strlen(rec->path) + 1; struct perf_record_mmap *xrec = xzmalloc(size); xrec->header.type = PERF_RECORD_MMAP; xrec->header.misc = PERF_RECORD_MISC_USER; xrec->header.size = size; xrec->pid = xrec->tid = rec->pid; xrec->addr = rec->addr; xrec->len = rec->size; xrec->pgoff = rec->offset; strcpy(xrec->filename, rec->path); mem_file_write(&cctx->data, xrec, size, 0); free(xrec); }
static void emit_static_mmaps(struct perfconv_context *cctx) { struct static_mmap64 *mm; for (mm = cctx->static_mmaps; mm; mm = mm->next) { size_t size = sizeof(struct perf_record_mmap) + strlen(mm->path) + 1; struct perf_record_mmap *xrec = xzmalloc(size); xrec->header.type = PERF_RECORD_MMAP; xrec->header.misc = PERF_RECORD_MISC_USER; xrec->header.size = size; xrec->pid = xrec->tid = mm->pid; xrec->addr = mm->addr; xrec->len = mm->size; xrec->pgoff = mm->offset; strcpy(xrec->filename, mm->path); mem_file_write(&cctx->data, xrec, size, 0); free(xrec); } }