Context Navigation

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

Last change on this file since 605 was 602, checked in by alain, 6 years ago
Improve the FAT32 file system to support cat, rm, cp commands.
File size: 20.8 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 <chdev.h>
30	#include <thread.h>
31	#include <dev_txt.h>
32	#include <cluster.h>
33	#include <vfs.h>
34	#include <kmem.h>
35	#include <devfs.h>
36
37	/////////////////////////////////////////////////////////////////////////////////////////
38	// Extern variables
39	/////////////////////////////////////////////////////////////////////////////////////////
40
41	extern vfs_ctx_t fs_context[]; // allocated in kernel_init.c
42	extern chdev_directory_t chdev_dir; // allocated in kernel_init.c
43
44	#if (DEBUG_SYS_READ & 1)
45	extern uint32_t enter_devfs_read;
46	extern uint32_t exit_devfs_read;
47	#endif
48
49	#if (DEBUG_SYS_WRITE & 1)
50	extern uint32_t enter_devfs_write;
51	extern uint32_t exit_devfs_write;
52	#endif
53
54	/////////////////////////////////////
55	devfs_ctx_t * devfs_ctx_alloc( void )
56	{
57	kmem_req_t req;
58
59	req.type = KMEM_DEVFS_CTX;
60	req.size = sizeof(devfs_ctx_t);
61	req.flags = AF_KERNEL \| AF_ZERO;
62
63	return (devfs_ctx_t *)kmem_alloc( &req );
64	}
65
66	/////////////////////////////////////////////
67	void devfs_ctx_init( devfs_ctx_t * devfs_ctx,
68	xptr_t devfs_dev_inode_xp,
69	xptr_t devfs_external_inode_xp )
70	{
71	devfs_ctx->dev_inode_xp = devfs_dev_inode_xp;
72	devfs_ctx->external_inode_xp = devfs_external_inode_xp;
73
74	fs_context[FS_TYPE_DEVFS].extend = devfs_ctx;
75	}
76
77	/////////////////////////////////////////////////
78	void devfs_ctx_destroy( devfs_ctx_t * devfs_ctx )
79	{
80	kmem_req_t req;
81
82	req.type = KMEM_DEVFS_CTX;
83	req.ptr = devfs_ctx;
84	kmem_free( &req );
85	}
86
87	/////////////////////////////////////////////////
88	void devfs_global_init( xptr_t root_inode_xp,
89	xptr_t * devfs_dev_inode_xp,
90	xptr_t * devfs_external_inode_xp )
91	{
92	error_t error;
93	xptr_t unused_xp; // required by vfs_add_child_in_parent()
94
95	// creates DEVFS "dev" inode in cluster 0
96	error = vfs_add_child_in_parent( 0, // cxy
97	INODE_TYPE_DIR,
98	FS_TYPE_DEVFS,
99	root_inode_xp,
100	"dev",
101	&unused_xp,
102	devfs_dev_inode_xp );
103
104	assert( (error == 0) , "cannot create <dev>\n" );
105
106	#if DEBUG_DEVFS_INIT
107	uint32_t cycle = (uint32_t)hal_get_cycles();
108	thread_t * this = CURRENT_THREAD;
109	if( DEBUG_DEVFS_INIT < cycle )
110	printk("\n[%s] thread[%x,%x] created <dev> inode / cycle %d\n",
111	__FUNCTION__, this->process->pid, this->trdid, cycle );
112	#endif
113
114	// create DEVFS "external" inode in cluster 0
115	error = vfs_add_child_in_parent( 0, // cxy
116	INODE_TYPE_DIR,
117	FS_TYPE_DEVFS,
118	*devfs_dev_inode_xp,
119	"external",
120	&unused_xp,
121	devfs_external_inode_xp );
122
123	assert( (error == 0) , "cannot create <external>\n" );
124
125	#if DEBUG_DEVFS_INIT
126	cycle = (uint32_t)hal_get_cycles();
127	if( DEBUG_DEVFS_INIT < cycle )
128	printk("\n[%s] thread[%x,%x] created <external> inode / cycle %d\n",
129	__FUNCTION__, this->process->pid, this->trdid, cycle );
130	#endif
131
132	} // end devfs_global_init()
133
134	///////////////////////////////////////////////////
135	void devfs_local_init( xptr_t devfs_dev_inode_xp,
136	xptr_t devfs_external_inode_xp,
137	xptr_t * devfs_internal_inode_xp )
138	{
139	char node_name[16];
140	xptr_t chdev_xp;
141	cxy_t chdev_cxy;
142	chdev_t * chdev_ptr;
143	xptr_t inode_xp;
144	cxy_t inode_cxy;
145	vfs_inode_t * inode_ptr;
146	uint32_t channel;
147	xptr_t unused_xp; // required by add_child_in_parent()
148
149	// create "internal" directory
150	snprintf( node_name , 16 , "internal_%x" , local_cxy );
151	vfs_add_child_in_parent( local_cxy,
152	INODE_TYPE_DIR,
153	FS_TYPE_DEVFS,
154	devfs_dev_inode_xp,
155	node_name,
156	&unused_xp,
157	devfs_internal_inode_xp );
158	#if DEBUG_DEVFS_INIT
159	uint32_t cycle = (uint32_t)hal_get_cycles();
160	thread_t * this = CURRENT_THREAD;
161	if( DEBUG_DEVFS_INIT < cycle )
162	printk("\n[%s] thread[%x,%x] created <%s> inode in cluster %x / cycle %d\n",
163	__FUNCTION__, this->process->pid, this->trdid, node_name, local_cxy, cycle );
164	#endif
165
166	// create MMC chdev inode
167	chdev_xp = chdev_dir.mmc[local_cxy];
168	if( chdev_xp != XPTR_NULL)
169	{
170	chdev_ptr = GET_PTR( chdev_xp );
171	vfs_add_child_in_parent( local_cxy,
172	INODE_TYPE_DEV,
173	FS_TYPE_DEVFS,
174	*devfs_internal_inode_xp,
175	chdev_ptr->name,
176	&unused_xp,
177	&inode_xp );
178
179	// update child inode "extend" field
180	inode_cxy = GET_CXY( inode_xp );
181	inode_ptr = GET_PTR( inode_xp );
182	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
183
184	#if DEBUG_DEVFS_INIT
185	cycle = (uint32_t)hal_get_cycles();
186	if( DEBUG_DEVFS_INIT < cycle )
187	printk("\n[%s] thread[%x,%x] created <mmc> inode in cluster %x\n",
188	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
189	#endif
190
191	}
192
193	// create DMA chdev inodes (one DMA channel per core)
194	for( channel = 0 ; channel < LOCAL_CLUSTER->cores_nr ; channel++ )
195	{
196	chdev_xp = chdev_dir.dma[channel];
197	if( chdev_xp != XPTR_NULL)
198	{
199	chdev_ptr = GET_PTR( chdev_xp );
200	vfs_add_child_in_parent( local_cxy,
201	INODE_TYPE_DEV,
202	FS_TYPE_DEVFS,
203	*devfs_internal_inode_xp,
204	chdev_ptr->name,
205	&unused_xp,
206	&inode_xp );
207
208	// update child inode "extend" field
209	inode_cxy = GET_CXY( inode_xp );
210	inode_ptr = GET_PTR( inode_xp );
211	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
212
213	#if DEBUG_DEVFS_INIT
214	cycle = (uint32_t)hal_get_cycles();
215	if( DEBUG_DEVFS_INIT < cycle )
216	printk("\n[%s] thread [%x,%x] created <dma[%d]> inode in cluster %x\n",
217	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
218	#endif
219	}
220	}
221
222	// create an IOB inode in cluster containing IOB chdev
223	chdev_xp = chdev_dir.iob;
224	if( chdev_xp != XPTR_NULL )
225	{
226	chdev_cxy = GET_CXY( chdev_xp );
227	chdev_ptr = GET_PTR( chdev_xp );
228	if( chdev_cxy == local_cxy )
229	{
230	vfs_add_child_in_parent( local_cxy,
231	INODE_TYPE_DEV,
232	FS_TYPE_DEVFS,
233	devfs_external_inode_xp,
234	chdev_ptr->name,
235	&unused_xp,
236	&inode_xp );
237
238	// update child inode "extend" field
239	inode_cxy = GET_CXY( inode_xp );
240	inode_ptr = GET_PTR( inode_xp );
241	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
242
243	#if DEBUG_DEVFS_INIT
244	cycle = (uint32_t)hal_get_cycles();
245	if( DEBUG_DEVFS_INIT < cycle )
246	printk("\n[%s] thread[%x,%x] created <iob> inode in cluster %x\n",
247	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
248	#endif
249	}
250	}
251
252	// create a PIC inode in cluster containing PIC chdev
253	chdev_xp = chdev_dir.pic;
254	if( chdev_xp != XPTR_NULL )
255	{
256	chdev_cxy = GET_CXY( chdev_xp );
257	chdev_ptr = GET_PTR( chdev_xp );
258	if( chdev_cxy == local_cxy )
259	{
260	vfs_add_child_in_parent( local_cxy,
261	INODE_TYPE_DEV,
262	FS_TYPE_DEVFS,
263	devfs_external_inode_xp,
264	chdev_ptr->name,
265	&unused_xp,
266	&inode_xp );
267
268	// update child inode "extend" field
269	inode_cxy = GET_CXY( inode_xp );
270	inode_ptr = GET_PTR( inode_xp );
271	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
272
273	#if DEBUG_DEVFS_INIT
274	cycle = (uint32_t)hal_get_cycles();
275	if( DEBUG_DEVFS_INIT < cycle )
276	printk("\n[%s] thread[%x,%x] created <pic> inode in cluster %x\n",
277	__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
278	#endif
279	}
280	}
281
282	// create a TXT_RX inode in each cluster containing a TXT_RX chdev
283	for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
284	{
285	chdev_xp = chdev_dir.txt_rx[channel];
286	if( chdev_xp != XPTR_NULL )
287	{
288	chdev_cxy = GET_CXY( chdev_xp );
289	chdev_ptr = GET_PTR( chdev_xp );
290	if( chdev_cxy == local_cxy )
291	{
292	vfs_add_child_in_parent( local_cxy,
293	INODE_TYPE_DEV,
294	FS_TYPE_DEVFS,
295	devfs_external_inode_xp,
296	chdev_ptr->name,
297	&unused_xp,
298	&inode_xp );
299
300	// update child inode "extend" field
301	inode_cxy = GET_CXY( inode_xp );
302	inode_ptr = GET_PTR( inode_xp );
303	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
304
305	#if DEBUG_DEVFS_INIT
306	cycle = (uint32_t)hal_get_cycles();
307	if( DEBUG_DEVFS_INIT < cycle )
308	printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
309	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
310	#endif
311	}
312	}
313	}
314
315	// create a TXT_TX inode in each cluster containing a TXT_TX chdev
316	for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
317	{
318	chdev_xp = chdev_dir.txt_tx[channel];
319	if( chdev_xp != XPTR_NULL )
320	{
321	chdev_cxy = GET_CXY( chdev_xp );
322	chdev_ptr = GET_PTR( chdev_xp );
323	if( chdev_cxy == local_cxy )
324	{
325	vfs_add_child_in_parent( local_cxy,
326	INODE_TYPE_DEV,
327	FS_TYPE_DEVFS,
328	devfs_external_inode_xp,
329	chdev_ptr->name,
330	&unused_xp,
331	&inode_xp );
332
333	// update child inode "extend" field
334	inode_cxy = GET_CXY( inode_xp );
335	inode_ptr = GET_PTR( inode_xp );
336	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
337
338	#if DEBUG_DEVFS_INIT
339	cycle = (uint32_t)hal_get_cycles();
340	if( DEBUG_DEVFS_INIT < cycle )
341	printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
342	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
343	#endif
344	}
345	}
346	}
347
348	// create an IOC inode in each cluster containing an IOC chdev
349	for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
350	{
351	chdev_xp = chdev_dir.ioc[channel];
352	if( chdev_xp != XPTR_NULL )
353	{
354	chdev_cxy = GET_CXY( chdev_xp );
355	chdev_ptr = GET_PTR( chdev_xp );
356	if( chdev_cxy == local_cxy )
357	{
358	vfs_add_child_in_parent( local_cxy,
359	INODE_TYPE_DEV,
360	FS_TYPE_DEVFS,
361	devfs_external_inode_xp,
362	chdev_ptr->name,
363	&unused_xp,
364	&inode_xp );
365
366	// update child inode "extend" field
367	inode_cxy = GET_CXY( inode_xp );
368	inode_ptr = GET_PTR( inode_xp );
369	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
370
371	#if DEBUG_DEVFS_INIT
372	cycle = (uint32_t)hal_get_cycles();
373	if( DEBUG_DEVFS_INIT < cycle )
374	printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
375	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
376	#endif
377	}
378	}
379	}
380
381	// create a FBF inode in each cluster containing a FBF chdev
382	for( channel = 0 ; channel < CONFIG_MAX_FBF_CHANNELS ; channel++ )
383	{
384	chdev_xp = chdev_dir.fbf[channel];
385	if( chdev_xp != XPTR_NULL )
386	{
387	chdev_cxy = GET_CXY( chdev_xp );
388	chdev_ptr = GET_PTR( chdev_xp );
389	if( chdev_cxy == local_cxy )
390	{
391	vfs_add_child_in_parent( local_cxy,
392	INODE_TYPE_DEV,
393	FS_TYPE_DEVFS,
394	devfs_external_inode_xp,
395	chdev_ptr->name,
396	&unused_xp,
397	&inode_xp );
398
399	// update child inode "extend" field
400	inode_cxy = GET_CXY( inode_xp );
401	inode_ptr = GET_PTR( inode_xp );
402	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
403
404	#if DEBUG_DEVFS_INIT
405	cycle = (uint32_t)hal_get_cycles();
406	if( DEBUG_DEVFS_INIT < cycle )
407	printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
408	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
409	#endif
410	}
411	}
412	}
413
414	// create a NIC_RX inode in each cluster containing a NIC_RX chdev
415	for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
416	{
417	chdev_xp = chdev_dir.nic_rx[channel];
418	if( chdev_xp != XPTR_NULL )
419	{
420	chdev_cxy = GET_CXY( chdev_xp );
421	chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
422	if( chdev_cxy == local_cxy )
423	{
424	vfs_add_child_in_parent( local_cxy,
425	INODE_TYPE_DEV,
426	FS_TYPE_DEVFS,
427	devfs_external_inode_xp,
428	chdev_ptr->name,
429	&unused_xp,
430	&inode_xp );
431	#if DEBUG_DEVFS_INIT
432	cycle = (uint32_t)hal_get_cycles();
433	if( DEBUG_DEVFS_INIT < cycle )
434	printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
435	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
436	#endif
437	}
438	}
439	}
440
441	// create a NIC_TX inode in each cluster containing a NIC_TX chdev
442	for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
443	{
444	chdev_xp = chdev_dir.nic_tx[channel];
445	if( chdev_xp != XPTR_NULL )
446	{
447	chdev_cxy = GET_CXY( chdev_xp );
448	chdev_ptr = GET_PTR( chdev_xp );
449	if( chdev_cxy == local_cxy )
450	{
451	vfs_add_child_in_parent( local_cxy,
452	INODE_TYPE_DEV,
453	FS_TYPE_DEVFS,
454	devfs_external_inode_xp,
455	chdev_ptr->name,
456	&unused_xp,
457	&inode_xp );
458
459	// update child inode "extend" field
460	inode_cxy = GET_CXY( inode_xp );
461	inode_ptr = GET_PTR( inode_xp );
462	hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
463
464	#if DEBUG_DEVFS_INIT
465	cycle = (uint32_t)hal_get_cycles();
466	if( DEBUG_DEVFS_INIT < cycle )
467	printk("\n[%s] thread[%x,%x] created <nic_tx[%d]> inode in cluster %x\n",
468	__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
469	#endif
470	}
471	}
472	}
473	} // end devfs_local_init()
474
475	//////////////////////////////////////////
476	int devfs_user_move( bool_t to_buffer,
477	xptr_t file_xp,
478	char * u_buf,
479	uint32_t size )
480	{
481	xptr_t chdev_xp;
482	cxy_t chdev_cxy;
483	chdev_t * chdev_ptr; // associated chdev type
484	uint32_t func; // chdev functionnal type
485	uint32_t channel; // chdev channel index
486	uint32_t burst; // number of bytes in a burst
487	uint32_t todo; // number of bytes not yet moved
488	error_t error;
489	uint32_t i;
490
491	char k_buf[CONFIG_TXT_KBUF_SIZE]; // local kernel buffer
492
493	assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
494
495	#if (DEBUG_SYS_READ & 1)
496	enter_devfs_read = hal_time_stamp();
497	#endif
498
499	#if (DEBUG_SYS_WRITE & 1)
500	enter_devfs_write = hal_time_stamp();
501	#endif
502
503	#if DEBUG_DEVFS_MOVE
504	uint32_t cycle = (uint32_t)hal_get_cycles();
505	thread_t * this = CURRENT_THREAD;
506	if( DEBUG_DEVFS_MOVE < cycle )
507	printk("\n[%s] thread[%x,%x] enter / to_mem %d / cycle %d\n",
508	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
509	#endif
510
511	// get extended pointer on chdev_xp
512	chdev_xp = chdev_from_file( file_xp );
513
514	// get cluster and local pointer on chdev
515	chdev_cxy = GET_CXY( chdev_xp );
516	chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
517
518	// get chdev functionnal type and channel
519	func = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->func ) );
520	channel = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
521
522	// Only TXT devices are associated to a pseudo-file
523	assert( ( func == DEV_FUNC_TXT ) , __FUNCTION__, "illegal device func_type");
524
525	// initialise number of bytes to move
526	todo = size;
527
528	/////////////// TXT read
529	if( to_buffer )
530	{
531	while( todo )
532	{
533	// set burst size
534	if( todo > CONFIG_TXT_KBUF_SIZE ) burst = CONFIG_TXT_KBUF_SIZE;
535	else burst = todo;
536
537	// read burst bytes from TXT device to kernel buffer
538	for( i = 0 ; i < burst ; i++ )
539	{
540	error = dev_txt_read( channel , &k_buf[i] );
541
542	if( error ) return -1;
543	}
544
545	// move burst bytes from k_buf to u_buf
546	hal_strcpy_to_uspace( u_buf , k_buf , burst );
547
548	// update loop variables
549	todo -= burst;
550	u_buf += burst;
551	}
552
553	#if DEBUG_DEVFS_MOVE
554	cycle = (uint32_t)hal_get_cycles();
555	if( DEBUG_DEVFS_MOVE < cycle )
556	printk("\n[%s] thread[%x,%x] exit / to_mem %d / cycle %d\n",
557	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
558	#endif
559
560	#if (DEBUG_SYS_READ & 1)
561	exit_devfs_read = hal_time_stamp();
562	#endif
563	return size;
564	}
565	///////////// TXT write
566	else
567	{
568	while( todo )
569	{
570	// set burst size
571	if( todo > CONFIG_TXT_KBUF_SIZE ) burst = CONFIG_TXT_KBUF_SIZE;
572	else burst = todo;
573
574	// move burst bytes from u_buf to k_buf
575	hal_strcpy_from_uspace( k_buf , u_buf , burst );
576
577	// write burst bytes from kernel buffer to TXT device
578	error = dev_txt_write( channel , k_buf , burst );
579
580	if( error ) return -1;
581
582	// update loop variables
583	todo -= burst;
584	u_buf += burst;
585	}
586
587	#if DEBUG_DEVFS_MOVE
588	cycle = (uint32_t)hal_get_cycles();
589	if( DEBUG_DEVFS_MOVE < cycle )
590	printk("\n[%s] thread[%x,%x] exit / to_mem %d / cycle %d\n",
591	__FUNCTION__, this->process->pid, this->trdid, to_buffer, cycle );
592	#endif
593
594	#if (DEBUG_SYS_WRITE & 1)
595	exit_devfs_write = hal_time_stamp();
596	#endif
597	return size;
598	}
599
600	} // end devfs_user_move()
601
602

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

Download in other formats: