Changeset 580

Timestamp:

Oct 8, 2018, 11:31:42 AM (6 years ago)

Author:

alain

Message:

1) Register the kernel process in the cluster manager local list.
2) Introduce a new service in idbg : display the set of busylocks taken by a given thread.

Location:

trunk

Files:

• kernel/kern/cluster.c (modified) (1 diff)
• kernel/kern/kernel_init.c (modified) (18 diffs)
• kernel/kern/process.c (modified) (9 diffs)
• kernel/kern/thread.c (modified) (7 diffs)
• kernel/kern/thread.h (modified) (1 diff)
• kernel/kernel_config.h (modified) (2 diffs)
• kernel/libk/busylock.c (modified) (3 diffs)
• kernel/libk/remote_busylock.c (modified) (3 diffs)
• kernel/mm/vmm.c (modified) (1 diff)
• kernel/syscalls/shared_include/shared_almos.h (modified) (1 diff)
• kernel/syscalls/sys_display.c (modified) (12 diffs)
• libs/libalmosmkh/almosmkh.c (modified) (12 diffs)
• libs/libalmosmkh/almosmkh.h (modified) (1 diff)
• libs/mini-libc/stdio.c (modified) (1 diff)
• params-hard.mk (modified) (1 diff)
• user/idbg/idbg.c (modified) (1 diff)
• user/pgcd/pgcd.c (modified) (2 diffs)

trunk/kernel/kern/cluster.c

@@ -200 +200 @@
     cluster->pmgr.pref_nr = 0;
     cluster->pmgr.pref_tbl[0] = XPTR( local_cxy , &process_zero );
-    for( lpid = 1 ; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ )
+    for( lpid = 0 ; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ )
     {
         cluster->pmgr.pref_tbl[lpid] = XPTR_NULL;

trunk/kernel/kern/kernel_init.c

@@ -375 +375 @@
             // check channels
             if( channels != 1 )
-            printk("\n[PANIC] in %s : MMC device must be single channel\n", __FUNCTION__ );
+            {
+                printk("\n[PANIC] in %s : MMC device must be single channel\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
 
             // create chdev in local cluster
@@ -386 +390 @@
             // check memory
             if( chdev_ptr == NULL )
-            printk("\n[PANIC] in %s : cannot create MMC chdev\n", __FUNCTION__ );
+            {
+                printk("\n[PANIC] in %s : cannot create MMC chdev\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
             
             // make MMC specific initialisation
@@ -427 +435 @@
                 // check memory
                 if( chdev_ptr == NULL )
-                printk("\n[PANIC] in %s : cannot create DMA chdev\n", __FUNCTION__ );
+                {
+                    printk("\n[PANIC] in %s : cannot create DMA chdev\n",
+                    __FUNCTION__ );
+                    hal_core_sleep();
+                }
             
                 // make DMA specific initialisation
@@ -503 +515 @@
         // check PIC device initialized
         if( chdev_dir.pic == XPTR_NULL )
-        printk("\n[PANIC] in %s : PIC device must be initialized first\n", __FUNCTION__ );
+        {
+            printk("\n[PANIC] in %s : PIC device must be initialized first\n",
+            __FUNCTION__ );
+            hal_core_sleep();
+        }
 
         // check external device functionnal type
         if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) &&
             (func != DEV_FUNC_NIC) && (func != DEV_FUNC_FBF) )
-        printk("\n[PANIC] in %s : undefined peripheral type\n", __FUNCTION__ );
+        {
+            printk("\n[PANIC] in %s : undefined peripheral type\n",
+            __FUNCTION__ );
+            hal_core_sleep();
+        }
 
         // loops on channels
@@ -548 +568 @@
 
                     if( chdev == NULL )
-                    printk("\n[PANIC] in %s : cannot allocate chdev for external device\n",
-                    __FUNCTION__ );
+                    {
+                        printk("\n[PANIC] in %s : cannot allocate chdev\n",
+                        __FUNCTION__ );
+                        hal_core_sleep();
+                    }
 
                     // make device type specific initialisation
@@ -646 +669 @@
     // check PIC existence
     if( found == false )
-    printk("\n[PANIC] in %s : PIC device not found\n", __FUNCTION__ );
+    {
+        printk("\n[PANIC] in %s : PIC device not found\n",
+        __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // allocate and initialize the PIC chdev in cluster 0
@@ -657 +684 @@
     // check memory
     if( chdev == NULL )
-    printk("\n[PANIC] in %s : no memory for PIC chdev\n", __FUNCTION__ );
+    {
+        printk("\n[PANIC] in %s : no memory for PIC chdev\n",
+        __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // make PIC device type specific initialisation
@@ -723 +754 @@
             else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel];
             else if( func == DEV_FUNC_IOB )                 ptr = &iopic_input.iob;
-            else     printk("\n[PANIC] in %s : illegal source device for IOPIC input" );
+            else
+            {
+                printk("\n[PANIC] in %s : illegal source device for IOPIC input\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
 
             // set one entry in all "iopic_input" structures
@@ -814 +850 @@
                 if     ( func == DEV_FUNC_MMC ) lapic_input.mmc = id;
                 else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id;
-                else     printk("\n[PANIC] in %s : illegal source device for LAPIC input" );
+                else
+                {
+                    printk("\n[PANIC] in %s : illegal source device for LAPIC input\n",
+                    __FUNCTION__ );
+                    hal_core_sleep();
+                }
             }
         }
@@ -939 +980 @@
     // all cores check identifiers
     if( error )
-    printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
-    __FUNCTION__, core_lid, core_cxy, core_lid );
+    {
+        printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
+        __FUNCTION__, core_lid, core_cxy, core_lid );
+        hal_core_sleep();
+    }
 
     // CP0 initializes cluster manager complex structures
@@ -948 +992 @@
 
         if( error )
-        printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
-        __FUNCTION__, local_cxy );
+        {
+             printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
+             __FUNCTION__, local_cxy );
+             hal_core_sleep();
+        }
     }
 
@@ -1068 +1115 @@
 
             if( fatfs_ctx == NULL )
-            printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
-            __FUNCTION__ );
+            {
+                printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
 
             // 2. access boot device to initialize FATFS context
@@ -1099 +1149 @@
                                       &vfs_root_inode_xp );                // return
             if( error )
-            printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
-            __FUNCTION__ );
+            {
+                printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
 
             // 6. update the FATFS entry in vfs_context[] array
@@ -1109 +1162 @@
 
             if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
-            printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
-            __FUNCTION__ );
+            {
+                printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
+                __FUNCTION__ );
+                hal_core_sleep();
+            }
+                
         }
         else
@@ -1116 +1173 @@
             printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n",
             __FUNCTION__ );
+            hal_core_sleep();
         }
 
@@ -1153 +1211 @@
             // check memory
             if( local_fatfs_ctx == NULL )
-            printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
-            __FUNCTION__ , local_cxy );
+            {
+                printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
+                __FUNCTION__ , local_cxy );
+                hal_core_sleep();
+            }
 
             // 2. get local pointer on VFS context for FATFS
@@ -1174 +1235 @@
 
             if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
-            printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
-            __FUNCTION__ , local_cxy );
+            {
+                printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
+                __FUNCTION__ , local_cxy );
+                hal_core_sleep();
+            }
         }
 
@@ -1210 +1274 @@
 
         if( devfs_ctx == NULL )
-        printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
-        __FUNCTION__ , local_cxy );
+        {
+            printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
+            __FUNCTION__ , local_cxy );
+            hal_core_sleep();
+        }
 
         // 2. initialize the DEVFS entry in the vfs_context[] array 

trunk/kernel/kern/process.c

@@ -112 +112 @@
     cxy_t       chdev_cxy;
     pid_t       parent_pid;
+    lpid_t      process_lpid;
+    lpid_t      parent_lpid;
 
     // get parent process cluster and local pointer
@@ -119 +121 @@
     // get parent_pid
     parent_pid = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
+
+    // get process and parent lpid
+    process_lpid = LPID_FROM_PID( pid );
+    parent_lpid  = LPID_FROM_PID( parent_pid ); 
 
 #if DEBUG_PROCESS_REFERENCE_INIT
@@ -150 +156 @@
 
     // define the stdin/stdout/stderr pseudo files <=> select a TXT terminal.
-    if( (pid == 1) || (parent_pid == 1)) // INIT or KSH process
+    if( (process_lpid == 1) ||     // INIT process
+        (parent_lpid  == 1) )      // KSH  process
     {
         // allocate a TXT channel
-        if( pid == 1 )  txt_id = 0;                     // INIT
-        else            txt_id = process_txt_alloc();   // KSH
+        if( process_lpid == 1 )  txt_id = 0;                     // INIT
+        else                     txt_id = process_txt_alloc();   // KSH
 
         // attach process to TXT
@@ -1487 +1494 @@
 void process_zero_create( process_t * process )
 {
+    error_t error;
+    pid_t   pid;
 
 #if DEBUG_PROCESS_ZERO_CREATE
@@ -1495 +1504 @@
 #endif
 
+    // get PID from local cluster manager for this kernel process
+    error = cluster_pid_alloc( process , &pid );
+
+    if( error || (LPID_FROM_PID( pid ) != 0) )
+    {
+        printk("\n[PANIC] in %s : cannot get valid PID in cluster %x / PID = %x\n",
+        __FUNCTION__ , local_cxy, pid );
+        hal_core_sleep();
+    }
+
     // initialize PID, REF_XP, PARENT_XP, and STATE
-    process->pid        = 0;
+    // the kernel process_zero is its own parent_process,
+    // reference_process, and owner_process, and cannot be killed...
+    process->pid        = pid;
     process->ref_xp     = XPTR( local_cxy , process );
     process->owner_xp   = XPTR( local_cxy , process );
-    process->parent_xp  = XPTR_NULL;
+    process->parent_xp  = XPTR( local_cxy , process );
     process->term_state = 0;
 
@@ -1518 +1539 @@
                            LOCK_PROCESS_CHILDREN );
 
+    // register kernel process in cluster manager local_list
+    cluster_process_local_link( process );
+    
         hal_fence();
 
@@ -1686 +1710 @@
     pid_t         pid;
     pid_t         ppid;
+    lpid_t        lpid;
     uint32_t      state;
     uint32_t      th_nr;
@@ -1707 +1732 @@
     process_cxy = GET_CXY( process_xp );
 
-    // get PID and state
+    // get process PID, LPID, and state
     pid   = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
+    lpid  = LPID_FROM_PID( pid );
     state = hal_remote_l32( XPTR( process_cxy , &process_ptr->term_state ) );
 
-    // get PPID
+    // get process PPID
     parent_xp  = hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) );
     parent_cxy = GET_CXY( parent_xp );
