source: trunk/kernel/vfs/devfs.c @ 144

Last change on this file since 144 was 50, checked in by alain, 5 years ago

bloup

File size: 19.1 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_types.h>
26#include <hal_special.h>
27#include <printk.h>
28#include <kmem.h>
29#include <string.h>
30#include <chdev.h>
31#include <core.h>
32#include <thread.h>
33#include <vfs.h>
34#include <errno.h>
35#include <devfs.h>
36#include <rpc.h>
37
38
39//////////////////////////////////////////////////////////////////////////////////////////
40//          Extern  variables         
41//////////////////////////////////////////////////////////////////////////////////////////
42
43extern vfs_ctx_t          fs_context[FS_TYPES_NR];   // allocated in vfs.c file
44
45extern remote_barrier_t   global_barrier;            // allocated in kernel_init.c
46 
47extern chdev_directory_t  chdev_dir;                 // allocated in kernel_init.c
48
49////////////////////////////////////////////////////////////////////////////////////////
50//                DEVFS private functions
51////////////////////////////////////////////////////////////////////////////////////////
52
53////////////////////////////////////////////////////////////////////////////////////////
54// This function creates in the local cluster the dentry and the associated inode,
55// for a DEVFS directory (level 0 or level 1 in DEVFS tree).
56////////////////////////////////////////////////////////////////////////////////////////
57// @ name        : directory entry name.
58// @ parent_xp   : extended pointer on parent inode.
59// @ inode_xp    : [out] buffer for extended pointer on created inode.
60////////////////////////////////////////////////////////////////////////////////////////
61static void devfs_create_directory( char        * name,
62                                    xptr_t        parent_xp,
63                                    xptr_t      * inode_xp )
64{
65    error_t       error;
66    xptr_t        new_dentry_xp;     // extended pointer on created dentry
67    xptr_t        new_inode_xp;      // extended pointer on created inode
68 
69    // get parent inode cluster and local pointer
70    cxy_t         parent_cxy = GET_CXY( parent_xp );
71    vfs_inode_t * parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
72
73    // create vfs_dentry in cluster containing the parent inode
74    if( parent_cxy == local_cxy )
75    {
76        error = vfs_dentry_create( FS_TYPE_DEVFS,
77                                   name,
78                                   parent_ptr,
79                                   &new_dentry_xp );
80    }
81    else
82    {
83        rpc_vfs_dentry_create_client( parent_cxy,
84                                      FS_TYPE_DEVFS,
85                                      name,
86                                      parent_ptr,
87                                      &new_dentry_xp,
88                                      &error );
89    }
90
91    if ( error )
92    {
93        printk("\n[PANIC] in %s : cannot create dentry for %s in cluster %x/n",
94               __FUNCTION__ , name , local_cxy );
95        hal_core_sleep();
96    }
97
98    // create vfs_inode in local cluster TODO define the 4 arguments below [AG]
99    uint32_t  attr   = 0;
100    uint32_t  rights = 0;
101    uid_t     uid    = 0;
102    gid_t     gid    = 0;
103    error = vfs_inode_create( new_dentry_xp,
104                              FS_TYPE_DEVFS,
105                              INODE_TYPE_DIR,
106                              attr,
107                              rights,
108                              uid,
109                              gid,
110                              &new_inode_xp );
111    if( error )
112    {
113        printk("\n[PANIC] in %s : cannot create inode for %s in cluster %x/n",
114               __FUNCTION__ , name , local_cxy );
115        hal_core_sleep();
116    }
117
118    // return extended pointer on directory inode
119    *inode_xp = new_inode_xp;
120
121}  // end devfs_create_directory()
122                                   
123////////////////////////////////////////////////////////////////////////////////////////
124// This function creates in the local cluster the dentry and the associated inode,
125// for a chdev (level 2 in DEVFS tree).
126////////////////////////////////////////////////////////////////////////////////////////
127// @ chdev    : local pointer on local chdev.
128// @ name     : directory entry name.
129// @ parent   : local pointer on local parent inode.
130// @ inode_xp : [out] buffer for extended pointer on created inode.
131////////////////////////////////////////////////////////////////////////////////////////
132static void devfs_register_chdev( chdev_t     * chdev,
133                                  char        * name,
134                                  vfs_inode_t * parent,
135                                  xptr_t      * inode_xp )
136{
137    error_t  error;
138    xptr_t   new_dentry_xp;
139    xptr_t   new_inode_xp;
140
141    devfs_dmsg("\n[INFO] %s : create dentry for %s\n", __FUNCTION__ , name );
142   
143    // create vfs_dentry in local cluster
144    error = vfs_dentry_create( FS_TYPE_DEVFS,
145                               name,
146                               parent,
147                               &new_dentry_xp );
148    if ( error )
149    {
150        printk("\n[PANIC] in %s : cannot create dentry for %s in cluster %x/n",
151               __FUNCTION__ , name , local_cxy );
152        hal_core_sleep();
153    }
154
155    devfs_dmsg("\n[INFO] %s : create inode for %s\n", __FUNCTION__ , name );
156   
157    // create vfs_inode in local cluster
158    uint32_t  attr   = 0;
159    uint32_t  rights = 0;
160    uid_t     uid    = 0;
161    gid_t     gid    = 0;
162    error = vfs_inode_create( new_dentry_xp,
163                              FS_TYPE_DEVFS,
164                              INODE_TYPE_DEV,
165                              attr,
166                              rights,
167                              uid,
168                              gid,
169                              &new_inode_xp );
170    if( error )
171    {
172        printk("\n[PANIC] in %s : cannot create inode for %s in cluster %x/n",
173               __FUNCTION__ , name , local_cxy );
174        hal_core_sleep();
175    }
176
177    // return extended pointer on chdev inode
178    *inode_xp = new_inode_xp;
179   
180}  // end devfs_register_chdev()
181
182
183
184///////////////////////////////////////////////////////////////////////////////////////
185// Generic API : the following functions are called by the VFS,
186//               and must be defined by all supported file systems.
187///////////////////////////////////////////////////////////////////////////////////////
188
189////////////////////////////////////////////
190
191////////////////////////////////////////////
192error_t devfs_mount( xptr_t   parent_inode_xp,
193                     char   * devfs_root_name )
194{
195    assert( (CURRENT_CORE->lid == 0) , __FUNCTION__ , "only CP0 should do it" );
196
197    vfs_inode_t * parent_inode_ptr;
198    cxy_t         parent_inode_cxy;
199    vfs_ctx_t   * vfs_ctx;
200
201    char          node_name[16];
202    uint32_t      channel;
203
204    xptr_t        root_inode_xp;
205    xptr_t        external_inode_xp;
206    xptr_t        internal_inode_xp;
207    xptr_t        chdev_inode_xp;
208
209    chdev_t     * chdev_ptr;
210
211    // get number of kernel instances and extended pointer on global barrier
212    cluster_t * cluster     = LOCAL_CLUSTER;
213    uint32_t    nb_clusters = cluster->x_size * cluster->y_size;
214    xptr_t      barrier_xp  = XPTR( cluster->io_cxy , &global_barrier );
215
216    // get VFS root inode cluster and local pointer
217    parent_inode_cxy = GET_CXY( parent_inode_xp );
218    parent_inode_ptr = (vfs_inode_t *)GET_PTR( parent_inode_xp );
219
220    // get local pointer on VFS context for DEVFS
221    vfs_ctx = &fs_context[FS_TYPE_DEVFS];
222
223    ///// step 1 : all clusters initialize local DEVFS context  /////
224
225    devfs_ctx_init( vfs_ctx , parent_inode_xp );
226
227    ///// step 2 : cluster_0 creates DEVFS root    /////
228
229    if( local_cxy == 0 )
230    {
231        devfs_create_directory( devfs_root_name,
232                                parent_inode_xp,
233                                &root_inode_xp );
234    }
235
236    // synchronize all clusters
237    remote_barrier( barrier_xp , nb_clusters );
238
239    ///// step 3 : all clusters create "internal" directory and chdevs  /////
240
241    // TODO check device existence : (chdev_xp != XPTR_NULL) in chdev_dir
242
243    snprintf( node_name , 16 , "internal_%x" , local_cxy );
244
245    devfs_create_directory( node_name,
246                            root_inode_xp,
247                            &internal_inode_xp );
248
249    // create ICU chdev inode
250    chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.icu[local_cxy] );
251    devfs_register_chdev( chdev_ptr,
252                          "icu",
253                          (vfs_inode_t *)GET_PTR( internal_inode_xp ),
254                          &chdev_inode_xp );
255
256    // create MMC chdev inode
257    chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.mmc[local_cxy] );
258    devfs_register_chdev( chdev_ptr,
259                          "mmc", 
260                          (vfs_inode_t *)GET_PTR( internal_inode_xp ),
261                          &chdev_inode_xp );
262
263    // create DMA chdev inodes (one DMA channel per core)
264    for( channel = 0 ; channel < cluster->cores_nr ; channel++ )
265    {
266        chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.dma[channel] );
267        snprintf( node_name , 16 , "dma_%d" , channel );
268        devfs_register_chdev( chdev_ptr,
269                              node_name,
270                              (vfs_inode_t *)GET_PTR( internal_inode_xp ),
271                              &chdev_inode_xp );
272    }
273
274    ///// step 4 : cluster_io creates "external" directory and chdevs /////
275
276    // TODO check device existence : (chdev_xp != XPTR_NULL) in chdev_dir
277
278    if( local_cxy == cluster->io_cxy )
279    {
280        devfs_create_directory( "external",
281                                root_inode_xp,
282                                &external_inode_xp );
283
284        // create IOB chdev inode
285        chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.iob );
286        devfs_register_chdev( chdev_ptr,
287                              "iob",
288                              (vfs_inode_t *)GET_PTR( external_inode_xp ),
289                              &chdev_inode_xp );
290       
291        // create PIC chdev inode
292        chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.pic );
293        devfs_register_chdev( chdev_ptr,
294                              "pic",
295                              (vfs_inode_t *)GET_PTR( external_inode_xp ),
296                              &chdev_inode_xp );
297
298        // create TXT chdev inodes
299        for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
300        {
301            chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.txt[channel] );
302            snprintf( node_name , 16 , "txt_%d" , channel );
303            devfs_register_chdev( chdev_ptr,
304                                  node_name,
305                                  (vfs_inode_t *)GET_PTR( external_inode_xp ),
306                                  &chdev_inode_xp );
307        }
308
309        // create IOC chdev inodes
310        for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
311        {
312            chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.ioc[channel] );
313            snprintf( node_name , 16 , "ioc_%d" , channel );
314            devfs_register_chdev( chdev_ptr,
315                                  node_name,
316                                  (vfs_inode_t *)GET_PTR( external_inode_xp ),
317                                  &chdev_inode_xp );
318        }
319
320        // create FBF chdev inodes
321        for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
322        {
323            chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.ioc[channel] );
324            snprintf( node_name , 16 , "fbf_%d" , channel );
325            devfs_register_chdev( chdev_ptr,
326                                  node_name,
327                                  (vfs_inode_t *)GET_PTR( external_inode_xp ),
328                                  &chdev_inode_xp );
329        }
330
331        // create NIC_RX chdevs
332        for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
333        {
334            chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.nic_rx[channel] );
335            snprintf( node_name , 16 , "nic_rx_%d" , channel );
336            devfs_register_chdev( chdev_ptr,
337                                  node_name,
338                                  (vfs_inode_t *)GET_PTR( external_inode_xp ),
339                                  &chdev_inode_xp );
340        }
341
342        // create NIC_TX chdev inodes
343        for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
344        {
345            chdev_ptr = (chdev_t *)GET_PTR( chdev_dir.nic_tx[channel] );
346            snprintf( node_name , 16 , "nic_tx_%d" , channel );
347            devfs_register_chdev( chdev_ptr,
348                                  node_name,
349                                  (vfs_inode_t *)GET_PTR( external_inode_xp ),
350                                  &chdev_inode_xp );
351        }
352    }
353
354    // synchronize all clusters
355    remote_barrier( barrier_xp , nb_clusters );
356
357    return 0;
358
359}  // end devfs_init()
360
361
362////////////////////////////////////////////
363error_t devfs_ctx_init( vfs_ctx_t * vfs_ctx,
364                        xptr_t      root_inode_xp )
365{
366    vfs_ctx->type    = FS_TYPE_DEVFS;
367    vfs_ctx->attr    = 0;                // not READ_ONLY / not SYNC
368    vfs_ctx->count   = 0;                // unused for DEVFS
369    vfs_ctx->blksize = 0;                // unused for DEVFS
370    vfs_ctx->root_xp = root_inode_xp;
371    vfs_ctx->extend  = NULL;             // unused for DEVFS
372
373    spinlock_init( &vfs_ctx->lock );
374
375    bitmap_init( vfs_ctx->bitmap , CONFIG_VFS_MAX_INODES );
376
377    return 0;
378}
379
380
381////////////////////////////////////////////////////
382error_t devfs_inode_create( vfs_inode_t * vfs_inode,
383                            chdev_t     * chdev )
384{
385    kmem_req_t      req;
386    devfs_inode_t * devfs_inode;
387
388    // allocate memory for FATFS inode extension
389        req.type    = KMEM_DEVFS_INODE;
390        req.size    = sizeof(devfs_inode_t);
391    req.flags   = AF_KERNEL | AF_ZERO;
392        devfs_inode = (devfs_inode_t *)kmem_alloc( &req );
393
394    if( devfs_inode == NULL ) return ENOMEM;
395
396    // link DEVFS inode to VFS inode
397    vfs_inode->extend = devfs_inode;
398
399    // initialise DEVFS inode 
400    devfs_inode->chdev = chdev;
401 
402    return 0;
403}
404
405///////////////////////////////////////////////////
406void devfs_inode_destroy( vfs_inode_t * vfs_inode )
407{
408    kmem_req_t      req;
409    devfs_inode_t * devfs_inode;
410
411    // get pointer on DEVFS inode
412    devfs_inode = (devfs_inode_t *)vfs_inode->extend;
413
414    req.type = KMEM_DEVFS_INODE;
415    req.ptr  = devfs_inode;
416    kmem_free( &req );
417
418        vfs_inode->extend = NULL;
419}
420
421
422/* deprecated [AG]
423
424error_t devfs_open_file( vfs_file_t * file,
425                         void       * extend );
426{
427        error_t err;
428        register struct devfs_context_s *ctx;
429        register struct devfs_file_s *info;
430        chdev_t       * chdev;
431        vfs_inode_t   * inode;
432        dev_request_t   rq;
433        kmem_req_t      req;
434
435        inode = file->inode;
436
437        info = file->fr_pv;
438        ctx  = (struct devfs_context_s *)&inode->i_ctx->ctx_devfs;
439
440        if(!(inode->i_attr & VFS_DIR))
441        {
442                dev = (struct device_s*)inode->i_pv;
443   
444                if(dev->type == DEV_INTERNAL)
445                        return EPERM;
446
447                if(dev->type == DEV_BLK)
448                        VFS_SET(inode->i_attr,VFS_DEV_BLK);
449                else
450                        VFS_SET(inode->i_attr,VFS_DEV_CHR);
451 
452                if(dev->op.dev.open != NULL)
453                {
454                        rq.fremote = file;
455                        if((err=dev->op.dev.open(dev, &rq)))
456                                return err;
457                }
458
459                priv->dev = (void*)dev;
460
461                return 0;
462        }
463
464        if(info == NULL)
465        {
466                req.type  = KMEM_DEVFS_FILE;
467                req.size  = sizeof(*info);
468                req.flags = AF_KERNEL;
469                info      = kmem_alloc(&req);
470        }
471
472        if(info == NULL) return ENOMEM;
473
474        metafs_iter_init(&devfs_db.root, &info->iter);
475        info->ctx  = ctx;
476        file->fr_pv = info;
477 
478        metafs_print(&devfs_db.root);
479        return 0;
480}
481
482#define TMP_BUFF_SZ 512
483
484//FIXME:
485//add a "while" loop for the case where the
486//buffer TMP_BUFF_SZ is smaller than
487//buffer->size
488//////////////////////////////
489devfs_read( vfs_file_t * file,
490            char       * buffer )
491{
492        chdev_t       * chdev;
493        dev_request_t   rq;
494        uint32_t        count;
495    uint8_t         buff[TMP_BUFF_SZ];
496
497    // get pointer on chdev
498        chdev = (chdev_t *)file->extend;
499
500    if( chdev->func == DEV_FUNC_TXT )
501    {
502    }
503    if( chdev->func == DEV_FUNC_IOC )
504    {
505    }
506    else
507    {
508        printk("\n[PANIC] in %s : illegal device functionnal type
509
510        rq.dst   = &buff[0];
511        rq.count = TMP_BUFF_SZ;
512        rq.flags = 0;
513        rq.file  = file;
514
515        if((count = dev->op.dev.read(dev, &rq)) < 0)
516                return count;
517
518        buffer->scpy_to_buff(buffer, &buff[0], count);
519        return count;
520}
521
522//FIXME: To improve this an avoid the extra copy,
523//we could set along with the buffer(src and dest)
524//the functions to manipulate them, such as in
525//do_exec.c
526///////////////////////////////
527devfs_write( vfs_file_t * file,
528             char       * buffer )
529{
530        register struct device_s *dev;
531        uint8_t buff[TMP_BUFF_SZ];
532        dev_request_t rq;
533       
534        dev = (struct device_s*)file->f_private.dev;
535       
536        //FIXME avoid the extra copy ?
537        buffer->scpy_from_buff(buffer, (void*)&buff[0], TMP_BUFF_SZ);
538        rq.src   = (void*)&buff[0];
539        rq.count = buffer->size;
540        rq.flags = 0;
541        rq.file  = file;
542 
543        return dev->op.dev.write(dev, &rq);
544}
545
546VFS_LSEEK_FILE(devfs_lseek)
547{
548        register struct device_s *dev;
549        dev_request_t rq;
550
551        dev = (struct device_s*)file->fr_inode->i_pv;
552
553        if(dev->op.dev.lseek == NULL)
554                return VFS_ENOTUSED;
555 
556        rq.fremote = file;
557        return dev->op.dev.lseek(dev, &rq);
558}
559
560VFS_CLOSE_FILE(devfs_close)
561{
562        register struct device_s *dev;
563        dev_request_t rq;
564
565        if(file->fr_inode->i_attr & VFS_DIR)
566                return 0;
567
568        dev = (struct device_s*)file->fr_inode->i_pv;
569
570        if(dev->op.dev.close == NULL)
571                return 0;
572 
573        rq.fremote = file;
574        return dev->op.dev.close(dev, &rq);
575}
576
577VFS_RELEASE_FILE(devfs_release)
578
579        kmem_req_t req;
580
581        if(file->fr_pv == NULL)
582                return 0;
583 
584        req.type = KMEM_DEVFS_FILE;
585        req.ptr  = file->fr_pv;
586        kmem_free(&req);
587
588        file->fr_pv = NULL;
589        return 0;
590}
591
592VFS_READ_DIR(devfs_readdir)
593{
594        register struct devfs_file_s *info;
595        register struct metafs_s *current;
596        register struct device_s *current_dev;
597 
598        info = file->fr_pv;
599 
600        if(file->fr_pv == NULL)
601                return ENOTDIR;
602
603        if((current = metafs_lookup_next(&devfs_db.root, &info->iter)) == NULL)
604                return EEODIR;
605
606        current_dev    = metafs_container(current, struct device_s, node);
607        dirent->u_attr = (current_dev->type == DEV_BLK) ? VFS_DEV_BLK : VFS_DEV_CHR;
608
609        strcpy((char*)dirent->u_name, metafs_get_name(current));
610
611        dirent->u_ino = (uint_t) current_dev->base_paddr;
612
613        return 0;
614}
615
616VFS_MMAP_FILE(devfs_mmap)
617{
618        register struct device_s *dev;
619        dev_request_t rq;
620 
621        dev = (struct device_s*)file->f_private.dev;
622
623        if(dev->op.dev.mmap == NULL)
624                return ENODEV;
625
626        rq.flags  = 0;
627        rq.file   = file;
628        rq.region = region;
629
630        return dev->op.dev.mmap(dev, &rq);
631}
632
633VFS_MMAP_FILE(devfs_munmap)
634{
635        register struct device_s *dev;
636        dev_request_t rq;
637
638        dev = (struct device_s*)file->f_private.dev;
639
640        if(dev->op.dev.munmap == NULL)
641                return ENODEV;
642
643        rq.flags  = 0;
644        rq.file   = file;
645        rq.region = region;
646
647        return dev->op.dev.munmap(dev, &rq);
648}
649
650
651*/
652
653
Note: See TracBrowser for help on using the repository browser.