Context Navigation

source: soft/giet_vm/giet_libs/stdio.c @ 336

Last change on this file since 336 was 331, checked in by alain, 10 years ago
Cosmetic.
Property svn:executable set to ``*
File size: 23.8 KB

Rev	Line
[258]	1	//////////////////////////////////////////////////////////////////////////////////
	2	// File : stdio.c
	3	// Date : 01/04/2010
	4	// Author : alain greiner & Joel Porquet
	5	// Copyright (c) UPMC-LIP6
	6	///////////////////////////////////////////////////////////////////////////////////
	7	// The stdio.c and stdio.h files are part of the GIET_VM nano-kernel.
	8	// This library contains all user-level functions that contain a system call
	9	// to access protected or shared ressources.
	10	///////////////////////////////////////////////////////////////////////////////////
	11
	12	#include <stdarg.h>
	13	#include <stdio.h>
[267]	14	#include <giet_config.h>
[258]	15
	16	////////////////////////////////////////////////////////////////////////////////////
	17	////////////////////// MIPS32 related system calls ///////////////////////////////
	18	////////////////////////////////////////////////////////////////////////////////////
	19
	20	////////////////////////////////////////////////////////////////////////////////////
[295]	21	///////////////////// TTY device related system calls /////////////////////////////
[258]	22	////////////////////////////////////////////////////////////////////////////////////
[295]	23
	24	////////////////////////////////////////
	25	void giet_tty_printf( char* format, ...)
[258]	26	{
[295]	27	va_list args;
	28	va_start( args, format );
[258]	29
[331]	30	int ret; // return value from the syscalls
	31	unsigned int channel = 0xFFFFFFFF; // channel defined in task context
[258]	32
[295]	33	printf_text:
[258]	34
[295]	35	while (*format)
[258]	36	{
[295]	37	unsigned int i;
	38	for (i = 0 ; format[i] && (format[i] != '%') ; i++);
	39	if (i)
	40	{
	41	ret = sys_call(SYSCALL_TTY_WRITE,
	42	(unsigned int)format,
	43	i,
	44	channel,
[258]	45	0);
	46
[295]	47	if (ret != i) goto return_error;
	48
	49	format += i;
[258]	50	}
[295]	51	if (*format == '%')
[258]	52	{
[295]	53	format++;
	54	goto printf_arguments;
[258]	55	}
	56	}
	57
[295]	58	va_end( args );
	59	return;
	60
	61	printf_arguments:
	62
[258]	63	{
[295]	64	char buf[20];
	65	char * pbuf;
	66	unsigned int len = 0;
	67	static const char HexaTab[] = "0123456789ABCDEF";
	68	unsigned int i;
[258]	69
[295]	70	switch (*format++)
[258]	71	{
[295]	72	case ('c'): /* char conversion */
[258]	73	{
[295]	74	int val = va_arg( args, int );
	75	len = 1;
	76	buf[0] = val;
	77	pbuf = &buf[0];
	78	break;
[258]	79	}
[295]	80	case ('d'): /* 32 bits decimal signed integer */
[258]	81	{
[295]	82	int val = va_arg( args, int );
	83	if (val < 0)
	84	{
	85	val = -val;
	86	ret = sys_call(SYSCALL_TTY_WRITE,
	87	(unsigned int)"-",
	88	1,
	89	channel,
	90	0);
	91	if (ret != 1) goto return_error;
	92	}
	93	for(i = 0; i < 10; i++)
	94	{
	95	buf[9 - i] = HexaTab[val % 10];
	96	if (!(val /= 10)) break;
	97	}
	98	len = i + 1;
	99	pbuf = &buf[9 - i];
	100	break;
[258]	101	}
[295]	102	case ('u'): /* 32 bits decimal unsigned integer */
	103	{
	104	unsigned int val = va_arg( args, unsigned int );
	105	for(i = 0; i < 10; i++)
	106	{
	107	buf[9 - i] = HexaTab[val % 10];
	108	if (!(val /= 10)) break;
	109	}
	110	len = i + 1;
	111	pbuf = &buf[9 - i];
	112	break;
	113	}
	114	case ('x'): /* 32 bits hexadecimal integer */
	115	{
	116	unsigned int val = va_arg( args, unsigned int );
	117	ret = sys_call(SYSCALL_TTY_WRITE,
	118	(unsigned int)"0x",
	119	2,
	120	channel,
	121	0);
	122	if (ret != 2) goto return_error;
	123	for(i = 0; i < 8; i++)
	124	{
	125	buf[7 - i] = HexaTab[val % 16];
	126	if (!(val /= 16)) break;
	127	}
	128	len = i + 1;
	129	pbuf = &buf[7 - i];
	130	break;
	131	}
	132	case ('l'): /* 64 bits hexadecimal unsigned */
	133	{
	134	unsigned long long val = va_arg( args, unsigned long long );
	135	ret = sys_call(SYSCALL_TTY_WRITE,
	136	(unsigned int)"0x",
	137	2,
	138	channel,
	139	0);
	140	if (ret != 2) goto return_error;
	141	for(i = 0; i < 16; i++)
	142	{
	143	buf[15 - i] = HexaTab[val % 16];
	144	if (!(val /= 16)) break;
	145	}
	146	len = i + 1;
	147	pbuf = &buf[15 - i];
	148	break;
	149	}
	150	case ('s'): /* string */
	151	{
	152	char* str = va_arg( args, char* );
	153	while (str[len])
	154	{
	155	len++;
	156	}
	157	pbuf = str;
	158	break;
	159	}
	160	default:
	161	goto return_error;
[258]	162	}
	163
[295]	164	ret = sys_call(SYSCALL_TTY_WRITE,
	165	(unsigned int)pbuf,
	166	len,
	167	channel,
	168	0);
	169	if (ret != len) goto return_error;
	170
	171	goto printf_text;
[258]	172	}
	173
[295]	174	return_error:
	175
	176	va_end( args );
	177	giet_exit("error in giet_tty_printf()");
	178	} // end giet_tty_printf()
	179
	180	////////////////////////////////////////
	181	void giet_shr_printf( char* format, ...)
