static ssize_t drop_caches_store
(struct device *dev, struct device_attribute *attr,\
const char *buf, size_t size)
{
struct sysinfo i;
if (strlen(buf) > 2)
goto out;
if (buf[0] == '3') {
si_meminfo(&i);
printk("[Before]\nMemFree : %8lu kB\n", K(i.freeram));
printk("Cached : %8lu kB\n\n", K(global_page_state(NR_FILE_PAGES) - \
total_swapcache_pages - i.bufferram));
iterate_supers(drop_pagecache_sb, NULL);
drop_slab();
si_meminfo(&i);
printk("[After]\nMemFree : %8lu kB\n", K(i.freeram));
printk("Cached : %8lu kB\n\n", K(global_page_state(NR_FILE_PAGES) - \
total_swapcache_pages - i.bufferram));
printk("Cached Drop done!\n");
}
out:
return size;
}
int nvmap_page_pool_init(struct nvmap_page_pool *pool, int flags)
{
int i;
int err;
struct page *page;
static int reg = 1;
struct sysinfo info;
int highmem_pages = 0;
typedef int (*set_pages_array) (struct page **pages, int addrinarray);
set_pages_array s_cpa[] = {
set_pages_array_uc,
set_pages_array_wc,
set_pages_array_iwb,
set_pages_array_wb
};
BUG_ON(flags >= NVMAP_NUM_POOLS);
memset(pool, 0x0, sizeof(*pool));
mutex_init(&pool->lock);
pool->flags = flags;
/* No default pool for cached memory. */
if (flags == NVMAP_HANDLE_CACHEABLE)
return 0;
si_meminfo(&info);
if (!pool_size[flags] && !CONFIG_NVMAP_PAGE_POOL_SIZE)
/* Use 3/8th of total ram for page pools.
* 1/8th for uc, 1/8th for wc and 1/8th for iwb.
*/
pool->max_pages = info.totalram >> 3;
else
static unsigned int update_balloon_stats(struct virtio_balloon *vb)
{
unsigned long events[NR_VM_EVENT_ITEMS];
struct sysinfo i;
unsigned int idx = 0;
long available;
all_vm_events(events);
si_meminfo(&i);
available = si_mem_available();
#ifdef CONFIG_VM_EVENT_COUNTERS
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
pages_to_bytes(events[PSWPIN]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
pages_to_bytes(events[PSWPOUT]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
#endif
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
pages_to_bytes(i.freeram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
pages_to_bytes(i.totalram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_AVAIL,
pages_to_bytes(available));
return idx;
}
void* random_pointer() {
struct sysinfo si;
si_meminfo(&si);
void* ptr = si.totalram << PAGE_SHIFT;
ptr = ((long)frandom() % (unsigned long)(ptr-33554432))+33554432; //as in, 0x2000000 in hex. Seems to work as an offset.
return ptr;
}
// Must be run in a work queue as the kernel function si_meminfo() can sleep
static void wq_sched_handler(struct work_struct *wsptr)
{
struct sysinfo info;
int i, len;
unsigned long long value;
meminfo_length = len = 0;
si_meminfo(&info);
for (i = 0; i < MEMINFO_TOTAL; i++) {
if (meminfo_enabled[i]) {
switch (i) {
case MEMINFO_MEMFREE:
value = info.freeram * PAGE_SIZE;
break;
case MEMINFO_MEMUSED:
value = (info.totalram - info.freeram) * PAGE_SIZE;
break;
case MEMINFO_BUFFERRAM:
value = info.bufferram * PAGE_SIZE;
break;
default:
value = 0;
break;
}
meminfo_buffer[len++] = (unsigned long long)meminfo_key[i];
meminfo_buffer[len++] = value;
}
}
meminfo_length = len;
new_data_avail = true;
}
static int get_meminfo(char * buffer)
{
struct sysinfo i;
int len;
si_meminfo(&i);
si_swapinfo(&i);
len = sprintf(buffer, " total: used: free: shared: buffers: cached:\n"
"Mem: %8lu %8lu %8lu %8lu %8lu %8lu\n"
"Swap: %8lu %8lu %8lu\n",
i.totalram, i.totalram-i.freeram, i.freeram, i.sharedram, i.bufferram, page_cache_size*PAGE_SIZE,
i.totalswap, i.totalswap-i.freeswap, i.freeswap);
/*
* Tagged format, for easy grepping and expansion. The above will go away
* eventually, once the tools have been updated.
*/
return len + sprintf(buffer+len,
"MemTotal: %8lu kB\n"
"MemFree: %8lu kB\n"
"MemShared: %8lu kB\n"
"Buffers: %8lu kB\n"
"Cached: %8lu kB\n"
"SwapTotal: %8lu kB\n"
"SwapFree: %8lu kB\n",
i.totalram >> 10,
i.freeram >> 10,
i.sharedram >> 10,
i.bufferram >> 10,
page_cache_size << (PAGE_SHIFT - 10),
i.totalswap >> 10,
i.freeswap >> 10);
}
asmlinkage int sys_sysinfo(struct sysinfo *info)
{
int error;
struct sysinfo val;
error = verify_area(VERIFY_WRITE, info, sizeof(struct sysinfo));
if (error)
return error;
memset((char *)&val, 0, sizeof(struct sysinfo));
val.uptime = jiffies / HZ;
#ifdef CONFIG_OSFMACH3
osfmach3_update_load_info();
#endif /* CONFIG_OSFMACH3 */
val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
val.procs = nr_tasks-1;
si_meminfo(&val);
si_swapinfo(&val);
memcpy_tofs(info, &val, sizeof(struct sysinfo));
return 0;
}
int sys_sysinfo(struct sysinfo *info)
{
int error;
struct sysinfo val;
struct task_struct **p;
error = verify_area(VERIFY_WRITE, info, sizeof(struct sysinfo));
if (error)
return error;
memset((char *)&val, 0, sizeof(struct sysinfo));
val.uptime = (jiffies + jiffies_offset) / HZ;
val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
for (p = &LAST_TASK; p > &FIRST_TASK; p--)
if (*p) val.procs++;
si_meminfo(&val);
si_swapinfo(&val);
memcpy_tofs(info, &val, sizeof(struct sysinfo));
return 0;
}
void get_total_ram(void)
{
struct sysinfo i = {};
si_meminfo(&i);
//si_swapinfo(&i);
brick_global_memavail = (long long)i.totalram * (PAGE_SIZE / 1024);
BRICK_INF("total RAM = %lld [KiB]\n", brick_global_memavail);
}
static void mod_sysstat_timer_handler(unsigned long data){
int num_cpu;
int i;
struct sysinfo info;
long cached, shmem;
struct timespec tv;
struct sysinfo_snapshot *new_ent;
/* get info */
si_meminfo(&info);
((void (*)(struct sysinfo *))ADDR_SI_SWAPINFO)(&info);
cached = global_page_state(NR_FILE_PAGES) - ((unsigned long (*)())ADDR_TOTAL_SWAPCACHE_PAGES)() - info.bufferram;
if(cached < 0)
cached = 0;
/* shared memory */
shmem = global_page_state(NR_SHMEM);
getnstimeofday(&tv);
/* count cpu */
num_cpu = 0;
for_each_online_cpu(i)
num_cpu++;
new_ent = new_snapshot(num_cpu);
if(new_ent == NULL){
print_msg("Ooops! kmalloc() fail");
mod_timer(&timer_mod_sysstat, get_jiffies_64() + (period_in_msecs*HZ)/1000);
return;
}
new_ent->epoch_time = tv.tv_sec;
new_ent->total_ram = info.totalram;
new_ent->free_ram = info.freeram;
new_ent->cached_ram = cached;
new_ent->buffer_ram = info.bufferram;
new_ent->total_swap = info.totalswap;
new_ent->free_swap = info.freeswap;
new_ent->shared_ram = shmem;
for(i = 0; i < num_cpu; i++){
new_ent->cpuinfo_list[i].user = cputime64_to_clock_t(kcpustat_cpu(i).cpustat[CPUTIME_USER]);
new_ent->cpuinfo_list[i].nice = cputime64_to_clock_t(kcpustat_cpu(i).cpustat[CPUTIME_NICE]);
new_ent->cpuinfo_list[i].system = cputime64_to_clock_t(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]);
new_ent->cpuinfo_list[i].idle = cputime64_to_clock_t(((cputime64_t (*)())ADDR_GET_IDLE_TIME)(i));
new_ent->cpuinfo_list[i].iowait = cputime64_to_clock_t(((cputime64_t (*)())ADDR_IOWAIT_TIME)(i));
new_ent->cpuinfo_list[i].irq = cputime64_to_clock_t(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]);
new_ent->cpuinfo_list[i].softirq = cputime64_to_clock_t(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]);
}
new_ent->next = NULL;
insert_sysinfo_snapshot(new_ent);
mod_timer(&timer_mod_sysstat, get_jiffies_64() + (period_in_msecs*HZ)/1000);
}
static int _phymem_dist_proc_show(struct seq_file *m, void *v)
{
struct sysinfo sys_info;
int node, i, pfn = 0, linux_total_size = 0;
struct meminfo *mi = &meminfo;
long cached;
long kernelmem;
struct vmalloc_info vmi;
unsigned long pages[NR_LRU_LISTS];
int lru;
for_each_bank (i,mi) {
struct membank *bank = &mi->bank[i];
unsigned int pfn1, pfn2;
linux_total_size += bank->size;
pfn = bank_pfn_end(bank);
}
si_meminfo(&sys_info);
si_swapinfo(&sys_info);
cached = global_page_state(NR_FILE_PAGES) -
total_swapcache_pages() - sys_info.bufferram;
if (cached < 0)
cached = 0;
for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)
pages[lru] = global_page_state(NR_LRU_BASE + lru);
kernelmem = K(sys_info.totalram - sys_info.freeram - sys_info.bufferram - pages[LRU_ACTIVE_ANON] \
- pages[LRU_INACTIVE_ANON] - cached - total_swapcache_pages());
get_vmalloc_info(&vmi);
seq_printf(m, "mem: %lukB\n", pfn*4);
seq_printf(m, " |--mem_other: %lukB\n", pfn*4 - linux_total_size/1024);
seq_printf(m, " |--mem_linux: %lukB\n", linux_total_size/1024);
seq_printf(m, " |--reserved: %lukB\n", linux_total_size/1024 - K(sys_info.totalram));
seq_printf(m, " |--mem_total: %lukB\n", K(sys_info.totalram));
seq_printf(m, " |--free: %lukB\n", K(sys_info.freeram));
seq_printf(m, " |--buffer: %lukB\n", K(sys_info.bufferram));
seq_printf(m, " |--cache: %lukB\n", K(cached));
seq_printf(m, " |--swapcache: %lukB\n", K(total_swapcache_pages()));
seq_printf(m, " |--user: %lukB\n", K(pages[LRU_ACTIVE_ANON] + pages[LRU_INACTIVE_ANON]));
seq_printf(m, " | |--active anon: %lukB\n", K(pages[LRU_ACTIVE_ANON]));
seq_printf(m, " | |--inactive anon: %lukB\n", K(pages[LRU_INACTIVE_ANON]));
seq_printf(m, " |--kernel: %lukB\n", kernelmem);
seq_printf(m, " |--stack: %lukB\n", global_page_state(NR_KERNEL_STACK) * THREAD_SIZE / 1024);
seq_printf(m, " |--slab: %lukB\n", K(global_page_state(NR_SLAB_RECLAIMABLE) +global_page_state(NR_SLAB_UNRECLAIMABLE)));
seq_printf(m, " |--pagetable: %lukB\n", K(global_page_state(NR_PAGETABLE)));
seq_printf(m, " |--vmalloc: %lukB\n",
kernelmem - global_page_state(NR_KERNEL_STACK) * THREAD_SIZE / 1024 \
- K(global_page_state(NR_SLAB_RECLAIMABLE) - global_page_state(NR_SLAB_UNRECLAIMABLE)) \
-K(global_page_state(NR_PAGETABLE)));
return 0;
}
void fandango() {
int i = 0;
struct sysinfo si;
si_meminfo(&si);
void* ptr = random_pointer();
int data = (int)frandom();
printk(KERN_CRIT,"Fandango: Dancing on pointer %p (virtually %p) with the number %d\n",ptr,phys_to_virt(ptr),data);
while(i < 1024) {
*((int*)phys_to_virt(ptr++)) = (char)data; //the business end of the fandango! Chose a chunk of memory and wipe it out!
}
}
asmlinkage long sys_sysinfo(struct sysinfo *info)
{
struct sysinfo val;
memset((char *)&val, 0, sizeof(struct sysinfo));
cli();
val.uptime = jiffies / HZ;
val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
val.procs = nr_threads-1;
sti();
si_meminfo(&val);
si_swapinfo(&val);
{
/* If the sum of all the available memory (i.e. ram + swap +
* highmem) is less then can be stored in a 32 bit unsigned long
* then we can be binary compatible with 2.2.x kernels. If not,
* well, who cares since in that case 2.2.x was broken anyways...
*
* -Erik Andersen <*****@*****.**> */
unsigned long mem_total = val.totalram + val.totalswap;
if ( !(mem_total < val.totalram || mem_total < val.totalswap)) {
unsigned long mem_total2 = mem_total + val.totalhigh;
if (!(mem_total2 < mem_total || mem_total2 < val.totalhigh))
{
/* If mem_total did not overflow. Divide all memory values by
* mem_unit and set mem_unit=1. This leaves things compatible with
* 2.2.x, and also retains compatibility with earlier 2.4.x
* kernels... */
int bitcount = 0;
while (val.mem_unit > 1)
{
bitcount++;
val.mem_unit >>= 1;
}
val.totalram <<= bitcount;
val.freeram <<= bitcount;
val.sharedram <<= bitcount;
val.bufferram <<= bitcount;
val.totalswap <<= bitcount;
val.freeswap <<= bitcount;
val.totalhigh <<= bitcount;
val.freehigh <<= bitcount;
}
}
static int get_meminfo(char * buffer)
{
struct sysinfo i;
si_meminfo(&i);
si_swapinfo(&i);
return sprintf(buffer, " total: used: free: shared: buffers:\n"
"Mem: %8d %8d %8d %8d %8d\n"
"Swap: %8d %8d %8d\n",
i.totalram, i.totalram-i.freeram, i.freeram, i.sharedram, i.bufferram,
i.totalswap, i.totalswap-i.freeswap, i.freeswap);
}
int init()
{
struct sysinfo si;
int i;//for for loop
si_meminfo(&si);
printk(KERN_INFO,"Fandango module reporting for duty and ready to DANCE!\n");
//setup proc
proc_create("fandango",0666,NULL,&proc_fops);
return 0;
}
static int meminfo_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
struct sysinfo i;
int len;
int pg_size ;
/*
* display in kilobytes.
*/
#define K(x) ((x) << (PAGE_SHIFT - 10))
si_meminfo(&i);
si_swapinfo(&i);
pg_size = atomic_read(&page_cache_size) - i.bufferram ;
/*
* Tagged format, for easy grepping and expansion.
*/
len = sprintf(page,
"MemTotal: %8lu kB\n"
"MemFree: %8lu kB\n"
"MemShared: %8lu kB\n"
"Buffers: %8lu kB\n"
"Cached: %8lu kB\n"
"SwapCached: %8lu kB\n"
"Active: %8u kB\n"
"Inactive: %8u kB\n"
"HighTotal: %8lu kB\n"
"HighFree: %8lu kB\n"
"LowTotal: %8lu kB\n"
"LowFree: %8lu kB\n"
"SwapTotal: %8lu kB\n"
"SwapFree: %8lu kB\n",
K(i.totalram),
K(i.freeram),
K(i.sharedram),
K(i.bufferram),
K(pg_size - swapper_space.nrpages),
K(swapper_space.nrpages),
K(nr_active_pages),
K(nr_inactive_pages),
K(i.totalhigh),
K(i.freehigh),
K(i.totalram-i.totalhigh),
K(i.freeram-i.freehigh),
K(i.totalswap),
K(i.freeswap));
return proc_calc_metrics(page, start, off, count, eof, len);
#undef K
}
asmlinkage int solaris_sysconf(int id)
{
switch (id) {
case SOLARIS_CONFIG_NGROUPS: return NGROUPS_MAX;
case SOLARIS_CONFIG_CHILD_MAX:
return current->signal->rlim[RLIMIT_NPROC].rlim_cur;
case SOLARIS_CONFIG_OPEN_FILES:
return current->signal->rlim[RLIMIT_NOFILE].rlim_cur;
case SOLARIS_CONFIG_POSIX_VER: return 199309;
case SOLARIS_CONFIG_PAGESIZE: return PAGE_SIZE;
case SOLARIS_CONFIG_XOPEN_VER: return 3;
case SOLARIS_CONFIG_CLK_TCK:
case SOLARIS_CONFIG_PROF_TCK:
return sparc64_get_clock_tick(smp_processor_id());
#ifdef CONFIG_SMP
case SOLARIS_CONFIG_NPROC_CONF: return NR_CPUS;
case SOLARIS_CONFIG_NPROC_ONLN: return num_online_cpus();
#else
case SOLARIS_CONFIG_NPROC_CONF: return 1;
case SOLARIS_CONFIG_NPROC_ONLN: return 1;
#endif
case SOLARIS_CONFIG_SIGRT_MIN: return 37;
case SOLARIS_CONFIG_SIGRT_MAX: return 44;
case SOLARIS_CONFIG_PHYS_PAGES:
case SOLARIS_CONFIG_AVPHYS_PAGES:
{
struct sysinfo s;
si_meminfo(&s);
if (id == SOLARIS_CONFIG_PHYS_PAGES)
return s.totalram >>= PAGE_SHIFT;
else
return s.freeram >>= PAGE_SHIFT;
}
/* XXX support these as well -jj */
case SOLARIS_CONFIG_AIO_LISTIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_AIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_AIO_PRIO_DELTA_MAX: return -EINVAL;
case SOLARIS_CONFIG_DELAYTIMER_MAX: return -EINVAL;
case SOLARIS_CONFIG_MQ_OPEN_MAX: return -EINVAL;
case SOLARIS_CONFIG_MQ_PRIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_RTSIG_MAX: return -EINVAL;
case SOLARIS_CONFIG_SEM_NSEMS_MAX: return -EINVAL;
case SOLARIS_CONFIG_SEM_VALUE_MAX: return -EINVAL;
case SOLARIS_CONFIG_SIGQUEUE_MAX: return -EINVAL;
case SOLARIS_CONFIG_TIMER_MAX: return -EINVAL;
default: return -EINVAL;
}
/*
* NAME: txInit()
*
* FUNCTION: initialize transaction management structures
*
* RETURN:
*
* serialization: single thread at jfs_init()
*/
int txInit(void)
{
int k, size;
struct sysinfo si;
/* Set defaults for nTxLock and nTxBlock if unset */
if (nTxLock == -1) {
if (nTxBlock == -1) {
/* Base default on memory size */
si_meminfo(&si);
if (si.totalram > (256 * 1024)) /* 1 GB */
nTxLock = 64 * 1024;
else
nTxLock = si.totalram >> 2;
} else if (nTxBlock > (8 * 1024))
static __init int init_emergency_pool(void)
{
struct sysinfo i;
si_meminfo(&i);
si_swapinfo(&i);
if (!i.totalhigh)
return 0;
page_pool = mempool_create(POOL_SIZE, page_pool_alloc, page_pool_free, NULL);
if (!page_pool)
BUG();
printk("highmem bounce pool size: %d pages\n", POOL_SIZE);
return 0;
}
asmlinkage int solaris_sysconf(int id)
{
switch (id) {
case SOLARIS_CONFIG_NGROUPS: return NGROUPS_MAX;
case SOLARIS_CONFIG_CHILD_MAX: return CHILD_MAX;
case SOLARIS_CONFIG_OPEN_FILES: return OPEN_MAX;
case SOLARIS_CONFIG_POSIX_VER: return 199309;
case SOLARIS_CONFIG_PAGESIZE: return PAGE_SIZE;
case SOLARIS_CONFIG_XOPEN_VER: return 3;
case SOLARIS_CONFIG_CLK_TCK:
case SOLARIS_CONFIG_PROF_TCK:
return prom_getintdefault(prom_cpu_nodes[smp_processor_id()],
"clock-frequency", 167000000);
#ifdef CONFIG_SMP
case SOLARIS_CONFIG_NPROC_CONF: return NR_CPUS;
case SOLARIS_CONFIG_NPROC_ONLN: return smp_num_cpus;
#else
case SOLARIS_CONFIG_NPROC_CONF: return 1;
case SOLARIS_CONFIG_NPROC_ONLN: return 1;
#endif
case SOLARIS_CONFIG_SIGRT_MIN: return 37;
case SOLARIS_CONFIG_SIGRT_MAX: return 44;
case SOLARIS_CONFIG_PHYS_PAGES:
case SOLARIS_CONFIG_AVPHYS_PAGES:
{
struct sysinfo s;
si_meminfo(&s);
if (id == SOLARIS_CONFIG_PHYS_PAGES)
return s.totalram >>= PAGE_SHIFT;
else
return s.freeram >>= PAGE_SHIFT;
}
/* XXX support these as well -jj */
case SOLARIS_CONFIG_AIO_LISTIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_AIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_AIO_PRIO_DELTA_MAX: return -EINVAL;
case SOLARIS_CONFIG_DELAYTIMER_MAX: return -EINVAL;
case SOLARIS_CONFIG_MQ_OPEN_MAX: return -EINVAL;
case SOLARIS_CONFIG_MQ_PRIO_MAX: return -EINVAL;
case SOLARIS_CONFIG_RTSIG_MAX: return -EINVAL;
case SOLARIS_CONFIG_SEM_NSEMS_MAX: return -EINVAL;
case SOLARIS_CONFIG_SEM_VALUE_MAX: return -EINVAL;
case SOLARIS_CONFIG_SIGQUEUE_MAX: return -EINVAL;
case SOLARIS_CONFIG_TIMER_MAX: return -EINVAL;
default: return -EINVAL;
}
/*
* appldata_get_mem_data()
*
* gather memory data
*/
static void appldata_get_mem_data(void *data)
{
/*
* don't put large structures on the stack, we are
* serialized through the appldata_ops_lock and can use static
*/
static struct sysinfo val;
unsigned long ev[NR_VM_EVENT_ITEMS];
struct appldata_mem_data *mem_data;
mem_data = data;
mem_data->sync_count_1++;
all_vm_events(ev);
mem_data->pgpgin = ev[PGPGIN] >> 1;
mem_data->pgpgout = ev[PGPGOUT] >> 1;
mem_data->pswpin = ev[PSWPIN];
mem_data->pswpout = ev[PSWPOUT];
mem_data->pgalloc = ev[PGALLOC_NORMAL];
#ifdef CONFIG_ZONE_DMA
mem_data->pgalloc += ev[PGALLOC_DMA];
#endif
mem_data->pgfault = ev[PGFAULT];
mem_data->pgmajfault = ev[PGMAJFAULT];
si_meminfo(&val);
mem_data->sharedram = val.sharedram;
mem_data->totalram = P2K(val.totalram);
mem_data->freeram = P2K(val.freeram);
mem_data->totalhigh = P2K(val.totalhigh);
mem_data->freehigh = P2K(val.freehigh);
mem_data->bufferram = P2K(val.bufferram);
mem_data->cached = P2K(global_page_state(NR_FILE_PAGES)
- val.bufferram);
si_swapinfo(&val);
mem_data->totalswap = P2K(val.totalswap);
mem_data->freeswap = P2K(val.freeswap);
mem_data->timestamp = get_clock();
mem_data->sync_count_2++;
#ifdef APPLDATA_DEBUG
appldata_debug_print(mem_data);
#endif
}
STATIC int __init
init_xfs_fs( void )
{
int error;
struct sysinfo si;
static char message[] __initdata =
KERN_INFO "SGI XFS " XFS_VERSION_STRING " with "
XFS_BUILD_OPTIONS " enabled\n";
printk(message);
si_meminfo(&si);
xfs_physmem = si.totalram;
error = init_inodecache();
if (error < 0)
goto undo_inodecache;
error = pagebuf_init();
if (error < 0)
goto undo_pagebuf;
vn_init();
xfs_init();
uuid_init();
vfs_initdmapi();
vfs_initquota();
error = register_filesystem(&xfs_fs_type);
if (error)
goto undo_register;
return 0;
undo_register:
pagebuf_terminate();
undo_pagebuf:
destroy_inodecache();
undo_inodecache:
return error;
}
/*
* appldata_get_mem_data()
*
* gather memory data
*/
static void appldata_get_mem_data(void *data)
{
/*
* don't put large structures on the stack, we are
* serialized through the appldata_ops_lock and can use static
*/
static struct sysinfo val;
static struct page_state ps;
struct appldata_mem_data *mem_data;
mem_data = data;
mem_data->sync_count_1++;
get_full_page_state(&ps);
mem_data->pgpgin = ps.pgpgin >> 1;
mem_data->pgpgout = ps.pgpgout >> 1;
mem_data->pswpin = ps.pswpin;
mem_data->pswpout = ps.pswpout;
mem_data->pgalloc = ps.pgalloc_high + ps.pgalloc_normal +
ps.pgalloc_dma;
mem_data->pgfault = ps.pgfault;
mem_data->pgmajfault = ps.pgmajfault;
si_meminfo(&val);
mem_data->sharedram = val.sharedram;
mem_data->totalram = P2K(val.totalram);
mem_data->freeram = P2K(val.freeram);
mem_data->totalhigh = P2K(val.totalhigh);
mem_data->freehigh = P2K(val.freehigh);
mem_data->bufferram = P2K(val.bufferram);
mem_data->cached = P2K(atomic_read(&nr_pagecache) - val.bufferram);
si_swapinfo(&val);
mem_data->totalswap = P2K(val.totalswap);
mem_data->freeswap = P2K(val.freeswap);
mem_data->timestamp = get_clock();
mem_data->sync_count_2++;
#ifdef APPLDATA_DEBUG
appldata_debug_print(mem_data);
#endif
}
static void update_balloon_stats(struct virtio_balloon *vb)
{
unsigned long events[NR_VM_EVENT_ITEMS];
struct sysinfo i;
int idx = 0;
all_vm_events(events);
si_meminfo(&i);
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
pages_to_bytes(events[PSWPIN]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
pages_to_bytes(events[PSWPOUT]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
pages_to_bytes(i.freeram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
pages_to_bytes(i.totalram));
}
static void do_read(void)
{
struct sysinfo info;
int i, len;
unsigned long long value;
meminfo_length = len = 0;
si_meminfo(&info);
for (i = 0; i < MEMINFO_TOTAL; i++) {
if (meminfo_enabled[i]) {
switch (i) {
case MEMINFO_MEMFREE:
value = info.freeram * PAGE_SIZE;
break;
case MEMINFO_MEMUSED:
/* pid -1 means system wide */
meminfo_buffer[len++] = 1;
meminfo_buffer[len++] = -1;
/* Emit value */
meminfo_buffer[len++] = meminfo_keys[MEMINFO_MEMUSED];
meminfo_buffer[len++] = (info.totalram - info.freeram) * PAGE_SIZE;
/* Clear pid */
meminfo_buffer[len++] = 1;
meminfo_buffer[len++] = 0;
continue;
case MEMINFO_BUFFERRAM:
value = info.bufferram * PAGE_SIZE;
break;
default:
value = 0;
break;
}
meminfo_buffer[len++] = meminfo_keys[i];
meminfo_buffer[len++] = value;
}
}
meminfo_length = len;
new_data_avail = true;
}
asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info)
{
struct sysinfo val;
int err;
unsigned long seq;
/* We don't need a memset here because we copy the
* struct to userspace once element at a time.
*/
do {
seq = read_seqbegin(&xtime_lock);
val.uptime = jiffies / HZ;
val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
val.procs = nr_threads;
} while (read_seqretry(&xtime_lock, seq));
si_meminfo(&val);
si_swapinfo(&val);
err = put_user (val.uptime, &info->uptime);
err |= __put_user (val.loads[0], &info->loads[0]);
err |= __put_user (val.loads[1], &info->loads[1]);
err |= __put_user (val.loads[2], &info->loads[2]);
err |= __put_user (val.totalram, &info->totalram);
err |= __put_user (val.freeram, &info->freeram);
err |= __put_user (val.sharedram, &info->sharedram);
err |= __put_user (val.bufferram, &info->bufferram);
err |= __put_user (val.totalswap, &info->totalswap);
err |= __put_user (val.freeswap, &info->freeswap);
err |= __put_user (val.procs, &info->procs);
err |= __put_user (val.totalhigh, &info->totalhigh);
err |= __put_user (val.freehigh, &info->freehigh);
err |= __put_user (val.mem_unit, &info->mem_unit);
return err ? -EFAULT : 0;
}
int amdgpu_amdkfd_init(void)
{
struct sysinfo si;
int ret;
si_meminfo(&si);
amdgpu_amdkfd_total_mem_size = si.totalram - si.totalhigh;
amdgpu_amdkfd_total_mem_size *= si.mem_unit;
#ifdef CONFIG_HSA_AMD
ret = kgd2kfd_init(KFD_INTERFACE_VERSION, &kgd2kfd);
if (ret)
kgd2kfd = NULL;
amdgpu_amdkfd_gpuvm_init_mem_limits();
#else
kgd2kfd = NULL;
ret = -ENOENT;
#endif
return ret;
}
static unsigned int update_balloon_stats(struct virtio_balloon *vb)
{
unsigned long events[NR_VM_EVENT_ITEMS];
struct sysinfo i;
unsigned int idx = 0;
long available;
unsigned long caches;
all_vm_events(events);
si_meminfo(&i);
available = si_mem_available();
caches = global_node_page_state(NR_FILE_PAGES);
#ifdef CONFIG_VM_EVENT_COUNTERS
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
pages_to_bytes(events[PSWPIN]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
pages_to_bytes(events[PSWPOUT]));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
#ifdef CONFIG_HUGETLB_PAGE
update_stat(vb, idx++, VIRTIO_BALLOON_S_HTLB_PGALLOC,
events[HTLB_BUDDY_PGALLOC]);
update_stat(vb, idx++, VIRTIO_BALLOON_S_HTLB_PGFAIL,
events[HTLB_BUDDY_PGALLOC_FAIL]);
#endif
#endif
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
pages_to_bytes(i.freeram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
pages_to_bytes(i.totalram));
update_stat(vb, idx++, VIRTIO_BALLOON_S_AVAIL,
pages_to_bytes(available));
update_stat(vb, idx++, VIRTIO_BALLOON_S_CACHES,
pages_to_bytes(caches));
return idx;
}
/*
* Scale msgmni with the available lowmem size: the memory dedicated to msg
* queues should occupy at most 1/MSG_MEM_SCALE of lowmem.
* Also take into account the number of nsproxies created so far.
* This should be done staying within the (MSGMNI , IPCMNI/nr_ipc_ns) range.
*/
void recompute_msgmni(struct ipc_namespace *ns)
{
struct sysinfo i;
unsigned long allowed;
int nb_ns;
si_meminfo(&i);
allowed = (((i.totalram - i.totalhigh) / MSG_MEM_SCALE) * i.mem_unit)
/ MSGMNB;
nb_ns = atomic_read(&nr_ipc_ns);
allowed /= nb_ns;
if (allowed < MSGMNI) {
ns->msg_ctlmni = MSGMNI;
return;
}
if (allowed > IPCMNI / nb_ns) {
ns->msg_ctlmni = IPCMNI / nb_ns;
return;
}
ns->msg_ctlmni = allowed;
}
static int meminfo_proc_show(struct seq_file *m, void *v)
{
struct sysinfo i;
unsigned long committed;
unsigned long allowed;
struct vmalloc_info vmi;
long cached;
unsigned long pages[NR_LRU_LISTS];
int lru;
/*
* display in kilobytes.
*/
#define K(x) ((x) << (PAGE_SHIFT - 10))
si_meminfo(&i);
si_swapinfo(&i);
committed = percpu_counter_read_positive(&vm_committed_as);
allowed = ((totalram_pages - hugetlb_total_pages())
* sysctl_overcommit_ratio / 100) + total_swap_pages;
cached = global_page_state(NR_FILE_PAGES) -
total_swapcache_pages - i.bufferram;
if (cached < 0)
cached = 0;
get_vmalloc_info(&vmi);
for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)
pages[lru] = global_page_state(NR_LRU_BASE + lru);
/*
* Tagged format, for easy grepping and expansion.
*/
seq_printf(m,
"MemTotal: %8lu kB\n"
"MemFree: %8lu kB\n"
"Buffers: %8lu kB\n"
"Cached: %8lu kB\n"
"SwapCached: %8lu kB\n"
"Active: %8lu kB\n"
"Inactive: %8lu kB\n"
"Active(anon): %8lu kB\n"
"Inactive(anon): %8lu kB\n"
"Active(file): %8lu kB\n"
"Inactive(file): %8lu kB\n"
"Unevictable: %8lu kB\n"
"Mlocked: %8lu kB\n"
#ifdef CONFIG_HIGHMEM
"HighTotal: %8lu kB\n"
"HighFree: %8lu kB\n"
"LowTotal: %8lu kB\n"
"LowFree: %8lu kB\n"
#endif
#ifndef CONFIG_MMU
"MmapCopy: %8lu kB\n"
#endif
"SwapTotal: %8lu kB\n"
"SwapFree: %8lu kB\n"
"Dirty: %8lu kB\n"
"Writeback: %8lu kB\n"
"AnonPages: %8lu kB\n"
"Mapped: %8lu kB\n"
"Shmem: %8lu kB\n"
"Slab: %8lu kB\n"
"SReclaimable: %8lu kB\n"
"SUnreclaim: %8lu kB\n"
"KernelStack: %8lu kB\n"
"PageTables: %8lu kB\n"
#ifdef CONFIG_QUICKLIST
"Quicklists: %8lu kB\n"
#endif
"NFS_Unstable: %8lu kB\n"
"Bounce: %8lu kB\n"
"WritebackTmp: %8lu kB\n"
"CommitLimit: %8lu kB\n"
"Committed_AS: %8lu kB\n"
"VmallocTotal: %8lu kB\n"
"VmallocUsed: %8lu kB\n"
"VmallocChunk: %8lu kB\n"
#ifdef CONFIG_MEMORY_FAILURE
"HardwareCorrupted: %5lu kB\n"
#endif
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
"AnonHugePages: %8lu kB\n"
#endif
,
((K(i.totalram) < 524288)&&(K(i.totalram) > 262144)) ? 524288 : K(i.totalram),
K(i.freeram),
K(i.bufferram),
K(cached),
K(total_swapcache_pages),
K(pages[LRU_ACTIVE_ANON] + pages[LRU_ACTIVE_FILE]),
K(pages[LRU_INACTIVE_ANON] + pages[LRU_INACTIVE_FILE]),
K(pages[LRU_ACTIVE_ANON]),
K(pages[LRU_INACTIVE_ANON]),
K(pages[LRU_ACTIVE_FILE]),
K(pages[LRU_INACTIVE_FILE]),
K(pages[LRU_UNEVICTABLE]),
K(global_page_state(NR_MLOCK)),
#ifdef CONFIG_HIGHMEM
K(i.totalhigh),
K(i.freehigh),
K(i.totalram-i.totalhigh),
K(i.freeram-i.freehigh),
#endif
#ifndef CONFIG_MMU
K((unsigned long) atomic_long_read(&mmap_pages_allocated)),
#endif
K(i.totalswap),
K(i.freeswap),
K(global_page_state(NR_FILE_DIRTY)),
K(global_page_state(NR_WRITEBACK)),
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
K(global_page_state(NR_ANON_PAGES)
+ global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
HPAGE_PMD_NR),
#else
K(global_page_state(NR_ANON_PAGES)),
#endif
K(global_page_state(NR_FILE_MAPPED)),
K(global_page_state(NR_SHMEM)),
K(global_page_state(NR_SLAB_RECLAIMABLE) +
global_page_state(NR_SLAB_UNRECLAIMABLE)),
K(global_page_state(NR_SLAB_RECLAIMABLE)),
K(global_page_state(NR_SLAB_UNRECLAIMABLE)),
global_page_state(NR_KERNEL_STACK) * THREAD_SIZE / 1024,
K(global_page_state(NR_PAGETABLE)),
#ifdef CONFIG_QUICKLIST
K(quicklist_total_size()),
#endif
K(global_page_state(NR_UNSTABLE_NFS)),
K(global_page_state(NR_BOUNCE)),
K(global_page_state(NR_WRITEBACK_TEMP)),
K(allowed),
K(committed),
(unsigned long)VMALLOC_TOTAL >> 10,
vmi.used >> 10,
vmi.largest_chunk >> 10
#ifdef CONFIG_MEMORY_FAILURE
,atomic_long_read(&mce_bad_pages) << (PAGE_SHIFT - 10)
#endif
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
,K(global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
HPAGE_PMD_NR)
#endif
);
hugetlb_report_meminfo(m);
arch_report_meminfo(m);
return 0;
#undef K
}
