plan 9 kernel history: overview | file list | diff list

1990/03091/gnot/sysproc.c (diff list | history)

1990/03091/sys/src/9/gnot/sysproc.c:51,57 – 1990/0312/sys/src/9/gnot/sysproc.c:51,57 (short | long)
1990/03091    
	s = &p->seg[SSEG]; 
	s->proc = p; 
	on = (s->maxva-s->minva)>>PGSHIFT; 
	usp = ((Ureg*)UREGADDR)->sp;
1990/0312    
	usp = ((Ureg*)UREGADDR)->usp;
1990/03091    
	if(usp >= USTKTOP) 
		panic("fork bad usp %lux", usp); 
	if(usp < u->p->seg[SSEG].minva)
1990/03091/sys/src/9/gnot/sysproc.c:174,188 – 1990/0312/sys/src/9/gnot/sysproc.c:174,193
1990/03091    
	} 
	if(!indir) 
		strcpy(elem, u->elem);
1990/0312    
print("offset %lux\n", tc->offset);
1990/03091    
	n = (*devtab[tc->type].read)(tc, &exec, sizeof(Exec)); 
	if(n < 2)
1990/0312    
	if(n < 2){ 
		print("short read\n");
1990/03091    
    Err: 
		error(0, Ebadexec);
1990/0312    
	}
1990/03091    
	if(n==sizeof(Exec) && exec.magic==A_MAGIC){ 
		if((exec.text&KZERO) 
		|| (ulong)exec.entry < UTZERO+sizeof(Exec) 
		|| (ulong)exec.entry >= UTZERO+sizeof(Exec)+exec.text)
1990/0312    
		|| (ulong)exec.entry >= UTZERO+sizeof(Exec)+exec.text){ 
			print("bad header sizes\n");
1990/03091    
			goto Err;
1990/0312    
		}
1990/03091    
		goto Binary; 
	}
1990/03091/sys/src/9/gnot/sysproc.c:189,194 – 1990/0312/sys/src/9/gnot/sysproc.c:194,200
1990/03091    
	/* 
	 * Process #! /bin/sh args ... 
	 */
1990/0312    
print("do #! magic=%lux size=%d\n", exec.magic, n);
1990/03091    
	memcpy(line, &exec, sizeof(Exec)); 
	if(indir || line[0]!='#' || line[1]!='!') 
		goto Err;
1990/03091/sys/src/9/gnot/sysproc.c:347,356 – 1990/0312/sys/src/9/gnot/sysproc.c:353,362
1990/03091    
	unlock(o); 
 
	flushmmu(); 
	((Ureg*)UREGADDR)->pc = exec.entry - 4;
1990/0312    
	((Ureg*)UREGADDR)->pc = exec.entry;
1990/03091    
	sp = (ulong*)(USTKTOP - ssize); 
	*--sp = nargs; 
	((Ureg*)UREGADDR)->sp = (ulong)sp;
1990/0312    
	((Ureg*)UREGADDR)->usp = (ulong)sp;
1990/03091    
	lock(&p->debug); 
	u->nnote = 0; 
	u->notify = 0;
1990/0312/sys/src/9/gnot/sysproc.c:174,180 – 1990/0315/sys/src/9/gnot/sysproc.c:174,179 (short | long)
1990/03091    
	} 
	if(!indir) 
		strcpy(elem, u->elem);
1990/0312    
print("offset %lux\n", tc->offset);
1990/03091    
	n = (*devtab[tc->type].read)(tc, &exec, sizeof(Exec));
1990/0312    
	if(n < 2){ 
		print("short read\n");
1990/0315/sys/src/9/gnot/sysproc.c:193,199 – 1990/0317/sys/src/9/gnot/sysproc.c:193,198 (short | long)
1990/03091    
	/* 
	 * Process #! /bin/sh args ... 
	 */
1990/0312    
print("do #! magic=%lux size=%d\n", exec.magic, n);
1990/03091    
	memcpy(line, &exec, sizeof(Exec)); 
	if(indir || line[0]!='#' || line[1]!='!') 
		goto Err;
1990/0317/sys/src/9/gnot/sysproc.c:175,192 – 1990/0504/sys/src/9/gnot/sysproc.c:175,188 (short | long)
1990/03091    
	if(!indir) 
		strcpy(elem, u->elem); 
	n = (*devtab[tc->type].read)(tc, &exec, sizeof(Exec));
1990/0312    
	if(n < 2){ 
		print("short read\n");
1990/0504    
	if(n < 2)
1990/03091    
    Err: 
		error(0, Ebadexec);
1990/0312    
	}
1990/03091    
	if(n==sizeof(Exec) && exec.magic==A_MAGIC){ 
		if((exec.text&KZERO) 
		|| (ulong)exec.entry < UTZERO+sizeof(Exec)
1990/0312    
		|| (ulong)exec.entry >= UTZERO+sizeof(Exec)+exec.text){ 
			print("bad header sizes\n");
1990/0504    
		|| (ulong)exec.entry >= UTZERO+sizeof(Exec)+exec.text)
1990/03091    
			goto Err;
1990/0312    
		}
1990/03091    
		goto Binary; 
	}
1990/0504/sys/src/9/gnot/sysproc.c:26,31 – 1990/06021/sys/src/9/gnot/sysproc.c:26,32 (short | long)
1990/03091    
	ulong usp, upa, pid; 
	Chan *c; 
	Orig *o;