[258]	182	{
[295]	183	va_list args;
	184	va_start( args, format );
[258]	185
[295]	186	int ret; // return value from the syscalls
	187	unsigned int channel = 0;
	188	unsigned int sr_save;
[267]	189
[295]	190	sys_call( SYSCALL_TTY_GET_LOCK,
	191	channel,
	192	(unsigned int)&sr_save,
	193	0, 0 );
	194
[258]	195	printf_text:
	196
	197	while (*format)
	198	{
	199	unsigned int i;
	200	for (i = 0 ; format[i] && (format[i] != '%') ; i++);
	201	if (i)
	202	{
	203	ret = sys_call(SYSCALL_TTY_WRITE,
	204	(unsigned int)format,
	205	i,
[295]	206	channel,
[258]	207	0);
[267]	208
	209	if (ret != i) goto return_error;
	210
[258]	211	format += i;
	212	}
	213	if (*format == '%')
	214	{
	215	format++;
	216	goto printf_arguments;
	217	}
	218	}
	219
[295]	220	sys_call( SYSCALL_TTY_RELEASE_LOCK,
	221	channel,
	222	(unsigned int)&sr_save,
	223	0, 0 );
	224
	225	va_end( args );
	226	return;
[267]	227
[258]	228	printf_arguments:
	229
	230	{
	231	char buf[20];
	232	char * pbuf;
	233	unsigned int len = 0;
	234	static const char HexaTab[] = "0123456789ABCDEF";
	235	unsigned int i;
	236
[295]	237	switch (*format++)
	238	{
[258]	239	case ('c'): /* char conversion */
[295]	240	{
	241	int val = va_arg( args, int );
[258]	242	len = 1;
	243	buf[0] = val;
[295]	244	pbuf = &buf[0];
[258]	245	break;
[295]	246	}
	247	case ('d'): /* 32 bits decimal signed integer */
	248	{
	249	int val = va_arg( args, int );
[258]	250	if (val < 0)
	251	{
	252	val = -val;
	253	ret = sys_call(SYSCALL_TTY_WRITE,
	254	(unsigned int)"-",
	255	1,
[295]	256	channel,
[258]	257	0);
[267]	258	if (ret != 1) goto return_error;
[258]	259	}
	260	for(i = 0; i < 10; i++)
	261	{
	262	buf[9 - i] = HexaTab[val % 10];
	263	if (!(val /= 10)) break;
	264	}
	265	len = i + 1;
	266	pbuf = &buf[9 - i];
	267	break;
[295]	268	}
	269	case ('u'): /* 32 bits decimal unsigned integer */
	270	{
	271	unsigned int val = va_arg( args, unsigned int );
	272	for(i = 0; i < 10; i++)
	273	{
	274	buf[9 - i] = HexaTab[val % 10];
	275	if (!(val /= 10)) break;
	276	}
	277	len = i + 1;
	278	pbuf = &buf[9 - i];
	279	break;
	280	}
	281	case ('x'): /* 32 bits hexadecimal integer */
	282	{
	283	unsigned int val = va_arg( args, unsigned int );
[258]	284	ret = sys_call(SYSCALL_TTY_WRITE,
	285	(unsigned int)"0x",
	286	2,
[295]	287	channel,
[258]	288	0);
[295]	289	if (ret != 2) goto return_error;
[258]	290	for(i = 0; i < 8; i++)
	291	{
[295]	292	buf[7 - i] = HexaTab[val % 16];
	293	if (!(val /= 16)) break;
[258]	294	}
	295	len = i + 1;
	296	pbuf = &buf[7 - i];
	297	break;
[295]	298	}
	299	case ('l'): /* 64 bits hexadecimal unsigned */
	300	{
	301	unsigned long long val = va_arg( args, unsigned long long );
	302	ret = sys_call(SYSCALL_TTY_WRITE,
	303	(unsigned int)"0x",
	304	2,
	305	channel,
	306	0);
	307	if (ret != 2) goto return_error;
	308	for(i = 0; i < 16; i++)
	309	{
	310	buf[15 - i] = HexaTab[val % 16];
	311	if (!(val /= 16)) break;
	312	}
	313	len = i + 1;
	314	pbuf = &buf[15 - i];
	315	break;
	316	}
[258]	317	case ('s'): /* string */
[295]	318	{
	319	char* str = va_arg( args, char* );
	320	while (str[len])
[258]	321	{
[295]	322	len++;
[258]	323	}
[295]	324	pbuf = str;
[258]	325	break;
[295]	326	}
[258]	327	default:
[295]	328	goto return_error;
[258]	329	}
	330
	331	ret = sys_call(SYSCALL_TTY_WRITE,
	332	(unsigned int)pbuf,
	333	len,
[295]	334	channel,
[258]	335	0);
[267]	336	if (ret != len) goto return_error;
	337
[258]	338	goto printf_text;
	339	}
[267]	340
	341	return_error:
[295]	342
	343	sys_call( SYSCALL_TTY_RELEASE_LOCK,
	344	channel,
	345	(unsigned int)&sr_save,
	346	0, 0 );
	347
	348	va_end( args );
	349	giet_exit("error in giet_shr_printf()");
	350	} // end giet_shr_printf()
	351
	352
	353	/////////////////////////////////
	354	void giet_tty_getc( char * byte )
	355	{
	356	int ret;
	357
	358	do
[267]	359	{
[295]	360	ret = sys_call(SYSCALL_TTY_READ,
	361	(unsigned int)byte, // buffer address
	362	1, // number of characters
	363	0xFFFFFFFF, // channel index from task context
	364	0);
	365	if ( ret < 0 ) giet_exit("error in giet_tty_getc()");
[267]	366	}
[295]	367	while (ret != 1);
	368	}