@@ -1725 +1751 @@
     owner_ptr = GET_PTR( owner_xp );
 
-    // get extended pointer on TXT_RX file descriptor attached to process
-    txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
-
-    assert( (txt_file_xp != XPTR_NULL) ,
-    "process must be attached to one TXT terminal\n" ); 
-
-    // get TXT_RX chdev pointers
-    txt_chdev_xp  = chdev_from_file( txt_file_xp );
-    txt_chdev_cxy = GET_CXY( txt_chdev_xp );
-    txt_chdev_ptr = GET_PTR( txt_chdev_xp );
-
-    // get TXT_RX name and ownership
-    hal_remote_strcpy( XPTR( local_cxy , txt_name ) ,
-                       XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) );
+    // get process TXT name and .elf name
+    if( lpid )                                   // user process
+    {
+
+        // get extended pointer on file descriptor associated to TXT_RX 
+        txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
+
+        assert( (txt_file_xp != XPTR_NULL) ,
+        "process must be attached to one TXT terminal\n" ); 
+
+        // get TXT_RX chdev pointers
+        txt_chdev_xp  = chdev_from_file( txt_file_xp );
+        txt_chdev_cxy = GET_CXY( txt_chdev_xp );
+        txt_chdev_ptr = GET_PTR( txt_chdev_xp );
+
+        // get TXT_RX name and ownership
+        hal_remote_strcpy( XPTR( local_cxy , txt_name ) ,
+                           XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) );
     
-    txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy, 
-                                                 &txt_chdev_ptr->ext.txt.owner_xp ) );
-    
-    // get process .elf name
-    elf_file_xp   = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
-    elf_file_cxy  = GET_CXY( elf_file_xp );
-    elf_file_ptr  = (vfs_file_t *)GET_PTR( elf_file_xp );
-    elf_inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( elf_file_cxy , &elf_file_ptr->inode ) );
-    vfs_inode_get_name( XPTR( elf_file_cxy , elf_inode_ptr ) , elf_name );
+        txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy, 
+                                                     &txt_chdev_ptr->ext.txt.owner_xp ) );
+
+        // get process .elf name
+        elf_file_xp   = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
+        elf_file_cxy  = GET_CXY( elf_file_xp );
+        elf_file_ptr  = GET_PTR( elf_file_xp );
+        elf_inode_ptr = hal_remote_lpt( XPTR( elf_file_cxy , &elf_file_ptr->inode ) );
+        vfs_inode_get_name( XPTR( elf_file_cxy , elf_inode_ptr ) , elf_name );
+    }
+    else                                         // kernel process_zero
+    {
+        // TXT name and .elf name are not registered in kernel process_zero
+        strcpy( txt_name , "txt0_rx" );
+        txt_owner_xp = process_xp; 
+        strcpy( elf_name , "kernel.elf" );
+    }
 
     // display process info

trunk/kernel/kern/thread.c

@@ -1216 +1216 @@
     xptr_t        lock_xp;             // extended pointer on lock protecting  this list
 
