/* Initialize hardware counters and get hardware information, this
* routine is called when the PAPI process is initialized
* (IE PAPI_library_init)
*/
int
_papi_hwd_init_global( void )
{
int retval;
/* Fill in what we can of the papi_system_info.
* This doesn't need to be called but sometimes
* it is nice to seperate it out.
*/
retval = _internal_get_system_info( );
if ( retval )
return ( retval );
/* This is usually implemented in an OS specific file
* but can be implemented here if need be
*/
retval = get_memory_info( &_papi_system_info.mem_info );
if ( retval )
return ( retval );
DBG( ( stderr, "Found %d %s %s CPUs at %f Mhz.\n",
_papi_system_info.hw_info.totalcpus,
_papi_system_info.hw_info.vendor_string,
_papi_system_info.hw_info.model_string,
_papi_system_info.hw_info.mhz ) );
return ( PAPI_OK );
}
double
vm_now()
{
size_t memory_usage=0;
size_t faults=0;
get_memory_info(memory_usage, faults);
return static_cast<double>(memory_usage);
}
double
vm_now()
{
size_t memory_usage;
size_t faults;
get_memory_info(memory_usage, faults);
return (double) memory_usage;
}
/* helper for find_vm_areas_via_probe() and get_memory_info_from_os()
* returns the passed-in pc if the probe was successful; else, returns
* where the next probe should be (to skip DR memory).
* if the probe was successful, returns in prot the results.
*/
static app_pc
probe_address(dcontext_t *dcontext, app_pc pc_in, byte *our_heap_start,
byte *our_heap_end, OUT uint *prot)
{
app_pc base;
size_t size;
app_pc pc = (app_pc)ALIGN_BACKWARD(pc_in, PAGE_SIZE);
ASSERT(ALIGNED(pc, PAGE_SIZE));
ASSERT(prot != NULL);
*prot = MEMPROT_NONE;
/* skip our own vmheap */
if (pc >= our_heap_start && pc < our_heap_end)
return our_heap_end;
/* if no vmheap and we probe our own stack, the SIGSEGV handler will
* report stack overflow as it checks that prior to handling TRY
*/
if (is_stack_overflow(dcontext, pc))
return pc + PAGE_SIZE;
#ifdef VMX86_SERVER
/* Workaround for PR 380621 */
if (is_vmkernel_addr_in_user_space(pc, &base)) {
LOG(GLOBAL, LOG_VMAREAS, 4, "%s: skipping vmkernel region " PFX "-" PFX "\n",
__func__, pc, base);
return base;
}
#endif
/* Only for find_vm_areas_via_probe(), skip modules added by
* dl_iterate_get_areas_cb. Subsequent probes are about gettting
* info from OS, so do the actual probe. See PR 410907.
*/
if (!dynamo_initialized && get_memory_info(pc, &base, &size, prot))
return base + size;
TRY_EXCEPT(dcontext, /* try */
{
PROBE_READ_PC(pc);
*prot |= MEMPROT_READ;
},
/* except */
{
/* nothing: just continue */
});
void
k_print_memory_usage_info()
{
memInfo_t memInfo;
int i;
get_memory_info(&memInfo);
k_print("Memory usage:\n");
k_print("Heap address: 0x%08x\n", memInfo.heapAddress);
k_print("Memory cached: %u/%u bytes\n", memInfo.heapCached, memInfo.totalSize);
k_print("Memory used: %u bytes\n", memInfo.memoryUsed);
k_print("Allocated blocks:\n");
for(i = 0; i < MEMORY_SLICES_MAX_COUNT; i++)
{
if(memPool.numAllocatedBlocks[i] != 0)
k_print("|%dx(%u)|", memPool.numAllocatedBlocks[i], (1<<i));
}
k_print("\n");
}
static void
test_self_direct(dcontext_t *dcontext)
{
app_pc base_pc;
size_t size;
uint found;
uint newfound;
#ifdef WINDOWS
/* this will get both code and data FIXME: data2data reference
* will be the majority
*/
size = get_allocation_size((app_pc)test_self_direct, &base_pc);
#else
/* platform agnostic but only looks for current CODE section, and
* on windows is not quite what we want - since base_pc will just
* be just page aligned
*/
get_memory_info((app_pc)test_self_direct, &base_pc, &size, NULL);
#endif
mutex_lock(&rct_module_lock);
found = find_address_references(dcontext,
base_pc, base_pc+size,
base_pc, base_pc+size);
mutex_unlock(&rct_module_lock);
/* guesstimate */
EXPECT_RELATION(found, >, 140);
#ifdef WINDOWS
/* FIXME: note data2data have a huge part here */
EXPECT_RELATION(found, <, 20000);
#else
EXPECT_RELATION(found, <, 1000);
#endif
EXPECT(is_address_taken(dcontext, (app_pc)f3), true);
EXPECT(is_address_taken(dcontext, (app_pc)f2), true);
EXPECT(is_address_taken(dcontext, (app_pc)f7), true); /* array reference only */
/* it is pretty hard to produce the address of a static
* (e.g. test_self) without making it address taken ;) so we just
* add a number to known to be good one's */
EXPECT(is_address_taken(dcontext, (app_pc)f3 + 1), false);
EXPECT(is_address_taken(dcontext, (app_pc)f3 + 2), false);
EXPECT(is_address_taken(dcontext, (app_pc)f2 + 1), false);
EXPECT(is_address_taken(dcontext, (app_pc)f7 + 1), false);
mutex_lock(&rct_module_lock);
EXPECT(invalidate_ind_branch_target_range(dcontext, 0, (app_pc)-1),
found);
EXPECT_RELATION(invalidate_ind_branch_target_range(dcontext, 0, (app_pc)-1)
, == , 0); /* nothing missed */
mutex_unlock(&rct_module_lock);
/* now try manually rct_analyze_module_at_violation */
mutex_lock(&rct_module_lock);
EXPECT(rct_analyze_module_at_violation(dcontext, (app_pc)test_self_direct), true);
/* should be all found */
/* FIXME: with the data2data in fact a few noisy entries show up
* since second lookup in data may differ from original
*/
newfound = find_address_references(dcontext,
base_pc, base_pc+size,
base_pc, base_pc+size);
EXPECT_RELATION(newfound, <, 4);
EXPECT_RELATION(invalidate_ind_branch_target_range(dcontext, 0, (app_pc)-1)
, > , found + newfound - 5); /* FIXME: data references uncomparable */
EXPECT_RELATION(invalidate_ind_branch_target_range(dcontext, 0, (app_pc)-1)
, == , 0); /* nothing missed */
mutex_unlock(&rct_module_lock);
}
/*****************************************************************************
Perform rtkgps status command.
*****************************************************************************/
void cmd_status(cmdlnopts_t *cmdopt) {
int fd;
unsigned int mu = 0;
status_t status;
logfile_t lgfl;
log_bndry_t lgbd;
memory_t mem;
firmware_t frm;
fd = coms_open(cmdopt);
if (cmdopt->vflg)
printf("Requesting logger status information\n");
status_read(fd, &status, cmdopt);
if (cmdopt->eflg) {
if (cmdopt->vflg)
printf("Requesting extended logger information\n");
gpsmouse_disable(fd, status.gpsms, cmdopt);
if (get_log_bndry(fd, &lgbd) < 0) {
fprintf(stderr,"rtkgps: Failed to read log start/end details [%s]\n",
gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
if (get_memory_info(fd, &mem) < 0) {
fprintf(stderr,"rtkgps: Failed to read logger memory details [%s]\n",
gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
if (get_firmware_info(fd, &frm) < 0) {
fprintf(stderr,"rtkgps: Failed to read logger firmware details [%s]\n",
gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
/* Get info for first logfile */
if (get_file_info(fd, 0, &lgfl) < 0) {
fprintf(stderr,"rtkgps: Error reading information for file %d [%s]\n",
0, gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
if (lgfl.memp == 0) { /* Memory has not wrapped around in overwrite mode */
/* Get info for last logfile */
if (get_file_info(fd, status.nfile-1, &lgfl) < 0) {
fprintf(stderr,"rtkgps: Error reading information for file %d [%s]\n",
status.nfile-1, gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
/* Memory used computed from last logfile pointer plus number of
fixes in active logfile */
mu = lgfl.memp + status.nfix*fix_size(status.fxtyp);
} else { /* Memory has wrapped around in overwrite mode */
int n;
/* Need to compute memory used by adding up number of fixes in each
log file */
mu = lgfl.nfix*fix_size(lgfl.fxtyp);
for (n = 1; n < status.nfile; n++) {
if (get_file_info(fd, n, &lgfl) < 0) {
fprintf(stderr,"rtkgps: Error reading information for file "
"%d [%s]\n", n, gcstrerror(rcerrno));
gpsmouse_enable(fd, status.gpsms, cmdopt);
coms_close(fd, cmdopt);
exit(5);
}
mu += lgfl.nfix*fix_size(lgfl.fxtyp);
}
}
gpsmouse_enable(fd, status.gpsms, cmdopt);
}
printf("GPS Fix: %s\nGPS mouse mode: %s\n"
"Record type: %s\nMemory full: %s\n"
"Sampling interval: %hds\nNumber of files: %hd\n"
"Fixes in last file: %d\n", gpsrx_string(status.gpsrx),
gpsms_string(status.gpsms), fxtyp_string(status.fxtyp),
mfowm_string(status.mfowm), status.sntvl, status.nfile,
status.nfix
);
if (cmdopt->eflg) {
printf("First log fix: %.4s-%.2s-%.2s %.2s:%.2s:%.2s\n"
"Last log fix: %.4s-%.2s-%.2s %.2s:%.2s:%.2s\n",
lgbd.first.date,lgbd.first.date+4,lgbd.first.date+6,
lgbd.first.time, lgbd.first.time+2, lgbd.first.time+4,
lgbd.last.date,lgbd.last.date+4,lgbd.last.date+6,
lgbd.last.time, lgbd.last.time+2, lgbd.last.time+4);
printf("Device memory: %7.2fkb\n"
"Memory used: %7.2fkb (%.2f%%)\n",
mem.nbytes / 1024.0, mu / 1024.4, ((float)mu / mem.nbytes)*100.0);
printf("Version: %s\n"
"Firmware: %s\n", frm.vrsnr, frm.frmwr);
}
coms_close(fd, cmdopt);
}
char *
sysinfo_backend_get_memory (void)
{
/* Memory information is always loaded dynamically since it includes the current amount of free memory */
return get_memory_info ();
}
void sngisdn_rcv_q931_ind(InMngmt *status)
{
if (status->t.usta.alarm.cause == 287) {
get_memory_info();
return;
}
switch (status->t.usta.alarm.event) {
case LCM_EVENT_UP:
case LCM_EVENT_DOWN:
{
ftdm_span_t *ftdmspan;
sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[status->t.usta.suId].spans[1];
if (!signal_data) {
ftdm_log(FTDM_LOG_INFO, "Received q931 status on unconfigured span (lnkNmb:%d)\n", status->t.usta.suId);
return;
}
ftdmspan = signal_data->ftdm_span;
if (status->t.usta.alarm.event == LCM_EVENT_UP) {
uint32_t chan_no = status->t.usta.evntParm[2];
ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
status->t.usta.suId,
DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
if (chan_no) {
ftdm_channel_t *ftdmchan = ftdm_span_get_channel(ftdmspan, chan_no);
if (ftdmchan) {
sngisdn_set_chan_sig_status(ftdmchan, FTDM_SIG_STATE_UP);
sngisdn_set_chan_avail_rate(ftdmchan, SNGISDN_AVAIL_UP);
} else {
ftdm_log(FTDM_LOG_CRIT, "stack alarm event on invalid channel :%d\n", chan_no);
}
} else {
sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_UP);
sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_UP);
}
} else {
ftdm_log(FTDM_LOG_WARNING, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
status->t.usta.suId,
DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_DOWN);
sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_PWR_SAVING);
}
}
break;
default:
ftdm_log(FTDM_LOG_WARNING, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
status->t.usta.suId,
DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
}
ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
return;
}
