WebSVN - shark - Blame - Rev 1618 - /shark/branches/xen/ports/first/first-server.c

Rev	Author	Line No.	Line
1063	tullio	1
		2	/*
		3	* This program is free software; you can redistribute it and/or modify
		4	* it under the terms of the GNU General Public License as published by
		5	* the Free Software Foundation; either version 2 of the License, or
		6	* (at your option) any later version.
		7	*
		8	* This program is distributed in the hope that it will be useful,
		9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		11	* GNU General Public License for more details.
		12	*
		13	* You should have received a copy of the GNU General Public License
		14	* along with this program; if not, write to the Free Software
		15	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		16	*
		17	*/
		18
221	giacomo	19	//=====================================================================
		20	// FFFFFFIII RRRRR SSTTTTTTT
		21	// FF IIR RR SS
		22	// FF IR SS
		23	// FFFFFF RRRR SSSSST
		24	// FF FI RRR SS
		25	// FF II RRR SS
		26	// FF IIIIIR RS
		27	//
		28	// Basic FSF(FIRST Scheduling Framework) contract management
		29	// S.Ha.R.K. Implementation
		30	//=====================================================================
		31
405	trimarchi	32	#include "ll/i386/64bit.h"
679	trimarchi	33	#include <kernel/kern.h>
975	trimarchi	34	#include <sem/sem/sem.h>
		35	#include <hartport/hartport/hartport.h>
		36	#include <cabs/cabs/cabs.h>
405	trimarchi	37
881	trimarchi	38	#include "fsf.h"
679	trimarchi	39	#include "fsf_service_task.h"
896	trimarchi	40	#include "fsf_server.h"
679	trimarchi	41	#include "message.h"
221	giacomo	42
868	trimarchi	43	#include "posixstar.h"
		44	#include "edfstar.h"
		45	#include "nonestar.h"
		46	#include "rmstar.h"
944	trimarchi	47	#include "tdstar.h"
1008	trimarchi	48	#include "fedfstar.h"
868	trimarchi	49
221	giacomo	50	#include <pthread.h>
		51	#include <stdlib.h>
808	trimarchi	52	#include "pistar.h"
975	trimarchi	53	#include <posix/posix/comm_message.h>
221	giacomo	54
417	giacomo	55	//#define FSF_DEBUG
221	giacomo	56
410	trimarchi	57	int current_server=0;
407	giacomo	58	server_elem server_list[FSF_MAX_N_SERVERS];
406	giacomo	59	bandwidth_t fsf_max_bw = 0;
405	trimarchi	60
241	giacomo	61	int fsf_server_level;
868	trimarchi	62	int fsf_posix_level = -1;
808	trimarchi	63	int shared_object_level;
679	trimarchi	64	PID server_task;
868	trimarchi	65	fsf_contract_parameters_t contract;
221	giacomo	66
868	trimarchi	67
679	trimarchi	68	PORT channel[2];
		69
868	trimarchi	70	fsf_server_id_t service_server = -1;
		71	fsf_contract_parameters_t service_contract;
		72
896	trimarchi	73	bandwidth_t SERVER_return_bandwidth();
		74
808	trimarchi	75	int FSF_register_shared_object_module(void) {
811	trimarchi	76	fsf_register_shared_object();
808	trimarchi	77	return PISTAR_register_module();
		78	}
		79
		80
810	trimarchi	81	int FSF_get_shared_object_level() {
		82	return shared_object_level;
		83	}
		84
868	trimarchi	85	int FSF_register_module(int posix_level, int server_level, bandwidth_t max_bw)
224	giacomo	86	{
		87	printk("FSF Module\n");
410	trimarchi	88	current_server=0;
241	giacomo	89	fsf_server_level = server_level;
868	trimarchi	90	fsf_posix_level = posix_level;
406	giacomo	91	fsf_max_bw = max_bw;
811	trimarchi	92	shared_object_level = FSF_register_shared_object_module();
679	trimarchi	93
224	giacomo	94	return 0;
		95
		96	}
		97
868	trimarchi	98	void FSF_start_service_task(void) {
679	trimarchi	99
868	trimarchi	100	int err;
881	trimarchi	101	struct timespec default_period = FSF_SERVICE_THREAD_PERIOD;
		102	struct timespec default_budget = FSF_SERVICE_THREAD_BUDGET;
868	trimarchi	103	DUMMY_TASK_MODEL m;
881	trimarchi	104	fsf_sched_params_t pr;
937	trimarchi	105	int budget_overrun_sig_notify = FSF_NULL_SIGNAL;
		106	union sigval budget_overrun_sig_value = {0};
		107	int deadline_miss_sig_notify = FSF_NULL_SIGNAL;
		108	union sigval deadline_miss_sig_value = {0};
868	trimarchi	109
881	trimarchi	110	pr.policy=FSF_NONE;
		111	pr.params=&m;
		112
868	trimarchi	113	dummy_task_default_model(m);
941	trimarchi	114
679	trimarchi	115	// create the service task
		116	// create the communication channel for negotiation and renegotiation
		117
		118	channel[1] = port_create("CHANW",sizeof(struct mess),1,STREAM,WRITE);
1008	trimarchi	119	if (channel[1]<0) exit(-1);
679	trimarchi	120
		121	channel[0] = port_create("CHANR",sizeof(struct mess),1,STREAM,READ);
1008	trimarchi	122	if (channel[0]<0) exit(-1);
679	trimarchi	123
1008	trimarchi	124	//kern_printf("FSF port WRITE %d, READ %d\n", channel[1], channel[0]);
		125
868	trimarchi	126	fsf_initialize_contract(&service_contract);
941	trimarchi	127
		128	err=fsf_set_contract_basic_parameters(&service_contract,&default_budget,&default_period,FSF_DEFAULT_WORKLOAD);
		129	if (err) exit(err);
868	trimarchi	130
941	trimarchi	131	err=fsf_set_contract_timing_requirements (&service_contract,
937	trimarchi	132	true,NULL,
		133	budget_overrun_sig_notify,
		134	budget_overrun_sig_value,
		135	deadline_miss_sig_notify,
		136	deadline_miss_sig_value);
941	trimarchi	137	if (err) exit(err);
937	trimarchi	138
868	trimarchi	139	negotiate_contract(&service_contract,&service_server);
		140
		141	//server_task = task_create("stask",service_task,model,NULL);
881	trimarchi	142	err = fsf_create_local_thread(service_server,&pr, &server_task,NULL,(fsf_thread_code_t)service_task,NULL);
868	trimarchi	143	if (err) {
679	trimarchi	144	cprintf("error creating service task\n");
		145	sys_shutdown_message("Could not create service_task");
927	pj	146	exit(1);
679	trimarchi	147	}
		148
		149	task_activate(server_task);
		150
		151	}
		152
		153
221	giacomo	154	/* Convert the contract specification to
		155	* budget parameters
		156	*/
