// proc_init - set up the first kernel thread idleproc "idle" by itself and
// - create the second kernel thread init_main
void
proc_init(void) {
int i;
list_init(&proc_list);
for (i = 0; i < HASH_LIST_SIZE; i ++) {
list_init(hash_list + i);
}
if ((idleproc = alloc_proc()) == NULL) {
panic("cannot alloc idleproc.\n");
}
idleproc->pid = 0;
idleproc->state = PROC_RUNNABLE;
idleproc->kstack = (uintptr_t)bootstack;
idleproc->need_resched = 1;
set_proc_name(idleproc, "idle");
nr_process ++;
current = idleproc;
int pid = kernel_thread(init_main, "Hello world!!", 0);
if (pid <= 0) {
panic("create init_main failed.\n");
}
initproc = find_proc(pid);
set_proc_name(initproc, "init");
assert(idleproc != NULL && idleproc->pid == 0);
assert(initproc != NULL && initproc->pid == 1);
}
void check_sync(void){
int i;
//check semaphore
sem_init(&mutex, 1);
for(i=0;i<N;i++){
sem_init(&s[i], 0);
int pid = kernel_thread(philosopher_using_semaphore, (void *)i, 0);
if (pid <= 0) {
panic("create No.%d philosopher_using_semaphore failed.\n");
}
philosopher_proc_sema[i] = find_proc(pid);
set_proc_name(philosopher_proc_sema[i], "philosopher_sema_proc");
}
//check condition variable
monitor_init(&mt, N);
for(i=0;i<N;i++){
state_condvar[i]=THINKING;
int pid = kernel_thread(philosopher_using_condvar, (void *)i, 0);
if (pid <= 0) {
panic("create No.%d philosopher_using_condvar failed.\n");
}
philosopher_proc_condvar[i] = find_proc(pid);
set_proc_name(philosopher_proc_condvar[i], "philosopher_condvar_proc");
}
}
// proc_init - set up the first kernel thread idleproc "idle" by itself and
// - create the second kernel thread init_main
void proc_init(void)
{
int i;
int cpuid = myid();
struct proc_struct *idle;
spinlock_init(&proc_lock);
list_init(&proc_list);
list_init(&proc_mm_list);
for (i = 0; i < HASH_LIST_SIZE; i++) {
list_init(hash_list + i);
}
idle = alloc_proc();
if (idle == NULL) {
panic("cannot alloc idleproc.\n");
}
idle->pid = cpuid;
idle->state = PROC_RUNNABLE;
// No need to be set for kthread (no privilege switch)
// idleproc->kstack = (uintptr_t)bootstack;
idle->need_resched = 1;
idle->tf = NULL;
if ((idle->fs_struct = fs_create()) == NULL) {
panic("create fs_struct (idleproc) failed.\n");
}
fs_count_inc(idle->fs_struct);
char namebuf[32];
snprintf(namebuf, 32, "idle/%d", cpuid);
set_proc_name(idle, namebuf);
nr_process++;
idleproc = idle;
current = idle;
int pid = ucore_kernel_thread(init_main, NULL, 0);
if (pid <= 0) {
panic("create init_main failed.\n");
}
initproc = find_proc(pid);
set_proc_name(initproc, "kinit");
char *proc_init="Proc init OK";
assert(idleproc != NULL && idleproc->pid == cpuid);
assert(initproc != NULL && initproc->pid == sysconf.lcpu_count);
}
// proc_init - set up the first kernel thread idleproc "idle" by itself and
// - create the second kernel thread init_main
void
proc_init(void) {
int i;
int lcpu_idx = pls_read(lcpu_idx);
int lapic_id = pls_read(lapic_id);
int lcpu_count = pls_read(lcpu_count);
list_init(&proc_list);
list_init(&proc_mm_list);
for (i = 0; i < HASH_LIST_SIZE; i ++) {
list_init(hash_list + i);
}
pls_write(idleproc, alloc_proc());
if (idleproc == NULL) {
panic("cannot alloc idleproc.\n");
}
idleproc->pid = lcpu_idx;
idleproc->state = PROC_RUNNABLE;
// XXX
// idleproc->kstack = (uintptr_t)bootstack;
idleproc->need_resched = 1;
idleproc->tf = NULL;
if ((idleproc->fs_struct = fs_create()) == NULL) {
panic("create fs_struct (idleproc) failed.\n");
}
fs_count_inc(idleproc->fs_struct);
char namebuf[32];
snprintf(namebuf, 32, "idle/%d", lapic_id);
set_proc_name(idleproc, namebuf);
nr_process ++;
pls_write(current, idleproc);
int pid = kernel_thread(init_main, NULL, 0);
if (pid <= 0) {
panic("create init_main failed.\n");
}
initproc = find_proc(pid);
set_proc_name(initproc, "init");
assert(idleproc != NULL && idleproc->pid == lcpu_idx);
assert(initproc != NULL && initproc->pid == lcpu_count);
}
void
proc_init_ap(void)
{
int lcpu_idx = pls_read(lcpu_idx);
int lapic_id = pls_read(lapic_id);
pls_write(idleproc, alloc_proc());
if (idleproc == NULL) {
panic("cannot alloc idleproc.\n");
}
idleproc->pid = lcpu_idx;
idleproc->state = PROC_RUNNABLE;
// XXX
// idleproc->kstack = (uintptr_t)bootstack;
idleproc->need_resched = 1;
idleproc->tf = NULL;
if ((idleproc->fs_struct = fs_create()) == NULL) {
panic("create fs_struct (idleproc) failed.\n");
}
fs_count_inc(idleproc->fs_struct);
char namebuf[32];
snprintf(namebuf, 32, "idle/%d", lapic_id);
set_proc_name(idleproc, namebuf);
nr_process ++;
pls_write(current, idleproc);
assert(idleproc != NULL && idleproc->pid == lcpu_idx);
}
void proc_init_ap(void)
{
int cpuid = myid();
struct proc_struct *idle;
idle = alloc_proc();
if (idle == NULL) {
panic("cannot alloc idleproc.\n");
}
idle->pid = cpuid;
idle->state = PROC_RUNNABLE;
// XXX
// idle->kstack = (uintptr_t)bootstack;
idle->need_resched = 1;
idle->tf = NULL;
if ((idle->fs_struct = fs_create()) == NULL) {
panic("create fs_struct (idleproc) failed.\n");
}
fs_count_inc(idle->fs_struct);
char namebuf[32];
snprintf(namebuf, 32, "idle/%d", cpuid);
set_proc_name(idle, namebuf);
nr_process++;
idleproc = idle;
current = idle;
assert(idleproc != NULL && idleproc->pid == cpuid);
}
sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
{
int pid = kernel_thread((kthrfunc)thread, arg, 0);
if (pid <= 0) {
panic("create tcp_ip thread failed");
}
set_proc_name(find_proc(pid), name);
return pid;
}
void proc_init_ap(void)
{
int cpuid = myid();
struct proc_struct *idle;
idle = alloc_proc();
if (idle == NULL) {
panic("cannot alloc idleproc.\n");
}
idle->pid = cpuid;
idle->state = PROC_RUNNABLE;
// No need to be set for kthread (no privilege switch)
// idle->kstack = (uintptr_t)bootstack;
idle->need_resched = 1;
idle->tf = NULL;
if ((idle->fs_struct = fs_create()) == NULL) {
panic("create fs_struct (idleproc) failed.\n");
}
fs_count_inc(idle->fs_struct);
char namebuf[32];
snprintf(namebuf, 32, "idle/%d", cpuid);
set_proc_name(idle, namebuf);
nr_process++;
idleproc = idle;
current = idle;
#if 1
int pid;
char proc_name[32];
if((pid = ucore_kernel_thread(krefcache_cleaner, NULL, 0)) <= 0){
panic("krefcache_cleaner init failed.\n");
}
struct proc_struct* cleaner = find_proc(pid);
snprintf(proc_name, 32, "krefcache/%d", myid());
set_proc_name(cleaner, proc_name);
set_proc_cpu_affinity(cleaner, myid());
nr_process++;
#endif
assert(idleproc != NULL && idleproc->pid == cpuid);
}
// proc_init - set up the first kernel thread idleproc "idle" by itself and
// - create the second kernel thread init_main
void
proc_init(void) {
int i;
list_init(&proc_list);
if ((idleproc = alloc_proc()) == NULL) {
panic("cannot alloc idleproc.\n");
}
idleproc->pid = 0;
idleproc->state = PROC_RUNNABLE;
idleproc->kstack = (uintptr_t)bootstack;
idleproc->need_resched = 1;
set_proc_name(idleproc, "idle");
nr_process ++;
current = idleproc;
int pid1 = kernel_thread(init_main, "init main1: Hello world!!", 0);
int pid2 = kernel_thread(init_main, "init main2: Hello world!!", 0);
int pid3 = kernel_thread(init_main, "init main3: Lab4 spoc discussion!!", 0);
if (pid1 <= 0 || pid2 <= 0 || pid3 <= 0) {
panic("create kernel thread init_main1 or 2 or 3 failed.\n");
}
initproc1 = find_proc(pid1);
initproc2 = find_proc(pid2);
initproc3 = find_proc(pid3);
set_proc_name(initproc1, "init1");
set_proc_name(initproc2, "init2");
set_proc_name(initproc3, "init3");
cprintf("proc_init:: Created kernel thread init_main--> pid: %d, name: %s\n", initproc1->pid, initproc1->name);
cprintf("proc_init:: Created kernel thread init_main--> pid: %d, name: %s\n", initproc2->pid, initproc2->name);
cprintf("proc_init:: Created kernel thread init_main--> pid: %d, name: %s\n", initproc3->pid, initproc3->name);
assert(idleproc != NULL && idleproc->pid == 0);
}
int
do_execve(const char *filename, const char **argv, const char **envp) {
static_assert(EXEC_MAX_ARG_LEN >= FS_MAX_FPATH_LEN);
struct mm_struct *mm = current->mm;
char local_name[PROC_NAME_LEN + 1];
memset(local_name, 0, sizeof(local_name));
char *kargv[EXEC_MAX_ARG_NUM], *kenvp[EXEC_MAX_ENV_NUM];
const char *path;
int ret = -E_INVAL;
lock_mm(mm);
#if 0
if (name == NULL) {
snprintf(local_name, sizeof(local_name), "<null> %d", current->pid);
}
else {
if (!copy_string(mm, local_name, name, sizeof(local_name))) {
unlock_mm(mm);
return ret;
}
}
#endif
snprintf(local_name, sizeof(local_name), "<null> %d", current->pid);
int argc = 0, envc = 0;
if ((ret = copy_kargv(mm, kargv, argv, EXEC_MAX_ARG_NUM, &argc)) != 0) {
unlock_mm(mm);
return ret;
}
if ((ret = copy_kargv(mm, kenvp, envp, EXEC_MAX_ENV_NUM, &envc)) != 0) {
unlock_mm(mm);
put_kargv(argc, kargv);
return ret;
}
#if 0
int i;
kprintf("## fn %s\n", filename);
kprintf("## argc %d\n", argc);
for(i=0;i<argc;i++)
kprintf("## %08x %s\n", kargv[i], kargv[i]);
kprintf("## envc %d\n", envc);
for(i=0;i<envc;i++)
kprintf("## %08x %s\n", kenvp[i], kenvp[i]);
#endif
//path = argv[0];
//copy_from_user (mm, &path, argv, sizeof (char*), 0);
path = filename;
unlock_mm(mm);
/* linux never do this */
//fs_closeall(current->fs_struct);
/* sysfile_open will check the first argument path, thus we have to use a user-space pointer, and argv[0] may be incorrect */
int fd;
if ((ret = fd = sysfile_open(path, O_RDONLY)) < 0) {
goto execve_exit;
}
if (mm != NULL) {
mm->lapic = -1;
mp_set_mm_pagetable(NULL);
if (mm_count_dec(mm) == 0) {
exit_mmap(mm);
put_pgdir(mm);
bool intr_flag;
local_intr_save(intr_flag);
{
list_del(&(mm->proc_mm_link));
}
local_intr_restore(intr_flag);
mm_destroy(mm);
}
current->mm = NULL;
}
put_sem_queue(current);
ret = -E_NO_MEM;
/* init signal */
put_sighand(current);
if ((current->signal_info.sighand = sighand_create()) == NULL) {
goto execve_exit;
}
sighand_count_inc(current->signal_info.sighand);
put_signal(current);
if ((current->signal_info.signal = signal_create()) == NULL) {
goto execve_exit;
}
signal_count_inc(current->signal_info.signal);
if ((current->sem_queue = sem_queue_create()) == NULL) {
goto execve_exit;
}
sem_queue_count_inc(current->sem_queue);
if ((ret = load_icode(fd, argc, kargv, envc, kenvp)) != 0) {
goto execve_exit;
}
set_proc_name(current, local_name);
if (do_execve_arch_hook (argc, kargv) < 0)
goto execve_exit;
put_kargv(argc, kargv);
return 0;
execve_exit:
put_kargv(argc, kargv);
put_kargv(envc, kenvp);
/* exec should return -1 if failed */
//return ret;
do_exit(ret);
panic("already exit: %e.\n", ret);
}
// init_main - the second kernel thread used to create kswapd_main & user_main kernel threads
static int
init_main(void *arg) {
int pid;
#ifndef CONFIG_NO_SWAP
if ((pid = kernel_thread(kswapd_main, NULL, 0)) <= 0) {
panic("kswapd init failed.\n");
}
kswapd = find_proc(pid);
set_proc_name(kswapd, "kswapd");
#else
#warning swapping disabled
#endif
int ret;
char root[] = "disk0:";
if ((ret = vfs_set_bootfs(root)) != 0) {
panic("set boot fs failed: %e.\n", ret);
}
size_t nr_used_pages_store = nr_used_pages();
size_t slab_allocated_store = slab_allocated();
unsigned int nr_process_store = nr_process;
pid = kernel_thread(user_main, NULL, 0);
if (pid <= 0) {
panic("create user_main failed.\n");
}
while (do_wait(0, NULL) == 0) {
if (nr_process_store == nr_process) {
break;
}
schedule();
}
#ifndef CONFIG_NO_SWAP
assert(kswapd != NULL);
int i;
for (i = 0; i < 10; i ++) {
if (kswapd->wait_state == WT_TIMER) {
wakeup_proc(kswapd);
}
schedule();
}
#endif
mbox_cleanup();
fs_cleanup();
kprintf("all user-mode processes have quit, no /bin/sh?.\n");
#ifndef CONFIG_NO_SWAP
assert(initproc->cptr == kswapd && initproc->yptr == NULL && initproc->optr == NULL);
assert(kswapd->cptr == NULL && kswapd->yptr == NULL && kswapd->optr == NULL);
assert(nr_process == 2 + pls_read(lcpu_count));
#else
assert(nr_process == 1 + pls_read(lcpu_count));
#endif
assert(nr_used_pages_store == nr_used_pages());
assert(slab_allocated_store == slab_allocated());
kprintf("init check memory pass.\n");
return 0;
}