Changeset 630 for trunk/kernel


Ignore:
Timestamp:
May 21, 2019, 6:00:06 PM (6 years ago)
Author:
alain
Message:

1) Fix a bug in the vfs_add_special_dentries() function:
The <.> and <..> dentries must not be created on IOC and on the mapper
for the VFS root directory.
2) Fix a bug in the hal_gpt_allocate_pt2 function, related to the
use of the TSAR_LOCKED attribute to avoid concurrent mapping of the PTD1.

Location:
trunk/kernel
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/fs/fatfs.c

    r628 r630  
    14041404
    14051405#if (DEBUG_FATFS_ADD_DENTRY & 1)
     1406cycle = (uint32_t)hal_get_cycles();
    14061407if( DEBUG_FATFS_ADD_DENTRY < cycle )
    1407 printk("\n[%s] FSM step = %d / offset = %x / nb_lfn = %d\n",
    1408 __FUNCTION__, step, offset, nb_lfn );
     1408printk("\n[%s] FSM step = %d / offset = %x / nb_lfn = %d / cycle %d\n",
     1409__FUNCTION__, step, offset, nb_lfn, cycle );
    14091410#endif
    14101411
    … …  
    15331534    } // exit while     
    15341535
     1536#if (DEBUG_FATFS_ADD_DENTRY & 1)
     1537cycle = (uint32_t)hal_get_cycles();
     1538if( DEBUG_FATFS_ADD_DENTRY < cycle )
     1539printk("\n[%s]  thread[%x,%x] before IOC access / cycle %d\n",
     1540__FUNCTION__, this->process->pid, this->trdid, cycle );
     1541#endif
     1542
    15351543    // copy the modified page to the IOC device
    15361544    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   

  • trunk/kernel/fs/vfs.c

    r629 r630  
    29152915    fs_type    = hal_remote_l32( XPTR( child_cxy , &ctx_ptr->type ) );
    29162916
    2917     //////////////////////////// create <.>
     2917    //////////////////////////// create <.> dentry //////////////////////
    29182918    if( child_cxy == local_cxy )     
    29192919    {
    … …  
    29412941
    29422942#if(DEBUG_VFS_ADD_SPECIAL & 1)
     2943cycle = (uint32_t)hal_get_cycles();
    29432944if( DEBUG_VFS_ADD_SPECIAL < cycle )
    2944 printk("\n[%s] thread[%x,%x] created dentry <.> (%x,%x)\n",
    2945 __FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
     2945printk("\n[%s] thread[%x,%x] created dentry <.> (%x,%x) / cycle %d\n",
     2946__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr, cycle );
    29462947#endif
    29472948
    … …  
    29692970
    29702971#if(DEBUG_VFS_ADD_SPECIAL & 1)
     2972cycle = (uint32_t)hal_get_cycles();
    29712973if( DEBUG_VFS_ADD_SPECIAL < cycle )
    2972 printk("\n[%s] thread[%x,%x] linked dentry <.> to parent and child inodes\n",
    2973 __FUNCTION__, this->process->pid, this->trdid );
     2974printk("\n[%s] thread[%x,%x] linked dentry <.> to parent and child inodes / cycle %d\n",
     2975__FUNCTION__, this->process->pid, this->trdid, cycle );
    29742976#endif
    29752977
    29762978    // introduce <.> dentry into child directory mapper
    2977     if( child_cxy == local_cxy )
    2978     {
    2979         error = vfs_fs_add_dentry( child_ptr,
    2980                                    dentry_ptr );
    2981     }
    2982     else
    2983     {
    2984         rpc_vfs_fs_add_dentry_client( child_cxy,
    2985                                       child_ptr,
    2986                                       dentry_ptr,
    2987                                       &error );
    2988     }
    2989     if( error )
    2990     {
    2991         printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
    2992         __FUNCTION__ );
    2993         return -1;
    2994     }
     2979    // only if the target directory is not the root VFS
     2980    if( child_xp != parent_xp )
     2981    {
     2982        if( child_cxy == local_cxy )
     2983        {
     2984            error = vfs_fs_add_dentry( child_ptr,
     2985                                       dentry_ptr );
     2986        }
     2987        else
     2988        {
     2989            rpc_vfs_fs_add_dentry_client( child_cxy,
     2990                                          child_ptr,
     2991                                          dentry_ptr,
     2992                                          &error );
     2993        }
     2994        if( error )
     2995        {
     2996            printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
     2997            __FUNCTION__ );
     2998            return -1;
     2999        }
    29953000
    29963001#if(DEBUG_VFS_ADD_SPECIAL & 1)
     3002cycle = (uint32_t)hal_get_cycles();
    29973003if( DEBUG_VFS_ADD_SPECIAL < cycle )
    2998 printk("\n[%s] thread[%x,%x] registered dentry <.> in child mapper\n",
    2999 __FUNCTION__, this->process->pid, this->trdid );
    3000 #endif
    3001 
    3002     ///////////////////////////// create <..> dentry
     3004printk("\n[%s] thread[%x,%x] registered dentry <.> in child mapper / cycle %d\n",
     3005__FUNCTION__, this->process->pid, this->trdid, cycle );
     3006#endif
     3007
     3008    }
     3009
     3010    ///////////////////////////// create <..> dentry ///////////////////////
    30033011    if( child_cxy == local_cxy )     
    30043012    {
    … …  
    30263034
    30273035#if(DEBUG_VFS_ADD_SPECIAL & 1)
     3036cycle = (uint32_t)hal_get_cycles();
    30283037if( DEBUG_VFS_ADD_SPECIAL < cycle )
    3029 printk("\n[%s] thread[%x,%x] created dentry <..> (%x,%x)\n",
    3030 __FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr );
     3038printk("\n[%s] thread[%x,%x] created dentry <..> (%x,%x) / cycle %d\n",
     3039__FUNCTION__, this->process->pid, this->trdid, child_cxy, dentry_ptr, cycle );
    30313040#endif
    30323041
    … …  
    30533062
    30543063#if(DEBUG_VFS_ADD_SPECIAL & 1)
     3064cycle = (uint32_t)hal_get_cycles();
    30553065if( DEBUG_VFS_ADD_SPECIAL < cycle )
    3056 printk("\n[%s] thread[%x,%x] linked dentry <..> to parent and child inodes\n",
    3057 __FUNCTION__, this->process->pid, this->trdid );
     3066printk("\n[%s] thread[%x,%x] linked dentry <..> to parent and child inodes / cycle %d\n",
     3067__FUNCTION__, this->process->pid, this->trdid, cycle );
    30583068#endif
    30593069
    30603070    // introduce <..> dentry into child directory mapper
    3061     if( child_cxy == local_cxy )
    3062     {
    3063         error = vfs_fs_add_dentry( child_ptr,
    3064                                    dentry_ptr );
    3065     }
    3066     else
    3067     {
    3068         rpc_vfs_fs_add_dentry_client( child_cxy,
    3069                                       child_ptr,
    3070                                       dentry_ptr,
    3071                                       &error );
    3072     }
    3073     if( error )
    3074     {
    3075         printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
    3076         __FUNCTION__ );
    3077         return -1;
    3078     }
     3071    // only if the target directory is not the root VFS
     3072    if( child_xp != parent_xp )
     3073    {
     3074        if( child_cxy == local_cxy )
     3075        {
     3076            error = vfs_fs_add_dentry( child_ptr,
     3077                                       dentry_ptr );
     3078        }
     3079        else
     3080        {
     3081            rpc_vfs_fs_add_dentry_client( child_cxy,
     3082                                          child_ptr,
     3083                                          dentry_ptr,
     3084                                          &error );
     3085        }
     3086        if( error )
     3087        {
     3088            printk("\n[ERROR] in %s : cannot introduce dentry <..> in mapper %x\n",
     3089            __FUNCTION__ );
     3090            return -1;
     3091        }
    30793092
    30803093#if(DEBUG_VFS_ADD_SPECIAL & 1)
     3094cycle = (uint32_t)hal_get_cycles();
    30813095if( DEBUG_VFS_ADD_SPECIAL < cycle )
    3082 printk("\n[%s] thread[%x,%x] registered dentry <..> in child mapper\n",
    3083 __FUNCTION__, this->process->pid, this->trdid );
    3084 #endif
     3096printk("\n[%s] thread[%x,%x] registered dentry <..> in child mapper / cycle %d\n",
     3097__FUNCTION__, this->process->pid, this->trdid, cycle );
     3098#endif
     3099
     3100    }
    30853101
    30863102#if DEBUG_VFS_ADD_SPECIAL

  • trunk/kernel/kern/kernel_init.c

    r629 r630  
    11551155    thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
    11561156    core->scheduler.idle = thread;
    1157 
    1158 #if( DEBUG_KERNEL_INIT & 1 )
    1159 sched_display( core_lid );
    1160 #endif
    11611157
    11621158    // core[O] in cluster[0] creates the VFS root

  • trunk/kernel/kern/scheduler.c

    r629 r630  
    248248uint32_t cycle = (uint32_t)hal_get_cycles();
    249249if( DEBUG_SCHED_HANDLE_SIGNALS < cycle )
    250 printk("\n[%s] thread[%x,%x] on core[%x,%d] deleted (still %d threads) / cycle %d\n",
    251 __FUNCTION__, process->pid, thread->trdid, local_cxy, thread->core->lid, count, cycle );
     250printk("\n[%s] thread[%x,%x] on core[%x,%d] deleted / cycle %d\n",
     251__FUNCTION__, process->pid, thread->trdid, local_cxy, thread->core->lid, cycle );
    252252#endif
    253253
    … …  
    259259uint32_t false_nr    = thread->info.false_pgfault_nr;
    260260uint32_t false_cost  = (false_nr == 0)  ? 0 : (thread->info.false_pgfault_cost / false_nr);
    261 printk("***** page faults for thread[%x,%x]\n"
     261printk("\n***** page faults for thread[%x,%x]\n"
    262262       "  - %d local  : %d cycles\n"
    263263       "  - %d global : %d cycles\n"

  • trunk/kernel/mm/vmm.c

    r629 r630  
    19781978        ref_ptr = GET_PTR( process->ref_xp );
    19791979
    1980         // private vseg or (local == reference) => access only the local GPT
     1980        /////////////// private vseg or (local == reference)
     1981        /////////////// => access only the local GPT
    19811982        if( (vseg->type == VSEG_TYPE_STACK) ||
    19821983            (vseg->type == VSEG_TYPE_CODE)  ||
    … …  
    20282029        }   // end local GPT access
    20292030
    2030         // public vseg and (local != reference) => access ref GPT to update local GPT
     2031        /////////////////// public vseg and (local != reference)
     2032        /////////////////// => access ref GPT to update local GPT
    20312033        else                               
    20322034        {
    … …  
    20352037
    20362038            // get current PPN and attributes from reference GPT
     2039            // without locking the PTE (in case of false page fault)
    20372040            hal_gpt_get_pte( ref_gpt_xp,
    20382041                             vpn,
Note: See TracChangeset for help on using the changeset viewer.