1990/06021    
	KMap *k;
1990/03091    
	int n, on, i; 
	int lastvar;	/* used to compute stack address */
1990/0504/sys/src/9/gnot/sysproc.c:34,40 – 1990/06021/sys/src/9/gnot/sysproc.c:35,43
1990/03091    
	 */ 
	p = newproc(); 
	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF)); 
	upa = p->upage->pa|KZERO;
1990/06021    
	k = kmap(p->upage); 
	upa = k->va;
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/0504/sys/src/9/gnot/sysproc.c:41,48 – 1990/06021/sys/src/9/gnot/sysproc.c:44,52
1990/03091    
	memcpy((void*)upa, u, sizeof(User)); 
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */ 
	memcpy((void*)(upa+BY2PG-n), (void*)((u->p->upage->pa|KZERO)+BY2PG-n), n);
1990/06021    
	memcpy((void*)(upa+BY2PG-n), (void*)(USERADDR+BY2PG-n), n);
1990/03091    
	((User *)upa)->p = p;
1990/06021    
	kunmap(k);
1990/03091    
 
	/* 
	 * User stack
1990/0504/sys/src/9/gnot/sysproc.c:70,82 – 1990/06021/sys/src/9/gnot/sysproc.c:74,88
1990/03091    
		op = u->p->seg[SSEG].o->pte[i+(on-n)].page; 
		if(op){ 
			np = newpage(1, s->o, op->va);
1990/06021    
			k = kmap(np);
1990/03091    
			p->seg[SSEG].o->pte[i].page = np; 
			if(i == 0){	/* only part of last stack page */ 
				memset((void*)(np->pa|KZERO), 0, usp); 
				memcpy((void*)((np->pa+usp)|KZERO), 
					(void*)((op->pa+usp)|KZERO), BY2PG-usp);
1990/06021    
				memset((void*)k->va, 0, usp); 
				memcpy((void*)(k->va+usp), 
					(void*)(op->va+usp), BY2PG-usp);
1990/03091    
			}else		/* all of higher pages */ 
				memcpy((void*)(np->pa|KZERO), (void*)(op->pa|KZERO), BY2PG);
1990/06021    
				memcpy((void*)k->va, (void*)op->va, BY2PG); 
			kunmap(k);
1990/03091    
		} 
	} 
	unlock(s->o);
1990/06021/sys/src/9/gnot/sysproc.c:36,42 – 1990/0614/sys/src/9/gnot/sysproc.c:36,42 (short | long)
1990/03091    
	p = newproc(); 
	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
1990/06021    
	k = kmap(p->upage); 
	upa = k->va;
1990/0614    
	upa = VA(k);
1990/06021    
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack
1990/06021/sys/src/9/gnot/sysproc.c:77,87 – 1990/0614/sys/src/9/gnot/sysproc.c:77,87
1990/06021    
			k = kmap(np);
1990/03091    
			p->seg[SSEG].o->pte[i].page = np; 
			if(i == 0){	/* only part of last stack page */
1990/06021    
				memset((void*)k->va, 0, usp); 
				memcpy((void*)(k->va+usp),
1990/0614    
				memset((void*)VA(k), 0, usp); 
				memcpy((void*)(VA(k)+usp),
1990/06021    
					(void*)(op->va+usp), BY2PG-usp);
1990/03091    
			}else		/* all of higher pages */
1990/06021    
				memcpy((void*)k->va, (void*)op->va, BY2PG);
1990/0614    
				memcpy((void*)VA(k), (void*)op->va, BY2PG);
1990/06021    
			kunmap(k);
1990/03091    
		} 
	}
1990/0614/sys/src/9/gnot/sysproc.c:404,411 – 1990/0619/sys/src/9/gnot/sysproc.c:404,409 (short | long)
1990/03091    
long 
syssleep(ulong *arg) 
{ 
	int ms; 
                 
	tsleep(&u->p->sleep, return0, 0, arg[0]); 
	return 0; 
}
1990/0619/sys/src/9/gnot/sysproc.c:157,163 – 1990/08141/sys/src/9/gnot/sysproc.c:157,163 (short | long)
1990/03091    
	Seg *s; 
	ulong l, t, d, b, v; 
	int i; 
	Chan *tc;
1990/08141    
	Chan *tc, *c;
1990/03091    
	Orig *o; 
	char **argv, **argp; 
	char *a, *charp, *file;
1990/0619/sys/src/9/gnot/sysproc.c:287,292 – 1990/08141/sys/src/9/gnot/sysproc.c:287,301
1990/03091    
	 * Committed.  Free old memory 
	 */ 
	freesegs(ESEG);
1990/08141    
 
	/* 
	 * Close on exec 
	 */ 
	for(i=0; i<=u->maxfd; i++) 
		if((c=u->fd[i]) && c->flag&CCEXEC){ 
			close(c); 
			fdclose(i); 
		}
