Changeset 580 for trunk/kernel
- Timestamp:
- Oct 8, 2018, 11:31:42 AM (6 years ago)
- Location:
- trunk/kernel
- Files:
-
- 11 edited
-
kern/cluster.c (modified) (1 diff)
-
kern/kernel_init.c (modified) (18 diffs)
-
kern/process.c (modified) (9 diffs)
-
kern/thread.c (modified) (7 diffs)
-
kern/thread.h (modified) (1 diff)
-
kernel_config.h (modified) (2 diffs)
-
libk/busylock.c (modified) (3 diffs)
-
libk/remote_busylock.c (modified) (3 diffs)
-
mm/vmm.c (modified) (1 diff)
-
syscalls/shared_include/shared_almos.h (modified) (1 diff)
-
syscalls/sys_display.c (modified) (12 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/kernel/kern/cluster.c
r564 r580 200 200 cluster->pmgr.pref_nr = 0; 201 201 cluster->pmgr.pref_tbl[0] = XPTR( local_cxy , &process_zero ); 202 for( lpid = 1; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ )202 for( lpid = 0 ; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ ) 203 203 { 204 204 cluster->pmgr.pref_tbl[lpid] = XPTR_NULL; -
trunk/kernel/kern/kernel_init.c
r577 r580 375 375 // check channels 376 376 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 } 378 382 379 383 // create chdev in local cluster … … 386 390 // check memory 387 391 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 } 389 397 390 398 // make MMC specific initialisation … … 427 435 // check memory 428 436 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 } 430 442 431 443 // make DMA specific initialisation … … 503 515 // check PIC device initialized 504 516 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 } 506 522 507 523 // check external device functionnal type 508 524 if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) && 509 525 (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 } 511 531 512 532 // loops on channels … … 548 568 549 569 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 } 552 575 553 576 // make device type specific initialisation … … 646 669 // check PIC existence 647 670 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 } 649 676 650 677 // allocate and initialize the PIC chdev in cluster 0 … … 657 684 // check memory 658 685 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 } 660 691 661 692 // make PIC device type specific initialisation … … 723 754 else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel]; 724 755 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 } 726 762 727 763 // set one entry in all "iopic_input" structures … … 814 850 if ( func == DEV_FUNC_MMC ) lapic_input.mmc = id; 815 851 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 } 817 858 } 818 859 } … … 939 980 // all cores check identifiers 940 981 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 } 943 987 944 988 // CP0 initializes cluster manager complex structures … … 948 992 949 993 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 } 952 999 } 953 1000 … … 1068 1115 1069 1116 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 } 1072 1122 1073 1123 // 2. access boot device to initialize FATFS context … … 1099 1149 &vfs_root_inode_xp ); // return 1100 1150 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 } 1103 1156 1104 1157 // 6. update the FATFS entry in vfs_context[] array … … 1109 1162 1110 1163 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 1113 1170 } 1114 1171 else … … 1116 1173 printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n", 1117 1174 __FUNCTION__ ); 1175 hal_core_sleep(); 1118 1176 } 1119 1177 … … 1153 1211 // check memory 1154 1212 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 } 1157 1218 1158 1219 // 2. get local pointer on VFS context for FATFS … … 1174 1235 1175 1236 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 } 1178 1242 } 1179 1243 … … 1210 1274 1211 1275 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 } 1214 1281 1215 1282 // 2. initialize the DEVFS entry in the vfs_context[] array -
trunk/kernel/kern/process.c
r564 r580 112 112 cxy_t chdev_cxy; 113 113 pid_t parent_pid; 114 lpid_t process_lpid; 115 lpid_t parent_lpid; 114 116 115 117 // get parent process cluster and local pointer … … 119 121 // get parent_pid 120 122 parent_pid = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) ); 123 124 // get process and parent lpid 125 process_lpid = LPID_FROM_PID( pid ); 126 parent_lpid = LPID_FROM_PID( parent_pid ); 121 127 122 128 #if DEBUG_PROCESS_REFERENCE_INIT … … 150 156 151 157 // define the stdin/stdout/stderr pseudo files <=> select a TXT terminal. 152 if( (pid == 1) || (parent_pid == 1)) // INIT or KSH process 158 if( (process_lpid == 1) || // INIT process 159 (parent_lpid == 1) ) // KSH process 153 160 { 154 161 // allocate a TXT channel 155 if( p id == 1 ) txt_id = 0; // INIT156 else txt_id = process_txt_alloc(); // KSH162 if( process_lpid == 1 ) txt_id = 0; // INIT 163 else txt_id = process_txt_alloc(); // KSH 157 164 158 165 // attach process to TXT … … 1487 1494 void process_zero_create( process_t * process ) 1488 1495 { 1496 error_t error; 1497 pid_t pid; 1489 1498 1490 1499 #if DEBUG_PROCESS_ZERO_CREATE … … 1495 1504 #endif 1496 1505 1506 // get PID from local cluster manager for this kernel process 1507 error = cluster_pid_alloc( process , &pid ); 1508 1509 if( error || (LPID_FROM_PID( pid ) != 0) ) 1510 { 1511 printk("\n[PANIC] in %s : cannot get valid PID in cluster %x / PID = %x\n", 1512 __FUNCTION__ , local_cxy, pid ); 1513 hal_core_sleep(); 1514 } 1515 1497 1516 // initialize PID, REF_XP, PARENT_XP, and STATE 1498 process->pid = 0; 1517 // the kernel process_zero is its own parent_process, 1518 // reference_process, and owner_process, and cannot be killed... 1519 process->pid = pid; 1499 1520 process->ref_xp = XPTR( local_cxy , process ); 1500 1521 process->owner_xp = XPTR( local_cxy , process ); 1501 process->parent_xp = XPTR _NULL;1522 process->parent_xp = XPTR( local_cxy , process ); 1502 1523 process->term_state = 0; 1503 1524 … … 1518 1539 LOCK_PROCESS_CHILDREN ); 1519 1540 1541 // register kernel process in cluster manager local_list 1542 cluster_process_local_link( process ); 1543 1520 1544 hal_fence(); 1521 1545 … … 1686 1710 pid_t pid; 1687 1711 pid_t ppid; 1712 lpid_t lpid; 1688 1713 uint32_t state; 1689 1714 uint32_t th_nr; … … 1707 1732 process_cxy = GET_CXY( process_xp ); 1708 1733 1709 // get PIDand state1734 // get process PID, LPID, and state 1710 1735 pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) ); 1736 lpid = LPID_FROM_PID( pid ); 1711 1737 state = hal_remote_l32( XPTR( process_cxy , &process_ptr->term_state ) ); 1712 1738 1713 // get PPID1739 // get process PPID 1714 1740 parent_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) ); 1715 1741 parent_cxy = GET_CXY( parent_xp ); … … 1725 1751 owner_ptr = GET_PTR( owner_xp ); 1726 1752 1727 // get extended pointer on TXT_RX file descriptor attached to process 1728 txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) ); 1729 1730 assert( (txt_file_xp != XPTR_NULL) , 1731 "process must be attached to one TXT terminal\n" ); 1732 1733 // get TXT_RX chdev pointers 1734 txt_chdev_xp = chdev_from_file( txt_file_xp ); 1735 txt_chdev_cxy = GET_CXY( txt_chdev_xp ); 1736 txt_chdev_ptr = GET_PTR( txt_chdev_xp ); 1737 1738 // get TXT_RX name and ownership 1739 hal_remote_strcpy( XPTR( local_cxy , txt_name ) , 1740 XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) ); 1753 // get process TXT name and .elf name 1754 if( lpid ) // user process 1755 { 1756 1757 // get extended pointer on file descriptor associated to TXT_RX 1758 txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) ); 1759 1760 assert( (txt_file_xp != XPTR_NULL) , 1761 "process must be attached to one TXT terminal\n" ); 1762 1763 // get TXT_RX chdev pointers 1764 txt_chdev_xp = chdev_from_file( txt_file_xp ); 1765 txt_chdev_cxy = GET_CXY( txt_chdev_xp ); 1766 txt_chdev_ptr = GET_PTR( txt_chdev_xp ); 1767 1768 // get TXT_RX name and ownership 1769 hal_remote_strcpy( XPTR( local_cxy , txt_name ) , 1770 XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) ); 1741 1771 1742 txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy, 1743 &txt_chdev_ptr->ext.txt.owner_xp ) ); 1744 1745 // get process .elf name 1746 elf_file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) ); 1747 elf_file_cxy = GET_CXY( elf_file_xp ); 1748 elf_file_ptr = (vfs_file_t *)GET_PTR( elf_file_xp ); 1749 elf_inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( elf_file_cxy , &elf_file_ptr->inode ) ); 1750 vfs_inode_get_name( XPTR( elf_file_cxy , elf_inode_ptr ) , elf_name ); 1772 txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy, 1773 &txt_chdev_ptr->ext.txt.owner_xp ) ); 1774 1775 // get process .elf name 1776 elf_file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) ); 1777 elf_file_cxy = GET_CXY( elf_file_xp ); 1778 elf_file_ptr = GET_PTR( elf_file_xp ); 1779 elf_inode_ptr = hal_remote_lpt( XPTR( elf_file_cxy , &elf_file_ptr->inode ) ); 1780 vfs_inode_get_name( XPTR( elf_file_cxy , elf_inode_ptr ) , elf_name ); 1781 } 1782 else // kernel process_zero 1783 { 1784 // TXT name and .elf name are not registered in kernel process_zero 1785 strcpy( txt_name , "txt0_rx" ); 1786 txt_owner_xp = process_xp; 1787 strcpy( elf_name , "kernel.elf" ); 1788 } 1751 1789 1752 1790 // display process info -
trunk/kernel/kern/thread.c
r564 r580 1216 1216 xptr_t lock_xp; // extended pointer on lock protecting this list 1217 1217 1218 #if DEBUG_THREAD_GET_XPTR 1219 uint32_t cycle = (uint32_t)hal_get_cycles(); 1220 thread_t * this = CURRENT_THREAD; 1221 if( DEBUG_THREAD_GET_XPTR < cycle ) 1222 printk("\n[DBG] %s : thread %x in process %x enters / pid %x / trdid %x / cycle %d\n", 1223 __FUNCTION__, this->trdid, this->process->pid, pid, trdid, cycle ); 1224 #endif 1225 1218 1226 // get target cluster identifier and local thread identifier 1219 1227 target_cxy = CXY_FROM_TRDID( trdid ); … … 1235 1243 remote_queuelock_acquire( lock_xp ); 1236 1244 1245 #if( DEBUG_THREAD_GET_XPTR & 1 ) 1246 if( DEBUG_THREAD_GET_XPTR < cycle ) 1247 printk("\n[DBG] %s : scan processes in cluster %x :\n", __FUNCTION__, target_cxy ); 1248 #endif 1249 1237 1250 // scan the list of local processes in target cluster 1238 1251 xptr_t iter; … … 1243 1256 target_process_ptr = GET_PTR( target_process_xp ); 1244 1257 target_process_pid = hal_remote_l32( XPTR( target_cxy , &target_process_ptr->pid ) ); 1258 1259 #if( DEBUG_THREAD_GET_XPTR & 1 ) 1260 if( DEBUG_THREAD_GET_XPTR < cycle ) 1261 printk(" - process %x\n", target_process_pid ); 1262 #endif 1263 1245 1264 if( target_process_pid == pid ) 1246 1265 { … … 1254 1273 1255 1274 // check PID found 1256 if( found == false ) return XPTR_NULL; 1275 if( found == false ) 1276 { 1277 1278 #if( DEBUG_THREAD_GET_XPTR & 1 ) 1279 if( DEBUG_THREAD_GET_XPTR < cycle ) 1280 printk("\n[DBG] %s : pid %x not found in cluster %x\n", 1281 __FUNCTION__, pid, target_cxy ); 1282 #endif 1283 return XPTR_NULL; 1284 } 1257 1285 1258 1286 // get target thread local pointer … … 1260 1288 target_thread_ptr = (thread_t *)hal_remote_lpt( xp ); 1261 1289 1262 if( target_thread_ptr == NULL ) return XPTR_NULL; 1290 if( target_thread_ptr == NULL ) 1291 { 1292 1293 #if( DEBUG_THREAD_GET_XPTR & 1 ) 1294 if( DEBUG_THREAD_GET_XPTR < cycle ) 1295 printk("\n[DBG] %s : thread %x not registered in process %x in cluster %x\n", 1296 __FUNCTION__, trdid, pid, target_cxy ); 1297 #endif 1298 return XPTR_NULL; 1299 } 1300 1301 #if DEBUG_THREAD_GET_XPTR 1302 cycle = (uint32_t)hal_get_cycles(); 1303 if( DEBUG_THREAD_GET_XPTR < cycle ) 1304 printk("\n[DBG] %s : thread %x in process %x exit / pid %x / trdid %x / cycle %d\n", 1305 __FUNCTION__, this->trdid, this->process->pid, pid, trdid, cycle ); 1306 #endif 1263 1307 1264 1308 return XPTR( target_cxy , target_thread_ptr ); … … 1287 1331 // display error message on TXT0 1288 1332 nolock_printk("\n[PANIC] in %s / thread %x in process %x [%x] cannot yield : " 1289 " %d busylock(s) / cycle %d\n",1333 "hold %d busylock(s) / cycle %d\n", 1290 1334 func_str, thread->trdid, thread->process->pid, thread, 1291 1335 thread->busylocks, (uint32_t)hal_get_cycles() ); 1292 1336 1293 1337 #if DEBUG_BUSYLOCK 1294 if( XPTR( local_cxy , thread ) == DEBUG_BUSYLOCK_THREAD_XP ) 1295 { 1296 // get root of list of taken busylocks 1297 xptr_t root_xp = XPTR( local_cxy , &thread->busylocks_root ); 1298 xptr_t iter_xp; 1299 1300 // scan list of busylocks 1301 XLIST_FOREACH( root_xp , iter_xp ) 1302 { 1303 xptr_t lock_xp = XLIST_ELEMENT( iter_xp , busylock_t , xlist ); 1304 cxy_t lock_cxy = GET_CXY( lock_xp ); 1305 busylock_t * lock_ptr = GET_PTR( lock_xp ); 1306 uint32_t lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) ); 1307 nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy ); 1308 } 1338 1339 // get root of list of taken busylocks 1340 xptr_t root_xp = XPTR( local_cxy , &thread->busylocks_root ); 1341 xptr_t iter_xp; 1342 1343 // scan list of busylocks 1344 XLIST_FOREACH( root_xp , iter_xp ) 1345 { 1346 xptr_t lock_xp = XLIST_ELEMENT( iter_xp , busylock_t , xlist ); 1347 cxy_t lock_cxy = GET_CXY( lock_xp ); 1348 busylock_t * lock_ptr = GET_PTR( lock_xp ); 1349 uint32_t lock_type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) ); 1350 nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy ); 1309 1351 } 1352 1310 1353 #endif 1311 1354 … … 1318 1361 } // end thread_assert_can yield() 1319 1362 1320 #if DEBUG_BUSYLOCK 1321 1322 //////////////////////////////////////////////////// 1323 void thread_display_busylocks( uint32_t lock_type, 1324 bool_t is_acquire ) 1325 { 1326 xptr_t iter_xp; 1327 1328 // get cluster and local pointer of target thread 1329 cxy_t thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP ); 1330 thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP ); 1331 1332 // get extended pointer on root of busylocks 1333 xptr_t root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root ); 1334 1335 // get pointers on TXT0 chdev 1336 xptr_t txt0_xp = chdev_dir.txt_tx[0]; 1337 cxy_t txt0_cxy = GET_CXY( txt0_xp ); 1338 chdev_t * txt0_ptr = GET_PTR( txt0_xp ); 1339 1340 // get extended pointer on remote TXT0 lock 1341 xptr_t txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock ); 1342 1343 // get TXT0 lock 1344 remote_busylock_acquire( txt0_lock_xp ); 1345 1346 if( is_acquire ) 1347 { 1348 nolock_printk("\n### thread [%x,%x] ACQUIRE lock %s / root %x / locks :\n", 1349 thread_cxy, thread_ptr, lock_type_str[lock_type], GET_PTR(root_xp) ); 1363 ////////////////////////////////////////////////// 1364 void thread_display_busylocks( xptr_t thread_xp ) 1365 { 1366 if( DEBUG_BUSYLOCK ) 1367 { 1368 xptr_t iter_xp; 1369 1370 // get cluster and local pointer of target thread 1371 cxy_t thread_cxy = GET_CXY( thread_xp ); 1372 thread_t * thread_ptr = GET_PTR( thread_xp ); 1373 1374 // get target thread TRDID and busylocks 1375 trdid_t trdid = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->trdid )); 1376 uint32_t locks = hal_remote_l32(XPTR( thread_cxy , &thread_ptr->busylocks )); 1377 1378 // get target thread process and PID; 1379 process_t * process = hal_remote_lpt(XPTR( thread_cxy , &thread_ptr->process )); 1380 pid_t pid = hal_remote_l32(XPTR( thread_cxy , &process->pid )); 1381 1382 // get extended pointer on root of busylocks 1383 xptr_t root_xp = XPTR( thread_cxy , &thread_ptr->busylocks_root ); 1384 1385 // get pointers on TXT0 chdev 1386 xptr_t txt0_xp = chdev_dir.txt_tx[0]; 1387 cxy_t txt0_cxy = GET_CXY( txt0_xp ); 1388 chdev_t * txt0_ptr = GET_PTR( txt0_xp ); 1389 1390 // get extended pointer on remote TXT0 lock 1391 xptr_t txt0_lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock ); 1392 1393 // get TXT0 lock 1394 remote_busylock_acquire( txt0_lock_xp ); 1395 1396 // display header 1397 nolock_printk("\n***** thread %x in process %x : %d busylocks at cycle %d\n", 1398 trdid, pid, locks, (uint32_t)hal_get_cycles() ); 1399 1400 // scan the xlist of busylocks when required 1401 if( locks ) 1402 { 1403 XLIST_FOREACH( root_xp , iter_xp ) 1404 { 1405 xptr_t lock_xp = XLIST_ELEMENT( iter_xp , busylock_t , xlist ); 1406 cxy_t lock_cxy = GET_CXY( lock_xp ); 1407 busylock_t * lock_ptr = GET_PTR( lock_xp ); 1408 uint32_t lock_type = hal_remote_l32(XPTR( lock_cxy , &lock_ptr->type )); 1409 nolock_printk(" - %s in cluster %x\n", lock_type_str[lock_type] , lock_cxy ); 1410 } 1411 } 1412 1413 // release TXT0 lock 1414 remote_busylock_release( txt0_lock_xp ); 1350 1415 } 1351 1416 else 1352 1417 { 1353 nolock_printk("\n### thread [%x,%x] RELEASE lock %s / root %x / locks :\n", 1354 thread_cxy, thread_ptr, lock_type_str[lock_type], GET_PTR(root_xp) ); 1355 } 1356 1357 int i; 1358 1359 XLIST_FOREACH( root_xp , iter_xp ) 1360 { 1361 xptr_t ilock_xp = XLIST_ELEMENT( iter_xp , busylock_t , xlist ); 1362 cxy_t ilock_cxy = GET_CXY( ilock_xp ); 1363 busylock_t * ilock_ptr = GET_PTR( ilock_xp ); 1364 uint32_t ilock_type = hal_remote_l32( XPTR( ilock_cxy , &ilock_ptr->type ) ); 1365 nolock_printk(" - %s in cluster %x\n", lock_type_str[ilock_type] , ilock_cxy ); 1366 } 1367 1368 // release TXT0 lock 1369 remote_busylock_release( txt0_lock_xp ); 1370 } 1371 #endif 1418 // display a warning 1419 printk("\n[WARNING] set the DEBUG_BUSYLOCK parmeter in kernel_config.h" 1420 " to use the %s function\n", __FUNCTION__ ); 1421 } 1422 } // end thread_display_busylock() -
trunk/kernel/kern/thread.h
r564 r580 467 467 468 468 /*************************************************************************************** 469 * This debug function display the list of busylocks currently owned by a thread 470 * identified by the DEBUG_BUSYLOCK_THREAD_XP parameter. 471 * It is called each time the target thread acquire or release a busylock 472 * (local or remote). It is never called when DEBUG_BUSYLOCK_THEAD_CP == 0. 473 *************************************************************************************** 474 * @ lock_type : type of acquired / released busylock. 475 * @ is_acquire : change is an acquire when true / change is a release when false. 476 **************************************************************************************/ 477 void thread_display_busylocks( uint32_t lock_type, 478 bool_t is_acquire ); 469 * This debug function display the list of busylocks (local or remote) currently owned 470 * by a thread identified by the <thread_xp> argument. 471 * WARNING : it can be called by the idbg tool, but the DEBUG_BUSYLOCK parameter 472 * must be set in the kernel_config.h file. 473 *************************************************************************************** 474 * @ thread_xp : extended pointer on target thread. 475 **************************************************************************************/ 476 void thread_display_busylocks( xptr_t thread_xp ); 479 477 480 478 -
trunk/kernel/kernel_config.h
r579 r580 175 175 #define DEBUG_THREAD_DELETE 0 176 176 #define DEBUG_THREAD_DESTROY 0 177 #define DEBUG_THREAD_GET_XPTR 1 177 178 #define DEBUG_THREAD_IDLE 0 178 179 #define DEBUG_THREAD_INIT 0 … … 336 337 //////////////////////////////////////////////////////////////////////////////////////////// 337 338 338 #define CONFIG_THREADS_MAX_PER_CLUSTER 16 // max threads per cluster &process339 #define CONFIG_THREADS_MAX_PER_CLUSTER 16 // max threads per cluster per process 339 340 #define CONFIG_THREAD_DESC_SIZE 0x4000 // thread desc size (with kernel stack) 340 341 #define CONFIG_THREAD_DESC_ORDER 2 // ln( number of 4K pages ) -
trunk/kernel/libk/busylock.c
r563 r580 77 77 #if DEBUG_BUSYLOCK 78 78 if( (lock->type != LOCK_CHDEV_TXT0) && 79 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&80 79 ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) ) 81 80 { … … 84 83 // update thread list of busylocks 85 84 xlist_add_last( root_xp , XPTR( local_cxy , &lock->xlist ) ); 85 } 86 #endif 86 87 87 // display list of taken locks for the selected thread 88 thread_display_busylocks( lock->type , true ); 88 #if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP ) 89 if( (lock->type != LOCK_CHDEV_TXT0) && 90 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) ) 91 { 92 // get cluster and local pointer of target thread 93 cxy_t thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP ); 94 thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP ); 95 96 // display message on kernel TXT0 97 printk("\n### thread [%x,%x] ACQUIRE lock %s\n", 98 thread_cxy, thread_ptr, lock_type_str[lock->type] ); 89 99 } 90 100 #endif … … 111 121 #if DEBUG_BUSYLOCK 112 122 if( (lock->type != LOCK_CHDEV_TXT0) && 113 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&114 123 ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) ) 115 124 { 116 125 // remove lock from thread list of busylocks 117 126 xlist_unlink( XPTR( local_cxy , &lock->xlist ) ); 127 } 128 #endif 118 129 119 // display list of taken locks for the selected thread 120 thread_display_busylocks( lock->type , false ); 130 #if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP ) 131 if( (lock->type != LOCK_CHDEV_TXT0) && 132 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) ) 133 { 134 // get cluster and local pointer of target thread 135 cxy_t thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP ); 136 thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP ); 137 138 // display message on kernel TXT0 139 printk("\n### thread [%x,%x] RELEASE lock %s\n", 140 thread_cxy, thread_ptr, lock_type_str[lock->type] ); 121 141 } 122 142 #endif -
trunk/kernel/libk/remote_busylock.c
r563 r580 88 88 uint32_t type = hal_remote_l32( XPTR( lock_cxy , &lock_ptr->type ) ); 89 89 if( (type != LOCK_CHDEV_TXT0) && 90 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) &&91 90 ((uint32_t)hal_get_cycles() > DEBUG_BUSYLOCK) ) 92 91 { … … 95 94 // update thread list of busyslocks 96 95 xlist_add_last( root_xp , XPTR( lock_cxy , &lock_ptr->xlist ) ); 96 } 97 #endif 97 98 98 // display busylocks for the selected thread (acquire) 99 thread_display_busylocks( type , true ); 99 #if( DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP ) 100 if( (type != LOCK_CHDEV_TXT0) && 101 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) ) 102 { 103 // get cluster and local pointer of target thread 104 cxy_t thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP ); 105 thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP ); 106 107 // display message on kernel TXT0 108 printk("\n### thread [%x,%x] ACQUIRE lock %s\n", 109 thread_cxy, thread_ptr, lock_type_str[type] ); 100 110 } 101 111 #endif … … 132 142 // remove lock from thread list of busyslocks 133 143 xlist_unlink( XPTR( lock_cxy , &lock_ptr->xlist ) ); 144 } 145 #endif 134 146 135 // display busylocks for the selected thread (release) 136 thread_display_busylocks( type , false ); 147 #if (DEBUG_BUSYLOCK && DEBUG_BUSYLOCK_THREAD_XP ) 148 if( (type != LOCK_CHDEV_TXT0) && 149 (XPTR( local_cxy , this ) == DEBUG_BUSYLOCK_THREAD_XP) ) 150 { 151 // get cluster and local pointer of target thread 152 cxy_t thread_cxy = GET_CXY( DEBUG_BUSYLOCK_THREAD_XP ); 153 thread_t * thread_ptr = GET_PTR( DEBUG_BUSYLOCK_THREAD_XP ); 154 155 // display message on kernel TXT0 156 printk("\n### thread [%x,%x] RELEASE lock %s\n", 157 thread_cxy, thread_ptr, lock_type_str[type] ); 137 158 } 138 159 #endif -
trunk/kernel/mm/vmm.c
r577 r580 78 78 vmm->vsegs_nr = 0; 79 79 xlist_root_init( XPTR( local_cxy , &vmm->vsegs_root ) ); 80 remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) ,LOCK_VMM_VSL );80 remote_rwlock_init( XPTR( local_cxy , &vmm->vsegs_lock ) , LOCK_VMM_VSL ); 81 81 82 82 assert( ((CONFIG_VMM_KENTRY_SIZE + CONFIG_VMM_ARGS_SIZE + CONFIG_VMM_ENVS_SIZE) -
trunk/kernel/syscalls/shared_include/shared_almos.h
r445 r580 51 51 DISPLAY_TXT_PROCESSES = 6, 52 52 DISPLAY_DQDT = 7, 53 DISPLAY_BUSYLOCKS = 8, 53 54 } 54 55 display_type_t; -
trunk/kernel/syscalls/sys_display.c
r506 r580 48 48 else if( type == DISPLAY_CHDEV ) return "CHDEV"; 49 49 else if( type == DISPLAY_TXT_PROCESSES ) return "TXT_PROCESSES"; 50 else if( type == DISPLAY_DQDT ) return "DQDT"; 51 else if( type == DISPLAY_BUSYLOCKS ) return "BUSYLOCKS"; 50 52 } 51 53 #endif … … 87 89 88 90 #if DEBUG_SYSCALLS_ERROR 89 printk("\n[ERROR] in %s : string buffer %x unmapped / thread %x / process %x\n",90 __FUNCTION__ , (intptr_t)arg0 , this->trdid , process->pid);91 printk("\n[ERROR] in %s for STRING : string buffer %x unmapped\n", 92 __FUNCTION__ , (intptr_t)arg0 ); 91 93 #endif 92 94 this->errno = EINVAL; … … 101 103 102 104 #if DEBUG_SYSCALLS_ERROR 103 printk("\n[ERROR] in %s : string length %d too large / thread %x / process %x\n",104 __FUNCTION__ , length , this->trdid , process->pid);105 printk("\n[ERROR] in %s for STRING : string length %d too large\n", 106 __FUNCTION__ , length ); 105 107 #endif 106 108 this->errno = EINVAL; … … 125 127 126 128 #if DEBUG_SYSCALLS_ERROR 127 printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process %x\n",128 __FUNCTION__ , cxy , this->trdid , process->pid);129 printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n", 130 __FUNCTION__ , pid , cxy ); 129 131 #endif 130 132 this->errno = EINVAL; … … 139 141 140 142 #if DEBUG_SYSCALLS_ERROR 141 printk("\n[ERROR] in %s : process %x in cluster %x not found / thread %x / process %x\n",142 __FUNCTION__ , pid , cxy , this->trdid , process->pid);143 printk("\n[ERROR] in %s for VMM : process %x in cluster %x not found\n", 144 __FUNCTION__ , pid , cxy ); 143 145 #endif 144 146 this->errno = EINVAL; … … 170 172 171 173 #if DEBUG_SYSCALLS_ERROR 172 printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process%x\n",173 __FUNCTION__ , cxy , this->trdid , process->pid);174 printk("\n[ERROR] in %s for SCHED : illegal cxy argument %x\n", 175 __FUNCTION__ , cxy ); 174 176 #endif 175 177 this->errno = EINVAL; … … 182 184 183 185 #if DEBUG_SYSCALLS_ERROR 184 printk("\n[ERROR] in %s : illegal lid argument %x / thread %x / process%x\n",185 __FUNCTION__ , lid , this->trdid , process->pid);186 printk("\n[ERROR] in %s for SCHED : illegal lid argument %x\n", 187 __FUNCTION__ , lid ); 186 188 #endif 187 189 this->errno = EINVAL; … … 208 210 209 211 #if DEBUG_SYSCALLS_ERROR 210 printk("\n[ERROR] in %s : illegal cxy argument %x / thread %x / process%x\n",211 __FUNCTION__ , cxy , this->trdid , process->pid);212 printk("\n[ERROR] in %s for CLUSTER_PROCESSES : illegal cxy argument %x\n", 213 __FUNCTION__ , cxy ); 212 214 #endif 213 215 this->errno = EINVAL; … … 216 218 217 219 cluster_processes_display( cxy ); 220 } 221 ////////////////////////////// 222 else if( type == DISPLAY_VFS ) 223 { 224 vfs_display( process->vfs_root_xp ); 225 } 226 //////////////////////////////// 227 else if( type == DISPLAY_CHDEV ) 228 { 229 chdev_dir_display(); 218 230 } 219 231 //////////////////////////////////////// … … 227 239 228 240 #if DEBUG_SYSCALLS_ERROR 229 printk("\n[ERROR] in %s : illegal txt_id argument %d / thread %x / process %x\n",230 __FUNCTION__ , txt_id , this->trdid , process->pid);241 printk("\n[ERROR] in %s for TXT_PROCESSES : illegal txt_id argument %d\n", 242 __FUNCTION__ , txt_id ); 231 243 #endif 232 244 this->errno = EINVAL; … … 236 248 process_txt_display( txt_id ); 237 249 } 238 ////////////////////////////// 239 else if( type == DISPLAY_VFS ) 240 { 241 vfs_display( process->vfs_root_xp ); 242 } 243 //////////////////////////////// 244 else if( type == DISPLAY_CHDEV ) 245 { 246 chdev_dir_display(); 247 } 248 //////////////////////////////// 250 /////////////////////////////// 249 251 else if( type == DISPLAY_DQDT ) 250 252 { 251 253 dqdt_display(); 254 } 255 //////////////////////////////////// 256 else if( type == DISPLAY_BUSYLOCKS ) 257 { 258 pid_t pid = (cxy_t)arg0; 259 trdid_t trdid = (trdid_t)arg1; 260 261 // get extended pointer on target thread 262 xptr_t thread_xp = thread_get_xptr( pid , trdid ); 263 264 if( thread_xp == XPTR_NULL ) 265 { 266 267 #if DEBUG_SYSCALLS_ERROR 268 printk("\n[ERROR] in %s for BUSYLOCKS : thread %x in process %x not found\n", 269 __FUNCTION__ , trdid , pid ); 270 #endif 271 this->errno = EINVAL; 272 return -1; 273 } 274 275 thread_display_busylocks( thread_xp ); 252 276 } 253 277 //// … … 256 280 257 281 #if DEBUG_SYSCALLS_ERROR 258 printk("\n[ERROR] in %s : undefined display type % x / thread %x / process %x\n",259 __FUNCTION__ , type , this->trdid , process->pid);282 printk("\n[ERROR] in %s : undefined display type %d\n", 283 __FUNCTION__ , type ); 260 284 #endif 261 285 this->errno = EINVAL;
Note: See TracChangeset
for help on using the changeset viewer.
