Changeset 564 for trunk/kernel/kern/kernel_init.c
- Timestamp:
- Oct 4, 2018, 11:47:36 PM (6 years ago)
- File:
-
- 1 edited
-
trunk/kernel/kern/kernel_init.c (modified) (55 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/kernel/kern/kernel_init.c
r561 r564 24 24 25 25 #include <kernel_config.h> 26 #include <hard_config.h> // for the USE_TXT_XXX macros27 26 #include <errno.h> 28 27 #include <hal_kernel_types.h> … … 30 29 #include <hal_context.h> 31 30 #include <hal_irqmask.h> 31 #include <hal_macros.h> 32 32 #include <hal_ppm.h> 33 33 #include <barrier.h> 34 #include < remote_barrier.h>34 #include <xbarrier.h> 35 35 #include <remote_fifo.h> 36 36 #include <core.h> … … 59 59 #include <devfs.h> 60 60 #include <mapper.h> 61 #include <cluster_info.h>62 61 63 62 /////////////////////////////////////////////////////////////////////////////////////////// … … 86 85 cluster_t cluster_manager CONFIG_CACHE_LINE_ALIGNED; 87 86 88 // This variable defines the TXT 0 kernel terminal (TX only)87 // This variable defines the TXT_TX[0] chdev 89 88 __attribute__((section(".kdata"))) 90 chdev_t txt0_ chdevCONFIG_CACHE_LINE_ALIGNED;91 92 // This variable defines the TXT 0 lock for writing characters to MTY089 chdev_t txt0_tx_chdev CONFIG_CACHE_LINE_ALIGNED; 90 91 // This variable defines the TXT_RX[0] chdev 93 92 __attribute__((section(".kdata"))) 94 spinlock_t txt0_lockCONFIG_CACHE_LINE_ALIGNED;93 chdev_t txt0_rx_chdev CONFIG_CACHE_LINE_ALIGNED; 95 94 96 95 // This variables define the kernel process0 descriptor … … 116 115 // This variable is used for CP0 cores synchronisation in kernel_init() 117 116 __attribute__((section(".kdata"))) 118 remote_barrier_tglobal_barrier CONFIG_CACHE_LINE_ALIGNED;117 xbarrier_t global_barrier CONFIG_CACHE_LINE_ALIGNED; 119 118 120 119 // This variable is used for local cores synchronisation in kernel_init() … … 127 126 128 127 // kernel_init is the entry point defined in hal/tsar_mips32/kernel.ld 129 // It will beused by the bootloader.128 // It is used by the bootloader. 130 129 extern void kernel_init( boot_info_t * info ); 131 130 132 // these debug variables are used to analyse the sys_read() syscall timing 131 // This array is used for debug, and describes the kernel locks usage, 132 // It must be kept consistent with the defines in kernel_config.h file. 133 char * lock_type_str[] = 134 { 135 "unused_0", // 0 136 137 "CLUSTER_KCM", // 1 138 "PPM_FREE", // 2 139 "SCHED_STATE", // 3 140 "VMM_STACK", // 4 141 "VMM_MMAP", // 5 142 "VFS_CTX", // 6 143 "KCM_STATE", // 7 144 "KHM_STATE", // 8 145 "HTAB_STATE", // 9 146 147 "THREAD_JOIN", // 10 148 "VFS_MAIN", // 11 149 "CHDEV_QUEUE", // 12 150 "CHDEV_TXT0", // 13 151 "CHDEV_TXTLIST", // 14 152 "PAGE_STATE", // 15 153 "MUTEX_STATE", // 16 154 "CONDVAR_STATE", // 17 155 "SEM_STATE", // 18 156 "XHTAB_STATE", // 19 157 158 "unused_20", // 20 159 160 "CLUSTER_PREFTBL", // 21 161 "PPM_DIRTY", // 22 162 163 "CLUSTER_LOCALS", // 23 164 "CLUSTER_COPIES", // 24 165 "PROCESS_CHILDREN", // 25 166 "PROCESS_USERSYNC", // 26 167 "PROCESS_FDARRAY", // 27 168 169 "MAPPER_STATE", // 28 170 "PROCESS_THTBL", // 29 171 172 "PROCESS_CWD", // 30 173 "VFS_INODE", // 31 174 "VFS_FILE", // 32 175 "VMM_VSL", // 33 176 }; 177 178 // these debug variables are used to analyse the sys_read() and sys_write() syscalls timing 133 179 134 180 #if DEBUG_SYS_READ … … 179 225 uint32_t exit_tty_isr_write; 180 226 #endif 227 228 // intrumentation variables : cumulated costs per syscall type in cluster 229 uint32_t syscalls_cumul_cost[SYSCALLS_NR]; 230 231 // intrumentation variables : number of syscalls per syscal type in cluster 232 uint32_t syscalls_occurences[SYSCALLS_NR]; 181 233 182 234 /////////////////////////////////////////////////////////////////////////////////////////// … … 201 253 202 254 /////////////////////////////////////////////////////////////////////////////////////////// 203 // This function initializes the TXT 0 chdev descriptor, that is the "kernel terminal",204 // shared by all kernel instances for debug messages.205 // It is a global variable (replicated in all clusters), because this terminal is used206 // be fore the kmem allocator initialisation, but only the instance in cluster containing207 // the c alling core isregistered in the "chdev_dir" directory.255 // This function initializes the TXT_TX[0] and TXT_RX[0] chdev descriptors, implementing 256 // the "kernel terminal", shared by all kernel instances for debug messages. 257 // These chdev are implemented as global variables (replicated in all clusters), 258 // because this terminal is used before the kmem allocator initialisation, but only 259 // the chdevs in cluster 0 are registered in the "chdev_dir" directory. 208 260 // As this TXT0 chdev supports only the TXT_SYNC_WRITE command, we don't create 209 261 // a server thread, we don't allocate a WTI, and we don't initialize the waiting queue. 262 // Note: The TXT_RX[0] chdev is created, but is not used by ALMOS-MKH (september 2018). 210 263 /////////////////////////////////////////////////////////////////////////////////////////// 211 264 // @ info : pointer on the local boot-info structure. 212 265 /////////////////////////////////////////////////////////////////////////////////////////// 213 static void txt0_device_init( boot_info_t * info )266 static void __attribute__ ((noinline)) txt0_device_init( boot_info_t * info ) 214 267 { 215 268 boot_device_t * dev_tbl; // pointer on array of devices in boot_info … … 237 290 if (func == DEV_FUNC_TXT ) 238 291 { 239 assert( (channels > 0) , "number of TXT channels cannot be 0\n"); 240 241 // initializes TXT_TX[0] chdev 242 txt0_chdev.func = func; 243 txt0_chdev.impl = impl; 244 txt0_chdev.channel = 0; 245 txt0_chdev.base = base; 246 txt0_chdev.is_rx = false; 247 248 // initializes lock 249 remote_spinlock_init( XPTR( local_cxy , &txt0_chdev.wait_lock ) ); 292 // initialize TXT_TX[0] chdev 293 txt0_tx_chdev.func = func; 294 txt0_tx_chdev.impl = impl; 295 txt0_tx_chdev.channel = 0; 296 txt0_tx_chdev.base = base; 297 txt0_tx_chdev.is_rx = false; 298 remote_busylock_init( XPTR( local_cxy , &txt0_tx_chdev.wait_lock ), 299 LOCK_CHDEV_TXT0 ); 250 300 251 // TXT specific initialisation: 252 // no server thread & no IRQ routing for channel 0 253 dev_txt_init( &txt0_chdev ); 254 255 // register the TXT0 in all chdev_dir[x][y] structures 301 // initialize TXT_RX[0] chdev 302 txt0_rx_chdev.func = func; 303 txt0_rx_chdev.impl = impl; 304 txt0_rx_chdev.channel = 0; 305 txt0_rx_chdev.base = base; 306 txt0_rx_chdev.is_rx = true; 307 remote_busylock_init( XPTR( local_cxy , &txt0_rx_chdev.wait_lock ), 308 LOCK_CHDEV_TXT0 ); 309 310 // make TXT specific initialisations 311 dev_txt_init( &txt0_tx_chdev ); 312 dev_txt_init( &txt0_rx_chdev ); 313 314 // register TXT_TX[0] & TXT_RX[0] in chdev_dir[x][y] 315 // for all valid clusters 256 316 for( x = 0 ; x < info->x_size ; x++ ) 257 317 { 258 for( y = 0 ; y < info->y_size ; y++ ) // [FIXME]318 for( y = 0 ; y < info->y_size ; y++ ) 259 319 { 260 if (cluster_info_is_active(info->cluster_info[x][y])) { 261 cxy_t cxy = (x<<info->y_width) + y; 262 hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) , 263 XPTR( local_cxy , &txt0_chdev ) ); 320 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 321 322 if( cluster_is_active( cxy ) ) 323 { 324 hal_remote_s64( XPTR( cxy , &chdev_dir.txt_tx[0] ) , 325 XPTR( local_cxy , &txt0_tx_chdev ) ); 326 hal_remote_s64( XPTR( cxy , &chdev_dir.txt_rx[0] ) , 327 XPTR( local_cxy , &txt0_rx_chdev ) ); 264 328 } 265 329 } 266 330 } 331 332 hal_fence(); 267 333 } 268 334 } // end loop on devices 269 335 } // end txt0_device_init() 270 271 ///////////////////////////////////////////////////////////////////////////////////////////272 // This function is the same as txt0_device_init() but uses the internal multi_tty device273 // attached to cluster (0,0) instead of the external tty_tsar.274 // This function is used instead of txt0_device_init() only for TSAR LETI.275 ///////////////////////////////////////////////////////////////////////////////////////////276 // @ info : pointer on the local boot-info structure.277 ///////////////////////////////////////////////////////////////////////////////////////////278 static void mtty0_device_init( boot_info_t * info)279 {280 boot_device_t * dev_tbl; // pointer on array of devices in boot_info281 uint32_t dev_nr; // actual number of devices in this cluster282 xptr_t base; // remote pointer on segment base283 uint32_t func; // device functional index284 uint32_t impl; // device implementation index285 uint32_t i; // device index in dev_tbl286 uint32_t x; // X cluster coordinate287 uint32_t y; // Y cluster coordinate288 289 dev_nr = info->int_dev_nr;290 dev_tbl = info->int_dev;291 292 // Initialize spinlock for writing to MTY0293 spinlock_init(&txt0_lock);294 295 // Loop on internal peripherals of cluster (0,0) to find MTY0296 for ( i = 0; i < dev_nr; i++ )297 {298 base = dev_tbl[i].base;299 func = FUNC_FROM_TYPE( dev_tbl[i].type );300 impl = IMPL_FROM_TYPE( dev_tbl[i].type );301 302 if ( func == DEV_FUNC_TXT )303 {304 txt0_chdev.func = func;305 txt0_chdev.impl = impl;306 txt0_chdev.channel = 0;307 txt0_chdev.base = base;308 txt0_chdev.is_rx = false;309 310 // Initialize MTY0 chdev lock311 remote_spinlock_init( XPTR( local_cxy, &txt0_chdev.wait_lock ) );312 313 // MTY specific initialization314 dev_txt_init( &txt0_chdev );315 316 // register the MTY in all chdev_dir[x][y] structures317 for( x = 0 ; x < info->x_size ; x++ )318 {319 for( y = 0 ; y < info->y_size; y++ ) // [FIXME]320 {321 if (cluster_info_is_active(info->cluster_info[x][y])) {322 cxy_t cxy = (x<<info->y_width) + y;323 hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,324 XPTR( local_cxy , &txt0_chdev ) );325 }326 }327 }328 }329 } // end loop on internal devices330 } // end mty0_device_init()331 336 332 337 /////////////////////////////////////////////////////////////////////////////////////////// … … 338 343 // @ info : pointer on the local boot-info structure. 339 344 /////////////////////////////////////////////////////////////////////////////////////////// 340 static void internal_devices_init( boot_info_t * info )345 static void __attribute__ ((noinline)) internal_devices_init( boot_info_t * info ) 341 346 { 342 347 boot_device_t * dev_tbl; // pointer on array of internaldevices in boot_info … … 367 372 if( func == DEV_FUNC_MMC ) 368 373 { 369 assert( (channels == 1) , "MMC device must be single channel\n" ); 374 375 // check channels 376 if( channels != 1 ) 377 printk("\n[PANIC] in %s : MMC device must be single channel\n", __FUNCTION__ ); 370 378 371 379 // create chdev in local cluster … … 376 384 base ); 377 385 378 assert( (chdev_ptr != NULL) , 379 "cannot allocate memory for MMC chdev\n" ); 386 // check memory 387 if( chdev_ptr == NULL ) 388 printk("\n[PANIC] in %s : cannot create MMC chdev\n", __FUNCTION__ ); 380 389 381 390 // make MMC specific initialisation … … 385 394 for( x = 0 ; x < info->x_size ; x++ ) 386 395 { 387 for( y = 0 ; y < info->y_size ; y++ ) // [FIXME]396 for( y = 0 ; y < info->y_size ; y++ ) 388 397 { 389 if (cluster_info_is_active(info->cluster_info[x][y])) { 390 cxy_t cxy = (x<<info->y_width) + y; 391 hal_remote_swd( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 398 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 399 400 if( cluster_is_active( cxy ) ) 401 { 402 hal_remote_s64( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 392 403 XPTR( local_cxy , chdev_ptr ) ); 393 404 } … … 414 425 base ); 415 426 416 assert( (chdev_ptr != NULL) , "cannot allocate memory for DMA chdev" ); 417 427 // check memory 428 if( chdev_ptr == NULL ) 429 printk("\n[PANIC] in %s : cannot create DMA chdev\n", __FUNCTION__ ); 430 418 431 // make DMA specific initialisation 419 432 dev_dma_init( chdev_ptr ); … … 430 443 } 431 444 } 432 433 ///////////////////////////////434 else if ( func == DEV_FUNC_TXT && USE_TXT_MTY == 1 )435 {436 assert(impl == IMPL_TXT_MTY,437 "Internal TTYs should have MTY implementation\n");438 439 for ( channel = 0; channel < channels; channel++ )440 {441 int rx;442 for ( rx = 0; rx <= 1; rx++ )443 {444 // skip MTY0_TX since it has already been initialized445 if ( channel == 0 && rx == 0 ) continue;446 447 // create chdev in local cluster448 chdev_ptr = chdev_create( func,449 impl,450 channel,451 rx,452 base );453 454 assert( (chdev_ptr != NULL) ,455 "cannot allocate memory for MTY chdev" );456 457 // make MTY specific initialization458 dev_txt_init( chdev_ptr );459 460 // set the MTY fields in all clusters461 xptr_t *chdev_entry;462 if ( rx == 1 ) {463 chdev_entry = &chdev_dir.txt_rx[channel];464 } else {465 chdev_entry = &chdev_dir.txt_tx[channel];466 }467 for ( x = 0; x < info->x_size; x++ )468 {469 for ( y = 0; y < info->y_size; y++ )470 {471 if (cluster_info_is_active(info->cluster_info[x][y])) {472 cxy_t cxy = (x<<info->y_width) + y;473 hal_remote_swd( XPTR( cxy, chdev_entry ),474 XPTR( local_cxy, chdev_ptr ) );475 }476 }477 }478 #if( DEBUG_KERNEL_INIT & 0x1 )479 if( hal_time_stamp() > DEBUG_KERNEL_INIT )480 printk("\n[DBG] %s : created MTY[%d] in cluster %x / chdev = %x\n",481 __FUNCTION__ , channel , local_cxy , chdev_ptr );482 #endif483 }484 }485 }486 487 ///////////////////////////////488 else if ( func == DEV_FUNC_IOC )489 {490 assert(impl == IMPL_IOC_SPI, __FUNCTION__,491 "Internal IOC should have SPI implementation\n");492 493 for ( channel = 0; channel < channels; channel++ )494 {495 // create chdev in local cluster496 chdev_ptr = chdev_create( func,497 impl,498 channel,499 0,500 base );501 502 assert( (chdev_ptr != NULL) , __FUNCTION__ ,503 "cannot allocate memory for IOC chdev" );504 505 // make IOC specific initialization506 dev_ioc_init( chdev_ptr );507 508 // set the IOC fields in all clusters509 xptr_t *chdev_entry = &chdev_dir.ioc[channel];510 for ( x = 0; x < info->x_size; x++ )511 {512 for ( y = 0; y < info->y_size; y++ )513 {514 if (cluster_info_is_active(info->cluster_info[x][y])) {515 cxy_t cxy = (x<<info->y_width) + y;516 hal_remote_swd( XPTR( cxy, chdev_entry ),517 XPTR( local_cxy, chdev_ptr ) );518 }519 }520 }521 #if( DEBUG_KERNEL_INIT & 0x1 )522 if( hal_time_stamp() > DEBUG_KERNEL_INIT )523 printk("\n[DBG] %s : created IOC[%d] in cluster %x / chdev = %x\n",524 __FUNCTION__ , channel , local_cxy , chdev_ptr );525 #endif526 }527 }528 529 445 } 530 446 } // end internal_devices_init() … … 586 502 587 503 // check PIC device initialized 588 assert( (chdev_dir.pic != XPTR_NULL ) ,589 "PIC device must be initialized before other devices\n");504 if( chdev_dir.pic == XPTR_NULL ) 505 printk("\n[PANIC] in %s : PIC device must be initialized first\n", __FUNCTION__ ); 590 506 591 507 // check external device functionnal type 592 assert( ( (func == DEV_FUNC_IOB) || 593 (func == DEV_FUNC_IOC) || 594 (func == DEV_FUNC_TXT) || 595 (func == DEV_FUNC_NIC) || 596 (func == DEV_FUNC_FBF) ) , 597 "undefined external peripheral type\n" ); 508 if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) && 509 (func != DEV_FUNC_NIC) && (func != DEV_FUNC_FBF) ) 510 printk("\n[PANIC] in %s : undefined peripheral type\n", __FUNCTION__ ); 598 511 599 512 // loops on channels … … 603 516 for( rx = 0 ; rx < directions ; rx++ ) 604 517 { 605 // skip TXT_TX[0] chdev that has already been created & registered 606 if( USE_TXT_MTY == 0 && (func == DEV_FUNC_TXT) && (channel == 0) && (rx == 0) ) 518 // skip TXT0 that has already been initialized 519 if( (func == DEV_FUNC_TXT) && (channel == 0) ) continue; 520 521 // all kernel instances compute the target cluster for all chdevs, 522 // computing the global index ext_chdev_gid[func,channel,direction] 523 cxy_t target_cxy; 524 while( 1 ) 607 525 { 608 continue; 526 uint32_t offset = ext_chdev_gid % ( info->x_size * info->y_size ); 527 uint32_t x = offset / info->y_size; 528 uint32_t y = offset % info->y_size; 529 530 target_cxy = HAL_CXY_FROM_XY( x , y ); 531 532 // exit loop if target cluster is active 533 if( cluster_is_active( target_cxy ) ) break; 534 535 // increment global index otherwise 536 ext_chdev_gid++; 609 537 } 610 538 611 // skip TXT chdevs because they are initialized in internal_devices_init()612 if ( USE_TXT_MTY == 1 && func == DEV_FUNC_TXT )613 {614 continue;615 }616 617 if ( func == DEV_FUNC_IOC && impl == IMPL_IOC_SPI )618 {619 continue;620 }621 622 // compute target cluster for chdev[func,channel,direction]623 uint32_t offset;624 uint32_t cx;625 uint32_t cy;626 uint32_t target_cxy;627 while (1) {628 offset = ext_chdev_gid % ( info->x_size * (info->y_size) );629 cx = offset / (info->y_size);630 cy = offset % (info->y_size);631 target_cxy = (cx<<info->y_width) + cy;632 // ext_chdev_gid that results in empty target clusters are skipped633 if ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[cx][cy] ) == 0 ) {634 ext_chdev_gid++;635 } else { // The ext_chdev_gid resulted in a full target cluster636 break;637 }638 }639 539 // allocate and initialize a local chdev 640 540 // when local cluster matches target cluster … … 647 547 base ); 648 548 649 assert( (chdev != NULL), 650 "cannot allocate external device" ); 549 if( chdev == NULL ) 550 printk("\n[PANIC] in %s : cannot allocate chdev for external device\n", 551 __FUNCTION__ ); 651 552 652 553 // make device type specific initialisation … … 672 573 for( x = 0 ; x < info->x_size ; x++ ) 673 574 { 674 for ( y = 0; y < info->y_size; y++ )575 for( y = 0 ; y < info->y_size ; y++ ) 675 576 { 676 if (cluster_info_is_active(info->cluster_info[x][y])) { 677 cxy_t cxy = (x<<info->y_width) + y; 678 hal_remote_swd( XPTR( cxy , entry ), 577 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 578 579 if( cluster_is_active( cxy ) ) 580 { 581 hal_remote_s64( XPTR( cxy , entry ), 679 582 XPTR( local_cxy , chdev ) ); 680 583 } … … 706 609 // @ info : pointer on the local boot-info structure. 707 610 /////////////////////////////////////////////////////////////////////////////////////////// 708 static void iopic_init( boot_info_t * info )611 static void __attribute__ ((noinline)) iopic_init( boot_info_t * info ) 709 612 { 710 613 boot_device_t * dev_tbl; // pointer on boot_info external devices array … … 723 626 dev_tbl = info->ext_dev; 724 627 628 // avoid GCC warning 629 base = XPTR_NULL; 630 impl = 0; 631 725 632 // loop on external peripherals to get the IOPIC 726 633 for( i = 0 , found = false ; i < dev_nr ; i++ ) … … 737 644 } 738 645 739 assert( found , "PIC device not found\n" ); 646 // check PIC existence 647 if( found == false ) 648 printk("\n[PANIC] in %s : PIC device not found\n", __FUNCTION__ ); 740 649 741 650 // allocate and initialize the PIC chdev in cluster 0 … … 746 655 base ); 747 656 748 assert( (chdev != NULL), "no memory for PIC chdev\n" ); 657 // check memory 658 if( chdev == NULL ) 659 printk("\n[PANIC] in %s : no memory for PIC chdev\n", __FUNCTION__ ); 749 660 750 661 // make PIC device type specific initialisation … … 757 668 for( x = 0 ; x < info->x_size ; x++ ) 758 669 { 759 for ( y = 0; y < info->y_size; y++ )670 for( y = 0 ; y < info->y_size ; y++ ) 760 671 { 761 if (cluster_info_is_active(info->cluster_info[x][y])) { 762 cxy_t cxy = (x<<info->y_width) + y; 763 hal_remote_swd( XPTR( cxy , entry ) , 672 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 673 674 if( cluster_is_active( cxy ) ) 675 { 676 hal_remote_s64( XPTR( cxy , entry ) , 764 677 XPTR( local_cxy , chdev ) ); 765 678 } … … 773 686 for( x = 0 ; x < info->x_size ; x++ ) 774 687 { 775 for ( y = 0; y < info->y_size; y++ )688 for( y = 0 ; y < info->y_size ; y++ ) 776 689 { 777 if (cluster_info_is_active(info->cluster_info[x][y])) { 778 cxy_t cxy = (x<<info->y_width) + y; 779 hal_remote_memset( XPTR( cxy , &iopic_input ) , 0xFF , sizeof(iopic_input_t) ); 690 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 691 692 if( cluster_is_active( cxy ) ) 693 { 694 hal_remote_memset( XPTR( cxy , &iopic_input ), 695 0xFF , sizeof(iopic_input_t) ); 780 696 } 781 697 } … … 807 723 else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel]; 808 724 else if( func == DEV_FUNC_IOB ) ptr = &iopic_input.iob; 809 else assert( false , "illegal source device for IOPIC input" );725 else printk("\n[PANIC] in %s : illegal source device for IOPIC input" ); 810 726 811 727 // set one entry in all "iopic_input" structures 812 728 for( x = 0 ; x < info->x_size ; x++ ) 813 729 { 814 for ( y = 0; y < info->y_size; y++ )730 for( y = 0 ; y < info->y_size ; y++ ) 815 731 { 816 if (cluster_info_is_active(info->cluster_info[x][y])) { 817 cxy_t cxy = (x<<info->y_width) + y; 818 hal_remote_swd( XPTR( cxy , ptr ) , id ); 732 cxy_t cxy = HAL_CXY_FROM_XY( x , y ); 733 734 if( cluster_is_active( cxy ) ) 735 { 736 hal_remote_s64( XPTR( cxy , ptr ) , id ); 819 737 } 820 738 } … … 824 742 825 743 #if( DEBUG_KERNEL_INIT & 0x1 ) 826 if( hal_tim e_stamp() > DEBUG_KERNEL_INIT )744 if( hal_tim_stamp() > DEBUG_KERNEL_INIT ) 827 745 { 828 746 printk("\n[DBG] %s created PIC chdev in cluster %x at cycle %d\n", … … 843 761 // @ info : pointer on the local boot-info structure. 844 762 /////////////////////////////////////////////////////////////////////////////////////////// 845 static void lapic_init( boot_info_t * info )763 static void __attribute__ ((noinline)) lapic_init( boot_info_t * info ) 846 764 { 847 765 boot_device_t * dev_tbl; // pointer on boot_info internal devices array … … 896 814 if ( func == DEV_FUNC_MMC ) lapic_input.mmc = id; 897 815 else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id; 898 else if( func == DEV_FUNC_TXT ) lapic_input.mtty = id; 899 else if( func == DEV_FUNC_IOC ) lapic_input.sdcard = id; 900 else assert( false , "illegal source device for LAPIC input" ); 816 else printk("\n[PANIC] in %s : illegal source device for LAPIC input" ); 901 817 } 902 818 } … … 913 829 // @ return 0 if success / return EINVAL if not found. 914 830 /////////////////////////////////////////////////////////////////////////////////////////// 915 static error_t get_core_identifiers( boot_info_t * info,916 lid_t * lid,917 cxy_t * cxy,918 gid_t * gid )831 static error_t __attribute__ ((noinline)) get_core_identifiers( boot_info_t * info, 832 lid_t * lid, 833 cxy_t * cxy, 834 gid_t * gid ) 919 835 { 920 836 uint32_t i; … … 989 905 thread->core = &LOCAL_CLUSTER->core_tbl[core_lid]; 990 906 991 // each core initializes the idle thread lists of locks 992 list_root_init( &thread->locks_root ); 993 xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) ); 994 thread->local_locks = 0; 995 thread->remote_locks = 0; 996 997 // CP0 in cluster 0 initializes TXT0 chdev descriptor 998 if( core_cxy == 0 && core_lid == 0 ) // [MODIF] 999 { 1000 if( USE_TXT_MTY == 1 ) { 1001 mtty0_device_init( info ); 1002 } else { 1003 txt0_device_init( info ); 1004 } 1005 } 1006 1007 ///////////////////////////////////////////////////////////////////////////////// 1008 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME] 1009 cluster_info_nb_actives(info->cluster_info) ); 907 // each core initializes the idle thread locks counters 908 thread->busylocks = 0; 909 910 #if DEBUG_BUSYLOCK 911 // each core initialise the idle thread list of busylocks 912 xlist_root_init( XPTR( local_cxy , &thread->busylocks_root ) ); 913 #endif 914 915 // CP0 initializes cluster info 916 if( core_lid == 0 ) cluster_info_init( info ); 917 918 // CP0 in cluster 0 initialises TXT0 chdev descriptor 919 if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info ); 920 921 ///////////////////////////////////////////////////////////////////////////////// 922 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 923 (info->x_size * info->y_size) ); 1010 924 barrier_wait( &local_barrier , info->cores_nr ); 1011 925 ///////////////////////////////////////////////////////////////////////////////// 1012 926 1013 927 #if DEBUG_KERNEL_INIT 1014 if( (core_lid == 0) & (local_cxy == 0) )1015 printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",1016 __FUNCTION__, (uint32_t)hal_get_ cycles() );928 // if( (core_lid == 0) & (local_cxy == 0) ) 929 printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / sr %x / cycle %d\n", 930 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1017 931 #endif 1018 932 … … 1025 939 // all cores check identifiers 1026 940 if( error ) 1027 { 1028 assert( false , 1029 "illegal core identifiers gid = %x / cxy = %x / lid = %d", 1030 core_lid , core_cxy , core_lid ); 1031 } 1032 1033 // CP0 initializes cluster manager 941 printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d", 942 __FUNCTION__, core_lid, core_cxy, core_lid ); 943 944 // CP0 initializes cluster manager complex structures 1034 945 if( core_lid == 0 ) 1035 946 { 1036 error = cluster_ init( info );947 error = cluster_manager_init( info ); 1037 948 1038 949 if( error ) 1039 { 1040 assert( false , 1041 "cannot initialise cluster %x", local_cxy ); 1042 } 950 printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n", 951 __FUNCTION__, local_cxy ); 1043 952 } 1044 953 1045 954 ///////////////////////////////////////////////////////////////////////////////// 1046 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1047 cluster_info_nb_actives(info->cluster_info) );955 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 956 (info->x_size * info->y_size) ); 1048 957 barrier_wait( &local_barrier , info->cores_nr ); 1049 958 ///////////////////////////////////////////////////////////////////////////////// … … 1051 960 #if DEBUG_KERNEL_INIT 1052 961 if( (core_lid == 0) & (local_cxy == 0) ) 1053 printk("\n[DBG] %s : exit barrier 1 : clusters initialised / cycle %d\n",1054 __FUNCTION__, (uint32_t)hal_get_ cycles() );962 printk("\n[DBG] %s : exit barrier 1 : clusters initialised / sr %x / cycle %d\n", 963 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1055 964 #endif 1056 965 … … 1071 980 1072 981 //////////////////////////////////////////////////////////////////////////////// 1073 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1074 cluster_info_nb_actives(info->cluster_info) );982 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 983 (info->x_size * info->y_size) ); 1075 984 barrier_wait( &local_barrier , info->cores_nr ); 1076 985 //////////////////////////////////////////////////////////////////////////////// … … 1078 987 #if DEBUG_KERNEL_INIT 1079 988 if( (core_lid == 0) & (local_cxy == 0) ) 1080 printk("\n[DBG] %s : exit barrier 2 : PIC initialised / cycle %d\n",1081 __FUNCTION__, (uint32_t)hal_get_ cycles() );989 printk("\n[DBG] %s : exit barrier 2 : PIC initialised / sr %x / cycle %d\n", 990 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1082 991 #endif 1083 992 … … 1104 1013 1105 1014 ///////////////////////////////////////////////////////////////////////////////// 1106 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1107 cluster_info_nb_actives(info->cluster_info) );1015 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1016 (info->x_size * info->y_size) ); 1108 1017 barrier_wait( &local_barrier , info->cores_nr ); 1109 1018 ///////////////////////////////////////////////////////////////////////////////// … … 1111 1020 #if DEBUG_KERNEL_INIT 1112 1021 if( (core_lid == 0) & (local_cxy == 0) ) 1113 printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / cycle %d\n",1114 __FUNCTION__, (uint32_t)hal_get_ cycles() );1022 printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / sr %x / cycle %d\n", 1023 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1115 1024 #endif 1116 1025 … … 1127 1036 ///////////////////////////////////////////////////////////////////////////////// 1128 1037 1129 // All cores enable the shared IPI channel1038 // All cores enable IPI 1130 1039 dev_pic_enable_ipi(); 1131 1040 hal_enable_irq( &status ); 1132 1133 #if DEBUG_KERNEL_INIT1134 printk("\n[DBG] %s: IPI enabled for core %d cluster %d\n", __FUNCTION__,1135 core_lid, local_cxy);1136 #endif1137 1041 1138 1042 // all cores initialize the idle thread descriptor … … 1163 1067 fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc(); 1164 1068 1165 assert( (fatfs_ctx != NULL) , 1166 "cannot create FATFS context in cluster 0\n" ); 1069 if( fatfs_ctx == NULL ) 1070 printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n", 1071 __FUNCTION__ ); 1167 1072 1168 1073 // 2. access boot device to initialize FATFS context … … 1175 1080 uint32_t total_clusters = fatfs_ctx->fat_sectors_count << 7; 1176 1081 1177 // 4. create VFS root inode in cluster 0 1082 // 4. initialize the FATFS entry in the vfs_context[] array 1083 vfs_ctx_init( FS_TYPE_FATFS, // fs type 1084 0, // attributes: unused 1085 total_clusters, 1086 cluster_size, 1087 vfs_root_inode_xp, // VFS root 1088 fatfs_ctx ); // extend 1089 1090 // 5. create VFS root inode in cluster 0 1178 1091 error = vfs_inode_create( XPTR_NULL, // dentry_xp 1179 1092 FS_TYPE_FATFS, // fs_type … … 1185 1098 0, // gid 1186 1099 &vfs_root_inode_xp ); // return 1187 1188 assert( (error == 0) , 1189 "cannot create VFS root inode\n" ); 1190 1191 // 5. initialize VFS context for FAT in cluster 0 1192 vfs_ctx_init( FS_TYPE_FATFS, // file system type 1193 0, // attributes 1194 total_clusters, 1195 cluster_size, 1196 vfs_root_inode_xp, // VFS root 1197 fatfs_ctx ); // extend 1198 1199 // 6. check initialisation 1100 if( error ) 1101 printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n", 1102 __FUNCTION__ ); 1103 1104 // 6. update the FATFS entry in vfs_context[] array 1105 fs_context[FS_TYPE_FATFS].vfs_root_xp = vfs_root_inode_xp; 1106 1107 // 7. check FATFS initialization 1200 1108 vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS]; 1201 assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8), 1202 "illegal value for FATFS context in cluster %x\n", local_cxy ); 1109 1110 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__ ); 1203 1113 } 1204 1114 else 1205 1115 { 1206 assert( false,1207 "root FS must be FATFS");1116 printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n", 1117 __FUNCTION__ ); 1208 1118 } 1209 1119 … … 1214 1124 1215 1125 ///////////////////////////////////////////////////////////////////////////////// 1216 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1217 cluster_info_nb_actives(info->cluster_info) );1126 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1127 (info->x_size * info->y_size) ); 1218 1128 barrier_wait( &local_barrier , info->cores_nr ); 1219 1129 ///////////////////////////////////////////////////////////////////////////////// … … 1221 1131 #if DEBUG_KERNEL_INIT 1222 1132 if( (core_lid == 0) & (local_cxy == 0) ) 1223 printk("\n[DBG] %s : exit barrier 4 : VFS _root = %l in cluster 0/ cycle %d\n",1224 __FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());1133 printk("\n[DBG] %s : exit barrier 4 : VFS root initialized in cluster 0 / sr %x / cycle %d\n", 1134 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1225 1135 #endif 1226 1136 … … 1241 1151 fatfs_ctx_t * local_fatfs_ctx = fatfs_ctx_alloc(); 1242 1152 1243 assert( (local_fatfs_ctx != NULL) , 1244 "cannot create FATFS context in cluster %x\n", local_cxy ); 1153 // check memory 1154 if( local_fatfs_ctx == NULL ) 1155 printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n", 1156 __FUNCTION__ , local_cxy ); 1245 1157 1246 1158 // 2. get local pointer on VFS context for FATFS … … 1261 1173 vfs_ctx->extend = local_fatfs_ctx; 1262 1174 1263 // 7. check initialisation1264 assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),1265 "illegal value for FATFS context in cluster %x\n", local_cxy );1175 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 ); 1266 1178 } 1267 1179 1268 1180 // get extended pointer on VFS root inode from cluster 0 1269 vfs_root_inode_xp = hal_remote_l wd( XPTR( 0 , &process_zero.vfs_root_xp ) );1181 vfs_root_inode_xp = hal_remote_l64( XPTR( 0 , &process_zero.vfs_root_xp ) ); 1270 1182 1271 1183 // update local process_zero descriptor … … 1275 1187 1276 1188 ///////////////////////////////////////////////////////////////////////////////// 1277 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1278 cluster_info_nb_actives(info->cluster_info) );1189 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1190 (info->x_size * info->y_size) ); 1279 1191 barrier_wait( &local_barrier , info->cores_nr ); 1280 1192 ///////////////////////////////////////////////////////////////////////////////// 1281 1193 1282 1194 #if DEBUG_KERNEL_INIT 1283 if( (core_lid == 0) & (local_cxy == 0) )1284 printk("\n[DBG] %s : exit barrier 5 : VFS _root = %l in cluster 0/ cycle %d\n",1285 __FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());1286 #endif 1287 1288 ///////////////////////////////////////////////////////////////////////////////// 1289 // STEP 6 : CP0 in cluster IOmakes the global DEVFS tree initialisation:1290 // It creates the DEVFS directory "dev", and the DEVFS "external"1291 // directory in cluster IO and mount these inodes into VFS.1292 ///////////////////////////////////////////////////////////////////////////////// 1293 1294 if( (core_lid == 0) && (local_cxy == 0) ) // [FIXME]1195 if( (core_lid == 0) & (local_cxy == 1) ) 1196 printk("\n[DBG] %s : exit barrier 5 : VFS root initialized in cluster 1 / sr %x / cycle %d\n", 1197 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1198 #endif 1199 1200 ///////////////////////////////////////////////////////////////////////////////// 1201 // STEP 6 : CP0 in cluster 0 makes the global DEVFS tree initialisation: 1202 // It initializes the DEVFS context, and creates the DEVFS 1203 // "dev" and "external" inodes in cluster 0. 1204 ///////////////////////////////////////////////////////////////////////////////// 1205 1206 if( (core_lid == 0) && (local_cxy == 0) ) 1295 1207 { 1296 // create "dev" and "external" directories. 1208 // 1. allocate memory for DEVFS context extension in cluster 0 1209 devfs_ctx_t * devfs_ctx = devfs_ctx_alloc(); 1210 1211 if( devfs_ctx == NULL ) 1212 printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n", 1213 __FUNCTION__ , local_cxy ); 1214 1215 // 2. initialize the DEVFS entry in the vfs_context[] array 1216 vfs_ctx_init( FS_TYPE_DEVFS, // fs type 1217 0, // attributes: unused 1218 0, // total_clusters: unused 1219 0, // cluster_size: unused 1220 vfs_root_inode_xp, // VFS root 1221 devfs_ctx ); // extend 1222 1223 // 3. create "dev" and "external" inodes (directories) 1297 1224 devfs_global_init( process_zero.vfs_root_xp, 1298 1225 &devfs_dev_inode_xp, 1299 1226 &devfs_external_inode_xp ); 1300 1227 1301 // creates the DEVFS context in cluster IO 1302 devfs_ctx_t * devfs_ctx = devfs_ctx_alloc(); 1303 1304 assert( (devfs_ctx != NULL) , 1305 "cannot create DEVFS context in cluster IO\n"); 1306 1307 // register DEVFS root and external directories 1308 devfs_ctx_init( devfs_ctx, devfs_dev_inode_xp, devfs_external_inode_xp ); 1228 // 4. initializes DEVFS context extension 1229 devfs_ctx_init( devfs_ctx, 1230 devfs_dev_inode_xp, 1231 devfs_external_inode_xp ); 1309 1232 } 1310 1233 1311 1234 ///////////////////////////////////////////////////////////////////////////////// 1312 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1313 cluster_info_nb_actives(info->cluster_info) );1235 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1236 (info->x_size * info->y_size) ); 1314 1237 barrier_wait( &local_barrier , info->cores_nr ); 1315 1238 ///////////////////////////////////////////////////////////////////////////////// … … 1317 1240 #if DEBUG_KERNEL_INIT 1318 1241 if( (core_lid == 0) & (local_cxy == 0) ) 1319 printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0/ cycle %d\n",1320 __FUNCTION__, devfs_dev_inode_xp, (uint32_t)hal_get_cycles() );1242 printk("\n[DBG] %s : exit barrier 6 : DEVFS root initialized in cluster 0 / sr %x / cycle %d\n", 1243 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1321 1244 #endif 1322 1245 … … 1324 1247 // STEP 7 : All CP0s complete in parallel the DEVFS tree initialization. 1325 1248 // Each CP0 get the "dev" and "external" extended pointers from 1326 // values stored in cluster IO.1327 // Then each CP0 in cluster(i) creates the DEVFS "internal directory,1249 // values stored in cluster 0. 1250 // Then each CP0 in cluster(i) creates the DEVFS "internal" directory, 1328 1251 // and creates the pseudo-files for all chdevs in cluster (i). 1329 1252 ///////////////////////////////////////////////////////////////////////////////// … … 1331 1254 if( core_lid == 0 ) 1332 1255 { 1333 // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO1334 xptr_t extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend ); // [FIXME]1256 // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0 1257 xptr_t extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend ); 1335 1258 1336 1259 // get pointer on DEVFS context in cluster 0 1337 1260 devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp ); 1338 1261 1339 devfs_dev_inode_xp = hal_remote_l wd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );1340 devfs_external_inode_xp = hal_remote_l wd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );1262 devfs_dev_inode_xp = hal_remote_l64( XPTR( 0 , &devfs_ctx->dev_inode_xp ) ); 1263 devfs_external_inode_xp = hal_remote_l64( XPTR( 0 , &devfs_ctx->external_inode_xp ) ); 1341 1264 1342 1265 // populate DEVFS in all clusters … … 1347 1270 1348 1271 ///////////////////////////////////////////////////////////////////////////////// 1349 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1350 cluster_info_nb_actives(info->cluster_info) );1272 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1273 (info->x_size * info->y_size) ); 1351 1274 barrier_wait( &local_barrier , info->cores_nr ); 1352 1275 ///////////////////////////////////////////////////////////////////////////////// … … 1354 1277 #if DEBUG_KERNEL_INIT 1355 1278 if( (core_lid == 0) & (local_cxy == 0) ) 1356 printk("\n[DBG] %s : exit barrier 7 : dev_root = %l in cluster 0/ cycle %d\n",1357 __FUNCTION__, devfs_dev_inode_xp, (uint32_t)hal_get_cycles() );1279 printk("\n[DBG] %s : exit barrier 7 : DEV initialized in cluster 0 / sr %x / cycle %d\n", 1280 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1358 1281 #endif 1359 1282 … … 1373 1296 1374 1297 ///////////////////////////////////////////////////////////////////////////////// 1375 if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]1376 cluster_info_nb_actives(info->cluster_info) );1298 if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 1299 (info->x_size * info->y_size) ); 1377 1300 barrier_wait( &local_barrier , info->cores_nr ); 1378 1301 ///////////////////////////////////////////////////////////////////////////////// … … 1380 1303 #if DEBUG_KERNEL_INIT 1381 1304 if( (core_lid == 0) & (local_cxy == 0) ) 1382 printk("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n",1383 __FUNCTION__ 1305 printk("\n[DBG] %s : exit barrier 8 : process init created / sr %x / cycle %d\n", 1306 __FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() ); 1384 1307 #endif 1385 1308 1386 1309 #if (DEBUG_KERNEL_INIT & 1) 1387 if( (core_lid == 0) /*& (local_cxy == 0)*/)1310 if( (core_lid == 0) & (local_cxy == 0) ) 1388 1311 sched_display( 0 ); 1389 1312 #endif … … 1393 1316 ///////////////////////////////////////////////////////////////////////////////// 1394 1317 1395 if( (core_lid == 0) && (local_cxy == 0) ) // [FIXME]1318 if( (core_lid == 0) && (local_cxy == 0) ) 1396 1319 { 1397 1320 print_banner( (info->x_size * info->y_size) , info->cores_nr ); … … 1415 1338 " - list item : %d bytes\n" 1416 1339 " - xlist item : %d bytes\n" 1417 " - spinlock : %d bytes\n" 1418 " - remote spinlock : %d bytes\n" 1340 " - busylock : %d bytes\n" 1341 " - remote busylock : %d bytes\n" 1342 " - queuelock : %d bytes\n" 1343 " - remote queuelock : %d bytes\n" 1419 1344 " - rwlock : %d bytes\n" 1420 1345 " - remote rwlock : %d bytes\n", 1421 sizeof( thread_t ), 1422 sizeof( process_t ), 1423 sizeof( cluster_t ), 1424 sizeof( chdev_t ), 1425 sizeof( core_t ), 1426 sizeof( scheduler_t ), 1427 sizeof( remote_fifo_t ), 1428 sizeof( page_t ), 1429 sizeof( mapper_t ), 1430 sizeof( ppm_t ), 1431 sizeof( kcm_t ), 1432 sizeof( khm_t ), 1433 sizeof( vmm_t ), 1434 sizeof( gpt_t ), 1435 sizeof( list_entry_t ), 1436 sizeof( xlist_entry_t ), 1437 sizeof( spinlock_t ), 1438 sizeof( remote_spinlock_t ), 1439 sizeof( rwlock_t ), 1440 sizeof( remote_rwlock_t )); 1346 sizeof( thread_t ), 1347 sizeof( process_t ), 1348 sizeof( cluster_t ), 1349 sizeof( chdev_t ), 1350 sizeof( core_t ), 1351 sizeof( scheduler_t ), 1352 sizeof( remote_fifo_t ), 1353 sizeof( page_t ), 1354 sizeof( mapper_t ), 1355 sizeof( ppm_t ), 1356 sizeof( kcm_t ), 1357 sizeof( khm_t ), 1358 sizeof( vmm_t ), 1359 sizeof( gpt_t ), 1360 sizeof( list_entry_t ), 1361 sizeof( xlist_entry_t ), 1362 sizeof( busylock_t ), 1363 sizeof( remote_busylock_t ), 1364 sizeof( queuelock_t ), 1365 sizeof( remote_queuelock_t ), 1366 sizeof( rwlock_t ), 1367 sizeof( remote_rwlock_t )); 1441 1368 #endif 1442 1369
Note: See TracChangeset
for help on using the changeset viewer.