+#if DEBUG_THREAD_GET_XPTR
+uint32_t cycle  = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk("\n[DBG] %s : thread %x in process %x enters / pid %x / trdid %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, trdid, cycle );
+#endif
+
     // get target cluster identifier and local thread identifier
     target_cxy         = CXY_FROM_TRDID( trdid );
@@ -1235 +1243 @@
     remote_queuelock_acquire( lock_xp );
 
+#if( DEBUG_THREAD_GET_XPTR & 1 )
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk("\n[DBG]  %s : scan processes in cluster %x :\n", __FUNCTION__, target_cxy );
+#endif
+
     // scan the list of local processes in target cluster
     xptr_t  iter;
@@ -1243 +1256 @@
         target_process_ptr = GET_PTR( target_process_xp );
         target_process_pid = hal_remote_l32( XPTR( target_cxy , &target_process_ptr->pid ) );
+
+#if( DEBUG_THREAD_GET_XPTR & 1 )
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk(" - process %x\n", target_process_pid );
+#endif
+
         if( target_process_pid == pid )
         {
@@ -1254 +1273 @@
 
     // check PID found
-    if( found == false ) return XPTR_NULL;
+    if( found == false ) 
+    {
+
+#if( DEBUG_THREAD_GET_XPTR & 1 )
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk("\n[DBG] %s : pid %x not found in cluster %x\n",
+__FUNCTION__, pid, target_cxy );
+#endif
+        return XPTR_NULL;
+    }
 
     // get target thread local pointer
@@ -1260 +1288 @@
     target_thread_ptr = (thread_t *)hal_remote_lpt( xp );
 
-    if( target_thread_ptr == NULL )  return XPTR_NULL;
+    if( target_thread_ptr == NULL )
+    {
+
+#if( DEBUG_THREAD_GET_XPTR & 1 )
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk("\n[DBG] %s : thread %x not registered in process %x in cluster %x\n",
+__FUNCTION__, trdid, pid, target_cxy );
+#endif
+        return XPTR_NULL;
+    }
+
+#if DEBUG_THREAD_GET_XPTR
+cycle  = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_GET_XPTR < cycle )
+printk("\n[DBG] %s : thread %x in process %x exit / pid %x / trdid %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, trdid, cycle );
+#endif
 
     return XPTR( target_cxy , target_thread_ptr );
@@ -1287 +1331 @@
         // display error message on TXT0
         nolock_printk("\n[PANIC] in %s / thread %x in process %x [%x] cannot yield : "
-        "%d busylock(s) / cycle %d\n",
+        "hold %d busylock(s) / cycle %d\n",
         func_str, thread->trdid, thread->process->pid, thread,
         thread->busylocks, (uint32_t)hal_get_cycles() );
 
 #if DEBUG_BUSYLOCK
-if( XPTR( local_cxy , thread ) == DEBUG_BUSYLOCK_THREAD_XP )
-{
-    // get root of list of taken busylocks
-    xptr_t    root_xp  = XPTR( local_cxy , &thread->busylocks_root );
-    xptr_t    iter_xp;
-
-    // scan list of busylocks
-    XLIST_FOREACH( root_xp , iter_xp )
-    {
-        xptr_t       lock_xp   = XLIST_ELEMENT( iter_xp , busylock_t , xlist );
-        cxy_t        lock_cxy  = GET_CXY( lock_xp );
-        busylock_t * lock_ptr  = GET_PTR( lock_xp );
-        uint32_t     lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) );
-        nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy );
-    }
+
+// get root of list of taken busylocks
+xptr_t    root_xp  = XPTR( local_cxy , &thread->busylocks_root );
+xptr_t    iter_xp;
+
+// scan list of busylocks
+XLIST_FOREACH( root_xp , iter_xp )
+{
+    xptr_t       lock_xp   = XLIST_ELEMENT( iter_xp , busylock_t , xlist );
+    cxy_t        lock_cxy  = GET_CXY( lock_xp );
+    busylock_t * lock_ptr  = GET_PTR( lock_xp );
+    uint32_t     lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) );
+    nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy );
 }
+
 #endif
 
@@ -1318 +1361 @@
 }  // end thread_assert_can yield()
 
-#if DEBUG_BUSYLOCK
-
-////////////////////////////////////////////////////
-void thread_display_busylocks( uint32_t   lock_type,
-                               bool_t     is_acquire )
-{
-    xptr_t    iter_xp;
-
-    // get cluster and local pointer of target thread
-    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
-    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
-
-    // get extended pointer on root of busylocks
-    xptr_t    root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root );
-
-   // get pointers on TXT0 chdev
-    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
-    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
-    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
-
-    // get extended pointer on remote TXT0 lock
-    xptr_t  txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
-
-    // get TXT0 lock 
-    remote_busylock_acquire( txt0_lock_xp );
-
-    if( is_acquire )
-    {
-        nolock_printk("\n### thread [%x,%x] ACQUIRE lock %s / root %x / locks :\n",
-        thread_cxy, thread_ptr, lock_type_str[lock_type], GET_PTR(root_xp) );
+//////////////////////////////////////////////////
+void thread_display_busylocks( xptr_t  thread_xp )
+{
+    if( DEBUG_BUSYLOCK )
+    {
+        xptr_t    iter_xp;
+
+        // get cluster and local pointer of target thread
+        cxy_t      thread_cxy = GET_CXY( thread_xp );
+        thread_t * thread_ptr = GET_PTR( thread_xp );
+
+        // get target thread TRDID and busylocks
+        trdid_t  trdid = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->trdid ));
+        uint32_t locks = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->busylocks ));
+
+        // get target thread process and PID;
+        process_t * process = hal_remote_lpt(XPTR( thread_cxy , &thread_ptr->process ));
+        pid_t       pid     = hal_remote_l32(XPTR( thread_cxy , &process->pid ));
+
+        // get extended pointer on root of busylocks
+        xptr_t    root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root );
+
+        // get pointers on TXT0 chdev
+        xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+        cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+        chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+        // get extended pointer on remote TXT0 lock
+        xptr_t  txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+        // get TXT0 lock 
+        remote_busylock_acquire( txt0_lock_xp );
+
+        // display header 
+        nolock_printk("\n***** thread %x in process %x : %d busylocks at cycle %d\n",
+        trdid, pid, locks, (uint32_t)hal_get_cycles() );
+
+        // scan the xlist of busylocks when required
+        if( locks )
+        {
+            XLIST_FOREACH( root_xp , iter_xp )
+            {
+                xptr_t       lock_xp   = XLIST_ELEMENT( iter_xp , busylock_t , xlist );
+                cxy_t        lock_cxy  = GET_CXY( lock_xp );
+                busylock_t * lock_ptr  = GET_PTR( lock_xp );
+                uint32_t     lock_type = hal_remote_l32(XPTR( lock_cxy , &lock_ptr->type ));
+                nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy );
+            }
+        }
+
+        // release TXT0 lock
+        remote_busylock_release( txt0_lock_xp );
     }
     else
     {
-        nolock_printk("\n### thread [%x,%x] RELEASE lock %s / root %x / locks :\n",
-        thread_cxy, thread_ptr, lock_type_str[lock_type], GET_PTR(root_xp) );
-    }
-
-    int i;
-
-    XLIST_FOREACH( root_xp , iter_xp )
-    {
-        xptr_t       ilock_xp   = XLIST_ELEMENT( iter_xp , busylock_t , xlist );
-        cxy_t        ilock_cxy  = GET_CXY( ilock_xp );
-        busylock_t * ilock_ptr  = GET_PTR( ilock_xp );
-        uint32_t     ilock_type = hal_remote_l32( XPTR( ilock_cxy , &ilock_ptr->type ) );
-        nolock_printk(" - %s in cluster %x\n", lock_type_str[ilock_type] , ilock_cxy );
-    }
-
-    // release TXT0 lock
-    remote_busylock_release( txt0_lock_xp );
-}
-#endif
+        // display a warning
+        printk("\n[WARNING] set the DEBUG_BUSYLOCK parmeter in kernel_config.h"
+        " to use the %s function\n", __FUNCTION__ );
+    }
+}  // end thread_display_busylock()