1990/03091    
 
	/* 
	 * Text.  Shared.
1990/08141/sys/src/9/gnot/sysproc.c:161,166 – 1990/08163/sys/src/9/gnot/sysproc.c:161,167 (short | long)
1990/03091    
	Orig *o; 
	char **argv, **argp; 
	char *a, *charp, *file;
1990/08163    
	long fpnull = 0;
1990/03091    
	char *progarg[sizeof(Exec)/2+1], elem[NAMELEN]; 
	ulong ssize, spage, nargs, nbytes, n; 
	ulong *sp;
1990/08141/sys/src/9/gnot/sysproc.c:370,375 – 1990/08163/sys/src/9/gnot/sysproc.c:371,381
1990/03091    
	u->nnote = 0; 
	u->notify = 0; 
	u->notified = 0;
1990/08163    
	splhi(); 
	m->fpstate = FPinit; 
	p->fpstate = FPinit; 
	fprestore((FPsave*)&fpnull); 
	spllo();
1990/03091    
	unlock(&p->debug); 
	return 0; 
}
1990/08163/sys/src/9/gnot/sysproc.c:163,169 – 1990/0918/sys/src/9/gnot/sysproc.c:163,169 (short | long)
1990/03091    
	char *a, *charp, *file;
1990/08163    
	long fpnull = 0;
1990/03091    
	char *progarg[sizeof(Exec)/2+1], elem[NAMELEN]; 
	ulong ssize, spage, nargs, nbytes, n;
1990/0918    
	ulong ssize, spage, nargs, nbytes, n, bssend;
1990/03091    
	ulong *sp; 
	int indir; 
	Exec exec;
1990/08163/sys/src/9/gnot/sysproc.c:218,228 – 1990/0918/sys/src/9/gnot/sysproc.c:218,226
1990/03091    
 
    Binary: 
	t = (UTZERO+sizeof(Exec)+exec.text+(BY2PG-1)) & ~(BY2PG-1); 
	/* 
	 * Last partial page of data goes into BSS. 
	 */ 
	d = (t + exec.data) & ~(BY2PG-1); 
	b = (t + exec.data + exec.bss + (BY2PG-1)) & ~(BY2PG-1);
1990/0918    
	d = (t + exec.data + (BY2PG-1)) & ~(BY2PG-1); 
	bssend = t + exec.data + exec.bss; 
	b = (bssend + (BY2PG-1)) & ~(BY2PG-1);
1990/03091    
	if((t|d|b) & KZERO) 
		error(0, Ebadexec);
1990/08163/sys/src/9/gnot/sysproc.c:323,329 – 1990/0918/sys/src/9/gnot/sysproc.c:321,327
1990/03091    
	if(o == 0){ 
		o = neworig(t, (d-t)>>PGSHIFT, OWRPERM|OPURE|OCACHED, tc); 
		o->minca = p->seg[TSEG].o->maxca; 
		o->maxca = o->minca + (exec.data & ~(BY2PG-1));
1990/0918    
		o->maxca = o->minca + exec.data;
1990/03091    
	} 
	s->o = o; 
	s->minva = t;
1990/08163/sys/src/9/gnot/sysproc.c:331,345 – 1990/0918/sys/src/9/gnot/sysproc.c:329,341
1990/03091    
	s->mod = 0; 
 
	/* 
	 * BSS.  Created afresh, starting with last page of data. 
	 * BUG: should pick up the last page of data, which should be cached in the 
	 * data segment.
1990/0918    
	 * BSS.  Created afresh.
1990/03091    
	 */ 
	s = &p->seg[BSEG]; 
	s->proc = p; 
	o = neworig(d, (b-d)>>PGSHIFT, OWRPERM, tc); 
	o->minca = p->seg[DSEG].o->maxca; 
	o->maxca = o->minca + (exec.data & (BY2PG-1));
1990/0918    
	o = neworig(d, (b-d)>>PGSHIFT, OWRPERM, 0); 
	o->minca = 0; 
	o->maxca = 0;
1990/03091    
	s->o = o; 
	s->minva = d; 
	s->maxva = b;
1990/08163/sys/src/9/gnot/sysproc.c:347,352 – 1990/0918/sys/src/9/gnot/sysproc.c:343,350
1990/03091    
 
	close(tc);
1990/0918    
	p->bssend = bssend;
1990/03091    
	/* 
	 * Move the stack 
	 */
1990/08163/sys/src/9/gnot/sysproc.c:529,535 – 1990/0918/sys/src/9/gnot/sysproc.c:527,543
1990/03091    
long 
sysbrk_(ulong *arg) 
{
1990/0918    
	ulong addr; 
	Seg *s; 
 
	addr = arg[0]; 
	if(addr < u->p->bssend) 
		error(0, Esegaddr); 
	if(addr <= ((u->p->bssend+(BY2PG-1))&~(BY2PG-1)))	/* still in DSEG */ 
		goto Return;
1990/03091    
	if(segaddr(&u->p->seg[BSEG], u->p->seg[BSEG].minva, arg[0]) == 0) 
		error(0, Esegaddr);
1990/0918    
    Return: 
	u->p->bssend = addr;
1990/03091    
	return 0; 
}
1990/0918/sys/src/9/gnot/sysproc.c:41,46 – 1990/0921/sys/src/9/gnot/sysproc.c:41,47 (short | long)
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/0921    
	clearmmucache();
1990/03091    
	memcpy((void*)upa, u, sizeof(User)); 
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
1990/0918/sys/src/9/gnot/sysproc.c:361,366 – 1990/0921/sys/src/9/gnot/sysproc.c:362,368
1990/03091    
	unlock(o); 
 
	flushmmu();
1990/0921    
	clearmmucache();
1990/0312    
	((Ureg*)UREGADDR)->pc = exec.entry;
1990/03091    
	sp = (ulong*)(USTKTOP - ssize); 
	*--sp = nargs;
1990/0921/sys/src/9/gnot/sysproc.c:41,47 – 1990/0928/sys/src/9/gnot/sysproc.c:41,46 (short | long)
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/0921    
	clearmmucache();
1990/03091    
	memcpy((void*)upa, u, sizeof(User)); 
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
1990/0921/sys/src/9/gnot/sysproc.c:362,368 – 1990/0928/sys/src/9/gnot/sysproc.c:361,366
1990/03091    
	unlock(o); 
 
	flushmmu();
1990/0921    
	clearmmucache();
1990/0312    
	((Ureg*)UREGADDR)->pc = exec.entry;
1990/03091    
	sp = (ulong*)(USTKTOP - ssize); 
	*--sp = nargs;
1990/0928/sys/src/9/gnot/sysproc.c:41,46 – 1990/1004/sys/src/9/gnot/sysproc.c:41,47 (short | long)
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/1004    
	clearmmucache();
1990/03091    
	memcpy((void*)upa, u, sizeof(User)); 
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
1990/0928/sys/src/9/gnot/sysproc.c:128,138 – 1990/1004/sys/src/9/gnot/sysproc.c:129,136
1990/03091    
	 * Sched 
	 */ 
	if(setlabel(&p->sched)){ 
		u->p = p; 
		p->state = Running; 
		p->mach = m; 
		m->proc = p; 
		spllo();
1990/1004    
		clearmmucache(); 
		restore();
1990/03091    
		return 0; 
	} 
	p->pop = u->p;
1990/0928/sys/src/9/gnot/sysproc.c:147,152 – 1990/1004/sys/src/9/gnot/sysproc.c:145,151
1990/03091    
	memcpy(p->text, u->p->text, NAMELEN); 
	ready(p); 
	flushmmu();
1990/1004    
	clearmmucache();
1990/03091    
	return pid; 
}
1990/0928/sys/src/9/gnot/sysproc.c:361,366 – 1990/1004/sys/src/9/gnot/sysproc.c:360,366
1990/03091    
	unlock(o); 
 
	flushmmu();
1990/1004    
	clearmmucache();
1990/0312    
	((Ureg*)UREGADDR)->pc = exec.entry;
1990/03091    
	sp = (ulong*)(USTKTOP - ssize); 
	*--sp = nargs;
1990/1004/sys/src/9/gnot/sysproc.c:500,505 – 1990/1009/sys/src/9/gnot/sysproc.c:500,507 (short | long)
1990/03091    
	} 
	if(arg[0] == 0) 
		pgrpcpy(pg, u->p->pgrp);
1990/1009    
	else 
		memcpy(pg->user, u->p->pgrp->user, NAMELEN);
1990/03091    
	closepgrp(u->p->pgrp); 
	u->p->pgrp = pg; 
	return pg->pgrpid;
1990/1009/sys/src/9/gnot/sysproc.c:533,544 – 1990/1115/sys/src/9/gnot/sysproc.c:533,550 (short | long)
1990/0918    
	Seg *s; 
 
	addr = arg[0]; 
	if(addr < u->p->bssend)
1990/1115    
	if(addr < u->p->bssend){ 
		pprint("addr below bss\n"); 
		pexit("Suicide", 0);
1990/0918    
		error(0, Esegaddr);
1990/1115    
	}
1990/0918    
	if(addr <= ((u->p->bssend+(BY2PG-1))&~(BY2PG-1)))	/* still in DSEG */ 
		goto Return;
1990/03091    
	if(segaddr(&u->p->seg[BSEG], u->p->seg[BSEG].minva, arg[0]) == 0)
1990/1115    
	if(segaddr(&u->p->seg[BSEG], u->p->seg[BSEG].minva, arg[0]) == 0){ 
		pprint("bad segaddr in brk\n"); 
		pexit("Suicide", 0);
1990/03091    
		error(0, Esegaddr);
1990/1115    
	}
1990/0918    
    Return: 
	u->p->bssend = addr;
1990/03091    
	return 0;
1990/1115/sys/src/9/gnot/sysproc.c:183,189 – 1990/11211/sys/src/9/gnot/sysproc.c:183,189 (short | long)
1990/03091    
	n = (*devtab[tc->type].read)(tc, &exec, sizeof(Exec));
1990/0504    
	if(n < 2)
1990/03091    
    Err: 
		error(0, Ebadexec);
1990/11211    
		error(Ebadexec);
