Changeset 580 for trunk/libs/libalmosmkh

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/libs/libalmosmkh

Files:

• almosmkh.c (modified) (12 diffs)
• almosmkh.h (modified) (1 diff)

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 );