241	giacomo	157	int set_SERVER_budget_from_contract
221	giacomo	158	(const fsf_contract_parameters_t *contract,
		159	int *budget)
		160	{
		161
		162	int local_scheduler_level = 0;
		163
868	trimarchi	164	switch (contract->policy) {
952	trimarchi	165	case FSF_RR:
241	giacomo	166	local_scheduler_level = POSIXSTAR_register_level(fsf_server_level,5000,32);
221	giacomo	167	break;
868	trimarchi	168	case FSF_EDF:
241	giacomo	169	local_scheduler_level = EDFSTAR_register_level(fsf_server_level);
221	giacomo	170	break;
1008	trimarchi	171	case FSF_FEDF:
		172	local_scheduler_level = FEDFSTAR_register_level(fsf_server_level);
		173	break;
952	trimarchi	174	case FSF_FP:
241	giacomo	175	local_scheduler_level = RMSTAR_register_level(fsf_server_level);
221	giacomo	176	break;
868	trimarchi	177	case FSF_NONE:
855	trimarchi	178	local_scheduler_level = NONESTAR_register_level(fsf_server_level);
334	giacomo	179	break;
944	trimarchi	180	case FSF_TABLE_DRIVEN:
		181	kern_printf("Register level");
		182	local_scheduler_level = TDSTAR_register_level(fsf_server_level);
		183	break;
221	giacomo	184	}
405	trimarchi	185
908	trimarchi	186	if (contract->d_equals_t == true) {
241	giacomo	187	*budget = SERVER_setbudget(fsf_server_level,
221	giacomo	188	TIMESPEC2USEC(&(contract->budget_min)),
		189	TIMESPEC2USEC(&(contract->period_max)),
661	giacomo	190	TIMESPEC2USEC(&(contract->period_max)),
868	trimarchi	191	local_scheduler_level,contract->policy);
661	giacomo	192	} else {
		193	*budget = SERVER_setbudget(fsf_server_level,
		194	TIMESPEC2USEC(&(contract->budget_min)),
		195	TIMESPEC2USEC(&(contract->period_max)),
		196	TIMESPEC2USEC(&(contract->deadline)),
868	trimarchi	197	local_scheduler_level,contract->policy);
661	giacomo	198	}
221	giacomo	199
		200	return 0;
		201
		202	}
		203
405	trimarchi	204	int adjust_SERVER_budget
		205	(int budget, const TIME budget_actual,
661	giacomo	206	const TIME period_actual, const TIME dline_actual)
221	giacomo	207	{
		208
241	giacomo	209	SERVER_adjust_budget(fsf_server_level,
405	trimarchi	210	budget_actual,
		211	period_actual,
661	giacomo	212	dline_actual,
241	giacomo	213	budget);
221	giacomo	214
		215	return 0;
		216
		217	}
		218
		219	/* Admission Test function */
		220	int add_contract(const fsf_contract_parameters_t *contract)
		221	{
896	trimarchi	222	bandwidth_t current_bandwidth,U;
		223
		224	TIME T,Q;
897	trimarchi	225
		226	#ifdef FSF_DEBUG
		227	kern_printf("(GA TEST)");
		228	#endif
896	trimarchi	229	T=TIMESPEC2USEC(&(contract->period_max));
		230	Q=TIMESPEC2USEC(&(contract->budget_min));
		231
		232	mul32div32to32(MAX_BANDWIDTH,Q,T,U);
		233	/* The current bandwidth is the min bandwidth */
		234	current_bandwidth=SERVER_return_bandwidth(fsf_server_level);
		235
897	trimarchi	236	if (fsf_max_bw<current_bandwidth+U) return -1;
896	trimarchi	237
221	giacomo	238	return 0;
		239
		240	}
		241
687	trimarchi	242	void contract_to_server(const fsf_contract_parameters_t *contract, int i) {
		243
410	trimarchi	244	TIME T,Q;
		245	#ifdef FSF_DEBUG
		246	int temp;
		247	#endif
		248
		249	T=TIMESPEC2USEC(&contract->period_min);
		250	Q=TIMESPEC2USEC(&contract->budget_max);
908	trimarchi	251	server_list[i].Cmax=Q;
		252
410	trimarchi	253	mul32div32to32(MAX_BANDWIDTH,Q,T,server_list[current_server].Umax);
		254
417	giacomo	255	T=TIMESPEC2USEC(&contract->period_min);
		256	server_list[i].Tmin=T;
		257
410	trimarchi	258	T=TIMESPEC2USEC(&contract->period_max);
		259	server_list[i].Tmax=T;
417	giacomo	260
410	trimarchi	261	Q=TIMESPEC2USEC(&contract->budget_min);
		262	server_list[i].Cmin=Q;
		263
		264	mul32div32to32(MAX_BANDWIDTH,Q,T,server_list[i].Umin);
416	trimarchi	265	server_list[i].U=server_list[i].Umin;
661	giacomo	266
908	trimarchi	267	if (contract->d_equals_t == true) {
661	giacomo	268	server_list[i].deadline = 0;
908	trimarchi	269	server_list[i].d_equals_t = true;
661	giacomo	270	} else {
		271	server_list[i].deadline = TIMESPEC2USEC(&contract->deadline);;
908	trimarchi	272	server_list[i].d_equals_t = false;
661	giacomo	273	}
		274
843	trimarchi	275	server_list[i].Qs = contract->quality;
		276	server_list[i].Is = contract->importance;
		277
410	trimarchi	278	#ifdef FSF_DEBUG
		279	mul32div32to32(server_list[i].Umax,100, MAX_BANDWIDTH, temp);
		280	kern_printf("(Umax %d)",temp);
		281	mul32div32to32(server_list[i].Umin,100, MAX_BANDWIDTH, temp);
		282	kern_printf("(Umin %d)",temp);
		283	#endif
		284
687	trimarchi	285	}
		286
		287	int relink_contract_to_server(const fsf_contract_parameters_t *contract,
		288	fsf_server_id_t server)
		289	{
		290	int i=0;
		291	#ifdef FSF_DEBUG
		292	kern_printf("(Relink Server %d)",server);
		293	#endif
		294	// find contract
		295	while(i<current_server) {
		296	if (server_list[i].server==server) break;
		297	i++;
		298	}
		299
		300	server_list[i].server=server;
843	trimarchi	301	// server_list[i].Qs=1;
687	trimarchi	302
		303	contract_to_server(contract, i);
		304
		305
410	trimarchi	306	return 0;
		307
		308	}
		309
221	giacomo	310	int link_contract_to_server(const fsf_contract_parameters_t *contract,
		311	fsf_server_id_t server)
		312	{
407	giacomo	313	#ifdef FSF_DEBUG
405	trimarchi	314	kern_printf("(Link Server %d)",server);
		315	#endif
		316
410	trimarchi	317	server_list[current_server].server=server;
843	trimarchi	318	//server_list[current_server].Qs=1;
405	trimarchi	319
687	trimarchi	320	contract_to_server(contract,current_server);
405	trimarchi	321
410	trimarchi	322	current_server++;
221	giacomo	323	return 0;
		324
		325	}
		326
		327	int remove_contract(fsf_server_id_t server)
		328	{
405	trimarchi	329	int i=0;
		330	// find the contract
410	trimarchi	331	while(i<current_server) {
405	trimarchi	332	if (server_list[i].server==server) break;
		333	i++;
		334	}
221	giacomo	335
405	trimarchi	336	// compress the array;
410	trimarchi	337	while (i<(current_server-1)) {
405	trimarchi	338	server_list[i].server=server_list[i+1].server;
		339	server_list[i].Umin=server_list[i+1].Umin;
416	trimarchi	340	server_list[i].U=server_list[i+1].Umin;
405	trimarchi	341	server_list[i].Umax=server_list[i+1].Umax;
		342	server_list[i].Cmin=server_list[i+1].Cmin;
908	trimarchi	343	server_list[i].Cmax=server_list[i+1].Cmax;
417	giacomo	344	server_list[i].Tmin=server_list[i+1].Tmin;
405	trimarchi	345	server_list[i].Tmax=server_list[i+1].Tmax;
		346	server_list[i].Qs=server_list[i+1].Qs;
661	giacomo	347	server_list[i].deadline = server_list[i+1].deadline;
		348	server_list[i].d_equals_t = server_list[i+1].d_equals_t;
843	trimarchi	349	server_list[i].Is = server_list[i+1].Is;
417	giacomo	350
405	trimarchi	351	i++;
		352	}
410	trimarchi	353	current_server--;
405	trimarchi	354
		355
221	giacomo	356	return 0;
		357
		358	}
		359