[267]	369
[295]	370	/////////////////////////////////////
	371	void giet_tty_gets( char* buf,
	372	unsigned int bufsize )
	373	{
	374	int ret;
	375	unsigned char byte;
	376	unsigned int index = 0;
	377
	378	while (index < (bufsize - 1))
	379	{
	380	do
	381	{
	382	ret = sys_call(SYSCALL_TTY_READ,
	383	(unsigned int)(&byte),
	384	1,
	385	0xFFFFFFFF,
	386	0);
	387	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	388	}
	389	while (ret != 1);
	390
	391	if (byte == 0x0A) /* LF */
	392	{
	393	break;
	394	}
	395	else if ((byte == 0x7F) && (index > 0)) /* DEL */
	396	{
	397	index--;
	398	}
	399	else
	400	{
	401	buf[index] = byte;
	402	index++;
	403	}
	404	}
	405	buf[index] = 0;
[258]	406	}
	407
[295]	408	///////////////////////////////////////
	409	void giet_tty_getw( unsigned int* val )
	410	{
	411	unsigned char buf[32];
	412	unsigned int string_byte = 0x00000000; // string containing one single byte
	413	unsigned int string_cancel = 0x00082008; // string containing BS/SPACE/BS
	414	unsigned int save = 0;
	415	unsigned int dec = 0;
	416	unsigned int done = 0;
	417	unsigned int overflow = 0;
	418	unsigned int length = 0;
	419	unsigned int i;
	420	unsigned int channel = 0xFFFFFFFF;
	421	int ret; // return value from syscalls
	422
	423	// get characters
	424	while (done == 0)
	425	{
	426	// read one character
	427	do
	428	{
	429	ret = sys_call( SYSCALL_TTY_READ,
	430	(unsigned int)(&string_byte),
	431	1,
	432	channel,
	433	0);
	434	if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
	435	}
	436	while (ret != 1);
[258]	437
[295]	438	// analyse character
	439	if ((string_byte > 0x2F) && (string_byte < 0x3A)) /* decimal character */
	440	{
	441	buf[length] = (unsigned char)string_byte;
	442	length++;
[258]	443
[295]	444	// echo
	445	ret = sys_call( SYSCALL_TTY_WRITE,
	446	(unsigned int)(&string_byte),
	447	1,
	448	channel,
	449	0 );
	450	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	451	}
	452	else if (string_byte == 0x0A) /* LF character */
	453	{
	454	done = 1;
	455	}
	456	else if ( (string_byte == 0x7F) \|\| /* DEL character */
	457	(string_byte == 0x08) ) /* BS character */
	458	{
	459	if ( length > 0 )
	460	{
	461	length--; // cancel the character
	462
	463	ret = sys_call( SYSCALL_TTY_WRITE,
	464	(unsigned int)(&string_cancel),
	465	3,
	466	channel,
	467	0 );
	468	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	469	}
	470	}
	471
	472	// test buffer overflow
	473	if ( length >= 32 )
	474	{
	475	overflow = 1;
	476	done = 1;
	477	}
	478	} // end while characters
	479
	480	// string to int conversion with overflow detection
	481	if ( overflow == 0 )
	482	{
	483	for (i = 0; (i < length) && (overflow == 0) ; i++)
	484	{
	485	dec = dec * 10 + (buf[i] - 0x30);
	486	if (dec < save) overflow = 1;
	487	save = dec;
	488	}
	489	}
	490
	491	// final evaluation
	492	if ( overflow == 0 )
	493	{
	494	// return value
	495	*val = dec;
	496	}
	497	else
	498	{
	499	// cancel all echo characters
	500	for (i = 0; i < length ; i++)
	501	{
	502	ret = sys_call( SYSCALL_TTY_WRITE,
	503	(unsigned int)(&string_cancel),
	504	3,
	505	channel,
	506	0 );
	507	if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
	508	}
	509	// echo character '0'
	510	string_byte = 0x30;
	511	ret = sys_call( SYSCALL_TTY_WRITE,
	512	(unsigned int)(&string_byte),
	513	1,
	514	channel,
	515	0 );
	516	if ( ret < 0 ) giet_exit();
	517
	518	// return 0 value
	519	*val = 0;
	520	}
	521	}
	522
	523
