/*
* Kill all sleeping threads. This is used during panic shutdown to make
* sure they don't wake up again and interfere with the panic.
*/
static
void
thread_killall(void)
{
int i, result;
assert(curspl>0);
/*
* Move all sleepers to the zombie list, to be sure they don't
* wake up while we're shutting down.
*/
for (i=0; i<array_getnum(sleepers); i++) {
struct thread *t = array_getguy(sleepers, i);
kprintf("sleep: Dropping thread %s\n", t->t_name);
/*
* Don't do this: because these threads haven't
* been through thread_exit, thread_destroy will
* get upset. Just drop the threads on the floor,
* which is safer anyway during panic.
*
* array_add(zombies, t);
*/
}
result = array_setsize(sleepers, 0);
/* shrinking array: not supposed to fail */
assert(result==0);
}
int
array_add(struct array *a, void *guy)
{
int ix = a->num;
if (array_setsize(a, ix+1)) {
return -1;
}
a->v[ix] = guy;
return 0;
}
int
arraytest(int nargs, char **args)
{
struct array *a;
(void)nargs;
(void)args;
kprintf("Beginning array test...\n");
a = array_create();
KASSERT(a != NULL);
testa(a);
array_setsize(a, 0);
testa(a);
array_setsize(a, 0);
array_destroy(a);
kprintf("Array test complete\n");
return 0;
}
int
array_add(struct array *a, void *guy)
{
int ix, result;
ix = a->num;
result = array_setsize(a, ix+1);
if (result) {
return result;
}
a->v[ix] = guy;
return 0;
}
static
void
commandline_macros_cleanup(void)
{
unsigned i, num;
struct commandline_macro *cm;
num = array_num(&commandline_macros);
for (i=0; i<num; i++) {
cm = array_get(&commandline_macros, i);
dofree(cm, sizeof(*cm));
}
array_setsize(&commandline_macros, 0);
array_cleanup(&commandline_macros);
}
/*
* Remove zombies. (Zombies are threads/processes that have exited but not
* been fully deleted yet.)
*/
static
void
exorcise(void)
{
int i, result;
assert(curspl>0);
for (i=0; i<array_getnum(zombies); i++) {
struct thread *z = array_getguy(zombies, i);
assert(z!=curthread);
thread_destroy(z);
}
result = array_setsize(zombies, 0);
/* Shrinking the array; not supposed to be able to fail. */
assert(result==0);
}
static
void
commandline_files_cleanup(void)
{
unsigned i, num;
struct commandline_file *cf;
num = array_num(&commandline_files);
for (i=0; i<num; i++) {
cf = array_get(&commandline_files, i);
if (cf != NULL) {
dofree(cf, sizeof(*cf));
}
}
array_setsize(&commandline_files, 0);
array_cleanup(&commandline_files);
}
/*
* Create a proc structure.
*/
static
struct proc *
proc_create(const char *name)
{
struct proc *proc;
proc = kmalloc(sizeof(*proc));
if (proc == NULL) {
return NULL;
}
proc->p_name = kstrdup(name);
if (proc->p_name == NULL) {
kfree(proc);
return NULL;
}
threadarray_init(&proc->p_threads);
spinlock_init(&proc->p_lock);
/* VM fields */
proc->p_addrspace = NULL;
/* VFS fields */
proc->p_cwd = NULL;
#if OPT_A2
//for some reason we cannot do vfs_open in here.
proc->filetable = array_create();
array_setsize(proc->filetable, 128);
for(int i = 0; i < 128; i++) {
array_set(proc->filetable, i, NULL);
}
proc->opencloselock = lock_create("opencloselock");
#endif
#ifdef UW
proc->console = NULL;
#endif // UW
return proc;
}
static
void
apply_commandline_macros(void)
{
struct commandline_macro *cm;
unsigned i, num;
num = array_num(&commandline_macros);
for (i=0; i<num; i++) {
cm = array_get(&commandline_macros, i);
if (cm->expansion != NULL) {
macro_define_plain(&cm->where, cm->macro,
&cm->where2, cm->expansion);
} else {
macro_undef(cm->macro);
}
dofree(cm, sizeof(*cm));
}
array_setsize(&commandline_macros, 0);
}
struct array *ftab_init(void){
struct vnode *v;
struct fildes *fdes;
struct array *OFtable;
OFtable = array_create();
array_setsize(OFtable, OPEN_MAX);
array_preallocate(OFtable, OPEN_MAX);
/* Open console as stdout and stderr */
int result = vfs_open((char *)"con:", O_WRONLY, 0777, &v);
(void)result;
fdes = fd_init(v, 0777, 0);
if(fdes){
/* Attach stdout/stderr to file table */
ftab_set(OFtable, fdes, 1);
ftab_set(OFtable, fdes, 2);
}
return OFtable;
}
static
void
read_commandline_files(void)
{
struct commandline_file *cf;
unsigned i, num;
bool save = false;
num = array_num(&commandline_files);
for (i=0; i<num; i++) {
cf = array_get(&commandline_files, i);
array_set(&commandline_files, i, NULL);
if (cf->suppress_output) {
save = mode.do_output;
mode.do_output = false;
file_readquote(&cf->where, cf->name);
mode.do_output = save;
} else {
file_readquote(&cf->where, cf->name);
}
dofree(cf, sizeof(*cf));
}
array_setsize(&commandline_files, 0);
}
static
void
testa(struct array *a)
{
int testarray[TESTSIZE];
int i, j, n, r, *p;
for (i=0; i<TESTSIZE; i++) {
testarray[i]=i;
}
n = array_num(a);
KASSERT(n==0);
for (i=0; i<TESTSIZE; i++) {
r = array_add(a, &testarray[i], NULL);
KASSERT(r==0);
n = array_num(a);
KASSERT(n==i+1);
}
n = array_num(a);
KASSERT(n==TESTSIZE);
for (i=0; i<TESTSIZE; i++) {
p = array_get(a, i);
KASSERT(*p == i);
}
n = array_num(a);
KASSERT(n==TESTSIZE);
for (j=0; j<TESTSIZE*4; j++) {
i = random()%TESTSIZE;
p = array_get(a, i);
KASSERT(*p == i);
}
n = array_num(a);
KASSERT(n==TESTSIZE);
for (i=0; i<TESTSIZE; i++) {
array_set(a, i, &testarray[TESTSIZE-i-1]);
}
for (i=0; i<TESTSIZE; i++) {
p = array_get(a, i);
KASSERT(*p == TESTSIZE-i-1);
}
r = array_setsize(a, TESTSIZE/2);
KASSERT(r==0);
for (i=0; i<TESTSIZE/2; i++) {
p = array_get(a, i);
KASSERT(*p == TESTSIZE-i-1);
}
array_remove(a, 1);
for (i=1; i<TESTSIZE/2 - 1; i++) {
p = array_get(a, i);
KASSERT(*p == TESTSIZE-i-2);
}
p = array_get(a, 0);
KASSERT(*p == TESTSIZE-1);
array_setsize(a, 2);
p = array_get(a, 0);
KASSERT(*p == TESTSIZE-1);
p = array_get(a, 1);
KASSERT(*p == TESTSIZE-3);
array_set(a, 1, NULL);
array_setsize(a, 2);
p = array_get(a, 0);
KASSERT(*p == TESTSIZE-1);
p = array_get(a, 1);
KASSERT(p==NULL);
array_setsize(a, TESTSIZE*10);
p = array_get(a, 0);
KASSERT(*p == TESTSIZE-1);
p = array_get(a, 1);
KASSERT(p==NULL);
}