868	trimarchi	360	int
		361	fsf_get_renegotiation_status
		362	(fsf_server_id_t server,
		363	fsf_renegotiation_status_t *renegotiation_status)
		364	{
221	giacomo	365
868	trimarchi	366	if (SERVER_get_renegotiation_status(fsf_server_level,server))
		367	*renegotiation_status=FSF_IN_PROGRESS;
		368	else
		369	*renegotiation_status=FSF_ADMITTED;
		370
		371	return 0;
		372
		373
		374	}
		375
896	trimarchi	376	int
		377	fsf_request_change_quality_and_importance
		378	(fsf_server_id_t server,
		379	int new_importance,
		380	int new_quality)
		381	{
		382	struct mess m;
868	trimarchi	383
896	trimarchi	384	// send response server is -1 if the operation fail
		385	m.type=CHANGE_PARAMETER;
908	trimarchi	386	m.server=server;
		387	m.qi.quality = new_quality;
		388	m.qi.importance = new_importance;
896	trimarchi	389	//memmove(&m.contract,contract, sizeof(fsf_contract_parameters_t));
		390
		391	port_send(channel[1],&m,BLOCK);
		392
		393	port_receive(channel[0], &m, BLOCK);
		394
		395	if (m.server==-1)
		396	return FSF_ERR_CONTRACT_REJECTED;
		397
		398	//*server=m.server;
		399
908	trimarchi	400	return 0;
896	trimarchi	401	}
		402
		403
1008	trimarchi	404	void copy_contract(fsf_contract_parameters_t contractd, const fsf_contract_parameters_t contracts) {
		405
		406	contractd->budget_min=contracts->budget_min;
		407	contractd->period_max=contracts->period_max;
		408	contractd->budget_max=contracts->budget_max;
		409	contractd->period_min=contracts->period_min;
		410	contractd->workload=contracts->workload;
		411	contractd->d_equals_t=contracts->d_equals_t;
		412	contractd->deadline=contracts->deadline;
		413	contractd->quality=contracts->quality;
		414	contractd->policy=contracts->policy;
		415	/*
		416	int budget_overrun_sig_notify;
		417	union sigval budget_overrun_sig_value;
		418	int deadline_miss_sig_notify;
		419	union sigval deadline_miss_sig_value;
		420
		421	fsf_granularity_t granularity;
		422	fsf_utilization_set_t utilization_set;
		423	int quality;
		424	int importance;
		425
		426	fsf_preemption_level_t preemption_level;
		427	fsf_critical_sections_t critical_sections;
		428
		429	fsf_sched_policy_t policy;
		430
		431	fsf_network_id_t network_id;
		432	bool granted_capacity_flag;
		433	*/
		434
		435
		436	}
		437
221	giacomo	438	int fsf_negotiate_contract
		439	(const fsf_contract_parameters_t *contract,
		440	fsf_server_id_t *server)
		441	{
880	trimarchi	442	struct mess m;
221	giacomo	443
679	trimarchi	444	// send response server is -1 if the operation fail
880	trimarchi	445	m.type=NEGOTIATE_CONTRACT;
1008	trimarchi	446	copy_contract(&m.contract,contract);
880	trimarchi	447	port_send(channel[1],&m,BLOCK);
		448	port_receive(channel[0], &m, BLOCK);
963	trimarchi	449	if (m.server==-1) {
		450	*server=0;
1008	trimarchi	451	return FSF_ERR_CONTRACT_REJECTED;
963	trimarchi	452	}
221	giacomo	453
880	trimarchi	454	*server=m.server;
679	trimarchi	455
221	giacomo	456	return 0;
		457
		458	}
		459
872	trimarchi	460	int
		461	fsf_negotiate_contract_for_new_thread
		462	(const fsf_contract_parameters_t *contract,
		463	fsf_server_id_t *server,
		464	pthread_t *thread,
		465	pthread_attr_t *attr,
		466	fsf_thread_code_t thread_code,
		467	void *arg) {
		468
		469	int err=0;
		470
		471	err = fsf_negotiate_contract(contract,server);
		472	if (!err) {
		473	err = pthread_create(thread, attr, thread_code, arg);
		474	if (!err)
		475	err = fsf_bind_thread_to_server(server,thread);
		476	} else return err;
		477
		478	return err;
		479	}
		480
		481	int
		482	fsf_negotiate_contract_for_myself
		483	(const fsf_contract_parameters_t *contract,
		484	fsf_server_id_t *server) {
		485
		486	int err=0;
		487
		488	err = fsf_negotiate_contract(contract,server);
		489	if (!err) {
937	trimarchi	490	#ifdef FSF_DEBUG
		491	kern_printf("Bind task");
		492	#endif
872	trimarchi	493	err = fsf_bind_thread_to_server(*server,exec_shadow);
937	trimarchi	494
872	trimarchi	495	} else return err;
		496
		497	return err;
		498	}
		499
868	trimarchi	500	int fsf_unbind_thread_from_server
		501	(pthread_t thread)
		502	{
		503
		504	int local_scheduler_level, scheduler_id;
963	trimarchi	505	SYS_FLAGS f;
868	trimarchi	506	/* Move thread from the local scheduler module to posix level */
		507
		508	#ifdef FSF_DEBUG
		509	kern_printf("(UnBind thread = %d)",thread);
		510	#endif
963	trimarchi	511	f=kern_fsave();
868	trimarchi	512	/* Check if thread exsists */
963	trimarchi	513	if (thread == -1) {
		514	kern_frestore(f);
868	trimarchi	515	return FSF_ERR_BAD_ARGUMENT;
963	trimarchi	516	}
868	trimarchi	517
		518	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		519	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level,thread);
963	trimarchi	520
868	trimarchi	521	/* Check if thread is already bind */
		522	if (scheduler_id == FSF_NONE) {
		523	/* Check if it is bind to a server */
963	trimarchi	524	if (NONESTAR_getbudget(local_scheduler_level,thread) == -1) {
		525	kern_frestore(f);
868	trimarchi	526	return FSF_ERR_BAD_ARGUMENT;
963	trimarchi	527	}
868	trimarchi	528	else {
		529
		530	STD_command_message *msg;
		531	NRT_TASK_MODEL nrt;
		532
		533	nrt_task_default_model(nrt);
		534	nrt_task_def_save_arrivals(nrt);
963	trimarchi	535	nrt_task_def_weight(nrt,0);
		536	nrt_task_def_policy(nrt,NRT_RR_POLICY);
		537	nrt_task_def_inherit(nrt,NRT_EXPLICIT_SCHED);
868	trimarchi	538
		539	/* Send change level command to local scheduler */
		540	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
		541
		542	msg->command = STD_SET_NEW_MODEL;
		543	msg->param = (void *)(&nrt);
		544	level_table[fsf_posix_level]->public_message(fsf_posix_level,thread,msg);
		545
		546	msg->command = STD_SET_NEW_LEVEL;
		547	msg->param = (void *)(fsf_posix_level);
		548	task_message(msg,thread,0);
963	trimarchi	549	//if (exec_shadow!=thread)
		550	level_table[proc_table[thread].task_level]->public_epilogue(proc_table[thread].task_level, thread);
		551	//else {
		552	//scheduler();
		553	//kern_context_load(proc_table[exec_shadow].context);
		554	//}
		555	kern_frestore(f);
868	trimarchi	556
		557	free(msg);
		558	}
963	trimarchi	559	} else {
		560	kern_frestore(f);
		561	return FSF_ERR_BAD_ARGUMENT;
868	trimarchi	562	}
		563
		564	return 0;
		565
		566	}
		567