[258]	524	//////////////////////////////////////////////////////////////////////////////////
	525	///////////////////// TIMER related system calls ////////////////////////////////
	526	//////////////////////////////////////////////////////////////////////////////////
	527
[295]	528	///////////////////////
	529	void giet_timer_start()
[258]	530	{
[295]	531	if ( sys_call( SYSCALL_TIMER_START, 0, 0, 0, 0 ) )
	532	giet_exit("error in giet_timer_start()");
[258]	533	}
[295]	534
	535	//////////////////////
	536	void giet_timer_stop()
[258]	537	{
[295]	538	if ( sys_call( SYSCALL_TIMER_STOP, 0, 0, 0, 0 ) )
	539	giet_exit("error in giet_timer_stop()");
[258]	540	}
	541
	542
	543	//////////////////////////////////////////////////////////////////////////////////
	544	/////////////// Frame buffer device related system calls ///////////////////////
	545	//////////////////////////////////////////////////////////////////////////////////
	546
[295]	547	////////////////////////////////////////////
	548	void giet_fb_sync_write( unsigned int offset,
[258]	549	void * buffer,
	550	unsigned int length )
	551	{
[295]	552	if ( sys_call( SYSCALL_FB_SYNC_WRITE,
	553	offset,
	554	(unsigned int)buffer,
	555	length,
	556	0 ) ) giet_exit("error in giet_fb_sync_write()");
[258]	557	}
[295]	558
	559	///////////////////////////////////////////
	560	void giet_fb_sync_read( unsigned int offset,
	561	void * buffer,
	562	unsigned int length )
