// return current resident set size in bytes
void get_memory_usage(size_t & now, size_t & hwm)
{
#if defined (PROCFS)
std::string vmhwm;
std::string vmrss;
std::string line(128,'\0');
now = 0;
hwm = 0;
/* Read memory size data from /proc/pid/status
* run "man proc" to get info on the contents of /proc/self/status
*/
std::ifstream proc_status("/proc/self/status");
if (!proc_status) return;
while (vmhwm.empty() || vmrss.empty())
{
if(!std::getline(proc_status, line)) return;
/* Find VmHWM */
else if (line.substr(0, 6) == "VmHWM:")
{
vmhwm = line.substr(7);
std::istringstream iss(vmhwm);
iss >> hwm;
hwm *= 1024;
}
/* Find VmRSS */
else if (line.substr(0, 6) == "VmRSS:")
//uint64_t exception_stack;
void start(uint32_t* modulep, void* physbase, void* physfree)
{
uint64_t address = (uint64_t)(&idt);
uint16_t size_idt = (uint16_t)(sizeof(idt));
int my_variable = 0;
// int i = 922222895;
//int i =0;
struct smap_t {
uint64_t base, length;
uint32_t type;
}__attribute__((packed)) *smap;
struct process *newproc1,*newproc2,*newproc3;
cls();
// while(--i>0);
while(modulep[0] != 0x9001) modulep += modulep[1]+2;
for(smap = (struct smap_t*)(modulep+2); smap < (struct smap_t*)((char*)modulep+modulep[1]+2*4); ++smap) {
if (smap->type == 1 /* memory */ && smap->length != 0) {
kprintf("Available Physical Memory [%x-%x]\n", smap->base, smap->base + smap->length);
}
}
kprintf("tarfs in [%p:%p]\n", &_binary_tarfs_start, &_binary_tarfs_end);
set_all_handlers();
setup_idtr(address,size_idt);
npages_determine(134205440);
set_consts((uint64_t)physbase,(uint64_t)physfree);
mm_init();
loadcr3(katopa((uint64_t)pml4e),(uint64_t)physbase,(uint64_t)physfree);
my_variable++;
newproc1 = (struct process*)process_setup((uint64_t)physbase,(uint64_t)physfree,"bin/newhello");
curproc_count++;
newproc2 = process_setup((uint64_t)physbase,(uint64_t)physfree,"bin/sacrifice");
curproc_count++;
newproc3 = process_setup((uint64_t)physbase,(uint64_t)physfree,"bin/pragathi");
proc_status(newproc1);
proc_status(newproc2);
proc_status(newproc3);
cur_proc = newproc1;
/*while(i<10000)
{
kmalloc(30);
i++;
}*/
exception_stack = page_alloc();
first_sched();
while(1){}
}
void proc_parser(t_proc *proc, char *path, t_task *task, t_taupe *t)
{
(task->overall)++;
proc_status(proc, path, task);
proc_stat(proc, path, t->old);
proc_statm(proc, path, t->mem);
if (proc->status == 'S')
(task->sleep)++;
else if (proc->status == 'R')
(task->run)++;
else if (proc->status == 'Z')
(task->zombie)++;
else if (proc->status == 'T')
(task->stop)++;
}
/*
--------------------------------------------------
void mpLoad(STRING *scan_path, STRING *scan_ext)
Desc:
Returns: -
--------------------------------------------------
*/
void mpLoad(STRING *scan_path, STRING *scan_ext) {
WriteLog("[ ] Scanning for external music...");
STRING *_scan_path = str_create(scan_path); // Prevent modification of the original string
mpSongs = txt_for_dir(mpPool, str_cat(_scan_path,scan_ext) );
while(proc_status(txt_for_dir)) wait(1);
str_remove(_scan_path);
WriteLog(", found " , (var) mpSongs ); //
WriteLog(" tracks.");
NewLine();
WriteLog("[X] Task completed.");
NewLine();
}
static ssize_t proc_read(FAR struct file *filep, FAR char *buffer,
size_t buflen)
{
FAR struct proc_file_s *procfile;
FAR struct tcb_s *tcb;
irqstate_t flags;
ssize_t ret;
fvdbg("buffer=%p buflen=%d\n", buffer, (int)buflen);
/* Recover our private data from the struct file instance */
procfile = (FAR struct proc_file_s *)filep->f_priv;
DEBUGASSERT(procfile);
/* Verify that the thread is still valid */
flags = irqsave();
tcb = sched_gettcb(procfile->pid);
if (!tcb)
{
fdbg("ERROR: PID %d is not valid\n", (int)procfile->pid);
irqrestore(flags);
return -ENODEV;
}
/* Provide the requested data */
switch (procfile->node->node)
{
case PROC_STATUS: /* Task/thread status */
ret = proc_status(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_CMDLINE: /* Task command line */
ret = proc_cmdline(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#ifdef CONFIG_SCHED_CPULOAD
case PROC_LOADAVG: /* Average CPU utilization */
ret = proc_loadavg(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#endif
case PROC_STACK: /* Task stack info */
ret = proc_stack(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_GROUP_STATUS: /* Task group status */
ret = proc_groupstatus(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_GROUP_FD: /* Group file descriptors */
ret = proc_groupfd(procfile, tcb, buffer, buflen, filep->f_pos);
break;
default:
ret = -EINVAL;
break;
}
irqrestore(flags);
/* Update the file offset */
if (ret > 0)
{
filep->f_pos += ret;
}
return ret;
}
static int procmgr_handler(message_context_t *mctp, int code, unsigned flags, void *handle) {
int n = ENOSYS;
resmgr_context_t *ctp = (resmgr_context_t *) mctp;
union proc_msg_union_local {
uint16_t type;
proc_getsetid_t getsetid;
proc_setpgid_t setpgid;
proc_wait_t wait;
proc_fork_t fork;
proc_umask_t umask;
proc_guardian_t guardian;
proc_session_t session;
proc_daemon_t daemon;
proc_event_t event;
sys_conf_t conf;
sys_cmd_t syscmd;
} *msg = (union proc_msg_union_local *)(void *) ctp->msg;
ctp->status = 0;
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
ENDIAN_SWAP16(&msg->type);
}
switch(msg->type) {
case _PROC_GETSETID:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_getsetid(ctp, &msg->getsetid);
}
break;
case _PROC_SETPGID:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_setpgid(ctp, &msg->setpgid);
}
break;
case _PROC_WAIT:
n = procmgr_wait(ctp, &msg->wait);
break;
case _PROC_FORK:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_fork(ctp, &msg->fork);
}
break;
case _PROC_SPAWN:
n = procmgr_spawn(ctp, msg, NULL);
break;
case _PROC_POSIX_SPAWN:
n = procmgr_pspawn(ctp, msg);
break;
case _PROC_UMASK:
n = procmgr_umask(ctp, &msg->umask);
break;
case _PROC_GUARDIAN:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_guardian(ctp, &msg->guardian);
}
break;
case _PROC_SESSION:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_session(ctp, &msg->session);
}
break;
case _PROC_DAEMON:
n = procmgr_msg_daemon(ctp, &msg->daemon);
break;
case _PROC_EVENT:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_event(ctp, &msg->event);
}
break;
case _PROC_RESOURCE:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_resource(ctp, msg);
}
break;
case _SYS_CONF:
n = sysmgr_conf(ctp, &msg->conf);
break;
case _SYS_CMD:
n = sysmgr_cmd(ctp, &msg->syscmd);
break;
case _SYS_VENDOR:
if ( sys_vendor_handler_hook ) {
n = sys_vendor_handler_hook(ctp);
}
break;
default:
break;
}
return proc_status(ctp, n);
}
static ssize_t proc_read(FAR struct file *filep, FAR char *buffer,
size_t buflen)
{
FAR struct proc_file_s *procfile;
FAR struct tcb_s *tcb;
irqstate_t flags;
ssize_t ret;
finfo("buffer=%p buflen=%d\n", buffer, (int)buflen);
/* Recover our private data from the struct file instance */
procfile = (FAR struct proc_file_s *)filep->f_priv;
DEBUGASSERT(procfile != NULL);
/* Verify that the thread is still valid */
flags = enter_critical_section();
tcb = sched_gettcb(procfile->pid);
if (tcb == NULL)
{
ferr("ERROR: PID %d is not valid\n", (int)procfile->pid);
leave_critical_section(flags);
return -ENODEV;
}
/* Provide the requested data */
switch (procfile->node->node)
{
case PROC_STATUS: /* Task/thread status */
ret = proc_status(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_CMDLINE: /* Task command line */
ret = proc_cmdline(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#ifdef CONFIG_SCHED_CPULOAD
case PROC_LOADAVG: /* Average CPU utilization */
ret = proc_loadavg(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#endif
case PROC_STACK: /* Task stack info */
ret = proc_stack(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_GROUP_STATUS: /* Task group status */
ret = proc_groupstatus(procfile, tcb, buffer, buflen, filep->f_pos);
break;
case PROC_GROUP_FD: /* Group file descriptors */
ret = proc_groupfd(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#if !defined(CONFIG_DISABLE_ENVIRON) && !defined(CONFIG_FS_PROCFS_EXCLUDE_ENVIRON)
case PROC_GROUP_ENV: /* Group environment variables */
ret = proc_groupenv(procfile, tcb, buffer, buflen, filep->f_pos);
break;
#endif
default:
ret = -EINVAL;
break;
}
leave_critical_section(flags);
/* Update the file offset */
if (ret > 0)
{
filep->f_pos += ret;
}
return ret;
}
