Changeset 457 for trunk/kernel/libk


Ignore:
Timestamp:
Aug 2, 2018, 11:47:13 AM (6 years ago)
Author:
alain
Message:

This version modifies the exec syscall and fixes a large number of small bugs.
The version number has been updated (0.1)

Location:
trunk/kernel/libk
Files:
39 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/libk/barrier.c

    r16 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_atomic.h>

  • trunk/kernel/libk/barrier.h

    r423 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*****************************************************************************************

  • trunk/kernel/libk/bits.c

    r351 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <bits.h>
    2727

  • trunk/kernel/libk/bits.h

    r454 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131/*********************************************************************************************

  • trunk/kernel/libk/ctype.c

    r1 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626////////////////////

  • trunk/kernel/libk/elf.c

    r441 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_uspace.h>
    … …  
    210210} // end elf_segments_register()
    211211
    212 ///////////////////////////////////////////////
    213 error_t elf_load_process( char      * pathname,
    214                           process_t * process)
     212//////////////////////////////////////////////
     213error_t elf_load_process( xptr_t      file_xp,
     214                          process_t * process )
    215215{
    216216        kmem_req_t   req;              // kmem request for program header
    … …  
    218218        void       * segs_base;        // pointer on buffer for segment descriptors array
    219219        uint32_t     segs_size;        // size of buffer for segment descriptors array
    220         xptr_t       file_xp;          // extended pointer on created file descriptor
    221         uint32_t     file_id;          // file descriptor index (unused)
     220    char         name[CONFIG_VFS_MAX_NAME_LENGTH];
    222221        error_t      error;
    223222
     223    // get file name for error reporting and debug
     224    cxy_t         file_cxy = GET_CXY( file_xp );
     225    vfs_file_t  * file_ptr = GET_PTR( file_xp );
     226    vfs_inode_t * inode    = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
     227    vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
     228   
    224229#if DEBUG_ELF_LOAD
    225 uint32_t cycle = (uint32_t)hal_get_cycles();
    226 if( DEBUG_ELF_LOAD < cycle )
    227 printk("\n[DBG] %s : thread %d enter for <%s> / cycle %d\n",
    228 __FUNCTION__, CURRENT_THREAD, pathname, cycle );
    229 #endif
    230 
    231     // avoid GCC warning
    232         file_xp = XPTR_NULL; 
    233         file_id = -1;
    234 
    235         // open file
    236         error = vfs_open( process,
    237                           pathname,
    238                           O_RDONLY,
    239                           0,
    240                           &file_xp,
    241                           &file_id );
    242         if( error )
    243         {
    244                 printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , pathname );
    245                 return -1;
    246         }
    247 
    248 #if (DEBUG_ELF_LOAD & 1)
    249 if( DEBUG_ELF_LOAD < cycle )
    250 printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, pathname );
     230uint32_t      cycle = (uint32_t)hal_get_cycles();
     231if( DEBUG_ELF_LOAD < cycle )
     232printk("\n[DBG] %s : thread %d in process %x enter for <%s> / cycle %d\n",
     233__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, cycle );
    251234#endif
    252235
    … …  
    257240        if( error )
    258241        {
    259                 printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , pathname );
    260                 vfs_close( file_xp , file_id );
     242                printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , name );
    261243                return -1;
    262244        }
    … …  
    264246#if (DEBUG_ELF_LOAD & 1)
    265247if( DEBUG_ELF_LOAD < cycle )
    266 printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , pathname );
     248printk("\n[DBG] %s : loaded elf header for <%s>\n", __FUNCTION__ , name );
    267249#endif
    268250
    … …  
    270252        {
    271253                printk("\n[ERROR] in %s : no segments found\n", __FUNCTION__ );
    272                 vfs_close( file_xp , file_id );
    273254                return -1;
    274255        }
    … …  
    286267        {
    287268                printk("\n[ERROR] in %s : no memory for segment descriptors\n", __FUNCTION__ );
    288                 vfs_close( file_xp , file_id );
    289269                return -1;
    290270        }
    … …  
    296276        {
    297277                printk("\n[ERROR] in %s : cannot seek for descriptors array\n", __FUNCTION__ );
    298                 vfs_close( file_xp , file_id );
    299278                req.ptr = segs_base;
    300279                kmem_free( &req );
    … …  
    304283#if (DEBUG_ELF_LOAD & 1)
    305284if( DEBUG_ELF_LOAD < cycle )
    306 printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , pathname );
     285printk("\n[DBG] %s : segments array allocated for <%s>\n", __FUNCTION__ , name );
    307286#endif
    308287
    … …  
    316295        {
    317296                printk("\n[ERROR] in %s : cannot read segments descriptors\n", __FUNCTION__ );
    318                 vfs_close( file_xp , file_id );
    319297                req.ptr = segs_base;
    320298                kmem_free( &req );
    … …  
    324302#if (DEBUG_ELF_LOAD & 1)
    325303if( DEBUG_ELF_LOAD < cycle )
    326 printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , pathname );
     304printk("\n[DBG] %s loaded segments descriptors for <%s>\n", __FUNCTION__ , name );
    327305#endif
    328306
    … …  
    334312        if( error )
    335313        {
    336                 vfs_close( file_xp , file_id );
    337314                req.ptr = segs_base;
    338315                kmem_free( &req );
    … …  
    353330cycle = (uint32_t)hal_get_cycles();
    354331if( DEBUG_ELF_LOAD < cycle )
    355 printk("\n[DBG] %s : thread %d exit for <%s> / entry_point %x / cycle %d\n",
    356 __FUNCTION__, CURRENT_THREAD, pathname, header.e_entry, cycle );
     332printk("\n[DBG] %s : thread %x in process %x exit for <%s> / entry_point %x / cycle %d\n",
     333__FUNCTION__, CURRENT_THREAD->trdid, process->pid, name, header.e_entry, cycle );
    357334#endif
    358335

  • trunk/kernel/libk/elf.h

    r273 r457  
    2222#define _ELF_H_ 1
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626/*
    … …  
    204204#define PF_MASKPROC     0xf0000000      /* Processor-specific */
    205205
    206 #if defined(HAL_32BIT)
     206#if defined(HAL_ELF_32_BITS)
    207207#define Elf_Half  Elf32_Half
    208208#define Elf_Word  Elf32_Word
    … …  
    213213#define Elf_Phdr  Elf32_Phdr
    214214#define ELFCLASS  ELFCLASS32
    215 #elif defined (HAL_64BIT)
     215#elif defined (HAL_ELF_64_BITS)
    216216#define Elf_Half  Elf64_Half
    217217#define Elf_Word  Elf64_Word
    … …  
    224224#define ELFCLASS  ELFCLASS64
    225225#else
    226 #error "Must define HAL_64BIT/HAL_32BIT"
     226#error "Must define HAL_ELF_64_BITS / HAL_ELF_32_BITS"
    227227#endif
    228228
    229229/****************************************************************************************
    230  * This function registers in VMM the CODE and DATA vsegs defined in the .elf file.
     230 * This function registers in VMM of the process identified by the <process> argument
     231 * the CODE and DATA vsegs defined in the .elf open file descriptor <file_xp>.
    231232 * The segments are not loaded in memory.
    232233 * It also registers the process entry point in VMM.
    233234 ****************************************************************************************
    234  * @ pathname : local pointer on .elf file pathname (in kernel space).
     235 * @ file_xp  : extended pointer on .elf file descriptor.
    235236 * @ process  : local pointer on target process descriptor.
    236237 ***************************************************************************************/
    237 error_t elf_load_process( char      * pathname,
     238error_t elf_load_process( xptr_t      file_xp,
    238239                          process_t * process);
    239240

  • trunk/kernel/libk/grdxt.c

    r423 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_special.h>
    2626#include <errno.h>

  • trunk/kernel/libk/grdxt.h

    r406 r457  
    2525#define _GRDXT_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828
    2929/*******************************************************************************************

  • trunk/kernel/libk/htab.c

    r423 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <htab.h>

  • trunk/kernel/libk/htab.h

    r23 r457  
    2626#define _HTAB_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <rwlock.h>
    3030#include <list.h>

  • trunk/kernel/libk/list.h

    r450 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030
    3131#ifndef NULL

  • trunk/kernel/libk/memcpy.c

    r113 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <printk.h>
    2626

  • trunk/kernel/libk/memcpy.h

    r113 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525
    2626

  • trunk/kernel/libk/readlock.c

    r124 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_atomic.h>
    2727#include <hal_special.h>

  • trunk/kernel/libk/readlock.h

    r14 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030/*******************************************************************************************

  • trunk/kernel/libk/remote_barrier.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_barrier.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <remote_spinlock.h>
    3030#include <xlist.h>

  • trunk/kernel/libk/remote_condvar.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_condvar.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <remote_spinlock.h>
    3030#include <xlist.h>

  • trunk/kernel/libk/remote_fifo.c

    r408 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_irqmask.h>
    2727#include <hal_remote.h>

  • trunk/kernel/libk/remote_fifo.h

    r407 r457  
    2727
    2828#include <kernel_config.h>
    29 #include <hal_types.h>
     29#include <hal_kernel_types.h>
    3030#include <printk.h>
    3131#include <errno.h>

  • trunk/kernel/libk/remote_mutex.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_special.h>

  • trunk/kernel/libk/remote_mutex.h

    r23 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/remote_rwlock.c

    r438 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_rwlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/remote_sem.c

    r436 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <thread.h>
    … …  
    7575
    7676///////////////////////////////////////////
    77 error_t remote_sem_create( intptr_t  vaddr,
    78                            uint32_t  value )
    79 {
     77error_t remote_sem_create( intptr_t   vaddr,
     78                           uint32_t   value,
     79                           xptr_t     sem_xp_xp )
     80{
     81    remote_sem_t * sem_ptr;
    8082    xptr_t         sem_xp;
    81     remote_sem_t * sem_ptr;
    8283
    8384    // get pointer on local process descriptor
    … …  
    103104    {
    104105        rpc_kcm_alloc_client( ref_cxy , KMEM_SEM , &sem_xp );
    105         sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
    106     }
    107 
    108     if( sem_xp == XPTR_NULL ) return ENOMEM;
     106        sem_ptr = GET_PTR( sem_xp );
     107    }
     108
     109    if( sem_xp == XPTR_NULL ) return -1;
    109110
    110111    // initialise semaphore
    111112    hal_remote_sw ( XPTR( ref_cxy , &sem_ptr->count ) , value );
    112113        hal_remote_spt( XPTR( ref_cxy , &sem_ptr->ident ) , (void *)vaddr );
    113 
    114114    remote_spinlock_init( XPTR( ref_cxy , &sem_ptr->lock ) );
    115115        xlist_root_init( XPTR( ref_cxy , &sem_ptr->root ) );
    … …  
    119119    xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->sem_root );
    120120    xptr_t xp_list = XPTR( ref_cxy , &sem_ptr->list );
    121 
    122121    remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
    123122    xlist_add_first( root_xp , xp_list );
    124123    remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
    125124
     125    // write extended pointer on semaphore in calling thread buffer
     126    hal_remote_swd( sem_xp_xp , sem_xp );
     127
    126128    return 0;
    127129
    128 }  // en remote_sem_init()
     130}  // en remote_sem_create()
    129131 
    130132////////////////////////////////////////
    … …  
    139141    // get reference process cluster and local pointer
    140142    cxy_t       ref_cxy = GET_CXY( ref_xp );
    141     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
     143    process_t * ref_ptr = GET_PTR( ref_xp );
    142144
    143145    // get semaphore cluster and local pointer
    … …  
    148150    remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
    149151 
    150     // get remote pointer on waiting queue
    151     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
     152    // get remote pointer on waiting queue root
     153    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
    152154 
    153155    if( !xlist_is_empty( root_xp ) )   // user error
    … …  
    184186}  // end remote_sem_destroy()
    185187
    186 //////////////////////////////////
     188/////////////////////////////////////
    187189void remote_sem_wait( xptr_t sem_xp )
    188190{
    189191    // get semaphore cluster and local pointer
    190192    cxy_t          sem_cxy = GET_CXY( sem_xp );
    191     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     193    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    192194
    193195    // get lock protecting semaphore     
    … …  
    210212
    211213        // register thread in waiting queue
    212         xptr_t root_xp   = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
    213         xptr_t thread_xp = XPTR( local_cxy , this );
    214                 xlist_add_last( root_xp , thread_xp );
     214        xptr_t root_xp = XPTR( sem_cxy   , &sem_ptr->root );
     215        xptr_t list_xp = XPTR( local_cxy , &this->wait_list );
     216                xlist_add_last( root_xp , list_xp );
    215217
    216218        // release lock
    … …  
    228230    // get semaphore cluster and local pointer
    229231    cxy_t          sem_cxy = GET_CXY( sem_xp );
    230     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     232    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    231233
    232234    // get lock protecting semaphore
    233235        remote_spinlock_lock( XPTR( sem_cxy , &sem_ptr->lock ) );
    234236 
     237    // get semaphore current value
     238    uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
     239
    235240    // get remote pointer on waiting queue root
    236     xptr_t root_xp = (xptr_t)hal_remote_lwd( XPTR( sem_cxy , &sem_ptr->root ) );
     241    xptr_t root_xp = XPTR( sem_cxy , &sem_ptr->root );
    237242 
    238243        if( xlist_is_empty( root_xp ) )   // no waiting thread
    239244    {
    240         // get semaphore current value
    241         uint32_t count = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );
    242 
    243245        // increment semaphore value
    244246        hal_remote_sw( XPTR( sem_cxy , &sem_ptr->count ) , count + 1 );
    … …  
    251253        // get thread cluster and local poiner
    252254        cxy_t      thread_cxy = GET_CXY( thread_xp );
    253         thread_t * thread_ptr = (thread_t *)GET_PTR( thread_xp );
    254 
    255         // remove the thread from the waiting queue, and unblock
     255        thread_t * thread_ptr = GET_PTR( thread_xp );
     256
     257        // remove this thread from the waiting queue, and unblock it
    256258        xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
    257259                thread_unblock( thread_xp , THREAD_BLOCKED_SEM );
    … …  
    270272    // get semaphore cluster and local pointer
    271273    cxy_t          sem_cxy = GET_CXY( sem_xp );
    272     remote_sem_t * sem_ptr = (remote_sem_t *)GET_PTR( sem_xp );
     274    remote_sem_t * sem_ptr = GET_PTR( sem_xp );
    273275
    274276    *data = hal_remote_lw( XPTR( sem_cxy , &sem_ptr->count ) );

  • trunk/kernel/libk/remote_sem.h

    r23 r457  
    2525#define _SEMAPHORE_H_
    2626
    27 #include <hal_types.h>
     27#include <hal_kernel_types.h>
    2828#include <xlist.h>
    2929#include <remote_spinlock.h>
    … …  
    7777 * This function implements the SEM_INIT operation.
    7878 * It allocates memory for a remote semaphore in reference cluster, using a RPC if required,
    79  * and initializes it, using remote accesses.
     79 * and initializes it, using remote accesses from values defined by the <vaddr> and <value>
     80 * arguments. It uses also a remote access to return the extended pointer on the semaphore
     81 * in the buffer identified by the <buf_xp> argument.
    8082 *********************************************************************************************
    81  * @ vaddr    : semaphore virtual address, used as identifier.
    82  * @ value    : semaphore initial value.
    83  * @ returns 0 if success / returns ENOMEM if error.
     83 * @ vaddr     : [in] semaphore virtual address, used as identifier.
     84 * @ value     : [in] semaphore initial value.
     85 * @ sem_xp_xp : [out] extended pointer on buffer to store extended pointer on semaphore.
     86 * @ returns 0 if success / returns -1 if no memory.
    8487 ********************************************************************************************/
    8588error_t remote_sem_create( intptr_t  vaddr,
    86                            uint32_t  value );
     89                           uint32_t  value,
     90                           xptr_t    sem_xp_xp );
    8791 
    8892/****************************yy***************************************************************
    … …  
    9195 * reference cluster, using a RPC if required.
    9296 *********************************************************************************************
    93  * @ sem_xp   : extended pointer on semaphore.
     97 * @ sem_xp   : [in] extended pointer on semaphore.
    9498 ********************************************************************************************/
    9599void remote_sem_destroy( xptr_t sem_xp );
    … …  
    102106 *    waiting queue, block the thread, and yield.
    103107 *********************************************************************************************
    104  * @ sem_xp   : extended pointer on semaphore.
     108 * @ sem_xp   : [in] extended pointer on semaphore.
    105109 ********************************************************************************************/
    106110void remote_sem_wait( xptr_t sem_xp );
    … …  
    111115 * - If the waiting queue is not empty, it wakes up the first waiting thread.
    112116 *********************************************************************************************
    113  * @ sem_xp   : extended pointer on semaphore.
     117 * @ sem_xp   : [in] extended pointer on semaphore.
    114118 ********************************************************************************************/
    115119void remote_sem_post( xptr_t sem_xp );
    … …  
    119123 * It returns in the <data> buffer the semaphore current value.
    120124 *********************************************************************************************
    121  * @ sem_xp   : extended pointer on semaphore.
    122  * @ data     : [out] returned value.
     125 * @ sem_xp   : [in]  extended pointer on semaphore.
     126 * @ data     : [out] local pointer on buffer for returned value.
    123127 ********************************************************************************************/
    124128void remote_sem_get_value( xptr_t      sem_xp,

  • trunk/kernel/libk/remote_spinlock.c

    r443 r457  
    2222 */
    2323
    24 #include <hal_types.h>
     24#include <hal_kernel_types.h>
    2525#include <hal_remote.h>
    2626#include <hal_irqmask.h>

  • trunk/kernel/libk/remote_spinlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <xlist.h>
    3030

  • trunk/kernel/libk/rwlock.c

    r438 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_atomic.h>
    2727#include <hal_special.h>

  • trunk/kernel/libk/rwlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <list.h>
    3030

  • trunk/kernel/libk/spinlock.c

    r438 r457  
    2424
    2525#include <kernel_config.h>
    26 #include <hal_types.h>
     26#include <hal_kernel_types.h>
    2727#include <hal_atomic.h>
    2828#include <hal_special.h>

  • trunk/kernel/libk/spinlock.h

    r438 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <list.h>
    3030

  • trunk/kernel/libk/string.c

    r337 r457  
    2323 */
    2424
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <ctype.h>
    2727#include <string.h>

  • trunk/kernel/libk/string.h

    r323 r457  
    2626#define _STRING_H_
    2727
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929
    3030

  • trunk/kernel/libk/xhtab.c

    r423 r457  
    2323
    2424#include <kernel_config.h>
    25 #include <hal_types.h>
     25#include <hal_kernel_types.h>
    2626#include <hal_special.h>
    2727#include <hal_remote.h>

  • trunk/kernel/libk/xhtab.h

    r204 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <remote_rwlock.h>
    3030#include <xlist.h>

  • trunk/kernel/libk/xlist.h

    r435 r457  
    2626
    2727#include <kernel_config.h>
    28 #include <hal_types.h>
     28#include <hal_kernel_types.h>
    2929#include <hal_remote.h>
    3030
Note: See TracChangeset for help on using the changeset viewer.