Ignore:
Timestamp:
Oct 8, 2018, 11:31:42 AM (3 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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/kern/kernel_init.c

    r577 r580  
    375375            // check channels
    376376            if( channels != 1 )
    377             printk("\n[PANIC] in %s : MMC device must be single channel\n", __FUNCTION__ );
     377            {
     378                printk("\n[PANIC] in %s : MMC device must be single channel\n",
     379                __FUNCTION__ );
     380                hal_core_sleep();
     381            }
    378382
    379383            // create chdev in local cluster
     
    386390            // check memory
    387391            if( chdev_ptr == NULL )
    388             printk("\n[PANIC] in %s : cannot create MMC chdev\n", __FUNCTION__ );
     392            {
     393                printk("\n[PANIC] in %s : cannot create MMC chdev\n",
     394                __FUNCTION__ );
     395                hal_core_sleep();
     396            }
    389397           
    390398            // make MMC specific initialisation
     
    427435                // check memory
    428436                if( chdev_ptr == NULL )
    429                 printk("\n[PANIC] in %s : cannot create DMA chdev\n", __FUNCTION__ );
     437                {
     438                    printk("\n[PANIC] in %s : cannot create DMA chdev\n",
     439                    __FUNCTION__ );
     440                    hal_core_sleep();
     441                }
    430442           
    431443                // make DMA specific initialisation
     
    503515        // check PIC device initialized
    504516        if( chdev_dir.pic == XPTR_NULL )
    505         printk("\n[PANIC] in %s : PIC device must be initialized first\n", __FUNCTION__ );
     517        {
     518            printk("\n[PANIC] in %s : PIC device must be initialized first\n",
     519            __FUNCTION__ );
     520            hal_core_sleep();
     521        }
    506522
    507523        // check external device functionnal type
    508524        if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) &&
    509525            (func != DEV_FUNC_NIC) && (func != DEV_FUNC_FBF) )
    510         printk("\n[PANIC] in %s : undefined peripheral type\n", __FUNCTION__ );
     526        {
     527            printk("\n[PANIC] in %s : undefined peripheral type\n",
     528            __FUNCTION__ );
     529            hal_core_sleep();
     530        }
    511531
    512532        // loops on channels
     
    548568
    549569                    if( chdev == NULL )
    550                     printk("\n[PANIC] in %s : cannot allocate chdev for external device\n",
    551                     __FUNCTION__ );
     570                    {
     571                        printk("\n[PANIC] in %s : cannot allocate chdev\n",
     572                        __FUNCTION__ );
     573                        hal_core_sleep();
     574                    }
    552575
    553576                    // make device type specific initialisation
     
    646669    // check PIC existence
    647670    if( found == false )
    648     printk("\n[PANIC] in %s : PIC device not found\n", __FUNCTION__ );
     671    {
     672        printk("\n[PANIC] in %s : PIC device not found\n",
     673        __FUNCTION__ );
     674        hal_core_sleep();
     675    }
    649676
    650677    // allocate and initialize the PIC chdev in cluster 0
     
    657684    // check memory
    658685    if( chdev == NULL )
    659     printk("\n[PANIC] in %s : no memory for PIC chdev\n", __FUNCTION__ );
     686    {
     687        printk("\n[PANIC] in %s : no memory for PIC chdev\n",
     688        __FUNCTION__ );
     689        hal_core_sleep();
     690    }
    660691
    661692    // make PIC device type specific initialisation
     
    723754            else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel];
    724755            else if( func == DEV_FUNC_IOB )                 ptr = &iopic_input.iob;
    725             else     printk("\n[PANIC] in %s : illegal source device for IOPIC input" );
     756            else
     757            {
     758                printk("\n[PANIC] in %s : illegal source device for IOPIC input\n",
     759                __FUNCTION__ );
     760                hal_core_sleep();
     761            }
    726762
    727763            // set one entry in all "iopic_input" structures
     
    814850                if     ( func == DEV_FUNC_MMC ) lapic_input.mmc = id;
    815851                else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id;
    816                 else     printk("\n[PANIC] in %s : illegal source device for LAPIC input" );
     852                else
     853                {
     854                    printk("\n[PANIC] in %s : illegal source device for LAPIC input\n",
     855                    __FUNCTION__ );
     856                    hal_core_sleep();
     857                }
    817858            }
    818859        }
     
    939980    // all cores check identifiers
    940981    if( error )
    941     printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
    942     __FUNCTION__, core_lid, core_cxy, core_lid );
     982    {
     983        printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
     984        __FUNCTION__, core_lid, core_cxy, core_lid );
     985        hal_core_sleep();
     986    }
    943987
    944988    // CP0 initializes cluster manager complex structures
     
    948992
    949993        if( error )
    950         printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
    951         __FUNCTION__, local_cxy );
     994        {
     995             printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
     996             __FUNCTION__, local_cxy );
     997             hal_core_sleep();
     998        }
    952999    }
    9531000
     
    10681115
    10691116            if( fatfs_ctx == NULL )
    1070             printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
    1071             __FUNCTION__ );
     1117            {
     1118                printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
     1119                __FUNCTION__ );
     1120                hal_core_sleep();
     1121            }
    10721122
    10731123            // 2. access boot device to initialize FATFS context
     
    10991149                                      &vfs_root_inode_xp );                // return
    11001150            if( error )
    1101             printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
    1102             __FUNCTION__ );
     1151            {
     1152                printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
     1153                __FUNCTION__ );
     1154                hal_core_sleep();
     1155            }
    11031156
    11041157            // 6. update the FATFS entry in vfs_context[] array
     
    11091162
    11101163            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
    1111             printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
    1112             __FUNCTION__ );
     1164            {
     1165                printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
     1166                __FUNCTION__ );
     1167                hal_core_sleep();
     1168            }
     1169               
    11131170        }
    11141171        else
     
    11161173            printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n",
    11171174            __FUNCTION__ );
     1175            hal_core_sleep();
    11181176        }
    11191177
     
    11531211            // check memory
    11541212            if( local_fatfs_ctx == NULL )
    1155             printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
    1156             __FUNCTION__ , local_cxy );
     1213            {
     1214                printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
     1215                __FUNCTION__ , local_cxy );
     1216                hal_core_sleep();
     1217            }
    11571218
    11581219            // 2. get local pointer on VFS context for FATFS
     
    11741235
    11751236            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
    1176             printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
    1177             __FUNCTION__ , local_cxy );
     1237            {
     1238                printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
     1239                __FUNCTION__ , local_cxy );
     1240                hal_core_sleep();
     1241            }
    11781242        }
    11791243
     
    12101274
    12111275        if( devfs_ctx == NULL )
    1212         printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
    1213         __FUNCTION__ , local_cxy );
     1276        {
     1277            printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
     1278            __FUNCTION__ , local_cxy );
     1279            hal_core_sleep();
     1280        }
    12141281
    12151282        // 2. initialize the DEVFS entry in the vfs_context[] array
Note: See TracChangeset for help on using the changeset viewer.