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

Last change on this file since 610 was 610, checked in by alain, 3 years ago

Fix several bugs in VFS to support the following
ksh commandis : cp, mv, rm, mkdir, cd, pwd

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