873	trimarchi	568	int
		569	fsf_bind_local_thread_to_server
		570	(fsf_server_id_t server,
		571	pthread_t thread,
		572	fsf_sched_params_t *sched_params)
		573	{
868	trimarchi	574
873	trimarchi	575	STD_command_message *msg;
		576	int local_scheduler_level,scheduler_id;
		577
		578	/* Move thread from the posix module to local scheduler */
		579
		580	#ifdef FSF_DEBUG
		581	kern_printf("(Bind thread = %d to Server = %d)",thread,server);
		582	#endif
		583
		584	/* Check if server and thread exsist */
		585	if (server == -1 \|\| thread == -1)
		586	return FSF_ERR_BAD_ARGUMENT;
		587
		588	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		589	if (local_scheduler_level==-1)
952	trimarchi	590	return FSF_ERR_UNKNOWN_SCHEDULED_THREAD;
873	trimarchi	591
		592	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
881	trimarchi	593
		594	if (scheduler_id!=sched_params->policy)
		595	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
873	trimarchi	596
		597	/* Check if thread is already bind */
		598	switch(scheduler_id) {
		599
952	trimarchi	600	case FSF_FP:
873	trimarchi	601	{
881	trimarchi	602	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
		603	HARD_TASK_MODEL h=(HARD_TASK_MODEL )(sched_params->params);
873	trimarchi	604
		605	if (m->pclass != HARD_PCLASS)
		606	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		607
		608	h = (HARD_TASK_MODEL *)m;
		609
		610	if (!h->wcet \|\| !h->mit) return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		611
		612	/* now we know that m is a valid model */
		613	if (RMSTAR_getbudget(local_scheduler_level,thread) != -1)
		614	return FSF_ERR_BAD_ARGUMENT;
		615
		616	/* Set server on local scheduler */
		617	RMSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		618
		619	/* Send change level command to posix level */
		620	}
877	trimarchi	621	break;
		622
873	trimarchi	623	case FSF_EDF:
		624	{
881	trimarchi	625	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
		626	HARD_TASK_MODEL h=(HARD_TASK_MODEL )(sched_params->params);
873	trimarchi	627
		628	if (m->pclass != HARD_PCLASS)
		629	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		630
		631	h = (HARD_TASK_MODEL *)m;
		632
		633	if (!h->wcet \|\| !h->mit) return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		634
		635	if (EDFSTAR_getbudget(local_scheduler_level,thread) != -1)
		636	return FSF_ERR_BAD_ARGUMENT;
		637
		638	/* Set server on local scheduler */
		639	EDFSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		640
		641	}
		642	break;
1008	trimarchi	643
		644	case FSF_FEDF:
		645	{
		646	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
		647	HARD_TASK_MODEL h=(HARD_TASK_MODEL )(sched_params->params);
		648
		649	if (m->pclass != HARD_PCLASS)
		650	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		651
		652	h = (HARD_TASK_MODEL *)m;
		653
		654	if (!h->wcet \|\| !h->mit) return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		655
		656	if (FEDFSTAR_getbudget(local_scheduler_level,thread) != -1)
		657	return FSF_ERR_BAD_ARGUMENT;
		658
		659	/* Set server on local scheduler */
		660	FEDFSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		661
		662	}
873	trimarchi	663
952	trimarchi	664	case FSF_RR:
873	trimarchi	665	{
881	trimarchi	666	TASK_MODEL m=(TASK_MODEL)(sched_params->params);
873	trimarchi	667
		668	if (m->pclass != NRT_PCLASS)
		669	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		670
		671	if (POSIXSTAR_getbudget(local_scheduler_level,thread) != -1)
		672	return FSF_ERR_BAD_ARGUMENT;
		673
		674	/* Set server on local scheduler */
		675	POSIXSTAR_setbudget(local_scheduler_level,thread,(int)(server));
		676	}
877	trimarchi	677	break;
873	trimarchi	678
877	trimarchi	679	default:
		680
873	trimarchi	681	return FSF_ERR_BAD_ARGUMENT;
877	trimarchi	682
873	trimarchi	683	}
		684
		685	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
877	trimarchi	686	if (msg) {
		687	SYS_FLAGS f;
		688	f=kern_fsave();
873	trimarchi	689	msg->command = STD_SET_NEW_MODEL;
881	trimarchi	690	msg->param = (void *)(sched_params->params);
873	trimarchi	691	level_table[local_scheduler_level]->public_message(local_scheduler_level,thread,msg);
		692
		693	msg->command = STD_SET_NEW_LEVEL;
		694	msg->param = (void *)(local_scheduler_level);
		695	task_message(msg,thread,0);
977	trimarchi	696	level_table[proc_table[thread].task_level]->public_dispatch(proc_table[thread].task_level, thread, 0);
		697	level_table[proc_table[thread].task_level]->public_epilogue(proc_table[thread].task_level, thread);
		698	//} else {
		699	if (cap_timer != NIL) {
		700	event_delete(cap_timer);
		701	cap_timer = NIL;
		702	}
		703
940	trimarchi	704	scheduler();
		705	kern_context_load(proc_table[exec_shadow].context);
977	trimarchi	706
877	trimarchi	707	kern_frestore(f);
873	trimarchi	708	free(msg);
		709	} else return FSF_ERR_INTERNAL_ERROR;
		710
		711	return 0;
		712
		713	}
		714
		715
