/* Initialize local data */ static void dump_init0(void) { dump_filep = NULL; dump_open = dump_type; switch (dump_open) { case DT_NONE: case DT_CMN_ERR: break; case DT_STDERR: dump_filep = stderr; break; case DT_FILE: dump_filep = fopen(dump_filename, "a"); if (dump_filep == NULL) { dump_open = DT_STDERR; dump_filep = stderr; dump_printf(EL_WARN, "Cannot open log file %s", dump_filename); } break; case DT_SYSLOG: openlog("lane", LOG_PID | LOG_CONS, LOG_DAEMON); break; case DT_CONSOLE: dump_filep = fopen(dump_console, "w"); if (dump_filep == NULL) { dump_open = DT_STDERR; dump_filep = stderr; dump_printf(EL_WARN, "Cannot open console log"); } break; } dump_printf(EL_DEBUG, "Log opened"); }
void trace_event(event_t *event) { unsigned char *raw_event = (void *)event; const char *color = PERF_COLOR_BLUE; int i, j; if (!dump_trace) return; dump_printf("."); dump_printf_color("\n. ... raw event: size %d bytes\n", color, event->header.size); for (i = 0; i < event->header.size; i++) { if ((i & 15) == 0) { dump_printf("."); dump_printf_color(" %04x: ", color, i); } dump_printf_color(" %02x", color, raw_event[i]); if (((i & 15) == 15) || i == event->header.size-1) { dump_printf_color(" ", color); for (j = 0; j < 15-(i & 15); j++) dump_printf_color(" ", color); for (j = i & ~15; j <= i; j++) { dump_printf_color("%c", color, isprint(raw_event[j]) ? raw_event[j] : '.'); } dump_printf_color("\n", color); } } dump_printf(".\n"); }
void CommonTimeServer::PacketRTTLog::dumpLog(int fd, const CommonClock& cclk) { const size_t SIZE = 256; char buffer[SIZE]; uint32_t avail = !logFull ? wrPtr : RTT_LOG_SIZE; if (!avail) return; dump_printf("\nPacket Log (%d entries)\n", avail); uint32_t ndx = 0; uint32_t i = logFull ? wrPtr : 0; do { if (rxTimes[i]) { int64_t delta = rxTimes[i] - txTimes[i]; int64_t deltaUsec = cclk.localDurationToCommonDuration(delta); dump_printf("pkt[%2d] : localTX %12" PRId64 " localRX %12" PRId64 " " "(%.3f msec RTT)\n", ndx, txTimes[i], rxTimes[i], static_cast<float>(deltaUsec) / 1000.0); } else { dump_printf("pkt[%2d] : localTX %12" PRId64 " localRX never\n", ndx, txTimes[i]); } i = (i + 1) % RTT_LOG_SIZE; ndx++; } while (i != wrPtr); }
static unsigned int increase_alignment (void) { struct varpool_node *vnode; /* Increase the alignment of all global arrays for vectorization. */ FOR_EACH_DEFINED_VARIABLE (vnode) { tree vectype, decl = vnode->symbol.decl; tree t; unsigned int alignment; t = TREE_TYPE(decl); if (TREE_CODE (t) != ARRAY_TYPE) continue; vectype = get_vectype_for_scalar_type (strip_array_types (t)); if (!vectype) continue; alignment = TYPE_ALIGN (vectype); if (DECL_ALIGN (decl) >= alignment) continue; if (vect_can_force_dr_alignment_p (decl, alignment)) { DECL_ALIGN (decl) = TYPE_ALIGN (vectype); DECL_USER_ALIGN (decl) = 1; dump_printf (MSG_NOTE, "Increasing alignment of decl: "); dump_generic_expr (MSG_NOTE, TDF_SLIM, decl); dump_printf (MSG_NOTE, "\n"); } } return 0; }
void xml_dump(void) { int i; for (i = 0; i < xml_numAttr; i++) { dump_printf("Attribute #%d:\n", i + 1); dump_printf("\tFilename: %s\n", xattr[i].filename); dump_printf("\tNode: %s\n", xattr[i].node); dump_printf("\tName: %s\n", xattr[i].name); dump_printf("\tValue: %s\n", xattr[i].value); } }
int event__process_comm(event_t *self) { struct thread *thread = threads__findnew(self->comm.pid); dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid); if (thread == NULL || thread__set_comm(thread, self->comm.comm)) { dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); return -1; } return 0; }
int event__process_comm(event_t *self, struct perf_session *session) { struct thread *thread = perf_session__findnew(session, self->comm.tid); dump_printf(": %s:%d\n", self->comm.comm, self->comm.tid); if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) { dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); return -1; } return 0; }
void dump_vars(const Unit_t *unit) { const VarList_t *tmp; LaneDestList_t *ltmp; Debug_unit(&load_unit, "Dumping variables"); for (tmp = varlist; tmp != NULL; tmp = tmp->next) { assert(tmp->var != NULL); assert(tmp->var->unit != NULL); assert(tmp->var->unit->name != NULL); assert(tmp->var->name != NULL); if (unit == NULL || strcmp(unit->name, tmp->var->unit->name) == 0) { switch (tmp->var->type) { case VT_INT: Debug_unit(&load_unit, "%s/%s = %d", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.intval); break; case VT_STR: Debug_unit(&load_unit, "%s/%s = \"%s\"", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.strval); break; case VT_BOOL: Debug_unit(&load_unit, "%s/%s = %s", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.boolval == BL_TRUE? "True" : "False" ); break; case VT_ADDR: Debug_unit(&load_unit, "%s/%s =", tmp->var->unit->name, tmp->var->name); dump_atmaddr(tmp->var->val_u.addrval); break; case VT_PVC: Debug_unit(&load_unit,"%s/%s = %d,%d,%d with lecid:%d ", tmp->var->unit->name, tmp->var->name, tmp->var->val_u.init->pvc->port, tmp->var->val_u.init->pvc->vpi, tmp->var->val_u.init->pvc->vci, tmp->var->val_u.init->lecid); dump_atmaddr(tmp->var->val_u.init->address); ltmp = tmp->var->val_u.init->destinations; while(ltmp) { dump_printf(EL_CONT,"\t"); dump_addr(ltmp->addr); dump_printf(EL_CONT,"\n"); ltmp = ltmp->next; } break; } } } }
int main( int argc, char *argv) { /* SET LOG LEVEL [PROCESS NAME] [ARG] ARG - 0, LOG ARG - 1, LOG ERROR ARG - 2, LOG ERROR DEBUG DEFAULT - 2, LOG ERROR DEBUG */ if ( argc > 1) { gi_LogLevel = atoi(argv[1]); } else { gi_LogLevel = 2; } log_printf(LOG_ARG,">>>>>>>>>>>>>>>>>>>>>>>>>"); log_printf(LOG_ARG,"TEST START!!"); log_printf(LOG_ARG,">>>>>>>>>>>>>>>>>>>>>>>>>"); db_Conn(); char lc_temp[1100]; memset(lc_temp,0x30,sizeof(lc_temp)); dump_printf(lc_temp,sizeof(lc_temp)); return 0; }
int event__preprocess_sample(const event_t *self, struct perf_session *session, struct addr_location *al, symbol_filter_t filter) { u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; struct thread *thread = perf_session__findnew(session, self->ip.pid); if (thread == NULL) return -1; if (symbol_conf.comm_list && !strlist__has_entry(symbol_conf.comm_list, thread->comm)) goto out_filtered; dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid); thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION, self->ip.ip, al, filter); dump_printf(" ...... dso: %s\n", al->map ? al->map->dso->long_name : al->level == 'H' ? "[hypervisor]" : "<not found>"); /* * We have to do this here as we may have a dso with no symbol hit that * has a name longer than the ones with symbols sampled. */ if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated) dso__calc_col_width(al->map->dso); if (symbol_conf.dso_list && (!al->map || !al->map->dso || !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) || (al->map->dso->short_name != al->map->dso->long_name && strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name))))) goto out_filtered; if (symbol_conf.sym_list && al->sym && !strlist__has_entry(symbol_conf.sym_list, al->sym->name)) goto out_filtered; al->filtered = false; return 0; out_filtered: al->filtered = true; return 0; }
int event__preprocess_sample(const event_t *self, struct addr_location *al, symbol_filter_t filter) { u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; struct thread *thread = threads__findnew(self->ip.pid); if (thread == NULL) return -1; dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid); thread__find_addr_location(thread, cpumode, MAP__FUNCTION, self->ip.ip, al, filter); dump_printf(" ...... dso: %s\n", al->map ? al->map->dso->long_name : al->level == 'H' ? "[hypervisor]" : "<not found>"); return 0; }
static void conn_main(void) { const AtmAddr_t *addr; int main_conn; const char *str; int i; addr = get_var_addr(&conn_unit, "S1"); if (addr == NULL) { dump_printf(EL_ERROR, "S1 (LES Address) must be specified"); event_put(&conn_unit, CE_EXIT, NULL); } else { str = get_var_str(&conn_unit,"S2"); if (str == NULL) { set_var_str(&conn_unit, "S2", S2_default); } i = get_var_int(&conn_unit,"S3"); if (i == 0) { set_var_int(&conn_unit,"S3", S3_default); } i = get_var_int(&conn_unit,"S4"); if (i == 0) { set_var_int(&conn_unit,"S4", S4_default); } i = get_var_int(&conn_unit,"S5"); if (i == 0) { set_var_int(&conn_unit,"S5", S5_default); } addr = get_var_addr(&conn_unit, "S6"); if (addr == NULL) { dump_printf(EL_ERROR, "S6 (BUS Address) must be specified"); event_put(&conn_unit, CE_EXIT, NULL); } else { main_conn = atm_create_socket(CONTROL_DIRECT, get_var_addr(&conn_unit, "S1")); if (main_conn >= 0) { (void)conn_add(CT_MAIN, main_conn,0); } } } }
static void dump_atmtext(const AtmAddr_t addr) { int i; char buffer[ATM_ADDR_LEN*3+2]; for (i=0;i<ATM_ADDR_LEN;i++) { sprintf(&buffer[i*2], "%2.2x ", 0xff&(unsigned char)addr.addr[i]); } dump_printf(EL_CONT, "%s", buffer); }
int event__process_mmap(event_t *self) { struct thread *thread = threads__findnew(self->mmap.pid); struct map *map = map__new(&self->mmap, MAP__FUNCTION, event__cwd, event__cwdlen); dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n", self->mmap.pid, self->mmap.tid, (void *)(long)self->mmap.start, (void *)(long)self->mmap.len, (void *)(long)self->mmap.pgoff, self->mmap.filename); if (thread == NULL || map == NULL) dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n"); else thread__insert_map(thread, map); return 0; }
static void init(const ctr_list_t *ctrs, const dumper_config_t *_conf) { attr = &ctrs->head->attr; const uint64_t sample_type = attr->sample_type; conf = *_conf; sample_no = 0; dump_printf("#"); if (sample_type & PERF_SAMPLE_TIME) dump_printf("time"); else dump_printf("number"); no_counters = 0; for (ctr_t *ctr = ctrs->head; ctr; ctr = ctr->next) { no_counters++; switch (ctr->attr.type) { case PERF_TYPE_HARDWARE: dump_printf(",hw:%" PRIu64, (uint64_t)ctr->attr.config); break; case PERF_TYPE_SOFTWARE: dump_printf(",sw:%" PRIu64, (uint64_t)ctr->attr.config); break; case PERF_TYPE_HW_CACHE: dump_printf(",hwc:0x%" PRIx64, (uint64_t)ctr->attr.config); break; case PERF_TYPE_RAW: dump_printf(",0x%" PRIx64, (uint64_t)ctr->attr.config); break; default: dump_printf(",%" PRIu32 ":%" PRIu64, (uint32_t)ctr->attr.type, (uint64_t)ctr->attr.config); break; } } if (conf.delta) { EXPECT(old_values = malloc(sizeof(*old_values) * no_counters)); memset(old_values, 0, sizeof(*old_values) * no_counters); } dump_printf("\n"); }
int event__process_task(event_t *self, struct perf_session *session) { struct thread *thread = perf_session__findnew(session, self->fork.tid); struct thread *parent = perf_session__findnew(session, self->fork.ptid); dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid, self->fork.ppid, self->fork.ptid); if (self->header.type == PERF_RECORD_EXIT) { perf_session__remove_thread(session, thread); return 0; } if (thread == NULL || parent == NULL || thread__fork(thread, parent) < 0) { dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n"); return -1; } return 0; }
struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe, struct perf_tool *tool) { struct perf_session *self; struct stat st; size_t len; if (!filename || !strlen(filename)) { if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) filename = "-"; else filename = "perf.data"; } len = strlen(filename); self = zalloc(sizeof(*self) + len); if (self == NULL) goto out; memcpy(self->filename, filename, len); self->repipe = repipe; INIT_LIST_HEAD(&self->ordered_samples.samples); INIT_LIST_HEAD(&self->ordered_samples.sample_cache); INIT_LIST_HEAD(&self->ordered_samples.to_free); machines__init(&self->machines); if (mode == O_RDONLY) { if (perf_session__open(self, force) < 0) goto out_delete; perf_session__set_id_hdr_size(self); } else if (mode == O_WRONLY) { /* * In O_RDONLY mode this will be performed when reading the * kernel MMAP event, in perf_event__process_mmap(). */ if (perf_session__create_kernel_maps(self) < 0) goto out_delete; } if (tool && tool->ordering_requires_timestamps && tool->ordered_samples && !perf_evlist__sample_id_all(self->evlist)) { dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); tool->ordered_samples = false; } out: return self; out_delete: perf_session__delete(self); return NULL; }
static int process_comm_event(event_t *event, unsigned long offset, unsigned long head) { struct thread *thread; thread = threads__findnew(event->comm.pid, &threads, &last_match); dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n", (void *)(offset + head), (void *)(long)(event->header.size), event->comm.comm, event->comm.pid); if (thread == NULL || thread__set_comm(thread, event->comm.comm)) { dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); return -1; } total_comm++; return 0; }
status_t CommonTimeServer::dumpConfigInterface(int fd, const Vector<String16>& /* args */) { AutoMutex _lock(&mLock); const size_t SIZE = 256; char buffer[SIZE]; if (checkCallingPermission(String16("android.permission.DUMP")) == false) { snprintf(buffer, SIZE, "Permission Denial: " "can't dump CommonTimeConfigService from pid=%d, uid=%d\n", IPCThreadState::self()->getCallingPid(), IPCThreadState::self()->getCallingUid()); write(fd, buffer, strlen(buffer)); } else { char meStr[64]; sockaddrToString(mMasterElectionEP, true, meStr, sizeof(meStr)); dump_printf("Common Time Config Service Status\n" "Bound Interface : %s\n", mBindIfaceValid ? mBindIface.string() : "<unbound>"); dump_printf("Master Election Endpoint : %s\n", meStr); dump_printf("Master Election Group ID : %016" PRIu64 "\n", mSyncGroupID); dump_printf("Master Announce Interval : %d mSec\n", mMasterAnnounceIntervalMs); dump_printf("Client Sync Interval : %d mSec\n", mSyncRequestIntervalMs); dump_printf("Panic Threshold : %d uSec\n", mPanicThresholdUsec); dump_printf("Base ME Prio : 0x%02x\n", static_cast<uint32_t>(mMasterPriority)); dump_printf("Effective ME Prio : 0x%02x\n", static_cast<uint32_t>(effectivePriority())); dump_printf("Auto Disable Allowed : %s\n", mAutoDisable ? "yes" : "no"); dump_printf("Auto Disable Engaged : %s\n", shouldAutoDisable() ? "yes" : "no"); } return NO_ERROR; }
void disp_sockaddr(struct sockaddr_atmsvc *addr, struct atm_blli *blli) { int i; dump_printf(EL_DEBUG,"Socket_address"); dump_printf(EL_CONT, "Sas_family:%d\n\tAddress:",addr->sas_family); for(i=0;i<20;i++) { dump_printf(EL_CONT,"%2.2x ",addr->sas_addr.prv[i]); } dump_printf(EL_CONT,"\nBlli:\n\t"); dump_printf(EL_CONT,"l2_proto:%d\n\t",blli->l2_proto); dump_printf(EL_CONT,"l3_proto:%d\n\t\t",blli->l3_proto); dump_printf(EL_CONT,"ipi:%x\tsnap:",blli->l3.tr9577.ipi); for(i=0;i<5;i++) { dump_printf(EL_CONT,"%2.2x ",blli->l3.tr9577.snap[i]); } dump_printf(EL_CONT,"\n"); }
struct perf_session *perf_session__new(struct perf_data_file *file, bool repipe, struct perf_tool *tool) { struct perf_session *session = zalloc(sizeof(*session)); if (!session) goto out; session->repipe = repipe; INIT_LIST_HEAD(&session->ordered_samples.samples); INIT_LIST_HEAD(&session->ordered_samples.sample_cache); INIT_LIST_HEAD(&session->ordered_samples.to_free); machines__init(&session->machines); if (file) { if (perf_data_file__open(file)) goto out_delete; session->file = file; if (perf_data_file__is_read(file)) { if (perf_session__open(session) < 0) goto out_close; perf_session__set_id_hdr_size(session); } } if (!file || perf_data_file__is_write(file)) { /* * In O_RDONLY mode this will be performed when reading the * kernel MMAP event, in perf_event__process_mmap(). */ if (perf_session__create_kernel_maps(session) < 0) goto out_delete; } if (tool && tool->ordering_requires_timestamps && tool->ordered_samples && !perf_evlist__sample_id_all(session->evlist)) { dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); tool->ordered_samples = false; } return session; out_close: perf_data_file__close(file); out_delete: perf_session__delete(session); out: return NULL; }
int event__process_mmap(event_t *self, struct perf_session *session) { struct machine *machine; struct thread *thread; struct map *map; u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; int ret = 0; dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n", self->mmap.pid, self->mmap.tid, self->mmap.start, self->mmap.len, self->mmap.pgoff, self->mmap.filename); if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || cpumode == PERF_RECORD_MISC_KERNEL) { ret = event__process_kernel_mmap(self, session); if (ret < 0) goto out_problem; return 0; } machine = perf_session__find_host_machine(session); if (machine == NULL) goto out_problem; thread = perf_session__findnew(session, self->mmap.pid); map = map__new(&machine->user_dsos, self->mmap.start, self->mmap.len, self->mmap.pgoff, self->mmap.pid, self->mmap.filename, MAP__FUNCTION, session->cwd, session->cwdlen); if (thread == NULL || map == NULL) goto out_problem; thread__insert_map(thread, map); return 0; out_problem: dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n"); return 0; }
/* Dumping functions, LANE address */ void dump_addr(const LaneDestination_t *addr) { assert(addr != NULL); switch (ntohs(addr->tag)) { case LANE_DEST_NP: dump_printf(EL_CONT, "Not present"); break; case LANE_DEST_MAC: dump_printf(EL_CONT, "MAC addr %2.2x.%2.2x.%2.2x.%2.2x.%2.2x.%2.2x", addr->a_r.mac_address[0],addr->a_r.mac_address[1], addr->a_r.mac_address[2],addr->a_r.mac_address[3], addr->a_r.mac_address[4],addr->a_r.mac_address[5] ); break; case LANE_DEST_RD: dump_printf(EL_CONT, "Route Designator %4.4x", addr->a_r.route.designator); break; } }
/* Release allocated memory, close files etc. */ static void dump_release(void) { int flush_ret; Debug_unit(&dump_unit, "Releasing unit"); dump_printf(EL_DEBUG, "Closing log file"); switch (dump_open) { case DT_NONE: case DT_CMN_ERR: break; case DT_STDERR: flush_ret = fflush(stderr); assert(flush_ret == 0); break; case DT_FILE: if (fclose(dump_filep) != 0) { dump_open = DT_STDERR; dump_filep = stderr; dump_printf(EL_WARN, "Cannot close log file %s", dump_filename); } break; case DT_SYSLOG: closelog(); break; case DT_CONSOLE: if (fclose(dump_filep) != 0) { dump_open = DT_STDERR; dump_filep = stderr; dump_printf(EL_WARN, "Cannot close console log"); } break; } dump_filep = NULL; dump_open = DT_NONE; }
/* Dumping functions, ATM address */ void dump_atmaddr(const AtmAddr_t *addr) { int i; char buffer[ATM_ADDR_LEN*3+2]; assert(addr != 0); for (i = 0; i<ATM_ADDR_LEN; i++){ sprintf(&buffer[i*2], "%2.2x ", 0xff&(unsigned char)addr->addr[i]); } dump_printf(EL_DEBUG, "%s", buffer); }
int event__process_task(event_t *self) { struct thread *thread = threads__findnew(self->fork.pid); struct thread *parent = threads__findnew(self->fork.ppid); dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid, self->fork.ppid, self->fork.ptid); /* * A thread clone will have the same PID for both parent and child. */ if (thread == parent) return 0; if (self->header.type == PERF_RECORD_EXIT) return 0; if (thread == NULL || parent == NULL || thread__fork(thread, parent) < 0) { dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n"); return -1; } return 0; }
static int register_req(Conn_t *conn) { Reg_t *tmp; Lecdb_t *ltmp; Debug_unit(&conn_unit, "Register_req called"); dump_conn(conn); assert(control_packet != NULL); /* If trying to register a multicast or broadcast address, reject */ if (is_multicast(&control_packet->source)) { send_register_response(conn->sfd, control_packet, LE_STATUS_BAD_DEST, 1); return 1; } /* Check lecid */ ltmp = leciddb_find(control_packet->lecid); if (!ltmp) { send_register_response(conn->sfd, control_packet, LE_STATUS_BAD_LECID, 1); return 1; } tmp = regdb_find_mac(control_packet->source); if (tmp == NULL) { /* Unregistered MAC, registering... */ dump_addr(&control_packet->source); dump_printf(EL_CONT,"\n"); regdb_add(control_packet->source_addr, control_packet->source); send_register_response(conn->sfd, control_packet, LE_STATUS_SUCCESS, 1); } else { if (memcmp(&tmp->atm_address,&control_packet->source_addr, sizeof(AtmAddr_t)) != 0) { Debug_unit(&conn_unit, "MAC Address is bound to another ATM address"); send_register_response(conn->sfd, control_packet, LE_STATUS_DUPLICATE_REG, 1); } else { Debug_unit(&conn_unit,"Duplicate registeration"); send_register_response(conn->sfd, control_packet, LE_STATUS_SUCCESS, 1); } } return 1; }
void dump_expr_if(const expr *e, dump *ctx) { dump_desc_expr(ctx, "conditional", e); dump_inc(ctx); dump_expr(e->expr, ctx); if(e->lhs) dump_expr(e->lhs, ctx); else dump_printf(ctx, "?: lhs\n"); dump_expr(e->rhs, ctx); dump_dec(ctx); }
static int arp_find(Conn_t *conn) { Reg_t *tmp; Lecdb_t *ltmp; Debug_unit(&conn_unit, "Arp_find called"); dump_conn(conn); Debug_unit(&conn_unit,"Arping for:"); dump_addr(&control_packet->target); dump_printf(EL_CONT,"\n"); /* If requested multicast /broadcast address, respond with BUS address */ if (is_multicast(&control_packet->target)) { tmp = mem_alloc(&conn_unit, sizeof(Reg_t)); memcpy(&tmp->atm_address, get_var_addr(&conn_unit, "S6"), sizeof(AtmAddr_t)); Debug_unit(&conn_unit,"Arp for multicast address"); send_arp_response(conn->sfd, control_packet, LE_STATUS_SUCCESS, tmp); return 1; } /* Check lecid */ ltmp = leciddb_find(control_packet->lecid); if (!ltmp) { send_arp_response(conn->sfd, control_packet, LE_STATUS_BAD_LECID, NULL); return 1; } tmp = regdb_find_mac(control_packet->target); if (tmp) { Debug_unit(&conn_unit,"Address in databases"); /* Send response */ send_arp_response(conn->sfd, control_packet, LE_STATUS_SUCCESS, tmp); return 1; } forward_arp_request(control_packet, proxylist); return 1; }
static int process_sample_event(event_t *event, struct perf_session *session) { struct addr_location al; dump_printf("(IP, %d): %d: %p\n", event->header.misc, event->ip.pid, (void *)(long)event->ip.ip); if (event__preprocess_sample(event, session, &al, NULL) < 0) { fprintf(stderr, "problem processing %d event, skipping it.\n", event->header.type); return -1; } if (!al.filtered && perf_session__add_hist_entry(session, &al, 1)) { fprintf(stderr, "problem incrementing symbol count, " "skipping event\n"); return -1; } return 0; }