trunk/kernel/kern/thread.h

@@ -467 +467 @@
 
 /***************************************************************************************
- * This debug function display the list of busylocks currently owned by a thread
- * identified by the DEBUG_BUSYLOCK_THREAD_XP parameter.
- * It is called each time the target thread acquire or release a busylock
- * (local or remote). It is never called when DEBUG_BUSYLOCK_THEAD_CP == 0.
- ***************************************************************************************
- * @ lock_type  : type of acquired / released busylock.
- * @ is_acquire : change is an acquire when true / change is a release when false.
- **************************************************************************************/
-void thread_display_busylocks( uint32_t lock_type,
-                               bool_t   is_acquire );
+ * This debug function display the list of busylocks (local or remote) currently owned
+ * by a thread identified by the <thread_xp> argument. 
+ * WARNING : it can be called by the idbg tool, but the DEBUG_BUSYLOCK parameter
+ * must be set in the kernel_config.h file.
+ ***************************************************************************************
+ * @ thread_xp  : extended pointer on target thread.
+ **************************************************************************************/
+void thread_display_busylocks( xptr_t  thread_xp );
 
 

trunk/kernel/kernel_config.h

@@ -175 +175 @@
 #define DEBUG_THREAD_DELETE            0
 #define DEBUG_THREAD_DESTROY           0
+#define DEBUG_THREAD_GET_XPTR          1
 #define DEBUG_THREAD_IDLE              0
 #define DEBUG_THREAD_INIT              0
@@ -336 +337 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 
-#define CONFIG_THREADS_MAX_PER_CLUSTER      16      // max threads per cluster & process
+#define CONFIG_THREADS_MAX_PER_CLUSTER      16      // max threads per cluster per process
 #define CONFIG_THREAD_DESC_SIZE             0x4000  // thread desc size (with kernel stack)
 #define CONFIG_THREAD_DESC_ORDER            2       // ln( number of 4K pages )

trunk/kernel/libk/busylock.c

@@ -77 +77 @@
 #if DEBUG_BUSYLOCK
 if( (lock->type != LOCK_CHDEV_TXT0) && 
-    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&
     ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) )
 {
@@ -84 +83 @@
     // update thread list of busylocks
     xlist_add_last( root_xp , XPTR( local_cxy , &lock->xlist ) );
+}
+#endif
 
-    // display list of taken locks for the selected thread
-    thread_display_busylocks( lock->type , true );
+#if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP )
+if( (lock->type != LOCK_CHDEV_TXT0) && 
+    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
+{
+    // get cluster and local pointer of target thread
+    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
+    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
+
+    // display message on kernel TXT0
+    printk("\n### thread [%x,%x] ACQUIRE lock %s\n",
+    thread_cxy, thread_ptr, lock_type_str[lock->type] );
 }
 #endif
@@ -111 +121 @@
 #if DEBUG_BUSYLOCK
 if( (lock->type != LOCK_CHDEV_TXT0) && 
-    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&
     ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) )
 {
     // remove lock from thread list of busylocks
     xlist_unlink( XPTR( local_cxy , &lock->xlist ) );
+}
+#endif
 
-    // display list of taken locks for the selected thread
-    thread_display_busylocks( lock->type , false );
+#if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP )
+if( (lock->type != LOCK_CHDEV_TXT0) && 
+    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
+{
+    // get cluster and local pointer of target thread
+    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
+    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
+
+    // display message on kernel TXT0
+    printk("\n### thread [%x,%x] RELEASE lock %s\n",
+    thread_cxy, thread_ptr, lock_type_str[lock->type] );
 }
 #endif

trunk/kernel/libk/remote_busylock.c

@@ -88 +88 @@
 uint32_t type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) );
 if( (type != LOCK_CHDEV_TXT0) &&
-    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&
     ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) )
 {
@@ -95 +94 @@
     // update thread list of busyslocks
     xlist_add_last( root_xp , XPTR( lock_cxy  , &lock_ptr->xlist ) );
+}
+#endif
 
-    // display busylocks for the selected thread (acquire)
-    thread_display_busylocks( type , true ); 
+#if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP )
+if( (type != LOCK_CHDEV_TXT0) && 
+    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
+{
+    // get cluster and local pointer of target thread
+    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
+    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
+
+    // display message on kernel TXT0
+    printk("\n### thread [%x,%x] ACQUIRE lock %s\n",
+    thread_cxy, thread_ptr, lock_type_str[type] );
 }
 #endif
@@ -132 +142 @@
     // remove lock from thread list of busyslocks
     xlist_unlink( XPTR( lock_cxy  , &lock_ptr->xlist ) );
+}
+#endif
 
-    // display busylocks for the selected thread (release)
-    thread_display_busylocks( type , false );   
+#if (DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP )
+if( (type != LOCK_CHDEV_TXT0) && 
+    (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) )
+{
+    // get cluster and local pointer of target thread
+    cxy_t      thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP );
+    thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP );
+
+    // display message on kernel TXT0
+    printk("\n### thread [%x,%x] RELEASE lock %s\n",
+    thread_cxy, thread_ptr, lock_type_str[type] );
 }
 #endif

trunk/kernel/mm/vmm.c

@@ -78 +78 @@
     vmm->vsegs_nr = 0;
         xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) );
-        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ),LOCK_VMM_VSL );
+        remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) , LOCK_VMM_VSL );
 
 assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE) 

trunk/kernel/syscalls/shared_include/shared_almos.h

@@ -51 +51 @@
     DISPLAY_TXT_PROCESSES     = 6,
     DISPLAY_DQDT              = 7,
+    DISPLAY_BUSYLOCKS         = 8,
 }
 display_type_t;

trunk/kernel/syscalls/sys_display.c

@@ -48 +48 @@
     else if( type == DISPLAY_CHDEV             ) return "CHDEV"; 
     else if( type == DISPLAY_TXT_PROCESSES     ) return "TXT_PROCESSES"; 
+    else if( type == DISPLAY_DQDT              ) return "DQDT";
+    else if( type == DISPLAY_BUSYLOCKS         ) return "BUSYLOCKS"; 
 }
 #endif
@@ -87 +89 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : string buffer %x unmapped / thread %x / process %x\n",
-__FUNCTION__ , (intptr_t)arg0 , this->trdid , process->pid );
+printk("\n[ERROR] in %s for STRING : string buffer %x unmapped\n",
+__FUNCTION__ , (intptr_t)arg0 );
 #endif
             this->errno = EINVAL;
@@ -101 +103 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : string length %d too large / thread %x / process %x\n",
-__FUNCTION__ , length , this->trdid , process->pid );
+printk("\n[ERROR] in %s for STRING : string length %d too large\n",
+__FUNCTION__ , length );
 #endif
             this->errno = EINVAL;
@@ -125 +127 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",
-__FUNCTION__ , cxy , this->trdid , process->pid );
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
 #endif
             this->errno = EINVAL;
@@ -139 +141 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : process %x in cluster %x not found / thread %x / process %x\n",
-__FUNCTION__ , pid , cxy , this->trdid , process->pid );
+printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n",
+__FUNCTION__ , pid , cxy );
 #endif
             this->errno = EINVAL;
@@ -170 +172 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",
-__FUNCTION__ , cxy , this->trdid , process->pid );
+printk("\n[ERROR] in %s for SCHED : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
 #endif
             this->errno = EINVAL;
@@ -182 +184 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal lid argument %x / thread %x / process %x\n",
-__FUNCTION__ , lid , this->trdid , process->pid );
+printk("\n[ERROR] in %s for SCHED : illegal lid argument %x\n",
+__FUNCTION__ , lid );
 #endif
             this->errno = EINVAL;
@@ -208 +210 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",
-__FUNCTION__ , cxy , this->trdid , process->pid );
+printk("\n[ERROR] in %s for CLUSTER_PROCESSES : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
 #endif
             this->errno = EINVAL;
@@ -216 +218 @@
 
         cluster_processes_display( cxy );
+    }
+    //////////////////////////////
+    else if( type == DISPLAY_VFS )
+    {
+        vfs_display( process->vfs_root_xp );
+    }
+    ////////////////////////////////
+    else if( type == DISPLAY_CHDEV )
+    {
+        chdev_dir_display();
     }
     ////////////////////////////////////////
@@ -227 +239 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal txt_id argument %d / thread %x / process %x\n",
-__FUNCTION__ , txt_id , this->trdid , process->pid );
+printk("\n[ERROR] in %s for TXT_PROCESSES : illegal txt_id argument %d\n",
+__FUNCTION__ , txt_id );
 #endif
             this->errno = EINVAL;
@@ -236 +248 @@
         process_txt_display( txt_id );
     }