868	trimarchi	716	int fsf_bind_thread_to_server
		717	(fsf_server_id_t server,
		718	pthread_t thread)
		719	{
		720
963	trimarchi	721	STD_command_message *msg=0;
868	trimarchi	722	int local_scheduler_level,scheduler_id;
937	trimarchi	723	SYS_FLAGS f;
868	trimarchi	724	/* Move thread from the posix module to local scheduler */
		725
963	trimarchi	726	f=kern_fsave();
868	trimarchi	727	#ifdef FSF_DEBUG
880	trimarchi	728	kern_printf("(Bthr=%d to Sr=%d)",thread,server);
868	trimarchi	729	#endif
		730
		731	/* Check if server and thread exsist */
		732	if (server == -1 \|\| thread == -1)
		733	return FSF_ERR_BAD_ARGUMENT;
		734
		735	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
873	trimarchi	736	if (local_scheduler_level==-1)
952	trimarchi	737	return FSF_ERR_UNKNOWN_SCHEDULED_THREAD;
873	trimarchi	738
868	trimarchi	739	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
		740	/* Check if thread is already bind */
		741	if (scheduler_id == FSF_NONE) {
		742	DUMMY_TASK_MODEL rt_arg;
963	trimarchi	743	if (NONESTAR_getbudget(local_scheduler_level,thread) != -1) {
		744	kern_frestore(f);
868	trimarchi	745	return FSF_ERR_BAD_ARGUMENT;
963	trimarchi	746	}
868	trimarchi	747	/* Set server on local scheduler */
		748	NONESTAR_setbudget(local_scheduler_level,thread,(int)(server));
963	trimarchi	749
868	trimarchi	750	/* Send change level command to posix level */
		751	msg = (STD_command_message *)malloc(sizeof(STD_command_message));
963	trimarchi	752	if (!msg) exit(-1);
868	trimarchi	753	msg->command = STD_SET_NEW_MODEL;
		754	msg->param = (void *)(&rt_arg);
937	trimarchi	755	level_table[local_scheduler_level]->public_message(local_scheduler_level,thread,msg);
868	trimarchi	756	msg->command = STD_SET_NEW_LEVEL;
		757	msg->param = (void *)(local_scheduler_level);
963	trimarchi	758	task_message(msg,thread,0);
		759	//if (thread!=exec_shadow) {
		760	level_table[proc_table[thread].task_level]->public_dispatch(proc_table[thread].task_level, thread, 0);
		761	level_table[proc_table[thread].task_level]->public_epilogue(proc_table[thread].task_level, thread);
		762	//} else {
		763	if (cap_timer != NIL) {
		764	event_delete(cap_timer);
		765	cap_timer = NIL;
		766	}
		767
937	trimarchi	768	scheduler();
		769	kern_context_load(proc_table[exec_shadow].context);
963	trimarchi	770	//}
937	trimarchi	771	kern_frestore(f);
		772
		773
963	trimarchi	774	if (msg) free(msg);
937	trimarchi	775
963	trimarchi	776	} else {
		777	kern_frestore(f);
		778	return FSF_ERR_BAD_ARGUMENT;
		779	}
868	trimarchi	780	return 0;
		781	}
		782
881	trimarchi	783	int fsf_create_local_thread
		784	(fsf_server_id_t server,
		785	fsf_sched_params_t *local_scheduler_arg,
		786	pthread_t *thread,
		787	pthread_attr_t *attr,
		788	fsf_thread_code_t thread_code,
		789	void *arg)
