static void
get_keys (void)
{
int search = 0;
int c, quit = 1;
uint64_t size1 = 0;
if (!logger->piping)
size1 = file_size (conf.ifile);
while (quit) {
c = wgetch (stdscr);
switch (c) {
case 'q': /* quit */
if (!gscroll.expanded) {
quit = 0;
break;
}
collapse_current_module ();
break;
case KEY_F (1):
case '?':
case 'h':
load_help_popup (main_win);
render_screens ();
break;
case 49: /* 1 */
/* reset expanded module */
set_module_to (&gscroll, VISITORS);
break;
case 50: /* 2 */
/* reset expanded module */
set_module_to (&gscroll, REQUESTS);
break;
case 51: /* 3 */
/* reset expanded module */
set_module_to (&gscroll, REQUESTS_STATIC);
break;
case 52: /* 4 */
/* reset expanded module */
set_module_to (&gscroll, NOT_FOUND);
break;
case 53: /* 5 */
/* reset expanded module */
set_module_to (&gscroll, HOSTS);
break;
case 54: /* 6 */
/* reset expanded module */
set_module_to (&gscroll, OS);
break;
case 55: /* 7 */
/* reset expanded module */
set_module_to (&gscroll, BROWSERS);
break;
case 56: /* 8 */
/* reset expanded module */
set_module_to (&gscroll, VISIT_TIMES);
break;
case 57: /* 9 */
/* reset expanded module */
set_module_to (&gscroll, REFERRERS);
break;
case 48: /* 0 */
/* reset expanded module */
set_module_to (&gscroll, REFERRING_SITES);
break;
case 33: /* shift + 1 */
/* reset expanded module */
set_module_to (&gscroll, KEYPHRASES);
break;
case 34: /* Shift + 2 */
/* reset expanded module */
#ifdef HAVE_LIBGEOIP
set_module_to (&gscroll, GEO_LOCATION);
#else
set_module_to (&gscroll, STATUS_CODES);
#endif
break;
#ifdef HAVE_LIBGEOIP
case 35: /* Shift + 3 */
/* reset expanded module */
set_module_to (&gscroll, STATUS_CODES);
break;
#endif
case 9: /* TAB */
/* reset expanded module */
collapse_current_module ();
if (next_module () == 0)
render_screens ();
break;
case 353: /* Shift TAB */
/* reset expanded module */
collapse_current_module ();
if (previous_module () == 0)
render_screens ();
break;
case 'g': /* g = top */
scroll_to_first_line ();
display_content (main_win, logger, dash, &gscroll);
break;
case 'G': /* G = down */
scroll_to_last_line ();
display_content (main_win, logger, dash, &gscroll);
break;
/* expand dashboard module */
case KEY_RIGHT:
case 0x0a:
case 0x0d:
case 32: /* ENTER */
case 79: /* o */
case 111: /* O */
case KEY_ENTER:
expand_current_module ();
display_content (main_win, logger, dash, &gscroll);
break;
case KEY_DOWN: /* scroll main dashboard */
if ((gscroll.dash + real_size_y) < (unsigned) dash->total_alloc) {
gscroll.dash++;
display_content (main_win, logger, dash, &gscroll);
}
break;
case KEY_MOUSE: /* handles mouse events */
expand_on_mouse_click ();
break;
case 106: /* j - DOWN expanded module */
scroll_down_expanded_module ();
display_content (main_win, logger, dash, &gscroll);
break;
/* scroll up main_win */
case KEY_UP:
if (gscroll.dash > 0) {
scroll_up_dashboard ();
display_content (main_win, logger, dash, &gscroll);
}
break;
case 2: /* ^ b - page up */
case 339: /* ^ PG UP */
page_up_module ();
display_content (main_win, logger, dash, &gscroll);
break;
case 6: /* ^ f - page down */
case 338: /* ^ PG DOWN */
page_down_module ();
display_content (main_win, logger, dash, &gscroll);
break;
case 107: /* k - UP expanded module */
scroll_up_expanded_module ();
display_content (main_win, logger, dash, &gscroll);
break;
case 'n':
search_next_match (search);
break;
case '/':
render_search_dialog (search);
break;
case 99: /* c */
if (conf.no_color)
break;
load_schemes_win (main_win);
free_dashboard (dash);
allocate_data ();
render_screens ();
break;
case 115: /* s */
render_sort_dialog ();
break;
case 269:
case KEY_RESIZE:
window_resize ();
break;
default:
perform_tail_follow (&size1);
break;
}
}
}
/* Add xenheap memory that was not already added to the boot
allocator. */
init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start),
pfn_to_paddr(boot_mfn_start));
end_boot_allocator();
}
#else /* CONFIG_ARM_64 */
static void __init setup_mm(unsigned long dtb_paddr, size_t dtb_size)
{
paddr_t ram_start = ~0;
paddr_t ram_end = 0;
paddr_t ram_size = 0;
int bank;
unsigned long dtb_pages;
void *fdt;
total_pages = 0;
for ( bank = 0 ; bank < early_info.mem.nr_banks; bank++ )
{
paddr_t bank_start = early_info.mem.bank[bank].start;
paddr_t bank_size = early_info.mem.bank[bank].size;
paddr_t bank_end = bank_start + bank_size;
paddr_t s, e;
paddr_t new_ram_size = ram_size + bank_size;
paddr_t new_ram_start = min(ram_start,bank_start);
paddr_t new_ram_end = max(ram_end,bank_end);
/*
* We allow non-contigious regions so long as at least half of
* the total RAM region actually contains RAM. We actually
* fudge this slightly and require that adding the current
* bank does not cause us to violate this restriction.
*
* This restriction ensures that the frametable (which is not
* currently sparse) does not consume all available RAM.
*/
if ( bank > 0 && 2 * new_ram_size < new_ram_end - new_ram_start )
/* Would create memory map which is too sparse, so stop here. */
break;
ram_start = new_ram_start;
ram_end = new_ram_end;
ram_size = new_ram_size;
setup_xenheap_mappings(bank_start>>PAGE_SHIFT, bank_size>>PAGE_SHIFT);
s = bank_start;
while ( s < bank_end )
{
paddr_t n = bank_end;
e = next_module(s, &n);
if ( e == ~(paddr_t)0 )
{
e = n = bank_end;
}
if ( e > bank_end )
e = bank_end;
xenheap_mfn_end = e;
dt_unreserved_regions(s, e, init_boot_pages, 0);
s = n;
}
}
if ( bank != early_info.mem.nr_banks )
{
early_printk("WARNING: only using %d out of %d memory banks\n",
bank, early_info.mem.nr_banks);
early_info.mem.nr_banks = bank;
}
total_pages += ram_size >> PAGE_SHIFT;
xenheap_virt_end = XENHEAP_VIRT_START + ram_end - ram_start;
xenheap_mfn_start = ram_start >> PAGE_SHIFT;
xenheap_mfn_end = ram_end >> PAGE_SHIFT;
xenheap_max_mfn(xenheap_mfn_end);
/*
* Need enough mapped pages for copying the DTB.
*/
dtb_pages = (dtb_size + PAGE_SIZE-1) >> PAGE_SHIFT;
/* Copy the DTB. */
fdt = mfn_to_virt(alloc_boot_pages(dtb_pages, 1));
copy_from_paddr(fdt, dtb_paddr, dtb_size, BUFFERABLE);
device_tree_flattened = fdt;
setup_frametable_mappings(ram_start, ram_end);
max_page = PFN_DOWN(ram_end);
end_boot_allocator();
}
/* Add xenheap memory that was not already added to the boot
allocator. */
init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start),
pfn_to_paddr(boot_mfn_start));
}
#else /* CONFIG_ARM_64 */
static void __init setup_mm(unsigned long dtb_paddr, size_t dtb_size)
{
paddr_t ram_start = ~0;
paddr_t ram_end = 0;
paddr_t ram_size = 0;
int bank;
unsigned long dtb_pages;
void *fdt;
init_pdx();
total_pages = 0;
for ( bank = 0 ; bank < bootinfo.mem.nr_banks; bank++ )
{
paddr_t bank_start = bootinfo.mem.bank[bank].start;
paddr_t bank_size = bootinfo.mem.bank[bank].size;
paddr_t bank_end = bank_start + bank_size;
paddr_t s, e;
ram_size = ram_size + bank_size;
ram_start = min(ram_start,bank_start);
ram_end = max(ram_end,bank_end);
setup_xenheap_mappings(bank_start>>PAGE_SHIFT, bank_size>>PAGE_SHIFT);
s = bank_start;
while ( s < bank_end )
{
paddr_t n = bank_end;
e = next_module(s, &n);
if ( e == ~(paddr_t)0 )
{
e = n = bank_end;
}
if ( e > bank_end )
e = bank_end;
xenheap_mfn_end = e;
dt_unreserved_regions(s, e, init_boot_pages, 0);
s = n;
}
}
total_pages += ram_size >> PAGE_SHIFT;
xenheap_virt_end = XENHEAP_VIRT_START + ram_end - ram_start;
xenheap_mfn_start = ram_start >> PAGE_SHIFT;
xenheap_mfn_end = ram_end >> PAGE_SHIFT;
/*
* Need enough mapped pages for copying the DTB.
*/
dtb_pages = (dtb_size + PAGE_SIZE-1) >> PAGE_SHIFT;
/* Copy the DTB. */
fdt = mfn_to_virt(alloc_boot_pages(dtb_pages, 1));
copy_from_paddr(fdt, dtb_paddr, dtb_size);
device_tree_flattened = fdt;
setup_frametable_mappings(ram_start, ram_end);
max_page = PFN_DOWN(ram_end);
}
static void __init setup_mm(unsigned long dtb_paddr, size_t dtb_size)
{
paddr_t ram_start, ram_end, ram_size;
paddr_t contig_start, contig_end;
paddr_t s, e;
unsigned long ram_pages;
unsigned long heap_pages, xenheap_pages, domheap_pages;
unsigned long dtb_pages;
unsigned long boot_mfn_start, boot_mfn_end;
int i;
void *fdt;
if ( !early_info.mem.nr_banks )
early_panic("No memory bank");
/*
* We are going to accumulate two regions here.
*
* The first is the bounds of the initial memory region which is
* contiguous with the first bank. For simplicity the xenheap is
* always allocated from this region.
*
* The second is the complete bounds of the regions containing RAM
* (ie. from the lowest RAM address to the highest), which
* includes any holes.
*
* We also track the number of actual RAM pages (i.e. not counting
* the holes).
*/
ram_size = early_info.mem.bank[0].size;
contig_start = ram_start = early_info.mem.bank[0].start;
contig_end = ram_end = ram_start + ram_size;
for ( i = 1; i < early_info.mem.nr_banks; i++ )
{
paddr_t bank_start = early_info.mem.bank[i].start;
paddr_t bank_size = early_info.mem.bank[i].size;
paddr_t bank_end = bank_start + bank_size;
paddr_t new_ram_size = ram_size + bank_size;
paddr_t new_ram_start = min(ram_start,bank_start);
paddr_t new_ram_end = max(ram_end,bank_end);
/*
* If the new bank is contiguous with the initial contiguous
* region then incorporate it into the contiguous region.
*
* Otherwise we allow non-contigious regions so long as at
* least half of the total RAM region actually contains
* RAM. We actually fudge this slightly and require that
* adding the current bank does not cause us to violate this
* restriction.
*
* This restriction ensures that the frametable (which is not
* currently sparse) does not consume all available RAM.
*/
if ( bank_start == contig_end )
contig_end = bank_end;
else if ( bank_end == contig_start )
contig_start = bank_start;
else if ( 2 * new_ram_size < new_ram_end - new_ram_start )
/* Would create memory map which is too sparse, so stop here. */
break;
ram_size = new_ram_size;
ram_start = new_ram_start;
ram_end = new_ram_end;
}
if ( i != early_info.mem.nr_banks )
{
early_printk("WARNING: only using %d out of %d memory banks\n",
i, early_info.mem.nr_banks);
early_info.mem.nr_banks = i;
}
total_pages = ram_pages = ram_size >> PAGE_SHIFT;
/*
* Locate the xenheap using these constraints:
*
* - must be 32 MiB aligned
* - must not include Xen itself or the boot modules
* - must be at most 1/8 the total RAM in the system
* - must be at least 128M
*
* We try to allocate the largest xenheap possible within these
* constraints.
*/
heap_pages = ram_pages;
xenheap_pages = (heap_pages/8 + 0x1fffUL) & ~0x1fffUL;
xenheap_pages = max(xenheap_pages, 128UL<<(20-PAGE_SHIFT));
do
{
/* xenheap is always in the initial contiguous region */
e = consider_modules(contig_start, contig_end,
pfn_to_paddr(xenheap_pages),
32<<20, 0);
if ( e )
break;
xenheap_pages >>= 1;
} while ( xenheap_pages > 128<<(20-PAGE_SHIFT) );
if ( ! e )
early_panic("Not not enough space for xenheap");
domheap_pages = heap_pages - xenheap_pages;
early_printk("Xen heap: %"PRIpaddr"-%"PRIpaddr" (%lu pages)\n",
e - (pfn_to_paddr(xenheap_pages)), e,
xenheap_pages);
early_printk("Dom heap: %lu pages\n", domheap_pages);
setup_xenheap_mappings((e >> PAGE_SHIFT) - xenheap_pages, xenheap_pages);
/*
* Need a single mapped page for populating bootmem_region_list
* and enough mapped pages for copying the DTB.
*/
dtb_pages = (dtb_size + PAGE_SIZE-1) >> PAGE_SHIFT;
boot_mfn_start = xenheap_mfn_end - dtb_pages - 1;
boot_mfn_end = xenheap_mfn_end;
init_boot_pages(pfn_to_paddr(boot_mfn_start), pfn_to_paddr(boot_mfn_end));
/* Copy the DTB. */
fdt = mfn_to_virt(alloc_boot_pages(dtb_pages, 1));
copy_from_paddr(fdt, dtb_paddr, dtb_size, BUFFERABLE);
device_tree_flattened = fdt;
/* Add non-xenheap memory */
for ( i = 0; i < early_info.mem.nr_banks; i++ )
{
paddr_t bank_start = early_info.mem.bank[i].start;
paddr_t bank_end = bank_start + early_info.mem.bank[i].size;
s = bank_start;
while ( s < bank_end )
{
paddr_t n = bank_end;
e = next_module(s, &n);
if ( e == ~(paddr_t)0 )
{
e = n = ram_end;
}
/*
* Module in a RAM bank other than the one which we are
* not dealing with here.
*/
if ( e > bank_end )
e = bank_end;
/* Avoid the xenheap */
if ( s < pfn_to_paddr(xenheap_mfn_start+xenheap_pages)
&& pfn_to_paddr(xenheap_mfn_start) < e )
{
e = pfn_to_paddr(xenheap_mfn_start);
n = pfn_to_paddr(xenheap_mfn_start+xenheap_pages);
}
dt_unreserved_regions(s, e, init_boot_pages, 0);
s = n;
}
}
/* Frame table covers all of RAM region, including holes */
setup_frametable_mappings(ram_start, ram_end);
max_page = PFN_DOWN(ram_end);
/* Add xenheap memory that was not already added to the boot
allocator. */
init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start),
pfn_to_paddr(boot_mfn_start));
end_boot_allocator();
}
static void __init setup_mm(unsigned long dtb_paddr, size_t dtb_size)
{
paddr_t ram_start, ram_end, ram_size;
paddr_t s, e;
unsigned long ram_pages;
unsigned long heap_pages, xenheap_pages, domheap_pages;
unsigned long dtb_pages;
unsigned long boot_mfn_start, boot_mfn_end;
int i;
void *fdt;
if ( !bootinfo.mem.nr_banks )
panic("No memory bank");
init_pdx();
ram_start = bootinfo.mem.bank[0].start;
ram_size = bootinfo.mem.bank[0].size;
ram_end = ram_start + ram_size;
for ( i = 1; i < bootinfo.mem.nr_banks; i++ )
{
paddr_t bank_start = bootinfo.mem.bank[i].start;
paddr_t bank_size = bootinfo.mem.bank[i].size;
paddr_t bank_end = bank_start + bank_size;
ram_size = ram_size + bank_size;
ram_start = min(ram_start,bank_start);
ram_end = max(ram_end,bank_end);
}
total_pages = ram_pages = ram_size >> PAGE_SHIFT;
/*
* If the user has not requested otherwise via the command line
* then locate the xenheap using these constraints:
*
* - must be 32 MiB aligned
* - must not include Xen itself or the boot modules
* - must be at most 1GB or 1/32 the total RAM in the system if less
* - must be at least 32M
*
* We try to allocate the largest xenheap possible within these
* constraints.
*/
heap_pages = ram_pages;
if ( opt_xenheap_megabytes )
xenheap_pages = opt_xenheap_megabytes << (20-PAGE_SHIFT);
else
{
xenheap_pages = (heap_pages/32 + 0x1fffUL) & ~0x1fffUL;
xenheap_pages = max(xenheap_pages, 32UL<<(20-PAGE_SHIFT));
xenheap_pages = min(xenheap_pages, 1UL<<(30-PAGE_SHIFT));
}
do
{
e = consider_modules(ram_start, ram_end,
pfn_to_paddr(xenheap_pages),
32<<20, 0);
if ( e )
break;
xenheap_pages >>= 1;
} while ( !opt_xenheap_megabytes && xenheap_pages > 32<<(20-PAGE_SHIFT) );
if ( ! e )
panic("Not not enough space for xenheap");
domheap_pages = heap_pages - xenheap_pages;
printk("Xen heap: %"PRIpaddr"-%"PRIpaddr" (%lu pages%s)\n",
e - (pfn_to_paddr(xenheap_pages)), e, xenheap_pages,
opt_xenheap_megabytes ? ", from command-line" : "");
printk("Dom heap: %lu pages\n", domheap_pages);
setup_xenheap_mappings((e >> PAGE_SHIFT) - xenheap_pages, xenheap_pages);
/*
* Need a single mapped page for populating bootmem_region_list
* and enough mapped pages for copying the DTB.
*/
dtb_pages = (dtb_size + PAGE_SIZE-1) >> PAGE_SHIFT;
boot_mfn_start = xenheap_mfn_end - dtb_pages - 1;
boot_mfn_end = xenheap_mfn_end;
init_boot_pages(pfn_to_paddr(boot_mfn_start), pfn_to_paddr(boot_mfn_end));
/* Copy the DTB. */
fdt = mfn_to_virt(alloc_boot_pages(dtb_pages, 1));
copy_from_paddr(fdt, dtb_paddr, dtb_size);
device_tree_flattened = fdt;
/* Add non-xenheap memory */
for ( i = 0; i < bootinfo.mem.nr_banks; i++ )
{
paddr_t bank_start = bootinfo.mem.bank[i].start;
paddr_t bank_end = bank_start + bootinfo.mem.bank[i].size;
s = bank_start;
while ( s < bank_end )
{
paddr_t n = bank_end;
e = next_module(s, &n);
if ( e == ~(paddr_t)0 )
{
e = n = ram_end;
}
/*
* Module in a RAM bank other than the one which we are
* not dealing with here.
*/
if ( e > bank_end )
e = bank_end;
/* Avoid the xenheap */
if ( s < pfn_to_paddr(xenheap_mfn_start+xenheap_pages)
&& pfn_to_paddr(xenheap_mfn_start) < e )
{
e = pfn_to_paddr(xenheap_mfn_start);
n = pfn_to_paddr(xenheap_mfn_start+xenheap_pages);
}
dt_unreserved_regions(s, e, init_boot_pages, 0);
s = n;
}
}
/* Frame table covers all of RAM region, including holes */
setup_frametable_mappings(ram_start, ram_end);
max_page = PFN_DOWN(ram_end);
/* Add xenheap memory that was not already added to the boot
allocator. */
init_xenheap_pages(pfn_to_paddr(xenheap_mfn_start),
pfn_to_paddr(boot_mfn_start));
}