[258]	563	{
[295]	564	if ( sys_call( SYSCALL_FB_SYNC_READ,
	565	offset,
	566	(unsigned int)buffer,
	567	length,
	568	0 ) ) giet_exit("error in giet_fb_sync_read()");
[258]	569	}
[295]	570
	571	/////////////////////////////////////////
	572	void giet_fb_cma_init( void * buf0,
	573	void * buf1,
	574	unsigned int length )
[258]	575	{
[295]	576	if ( sys_call( SYSCALL_FB_CMA_INIT,
	577	(unsigned int)buf0,
	578	(unsigned int)buf1,
	579	length,
	580	0 ) ) giet_exit("error in giet_fb_cma_init()");
[258]	581	}
[295]	582
	583	///////////////////////////////////////////////
	584	void giet_fb_cma_write( unsigned int buffer_id )
[258]	585	{
[295]	586	if ( sys_call( SYSCALL_FB_CMA_WRITE,
	587	buffer_id,
	588	0, 0, 0 ) ) giet_exit("error in giet_fb_cma_write()");
[258]	589	}
[295]	590
	591	////////////////////////
	592	void giet_fb_cma_stop()
[258]	593	{
[295]	594	if ( sys_call( SYSCALL_FB_CMA_STOP,
	595	0, 0, 0, 0 ) ) giet_exit("error in giet_fb_cma_stop()");
[258]	596	}
	597
	598
	599	//////////////////////////////////////////////////////////////////////////////////
	600	/////////////////////// NIC related system calls /////////////////////////////////
	601	//////////////////////////////////////////////////////////////////////////////////
	602
[295]	603	/////////////////////////
	604	void giet_nic_cma_start()
