Context Navigation

source: trunk/kernel/fs/devfs.c @ 615

Last change on this file since 615 was 614, checked in by alain, 6 years ago

1) introduce a dev_ioc_sync_write() function in IOC API,

to improve the DEVFS synchronous update.

2) fix a big bug in both the user_dir_create() and user_dir_destroy()

functions: add an extended pointer on the reference client process
in the function's arguments.

File size: 26.0 KB

Line
1	/*
2	* devfs.c - DEVFS File system API implementation.
3	*
4	* Author Mohamed Lamine Karaoui (2014,2015)
5	* Alain Greiner (2016,2017)
6	*
7	* Copyright (c) Sorbonne Universites
8	*
9	* This file is part of ALMOS-MKH.
10	*
11	* ALMOS-MKH is free software; you can redistribute it and/or modify it
12	* under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; version 2.0 of the License.
14	*
15	* ALMOS-MKH is distributed in the hope that it will be useful, but
16	* WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18	* General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
22	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23	*/
24
25	#include <hal_kernel_types.h>
26	#include <hal_special.h>
27	#include <hal_uspace.h>
28	#include <printk.h>
29	#include <string.h>
30	#include <chdev.h>
31	#include <thread.h>
32	#include <dev_txt.h>
33	#include <cluster.h>
34	#include <vfs.h>
35	#include <kmem.h>
36	#include <devfs.h>
37
38	/////////////////////////////////////////////////////////////////////////////////////////
39	// Extern variables
40	/////////////////////////////////////////////////////////////////////////////////////////
41
42	extern vfs_ctx_t fs_context[]; // allocated in kernel_init.c
43	extern chdev_directory_t chdev_dir; // allocated in kernel_init.c
44
45	#if (DEBUG_SYS_READ & 1)
46	extern uint32_t enter_devfs_read;
47	extern uint32_t exit_devfs_read;
48	#endif
49
50	#if (DEBUG_SYS_WRITE & 1)
51	extern uint32_t enter_devfs_write;
52	extern uint32_t exit_devfs_write;
53	#endif
54
55	/////////////////////////////////////
56	devfs_ctx_t * devfs_ctx_alloc( void )
57	{
58	kmem_req_t req;
59
60	req.type = KMEM_DEVFS_CTX;
61	req.size = sizeof(devfs_ctx_t);
62	req.flags = AF_KERNEL \| AF_ZERO;
63
64	return (devfs_ctx_t *)kmem_alloc( &req );
65	}
66
67	/////////////////////////////////////////////
68	void devfs_ctx_init( devfs_ctx_t * devfs_ctx,
69	xptr_t devfs_dev_inode_xp,
70	xptr_t devfs_external_inode_xp )
71	{
72	devfs_ctx->dev_inode_xp = devfs_dev_inode_xp;
73	devfs_ctx->external_inode_xp = devfs_external_inode_xp;
74
75	fs_context[FS_TYPE_DEVFS].extend = devfs_ctx;
76	}
77
78	/////////////////////////////////////////////////
79	void devfs_ctx_destroy( devfs_ctx_t * devfs_ctx )
80	{
81	kmem_req_t req;
82
83	req.type = KMEM_DEVFS_CTX;
84	req.ptr = devfs_ctx;
85	kmem_free( &req );
86	}
87
88	/////////////////////////////////////////////////
89	void devfs_global_init( xptr_t root_inode_xp,
90	xptr_t * devfs_dev_inode_xp,
91	xptr_t * devfs_external_inode_xp )
92	{
93	error_t error;
94	xptr_t unused_xp; // required by vfs_add_child_in_parent()
95
96	// create DEVFS "dev" inode in cluster 0
97	error = vfs_add_child_in_parent( 0, // cxy
98	INODE_TYPE_DIR,
99	FS_TYPE_DEVFS,
100	root_inode_xp,
101	"dev",
102	&unused_xp,
103	devfs_dev_inode_xp );
104
105	// create dentries <.> and <..> in <dev>
106	error \|= vfs_add_special_dentries( *devfs_dev_inode_xp,
107	root_inode_xp );
108
109	// check success
110	assert( (error == 0) , "cannot create <dev>\n" );
111
112	#if DEBUG_DEVFS_GLOBAL_INIT
113	uint32_t cycle = (uint32_t)hal_get_cycles();
114	thread_t * this = CURRENT_THREAD;
115	if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
116	printk("\n[%s] thread[%x,%x] created <dev> inode / cycle %d\n",
117	__FUNCTION__, this->process->pid, this->trdid, cycle );
118	#endif
119
120	// create DEVFS "external" inode in cluster 0
121	error = vfs_add_child_in_parent( 0, // cxy
122	INODE_TYPE_DIR,
123	FS_TYPE_DEVFS,
124	*devfs_dev_inode_xp,
125	"external",
126	&unused_xp,
127	devfs_external_inode_xp );
128
129	// create dentries <.> and <..> in <external>
130	error \|= vfs_add_special_dentries( *devfs_external_inode_xp,
131	*devfs_dev_inode_xp );
132
133	// check success
134	assert( (error == 0) , "cannot create <external>\n" );
135
136	#if DEBUG_DEVFS_GLOBAL_INIT
137	cycle = (uint32_t)hal_get_cycles();
138	if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
139	printk("\n[%s] thread[%x,%x] created <external> inode / cycle %d\n",
140	__FUNCTION__, this->process->pid, this->trdid, cycle );
141	#endif
142
143	} // end devfs_global_init()
144
145	///////////////////////////////////////////////////
146	void devfs_local_init( xptr_t devfs_dev_inode_xp,
147	xptr_t devfs_external_inode_xp,
148	xptr_t * devfs_internal_inode_xp )
149	{
150	char node_name[16];
151	xptr_t chdev_xp;
152	cxy_t chdev_cxy;
153	chdev_t * chdev_ptr;
154	xptr_t inode_xp;
155	cxy_t inode_cxy;
156	vfs_inode_t * inode_ptr;
157	uint32_t channel;
158	xptr_t unused_xp; // required by add_child_in_parent()
159	error_t error;
160
161	#if DEBUG_DEVFS_LOCAL_INIT
162	uint32_t cycle = (uint32_t)hal_get_cycles();
163	thread_t * this = CURRENT_THREAD;
164	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
165	printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
166	__FUNCTION__, this->process->pid, this->trdid, cycle );
167	#endif
168
169	// create "internal" directory
170	snprintf( node_name , 16 , "internal_%x" , local_cxy );
171
172	error = vfs_add_child_in_parent( local_cxy,
173	INODE_TYPE_DIR,
174	FS_TYPE_DEVFS,
175	devfs_dev_inode_xp,
176	node_name,
177	&unused_xp,
178	devfs_internal_inode_xp );
179
180	// create dentries <.> and <..> in <internal>
181	error \|= vfs_add_special_dentries( *devfs_internal_inode_xp,
182	devfs_dev_inode_xp );
183
184	// check success
185	assert( (error == 0) , "cannot create <external>\n" );
186
187	#if DEBUG_DEVFS_LOCAL_INIT
188	cycle = (uint32_t)hal_get_cycles();
189	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
190	printk("\n[%s] thread[%x,%x] created <%s> inode in cluster %x / cycle %d\n",
191	__FUNCTION__, this->process->pid, this->trdid, node_name, local_cxy, cycle );
192	#endif
193
194	// create MMC chdev inode
195	chdev_xp = chdev_dir.mmc[local_cxy];
196	if( chdev_xp != XPTR_NULL)
197	{
198	chdev_ptr = GET_PTR( chdev_xp );
199	chdev_cxy = GET_CXY( chdev_xp );
200
201	assert( (chdev_cxy == local_cxy ), "illegal MMC chdev in cluster %x\n", local_cxy );
202
203	error = vfs_add_child_in_parent( local_cxy,
204	INODE_TYPE_DEV,
205	FS_TYPE_DEVFS,
206	*devfs_internal_inode_xp,
207	chdev_ptr->name,
208	&unused_xp,
209	&inode_xp );
210
211	assert( (error == 0) , "cannot create MMC inode\n" );
212
213	// update child inode "extend" field
214	inode_cxy = GET_CXY( inode_xp );
215	inode_ptr = GET_PTR( inode_xp );
216	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
217
218	#if DEBUG_DEVFS_LOCAL_INIT
219	cycle = (uint32_t)hal_get_cycles();
220	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
221	printk("\n[%s] thread[%x,%x] created <mmc> inode in cluster %x\n",
222	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
223	#endif
224
225	}
226
227	// create DMA chdev inodes (one DMA channel per core)
228	for( channel = 0 ; channel < LOCAL_CLUSTER->cores_nr ; channel++ )
229	{
230	chdev_xp = chdev_dir.dma[channel];
231	if( chdev_xp != XPTR_NULL)
232	{
233	chdev_ptr = GET_PTR( chdev_xp );
234	chdev_cxy = GET_CXY( chdev_xp );
235
236	assert( (chdev_cxy == local_cxy ), "illegal DMA chdev in cluster %x\n", local_cxy );
237
238	error = vfs_add_child_in_parent( local_cxy,
239	INODE_TYPE_DEV,
240	FS_TYPE_DEVFS,
241	*devfs_internal_inode_xp,
242	chdev_ptr->name,
243	&unused_xp,
244	&inode_xp );
245
246	assert( (error == 0) , "cannot create DMA inode\n" );
247
248	// update child inode "extend" field
249	inode_cxy = GET_CXY( inode_xp );
250	inode_ptr = GET_PTR( inode_xp );
251	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
252
253	#if DEBUG_DEVFS_LOCAL_INIT
254	cycle = (uint32_t)hal_get_cycles();
255	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
256	printk("\n[%s] thread [%x,%x] created <dma[%d]> inode in cluster %x\n",
257	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
258	#endif
259	}
260	}
261
262	// create an IOB inode in cluster containing IOB chdev
263	chdev_xp = chdev_dir.iob;
264	if( chdev_xp != XPTR_NULL )
265	{
266	chdev_cxy = GET_CXY( chdev_xp );
267	chdev_ptr = GET_PTR( chdev_xp );
268
269	if( chdev_cxy == local_cxy )
270	{
271	error = vfs_add_child_in_parent( local_cxy,
272	INODE_TYPE_DEV,
273	FS_TYPE_DEVFS,
274	devfs_external_inode_xp,
275	chdev_ptr->name,
276	&unused_xp,
277	&inode_xp );
278
279	assert( (error == 0) , "cannot create IOB inode\n" );
280
281	// update child inode "extend" field
282	inode_cxy = GET_CXY( inode_xp );
283	inode_ptr = GET_PTR( inode_xp );
284	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
285
286	#if DEBUG_DEVFS_LOCAL_INIT
287	cycle = (uint32_t)hal_get_cycles();
288	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
289	printk("\n[%s] thread[%x,%x] created <iob> inode in cluster %x\n",
290	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
291	#endif
292	}
293	}
294
295	// create a PIC inode in cluster containing PIC chdev
296	chdev_xp = chdev_dir.pic;
297	if( chdev_xp != XPTR_NULL )
298	{
299	chdev_cxy = GET_CXY( chdev_xp );
300	chdev_ptr = GET_PTR( chdev_xp );
301
302	if( chdev_cxy == local_cxy )
303	{
304	error = vfs_add_child_in_parent( local_cxy,
305	INODE_TYPE_DEV,
306	FS_TYPE_DEVFS,
307	devfs_external_inode_xp,
308	chdev_ptr->name,
309	&unused_xp,
310	&inode_xp );
311
312	assert( (error == 0) , "cannot create PIC inode\n" );
313
314	// update child inode "extend" field
315	inode_cxy = GET_CXY( inode_xp );
316	inode_ptr = GET_PTR( inode_xp );
317	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
318
319	#if DEBUG_DEVFS_LOCAL_INIT
320	cycle = (uint32_t)hal_get_cycles();
321	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
322	printk("\n[%s] thread[%x,%x] created <pic> inode in cluster %x\n",
323	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
324	#endif
325	}
326	}
327
328	// create a TXT_RX inode in each cluster containing a TXT_RX chdev
329	for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
330	{
331	chdev_xp = chdev_dir.txt_rx[channel];
332	if( chdev_xp != XPTR_NULL )
333	{
334	chdev_cxy = GET_CXY( chdev_xp );
335	chdev_ptr = GET_PTR( chdev_xp );
336
337	if( chdev_cxy == local_cxy )
338	{
339	error = vfs_add_child_in_parent( local_cxy,
340	INODE_TYPE_DEV,
341	FS_TYPE_DEVFS,
342	devfs_external_inode_xp,
343	chdev_ptr->name,
344	&unused_xp,
345	&inode_xp );
346
347	assert( (error == 0) , "cannot create TXT_RX inode\n" );
348
349	// update child inode "extend" field
350	inode_cxy = GET_CXY( inode_xp );
351	inode_ptr = GET_PTR( inode_xp );
352	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
353
354	#if DEBUG_DEVFS_LOCAL_INIT
355	cycle = (uint32_t)hal_get_cycles();
356	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
357	printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
358	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
359	#endif
360	}
361	}
362	}
363
364	// create a TXT_TX inode in each cluster containing a TXT_TX chdev
365	for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
366	{
367	chdev_xp = chdev_dir.txt_tx[channel];
368	if( chdev_xp != XPTR_NULL )
369	{
370	chdev_cxy = GET_CXY( chdev_xp );
371	chdev_ptr = GET_PTR( chdev_xp );
372
373	if( chdev_cxy == local_cxy )
374	{
375	error = vfs_add_child_in_parent( local_cxy,
376	INODE_TYPE_DEV,
377	FS_TYPE_DEVFS,
378	devfs_external_inode_xp,
379	chdev_ptr->name,
380	&unused_xp,
381	&inode_xp );
382
383	assert( (error == 0) , "cannot create TXT_TX inode\n" );
384
385	// update child inode "extend" field
386	inode_cxy = GET_CXY( inode_xp );
387	inode_ptr = GET_PTR( inode_xp );
388	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
389
390	#if DEBUG_DEVFS_LOCAL_INIT
391	cycle = (uint32_t)hal_get_cycles();
392	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
393	printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
394	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
395	#endif
396	}
397	}
398	}
399
400	// create an IOC inode in each cluster containing an IOC chdev
401	for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
402	{
403	chdev_xp = chdev_dir.ioc[channel];
404	if( chdev_xp != XPTR_NULL )
405	{
406	chdev_cxy = GET_CXY( chdev_xp );
407	chdev_ptr = GET_PTR( chdev_xp );
408
409	if( chdev_cxy == local_cxy )
410	{
411	error = vfs_add_child_in_parent( local_cxy,
412	INODE_TYPE_DEV,
413	FS_TYPE_DEVFS,
414	devfs_external_inode_xp,
415	chdev_ptr->name,
416	&unused_xp,
417	&inode_xp );
418
419	assert( (error == 0) , "cannot create IOC inode\n" );
420
421	// update child inode "extend" field
422	inode_cxy = GET_CXY( inode_xp );
423	inode_ptr = GET_PTR( inode_xp );
424	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
425
426	#if DEBUG_DEVFS_LOCAL_INIT
427	cycle = (uint32_t)hal_get_cycles();
428	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
429	printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
430	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
431	#endif
432	}
433	}
434	}
435
436	// create a FBF inode in each cluster containing a FBF chdev
437	for( channel = 0 ; channel < CONFIG_MAX_FBF_CHANNELS ; channel++ )
438	{
439	chdev_xp = chdev_dir.fbf[channel];
440	if( chdev_xp != XPTR_NULL )
441	{
442	chdev_cxy = GET_CXY( chdev_xp );
443	chdev_ptr = GET_PTR( chdev_xp );
444
445	if( chdev_cxy == local_cxy )
446	{
447	error = vfs_add_child_in_parent( local_cxy,
448	INODE_TYPE_DEV,
449	FS_TYPE_DEVFS,
450	devfs_external_inode_xp,
451	chdev_ptr->name,
452	&unused_xp,
453	&inode_xp );
454
455	assert( (error == 0) , "cannot create FBF inode\n" );
456
457	// update child inode "extend" field
458	inode_cxy = GET_CXY( inode_xp );
459	inode_ptr = GET_PTR( inode_xp );
460	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
461
462	#if DEBUG_DEVFS_LOCAL_INIT
463	cycle = (uint32_t)hal_get_cycles();
464	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
465	printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
466	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
467	#endif
468	}
469	}
470	}
471
472	// create a NIC_RX inode in each cluster containing a NIC_RX chdev
473	for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
474	{
475	chdev_xp = chdev_dir.nic_rx[channel];
476	if( chdev_xp != XPTR_NULL )
477	{
478	chdev_cxy = GET_CXY( chdev_xp );
479	chdev_ptr = GET_PTR( chdev_xp );
480
481	if( chdev_cxy == local_cxy )
482	{
483	error = vfs_add_child_in_parent( local_cxy,
484	INODE_TYPE_DEV,
485	FS_TYPE_DEVFS,
486	devfs_external_inode_xp,
487	chdev_ptr->name,
488	&unused_xp,
489	&inode_xp );
490
491	assert( (error == 0) , "cannot create NIC_RX inode\n" );
492
493	// update child inode "extend" field
494	inode_cxy = GET_CXY( inode_xp );
495	inode_ptr = GET_PTR( inode_xp );
496	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
497
498	#if DEBUG_DEVFS_LOCAL_INIT
499	cycle = (uint32_t)hal_get_cycles();
500	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
501	printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
502	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
503	#endif
504	}
505	}
506	}
507
508	// create a NIC_TX inode in each cluster containing a NIC_TX chdev
509	for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
510	{
511	chdev_xp = chdev_dir.nic_tx[channel];
512	if( chdev_xp != XPTR_NULL )
513	{
514	chdev_cxy = GET_CXY( chdev_xp );
515	chdev_ptr = GET_PTR( chdev_xp );
516
517	if( chdev_cxy == local_cxy )
518	{
519	error = vfs_add_child_in_parent( local_cxy,
520	INODE_TYPE_DEV,
521	FS_TYPE_DEVFS,
522	devfs_external_inode_xp,
523	chdev_ptr->name,
524	&unused_xp,
525	&inode_xp );
526
527	assert( (error == 0) , "cannot create NIC_TX inode\n" );
528
529	// update child inode "extend" field
530	inode_cxy = GET_CXY( inode_xp );
531	inode_ptr = GET_PTR( inode_xp );
532	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
533
534	#if DEBUG_DEVFS_LOCAL_INIT
535	cycle = (uint32_t)hal_get_cycles();
536	if( DEBUG_DEVFS_LOCAL_INIT < cycle )
537	printk("\n[%s] thread[%x,%x] created <nic_tx[%d]> inode in cluster %x\n",
538	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
539	#endif
540	}
541	}
542	}
543	} // end devfs_local_init()
544
545	//////////////////////////////////////////
546	int devfs_user_move( bool_t to_buffer,
547	xptr_t file_xp,
548	char * u_buf,
549	uint32_t size )
550	{
551	xptr_t chdev_xp;
552	cxy_t chdev_cxy;
553	chdev_t * chdev_ptr; // associated chdev type
554	uint32_t func; // chdev functionnal type
555	uint32_t channel; // chdev channel index
556	uint32_t burst; // number of bytes in a burst
557	uint32_t todo; // number of bytes not yet moved
558	error_t error;
559	uint32_t i;
560
561	char k_buf[CONFIG_TXT_KBUF_SIZE]; // local kernel buffer
562
563	assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
564
565	#if (DEBUG_SYS_READ & 1)
566	enter_devfs_read = hal_time_stamp();
567	#endif
568
569	#if (DEBUG_SYS_WRITE & 1)
570	enter_devfs_write = hal_time_stamp();
571	#endif
572
573	#if DEBUG_DEVFS_MOVE
574	uint32_t cycle = (uint32_t)hal_get_cycles();
575	thread_t * this = CURRENT_THREAD;
576	if( DEBUG_DEVFS_MOVE < cycle )
577	printk("\n[%s] thread[%x,%x] enter / to_mem %d / cycle %d\n",
578	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
579	#endif
580
581	// get extended pointer on chdev_xp
582	chdev_xp = chdev_from_file( file_xp );
583
584	// get cluster and local pointer on chdev
585	chdev_cxy = GET_CXY( chdev_xp );
586	chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
587
588	// get chdev functionnal type and channel
589	func = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->func ) );
590	channel = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
591
592	// Only TXT devices are associated to a pseudo-file
593	assert( ( func == DEV_FUNC_TXT ) , __FUNCTION__, "illegal device func_type");
594
595	// initialise number of bytes to move
596	todo = size;
597
598	/////////////// TXT read
599	if( to_buffer )
600	{
601	while( todo )
602	{
603	// set burst size
604	if( todo > CONFIG_TXT_KBUF_SIZE ) burst = CONFIG_TXT_KBUF_SIZE;
605	else burst = todo;
606
607	// read burst bytes from TXT device to kernel buffer
608	for( i = 0 ; i < burst ; i++ )
609	{
610	error = dev_txt_read( channel , &k_buf[i] );
611
612	if( error ) return -1;
613	}
614
615	// move burst bytes from k_buf to u_buf
616	hal_strcpy_to_uspace( u_buf , k_buf , burst );
617
618	// update loop variables
619	todo -= burst;
620	u_buf += burst;
621	}
622
623	#if DEBUG_DEVFS_MOVE
624	cycle = (uint32_t)hal_get_cycles();
625	if( DEBUG_DEVFS_MOVE < cycle )
626	printk("\n[%s] thread[%x,%x] exit / to_mem %d / cycle %d\n",
627	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
628	#endif
629
630	#if (DEBUG_SYS_READ & 1)
631	exit_devfs_read = hal_time_stamp();
632	#endif
633	return size;
634	}
635	///////////// TXT write
636	else
637	{
638	while( todo )
639	{
640	// set burst size
641	if( todo > CONFIG_TXT_KBUF_SIZE ) burst = CONFIG_TXT_KBUF_SIZE;
642	else burst = todo;
643
644	// move burst bytes from u_buf to k_buf
645	hal_strcpy_from_uspace( k_buf , u_buf , burst );
646
647	// write burst bytes from kernel buffer to TXT device
648	error = dev_txt_write( channel , k_buf , burst );
649
650	if( error ) return -1;
651
652	// update loop variables
653	todo -= burst;
654	u_buf += burst;
655	}
656
657	#if DEBUG_DEVFS_MOVE
658	cycle = (uint32_t)hal_get_cycles();
659	if( DEBUG_DEVFS_MOVE < cycle )
660	printk("\n[%s] thread[%x,%x] exit / to_mem %d / cycle %d\n",
661	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
662	#endif
663
664	#if (DEBUG_SYS_WRITE & 1)
665	exit_devfs_write = hal_time_stamp();
666	#endif
667	return size;
668	}
669
670	} // end devfs_user_move()
671
672	///////////////////////////////////////////////////////
673	error_t devfs_get_user_dir( struct vfs_inode_s * inode,
674	struct dirent * array,
675	uint32_t max_dirent,
676	uint32_t min_dentry,
677	bool_t detailed,
678	uint32_t * entries,
679	bool_t * done )
680	{
681	xptr_t xhtab_xp; // extended pointer on inode xhtab (children dentries)
682	xptr_t dentry_xp; // extended pointer on current dentry
683	vfs_dentry_t * dentry_ptr; // local pointer on current dentry
684	uint32_t dentry_id; // dentry index in set of children dentry
685	uint32_t dirent_id; // dirent index in array of dirent
686
687	// detailed argument unused
688	assert( (detailed == false) , "detailed argument not supported\n");
689
690	// One loop to scan the target inode xhtab containing the set of dentries
691	// exit loop if no more dentries, or dirent array full
692
693	#if DEBUG_DEVFS_GET_USER_DIR
694	char inode_name[CONFIG_VFS_MAX_NAME_LENGTH];
695	uint32_t cycle = (uint32_t)hal_get_cycles();
696	thread_t * this = CURRENT_THREAD;
697	vfs_inode_get_name( XPTR( local_cxy , inode ) , inode_name );
698	if( DEBUG_DEVFS_GET_USER_DIR < cycle )
699	printk("\n[%s] thread[%x,%x] enter for inode <%s> / cycle %d\n",
700	__FUNCTION__, this->process->pid, this->trdid, inode_name , cycle );
701	#endif
702
703	// get extended pointer on inode xhtab
704	xhtab_xp = XPTR( local_cxy , &inode->children );
705
706	// initialize loop variables
707	dentry_xp = xhtab_get_first( xhtab_xp );
708	dentry_id = 0;
709	dirent_id = 0;
710
711	while( (dentry_xp != XPTR_NULL ) && (dirent_id < max_dirent) )
712	{
713	if( dentry_id >= min_dentry )
714	{
715	// copy name into dirent array
716	dentry_ptr = GET_PTR( dentry_xp );
717	strcpy( array[dirent_id].d_name , dentry_ptr->name );
718
719	// increment dirent_id
720	dirent_id++;
721	}
722
723	// update loop variables
724	dentry_xp = xhtab_get_next( xhtab_xp );
725	dentry_id++;
726	}
727
728	// return results of scan
729	*done = (dentry_xp == XPTR_NULL);
730	*entries = dirent_id;
731
732	#if DEBUG_DEVFS_GET_USER_DIR
733	cycle = (uint32_t)hal_get_cycles();
734	if( DEBUG_DEVFS_GET_USER_DIR < cycle )
735	printk("\n[%s] thread[%x,%x] exit for inode <%s> / %d entries / cycle %d\n",
736	__FUNCTION__, this->process->pid, this->trdid, inode_name, entries, cycle );
737	#endif
738
739	return 0;
740
741	} // en devfs_get_user_dir()
742

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

Download in other formats: