GMM_EXPORT
void gmm_dump_dptr(const char *filepath, const void *dptr, const size_t size)
{
struct region *r;
if (!filepath) {
gprint(DEBUG, "bad filepath for gmm_dump\n");
return;
}
if (size <= 0) {
gprint(DEBUG, "bad size for gmm_dump\n");
return;
}
r = region_lookup(pcontext, dptr);
if (!r) {
gprint(DEBUG, "region lookup failed for %p in gmm_dump\n", dptr);
return;
}
if (dptr + size > &(r->swp_addr) + r->size) {//potential bug
gprint(DEBUG, "bad dump range for gmm_dump\n");
return;
}
gmm_dump_region(filepath, r, dptr, size);
}
// Print info of the region containing %dptr
GMM_EXPORT
void gmm_print_dptr(const void *dptr)
{
struct region *r;
r = region_lookup(pcontext, dptr);
if (!r) {
gprint(DEBUG, "failed to look up region containing %p\n", dptr);
return;
}
gmm_print_region(r);
}
/*
* allocate_program_memory()
*
* This function attempts to allocate program memory sections.
*
* Called by: allocate_memory()
*
* Calls: build_alloc_section_list()
* build_free_block_list()
* locate_sections()
* pic32_section_list_length()
*
* Returns: status code
* (0 = success)
*/
static int
allocate_program_memory() {
struct memory_region_struct *region;
unsigned int mask = code;
int result = 0;
if (pic32_debug)
printf("\nBuilding allocation list for region \"program\"\n"
" attribute mask = %x\n", mask);
build_alloc_section_list(mask);
if (pic32_section_list_length(alloc_section_list) == 0)
return result;
region = region_lookup ("kseg0_program_mem");
build_free_block_list(region, mask);
if (pic32_debug) {
pic32_print_section_list(alloc_section_list, "allocation");
}
#if 0
if (pic32_debug)
pic32_print_section_list(unassigned_sections, "unassigned");
#endif
reset_locate_options();
result |= locate_sections(address, 0, region); /* most restrictive */
result |= locate_sections(all_attr, 0, region); /* least restrictive */
/* save the free blocks list */
program_memory_free_blocks = free_blocks;
free_blocks = 0;
return result;
} /* allocate_program_memory() */
/*
** Utility routine: bfd_pic30_report_memory_usage
**
** - print a section chart to file *fp
**/
static void
bfd_pic30_report_memory_usage (FILE *fp) {
bfd_size_type max_heap, max_stack;
lang_memory_region_type *region;
struct pic30_section *s;
int has_eedata = 0;
/* clear the counters */
actual_prog_memory_used = 0;
actual_eedata_memory_used = 0;
data_memory_used = 0;
/* build an ordered list of output sections */
pic30_init_section_list(&pic30_section_list);
bfd_map_over_sections(output_bfd, &pic30_build_section_list, NULL);
region = region_lookup("program");
/* print code header */
fprintf( fp, "\n\nProgram Memory [Origin = 0x%lx, Length = 0x%lx]\n\n",
region->origin, region->length);
fprintf( fp, "section address length (PC units)"
" length (bytes) (dec)\n");
fprintf( fp, "------- ------- -----------------"
" --------------------\n");
/* report code sections */
for (s = pic30_section_list; s != NULL; s = s->next)
if ((s->sec) && in_bounds(s->sec, region))
bfd_pic30_report_program_sections (s->sec, fp);
/* print code summary */
fprintf( fp, "\n Total program memory used (bytes):"
" %#10lx (%ld) ",
actual_prog_memory_used, actual_prog_memory_used);
report_percent_used((actual_prog_memory_used * 2)/3,
region->length, fp);
fprintf( fp, "\n");
/* the eedata report is optional */
for (s = pic30_section_list; s != NULL; s = s->next)
if ((s->sec) && PIC30_IS_EEDATA_ATTR(s->sec))
has_eedata = 1;
if (has_eedata) {
region = region_lookup("eedata");
/* print eedata header */
fprintf( fp, "\n\nData EEPROM Memory [Origin = 0x%lx, Length = 0x%lx]\n\n",
region->origin, region->length);
fprintf( fp, "section address length (PC units)"
" length (bytes) (dec)\n");
fprintf( fp, "------- ------- -----------------"
" --------------------\n");
/* report eedata sections */
for (s = pic30_section_list; s != NULL; s = s->next)
if ((s->sec) && in_bounds(s->sec, region))
bfd_pic30_report_eedata_sections (s->sec, fp);
/* print eedata summary */
fprintf( fp, "\n Total data EEPROM used (bytes):"
" %#10lx (%ld) ",
actual_eedata_memory_used, actual_eedata_memory_used);
report_percent_used(actual_eedata_memory_used, region->length, fp);
fprintf( fp, "\n");
}
/* print data header */
region = region_lookup("data");
fprintf( fp, "\n\nData Memory [Origin = 0x%lx, Length = 0x%lx]\n\n",
region->origin, region->length);
fprintf( fp, "section address alignment gaps"
" total length (dec)\n");
fprintf( fp, "------- ------- --------------"
" -------------------\n");
/* report data sections */
for (s = pic30_section_list; s != NULL; s = s->next)
if ((s->sec) && in_bounds(s->sec, region))
bfd_pic30_report_data_sections (s->sec, fp);
/* print data summary */
fprintf( fp, "\n Total data memory used (bytes):"
" %#10lx (%ld) ",
data_memory_used, data_memory_used);
if (data_memory_used > 0)
report_percent_used(data_memory_used, region->length, fp);
fprintf( fp, "\n");
/* print dynamic header */
fprintf( fp, "\n\nDynamic Memory Usage\n\n");
fprintf( fp, "region address "
"maximum length (dec)\n");
fprintf( fp, "------ ------- "
"---------------------\n");
/* report dynamic regions */
max_heap = heap_limit - heap_base;
fprintf( fp, "%-24s%#10x%#36lx (%ld)\n", "heap",
heap_base, max_heap, max_heap);
if (user_defined_stack) {
max_stack = 0;
fprintf( fp, "(user-defined stack at 0x%x, length = 0x%x)\n",
stack_base, (unsigned int) (stack_limit - stack_base));
}
else {
max_stack = stack_limit - stack_base + pic30_stackguard_size;
fprintf( fp, "%-24s%#10x%#36lx (%ld)\n", "stack",
stack_base, max_stack, max_stack);
}
/* print dynamic summary */
fprintf( fp, "\n Maximum dynamic memory (bytes):"
" %#14lx (%ld)\n\n",
(max_heap + max_stack), (max_heap + max_stack));
/* report user-defined memory sections...
they require some extra effort to organize by
external memory region */
if (has_user_defined_memory) {
struct pic30_section *r, *rnext, *s;
const char *region_name;
/* loop through any user-defined regions */
for (r = memory_region_list; r != NULL; r = rnext) {
rnext = r->next;
if (r->sec == 0) continue;
region_name = r->sec->name + strlen(memory_region_prefix);
fprintf( fp, "\nExternal Memory %s"
" [Origin = 0x%lx, Length = 0x%lx]\n\n",
region_name, r->sec->vma, r->sec->lma);
fprintf( fp, "section address "
" total length (dec)\n");
fprintf( fp, "------- ------- "
" -------------------\n");
external_memory_used = 0;
for (s = pic30_section_list; s != NULL; s = s->next)
if (s->sec)
bfd_pic30_report_memory_sections (region_name, s->sec, fp);
/* print summary for this region */
fprintf( fp, "\n Total external memory used (bytes):"
" %#10lx (%ld) ",
external_memory_used, external_memory_used);
if (external_memory_used > 0)
report_percent_used(external_memory_used, r->sec->lma, fp);
fprintf( fp, "\n\n");
}
}
/* free the output section list */
pic30_free_section_list(&pic30_section_list);
} /* static void bfd_pic30_report_memory_usage (...)*/
isc_boolean_t
dns_geoip_match(const isc_netaddr_t *reqaddr, isc_uint8_t *scope,
const dns_geoip_databases_t *geoip,
const dns_geoip_elem_t *elt)
{
#ifndef HAVE_GEOIP
UNUSED(reqaddr);
UNUSED(geoip);
UNUSED(elt);
return (ISC_FALSE);
#else
GeoIP *db;
GeoIPRecord *record;
GeoIPRegion *region;
dns_geoip_subtype_t subtype;
isc_uint32_t ipnum = 0;
int maxlen = 0, id, family;
const char *cs;
char *s;
#ifdef HAVE_GEOIP_V6
const geoipv6_t *ipnum6 = NULL;
#else
const void *ipnum6 = NULL;
#endif
INSIST(geoip != NULL);
family = reqaddr->family;
switch (family) {
case AF_INET:
ipnum = ntohl(reqaddr->type.in.s_addr);
break;
case AF_INET6:
#ifdef HAVE_GEOIP_V6
ipnum6 = &reqaddr->type.in6;
break;
#else
return (ISC_FALSE);
#endif
default:
return (ISC_FALSE);
}
subtype = fix_subtype(reqaddr, geoip, elt->subtype);
switch (subtype) {
case dns_geoip_country_code:
maxlen = 2;
goto getcountry;
case dns_geoip_country_code3:
maxlen = 3;
goto getcountry;
case dns_geoip_country_name:
maxlen = 255;
getcountry:
db = DB46(reqaddr, geoip, country);
if (db == NULL)
return (ISC_FALSE);
INSIST(elt->as_string != NULL);
cs = country_lookup(db, subtype, family, ipnum, ipnum6, scope);
if (cs != NULL && strncasecmp(elt->as_string, cs, maxlen) == 0)
return (ISC_TRUE);
break;
case dns_geoip_city_countrycode:
case dns_geoip_city_countrycode3:
case dns_geoip_city_countryname:
case dns_geoip_city_region:
case dns_geoip_city_regionname:
case dns_geoip_city_name:
case dns_geoip_city_postalcode:
case dns_geoip_city_continentcode:
case dns_geoip_city_timezonecode:
INSIST(elt->as_string != NULL);
db = DB46(reqaddr, geoip, city);
if (db == NULL)
return (ISC_FALSE);
record = city_lookup(db, subtype, family,
ipnum, ipnum6, scope);
if (record == NULL)
break;
s = city_string(record, subtype, &maxlen);
INSIST(maxlen != 0);
if (s != NULL && strncasecmp(elt->as_string, s, maxlen) == 0)
return (ISC_TRUE);
break;
case dns_geoip_city_metrocode:
db = DB46(reqaddr, geoip, city);
if (db == NULL)
return (ISC_FALSE);
record = city_lookup(db, subtype, family,
ipnum, ipnum6, scope);
if (record == NULL)
break;
if (elt->as_int == record->metro_code)
return (ISC_TRUE);
break;
case dns_geoip_city_areacode:
db = DB46(reqaddr, geoip, city);
if (db == NULL)
return (ISC_FALSE);
record = city_lookup(db, subtype, family,
ipnum, ipnum6, scope);
if (record == NULL)
break;
if (elt->as_int == record->area_code)
return (ISC_TRUE);
break;
case dns_geoip_region_countrycode:
case dns_geoip_region_code:
case dns_geoip_region_name:
case dns_geoip_region:
if (geoip->region == NULL)
return (ISC_FALSE);
INSIST(elt->as_string != NULL);
/* Region DB is not supported for IPv6 */
if (family == AF_INET6)
return (ISC_FALSE);
region = region_lookup(geoip->region, subtype, ipnum, scope);
if (region == NULL)
break;
s = region_string(region, subtype, &maxlen);
INSIST(maxlen != 0);
if (s != NULL && strncasecmp(elt->as_string, s, maxlen) == 0)
return (ISC_TRUE);
break;
case dns_geoip_isp_name:
db = geoip->isp;
goto getname;
case dns_geoip_org_name:
db = geoip->org;
goto getname;
case dns_geoip_as_asnum:
db = geoip->as;
goto getname;
case dns_geoip_domain_name:
db = geoip->domain;
getname:
if (db == NULL)
return (ISC_FALSE);
INSIST(elt->as_string != NULL);
/* ISP, Org, AS, and Domain are not supported for IPv6 */
if (family == AF_INET6)
return (ISC_FALSE);
s = name_lookup(db, subtype, ipnum, scope);
if (s != NULL) {
size_t l;
if (strcasecmp(elt->as_string, s) == 0)
return (ISC_TRUE);
if (subtype != dns_geoip_as_asnum)
break;
/*
* Just check if the ASNNNN value matches.
*/
l = strlen(elt->as_string);
if (l > 0U && strchr(elt->as_string, ' ') == NULL &&
strncasecmp(elt->as_string, s, l) == 0 &&
s[l] == ' ')
return (ISC_TRUE);
}
break;
case dns_geoip_netspeed_id:
INSIST(geoip->netspeed != NULL);
/* Netspeed DB is not supported for IPv6 */
if (family == AF_INET6)
return (ISC_FALSE);
id = netspeed_lookup(geoip->netspeed, subtype, ipnum, scope);
if (id == elt->as_int)
return (ISC_TRUE);
break;
case dns_geoip_countrycode:
case dns_geoip_countrycode3:
case dns_geoip_countryname:
case dns_geoip_regionname:
/*
* If these were not remapped by fix_subtype(),
* the database was unavailable. Always return false.
*/
break;
default:
INSIST(0);
}
return (ISC_FALSE);
#endif
}
/*
* allocate_data_memory()
*
* This function attempts to allocate data memory sections.
*
* Called by: allocate_memory()
*
* Calls: build_section_list()
* build_free_block_list()
* locate_sections()
*
* Returns: status code
* (0 = success)
*
* Notes: List "data_memory_free_blocks" is needed by
* bfd_pic322_finish() to allocate the stack
* and heap, so don't exit this function early.
*
* EDS allocation is tricky. Although these sections
* can be allocated anywhere, we need to preserve
* low memory for the stack. In the first pass,
* we exclude memory below the stack limit altogether.
* In the second pass, we scan free blocks in reverse
* only, which helps when a block crosses the
* stack limit boundary. Eventually we'll take
* whatever memory we need to, and leave the rest
* for the stack and heap.
*
* We also support allocation of stack and heap
* that are defined with section attributes.
*
* See comments below for additional info
* about stack allocation.
*/
static int
allocate_data_memory() {
struct memory_region_struct *region;
struct pic32_section *s;
unsigned int mask = data|bss|persist|stack|heap|ramfunc;
int result = 0;
if (pic32_debug)
printf("\nBuilding allocation list for region \"data\"\n"
" attribute mask = %x\n", mask);
build_alloc_section_list(mask);
region = region_lookup ("kseg1_data_mem");
build_free_block_list(region, mask);
if (pic32_debug) {
pic32_print_section_list(alloc_section_list, "allocation");
}
reset_locate_options();
result |= locate_sections(ramfunc, 0, region); /* most restrictive */
if (!bfd_pic32_is_defined_global_symbol("_ramfunc_begin"))
{
/* If there are no ram fumctions, add the _ramfunc_begin symbol with value 0 */
_bfd_generic_link_add_one_symbol (&link_info, link_info.output_bfd, "_ramfunc_begin",
BSF_GLOBAL, bfd_abs_section_ptr,
0, "_ramfunc_begin", 1, 0, 0);
}
if (ramfunc_begin != 0) {
set_locate_options(EXCLUDE_HIGH_ADDR, ramfunc_begin);
}
result |= locate_sections(address, 0, region);
result |= locate_sections(near, 0, region); /* less restrictive */
result |= locate_sections(all_attr, stack|heap, region);
#if 0
/* user-defined heap */
if (ramfunc_begin != 0) {
set_locate_options(EXCLUDE_HIGH_ADDR, ramfunc_begin);
}
result |= locate_sections(heap, 0, region);
/* user-defined stack */
if (ramfunc_begin != 0) {
set_locate_options(EXCLUDE_HIGH_ADDR, ramfunc_begin);
}
result |= locate_sections(stack, 0, region);
#else
/* Don't support user-defined stack sections yet */
for (s = alloc_section_list; s != NULL; s = s->next) {
if (s->sec && (PIC32_IS_STACK_ATTR(s->sec) || PIC32_IS_HEAP_ATTR(s->sec))) {
lang_output_section_statement_type *os;
s->sec->lma = 0;
s->sec->vma = 0;
os = lang_output_section_statement_lookup (".stack", 0, TRUE);
/* lang_add_section() will call init_os() if needed */
lang_add_section (&os->children, s->sec, os);
finish_section_info(s, os);
pic32_remove_from_section_list(alloc_section_list,s);
os->bfd_section->flags = s->sec->flags;
}
}
#endif
/* if any sections are left in the allocation list, report an error */
for (s = alloc_section_list; s != NULL; s = s->next) {
if (s->attributes != 0) {
report_allocation_error(s);
result = 1;
break;
}
}
/* save the free blocks list */
data_memory_free_blocks = free_blocks;
free_blocks = 0;
return result;
} /* allocate_data_memory() */