1990/03091    
	if(n==sizeof(Exec) && exec.magic==A_MAGIC){ 
		if((exec.text&KZERO) 
		|| (ulong)exec.entry < UTZERO+sizeof(Exec)
1990/1115/sys/src/9/gnot/sysproc.c:221,227 – 1990/11211/sys/src/9/gnot/sysproc.c:221,227
1990/0918    
	bssend = t + exec.data + exec.bss; 
	b = (bssend + (BY2PG-1)) & ~(BY2PG-1);
1990/03091    
	if((t|d|b) & KZERO) 
		error(0, Ebadexec);
1990/11211    
		error(Ebadexec);
1990/03091    
 
	/* 
	 * Args: pass 1: count
1990/1115/sys/src/9/gnot/sysproc.c:450,490 – 1990/11211/sys/src/9/gnot/sysproc.c:450,468
1990/03091    
} 
 
long 
syslasterr(ulong *arg)
1990/11211    
sysdeath(ulong *arg)
1990/03091    
{ 
	Error *e; 
                 
	validaddr(arg[0], sizeof u->error, 1); 
	evenaddr(arg[0]); 
	e = (Error *)arg[0]; 
	memcpy(e, &u->error, sizeof u->error); 
	memset(&u->error, 0, sizeof u->error); 
	e->type = devchar[e->type]; 
	return 0;
1990/11211    
	pprint("deprecated system call"); 
	pexit("Suicide", 0);
1990/03091    
} 
 
long 
syserrstr(ulong *arg) 
{ 
	Error *e, err; 
	char buf[ERRLEN]; 
 
	validaddr(arg[1], ERRLEN, 1); 
	e = &err; 
	if(arg[0]){ 
		validaddr(arg[0], sizeof u->error, 0); 
		memcpy(e, (Error*)arg[0], sizeof(Error)); 
		e->type = devno(e->type, 1); 
		if(e->type == -1){ 
			e->type = 0; 
			e->code = Egreg+1;	/* -> "no such error" */ 
		} 
	}else{ 
		memcpy(e, &u->error, sizeof(Error)); 
		memset(&u->error, 0, sizeof(Error)); 
	} 
	(*devtab[e->type].errstr)(e, buf); 
	memcpy((char*)arg[1], buf, sizeof buf);
1990/11211    
	validaddr(arg[0], ERRLEN, 1); 
	memcpy((char*)arg[0], u->error, ERRLEN);
1990/03091    
	return 0; 
}
1990/1115/sys/src/9/gnot/sysproc.c:519,525 – 1990/11211/sys/src/9/gnot/sysproc.c:497,503
1990/03091    
sysnoted(ulong *arg) 
{ 
	if(u->notified == 0) 
		error(0, Egreg);
1990/11211    
		error(Egreg);
1990/03091    
	return 0; 
}
1990/1115/sys/src/9/gnot/sysproc.c:536,542 – 1990/11211/sys/src/9/gnot/sysproc.c:514,520
1990/1115    
	if(addr < u->p->bssend){ 
		pprint("addr below bss\n"); 
		pexit("Suicide", 0);
1990/0918    
		error(0, Esegaddr);
1990/11211    
		error(Esegaddr);
1990/1115    
	}
1990/0918    
	if(addr <= ((u->p->bssend+(BY2PG-1))&~(BY2PG-1)))	/* still in DSEG */ 
		goto Return;
1990/1115/sys/src/9/gnot/sysproc.c:543,549 – 1990/11211/sys/src/9/gnot/sysproc.c:521,527
1990/1115    
	if(segaddr(&u->p->seg[BSEG], u->p->seg[BSEG].minva, arg[0]) == 0){ 
		pprint("bad segaddr in brk\n"); 
		pexit("Suicide", 0);
1990/03091    
		error(0, Esegaddr);
1990/11211    
		error(Esegaddr);
1990/1115    
	}
1990/0918    
    Return: 
	u->p->bssend = addr;
1990/11211/sys/src/9/gnot/sysproc.c:112,131 – 1990/1124/sys/src/9/gnot/sysproc.c:112,117 (short | long)
1990/03091    
		if(c = u->fd[n])	/* assign = */ 
			incref(c); 
	/* 
	 * Committed.  Link into hierarchy 
	 */ 
	lock(&p->kidlock); 
	lock(&u->p->kidlock); 
	if(u->p->kid == 0){ 
		p->sib = p; 
		u->p->kid = p; 
	}else{ 
		p->sib = u->p->kid->sib; 
		u->p->kid->sib = p; 
	} 
	unlock(&u->p->kidlock); 
	unlock(&p->kidlock); 
	/* 
	 * Sched 
	 */ 
	if(setlabel(&p->sched)){
1990/11211/sys/src/9/gnot/sysproc.c:133,139 – 1990/1124/sys/src/9/gnot/sysproc.c:119,124
1990/1004    
		restore();
1990/03091    
		return 0; 
	} 
	p->pop = u->p; 
	p->parent = u->p; 
	p->parentpid = u->p->pid; 
	p->pgrp = u->p->pgrp;
1990/1124/sys/src/9/gnot/sysproc.c:1,514 – 1990/1211/sys/src/9/gnot/sysproc.c:0 (short | long)
Deleted.
rsc Mon Mar 7 10:21:57 2005
1990/03091    
#include	"u.h" 
#include	"lib.h" 
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
#include	"ureg.h" 
#include	"errno.h" 
                 
#include	<a.out.h> 
                 
int	shargs(char*, int, char**); 
                 
long 
sysr1(ulong *arg) 
{ 
	print("[%d] r1 = %d\n", u->p->pid, arg[0]); 
	return 0; 
} 
                 
long 
sysfork(ulong *arg) 
{ 
	Proc *p; 
	Seg *s; 
	Page *np, *op; 
	ulong usp, upa, pid; 
	Chan *c; 
	Orig *o;
1990/06021    
	KMap *k;
1990/03091    
	int n, on, i; 
	int lastvar;	/* used to compute stack address */ 
                 
	/* 
	 * Kernel stack 
	 */ 
	p = newproc(); 
	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
1990/06021    
	k = kmap(p->upage);
1990/0614    
	upa = VA(k);
1990/06021    
                 
1990/03091    
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/1004    
	clearmmucache();
1990/03091    
	memcpy((void*)upa, u, sizeof(User)); 
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
1990/06021    
	memcpy((void*)(upa+BY2PG-n), (void*)(USERADDR+BY2PG-n), n);
1990/03091    
	((User *)upa)->p = p;
1990/06021    
	kunmap(k);
1990/03091    
                 
	/* 
	 * User stack 
	 */ 
	p->seg[SSEG] = u->p->seg[SSEG]; 
	s = &p->seg[SSEG]; 
	s->proc = p; 
	on = (s->maxva-s->minva)>>PGSHIFT;
1990/0312    
	usp = ((Ureg*)UREGADDR)->usp;
1990/03091    
	if(usp >= USTKTOP) 
		panic("fork bad usp %lux", usp); 
	if(usp < u->p->seg[SSEG].minva) 
		s->minva = u->p->seg[SSEG].minva; 
	else 
		s->minva = usp & ~(BY2PG-1); 
	usp = s->minva & (BY2PG-1);	/* just low bits */ 
	s->maxva = USTKTOP; 
	n = (s->maxva-s->minva)>>PGSHIFT; 
	s->o = neworig(s->minva, n, OWRPERM, 0); 
	lock(s->o); 
	/* 
	 * Only part of last stack page 
	 */ 
	for(i=0; i<n; i++){ 
		op = u->p->seg[SSEG].o->pte[i+(on-n)].page; 
		if(op){ 
			np = newpage(1, s->o, op->va);
1990/06021    
			k = kmap(np);
1990/03091    
			p->seg[SSEG].o->pte[i].page = np; 
			if(i == 0){	/* only part of last stack page */
1990/0614    
				memset((void*)VA(k), 0, usp); 
				memcpy((void*)(VA(k)+usp),
1990/06021    
					(void*)(op->va+usp), BY2PG-usp);
1990/03091    
			}else		/* all of higher pages */
1990/0614    
				memcpy((void*)VA(k), (void*)op->va, BY2PG);
1990/06021    
			kunmap(k);
1990/03091    
		} 
	} 
	unlock(s->o); 
	/* 
	 * Duplicate segments 
	 */ 
	for(s=&u->p->seg[0], n=0; n<NSEG; n++, s++){ 
		if(n == SSEG)		/* already done */ 
			continue; 
		if(s->o == 0) 
			continue; 
		p->seg[n] = *s; 
		p->seg[n].proc = p; 
		o = s->o; 
		lock(o); 
		o->nproc++; 
		if(s->mod) 
			forkmod(s, &p->seg[n], p); 
		unlock(o); 
	} 
	/* 
	 * Refs 
	 */ 
	incref(u->dot); 
	for(n=0; n<=u->maxfd; n++) 
		if(c = u->fd[n])	/* assign = */ 
			incref(c); 
	/* 
	 * Sched 
	 */ 
	if(setlabel(&p->sched)){
1990/1004    
		clearmmucache(); 
		restore();
1990/03091    
		return 0; 
	} 
	p->parent = u->p; 
	p->parentpid = u->p->pid; 
	p->pgrp = u->p->pgrp; 
	incref(p->pgrp); 
	u->p->nchild++; 
	pid = p->pid; 
	memset(p->time, 0, sizeof(p->time)); 
	p->time[TReal] = MACHP(0)->ticks; 
	memcpy(p->text, u->p->text, NAMELEN); 
	ready(p); 
	flushmmu();
1990/1004    
	clearmmucache();
1990/03091    
	return pid; 
} 
                 
long 
sysexec(ulong *arg) 
{ 
	Proc *p; 
	Seg *s; 
	ulong l, t, d, b, v; 
	int i;
1990/08141    
	Chan *tc, *c;
1990/03091    
	Orig *o; 
	char **argv, **argp; 
	char *a, *charp, *file;
1990/08163    
	long fpnull = 0;
1990/03091    
	char *progarg[sizeof(Exec)/2+1], elem[NAMELEN];
1990/0918    
	ulong ssize, spage, nargs, nbytes, n, bssend;
1990/03091    
	ulong *sp; 
	int indir; 
	Exec exec; 
	char line[sizeof(Exec)]; 
                 
	p = u->p; 
	validaddr(arg[0], 1, 0); 
	file = (char*)arg[0]; 
	indir = 0; 
    Header: 
	tc = namec(file, Aopen, OEXEC, 0); 
	if(waserror()){ 
		close(tc); 
		nexterror(); 
	} 
	if(!indir) 
		strcpy(elem, u->elem); 
	n = (*devtab[tc->type].read)(tc, &exec, sizeof(Exec));
1990/0504    
	if(n < 2)
1990/03091    
    Err:
1990/11211    
		error(Ebadexec);
1990/03091    
	if(n==sizeof(Exec) && exec.magic==A_MAGIC){ 
		if((exec.text&KZERO) 
		|| (ulong)exec.entry < UTZERO+sizeof(Exec)
1990/0504    
		|| (ulong)exec.entry >= UTZERO+sizeof(Exec)+exec.text)
1990/03091    
			goto Err; 
		goto Binary; 
	} 
                 
	/* 
	 * Process #! /bin/sh args ... 
	 */ 
	memcpy(line, &exec, sizeof(Exec)); 
	if(indir || line[0]!='#' || line[1]!='!') 
		goto Err; 
	n = shargs(line, n, progarg); 
	if(n == 0) 
		goto Err; 
	indir = 1; 
	/* 
	 * First arg becomes complete file name 
	 */ 
	progarg[n++] = file; 
	progarg[n] = 0; 
	validaddr(arg[1], BY2WD, 1); 
	arg[1] += BY2WD; 
	file = progarg[0]; 
	progarg[0] = elem; 
	close(tc); 
	poperror(); 
	goto Header; 
                 
    Binary: 
	t = (UTZERO+sizeof(Exec)+exec.text+(BY2PG-1)) & ~(BY2PG-1);
1990/0918    
	d = (t + exec.data + (BY2PG-1)) & ~(BY2PG-1); 
	bssend = t + exec.data + exec.bss; 
	b = (bssend + (BY2PG-1)) & ~(BY2PG-1);
1990/03091    
	if((t|d|b) & KZERO)
1990/11211    
		error(Ebadexec);
1990/03091    
                 
	/* 
	 * Args: pass 1: count 
	 */ 
	nbytes = 0; 
	nargs = 0; 
	if(indir){ 
		argp = progarg; 
		while(*argp){ 
			a = *argp++; 
			nbytes += strlen(a) + 1; 
			nargs++; 
		} 
	} 
	evenaddr(arg[1]); 
	argp = (char**)arg[1]; 
	validaddr((ulong)argp, BY2WD, 0); 
	while(*argp){ 
		a = *argp++; 
		if(((ulong)argp&(BY2PG-1)) < BY2WD) 
			validaddr((ulong)argp, BY2WD, 0); 
		validaddr((ulong)a, 1, 0); 
		nbytes += (vmemchr(a, 0, 0xFFFFFFFF) - a) + 1; 
			nargs++; 
	} 
	ssize = BY2WD*(nargs+1) + ((nbytes+(BY2WD-1)) & ~(BY2WD-1)); 
	spage = (ssize+(BY2PG-1)) >> PGSHIFT; 
                 
	/* 
	 * Build the stack segment, putting it in kernel virtual for the moment 
	 */ 
	s = &p->seg[ESEG]; 
	s->proc = p; 
	s->o = neworig(TSTKTOP-(spage<<PGSHIFT), spage, OWRPERM, 0); 
	s->minva = s->o->va; 
	s->maxva = TSTKTOP; 
                 
	/* 
	 * Args: pass 2: assemble; the pages will be faulted in 
	 */ 
	argv = (char**)(TSTKTOP - ssize); 
	charp = (char*)(TSTKTOP - nbytes); 
	if(indir) 
		argp = progarg; 
	else 
		argp = (char**)arg[1]; 
	for(i=0; i<nargs; i++){ 
		if(indir && *argp==0){ 
			indir = 0; 
			argp = (char**)arg[1]; 
		} 
		*argv++ = charp + (USTKTOP-TSTKTOP); 
		n = strlen(*argp) + 1; 
		memcpy(charp, *argp++, n); 
		charp += n; 
	} 
                 
	memcpy(p->text, elem, NAMELEN); 
                 
	/* 
	 * Committed.  Free old memory 
	 */ 
	freesegs(ESEG);
1990/08141    
                 
	/* 
	 * Close on exec 
	 */ 
	for(i=0; i<=u->maxfd; i++) 
		if((c=u->fd[i]) && c->flag&CCEXEC){ 
			close(c); 
			fdclose(i); 
		}
1990/03091    
                 
	/* 
	 * Text.  Shared. 
	 */ 
	s = &p->seg[TSEG]; 
	s->proc = p; 
	o = lookorig(UTZERO, (t-UTZERO)>>PGSHIFT, OCACHED, tc); 
	if(o == 0){ 
		o = neworig(UTZERO, (t-UTZERO)>>PGSHIFT, OCACHED, tc); 
		o->minca = 0; 
		o->maxca = sizeof(Exec)+exec.text; 
	} 
	s->o = o; 
	s->minva = UTZERO; 
	s->maxva = t; 
	s->mod = 0; 
                 
	/* 
	 * Data.  Shared. 
	 */ 
	s = &p->seg[DSEG]; 
	s->proc = p; 
	o = lookorig(t, (d-t)>>PGSHIFT, OWRPERM|OPURE|OCACHED, tc); 
	if(o == 0){ 
		o = neworig(t, (d-t)>>PGSHIFT, OWRPERM|OPURE|OCACHED, tc); 
		o->minca = p->seg[TSEG].o->maxca;
1990/0918    
		o->maxca = o->minca + exec.data;
1990/03091    
	} 
	s->o = o; 
	s->minva = t; 
	s->maxva = d; 
	s->mod = 0; 
                 
	/*
1990/0918    
	 * BSS.  Created afresh.
1990/03091    
	 */ 
	s = &p->seg[BSEG]; 
	s->proc = p;
1990/0918    
	o = neworig(d, (b-d)>>PGSHIFT, OWRPERM, 0); 
	o->minca = 0; 
	o->maxca = 0;
1990/03091    
	s->o = o; 
	s->minva = d; 
	s->maxva = b; 
	s->mod = 0; 
                 
	close(tc); 
                 
1990/0918    
	p->bssend = bssend; 
                 
1990/03091    
	/* 
	 * Move the stack 
	 */ 
	s = &p->seg[SSEG]; 
	*s = p->seg[ESEG]; 
	p->seg[ESEG].o = 0; 
	o = s->o; 
	o->va += (USTKTOP-TSTKTOP); 
	s->minva = o->va; 
	s->maxva = USTKTOP; 
	lock(o); 
	for(i=0; i<o->npte; i++) 
		o->pte[i].page->va += (USTKTOP-TSTKTOP); 
	unlock(o); 
                 
	flushmmu();
1990/1004    
	clearmmucache();
1990/0312    
	((Ureg*)UREGADDR)->pc = exec.entry;
1990/03091    
	sp = (ulong*)(USTKTOP - ssize); 
	*--sp = nargs;
1990/0312    
	((Ureg*)UREGADDR)->usp = (ulong)sp;
1990/03091    
	lock(&p->debug); 
	u->nnote = 0; 
	u->notify = 0; 
	u->notified = 0;
1990/08163    
	splhi(); 
	m->fpstate = FPinit; 
	p->fpstate = FPinit; 
	fprestore((FPsave*)&fpnull); 
	spllo();
1990/03091    
	unlock(&p->debug); 
	return 0; 
} 
                 
int 
shargs(char *s, int n, char **ap) 
{ 
	int i; 
                 
	s += 2, n -= 2;		/* skip #! */ 
	for(i=0; s[i]!='\n'; i++) 
		if(i == n-1) 
			return 0; 
	s[i] = 0; 
	*ap = 0; 
	i = 0; 
	for(;;){ 
		while(*s==' ' || *s=='\t') 
			s++; 
		if(*s == 0) 
			break; 
		i++; 
		*ap++ = s; 
		*ap = 0; 
		while(*s && *s!=' ' && *s!='\t') 
			s++; 
		if(*s == 0) 
			break; 
		else 
			*s++ = 0; 
	} 
	return i; 
} 
                 
int 
return0(void *a) 
{ 
	return 0; 
} 
                 
long 
syssleep(ulong *arg) 
{ 
	tsleep(&u->p->sleep, return0, 0, arg[0]); 
	return 0; 
} 
                 
                 
long 
sysexits(ulong *arg) 
{ 
	char *status; 
                 
	status = (char*)arg[0]; 
	if(status){ 
		if(waserror()) 
			status = "invalid exit string"; 
		else{ 
			validaddr((ulong)status, 1, 0); 
			vmemchr(status, 0, ERRLEN); 
		} 
	} 
	pexit(status, 1); 
} 
                 
long 
syswait(ulong *arg) 
{ 
	if(arg[0]){ 
		validaddr(arg[0], sizeof(Waitmsg), 1); 
		evenaddr(arg[0]); 
	} 
	return pwait((Waitmsg*)arg[0]); 
} 
                 
long
1990/11211    
sysdeath(ulong *arg)
1990/03091    
{
1990/11211    
	pprint("deprecated system call"); 
	pexit("Suicide", 0);
1990/03091    
} 
                 
long 
syserrstr(ulong *arg) 
{ 
	char buf[ERRLEN]; 
                 
1990/11211    
	validaddr(arg[0], ERRLEN, 1); 
	memcpy((char*)arg[0], u->error, ERRLEN);
1990/03091    
	return 0; 
} 
                 
long 
sysforkpgrp(ulong *arg) 
{ 
	Pgrp *pg; 
                 
	pg = newpgrp(); 
	if(waserror()){ 
		closepgrp(pg); 
		nexterror(); 
	} 
	if(arg[0] == 0) 
		pgrpcpy(pg, u->p->pgrp);
1990/1009    
	else 
		memcpy(pg->user, u->p->pgrp->user, NAMELEN);
1990/03091    
	closepgrp(u->p->pgrp); 
	u->p->pgrp = pg; 
	return pg->pgrpid; 
} 
                 
long 
sysnotify(ulong *arg) 
{ 
	validaddr(arg[0], sizeof(ulong), 0); 
	u->notify = (int(*)(void*, char*))(arg[0]); 
	return 0; 
} 
                 
long 
sysnoted(ulong *arg) 
{ 
	if(u->notified == 0)
1990/11211    
		error(Egreg);
1990/03091    
	return 0; 
} 
                 
/* 
 * Temporary; should be replaced by a generalized segment control operator 
 */ 
long 
sysbrk_(ulong *arg) 
{
1990/0918    
	ulong addr; 
	Seg *s; 
                 
	addr = arg[0];
1990/1115    
	if(addr < u->p->bssend){ 
		pprint("addr below bss\n"); 
		pexit("Suicide", 0);
1990/11211    
		error(Esegaddr);
1990/1115    
	}
1990/0918    
	if(addr <= ((u->p->bssend+(BY2PG-1))&~(BY2PG-1)))	/* still in DSEG */ 
		goto Return;
1990/1115    
	if(segaddr(&u->p->seg[BSEG], u->p->seg[BSEG].minva, arg[0]) == 0){ 
		pprint("bad segaddr in brk\n"); 
		pexit("Suicide", 0);
1990/11211    
		error(Esegaddr);
1990/1115    
	}
1990/0918    
    Return: 
	u->p->bssend = addr;
1990/03091    
	return 0; 
}


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)