221	giacomo	790	{
		791
		792	int local_scheduler_level,scheduler_id;
		793
		794	/* Check if server and thread exsist */
241	giacomo	795	if (server == NIL)
873	trimarchi	796	return FSF_ERR_BAD_ARGUMENT;
221	giacomo	797
241	giacomo	798	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		799	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
868	trimarchi	800	#ifdef FSF_DEBUG
		801	kern_printf("sched policy %d", scheduler_id);
		802	#endif
888	trimarchi	803
		804	if (scheduler_id!=local_scheduler_arg->policy)
		805	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		806
221	giacomo	807	/* Check if thread is already bind */
		808	switch (scheduler_id) {
952	trimarchi	809	case FSF_RR:
221	giacomo	810
888	trimarchi	811	nrt_task_def_arg((NRT_TASK_MODEL )(local_scheduler_arg->params),arg);
		812	nrt_task_def_level((NRT_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
221	giacomo	813
888	trimarchi	814	*thread = task_create("POSIXSTAR", thread_code, local_scheduler_arg->params, NULL);
267	giacomo	815	if (*thread == NIL) {
		816	#ifdef FSF_DEBUG
		817	kern_printf("(FSF:Error creating thread)");
		818	#endif
873	trimarchi	819	return FSF_ERR_INTERNAL_ERROR;
267	giacomo	820	}
221	giacomo	821
241	giacomo	822	POSIXSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
234	giacomo	823
221	giacomo	824	break;
868	trimarchi	825	case FSF_EDF:
221	giacomo	826
888	trimarchi	827	hard_task_def_arg((HARD_TASK_MODEL )(local_scheduler_arg->params),arg);
		828	hard_task_def_level((HARD_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
250	giacomo	829
888	trimarchi	830	*thread = task_create("EDFSTAR", thread_code, local_scheduler_arg->params, NULL);
250	giacomo	831	if (*thread == NIL)
873	trimarchi	832	return FSF_ERR_INTERNAL_ERROR;
250	giacomo	833
		834	EDFSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
		835
221	giacomo	836	break;
235	giacomo	837
1008	trimarchi	838	case FSF_FEDF:
		839	hard_task_def_arg((HARD_TASK_MODEL )(local_scheduler_arg->params),arg);
		840	hard_task_def_level((HARD_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
		841
		842	*thread = task_create("FEDFSTAR", thread_code, local_scheduler_arg->params, NULL);
		843	if (*thread == NIL)
		844	return FSF_ERR_INTERNAL_ERROR;
		845
		846	FEDFSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
		847
		848	break;
		849
952	trimarchi	850	case FSF_FP:
235	giacomo	851
888	trimarchi	852	hard_task_def_arg((HARD_TASK_MODEL )(local_scheduler_arg->params),arg);
		853	hard_task_def_level((HARD_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
273	giacomo	854
888	trimarchi	855	*thread = task_create("RMSTAR", thread_code, local_scheduler_arg->params, NULL);
273	giacomo	856	if (*thread == NIL)
873	trimarchi	857	return FSF_ERR_INTERNAL_ERROR;
273	giacomo	858
		859	RMSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
		860
		861	break;
868	trimarchi	862	case FSF_NONE:
334	giacomo	863
888	trimarchi	864	dummy_task_def_arg(( DUMMY_TASK_MODEL )(local_scheduler_arg->params),arg);
		865	dummy_task_def_level(( DUMMY_TASK_MODEL )(local_scheduler_arg->params),local_scheduler_level);
910	trimarchi	866
888	trimarchi	867	*thread = task_create("NONESTAR", thread_code, local_scheduler_arg->params, NULL);
334	giacomo	868	if (*thread == NIL)
873	trimarchi	869	return FSF_ERR_INTERNAL_ERROR;
334	giacomo	870
855	trimarchi	871	NONESTAR_setbudget(local_scheduler_level, *thread, (int)(server));
334	giacomo	872
		873	break;
910	trimarchi	874
		875	case FSF_TABLE_DRIVEN:
		876	{
944	trimarchi	877	HARD_TASK_MODEL ht;
		878	hard_task_default_model(ht);
		879	hard_task_def_aperiodic(ht);
910	trimarchi	880
944	trimarchi	881	hard_task_def_arg(ht,arg);
		882	hard_task_def_level(ht,local_scheduler_level);
910	trimarchi	883
944	trimarchi	884	*thread = task_create("TDSTAR", thread_code, &ht, NULL);
910	trimarchi	885	if (*thread == NIL)
		886	return FSF_ERR_INTERNAL_ERROR;
		887
930	trimarchi	888	TDSTAR_setbudget(local_scheduler_level, *thread, (int)(server));
944	trimarchi	889	TDSTAR_settable(local_scheduler_level, (fsf_table_driven_params_t )(local_scheduler_arg->params),thread);
910	trimarchi	890	}
		891	break;
		892
334	giacomo	893
221	giacomo	894	default:
873	trimarchi	895	return FSF_ERR_INTERNAL_ERROR;
221	giacomo	896	break;
		897	}
811	trimarchi	898
		899	#ifdef FSF_DEBUG
		900	kern_printf("(FSF:Insert thread = %d to Server = %d)",*thread,server);
		901	#endif
221	giacomo	902
		903	return 0;
		904
		905	}
		906
808	trimarchi	907	int fsf_settask_nopreemptive
221	giacomo	908	(fsf_server_id_t *server,
		909	pthread_t thread)
		910	{
		911	int local_scheduler_level, scheduler_id;
		912
241	giacomo	913	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		914	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
221	giacomo	915
		916	switch (scheduler_id) {
952	trimarchi	917	case FSF_RR:
816	trimarchi	918	POSIXSTAR_set_nopreemtive_current(local_scheduler_level);
		919	return 1;
808	trimarchi	920	break;
868	trimarchi	921	case FSF_EDF:
808	trimarchi	922	EDFSTAR_set_nopreemtive_current(local_scheduler_level);
		923	return 1;
		924	break;
1008	trimarchi	925	case FSF_FEDF:
		926	FEDFSTAR_set_nopreemtive_current(local_scheduler_level);
		927	return 1;
		928	break;
		929
952	trimarchi	930	case FSF_FP:
812	trimarchi	931	RMSTAR_set_nopreemtive_current(local_scheduler_level);
		932	return 1;
808	trimarchi	933	break;
868	trimarchi	934	case FSF_NONE:
808	trimarchi	935	break;
		936	default:
		937	return -1;
		938	}
		939	return -1;
		940	}
		941
		942
		943	int fsf_settask_preemptive
		944	(fsf_server_id_t *server,
		945	pthread_t thread)
		946	{
		947	int local_scheduler_level, scheduler_id;
		948
		949	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		950	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
		951
		952	switch (scheduler_id) {
952	trimarchi	953	case FSF_RR:
823	trimarchi	954	POSIXSTAR_unset_nopreemtive_current(local_scheduler_level);
816	trimarchi	955	return 1;
808	trimarchi	956	break;
868	trimarchi	957	case FSF_EDF:
808	trimarchi	958	EDFSTAR_unset_nopreemtive_current(local_scheduler_level);
		959	return 1;
		960	break;
1008	trimarchi	961
		962	case FSF_FEDF:
		963	EDFSTAR_unset_nopreemtive_current(local_scheduler_level);
		964	return 1;
		965	break;
		966
952	trimarchi	967	case FSF_FP:
812	trimarchi	968	RMSTAR_unset_nopreemtive_current(local_scheduler_level);
		969	return 1;
808	trimarchi	970	break;
868	trimarchi	971	case FSF_NONE:
808	trimarchi	972	break;
		973	default:
		974	return -1;
		975	}
		976
		977	return -1;
		978
		979	}
		980
		981
		982	int fsf_get_server
868	trimarchi	983	(pthread_t thread,
		984	fsf_server_id_t *server)
808	trimarchi	985	{
		986	int local_scheduler_level, scheduler_id;
		987
		988	local_scheduler_level = SERVER_get_local_scheduler_level_from_pid(fsf_server_level,thread);
		989	scheduler_id = SERVER_get_local_scheduler_id_from_pid(fsf_server_level, thread);
		990
		991	switch (scheduler_id) {
952	trimarchi	992	case FSF_RR:
829	giacomo	993	*server = POSIXSTAR_getbudget(local_scheduler_level,thread);
		994	return 0;
868	trimarchi	995	case FSF_EDF:
829	giacomo	996	*server = EDFSTAR_getbudget(local_scheduler_level,thread);
		997	return 0;
1008	trimarchi	998	case FSF_FEDF:
		999	*server = FEDFSTAR_getbudget(local_scheduler_level,thread);
		1000	return 0;
		1001
952	trimarchi	1002	case FSF_FP:
829	giacomo	1003	*server = RMSTAR_getbudget(local_scheduler_level,thread);
		1004	return 0;
868	trimarchi	1005	case FSF_NONE:
855	trimarchi	1006	*server = NONESTAR_getbudget(local_scheduler_level,thread);
829	giacomo	1007	return 0;
235	giacomo	1008	default:
221	giacomo	1009	return -1;
		1010	}
		1011
		1012	return -1;
		1013
		1014	}
		1015
339	giacomo	1016	int fsf_get_server_level(void)
		1017	{
		1018
		1019	return fsf_server_level;
		1020
		1021	}
		1022
221	giacomo	1023	int fsf_cancel_contract
868	trimarchi	1024	(fsf_server_id_t server)
221	giacomo	1025	{
		1026
		1027	int local_scheduler_level, scheduler_id;
411	trimarchi	1028	SYS_FLAGS f;
		1029	TIME T,Q;
963	trimarchi	1030	int i=0,err=0;
221	giacomo	1031
963	trimarchi	1032
221	giacomo	1033	#ifdef FSF_DEBUG
868	trimarchi	1034	kern_printf("(Remove server %d)",server);
221	giacomo	1035	#endif
		1036
		1037	/* Check server id */
868	trimarchi	1038	if (server < 0)
873	trimarchi	1039	return FSF_ERR_BAD_ARGUMENT;
221	giacomo	1040
868	trimarchi	1041	local_scheduler_level = SERVER_get_local_scheduler_level_from_budget(fsf_server_level,server);
		1042	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
221	giacomo	1043
		1044	switch (scheduler_id) {
952	trimarchi	1045	case FSF_RR:
221	giacomo	1046
		1047	/* Check if some thread use the server */
868	trimarchi	1048	if(POSIXSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	1049	return FSF_ERR_NOT_CONTRACTED_SERVER;
221	giacomo	1050
		1051	break;
868	trimarchi	1052	case FSF_EDF:
235	giacomo	1053	/* Check if some thread use the server */
868	trimarchi	1054	if(EDFSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	1055	return FSF_ERR_NOT_CONTRACTED_SERVER;
235	giacomo	1056	break;
		1057
1008	trimarchi	1058	case FSF_FEDF:
		1059	/* Check if some thread use the server */
		1060	if(FEDFSTAR_budget_has_thread(local_scheduler_level,server))
		1061	return FSF_ERR_NOT_CONTRACTED_SERVER;
		1062	break;
		1063
952	trimarchi	1064	case FSF_FP:
235	giacomo	1065	/* Check if some thread use the server */
868	trimarchi	1066	if(RMSTAR_budget_has_thread(local_scheduler_level,server))
873	trimarchi	1067	return FSF_ERR_NOT_CONTRACTED_SERVER;
235	giacomo	1068
221	giacomo	1069	break;
334	giacomo	1070
868	trimarchi	1071	case FSF_NONE:
334	giacomo	1072	/* Check if some thread use the server */
963	trimarchi	1073	if(NONESTAR_budget_has_thread(local_scheduler_level,server)) {
		1074	err=fsf_unbind_thread_from_server(NONESTAR_get_current(local_scheduler_level));
		1075	if (err) return err;
		1076	}
334	giacomo	1077
		1078	break;
		1079
221	giacomo	1080	}
963	trimarchi	1081
868	trimarchi	1082	SERVER_removebudget(fsf_server_level,server);
221	giacomo	1083
		1084	level_free_descriptor(local_scheduler_level);
405	trimarchi	1085
868	trimarchi	1086	remove_contract(server);
411	trimarchi	1087
		1088	f=kern_fsave();
		1089	if (recalculate_contract(fsf_max_bw)==-1) {
		1090	kern_frestore(f);
873	trimarchi	1091	return FSF_ERR_INTERNAL_ERROR;
411	trimarchi	1092	}
		1093	#ifdef FSF_DEBUG
		1094	kern_printf("(Adjust budget)");
		1095	#endif
		1096	for (i=0; i<current_server; i++) {
963	trimarchi	1097
411	trimarchi	1098	mul32div32to32(MAX_BANDWIDTH,server_list[i].Cmin,server_list[i].U,T);
963	trimarchi	1099
417	giacomo	1100	if (T > server_list[i].Tmin ) {
411	trimarchi	1101	server_list[i].actual_budget = server_list[i].Cmin;
963	trimarchi	1102
		1103	if (T > server_list[i].Tmax)
		1104	T=server_list[i].Tmax;
		1105
411	trimarchi	1106	server_list[i].actual_period = T;
963	trimarchi	1107	server_list[i].actual_budget = server_list[i].Cmin;
		1108
417	giacomo	1109	#ifdef FSF_DEBUG
		1110	kern_printf("(1 - Q %ld T %ld)", server_list[i].actual_budget, server_list[i].actual_period);
		1111	#endif
963	trimarchi	1112
908	trimarchi	1113	if (server_list[i].d_equals_t == true)
963	trimarchi	1114	adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T);
661	giacomo	1115	else
963	trimarchi	1116	adjust_SERVER_budget(server_list[i].server,server_list[i].Cmin, T, T); // server_list[i].deadline);
		1117
411	trimarchi	1118	} else {
963	trimarchi	1119
417	giacomo	1120	mul32div32to32(server_list[i].Tmin,server_list[i].U,MAX_BANDWIDTH,Q);
963	trimarchi	1121
		1122
		1123	if (Q>server_list[i].Cmax)
		1124	Q=server_list[i].Cmax;
		1125
411	trimarchi	1126	server_list[i].actual_budget = Q;
417	giacomo	1127	server_list[i].actual_period = server_list[i].Tmin;
		1128	#ifdef FSF_DEBUG
		1129	kern_printf("(2 - Q %ld T %ld)", server_list[i].actual_budget, server_list[i].actual_period);
		1130	#endif
661	giacomo	1131
908	trimarchi	1132	if (server_list[i].d_equals_t == true)
963	trimarchi	1133	adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin);
661	giacomo	1134	else
963	trimarchi	1135	adjust_SERVER_budget(server_list[i].server,Q, server_list[i].Tmin, server_list[i].Tmin); //server_list[i].deadline);
661	giacomo	1136
963	trimarchi	1137
411	trimarchi	1138	}
416	trimarchi	1139	server_list[i].U=server_list[i].Umin;
411	trimarchi	1140
		1141	}
221	giacomo	1142
405	trimarchi	1143
411	trimarchi	1144	kern_frestore(f);
221	giacomo	1145
		1146	return 0;
411	trimarchi	1147
221	giacomo	1148	}
		1149
881	trimarchi	1150	bandwidth_t SERVER_return_bandwidth() {
		1151	int i=0;
		1152	bandwidth_t U;
		1153	U=0;
		1154	for(i=0;i<current_server;i++) {
		1155
		1156	U+=server_list[i].Umin;
		1157
		1158	}
		1159
		1160	return U;
		1161	}
		1162
405	trimarchi	1163	int recalculate_contract(bandwidth_t U) {
416	trimarchi	1164	bandwidth_t current_bandwidth;
418	giacomo	1165	unsigned int temp_U;
416	trimarchi	1166	int Qt;
405	trimarchi	1167	int isok=0;
		1168	int i=0;
868	trimarchi	1169	int target_importance=FSF_DEFAULT_IMPORTANCE;
		1170
		1171	#define MAX_IMPORTANCE 5
405	trimarchi	1172
896	trimarchi	1173	#ifdef FSF_DEBUG
		1174	int temp;
		1175
908	trimarchi	1176	kern_printf("(RC)");
896	trimarchi	1177	#endif
405	trimarchi	1178
		1179	/* The current bandwidth is the min bandwidth */
881	trimarchi	1180	current_bandwidth=SERVER_return_bandwidth(fsf_server_level);
405	trimarchi	1181	#ifdef FSF_DEBUG
908	trimarchi	1182	kern_printf("(SER%d)", current_server);
405	trimarchi	1183	#endif
880	trimarchi	1184	//kern_printf("(CS:%d)", current_server);
405	trimarchi	1185	do {
		1186	current_bandwidth=0;
		1187	Qt=0;
410	trimarchi	1188	for (i=0; i<current_server; i++) {
843	trimarchi	1189	if (server_list[i].Is==target_importance
		1190	&& server_list[i].U<server_list[i].Umax && server_list[i].Qs>0)
405	trimarchi	1191	Qt+=server_list[i].Qs;
416	trimarchi	1192	current_bandwidth+=server_list[i].U;
868	trimarchi	1193	#ifdef FSF_DEBUG
843	trimarchi	1194	kern_printf("(Qs %d, Qt %d, Is %d)", server_list[i].Qs, Qt,server_list[i].Is);
868	trimarchi	1195	#endif
405	trimarchi	1196	}
413	trimarchi	1197
868	trimarchi	1198	#ifdef FSF_DEBUG
908	trimarchi	1199	kern_printf("(TQ%d)", Qt);
868	trimarchi	1200	#endif
405	trimarchi	1201	isok=1;
410	trimarchi	1202	for (i=0; i<current_server; i++) {
843	trimarchi	1203	if (server_list[i].Is==target_importance && server_list[i].U<server_list[i].Umax && server_list[i].Qs>0) {
416	trimarchi	1204	temp_U=server_list[i].U;
		1205	server_list[i].U=U-current_bandwidth;
963	trimarchi	1206	//kern_printf("before mull");
416	trimarchi	1207	mul32div32to32(server_list[i].U, server_list[i].Qs, Qt, server_list[i].U);
963	trimarchi	1208	//kern_printf("after mull");
416	trimarchi	1209	temp_U+=server_list[i].U;
		1210
		1211	if (temp_U<=server_list[i].Umin) {
405	trimarchi	1212	server_list[i].U=server_list[i].Umin;
416	trimarchi	1213	} else if (temp_U>server_list[i].Umax) {
		1214	server_list[i].U=server_list[i].Umax;
405	trimarchi	1215	isok=0;
		1216	} else server_list[i].U=temp_U;
		1217
		1218	#ifdef FSF_DEBUG
		1219	mul32div32to32(server_list[i].U,100, MAX_BANDWIDTH, temp);
908	trimarchi	1220	kern_printf("(SER %d BW %d)", server_list[i].server, temp);
405	trimarchi	1221	#endif
		1222	}
		1223	}
843	trimarchi	1224	target_importance++;
880	trimarchi	1225	} while (!isok \|\| target_importance<=MAX_IMPORTANCE);
963	trimarchi	1226
405	trimarchi	1227	return 0;
		1228	}
		1229
937	trimarchi	1230
		1231	int fsf_negotiate_group
		1232	(const fsf_contracts_group_t *contracts_up,
		1233	const fsf_servers_group_t *severs_down,
		1234	fsf_servers_group_t *severs_up,
		1235	bool *accepted) {
		1236
		1237	return 0;
		1238	}
		1239
221	giacomo	1240	int fsf_renegotiate_contract
		1241	(const fsf_contract_parameters_t *new_contract,
		1242	fsf_server_id_t server)
		1243	{
679	trimarchi	1244
908	trimarchi	1245	struct mess msg;
221	giacomo	1246
679	trimarchi	1247	// send response server is -1 if the operation fail
908	trimarchi	1248	msg.type=RENEGOTIATE_CONTRACT;
1008	trimarchi	1249	copy_contract(&msg.contract,new_contract);
908	trimarchi	1250	msg.server = server;
		1251	//kern_printf("(REN %d)", server);
		1252	port_send(channel[1],&msg,BLOCK);
963	trimarchi	1253	//kern_printf("After send\n");
908	trimarchi	1254	port_receive(channel[0], &msg, BLOCK);
963	trimarchi	1255	//kern_printf("After receive\n");
		1256	//kern_printf("(EREN %d)", msg.server);
908	trimarchi	1257	if (msg.server==-1) return FSF_ERR_CONTRACT_REJECTED;
679	trimarchi	1258
405	trimarchi	1259	return 0;
221	giacomo	1260	}
241	giacomo	1261
868	trimarchi	1262	int fsf_request_contract_renegotiation
		1263	(const fsf_contract_parameters_t *new_contract,
		1264	fsf_server_id_t server,
		1265	int sig_notify,
		1266	union sigval sig_value)
		1267	{
		1268
908	trimarchi	1269	struct mess msg;
868	trimarchi	1270
		1271	// send response server is -1 if the operation fail
908	trimarchi	1272	msg.type=REQUEST_RENEGOTIATE_CONTRACT;
1008	trimarchi	1273	copy_contract(&msg.contract,new_contract);
908	trimarchi	1274	msg.server = server;
910	trimarchi	1275	msg.sig_notify=sig_notify;
		1276	msg.sig_value=sig_value;
		1277	msg.process=exec_shadow;
868	trimarchi	1278
908	trimarchi	1279	port_send(channel[1],&msg,BLOCK);
868	trimarchi	1280
908	trimarchi	1281	port_receive(channel[0], &msg, BLOCK);
868	trimarchi	1282
908	trimarchi	1283	if (msg.server==-1) return FSF_ERR_CONTRACT_REJECTED;
868	trimarchi	1284
		1285	return 0;
		1286	}
		1287
407	giacomo	1288	void print_server_list()
		1289	{
		1290
		1291	int i;
		1292
		1293	kern_printf("Server List\n");
		1294
410	trimarchi	1295	for(i=0;i<current_server;i++) {
407	giacomo	1296
662	giacomo	1297	kern_printf("[%d] Q:%d T:%d D:%d [DeT = %d]\n",server_list[i].server,(int)server_list[i].actual_budget,(int)server_list[i].actual_period,(int)server_list[i].deadline,(int)server_list[i].d_equals_t);
407	giacomo	1298
		1299	}
		1300
		1301	}
808	trimarchi	1302
963	trimarchi	1303	int
		1304	fsf_get_remaining_budget
		1305	(fsf_server_id_t server,
		1306	struct timespec *budget) {
		1307	TIME t;
		1308	NULL_TIMESPEC(budget);
		1309	t=SERVER_get_remain_capacity(fsf_server_level, server);
		1310	ADDUSEC2TIMESPEC(t, budget);
		1311	return 0;
		1312
		1313
		1314	}
		1315	/*
		1316	int fsf_get_remaining_budget(fsf_server_id_t server) {
		1317
825	trimarchi	1318	return SERVER_get_remain_capacity(fsf_server_level, server);
808	trimarchi	1319	}
963	trimarchi	1320	*/
868	trimarchi	1321	int fsf_get_budget_and_period
		1322	(fsf_server_id_t server,
		1323	struct timespec *budget,
		1324	struct timespec *period) {
		1325	TIME bg;
		1326	TIME pd;
		1327
		1328	if (!SERVER_getbudgetinfo(fsf_server_level, &bg, &pd, NULL, server)) {
		1329	if (budget) {
		1330	NULL_TIMESPEC(budget);
		1331	ADDUSEC2TIMESPEC(bg, budget);
		1332	}
		1333	if (period) {
		1334	NULL_TIMESPEC(period);
		1335	ADDUSEC2TIMESPEC(pd, period);
		1336	}
		1337
		1338	return 0;
		1339	}
		1340	return FSF_ERR_BAD_ARGUMENT;
		1341	}
		1342
		1343	int
		1344	fsf_set_service_thread_data
		1345	(const struct timespec *budget,
		1346	const struct timespec *period,
		1347	bool *accepted) {
		1348
		1349	if (budget==NULL && period==NULL) return FSF_ERR_BAD_ARGUMENT;
		1350	fsf_set_contract_basic_parameters(&service_contract,budget,period,FSF_DEFAULT_WORKLOAD);
		1351	*accepted = !fsf_renegotiate_contract(&service_contract,service_server)?true:false;
		1352	return 0;
		1353
		1354	}
		1355
		1356
		1357
		1358	int fsf_get_service_thread_data
		1359	(struct timespec *budget,
		1360	struct timespec *period) {
		1361
		1362	return fsf_get_budget_and_period(service_server, budget, period);
		1363
		1364	}
944	trimarchi	1365
		1366	int fsf_init_local_scheduler(fsf_server_id_t server,
		1367	fsf_sched_init_info_t info) {
		1368	int scheduler_id, local_scheduler_level;
		1369
		1370	struct timespec duration=(struct timespec )info;
		1371
		1372	local_scheduler_level=SERVER_get_local_scheduler_level_from_budget(fsf_server_level, server);
		1373	scheduler_id = SERVER_get_local_scheduler_id_from_budget(fsf_server_level,server);
		1374
		1375	if (scheduler_id!=FSF_TABLE_DRIVEN)
		1376	return FSF_ERR_SCHED_POLICY_NOT_COMPATIBLE;
		1377
		1378	if (duration->tv_sec < 0 \|\| duration->tv_nsec > 1000000000)
		1379	return FSF_ERR_BAD_ARGUMENT;
		1380
		1381	//TDSTAR_debugtable(local_scheduler_level);
		1382	TDSTAR_start_simulation(local_scheduler_level);
		1383	return 0;
		1384
		1385	}
963	trimarchi	1386
		1387	int
		1388	fsf_get_total_quality
		1389	(fsf_server_id_t server, int *total_quality) {
996	trimarchi	1390	int server_importance;
		1391	int i=0,Qt=0;
963	trimarchi	1392
996	trimarchi	1393	while(i<current_server) {
		1394	if (server_list[i].server==server) break;
		1395	i++;
		1396	}
		1397	if (i==current_server) return FSF_ERR_BAD_ARGUMENT;
		1398	else server_importance=server_list[i].Is;
		1399
		1400	for (i=0; i<current_server; i++) {
		1401	if (server_list[i].Is==server_importance)
		1402	Qt+=server_list[i].Qs;
		1403	}
		1404
		1405	return Qt;
963	trimarchi	1406	}
		1407
		1408	int
		1409	fsf_get_available_capacity (
		1410	fsf_server_id_t server, uint32_t *capacity){
		1411
		1412	return 0;
		1413	}
		1414
		1415	bool
		1416	fsf_is_admission_test_enabled() {
		1417	return true;
		1418	}
		1419
		1420
		1421	int
		1422	fsf_get_cpu_time
		1423	(fsf_server_id_t server,
		1424	struct timespec *cpu_time) {
		1425
		1426	return 0;
		1427	}
		1428
		1429
		1430	int
		1431	fsf_get_contract
		1432	(fsf_server_id_t server,
		1433	fsf_contract_parameters_t *contract) {
		1434
		1435	return 0;
		1436	}

Subversion Repositories shark

(root)/shark/branches/xen/ports/first/first-server.c - Rev 1618