[258]	605	{
[295]	606	if ( sys_call( SYSCALL_NIC_CMA_START, 0, 0, 0, 0 ) )
	607	giet_exit("error in giet_nic_cma_start()");
[258]	608	}
[295]	609
	610	/////////////////////////
	611	void giet_nic_cma_stop()
[258]	612	{
[295]	613	if ( sys_call( SYSCALL_NIC_CMA_STOP, 0, 0, 0, 0 ) )
	614	giet_exit("error in giet_nic_cma_stop()");
[258]	615	}
	616
[295]	617	///////////////////////////////////////////////////////////////////////////////////
	618	///////////////////// FAT related system calls ////////////////////////////////////
	619	///////////////////////////////////////////////////////////////////////////////////
[258]	620
[295]	621	///////////////////////////////////////////
	622	int giet_fat_open( const char* pathname,
	623	unsigned int flags )
	624	{
	625	return sys_call( SYSCALL_FAT_OPEN,
	626	(unsigned int)pathname,
	627	flags,
	628	0, 0 );
	629	}
[258]	630
[295]	631	////////////////////////////////////
	632	void giet_fat_read( unsigned int fd,
	633	void* buffer,
	634	unsigned int count,
	635	unsigned int offset )
	636	{
	637	if ( sys_call( SYSCALL_FAT_READ,
	638	fd,
	639	(unsigned int)buffer,
	640	count,
	641	offset ) != count ) giet_exit("in giet_fat_read()");
	642	}
	643
	644	/////////////////////////////////////
	645	void giet_fat_write( unsigned int fd,
	646	void* buffer,
	647	unsigned int count,
	648	unsigned int offset )
	649	{
	650	if ( sys_call( SYSCALL_FAT_WRITE,
	651	fd,
	652	(unsigned int)buffer,
	653	count,
	654	offset ) != count ) giet_exit("in giet_fat_write()");
	655	}
	656
	657	/* variant implementing the UNIX spec
[258]	658	///////////////////////////////////////////////////////////////////////////////////
[295]	659	// This system call writes to a file identified by the "fd" file descriptor.
	660	// - "buffer" is the source buffer virtual address (must be word aligned).
	661	// - "count" is a number of bytes (must be multiple of 4).
	662	// It uses the implicit "lseek" pointer in file descriptor.
[258]	663	///////////////////////////////////////////////////////////////////////////////////
[295]	664	void giet_fat_write( unsigned int fd,
	665	void* buffer,
	666	unsigned int count ) // number of bytes
[258]	667	{
[295]	668	return sys_call( SYSCALL_FAT_WRITE,
	669	fd,
	670	(unsigned int)buffer,
	671	count, 0 );
[258]	672	}
[295]	673	*/
	674
	675	/////////////////////////////////////
	676	void giet_fat_lseek( unsigned int fd,
	677	unsigned int offset,
	678	unsigned int whence )
[258]	679	{
[295]	680	if ( sys_call( SYSCALL_FAT_LSEEK,
	681	fd,
	682	offset,
	683	whence,
	684	0 ) ) giet_exit("in giet_fat_lseek()");
[258]	685	}
[295]	686
	687	//////////////////////////////////////
	688	void giet_fat_fstat( unsigned int fd )
[258]	689	{
[295]	690	if ( sys_call( SYSCALL_FAT_FSTAT,
	691	fd,
	692	0, 0, 0 ) ) giet_exit("in giet_fat_lseek()");
[258]	693	}
[295]	694
	695	/////////////////////////////////////
	696	void giet_fat_close( unsigned int fd )
[258]	697	{
[295]	698	if ( sys_call( SYSCALL_FAT_CLOSE,
	699	fd,
	700	0, 0, 0 ) ) giet_exit("in giet_fat_close()");
[258]	701	}
[295]	702
	703
