C++ (Cpp) closesigs Examples

Example #1

File: os.c Project: 8l/inferno

static void
pfree(Proc *p)
{
	Osenv *e;

	lock(&procs.l);
	if(p->prev)
		p->prev->next = p->next;
	else
		procs.head = p->next;

	if(p->next)
		p->next->prev = p->prev;
	else
		procs.tail = p->prev;
	unlock(&procs.l);

	e = p->env;
	if(e != nil) {
		closefgrp(e->fgrp);
		closepgrp(e->pgrp);
		closeegrp(e->egrp);
		closesigs(e->sigs);
	}
	free(e->user);
	free(p->prog);
	CloseHandle((HANDLE)p->os);
	free(p);
}

Example #2

File: proc.c Project: 8l/inferno

void
pexit(char*, int)
{
	Osenv *o;

	up->alarm = 0;

	o = up->env;
	if(o != nil){
		closefgrp(o->fgrp);
		closepgrp(o->pgrp);
		closeegrp(o->egrp);
		closesigs(o->sigs);
	}

	/* Sched must not loop for this lock */
	lock(&procalloc);

/*
	edfstop(up);
*/
	up->state = Moribund;
	sched();
	panic("pexit");
}

Example #3

File: os.c Project: 8l/inferno

void
pexit(char *msg, int t)
{
	Osenv *e;
	void *kstack;

	lock(&procs.l);
	if(up->prev)
		up->prev->next = up->next;
	else
		procs.head = up->next;

	if(up->next)
		up->next->prev = up->prev;
	else
		procs.tail = up->prev;
	unlock(&procs.l);

	if(0)
		print("pexit: %s: %s\n", up->text, msg);

	e = up->env;
	if(e != nil) {
		closefgrp(e->fgrp);
		closepgrp(e->pgrp);
		closeegrp(e->egrp);
		closesigs(e->sigs);
	}
	kstack = up->kstack;
	free(up->prog);
	free(up);
	if(kstack != nil)
		stackfreeandexit(kstack);
}

Example #4

File: kproc-libuv.c Project: AndreasBriese/node9

/* kproc exit */
void
pexit(char *msg, int t)
{
	Osenv *e;
	kproc_t* p;
	Osdep *os;

	USED(t);

    /* get our process context and remove ourselves from proc list
     */
    trace(TRACE_DEBUG, "kernel/pexit: process shutdown");
    
	p = (kproc_t*)up;

	lock(&procs.l);
	if(p->prev)
		p->prev->next = p->next;
	else
		procs.head = p->next;

	if(p->next)
		p->next->prev = p->prev;
	else
		procs.tail = p->prev;
	unlock(&procs.l);

	if(0)
		print("pexit: %s: %s\n", p->text, msg);

    trace(TRACE_DEBUG, "kernel/pexit: releasing resources"); 
    
    /* release name,fid and env groups */
	e = p->env;
	if(e != nil) {
    trace(TRACE_DEBUG, "kernel/pexit: closing fgrp"); 
		closefgrp(e->fgrp);
    trace(TRACE_DEBUG, "kernel/pexit: closing pgrp"); 
		closepgrp(e->pgrp);
    trace(TRACE_DEBUG, "kernel/pexit: closing egrp"); 
		closeegrp(e->egrp);
    trace(TRACE_DEBUG, "kernel/pexit: closing signatures"); 
		closesigs(e->sigs);
    trace(TRACE_DEBUG, "kernel/pexit: freeing user");
		free(e->user);
	}
	
    /* release os dependencies */
	os = p->os;
    if(os != nil){
        trace(TRACE_DEBUG, "kernel/pexit: deleting semaphore"); 
		uv_sem_destroy(&os->sem);
        trace(TRACE_DEBUG, "kernel/pexit: freeing os dependencies"); 
		free(os);
	}
       
    /* release the process itself */
    trace(TRACE_DEBUG, "kernel/pexit: freeing process"); 
	free(p);
}

Example #5

File: dis.c Project: 8l/inferno

void
delprog(Prog *p, char *msg)
{
	Osenv *o;
	Prog **ph;

	tellsomeone(p, msg);	/* call before being removed from prog list */

	o = p->osenv;
	release();
	closepgrp(o->pgrp);
	closefgrp(o->fgrp);
	closeegrp(o->egrp);
	closesigs(o->sigs);
	acquire();

	delgrp(p);

	if(p->prev)
		p->prev->next = p->next;
	else
		isched.head = p->next;

	if(p->next)
		p->next->prev = p->prev;
	else
		isched.tail = p->prev;

	ph = pidlook(p->pid);
	if(*ph == nil)
		panic("lost pid");
	*ph = p->pidlink;

	if(p == isched.runhd) {
		isched.runhd = p->link;
		if(p->link == nil)
			isched.runtl = nil;
	}
	p->state = 0xdeadbeef;
	free(o->user);
	free(p->killstr);
	free(p->exstr);
	free(p);
}