-    //////////////////////////////
-    else if( type == DISPLAY_VFS )
-    {
-        vfs_display( process->vfs_root_xp );
-    }
-    ////////////////////////////////
-    else if( type == DISPLAY_CHDEV )
-    {
-        chdev_dir_display();
-    }
-    ////////////////////////////////
+    ///////////////////////////////
     else if( type == DISPLAY_DQDT )
     {
         dqdt_display();
+    }
+    ////////////////////////////////////
+    else if( type == DISPLAY_BUSYLOCKS )
+    {
+        pid_t   pid   = (cxy_t)arg0;
+        trdid_t trdid = (trdid_t)arg1;
+
+        // get extended pointer on target thread
+        xptr_t thread_xp = thread_get_xptr( pid , trdid );
+
+        if( thread_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for BUSYLOCKS : thread %x in process %x not found\n",
+__FUNCTION__ , trdid , pid );
+#endif
+            this->errno = EINVAL;
+            return -1;
+        }
+
+        thread_display_busylocks( thread_xp );
     }
     ////
@@ -256 +280 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : undefined display type %x / thread %x / process %x\n",
-        __FUNCTION__ , type , this->trdid , process->pid );
+printk("\n[ERROR] in %s : undefined display type %d\n",
+        __FUNCTION__ , type );
 #endif
         this->errno = EINVAL;

trunk/libs/libalmosmkh/almosmkh.c

@@ -88 +88 @@
 }
 
-////////////
-int getint( void )
+///////////////////////////////
+unsigned int get_uint32( void )
 {
     unsigned int  i;
-    int           val;    // ASCII character value
+    int           c;    // ASCII character value
 
     unsigned char buf[32];
+
     unsigned int  save          = 0;
-    unsigned int  dec           = 0;
+    unsigned int  value         = 0;
     unsigned int  done          = 0;
     unsigned int  overflow      = 0;
     unsigned int  length        = 0;
- 
+
     // get characters
     while (done == 0) 
     {
         // read one character
-        val = getchar();
-
-        // analyse character
-        if ((val > 0x2F) && (val < 0x3A))         // decimal character 
-        {
-            buf[length] = (unsigned char)val;
+        c = getchar();
+
+        // analyse this character
+        if ( ((c > 0x2F) && (c < 0x3A)) ||                      // 0 to 9
+             ((c > 0x40) && (c < 0x47)) ||                      // A to F
+             ((c > 0x60) && (c < 0x67)) ||                      // a to f
+             (((c == 0x58) || (c == 0x78)) && (length == 1)) )  // X or x
+        {
+            putchar( c );                       // echo
+            if ( c > 0x60 )  c = c - 0x20;      // to upper case
+            buf[length] = (unsigned char)c;
             length++;                      
-            putchar( val );                       // echo
-        }
-        else if (val == 0x0A)                     // LF character 
+        }
+        else if (c == 0x0A)                                     // LF character 
         {
             done = 1;
         }
-        else if ( (val == 0x7F) ||                // DEL character
-                  (val == 0x08) )                 // BS  character 
+        else if ( (c == 0x7F) ||                                // DEL character
+                  (c == 0x08) )                                 // BS  character 
         {
             if ( length > 0 ) 
             {
                 length--;          
-                printf("\b \b");                  // BS /  / BS 
+                printf("\b \b");                // BS /  / BS 
             }
         }
-        else if ( val == 0 )                      // EOF
+        else if ( c == 0 )                                      // EOF character
         {
             return -1;
@@ -140 +145 @@
     }  // end while characters
 
-    // string to int conversion with overflow detection 
+    // string to int conversion with overflow detection
     if ( overflow == 0 )
     {
-        for (i = 0; (i < length) && (overflow == 0) ; i++) 
-        {
-            dec = dec * 10 + (buf[i] - 0x30);
-            if (dec < save)  overflow = 1; 
-            save = dec;
+        // test (decimal / hexa)
+        if( (buf[0] == 0x30) && (buf[1] == 0x58) )     // hexadecimal input
+        {
+            for (i = 2; (i < length) && (overflow == 0) ; i++)
+            {
+                if( buf[i] < 0x40 ) value = (value << 4) + (buf[i] - 0x30);
+                else                value = (value << 4) + (buf[i] - 0x37);
+                if (value < save) overflow = 1; 
+                save = value;
+            }
+        }
+        else                                           // decimal input
+        {
+            for (i = 0; (i < length) && (overflow == 0) ; i++) 
+            {
+                value = (value * 10) + (buf[i] - 0x30);
+                if (value < save) overflow = 1; 
+                save = value;
+            }
         }
     } 
@@ -155 +174 @@
     {
         // return value
-        return dec;
+        return value;
     }
     else
@@ -171 +190 @@
         return 0;
     }
-}  // end getint()
+}  // end get_uint32()
 
 
@@ -184 +203 @@
 }
 
-///////////////////////////////////
+/////////////////////////////////////////////////////
 int display_vmm( unsigned int cxy, unsigned int pid )
 {
     return hal_user_syscall( SYS_DISPLAY,
                              DISPLAY_VMM,
-                             (reg_t)pid,
-                             (reg_t)cxy, 0 );
+                             (reg_t)cxy,
+                             (reg_t)pid, 0 );
 } 
 
@@ -211 +230 @@
 } 
 
-///////////////////
+////////////////////////////////////////
+int display_busylocks( unsigned int pid,
+                       unsigned int trdid )
+{
+    return hal_user_syscall( SYS_DISPLAY,
+                             DISPLAY_BUSYLOCKS,
+                             (reg_t)pid,
+                             (reg_t)trdid, 0 );
+} 
+
+/////////////////////////
 int display_chdev( void )
 {
@@ -258 +287 @@
    unsigned int  lid;
    unsigned int  txt;
+   unsigned int  pid;
+   unsigned int  trdid;
    unsigned int  active;
 
@@ -270 +301 @@
                    "p : display on TXT0 process descriptors in cluster[cxy]\n"
                    "s : display on TXT0 scheduler state for core[cxy,lid]\n"
-                   "v : display on TXT0 VMM for calling process in cluster [cxy]\n"
+                   "v : display on TXT0 VMM state for process[cxy,pid]\n"
                    "t : display on TXT0 process decriptors attached to TXT[tid]\n"
+                   "b : display on TXT0 busylocks taken by thread[pid,trdid]\n"
                    "y : activate/desactivate trace for core[cxy,lid]\n"
                    "x : force calling process to exit\n"
@@ -280 +312 @@
         {
             printf("p / cxy = ");
-            cxy = getint();
+            cxy = get_uint32();
             display_cluster_processes( cxy );
         }
@@ -286 +318 @@
         {
             printf("s / cxy = ");
-            cxy = getint();
+            cxy = get_uint32();
             printf(" / lid = ");
-            lid = getint();
+            lid = get_uint32();
             display_sched( cxy , lid );
         }
@@ -294 +326 @@
         {
             printf("v / cxy = ");
-            cxy = getint();
-            display_vmm( cxy , (unsigned int)getpid() );
+            cxy = get_uint32();
+            printf(" / pid = ");
+            pid = get_uint32();
+            display_vmm( cxy , pid );
         }
         else if( cmd == 't' )
         {
             printf("t / txt_id = ");
-            txt = getint();
+            txt = get_uint32();
             display_txt_processes( txt );
         }
@@ -306 +340 @@
         {
             printf("y / active = ");
-            active = getint();
+            active = get_uint32();
             printf(" / cxy = ");
-            cxy    = getint();
+            cxy    = get_uint32();
             printf(" / lid = ");
-            lid    = getint();
+            lid    = get_uint32();
             trace( active , cxy , lid );
+        }
+        else if( cmd == 'b' )
+        {
+            printf("b / pid = ");
+            pid = get_uint32();
+            printf(" / trdid = ");
+            trdid = get_uint32();
+            display_busylocks( pid , trdid );
         }
         else if( cmd == 'x' )

trunk/libs/libalmosmkh/almosmkh.h

@@ -101 +101 @@
 
 /***************************************************************************************
- * This function returns a positive integer fom the standard "stdin" stream.
+ * This function returns an unsigned 32 bits integer from the standard "stdin" stream.
+ * Both decimal numbers and hexadecimal numbers (prefixed by 0x) are supported.
  ***************************************************************************************
  * returns the integer value if success / returns -1 if failure.
  **************************************************************************************/
-int getint( void );
+unsigned int getint32( void );
 
 

trunk/libs/mini-libc/stdio.c

@@ -286 +286 @@
 }  // end printf()
 
-/////////////
+///////////////////
 int getchar( void )
 {

trunk/params-hard.mk

@@ -2 +2 @@
 
 ARCH      = /users/alain/soc/tsar-trunk-svn-2013/platforms/tsar_generic_iob
-X_SIZE    = 2
-Y_SIZE    = 2
-NB_PROCS  = 2
+X_SIZE    = 1
+Y_SIZE    = 1
+NB_PROCS  = 1
 NB_TTYS   = 3
 FBF_WIDTH = 128

trunk/user/idbg/idbg.c

@@ -16 +16 @@
 {
     unsigned long long  cycle;
+    unsigned int        cxy;
+    unsigned int        lid;
 
     get_cycle( &cycle );
+    get_core( &cxy , &lid );
 
-    printf( "\n[IDBG] starts at cycle %d\n", (unsigned int)cycle ); 
+    printf( "\n[IDBG] starts on core[%x,%d] / cycle %d\n",
+    cxy , lid , (unsigned int)cycle ); 
 
     idbg();

trunk/user/pgcd/pgcd.c

@@ -18 +18 @@
     int                opy;
     unsigned long long cycle;
+    unsigned int       cxy;
+    unsigned int       lid;
 
     get_cycle( &cycle );
-    printf( "\n\n[PGCD] starts / cycle %d\n", (unsigned int)cycle ); 
+    get_core( &cxy , &lid );
+
+    printf( "\n\n[PGCD] starts on core[%x,%d] / cycle %d\n",
+    cxy , lid , (unsigned int)cycle ); 
 
     while (1) 
@@ -26 +31 @@
         printf("\n*******************\n");
         printf("operand X = ");
-        opx = getint();
+        opx = get_uint32();
         printf("\n");
         printf("operand Y = ");
-        opy = getint();
+        opy = get_uint32();
         printf("\n");