[258]	704	//////////////////////////////////////////////////////////////////////////////////
[295]	705	///////////////////// Miscellaneous system calls /////////////////////////////////
[258]	706	//////////////////////////////////////////////////////////////////////////////////
[295]	707
	708	/////////////////
	709	int giet_procid()
[258]	710	{
[295]	711	return sys_call( SYSCALL_PROCID,
[258]	712	0, 0, 0, 0 );
	713	}
[295]	714
	715	////////////////////
	716	int giet_proctime()
	717	{
	718	return sys_call( SYSCALL_PROCTIME,
	719	0, 0, 0, 0 );
	720	}
	721
	722	///////////////////////
[258]	723	int giet_proc_task_id()
	724	{
	725	return sys_call( SYSCALL_LOCAL_TASK_ID,
	726	0, 0, 0, 0 );
	727	}
[295]	728
	729	/////////////////////////
[258]	730	int giet_global_task_id()
	731	{
	732	return sys_call( SYSCALL_GLOBAL_TASK_ID,
	733	0, 0, 0, 0 );
	734	}
	735
[295]	736	////////////////////
[267]	737	int giet_thread_id()
	738	{
	739	return sys_call( SYSCALL_THREAD_ID,
	740	0, 0, 0, 0 );
	741	}
	742
[295]	743	///////////////
	744	int giet_rand()
[258]	745	{
[295]	746	unsigned int x = sys_call(SYSCALL_PROCTIME, 0, 0, 0, 0);
	747	if ((x & 0xF) > 7) {
	748	return (x*x & 0xFFFF);
	749	}
	750	else {
	751	return (xxx & 0xFFFF);
	752	}
[258]	753	}
[295]	754
	755	//////////////////////////////
	756	void giet_exit( char* string )
[258]	757	{
[295]	758	sys_call( SYSCALL_EXIT,
	759	(unsigned int)string,
	760	0, 0, 0 );
[258]	761	}
[295]	762
	763	/////////////////////////////////////////
	764	void giet_assert( unsigned int condition,
	765	char* string )
[258]	766	{
[295]	767	if ( condition == 0 ) giet_exit( string );
[258]	768	}
[295]	769
	770	////////////////////////////////////////////////////
	771	void giet_vobj_get_vbase( char* vspace_name,
	772	char* vobj_name,
	773	unsigned int* vobj_vaddr )
[258]	774	{
[295]	775	if ( sys_call( SYSCALL_VOBJ_GET_VBASE,
	776	(unsigned int) vspace_name,
	777	(unsigned int) vobj_name,
	778	(unsigned int) vobj_vaddr,
	779	0 ) ) giet_exit("in giet_vobj_get_vbase()");
[258]	780	}
[260]	781
[295]	782	///////////////////////////////////////////////
	783	void giet_proc_number( unsigned int cluster_id,
	784	unsigned int* buffer )
[260]	785	{
[295]	786	if ( sys_call( SYSCALL_PROC_NUMBER,
	787	cluster_id,
	788	(unsigned int) buffer,
	789	0, 0) ) giet_exit("in giet_proc_number()");
[260]	790	}
	791
[295]	792	//////////////////////////
	793	void giet_context_switch()
[258]	794	{
[295]	795	sys_call( SYSCALL_CTX_SWITCH,
	796	0, 0, 0, 0 );
[258]	797	}
	798
[295]	799	/////////////////////////////////////////
	800	void giet_heap_info( unsigned int* vaddr,
	801	unsigned int* length )
[258]	802	{
[295]	803	if ( sys_call( SYSCALL_HEAP_INFO,
	804	(unsigned int)vaddr,
	805	(unsigned int)length,
	806	0, 0 ) ) giet_exit("in giet_heap_info()");
[258]	807	}
	808
[295]	809
[258]	810	// Local Variables:
	811	// tab-width: 4
	812	// c-basic-offset: 4
	813	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	814	// indent-tabs-mode: nil
	815	// End:
	816	// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	817

Note: See TracBrowser for help on using the repository browser.

Download in other formats: