Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/amd/amd/sched.c	Lines:	0	58	0.0 %
Date:	2016-12-06	Branches:	0	26	0.0 %


/*	$OpenBSD: sched.c,v 1.18 2014/10/26 03:28:41 guenther Exp $	*/

/*
 * Copyright (c) 1990 Jan-Simon Pendry
 * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry at Imperial College, London.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	from: @(#)sched.c	8.1 (Berkeley) 6/6/93
 *	$Id: sched.c,v 1.18 2014/10/26 03:28:41 guenther Exp $
 */

/*
 * Process scheduler
 */

#include "am.h"
#include <signal.h>
#include <sys/wait.h>
#include <setjmp.h>
extern jmp_buf select_intr;
extern int select_intr_valid;

typedef struct pjob pjob;
struct pjob {
	qelem hdr;			/* Linked list */
	pid_t pid;			/* Process ID of job */
	cb_fun cb_fun;			/* Callback function */
	void *cb_closure;		/* Closure for callback */
	int w;				/* Status filled in by sigchld */
	void *wchan;			/* Wait channel */
};

extern qelem proc_list_head;
qelem proc_list_head = { &proc_list_head, &proc_list_head };
extern qelem proc_wait_list;
qelem proc_wait_list = { &proc_wait_list, &proc_wait_list };

int task_notify_todo;

void
ins_que(qelem *elem, qelem *pred)
{
	qelem *p = pred->q_forw;
	elem->q_back = pred;
	elem->q_forw = p;
	pred->q_forw = elem;
	p->q_back = elem;
}

void
rem_que(qelem *elem)
{
	qelem *p = elem->q_forw;
	qelem *p2 = elem->q_back;
	p2->q_forw = p;
	p->q_back = p2;
}

static pjob *
sched_job(cb_fun cf, void *ca)
{
	pjob *p = ALLOC(pjob);

	p->cb_fun = cf;
	p->cb_closure = ca;

	/*
	 * Now place on wait queue
	 */
	ins_que(&p->hdr, &proc_wait_list);

	return p;
}

void
run_task(task_fun tf, void *ta, cb_fun cf, void *ca)
{
	pjob *p = sched_job(cf, ca);
	sigset_t mask, omask;

	p->wchan = p;

	sigemptyset(&mask);
	sigaddset(&mask, SIGCHLD);
	sigprocmask(SIG_BLOCK, &mask, &omask);

	if ((p->pid = background())) {
		sigprocmask(SIG_SETMASK, &omask, NULL);
		return;
	}

	exit((*tf)(ta));
	/* firewall... */
	abort();
}

/*
 * Schedule a task to be run when woken up
 */
void
sched_task(cb_fun cf, void *ca, void *wchan)
{
	/*
	 * Allocate a new task
	 */
	pjob *p = sched_job(cf, ca);
#ifdef DEBUG_SLEEP
	dlog("SLEEP on %#x", wchan);
#endif
	p->wchan = wchan;
	p->pid = 0;
	bzero(&p->w, sizeof(p->w));
}

static void
wakeupjob(pjob *p)
{
	rem_que(&p->hdr);
	ins_que(&p->hdr, &proc_list_head);
	task_notify_todo++;
}

void
wakeup(void *wchan)
{
	pjob *p, *p2;
#ifdef DEBUG_SLEEP
	int done = 0;
#endif
	if (!foreground)
		return;

#ifdef DEBUG_SLEEP
	/*dlog("wakeup(%#x)", wchan);*/
#endif
	/*
	 * Can't user ITER() here because
	 * wakeupjob() juggles the list.
	 */
	for (p = FIRST(pjob, &proc_wait_list);
			p2 = NEXT(pjob, p), p != HEAD(pjob, &proc_wait_list);
			p = p2) {
		if (p->wchan == wchan) {
#ifdef DEBUG_SLEEP
			done = 1;
#endif
			wakeupjob(p);
		}
	}

#ifdef DEBUG_SLEEP
	if (!done)
		dlog("Nothing SLEEPing on %#x", wchan);
#endif
}

void
wakeup_task(int rc, int term, void *cl)
{
	wakeup(cl);
}


void
sigchld(int sig)
{
	int w;
	int save_errno = errno;
	pid_t pid;

	while ((pid = waitpid((pid_t)-1, &w, WNOHANG)) > 0) {
		pjob *p, *p2;

		if (WIFSIGNALED(w))
			plog(XLOG_ERROR, "Process %ld exited with signal %d",
				(long)pid, WTERMSIG(w));
#ifdef DEBUG
		else
			dlog("Process %ld exited with status %d",
				(long)pid, WEXITSTATUS(w));
#endif /* DEBUG */

		for (p = FIRST(pjob, &proc_wait_list);
		     p2 = NEXT(pjob, p), p != HEAD(pjob, &proc_wait_list);
		     p = p2) {
			if (p->pid == pid) {
				p->w = w;
				wakeupjob(p);
				break;
			}
		}

#ifdef DEBUG
		if (p == NULL)
			dlog("can't locate task block for pid %ld", (long)pid);
#endif /* DEBUG */
	}

	if (select_intr_valid)
		longjmp(select_intr, sig);
	errno = save_errno;
}

/*
 * Run any pending tasks.
 * This must be called with SIGCHLD disabled
 */
void
do_task_notify(void)
{
	/*
	 * Keep taking the first item off the list and processing it.
	 *
	 * Done this way because the callback can, quite reasonably,
	 * queue a new task, so no local reference into the list can be
	 * held here.
	 */
	while (FIRST(pjob, &proc_list_head) != HEAD(pjob, &proc_list_head)) {
		pjob *p = FIRST(pjob, &proc_list_head);
		rem_que(&p->hdr);
		/*
		 * This job has completed
		 */
		--task_notify_todo;

		/*
		 * Do callback if it exists
		 */
		if (p->cb_fun)
			(*p->cb_fun)(WIFEXITED(p->w) ? WEXITSTATUS(p->w) : 0,
				WIFSIGNALED(p->w) ? WTERMSIG(p->w) : 0,
				p->cb_closure);

		free(p);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: sched.c,v 1.18 2014/10/26 03:28:41 guenther Exp $ */
2
3			/*
4			* Copyright (c) 1990 Jan-Simon Pendry
5			* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
6			* Copyright (c) 1990, 1993
7			* The Regents of the University of California. All rights reserved.
8			*
9			* This code is derived from software contributed to Berkeley by
10			* Jan-Simon Pendry at Imperial College, London.
11			*
12			* Redistribution and use in source and binary forms, with or without
13			* modification, are permitted provided that the following conditions
14			* are met:
15			* 1. Redistributions of source code must retain the above copyright
16			* notice, this list of conditions and the following disclaimer.
17			* 2. Redistributions in binary form must reproduce the above copyright
18			* notice, this list of conditions and the following disclaimer in the
19			* documentation and/or other materials provided with the distribution.
20			* 3. Neither the name of the University nor the names of its contributors
21			* may be used to endorse or promote products derived from this software
22			* without specific prior written permission.
23			*
24			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34			* SUCH DAMAGE.
35			*
36			* from: @(#)sched.c 8.1 (Berkeley) 6/6/93
37			* $Id: sched.c,v 1.18 2014/10/26 03:28:41 guenther Exp $
38			*/
39
40			/*
41			* Process scheduler
42			*/
43
44			#include "am.h"
45			#include <signal.h>
46			#include <sys/wait.h>
47			#include <setjmp.h>
48			extern jmp_buf select_intr;
49			extern int select_intr_valid;
50
51			typedef struct pjob pjob;
52			struct pjob {
53			qelem hdr; /* Linked list */
54			pid_t pid; /* Process ID of job */
55			cb_fun cb_fun; /* Callback function */
56			void cb_closure; / Closure for callback */
57			int w; /* Status filled in by sigchld */
58			void wchan; / Wait channel */
59			};
60
61			extern qelem proc_list_head;
62			qelem proc_list_head = { &proc_list_head, &proc_list_head };
63			extern qelem proc_wait_list;
64			qelem proc_wait_list = { &proc_wait_list, &proc_wait_list };
65
66			int task_notify_todo;
67
68			void
69			ins_que(qelem elem, qelem pred)
70			{
71			qelem *p = pred->q_forw;
72			elem->q_back = pred;
73			elem->q_forw = p;
74			pred->q_forw = elem;
75			p->q_back = elem;
76			}
77
78			void
79			rem_que(qelem *elem)
80			{
81			qelem *p = elem->q_forw;
82			qelem *p2 = elem->q_back;
83			p2->q_forw = p;
84			p->q_back = p2;
85			}
86
87			static pjob *
88			sched_job(cb_fun cf, void *ca)
89			{
90			pjob *p = ALLOC(pjob);
91
92			p->cb_fun = cf;
93			p->cb_closure = ca;
94
95			/*
96			* Now place on wait queue
97			*/
98			ins_que(&p->hdr, &proc_wait_list);
99
100			return p;
101			}
102
103			void
104			run_task(task_fun tf, void ta, cb_fun cf, void ca)
105			{
106			pjob *p = sched_job(cf, ca);
107			sigset_t mask, omask;
108
109			p->wchan = p;
110
111			sigemptyset(&mask);
112			sigaddset(&mask, SIGCHLD);
113			sigprocmask(SIG_BLOCK, &mask, &omask);
114
115			if ((p->pid = background())) {
116			sigprocmask(SIG_SETMASK, &omask, NULL);
117			return;
118			}
119
120			exit((*tf)(ta));
121			/* firewall... */
122			abort();
123			}
124
125			/*
126			* Schedule a task to be run when woken up
127			*/
128			void
129			sched_task(cb_fun cf, void ca, void wchan)
130			{
131			/*
132			* Allocate a new task
133			*/
134			pjob *p = sched_job(cf, ca);
135			#ifdef DEBUG_SLEEP
136			dlog("SLEEP on %#x", wchan);
137			#endif
138			p->wchan = wchan;
139			p->pid = 0;
140			bzero(&p->w, sizeof(p->w));
141			}
142
143			static void
144			wakeupjob(pjob *p)
145			{
146			rem_que(&p->hdr);
147			ins_que(&p->hdr, &proc_list_head);
148			task_notify_todo++;
149			}
150
151			void
152			wakeup(void *wchan)
153			{
154			pjob p, p2;
155			#ifdef DEBUG_SLEEP
156			int done = 0;
157			#endif
158			if (!foreground)
159			return;
160
161			#ifdef DEBUG_SLEEP
162			/dlog("wakeup(%#x)", wchan);/
163			#endif
164			/*
165			* Can't user ITER() here because
166			* wakeupjob() juggles the list.
167			*/
168			for (p = FIRST(pjob, &proc_wait_list);
169			p2 = NEXT(pjob, p), p != HEAD(pjob, &proc_wait_list);
170			p = p2) {
171			if (p->wchan == wchan) {
172			#ifdef DEBUG_SLEEP
173			done = 1;
174			#endif
175			wakeupjob(p);
176			}
177			}
178
179			#ifdef DEBUG_SLEEP
180			if (!done)
181			dlog("Nothing SLEEPing on %#x", wchan);
182			#endif
183			}
184
185			void
186			wakeup_task(int rc, int term, void *cl)
187			{
188			wakeup(cl);
189			}
190
191
192			void
193			sigchld(int sig)
194			{
195			int w;
196			int save_errno = errno;
197			pid_t pid;
198
199			while ((pid = waitpid((pid_t)-1, &w, WNOHANG)) > 0) {
200			pjob p, p2;
201
202			if (WIFSIGNALED(w))
203			plog(XLOG_ERROR, "Process %ld exited with signal %d",
204			(long)pid, WTERMSIG(w));
205			#ifdef DEBUG
206			else
207			dlog("Process %ld exited with status %d",
208			(long)pid, WEXITSTATUS(w));
209			#endif /* DEBUG */
210
211			for (p = FIRST(pjob, &proc_wait_list);
212			p2 = NEXT(pjob, p), p != HEAD(pjob, &proc_wait_list);
213			p = p2) {
214			if (p->pid == pid) {
215			p->w = w;
216			wakeupjob(p);
217			break;
218			}
219			}
220
221			#ifdef DEBUG
222			if (p == NULL)
223			dlog("can't locate task block for pid %ld", (long)pid);
224			#endif /* DEBUG */
225			}
226
227			if (select_intr_valid)
228			longjmp(select_intr, sig);
229			errno = save_errno;
230			}
231
232			/*
233			* Run any pending tasks.
234			* This must be called with SIGCHLD disabled
235			*/
236			void
237			do_task_notify(void)
238			{
239			/*
240			* Keep taking the first item off the list and processing it.
241			*
242			* Done this way because the callback can, quite reasonably,
243			* queue a new task, so no local reference into the list can be
244			* held here.
245			*/
246			while (FIRST(pjob, &proc_list_head) != HEAD(pjob, &proc_list_head)) {
247			pjob *p = FIRST(pjob, &proc_list_head);
248			rem_que(&p->hdr);
249			/*
250			* This job has completed
251			*/
252			--task_notify_todo;
253
254			/*
255			* Do callback if it exists
256			*/
257			if (p->cb_fun)
258			(*p->cb_fun)(WIFEXITED(p->w) ? WEXITSTATUS(p->w) : 0,
259			WIFSIGNALED(p->w) ? WTERMSIG(p->w) : 0,
260			p->cb_closure);
261
262			free(p);
263			}
264			}