Changeset 16 for trunk/kernel


Ignore:
Timestamp:
May 10, 2017, 5:04:01 PM (5 years ago)
Author:
alain
Message:

mprove the HAL for interrupt, exception, syscall handling.

Location:
trunk/kernel
Files:
5 added
1 deleted
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/devices/dev_txt.c

    r14 r16  
    158158                            uint32_t   count )
    159159{
    160     uint32_t  save_sr;
    161 
    162160    // get pointer on calling thread
    163161    thread_t * this = CURRENT_THREAD;
  • trunk/kernel/kern/chdev.c

    r14 r16  
    2525#include <hal_types.h>
    2626#include <hal_special.h>
     27#include <printk.h>
    2728#include <boot_info.h>
    2829#include <xlist.h>
     
    4748        else if( func_type == DEV_FUNC_ICU ) return "ICU";
    4849        else if( func_type == DEV_FUNC_PIC ) return "PIC";
    49     else                                 return "UNDEFINED";
     50    else                                 return "undefined";
    5051}
    5152
  • trunk/kernel/kern/chdev.h

    r14 r16  
    222222 ******************************************************************************************
    223223 * @ func_type  : functionnal type.
    224  * @ return a printable string.
     224 * @ return pointer on string.
    225225 *****************************************************************************************/
    226226char * chdev_func_str( uint32_t func_type );
  • trunk/kernel/kern/core.h

    r14 r16  
    148148
    149149/***************************************************************************************
    150  * This function and reset the usage statistics.
     150 * This function reset the usage statistics.
    151151 ***************************************************************************************
    152152 * @ core       : pointer on core descriptor.
  • trunk/kernel/kern/do_interrupt.c

    r5 r16  
    11/*
    2  * kern/do_interrupt.c - kernel unified interrupt entry-point
     2 * do_interrupt.c - architecture independant interrupt handler.
    33 *
    4  * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
    5  * Copyright (c) 2011,2012 UPMC Sorbonne Universites
     4 * Author        Alain Greiner (2016)
    65 *
    7  * This file is part of ALMOS-kernel.
     6 * Copyright (c) UPMC Sorbonne Universites
    87 *
    9  * ALMOS-kernel is free software; you can redistribute it and/or modify it
     8 * This file is part of ALMOS-MKH.
     9 *
     10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
    1011 * under the terms of the GNU General Public License as published by
    1112 * the Free Software Foundation; version 2.0 of the License.
    1213 *
    13  * ALMOS-kernel is distributed in the hope that it will be useful, but
     14 * ALMOS-MKH is distributed in the hope that it will be useful, but
    1415 * WITHOUT ANY WARRANTY; without even the implied warranty of
    1516 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     
    1718 *
    1819 * You should have received a copy of the GNU General Public License
    19  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
     20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
    2021 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    2122 */
    2223
    23 #include <cpu.h>
    24 #include <task.h>
     24#include <hal_types.h>
     25#include <kernel_config.h>
    2526#include <thread.h>
    26 #include <cpu-trace.h>
    27 #include <chdev.h>
    28 #include <system.h>
    29 #include <signal.h>
     27#include <dev_icu.h>
    3028
    31 #define irq_cpu_dmsg(c,...)                             \
    32         do{                                             \
    33                 if(cpu_get_id() == (c))                 \
    34                         isr_dmsg(INFO, __VA_ARGS__);    \
    35         }while(0)
    3629
    37 void do_interrupt(struct thread_s *this, uint_t irq_num)
     30////////////////////////////////////
     31void do_interrupt( thread_t * this )
    3832{
    39         register thread_state_t old_state;
    40         struct irq_action_s *action;
    41         struct cpu_s *cpu;
    42         uint_t irq_state;
    43         error_t ret;
     33        // update user time     
     34        thread_user_time_update( this );
    4435
    45         cpu_trace_write(thread_current_cpu(this), do_interrupt);
     36    // access ICU device to call the relevant ISR
     37    dev_icu_irq_handler();
     38           
     39    // handle pending signals for interrupted thread
     40    thread_signals_handle( this );
    4641
    47         cpu = thread_current_cpu(this);
    48 
    49         cpu->irq_nr ++;
    50         old_state = this->state;
    51 
    52         if(old_state == S_USR)
    53         {
    54                 this->state = S_KERNEL;
    55                 tm_usr_compute(this);
    56         }
    57 
    58         arch_cpu_get_irq_entry(cpu, irq_num, &action);
    59         action->irq_handler(action);
    60            
    61         cpu_yield();
    62 
    63         if(old_state != S_USR)//and not a kernel thread ?
    64                 return;
    65 
    66         /* it is safe to migrate as we are going to user *
    67          * space.                                        */
    68         if(thread_migration_isActivated(this))
    69         {
    70                 thread_clear_cap_migrate(this);
    71                 cpu_enable_all_irq(&irq_state);
    72                 ret = thread_migrate(this,-1);
    73                 cpu_restore_irq(irq_state);
    74 
    75                 /* this pointer has expired */
    76                 this = CURRENT_THREAD;
    77                 cpu_wbflush();
    78 
    79                 if(ret == 0)   
    80                         thread_migration_deactivate(this);
    81                 else
    82                 {
    83                         isr_dmsg(INFO,
    84                         "%s: cpu %d, migration failed for victim pid %d, tid %d, err %d\n",
    85                          __FUNCTION__,
    86                          cpu_get_id(),
    87                          this->task->pid,
    88                          this->info.order,
    89                          ret);
    90                 }
    91         }
    92        
    93         tm_sys_compute(this);
    94         this->state = S_USR;
    95         signal_notify(this);
     42        // update kernel time
     43        thread_kernel_time_update( this );
    9644}
  • trunk/kernel/kern/printk.h

    r5 r16  
    213213#endif
    214214
     215#if CONFIG_SYSCALL_DEBUG
     216#define syscall_dmsg(...)   printk(__VA_ARGS__)
     217#else
     218#define syscall_dmsg(...)
     219#endif
     220
    215221#if CONFIG_THREAD_DEBUG
    216222#define thread_dmsg(...)   printk(__VA_ARGS__)
  • trunk/kernel/kern/rpc.c

    r14 r16  
    745745
    746746/////////////////////////////////////////////////////////////////////////////////////////
    747 //               Marshaling functions attached to RPC_VMM_GET_VSEG
     747//               Marshaling functions attached to RPC_VMM_GET_REF_VSEG
    748748/////////////////////////////////////////////////////////////////////////////////////////
    749749
     
    797797
    798798    // set output argument to client RPC descriptor
    799     vseg_xp = XPTR( local_cxy , vseg_ptr );
     799    if( vseg_ptr == NULL ) vseg_xp = XPTR_NULL;
     800    else                   vseg_xp = XPTR( local_cxy , vseg_ptr );
    800801    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)vseg_xp );
    801802}
  • trunk/kernel/kern/rpc.h

    r14 r16  
    371371 * on the vseg containing a given virtual address in a given process.
    372372 * The server cluster is supposed to be the reference cluster.
    373  * It returns NULL if no vseg has been founded.
     373 * It returns XPTR_NULL if no vseg has been founded.
    374374 ***********************************************************************************
    375375 * @ cxy     : server cluster identifier.
    376376 * @ process : [in]   pointer on process descriptor in server cluster.
    377377 * @ vaddr   : [in]   virtual address to be searched.
    378  * @ vseg    : [out]  address of buffer for vseg pointer in client cluster.
     378 * @ vseg_xp : [out]  buffer for extended pointer on vseg in client cluster.
    379379 **********************************************************************************/
    380380void rpc_vmm_get_ref_vseg_client( cxy_t              cxy,
  • trunk/kernel/kern/signal.h

    r5 r16  
    9292        uid_t    si_uid;      /*! Real user ID of sending process */
    9393        int      si_status;   /*! Exit value or signal */
    94         clock_t  si_utime;    /*! User time consumed */
    95         clock_t  si_stime;    /*! System time consumed */
     94        cycle_t  si_utime;    /*! User time consumed */
     95        cycle_t  si_stime;    /*! System time consumed */
    9696        sigval_t si_value;    /*! Signal value */
    9797        int      si_int;      /*! POSIX.1b signal */
  • trunk/kernel/kern/thread.c

    r14 r16  
    5151
    5252//////////////////////////////////////////////////////////////////////////////////////
    53 //   global variables for display / must be consistant with enum in "thread.h"
    54 //////////////////////////////////////////////////////////////////////////////////////
    55 
    56 const char* thread_type_name[THREAD_TYPES_NR] =
    57 {
    58         "USER",
    59         "RPC"
    60         "KERNEL",
    61         "IDLE",
    62 };
    63 
    64 //////////////////////////////////////////////////////////////////////////////////////
    65 // This static function returns a printable string for the thread type.
     53// This function returns a printable string for the thread type.
    6654//////////////////////////////////////////////////////////////////////////////////////
    6755char * thread_type_str( uint32_t type )
    6856{
    69     if     ( type == THREAD_USER   ) return "THREAD_USER";
    70     else if( type == THREAD_RPC    ) return "THREAD_RPC";
    71     else if( type == THREAD_DEV    ) return "THREAD_DEV";
    72     else if( type == THREAD_KERNEL ) return "THREAD_KERNEL";
    73     else if( type == THREAD_IDLE   ) return "THREAD_IDLE";
     57    if     ( type == THREAD_USER   ) return "USER";
     58    else if( type == THREAD_RPC    ) return "RPC";
     59    else if( type == THREAD_DEV    ) return "DEV";
     60    else if( type == THREAD_KERNEL ) return "KERNEL";
     61    else if( type == THREAD_IDLE   ) return "IDLE";
    7462    else                             return "undefined";
    7563}
     
    703691}  // end thread_idle()
    704692
    705 
     693/////////////////////////////////////////////////
     694void thread_user_time_update( thread_t * thread )
     695{
     696    // TODO
     697    printk("\n[WARNING] function %s not implemented\n", __FUNCTION__ );
     698}
     699
     700///////////////////////////////////////////////////
     701void thread_kernel_time_update( thread_t * thread )
     702{
     703    // TODO
     704    printk("\n[WARNING] function %s not implemented\n", __FUNCTION__ );
     705}
     706
     707////////////////////////////////////////////////
     708void thread_signals_handler( thread_t * thread )
     709{
     710    // TODO
     711    printk("\n[WARNING] function %s not implemented\n", __FUNCTION__ );
     712}
     713
     714
  • trunk/kernel/kern/thread.h

    r14 r16  
    128128        uint32_t              tm_born;       /*! date of the thread loading               */
    129129        uint32_t              tm_dead;       /*! date of the death                        */
    130         clock_t               tm_sleep;      /*! TODO ???  [AG]                           */
    131         clock_t               tm_wait;       /*! TODO ???  [AG]                           */
    132         clock_t               tm_usr;        /*! user execution duration                  */
    133         clock_t               tm_sys;        /*! system execution duration                */
     130        cycle_t               tm_sleep;      /*! TODO ???  [AG]                           */
     131        cycle_t               tm_wait;       /*! TODO ???  [AG]                           */
     132        cycle_t               tm_usr;        /*! user execution duration                  */
     133        cycle_t               tm_sys;        /*! system execution duration                */
    134134}
    135135thread_info_t;
     
    151151typedef struct thread_s
    152152{
     153    void              * cpu_uzone;       /*! used for exception/interrupt/syscall     */
     154        void              * cpu_context;     /*! used for context switch                  */
     155        void              * fpu_context;     /*! used for dynamic FPU allocation          */
     156
    153157        uint32_t            trdid;           /*! thread index (in THTBL)                  */
    154158        thread_type_t       type;            /*! thread type                              */
     
    177181    uint32_t            signals;         /*! bit vector of signals                    */
    178182
    179         error_t             errno;           /*! errno value of last system call          */
     183        error_t             errno;           /*! errno value set by last system call      */
    180184
    181185    bool_t              fork_user;       /*! user defined placement for next fork()   */
     
    205209    xlist_entry_t       wait_list;       /*! member of threads blocked on same cond   */
    206210
    207         void              * fpu_context;     /*! pointer on FPU context                   */
    208         void              * cpu_context;     /*! pointer on CPU context                   */
    209 
    210211        thread_info_t       info;            /*! embedded thread_info_t                   */
    211212
     
    219220
    220221#define CURRENT_THREAD  (hal_get_current_thread())
     222
     223/***************************************************************************************
     224 * This function returns a printable string for a thread type.
     225 ***************************************************************************************
     226 * @ type    : thread type.
     227 * returns pointer on string.
     228 **************************************************************************************/
     229char * thread_type_str( uint32_t type );
    221230
    222231/***************************************************************************************
     
    438447void thread_kill( thread_t * thread );
    439448
     449/***************************************************************************************
     450 * This function updates the calling thread user_time counter, and reset the thread
     451 * cycles counter.
     452 * TODO This function is not implemented.
     453 ***************************************************************************************
     454 * @ thread   : local pointer on target thread.
     455 **************************************************************************************/
     456void thread_user_time_update( thread_t * thread );
     457
     458/**************************************************************************************n
     459 * This function updates the calling thread kernel_time counter, and reset the thread
     460 * cycles counter.
     461 * TODO This function is not implemented.
     462 ***************************************************************************************
     463 * @ thread   : local pointer on target thread.
     464 **************************************************************************************/
     465void thread_kernel_time_update( thread_t * thread );
     466
     467/***************************************************************************************
     468 * This function handle all pending signals for the thread identified by the <thread>
     469 * argument. It is called each time the core exit the kernel, after handling an
     470 * interrupt, exception or syscall.
     471 * TODO This function is not implemented.
     472 ***************************************************************************************
     473 * @ thread   : local pointer on target thread.
     474 **************************************************************************************/
     475void thread_signals_handle( thread_t * thread );
     476
     477
     478
    440479#endif  /* _THREAD_H_ */
  • trunk/kernel/libk/barrier.c

    r14 r16  
    2424#include <hal_types.h>
    2525#include <hal_remote.h>
     26#include <hal_atomic.h>
    2627#include <barrier.h>
    2728
  • trunk/kernel/libk/barrier.h

    r14 r16  
    3838typedef struct barrier_s
    3939{
    40     volatile uint32_t   current;            // number of arrived threads
    41     volatile uint32_t   sense;              // barrier state (toggle)
    42     uint32_t            pad[(CONFIG_CACHE_LINE_SIZE>>2)-2];
     40    uint32_t   current;            // number of arrived threads
     41    uint32_t   sense;              // barrier state (toggle)
     42    uint32_t   pad[(CONFIG_CACHE_LINE_SIZE>>2)-2];
    4343}
    4444barrier_t;
  • trunk/kernel/mm/vseg.h

    r1 r16  
    133133 **********************************************************************************************
    134134 * @ vseg      : pointer on the vseg descriptor.
    135  * @ src       : extended pointer on the reference vseg descriptor.
     135 * @ ref_xp    : extended pointer on the reference vseg descriptor.
    136136 *********************************************************************************************/
    137137void vseg_init_from_ref( vseg_t * vseg,
    138                          xptr_t   ref );
     138                         xptr_t   ref_xp );
    139139
    140140/**********************************************************************************************
  • trunk/kernel/syscalls/sys_thread_exit.c

    r1 r16  
    3232int sys_thread_exit ( void * exit_val )
    3333{
    34         thread_t * this = current_thread;
    35     cpu_t    * cpu  = current_cpu;
    36         uint32_t   state;
    37         bool_t     isEmpty;
    38         bool_t     isReleased;
     34        thread_t  * this = CURRENT_THREAD;
     35    core_t    * core = this->core;
     36        bool_t      isEmpty;
     37        bool_t      isReleased;
     38    uint32_t    irq_state;
    3939
    40         /* TODO: the cpu->lid must match the core index in the logical cluster */
    41         if(this->process->pid != 1)
    42                 dqdt_update_threads_number( local_cxy , cpu->lid , -1 );
     40        // update DQDT TODO must be done by thread destroy
     41        if(this->process->pid != 1) dqdt_local_update_threads( -1 );
    4342
    4443        spinlock_lock( &this->lock );
     
    4645        if(!(thread_isJoinable(this)))
    4746        {
    48                 spinlock_unlock_nosched(&this->lock);
    4947                goto exit_dead;
    5048        }
    5149
    52         // Check if there's a thread waiting the end of callee thread
     50        // Check if there's a thread waiting the end of calling thread
    5351        isEmpty = wait_queue_isEmpty(&this->info.wait_queue);
    5452
     
    7270
    7371        // Release FPU if required
    74         cpu_disable_all_irq(&state);
    75         if(current_cpu->fpu_owner == this)
     72        hal_disable_irq( &irq_state );
     73        if(core->fpu_owner == this)
    7674        {
    77                 current_cpu->fpu_owner = NULL;
     75                core->fpu_owner = NULL;
    7876                isReleased = true;
    7977        }
    80         cpu_restore_irq(state);
     78        hal_restore_irq( irq_state );
    8179
    8280        if(isReleased)
  • trunk/kernel/syscalls/syscalls.h

    r1 r16  
    11/*
    2  * syscall.h - kernel services definition
     2 * syscalls.h - kernel services definition
    33 *
    44 * Author  Ghassan Almaless (2007,2008,2009,2010,2011,2012)
     
    2323 */
    2424
    25 #ifndef _SYSCALL_H_
    26 #define _SYSCALL_H_
     25#ifndef _SYSCALLS_H_
     26#define _SYSCALLS_H_
    2727
    2828/******************************************************************************************
    29  * This enum defines the system calls index.
    30  * It must be kept consistant with the syscall vector defined in sys_vector.c file.
     29 * This enum defines the mnemonics for the syscall indexes.
     30 * It must be kept consistent with the array defined in do_syscalls.c
    3131 *****************************************************************************************/
    3232enum
     
    9090/********************************************************************************************/
    9191
    92 /*********************************************************************************************
    93  * This function TODO
     92
     93/*********************************************************************************************
     94 * [0] This function TODO
     95 ********************************************************************************************/
     96int sys_thread_exit( void * );
     97
     98/*********************************************************************************************
     99 * [1] This function TODO
     100 ********************************************************************************************/
     101int sys_mmap();
     102
     103/*********************************************************************************************
     104 * [2] This function TODO
     105 ********************************************************************************************/
     106int sys_thread_create();
     107
     108/*********************************************************************************************
     109 * [3] This function TODO
     110 ********************************************************************************************/
     111int sys_thread_join();
     112
     113/*********************************************************************************************
     114 * [4] This function TODO
     115 ********************************************************************************************/
     116int sys_thread_detach();
     117
     118/*********************************************************************************************
     119 * [5] This function TODO
     120 ********************************************************************************************/
     121int sys_thread_yield();
     122
     123/*********************************************************************************************
     124 * [6] This function TODO
     125 ********************************************************************************************/
     126int sys_sem();
     127
     128/*********************************************************************************************
     129 * [7] This function TODO
     130 ********************************************************************************************/
     131int sys_cond_var();
     132
     133/*********************************************************************************************
     134 * [8] This function TODO
     135 ********************************************************************************************/
     136int sys_barrier();
     137
     138/*********************************************************************************************
     139 * [9] This function TODO
     140 ********************************************************************************************/
     141int sys_rwlock();
     142
     143/*********************************************************************************************
     144 * [10] This function TODO
     145 ********************************************************************************************/
     146int sys_thread_sleep();
     147
     148/*********************************************************************************************
     149 * [11] This function TODO
     150 ********************************************************************************************/
     151int sys_thread_wakeup();
     152
     153/*********************************************************************************************
     154 * [12] This function TODO
     155 ********************************************************************************************/
     156int sys_open();
     157
     158/*********************************************************************************************
     159 * [13] This function TODO
     160 ********************************************************************************************/
     161int sys_creat();
     162
     163/*********************************************************************************************
     164 * [14] This function TODO
     165 ********************************************************************************************/
     166int sys_read();
     167
     168/*********************************************************************************************
     169 * [15] This function TODO
     170 ********************************************************************************************/
     171int sys_write();
     172
     173/*********************************************************************************************
     174 * [16] This function TODO
     175 ********************************************************************************************/
     176int sys_lseek();
     177
     178/*********************************************************************************************
     179 * [17] This function TODO
     180 ********************************************************************************************/
     181int sys_close();
     182
     183/*********************************************************************************************
     184 * [18] This function TODO
     185 ********************************************************************************************/
     186int sys_unlink();
     187
     188/*********************************************************************************************
     189 * [19] This function TODO
     190 ********************************************************************************************/
     191int sys_pipe();
     192
     193/*********************************************************************************************
     194 * [20] This function TODO
     195 ********************************************************************************************/
     196int sys_chdir();
     197
     198/*********************************************************************************************
     199 * [21] This function TODO
     200 ********************************************************************************************/
     201int sys_mkdir();
     202
     203/*********************************************************************************************
     204 * [22] This function TODO
     205 ********************************************************************************************/
     206int sys_mkfifo();
     207
     208/*********************************************************************************************
     209 * [23] This function TODO
     210 ********************************************************************************************/
     211int sys_opendir();
     212
     213/*********************************************************************************************
     214 * [24] This function TODO
     215 ********************************************************************************************/
     216int sys_readdir();
     217
     218/*********************************************************************************************
     219 * [25] This function TODO
     220 ********************************************************************************************/
     221int sys_closedir();
     222
     223/*********************************************************************************************
     224 * [26] This function TODO
     225 ********************************************************************************************/
     226int sys_getcwd();
     227
     228/*********************************************************************************************
     229 * [27] This function TODO
     230 ********************************************************************************************/
     231int sys_clock();
     232
     233/*********************************************************************************************
     234 * [28] This function TODO
     235 ********************************************************************************************/
     236int sys_alarm();
     237
     238/*********************************************************************************************
     239 * [29] This function TODO
     240 ********************************************************************************************/
     241int sys_dma_memcpy();
     242
     243/*********************************************************************************************
     244 * [30] This function TODO
     245 ********************************************************************************************/
     246int sys_utls();
     247
     248/*********************************************************************************************
     249 * [31] This function TODO
     250 ********************************************************************************************/
     251int sys_notAvailable();
     252
     253/*********************************************************************************************
     254 * [32] This function TODO
     255 ********************************************************************************************/
     256int sys_signal();
     257
     258/*********************************************************************************************
     259 * [33] This function TODO
     260 ********************************************************************************************/
     261int sys_sigreturn_setup();
     262
     263/*********************************************************************************************
     264 * [34] This function implements the "kill" system call.
     265 * It register the signal identified by the <sig> argument in all thread descriptors
     266 * of process identified by the <pid> argument.
     267 *********************************************************************************************
     268 * @ pid      : target process identifier.
     269 * @ sig      : signal index.
     270 ********************************************************************************************/
     271int sys_kill( pid_t    pid,
     272              uint32_t sig );
     273
     274/*********************************************************************************************
     275 * [35] This function TODO
    94276 ********************************************************************************************/
    95277int sys_getpid();
    96278
    97279/*********************************************************************************************
    98  * This function implement the "fork" system call.
     280 * [36] This function implement the "fork" system call.
    99281 * The calling process descriptor (parent process), and the associated thread descriptor are
    100282 * replicated in the same cluster as the calling thread, but the new process (child process)
     
    111293
    112294/*********************************************************************************************
    113  * This function implement the exec system call.
     295 * [37] This function implement the "exec" system call.
    114296 * It is executed in the client cluster, but the new process descriptor and main thread
    115297 * must be created in a server cluster, that is generally another cluster, using a RPC.
     
    124306 * required to build the new process descriptor and the associated thread, including
    125307 * the mode (local/remote).
     308 *********************************************************************************************
    126309 * @ filename : string pointer on .elf filename (virtual pointer in user space)
    127310 * @ argv     : array of strings on process arguments (virtual pointers in user space)
     
    133316              char ** envp );
    134317
    135 
    136 /*********************************************************************************************
    137  * This function TODO
     318/*********************************************************************************************
     319 * [38] This function TODO
     320 ********************************************************************************************/
     321int sys_thread_getattr();
     322
     323/*********************************************************************************************
     324 * [39] This function implements the ps system call.
    138325 ********************************************************************************************/
    139326int sys_ps( uint32_t cmd,
     
    141328            uint32_t tid );
    142329
    143 
    144 
    145 #endif
     330/*********************************************************************************************
     331 * [40] This function TODO
     332 ********************************************************************************************/
     333int sys_madvise();
     334
     335/*********************************************************************************************
     336 * [41] This function TODO
     337 ********************************************************************************************/
     338int sys_mcntl();
     339
     340/*********************************************************************************************
     341 * [42] This function TODO
     342 ********************************************************************************************/
     343int sys_stat();
     344
     345/*********************************************************************************************
     346 * [43] This function TODO
     347 ********************************************************************************************/
     348int sys_thread_migrate();
     349
     350/*********************************************************************************************
     351 * [44] This function TODO
     352 ********************************************************************************************/
     353int sys_sbrk();
     354
     355/*********************************************************************************************
     356 * [45] This function TODO
     357 ********************************************************************************************/
     358int sys_rmdir();
     359
     360/*********************************************************************************************
     361 * [46] This function TODO
     362 ********************************************************************************************/
     363int sys_ftime();
     364
     365/*********************************************************************************************
     366 * [47] This function TODO
     367 ********************************************************************************************/
     368int sys_chmod();
     369
     370/*********************************************************************************************
     371 * [48] This function TODO
     372 ********************************************************************************************/
     373int sys_fsync();
     374
     375/*********************************************************************************************
     376 * [49] This function TODO
     377 ********************************************************************************************/
     378int sys_gettimeofday();
     379
     380/*********************************************************************************************
     381 * [50] This function TODO
     382 ********************************************************************************************/
     383int sys_times();
     384
     385
     386#endif  // _SYSCALLS_H_
Note: See TracChangeset for help on using the changeset viewer.