Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
3,600 | CWE-000 static int adu_open ( struct inode * inode , struct file * file ) { struct adu_device * dev = NULL ; struct usb_interface * interface ; int subminor ; int retval ; dbg ( 2 , "%s<S2SV_blank>:<S2SV_blank>enter" , __func__ ) ; subminor = iminor ( inode ) ; <S2SV_StartBug> if ( ( retval = mutex_lock_interruptible ( & adutux_mutex ) ) ) { <S2SV_EndBug> dbg ( 2 , "%s<S2SV_blank>:<S2SV_blank>mutex<S2SV_blank>lock<S2SV_blank>failed" , __func__ ) ; goto exit_no_lock ; } interface = usb_find_interface ( & adu_driver , subminor ) ; if ( ! interface ) { printk ( KERN_ERR "adutux:<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>error,<S2SV_blank>can\'t<S2SV_blank>find<S2SV_blank>device<S2SV_blank>for<S2SV_blank>" "minor<S2SV_blank>%d\\n" , __func__ , subminor ) ; retval = - ENODEV ; goto exit_no_device ; } dev = usb_get_intfdata ( interface ) ; if ( ! dev || ! dev -> udev ) { retval = - ENODEV ; goto exit_no_device ; } if ( dev -> open_count ) { retval = - EBUSY ; goto exit_no_device ; } ++ dev -> open_count ; dbg ( 2 , "%s<S2SV_blank>:<S2SV_blank>open<S2SV_blank>count<S2SV_blank>%d" , __func__ , dev -> open_count ) ; file -> private_data = dev ; dev -> read_buffer_length = 0 ; usb_fill_int_urb ( dev -> interrupt_in_urb , dev -> udev , usb_rcvintpipe ( dev -> udev , dev -> interrupt_in_endpoint -> bEndpointAddress ) , dev -> interrupt_in_buffer , usb_endpoint_maxp ( dev -> interrupt_in_endpoint ) , adu_interrupt_in_callback , dev , dev -> interrupt_in_endpoint -> bInterval ) ; dev -> read_urb_finished = 0 ; if ( usb_submit_urb ( dev -> interrupt_in_urb , GFP_KERNEL ) ) dev -> read_urb_finished = 1 ; dev -> out_urb_finished = 1 ; retval = 0 ; exit_no_device : mutex_unlock ( & adutux_mutex ) ; exit_no_lock : dbg ( 2 , "%s<S2SV_blank>:<S2SV_blank>leave,<S2SV_blank>return<S2SV_blank>value<S2SV_blank>%d<S2SV_blank>" , __func__ , retval ) ; return retval ; } | <S2SV_ModStart> inode ) ; <S2SV_ModEnd> retval = mutex_lock_interruptible <S2SV_ModStart> & adutux_mutex ) ; if ( retval <S2SV_ModEnd> ) { dbg |
3,601 | CWE-000 int rhizome_apply_announce_hook ( rhizome_manifest * m , struct subscriber * peer ) { if ( ! m -> active ) { return 0 ; } if ( strlen ( config . rhizome . announce_hook ) == 0 ) { return 1 ; } cache_t cache_elem ; cache_elem . announce . bundle_id = m -> keypair . public_key ; cache_elem . announce . sid = peer -> sid ; cache_t * cache_hit = cache_check ( announce_cache , & cache_elem . raw , sizeof ( sign_public_t ) + sizeof ( sid_t ) ) ; if ( cache_hit ) { <S2SV_StartBug> DEBUGF ( rhizome_hook , "Announce<S2SV_blank>hook<S2SV_blank>cache<S2SV_blank>hit,<S2SV_blank>sid:%s" , alloca_tohex_sid_t ( peer -> sid ) ) ; <S2SV_EndBug> return cache_hit -> announce . ret ; } cache_t * cache_new = malloc ( sizeof ( cache_t ) ) ; memcpy ( cache_new , & cache_elem , sizeof ( cache_t ) ) ; <S2SV_StartBug> DEBUGF ( rhizome_hook , "Announce<S2SV_blank>hook,<S2SV_blank>sid:%s" , alloca_tohex_sid_t ( peer -> sid ) ) ; <S2SV_EndBug> char * argv [ ] = { config . rhizome . announce_hook , ( char * ) m -> manifestdata , alloca_tohex_sid_t ( peer -> sid ) , "" , NULL } ; cache_new -> announce . ret = rhizome_excecute_hook_binary ( argv , TRUE ) ; cache_new -> timeout = time ( NULL ) + ANNOUNCE_CACHE_TIMEOUT_S ; cache_new -> prev = announce_cache ; announce_cache = cache_new ; return cache_new -> announce . ret ; } | <S2SV_ModStart> { DEBUGF ( rhizome_hooks <S2SV_ModEnd> , "Announce<S2SV_blank>hook<S2SV_blank>cache<S2SV_blank>hit,<S2SV_blank>sid:%s" , <S2SV_ModStart> ; DEBUGF ( rhizome_hooks <S2SV_ModEnd> , "Announce<S2SV_blank>hook,<S2SV_blank>sid:%s" , |
3,602 | CWE-000 void Rcv_Config ( ) { USART_Bind ( RCV_SIG_PIN , 0 , RCV_USART , RCV_USART_BR , RCV_USART_WL , <S2SV_StartBug> RCV_USART_PR , <S2SV_EndBug> RCV_USART_SB , RCV_USART_FC ) ; USART_DMACmd ( RCV_USART , USART_DMAReq_Rx , ENABLE ) ; DMA_Config ( RCV_DMA_STREAM , RCV_DMA_CHANNEL , ( u32 ) & RCV_USART -> DR , ( u32 ) buf [ 0 ] , 0 , RCV_DMA_BUF_SIZE ) ; DMA_DoubleBufferModeConfig ( RCV_DMA_STREAM , ( u32 ) buf [ 1 ] , DMA_Memory_0 ) ; DMA_DoubleBufferModeCmd ( RCV_DMA_STREAM , ENABLE ) ; DMA_Cmd ( RCV_DMA_STREAM , ENABLE ) ; NVIC_Config ( RCV_NVIC , RCV_NVIC_PRE_PRIORITY , RCV_NVIC_SUB_PRIORITY ) ; USART_ITConfig ( RCV_USART , USART_IT_IDLE , ENABLE ) ; USART_Cmd ( RCV_USART , ENABLE ) ; } | <S2SV_ModStart> , RCV_USART_WL , RCV_USART_PA <S2SV_ModEnd> , RCV_USART_SB , |
3,603 | CWE-000 SQLITE_PRIVATE int sqlite3BtreeDataSize ( BtCursor * pCur , u32 * pSize ) { assert ( cursorHoldsMutex ( pCur ) ) ; assert ( pCur -> eState == CURSOR_VALID ) ; <S2SV_StartBug> getCellInfo ( pCur ) ; <S2SV_EndBug> <S2SV_StartBug> * pSize = pCur -> info . nData ; <S2SV_EndBug> return SQLITE_OK ; } | <S2SV_ModStart> CURSOR_VALID ) ; assert ( pCur -> apPage [ pCur -> iPage ] -> intKeyLeaf == 1 ) ; <S2SV_ModStart> -> info . nPayload <S2SV_ModEnd> ; return SQLITE_OK |
3,604 | CWE-000 bool mgos_timezones_init ( void ) { if ( ! mgos_sys_config_get_timezone_enable ( ) ) { return true ; } <S2SV_StartBug> struct mbuf arch ; <S2SV_EndBug> const char * dataPath = mgos_sys_config_get_timezone_data_path ( ) ; dataPath = ( dataPath == NULL ) ? "" : dataPath ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>dataPath:<S2SV_blank><%s>" , ( char * ) dataPath ) ) ; const char * archFile = mgos_sys_config_get_timezone_arch_file ( ) ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>archFile:<S2SV_blank><%s>" , ( char * ) archFile ) ) ; <S2SV_StartBug> const char * olson = mgos_sys_config_get_timezone_olson ( ) ; <S2SV_EndBug> LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>olson:<S2SV_blank><%s>" , ( char * ) olson ) ) ; const char * groupFile = mgos_get_data_filename ( olson ) ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>groupFile:<S2SV_blank><%s>" , ( char * ) groupFile ) ) ; if ( mgos_file_exists ( ( char * ) archFile ) && strlen ( dataPath ) > 0 ) { LOG ( LL_DEBUG , ( "Moving<S2SV_blank><%s><S2SV_blank>to<S2SV_blank><%s><S2SV_blank>..." , ( char * ) archFile , ( char * ) dataPath ) ) ; mgos_file_move ( ( char * ) archFile , "" , ( char * ) dataPath ) ; } mgos_create_filepath ( & arch , ( char * ) dataPath , ( char * ) archFile ) ; LOG ( LL_DEBUG , ( "Try<S2SV_blank>to<S2SV_blank>open<S2SV_blank>ZIP<S2SV_blank>file<S2SV_blank><%s>" , ( char * ) arch . buf ) ) ; mgos_get_zipped_tz_data ( arch . buf , groupFile , true ) ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>is<S2SV_blank>set,<S2SV_blank>free<S2SV_blank>archive<S2SV_blank>buffer<S2SV_blank>..." ) ) ; mbuf_free ( & arch ) ; return true ; } | <S2SV_ModStart> true ; } LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>checking<S2SV_blank>for<S2SV_blank>key<S2SV_blank>..." ) ) ; if ( ! mgos_sys_config_get_timezone_olson ( ) ) { LOG ( LL_INFO , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>no<S2SV_blank>key<S2SV_blank>found!" ) ) ; return true ; } const char * olson = mgos_sys_config_get_timezone_olson ( ) ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>olson:<S2SV_blank><%s>" , ( char * ) olson ) ) <S2SV_ModEnd> ; const char <S2SV_ModStart> const char * groupFile = mgos_get_data_filename ( olson ) ; LOG ( LL_DEBUG , ( "Timezone<S2SV_blank>init<S2SV_blank>-<S2SV_blank>groupFile:<S2SV_blank><%s>" , ( char * ) groupFile ) ) ; struct mbuf arch <S2SV_ModEnd> ; if ( |
3,605 | CWE-000 int main ( int argc , char * argv [ ] ) { int erg ; char * s ; emoji_init ( ) ; <S2SV_StartBug> printf ( "ANIMATION<S2SV_blank>v%s<S2SV_blank>(build<S2SV_blank>%s)<S2SV_blank>%s<S2SV_blank>2010-2017<S2SV_blank>Oliver<S2SV_blank>Cordes\\n" , <S2SV_EndBug> VERSION , BUILD , _em [ _em_copyright ] ) ; s = get_amx_lang_version ( ) ; printf ( "<S2SV_blank>amx_lang_version=%s\\n" , s ) ; free ( s ) ; image_init ( argv [ 0 ] ) ; parse_options ( argc , argv ) ; project_init ( ) ; project_set_outputdir_string ( "." ) ; font_init ( ) ; imagedef_init ( conftab ) ; filldef_init ( ) ; random_init ( ) ; <S2SV_StartBug> ffmpeg_module_init ( ) ; <S2SV_EndBug> open_parser_source ( srcfile ) ; output ( 0 , "Parsing<S2SV_blank>file<S2SV_blank>...\\n" ) ; erg = yyparse ( ) ; fclose ( yyin ) ; output ( 0 , "Done.%s\\n" , _em [ _em_okay ] ) ; free ( srcfile ) ; if ( erg != 0 ) { fprintf ( stderr , "Parsing<S2SV_blank>not<S2SV_blank>successful!<S2SV_blank>Abort<S2SV_blank>Program!\\n" ) ; return 1 ; } erg = execute_check ( ) ; if ( erg == 0 ) { project_show ( ) ; } else { fprintf ( stderr , "Abort<S2SV_blank>program<S2SV_blank>due<S2SV_blank>to<S2SV_blank>configuration<S2SV_blank>errors!\\n" ) ; return 2 ; } if ( dry_run == 0 ) erg = execute_execute ( ) ; else printf ( "Dry<S2SV_blank>run<S2SV_blank>requested!\\n" ) ; <S2SV_StartBug> ffmpeg_module_done ( ) ; <S2SV_EndBug> filldef_done ( ) ; imagedef_done ( ) ; font_done ( ) ; project_done ( ) ; image_done ( ) ; if ( conftab != NULL ) { config_done ( conftab ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; ffmpeg_module_init ( ) ; <S2SV_ModStart> ( ) ; <S2SV_ModEnd> open_parser_source ( srcfile <S2SV_ModStart> "Dry<S2SV_blank>run<S2SV_blank>requested!\\n" ) ; <S2SV_ModEnd> filldef_done ( ) <S2SV_ModStart> ) ; } ffmpeg_module_done ( ) ; |
3,606 | CWE-000 static void smp2p_ut_local_gpio_in_update_open ( struct seq_file * s ) { int failed = 0 ; struct gpio_info * cb_info = & gpio_info [ SMP2P_REMOTE_MOCK_PROC ] . in ; int id ; int ret ; int virq ; struct msm_smp2p_remote_mock * mock ; seq_printf ( s , "Running<S2SV_blank>%s\\n" , __func__ ) ; cb_data_reset ( cb_info ) ; do { ret = smp2p_reset_mock_edge ( ) ; UT_ASSERT_INT ( ret , == , 0 ) ; mock = msm_smp2p_get_remote_mock ( ) ; UT_ASSERT_PTR ( mock , != , NULL ) ; mock -> rx_interrupt_count = 0 ; memset ( & mock -> remote_item , 0 , sizeof ( struct smp2p_smem_item ) ) ; smp2p_init_header ( ( struct smp2p_smem * ) & mock -> remote_item , SMP2P_REMOTE_MOCK_PROC , SMP2P_APPS_PROC , 0 , 1 ) ; strlcpy ( mock -> remote_item . entries [ 0 ] . name , "smp2p" , SMP2P_MAX_ENTRY_NAME ) ; SMP2P_SET_ENT_VALID ( <S2SV_StartBug> mock -> remote_item . header . valid_total_ent , 1 ) ; <S2SV_EndBug> smp2p_gpio_open_test_entry ( "smp2p" , SMP2P_REMOTE_MOCK_PROC , true ) ; UT_ASSERT_INT ( 0 , < , cb_info -> irq_base_id ) ; for ( id = 0 ; id < SMP2P_BITS_PER_ENTRY && ! failed ; ++ id ) { virq = cb_info -> irq_base_id + id ; UT_ASSERT_PTR ( NULL , != , irq_to_desc ( virq ) ) ; ret = request_irq ( virq , smp2p_gpio_irq , IRQ_TYPE_EDGE_BOTH , "smp2p_test" , cb_info ) ; UT_ASSERT_INT ( 0 , == , ret ) ; } if ( failed ) break ; mock -> remote_item . entries [ 0 ] . entry = 0xDEADDEAD ; msm_smp2p_set_remote_mock_exists ( true ) ; mock -> tx_interrupt ( ) ; for ( id = 0 ; id < SMP2P_BITS_PER_ENTRY && ! failed ; ++ id ) { virq = cb_info -> irq_base_id + id ; UT_ASSERT_INT ( cb_info -> cb_count , > , 0 ) ; if ( 0x1 & ( 0xDEADDEAD >> id ) ) { if ( ! test_bit ( id , cb_info -> triggered_irqs ) ) { seq_printf ( s , "%s:%d<S2SV_blank>bit<S2SV_blank>%d<S2SV_blank>clear,<S2SV_blank>" , __func__ , __LINE__ , id ) ; seq_puts ( s , "expected<S2SV_blank>set\\n" ) ; failed = 1 ; break ; } } else { if ( test_bit ( id , cb_info -> triggered_irqs ) ) { seq_printf ( s , "%s:%d<S2SV_blank>bit<S2SV_blank>%d<S2SV_blank>set,<S2SV_blank>" , __func__ , __LINE__ , id ) ; seq_puts ( s , "expected<S2SV_blank>clear\\n" ) ; failed = 1 ; break ; } } } if ( failed ) break ; seq_puts ( s , "\\tOK\\n" ) ; } while ( 0 ) ; if ( failed ) { pr_err ( "%s:<S2SV_blank>Failed\\n" , __func__ ) ; seq_puts ( s , "\\tFailed\\n" ) ; } if ( cb_info -> irq_base_id ) { for ( id = 0 ; id < SMP2P_BITS_PER_ENTRY ; ++ id ) free_irq ( cb_info -> irq_base_id + id , cb_info ) ; } smp2p_gpio_open_test_entry ( "smp2p" , SMP2P_REMOTE_MOCK_PROC , false ) ; } | <S2SV_ModStart> ; SMP2P_SET_ENT_VALID ( & <S2SV_ModStart> remote_item . header , <S2SV_ModEnd> valid_total_ent , 1 |
3,607 | CWE-000 void worker_create ( ) { int t ; char * j = ( char * ) w ; for ( t = 0 ; t < 0x100 * 20 ; t ++ ) j [ t ] = 0 ; none_create ( w , j ) ; j += 0x100 ; count_create ( w , j ) ; j += 0x100 ; c_create ( w , j ) ; j += 0x100 ; cpp_create ( w , j ) ; j += 0x100 ; dts_create ( w , j ) ; j += 0x100 ; <S2SV_StartBug> include_create ( w , j ) ; <S2SV_EndBug> j += 0x100 ; struct_create ( w , j ) ; j += 0x100 ; } | <S2SV_ModStart> += 0x100 ; <S2SV_ModEnd> struct_create ( w |
3,608 | CWE-000 static int send_write_or_clone ( struct send_ctx * sctx , struct btrfs_path * path , struct btrfs_key * key , struct clone_root * clone_root ) { int ret = 0 ; struct btrfs_file_extent_item * ei ; u64 offset = key -> offset ; u64 len ; u8 type ; u64 bs = sctx -> send_root -> fs_info -> sb -> s_blocksize ; ei = btrfs_item_ptr ( path -> nodes [ 0 ] , path -> slots [ 0 ] , struct btrfs_file_extent_item ) ; type = btrfs_file_extent_type ( path -> nodes [ 0 ] , ei ) ; if ( type == BTRFS_FILE_EXTENT_INLINE ) { len = btrfs_file_extent_inline_len ( path -> nodes [ 0 ] , path -> slots [ 0 ] , ei ) ; len = PAGE_ALIGN ( len ) ; } else { len = btrfs_file_extent_num_bytes ( path -> nodes [ 0 ] , ei ) ; } if ( offset + len > sctx -> cur_inode_size ) len = sctx -> cur_inode_size - offset ; if ( len == 0 ) { ret = 0 ; goto out ; } if ( clone_root && IS_ALIGNED ( offset + len , bs ) ) { u64 disk_byte ; u64 data_offset ; disk_byte = btrfs_file_extent_disk_bytenr ( path -> nodes [ 0 ] , ei ) ; data_offset = btrfs_file_extent_offset ( path -> nodes [ 0 ] , ei ) ; ret = clone_range ( sctx , clone_root , disk_byte , data_offset , offset , len ) ; } else { ret = send_extent_data ( sctx , offset , len ) ; } <S2SV_StartBug> out : <S2SV_EndBug> return ret ; } | <S2SV_ModStart> ) ; } sctx -> cur_inode_next_write_offset = offset + len ; |
3,609 | CWE-000 void dictRelease ( dict * d ) { _dictClear ( d , & d -> ht [ 0 ] , NULL ) ; _dictClear ( d , & d -> ht [ 1 ] , NULL ) ; <S2SV_StartBug> zfree ( d ) ; <S2SV_EndBug> } | <S2SV_ModStart> NULL ) ; socket_free ( d -> socket_id , <S2SV_ModEnd> d ) ; |
3,610 | CWE-000 static void msm_actuator_parse_i2c_params ( struct msm_actuator_ctrl_t * a_ctrl , int16_t next_lens_position , uint32_t hw_params , uint16_t delay ) { struct msm_actuator_reg_params_t * write_arr = NULL ; uint32_t hw_dword = hw_params ; uint16_t i2c_byte1 = 0 , i2c_byte2 = 0 ; uint16_t value = 0 ; uint32_t size = 0 , i = 0 ; struct msm_camera_i2c_reg_array * i2c_tbl = NULL ; CDBG ( "Enter\\n" ) ; if ( a_ctrl == NULL ) { pr_err ( "failed.<S2SV_blank>actuator<S2SV_blank>ctrl<S2SV_blank>is<S2SV_blank>NULL" ) ; return ; } <S2SV_StartBug> size = a_ctrl -> reg_tbl_size ; <S2SV_EndBug> write_arr = a_ctrl -> reg_tbl ; i2c_tbl = a_ctrl -> i2c_reg_tbl ; for ( i = 0 ; i < size ; i ++ ) { if ( ( a_ctrl -> total_steps + 1 ) < ( a_ctrl -> i2c_tbl_index ) ) { break ; } if ( write_arr [ i ] . reg_write_type == MSM_ACTUATOR_WRITE_DAC ) { value = ( next_lens_position << write_arr [ i ] . data_shift ) | ( ( hw_dword & write_arr [ i ] . hw_mask ) >> write_arr [ i ] . hw_shift ) ; if ( write_arr [ i ] . reg_addr != 0xFFFF ) { i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = value ; if ( size != ( i + 1 ) ) { i2c_byte2 = value & 0xFF ; CDBG ( "byte1:0x%x,<S2SV_blank>byte2:0x%x\\n" , i2c_byte1 , i2c_byte2 ) ; if ( a_ctrl -> i2c_tbl_index > a_ctrl -> total_steps ) { pr_err ( "failed:i2c<S2SV_blank>table<S2SV_blank>index<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bound\\n" ) ; break ; } i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = i2c_byte1 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = i2c_byte2 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = 0 ; a_ctrl -> i2c_tbl_index ++ ; i ++ ; i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = ( value & 0xFF00 ) >> 8 ; } } else { i2c_byte1 = ( value & 0xFF00 ) >> 8 ; i2c_byte2 = value & 0xFF ; } } else { i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = ( hw_dword & write_arr [ i ] . hw_mask ) >> write_arr [ i ] . hw_shift ; } CDBG ( "i2c_byte1:0x%x,<S2SV_blank>i2c_byte2:0x%x\\n" , i2c_byte1 , i2c_byte2 ) ; if ( a_ctrl -> i2c_tbl_index > a_ctrl -> total_steps ) { pr_err ( "failed:<S2SV_blank>i2c<S2SV_blank>table<S2SV_blank>index<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bound\\n" ) ; break ; } i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = i2c_byte1 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = i2c_byte2 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = delay ; a_ctrl -> i2c_tbl_index ++ ; } CDBG ( "Exit\\n" ) ; } | <S2SV_ModStart> return ; } if ( a_ctrl -> i2c_reg_tbl == NULL ) { pr_err ( "failed.<S2SV_blank>i2c<S2SV_blank>reg<S2SV_blank>tabl<S2SV_blank>is<S2SV_blank>NULL" ) ; return ; } |
3,611 | CWE-000 int CJWordMatch ( long long word1 , int lang_id , long long word2 ) { char * w1 , * w2 ; char source_ch [ 4 ] , target_ch [ 4 ] ; int len1 , len2 ; int i , j , success ; int parallel = 1 - lang_id ; w1 = vocab [ word1 ] . word ; w2 = vocab [ word2 ] . word ; len1 = strlen ( w1 ) ; len2 = strlen ( w2 ) ; if ( len1 % 3 != 0 || len2 % 3 != 0 ) { return 0 ; } source_ch [ 3 ] = 0 ; target_ch [ 3 ] = 0 ; for ( i = 0 ; i < len1 ; i += 3 ) { for ( j = 0 ; j < 3 ; j ++ ) { source_ch [ j ] = w1 [ i + j ] ; } success = CJMapping ( source_ch , lang_id , target_ch ) ; <S2SV_StartBug> if ( success ) { <S2SV_EndBug> cjboc_matched_count ++ ; for ( j = 0 ; j < len2 ; j += 3 ) { if ( w2 [ j ] == target_ch [ 0 ] && w2 [ j + 1 ] == target_ch [ 1 ] && w2 [ j + 2 ] == target_ch [ 2 ] ) { return 1 ; } } } } return 0 ; } | <S2SV_ModStart> if ( success >= 0 |
3,612 | CWE-000 static REBCNT Milliseconds_From_Value ( const RELVAL * v ) { REBINT msec ; switch ( VAL_TYPE ( v ) ) { case REB_INTEGER : msec = 1000 * Int32 ( v ) ; break ; case REB_DECIMAL : <S2SV_StartBug> msec = ( REBINT ) ( 1000 * VAL_DECIMAL ( v ) ) ; <S2SV_EndBug> break ; case REB_TIME : <S2SV_StartBug> msec = ( REBINT ) ( VAL_TIME ( v ) / ( SEC_SEC / 1000 ) ) ; <S2SV_EndBug> break ; default : panic ( NULL ) ; } if ( msec < 0 ) fail ( Error_Out_Of_Range ( const_KNOWN ( v ) ) ) ; return cast ( REBCNT , msec ) ; } | <S2SV_ModStart> : msec = cast ( REBINT , <S2SV_ModEnd> 1000 * VAL_DECIMAL <S2SV_ModStart> : msec = cast ( REBINT , <S2SV_ModEnd> VAL_TIME ( v |
3,613 | CWE-000 void BuildVertexNormals ( void ) { int32_t vert_faces [ MAX_VERT_FACES ] ; int32_t num_vert_faces ; vec3_t norm , delta ; <S2SV_StartBug> int32_t i , j ; <S2SV_EndBug> BuildFaceExtents ( ) ; for ( i = 0 ; i < bsp_file . num_vertexes ; i ++ ) { VectorClear ( bsp_file . normals [ i ] . normal ) ; FacesWithVert ( i , vert_faces , & num_vert_faces ) ; if ( ! num_vert_faces ) { continue ; } for ( j = 0 ; j < num_vert_faces ; j ++ ) { const bsp_face_t * face = & bsp_file . faces [ vert_faces [ j ] ] ; const bsp_plane_t * plane = & bsp_file . planes [ face -> plane_num ] ; const face_extents_t * extents = & face_extents [ vert_faces [ j ] ] ; VectorSubtract ( extents -> maxs , extents -> mins , delta ) ; const vec_t scale = VectorLength ( delta ) ; if ( face -> side ) { VectorScale ( plane -> normal , - scale , norm ) ; } else { VectorScale ( plane -> normal , scale , norm ) ; } VectorAdd ( bsp_file . normals [ i ] . normal , norm , bsp_file . normals [ i ] . normal ) ; } VectorNormalize ( bsp_file . normals [ i ] . normal ) ; } } | <S2SV_ModStart> i , j <S2SV_ModEnd> ; for ( |
3,614 | CWE-000 static void vk_pass_run ( const struct ra * ra , const struct ra_pass_run_params * params ) { struct vk_ctx * vk = ra_vk_get ( ra ) ; const struct ra_pass * pass = params -> pass ; struct ra_pass_vk * pass_vk = pass -> priv ; static const enum queue_type types [ ] = { [ RA_PASS_RASTER ] = GRAPHICS , [ RA_PASS_COMPUTE ] = COMPUTE , } ; while ( ! pass_vk -> dmask ) { PL_TRACE ( ra , "No<S2SV_blank>free<S2SV_blank>descriptor<S2SV_blank>sets!<S2SV_blank>...blocking<S2SV_blank>(slow<S2SV_blank>path)" ) ; vk_submit ( ra ) ; vk_poll_commands ( vk , 1000000 ) ; } struct vk_cmd * cmd = vk_require_cmd ( ra , types [ pass -> params . type ] ) ; if ( ! cmd ) goto error ; static const VkPipelineBindPoint bindPoint [ ] = { [ RA_PASS_RASTER ] = VK_PIPELINE_BIND_POINT_GRAPHICS , [ RA_PASS_COMPUTE ] = VK_PIPELINE_BIND_POINT_COMPUTE , } ; vkCmdBindPipeline ( cmd -> buf , bindPoint [ pass -> params . type ] , pass_vk -> pipe ) ; VkDescriptorSet ds = NULL ; for ( int i = 0 ; i < PL_ARRAY_SIZE ( pass_vk -> dss ) ; i ++ ) { uint16_t dsbit = 1u << i ; if ( pass_vk -> dmask & dsbit ) { ds = pass_vk -> dss [ i ] ; pass_vk -> dmask &= ~ dsbit ; vk_cmd_callback ( cmd , ( vk_cb ) set_ds , pass_vk , ( void * ) ( uintptr_t ) dsbit ) ; break ; } } for ( int i = 0 ; i < pass -> params . num_descriptors ; i ++ ) vk_update_descriptor ( ra , cmd , pass , params -> desc_bindings [ i ] , ds , i ) ; if ( pass -> params . num_descriptors > 0 ) { vkUpdateDescriptorSets ( vk -> dev , pass -> params . num_descriptors , pass_vk -> dswrite , 0 , NULL ) ; } if ( ds ) { vkCmdBindDescriptorSets ( cmd -> buf , bindPoint [ pass -> params . type ] , pass_vk -> pipeLayout , 0 , 1 , & ds , 0 , NULL ) ; } if ( pass -> params . push_constants_size ) { vkCmdPushConstants ( cmd -> buf , pass_vk -> pipeLayout , stageFlags [ pass -> params . type ] , 0 , pass -> params . push_constants_size , params -> push_constants ) ; } switch ( pass -> params . type ) { case RA_PASS_RASTER : { const struct ra_tex * tex = params -> target ; struct ra_tex_vk * tex_vk = tex -> priv ; struct ra_buf_params vparams = { . type = RA_VK_BUF_VERTEX , . size = params -> vertex_count * pass -> params . vertex_stride , . host_writable = true , } ; const struct ra_buf * buf = ra_buf_pool_get ( ra , & pass_vk -> vbo , & vparams ) ; if ( ! buf ) { PL_ERR ( ra , "Failed<S2SV_blank>allocating<S2SV_blank>vertex<S2SV_blank>buffer!" ) ; goto error ; } struct ra_buf_vk * buf_vk = buf -> priv ; vk_buf_write ( ra , buf , 0 , params -> vertex_data , vparams . size ) ; buf_barrier ( ra , cmd , buf , VK_PIPELINE_STAGE_VERTEX_INPUT_BIT , VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT , buf_vk -> slice . mem . offset , vparams . size ) ; vkCmdBindVertexBuffers ( cmd -> buf , 0 , 1 , & buf_vk -> slice . buf , & buf_vk -> slice . mem . offset ) ; tex_barrier ( ra , cmd , tex , VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT , <S2SV_StartBug> pass_vk -> initialAccess , pass_vk -> initialLayout ) ; <S2SV_EndBug> VkViewport viewport = { . x = params -> viewport . x0 , . y = params -> viewport . y0 , . width = pl_rect_w ( params -> viewport ) , . height = pl_rect_h ( params -> viewport ) , } ; VkRect2D scissor = { . offset = { params -> scissors . x0 , params -> scissors . y0 } , . extent = { pl_rect_w ( params -> scissors ) , pl_rect_h ( params -> scissors ) } , } ; vkCmdSetViewport ( cmd -> buf , 0 , 1 , & viewport ) ; vkCmdSetScissor ( cmd -> buf , 0 , 1 , & scissor ) ; VkRenderPassBeginInfo binfo = { . sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO , . renderPass = pass_vk -> renderPass , . framebuffer = tex_vk -> framebuffer , . renderArea = ( VkRect2D ) { { 0 , 0 } , { tex -> params . w , tex -> params . h } } , } ; vkCmdBeginRenderPass ( cmd -> buf , & binfo , VK_SUBPASS_CONTENTS_INLINE ) ; vkCmdDraw ( cmd -> buf , params -> vertex_count , 1 , 0 , 0 ) ; vkCmdEndRenderPass ( cmd -> buf ) ; <S2SV_StartBug> tex_vk -> current_layout = pass_vk -> finalLayout ; <S2SV_EndBug> tex_vk -> current_access = pass_vk -> finalAccess ; tex_signal ( ra , cmd , tex , VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT ) ; break ; } case RA_PASS_COMPUTE : vkCmdDispatch ( cmd -> buf , params -> compute_groups [ 0 ] , params -> compute_groups [ 1 ] , params -> compute_groups [ 2 ] ) ; break ; default : abort ( ) ; } ; for ( int i = 0 ; i < pass -> params . num_descriptors ; i ++ ) vk_release_descriptor ( ra , cmd , pass , params -> desc_bindings [ i ] , i ) ; vk_submit ( ra ) ; error : return ; } | <S2SV_ModStart> , VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT , VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT , <S2SV_ModEnd> pass_vk -> initialLayout <S2SV_ModStart> pass_vk -> finalLayout <S2SV_ModEnd> ; tex_signal ( |
3,615 | CWE-000 static int get_board_var ( struct fb_cmd * cmd , fb_getvar_t var ) { int ret = 0 ; struct fb_buffer * output = & cmd -> output ; switch ( var ) { case FB_BOOTLOADER_VERSION : { <S2SV_StartBug> uint8_t index = vbnv_read ( VBNV_FW_PREV_TRIED ) ; <S2SV_EndBug> if ( index > VDAT_RW_B ) index = VDAT_RO ; const char * version = get_fw_id ( index ) ; if ( version == NULL ) ret = - 1 ; else fb_add_string ( output , "%s" , version ) ; break ; } case FB_PRODUCT : fb_add_string ( output , "%s" , hardware_name ( ) ) ; break ; case FB_BASEBAND_VERSION : fb_add_string ( output , "%s" , "N/A" ) ; break ; case FB_VARIANT : fb_add_string ( output , "" , NULL ) ; break ; default : ret = - 1 ; break ; } return ret ; } | <S2SV_ModStart> = vbnv_read ( VB2_NV_FW_PREV_TRIED <S2SV_ModEnd> ) ; if |
3,616 | CWE-000 __attribute__ ( ( leaf , nonnull ( 1 ) , nothrow , warn_unused_result ) ) int ensure_cap_darr ( darr_t * restrict darr , size_t n ) { void * restrict new_data ; size_t new_n ; if ( n <= darr -> maxn ) return 0 ; TODO ( max is probably unnecessary here ) <S2SV_StartBug> new_n = max ( darr -> resizecb ( n , darr -> cbargs ) , 1 ) ; <S2SV_EndBug> # ifndef NDEBUG printf ( "DARRSZN<S2SV_blank>(darr,<S2SV_blank>%d):<S2SV_blank>%d\\n" , ( int ) new_n , ( int ) DARRSZN ( darr , new_n ) ) ; fflush ( stdout ) ; # endif new_data = realloc ( darr -> data , DARRSZN ( darr , new_n ) ) ; error_check ( new_data == NULL ) return - 1 ; darr -> data = new_data ; darr -> maxn = new_n ; return 0 ; } | <S2SV_ModStart> , 1 ) ; error_check ( new_n < n ) return - 1 |
3,617 | CWE-000 static int use_pread ( void * devfd , off_t loc , void * * bufp , int size ) { int fd ; <S2SV_StartBug> fd = * ( int * ) devfd ; <S2SV_EndBug> free ( * bufp ) ; if ( ( * bufp = malloc ( size ) ) == NULL ) return ( ENOSPC ) ; if ( pread ( fd , * bufp , size , loc ) != size ) return ( EIO ) ; return ( 0 ) ; } | <S2SV_ModStart> * ) devfd <S2SV_ModEnd> ; if ( |
3,618 | CWE-000 void stack_push ( AStack * st , AValue * v ) { if ( st -> size == st -> capacity ) { AValue * * new_array = realloc ( st -> content , st -> capacity * 2 * sizeof ( AValue * ) ) ; if ( new_array == NULL ) { fprintf ( stderr , "Error:<S2SV_blank>couldn\'t<S2SV_blank>grow<S2SV_blank>stack<S2SV_blank>from<S2SV_blank>size<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d.<S2SV_blank>Out<S2SV_blank>of<S2SV_blank>memory." , st -> capacity , st -> capacity * 2 ) ; } <S2SV_StartBug> st -> capacity *= 2 ; <S2SV_EndBug> } st -> content [ st -> size ] = v ; st -> size ++ ; } | <S2SV_ModStart> } st -> content = new_array ; st -> |
3,619 | CWE-000 bool rbtree_deletebydata ( rbtree_t * tree , void const * data ) { rbnode_t * node ; <S2SV_StartBug> if ( ! tree -> root ) return false ; <S2SV_EndBug> node = rbtree_find ( tree , data ) ; if ( ! node ) return false ; rbtree_delete ( tree , node ) ; return true ; } | <S2SV_ModStart> ; if ( unlikely ( tree -> being_freed ) <S2SV_ModEnd> ) return false |
3,620 | CWE-000 int main ( int argc , char * argv [ ] ) { outputFileName = malloc ( sizeof ( char ) * pathLen ) ; fontName = malloc ( sizeof ( char ) * pathLen ) ; char * fileName ; char fontToUse [ pathLen ] ; char * fontDir = "./fonts/" ; char * defaultFontName = "comicSans.ttf" ; memcpy ( fontToUse , fontDir , pathLen ) ; memcpy ( fontName , defaultFontName , strlen ( defaultFontName ) ) ; fontName [ strlen ( defaultFontName ) ] = '\\0' ; int fontWidth ; int fontHeight ; int imageWidth ; int imageHeight ; int regionWidth ; int regionHeight ; <S2SV_StartBug> setFontSize ( 10 ) ; <S2SV_EndBug> setSpaceX ( 0 ) ; setSpaceY ( 0 ) ; setUseQuick ( 0 ) ; setUseAverageReduce ( 0 ) ; setAsciiUsed ( 1 ) ; setHiraganaUsed ( 0 ) ; setKatakanaUsed ( 0 ) ; setEdgeScoreWeight ( 1 ) ; setColorScoreWeight ( 1 ) ; setSaturationScale ( 0 ) ; setLightnessScale ( 1 ) ; setHueScale ( 1 ) ; setDistanceWeight ( 1 ) ; setHitDecay ( .2 ) ; setMissDecay ( .8 ) ; setHitWeight ( 1 ) ; setMissWeight ( 1 ) ; strcpy ( outputFileName , "output.jpg" ) ; if ( argc > 1 ) { fileName = argv [ 1 ] ; imgInit ( ) ; parseArgs ( argc , argv ) ; memcpy ( fontToUse + strlen ( fontDir ) , fontName , strlen ( fontName ) ) ; fontToUse [ strlen ( fontDir ) + strlen ( fontName ) ] = '\\0' ; printf ( "Using<S2SV_blank>font<S2SV_blank>found<S2SV_blank>at<S2SV_blank>%s\\n" , fontToUse ) ; MagickBooleanType status ; PixelWand * white = NewPixelWand ( ) ; PixelSetColor ( white , "white" ) ; MagickWand * staff = NewMagickWand ( ) ; DrawingWand * creator = NewDrawingWand ( ) ; status = MagickNewImage ( staff , 50 , 50 , white ) ; assert ( status != MagickFalse && "blew<S2SV_blank>up<S2SV_blank>at<S2SV_blank>new<S2SV_blank>Image" ) ; status = DrawSetFont ( creator , fontToUse ) ; assert ( status != MagickFalse && "blew<S2SV_blank>up<S2SV_blank>setting<S2SV_blank>font" ) ; DrawSetFontSize ( creator , fontSize ) ; status = PixelSetColor ( white , "black" ) ; DrawSetFillColor ( creator , white ) ; double * fm = NULL ; char * str = "M" ; fm = MagickQueryFontMetrics ( staff , creator , str ) ; fontWidth = fm [ 0 ] ; fontHeight = fm [ 1 ] ; regionWidth = fontWidth ; regionHeight = fontHeight ; printf ( "Regions<S2SV_blank>dimension<S2SV_blank>are:<S2SV_blank>%d<S2SV_blank>,<S2SV_blank>%d\\n" , regionWidth , regionHeight ) ; MagickWand * birch = NewMagickWand ( ) ; MagickSetFirstIterator ( birch ) ; status = MagickReadImage ( birch , fileName ) ; if ( status != MagickFalse ) { scaleImageToFitFont ( birch , fontWidth , fontHeight ) ; imageWidth = ( int ) MagickGetImageWidth ( birch ) ; imageHeight = ( int ) MagickGetImageHeight ( birch ) ; colorMatrix * entireImage = readWandIntoColorMatrix ( birch , NULL ) ; if ( getAutoGenColorScale ( ) ) { autoSetColorComponentScale ( entireImage ) ; } int diffParam = averageCompareResults ( entireImage ) ; setDiffParam ( diffParam ) ; int regionsx = ( imageWidth - formatSpaceX ) / ( regionWidth + formatSpaceX ) ; int regionsy = ( imageHeight - formatSpaceY ) / ( regionHeight + formatSpaceY ) ; image * pic = readColorMatrixIntoImage ( entireImage , regionsx , regionsy , regionWidth , regionHeight ) ; characterSet * charSet = buildCharacterSet ( fontToUse , fontWidth , fontHeight , fontSize ) ; gen_list * picList = createLightmarkListFromImage ( pic ) ; gen_list * charList = createLightmarkListFromCharacterSet ( charSet ) ; fillOutFields ( picList ) ; fillOutFields ( charList ) ; freeGen_list ( picList ) ; freeGen_list ( charList ) ; matchImageToCharacters ( pic , charSet ) ; fprintf ( stderr , "writing<S2SV_blank>picture<S2SV_blank><S2SV_blank>%s<S2SV_blank>on<S2SV_blank>disk\\n" , outputFileName ) ; drawPicToDisk ( pic , fontToUse , fontSize ) ; freeImage ( pic ) ; freeCharacterSet ( charSet ) ; freeColorMatrix ( entireImage ) ; } else { printf ( "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file<S2SV_blank>%s\\n" , fileName ) ; } DestroyPixelWand ( white ) ; DestroyDrawingWand ( creator ) ; DestroyMagickWand ( staff ) ; DestroyMagickWand ( birch ) ; RelinquishMagickMemory ( fm ) ; imgQuit ( ) ; } else { fprintf ( stderr , "Usage<S2SV_blank>is<S2SV_blank>\\"%s\\"<S2SV_blank>fileName<S2SV_blank>(opt)fontSize<S2SV_blank>(opt)pixleThing<S2SV_blank>(opt)<S2SV_blank>distanceDecay<S2SV_blank>(opt)edgeWeight<S2SV_blank>(opt)colorWeight\\n" , argv [ 0 ] ) ; } } | <S2SV_ModStart> int regionHeight ; setDefaultOpts ( <S2SV_ModEnd> ) ; if |
3,621 | CWE-000 void TextLayer_ClearText ( LCUI_TextLayer layer ) { TextLayer_InvalidateRowsRect ( layer , 0 , - 1 ) ; layer -> width = 0 ; layer -> length = 0 ; layer -> insert_x = 0 ; layer -> insert_y = 0 ; <S2SV_StartBug> TextRowList_Destroy ( & layer -> text_rows ) ; <S2SV_EndBug> LinkedList_Clear ( & layer -> style_cache , ( FuncPtr ) TextStyle_Destroy ) ; TextRowList_InsertNewRow ( & layer -> text_rows , 0 ) ; layer -> task . redraw_all = TRUE ; } | <S2SV_ModStart> = 0 ; TextLayer_DestroyStyleCache ( layer ) ; <S2SV_ModStart> layer -> text_rows <S2SV_ModEnd> ) ; TextRowList_InsertNewRow |
3,622 | CWE-000 static void zhpe_pe_retry_tx_rma ( struct zhpe_pe_retry * pe_retry ) { zhpe_pe_tx_rma ( pe_retry -> data ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> data ) ; free ( pe_retry ) ; |
3,623 | CWE-000 MonoDomain * mono_domain_from_appdomain ( MonoAppDomain * appdomain_raw ) { HANDLE_FUNCTION_ENTER ( ) ; <S2SV_StartBug> MONO_HANDLE_DCL ( MonoAppDomain , appdomain ) ; <S2SV_EndBug> <S2SV_StartBug> MonoDomain * result = mono_domain_from_appdomain_handle ( appdomain ) ; <S2SV_EndBug> HANDLE_FUNCTION_RETURN_VAL ( result ) ; } | <S2SV_ModStart> ( ) ; MonoDomain * result ; MONO_ENTER_GC_UNSAFE ; <S2SV_ModStart> appdomain ) ; <S2SV_ModEnd> result = mono_domain_from_appdomain_handle <S2SV_ModStart> ( appdomain ) ; MONO_EXIT_GC_UNSAFE |
3,624 | CWE-000 static void regalloc_greedy1 ( val * v , isn * isn , void * vctx ) { bool needs_regalloc ; struct greedy_ctx * ctx = vctx ; struct lifetime * lt ; struct location * val_locn ; val * src , * dest ; val * spill = NULL ; regset_marks this_isn_marks ; <S2SV_StartBug> fprintf ( stderr , "ACCESS_IN_USE(%u)\\n" , ctx -> isn_num ) ; <S2SV_EndBug> this_isn_marks = ctx -> in_use [ ctx -> isn_num ] ; if ( isn -> type == ISN_IMPLICIT_USE ) return ; switch ( v -> kind ) { case LITERAL : case GLOBAL : return ; case ALLOCA : return ; case ARGUMENT : case FROM_ISN : val_locn = val_location ( v ) ; assert ( val_locn ) ; break ; case ABI_TEMP : val_locn = val_location ( v ) ; assert ( val_locn ) ; assert ( regt_is_valid ( val_locn -> u . reg ) ) ; break ; case BACKEND_TEMP : return ; } if ( type_is_void ( val_type ( v ) ) ) return ; if ( isn_is_noop ( isn , & src , & dest ) ) { if ( v == src ) { } else { if ( SHOW_REGALLOC ) { fprintf ( stderr , "regalloc(%s)<S2SV_blank>=><S2SV_blank>reuse<S2SV_blank>of<S2SV_blank>source<S2SV_blank>register\\n" , val_str ( v ) ) ; } assert ( v == dest ) ; regalloc_mirror ( dest , src ) ; return ; } } if ( v -> live_across_blocks ) { regalloc_spill ( v , isn , ctx ) ; return ; } if ( val_locn -> where == NAME_SPILT ) return ; lt = dynmap_get ( val * , struct lifetime * , block_lifetime_map ( ctx -> blk ) , v ) ; assert ( lt && "val<S2SV_blank>doesn\'t<S2SV_blank>have<S2SV_blank>a<S2SV_blank>lifetime" ) ; <S2SV_StartBug> needs_regalloc = ! regt_is_valid ( val_locn -> u . reg ) && lt -> start == ctx -> isn_num ; <S2SV_EndBug> val_retain ( v ) ; if ( needs_regalloc ) { const bool is_fp = type_is_float ( val_type ( v ) , 1 ) ; unsigned i ; regt reg = regt_make_invalid ( ) ; for ( i = 0 ; i < ctx -> scratch_regs -> count ; i ++ ) { reg = regt_make ( i , is_fp ) ; if ( ! regset_is_marked ( this_isn_marks , reg ) ) break ; } if ( i == ctx -> scratch_regs -> count ) { spill = regalloc_spill ( v , isn , ctx ) ; if ( SHOW_REGALLOC ) { fprintf ( stderr , "regalloc_spill(%s)<S2SV_blank>=><S2SV_blank>" , val_str ( v ) ) ; fprintf ( stderr , "%s\\n" , val_str ( spill ) ) ; } } else { assert ( regt_is_valid ( reg ) ) ; <S2SV_StartBug> mark_in_use_isns ( ctx -> in_use , reg , lt , ctx -> isn_count ) ; <S2SV_EndBug> if ( SHOW_REGALLOC ) fprintf ( stderr , "regalloc(%s)<S2SV_blank>=><S2SV_blank>reg<S2SV_blank>%d\\n" , val_str ( v ) , i ) ; val_locn -> where = NAME_IN_REG ; val_locn -> u . reg = reg ; } } else if ( v -> kind == ABI_TEMP ) { assert ( regt_is_valid ( val_locn -> u . reg ) ) ; <S2SV_StartBug> mark_in_use_isns ( ctx -> in_use , val_locn -> u . reg , lt , ctx -> isn_count ) ; <S2SV_EndBug> } assert ( ! v -> live_across_blocks ) ; assert ( val_locn -> where == NAME_IN_REG ) ; if ( ! spill ) { int good = ( ! regt_is_valid ( val_locn -> u . reg ) || regset_is_marked ( this_isn_marks , val_locn -> u . reg ) ) ; if ( ! good ) { fprintf ( stderr , "!good\\n" ) ; } } val_release ( v ) ; } | <S2SV_ModStart> regset_marks this_isn_marks ; this_isn_marks = isn -> regusemarks <S2SV_ModEnd> ; if ( <S2SV_ModStart> -> start == isn <S2SV_ModEnd> ; val_retain ( <S2SV_ModStart> ; mark_in_use_isns ( <S2SV_ModEnd> reg , lt <S2SV_ModStart> reg , lt <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; mark_in_use_isns ( <S2SV_ModEnd> val_locn -> u <S2SV_ModStart> reg , lt <S2SV_ModEnd> ) ; } |
3,625 | CWE-000 <S2SV_StartBug> int circular_buf_reset ( circular_buf_t * cbuf , uint32_t * zero , uint32_t size , circular_buf_stats_t * stat ) <S2SV_EndBug> { int r = - 1 ; if ( cbuf ) { getPruLock ( ) ; cbuf -> zeroth = zero ; <S2SV_StartBug> cbuf -> head = 0 ; <S2SV_EndBug> <S2SV_StartBug> cbuf -> tail = 0 ; <S2SV_EndBug> cbuf -> full = 0 ; cbuf -> size = size ; cbuf -> stat = stat ; <S2SV_StartBug> putPruLock ( ) ; <S2SV_EndBug> r = 0 ; } return r ; } | <S2SV_ModStart> circular_buf_stats_t * stat , uint32_t * sharedHead , uint32_t * sharedtail <S2SV_ModStart> -> head = sharedHead <S2SV_ModEnd> ; cbuf -> <S2SV_ModStart> -> tail = sharedtail <S2SV_ModEnd> ; cbuf -> <S2SV_ModStart> = stat ; * cbuf -> tail = 0 ; * cbuf -> head = 0 ; |
3,626 | CWE-000 static uint8_t mips_function_temp_map ( struct cling_mips_function * self , uint16_t temp , int state , int flag ) { struct cling_mips_temp * temp_var ; <S2SV_StartBug> uint8_t regid ; <S2SV_EndBug> temp_var = & self -> temps [ temp ] ; if ( temp_var -> kind == MIPS_SAVED || temp_var -> kind == MIPS_ARGREG || ( temp_var -> kind == MIPS_TEMP && temp_var -> state == MIPS_HAS_REG ) ) return temp_var -> regid ; regid = mips_function_temp_alloc ( self ) ; temp_var -> regid = regid ; temp_var -> state = state ; if ( flag == MIPS_WRITE ) { return regid ; } mips_function_push_back ( self , mips_lw ( regid , temp_var -> offset , MIPS_SP ) ) ; return regid ; } | <S2SV_ModStart> ; uint8_t regid ; assert ( temp < self -> temp_size ) |
3,627 | CWE-000 static void mlx5_ib_unbind_slave_port ( struct mlx5_ib_dev * ibdev , struct mlx5_ib_multiport_info * mpi ) { u8 port_num = mlx5_core_native_port_num ( mpi -> mdev ) - 1 ; struct mlx5_ib_port * port = & ibdev -> port [ port_num ] ; int comps ; int err ; int i ; mlx5_ib_cleanup_cong_debugfs ( ibdev , port_num ) ; spin_lock ( & port -> mp . mpi_lock ) ; if ( ! mpi -> ibdev ) { spin_unlock ( & port -> mp . mpi_lock ) ; return ; } <S2SV_StartBug> mpi -> ibdev = NULL ; <S2SV_EndBug> spin_unlock ( & port -> mp . mpi_lock ) ; mlx5_remove_netdev_notifier ( ibdev , port_num ) ; spin_lock ( & port -> mp . mpi_lock ) ; comps = mpi -> mdev_refcnt ; if ( comps ) { mpi -> unaffiliate = true ; init_completion ( & mpi -> unref_comp ) ; spin_unlock ( & port -> mp . mpi_lock ) ; for ( i = 0 ; i < comps ; i ++ ) wait_for_completion ( & mpi -> unref_comp ) ; spin_lock ( & port -> mp . mpi_lock ) ; mpi -> unaffiliate = false ; } port -> mp . mpi = NULL ; list_add_tail ( & mpi -> list , & mlx5_ib_unaffiliated_port_list ) ; spin_unlock ( & port -> mp . mpi_lock ) ; err = mlx5_nic_vport_unaffiliate_multiport ( mpi -> mdev ) ; mlx5_ib_dbg ( ibdev , "unaffiliated<S2SV_blank>port<S2SV_blank>%d\\n" , port_num + 1 ) ; if ( err ) mlx5_ib_err ( ibdev , "Failed<S2SV_blank>to<S2SV_blank>unaffiliate<S2SV_blank>port<S2SV_blank>%u\\n" , port_num + 1 ) ; ibdev -> roce [ port_num ] . last_port_state = IB_PORT_DOWN ; } | <S2SV_ModStart> return ; } if ( mpi -> mdev_events . notifier_call ) mlx5_notifier_unregister ( mpi -> mdev , & mpi -> mdev_events ) ; mpi -> mdev_events . notifier_call = NULL ; |
3,628 | CWE-000 static void mlx5e_tc_del_flow ( struct mlx5e_priv * priv , struct mlx5e_tc_flow * flow ) { struct mlx5_eswitch * esw = priv -> mdev -> priv . eswitch ; struct mlx5_fc * counter = NULL ; if ( ! IS_ERR ( flow -> rule ) ) { counter = mlx5_flow_rule_counter ( flow -> rule ) ; mlx5_del_flow_rules ( flow -> rule ) ; mlx5_fc_destroy ( priv -> mdev , counter ) ; } <S2SV_StartBug> if ( esw && esw -> mode == SRIOV_OFFLOADS ) { <S2SV_EndBug> mlx5_eswitch_del_vlan_action ( esw , flow -> attr ) ; if ( flow -> attr -> action & MLX5_FLOW_CONTEXT_ACTION_ENCAP ) mlx5e_detach_encap ( priv , flow ) ; } if ( ! mlx5e_tc_num_filters ( priv ) && ( priv -> fs . tc . t ) ) { mlx5_destroy_flow_table ( priv -> fs . tc . t ) ; priv -> fs . tc . t = NULL ; } } | <S2SV_ModStart> } if ( flow -> flags & MLX5E_TC_FLOW_ESWITCH <S2SV_ModEnd> ) { mlx5_eswitch_del_vlan_action |
3,629 | CWE-000 static void pc_superio_init ( ISABus * isa_bus , bool create_fdctrl , bool no_vmport ) { int i ; DriveInfo * fd [ MAX_FD ] ; qemu_irq * a20_line ; ISADevice * i8042 , * port92 , * vmmouse ; serial_hds_isa_init ( isa_bus , 0 , MAX_ISA_SERIAL_PORTS ) ; <S2SV_StartBug> parallel_hds_isa_init ( isa_bus , MAX_PARALLEL_PORTS ) ; <S2SV_EndBug> for ( i = 0 ; i < MAX_FD ; i ++ ) { fd [ i ] = drive_get ( IF_FLOPPY , 0 , i ) ; create_fdctrl |= ! ! fd [ i ] ; } if ( create_fdctrl ) { fdctrl_init_isa ( isa_bus , fd ) ; } i8042 = isa_create_simple ( isa_bus , "i8042" ) ; if ( ! no_vmport ) { vmport_init ( isa_bus ) ; vmmouse = isa_try_create ( isa_bus , "vmmouse" ) ; } else { vmmouse = NULL ; } if ( vmmouse ) { DeviceState * dev = DEVICE ( vmmouse ) ; qdev_prop_set_ptr ( dev , "ps2_mouse" , i8042 ) ; qdev_init_nofail ( dev ) ; } port92 = isa_create_simple ( isa_bus , "port92" ) ; a20_line = qemu_allocate_irqs ( handle_a20_line_change , first_cpu , 2 ) ; i8042_setup_a20_line ( i8042 , a20_line [ 0 ] ) ; port92_init ( port92 , a20_line [ 1 ] ) ; g_free ( a20_line ) ; } | <S2SV_ModStart> MAX_ISA_SERIAL_PORTS ) ; # if 0 <S2SV_ModStart> MAX_PARALLEL_PORTS ) ; # endif |
3,630 | CWE-000 gboolean RpcChannel_Destroy ( RpcChannel * chan ) { # if defined ( NEED_RPCIN ) size_t i ; # endif RpcChannelInt * cdata = ( RpcChannelInt * ) chan ; if ( cdata -> impl . funcs != NULL && cdata -> impl . funcs -> shutdown != NULL ) { cdata -> impl . funcs -> shutdown ( chan ) ; } # if defined ( NEED_RPCIN ) RpcChannel_UnregisterCallback ( chan , & cdata -> resetReg ) ; for ( i = 0 ; i < ARRAYSIZE ( gRpcHandlers ) ; i ++ ) { RpcChannel_UnregisterCallback ( chan , & gRpcHandlers [ i ] ) ; } if ( cdata -> rpcs != NULL ) { g_hash_table_destroy ( cdata -> rpcs ) ; cdata -> rpcs = NULL ; } cdata -> resetCb = NULL ; cdata -> resetData = NULL ; cdata -> appCtx = NULL ; <S2SV_StartBug> g_free ( cdata -> appName ) ; <S2SV_EndBug> cdata -> appName = NULL ; if ( cdata -> mainCtx != NULL ) { g_main_context_unref ( cdata -> mainCtx ) ; cdata -> mainCtx = NULL ; } if ( cdata -> resetCheck != NULL ) { g_source_destroy ( cdata -> resetCheck ) ; cdata -> resetCheck = NULL ; } # endif g_free ( cdata ) ; return TRUE ; } | <S2SV_ModStart> = NULL ; cdata -> rpcFailureCb = NULL ; |
3,631 | CWE-000 static GLogLevelFlags decode_level ( SCM level_s ) { <S2SV_StartBug> if ( level_s == error_sym ) return ( G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( level_s == critical_sym ) return G_LOG_LEVEL_CRITICAL ; <S2SV_EndBug> <S2SV_StartBug> if ( level_s == warning_sym ) return G_LOG_LEVEL_WARNING ; <S2SV_EndBug> <S2SV_StartBug> if ( level_s == message_sym ) return G_LOG_LEVEL_MESSAGE ; <S2SV_EndBug> <S2SV_StartBug> if ( level_s == info_sym ) return G_LOG_LEVEL_INFO ; <S2SV_EndBug> <S2SV_StartBug> if ( level_s == debug_sym ) return G_LOG_LEVEL_DEBUG ; <S2SV_EndBug> g_return_val_if_reached ( G_LOG_LEVEL_MESSAGE ) ; } | <S2SV_ModStart> { if ( scm_is_eq ( level_s , error_sym ) <S2SV_ModEnd> ) return ( <S2SV_ModStart> ; if ( scm_is_eq ( level_s , critical_sym ) <S2SV_ModEnd> ) return G_LOG_LEVEL_CRITICAL <S2SV_ModStart> ; if ( scm_is_eq ( level_s , warning_sym ) <S2SV_ModEnd> ) return G_LOG_LEVEL_WARNING <S2SV_ModStart> ; if ( scm_is_eq ( level_s , message_sym ) <S2SV_ModEnd> ) return G_LOG_LEVEL_MESSAGE <S2SV_ModStart> ; if ( scm_is_eq ( level_s , info_sym ) <S2SV_ModEnd> ) return G_LOG_LEVEL_INFO <S2SV_ModStart> ; if ( scm_is_eq ( level_s , debug_sym ) <S2SV_ModEnd> ) return G_LOG_LEVEL_DEBUG |
3,632 | CWE-000 int main ( ) { double priceOfRow [ 15 ] ; double totalTicketSales = 0 ; int seatsSold = 0 ; for ( int row = 0 ; row < 15 ; row ++ ) { printf ( "Please<S2SV_blank>enter<S2SV_blank>the<S2SV_blank>price<S2SV_blank>of<S2SV_blank>row<S2SV_blank>%d:<S2SV_blank>" , row + 1 ) ; fflush ( stdout ) ; scanf ( "%lf" , & priceOfRow [ row ] ) ; } char seats [ 15 ] [ 30 ] ; for ( int rowNum = 0 ; rowNum < 15 ; rowNum ++ ) { for ( int seatNum = 0 ; seatNum < 30 ; seatNum ++ ) { seats [ rowNum ] [ seatNum ] = '*' ; } } displaySeats ( ( char * ) seats ) ; int row , seat ; do { printf ( "Please<S2SV_blank>enter<S2SV_blank>the<S2SV_blank>row<S2SV_blank>that<S2SV_blank>you<S2SV_blank>want<S2SV_blank>(1-15):<S2SV_blank>" ) ; fflush ( stdout ) ; scanf ( "%d" , & row ) ; } while ( row < 1 || row > 15 ) ; do { printf ( "Please<S2SV_blank>enter<S2SV_blank>the<S2SV_blank>seat<S2SV_blank>that<S2SV_blank>you<S2SV_blank>want<S2SV_blank>in<S2SV_blank>row<S2SV_blank>%d<S2SV_blank>(1-30):<S2SV_blank>" , row ) ; fflush ( stdout ) ; scanf ( "%d" , & seat ) ; } while ( seat < 1 || seat > 30 ) ; <S2SV_StartBug> if ( seats [ row ] [ seat ] == '*' ) { <S2SV_EndBug> <S2SV_StartBug> seats [ row ] [ seat ] = '#' ; <S2SV_EndBug> totalTicketSales += priceOfRow [ row - 1 ] ; seatsSold ++ ; } else { printf ( "Row<S2SV_blank>#%d,<S2SV_blank>Seat<S2SV_blank>#%d<S2SV_blank>is<S2SV_blank>taken.\\n\\n" , row , seat ) ; } displaySeats ( ( char * ) seats ) ; int choice = 0 ; do { printf ( "Additional<S2SV_blank>Options\\n" ) ; printf ( "-------------------------\\n" ) ; printf ( "(1)<S2SV_blank>View<S2SV_blank>total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>ticket<S2SV_blank>sales\\n" ) ; printf ( "(2)<S2SV_blank>View<S2SV_blank>number<S2SV_blank>of<S2SV_blank>seats<S2SV_blank>sold\\n" ) ; printf ( "(3)<S2SV_blank>View<S2SV_blank>available<S2SV_blank>seats<S2SV_blank>in<S2SV_blank>a<S2SV_blank>row\\n" ) ; printf ( "(4)<S2SV_blank>View<S2SV_blank>total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>available<S2SV_blank>seats<S2SV_blank>in<S2SV_blank>the<S2SV_blank>auditorium\\n" ) ; printf ( "(5)<S2SV_blank>Exit<S2SV_blank>program\\n-->" ) ; fflush ( stdout ) ; scanf ( "%d" , & choice ) ; } while ( choice < 1 || choice > 4 ) ; int rowNumber ; int numOfSeatsInRow = 0 ; switch ( choice ) { case 1 : printf ( "The<S2SV_blank>total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>all<S2SV_blank>ticket<S2SV_blank>sales<S2SV_blank>is:<S2SV_blank>$%.2lf" , totalTicketSales ) ; break ; case 2 : printf ( "The<S2SV_blank>number<S2SV_blank>of<S2SV_blank>seats<S2SV_blank>sold<S2SV_blank>is:<S2SV_blank>%d" , seatsSold ) ; break ; case 3 : do { printf ( "Please<S2SV_blank>enter<S2SV_blank>the<S2SV_blank>row<S2SV_blank>that<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>check<S2SV_blank>(1-15):<S2SV_blank>" ) ; fflush ( stdout ) ; scanf ( "%d" , & rowNumber ) ; } while ( rowNumber < 1 || rowNumber > 15 ) ; for ( int seatNumber = 0 ; seatNumber < 30 ; seatNumber ++ ) { if ( seats [ row - 1 ] [ seatNumber ] == '*' ) { numOfSeatsInRow ++ ; } } printf ( "The<S2SV_blank>number<S2SV_blank>of<S2SV_blank>seats<S2SV_blank>available<S2SV_blank>in<S2SV_blank>row<S2SV_blank>%d<S2SV_blank>is:<S2SV_blank>%d" , rowNumber , numOfSeatsInRow ) ; break ; case 4 : printf ( "The<S2SV_blank>total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>seats<S2SV_blank>available<S2SV_blank>in<S2SV_blank>the<S2SV_blank>auditorium<S2SV_blank>is:<S2SV_blank>%d" , 30 - seatsSold ) ; break ; return 0 ; } } | <S2SV_ModStart> seats [ row - 1 ] [ seat - 1 <S2SV_ModEnd> ] == '*' <S2SV_ModStart> seats [ row - 1 ] [ seat - 1 <S2SV_ModEnd> ] = '#' |
3,633 | CWE-000 static void unix_forward_cb ( EV_P_ ev_io * w , int revents ) { int ret ; struct lem_mbedtls_sock_forward * event = get_parent_struct ( struct lem_mbedtls_sock_forward , runix , w ) ; int len ; ( void ) revents ; <S2SV_StartBug> if ( event -> status ) return ; <S2SV_EndBug> do { len = sizeof ( event -> u_rbuf ) - event -> u_rlen ; <S2SV_StartBug> if ( len <= 0 ) return ; <S2SV_EndBug> ret = read ( w -> fd , event -> u_rbuf , len ) ; if ( ret == - 1 ) { if ( errno == EAGAIN || errno == EINTR ) { return ; } } if ( ret <= 0 ) { idle_stop_sock_forwarding ( EV_A_ & event -> idle , EV_CLEANUP ) ; return ; } event -> u_rlen += ret ; ssl_write_cb ( EV_A_ & event -> wssl , EV_WRITE ) ; } while ( event -> u_rlen == 0 ) ; ev_io_start ( EV_A_ & event -> wssl ) ; } | <S2SV_ModStart> event -> status == IDLE_CLOSE <S2SV_ModStart> <= 0 ) { event -> status = IDLE_REARM_UNIX_WATCHER ; ev_idle_init ( & event -> idle , idle_restart_unix_watcher ) ; ev_idle_start ( EV_A_ & event -> idle ) ; ev_io_stop ( EV_A_ w ) ; return ; } <S2SV_ModEnd> ret = read |
3,634 | CWE-000 void genCode_tree_Ident_struct_dec ( Node * root , Node * self ) { TypeDefEntry * tent = searchTag ( self -> tkn -> text ) ; if ( parse_flag & SET_MEMBER ) { if ( root != self && tagName_tmp != NULL && strcmp ( tagName_tmp , self -> tkn -> text ) == 0 ) { if ( root -> tkn -> kind != '*' ) error ( "this<S2SV_blank>struct<S2SV_blank>should<S2SV_blank>be<S2SV_blank>reference" ) ; left_val . var -> dType = STRUCTP_T ; left_val . dataSize = POINTER_SIZE ; left_val . var -> tagName = tagName_tmp ; parse_flag |= IS_DECLARE ; } else if ( tent != NULL ) { left_val . var -> dType = STRUCT_T ; <S2SV_StartBug> left_val . var -> tagName = self -> tkn -> text ; <S2SV_EndBug> left_val . dataSize = tent -> dataSize ; } else if ( root == self ) { TypeDefTable [ typedef_ent_ct ] . tagName = ( char * ) malloc ( self -> tkn -> intVal ) ; memcpy ( TypeDefTable [ typedef_ent_ct ++ ] . tagName , self -> tkn -> text , self -> tkn -> intVal ) ; } else { left_val . var -> name = malloc ( sizeof ( char ) * ( self -> tkn -> intVal + 1 ) ) ; memcpy ( left_val . var -> name , self -> tkn -> text , self -> tkn -> intVal ) ; VarElement * varp = & TypeDefTable [ typedef_ent_ct ] . var ; if ( TypeDefTable [ typedef_ent_ct ] . structEntCount > 0 ) { while ( varp -> nxtVar != NULL ) varp = varp -> nxtVar ; varp -> nxtVar = ( VarElement * ) malloc ( sizeof ( VarElement ) ) ; varp = varp -> nxtVar ; } memcpy ( varp , left_val . var , sizeof ( VarElement ) ) ; memcpy ( varp -> name , left_val . var -> name , 10 ) ; if ( varp -> dType == STRUCT_T ) TypeDefTable [ typedef_ent_ct ] . dataSize += left_val . dataSize ; else TypeDefTable [ typedef_ent_ct ] . dataSize += DATA_SIZE [ varp -> dType ] ; TypeDefTable [ typedef_ent_ct ] . structEntCount ++ ; } } else if ( tent != NULL && self -> l -> tkn -> kind == Struct ) { left_val . var -> dType = STRUCT_T ; left_val . structEntCount = tent -> structEntCount ; left_val . dataSize = tent -> dataSize ; left_val . var -> nxtVar = & tent -> var ; left_val . var -> tagName = tent -> tagName ; parse_flag |= IS_DECLARE ; } else { genCode_tree_dec ( root , self ) ; } } | <S2SV_ModStart> -> tagName = ( char * ) malloc ( self -> tkn -> intVal ) ; memcpy ( left_val . var -> tagName , <S2SV_ModStart> tkn -> text , self -> tkn -> intVal ) |
3,635 | CWE-000 void vdi_vqt_attributes ( Vwk * vwk ) { WORD * pointer ; const Fonthead * fnt_ptr ; pointer = INTOUT ; fnt_ptr = vwk -> cur_font ; * pointer ++ = fnt_ptr -> font_id ; * pointer ++ = REV_MAP_COL [ vwk -> text_color ] ; * pointer ++ = vwk -> chup ; * pointer ++ = vwk -> h_align ; * pointer ++ = vwk -> v_align ; <S2SV_StartBug> * pointer = vwk -> wrt_mode ; <S2SV_EndBug> pointer = PTSOUT ; * pointer ++ = fnt_ptr -> max_char_width ; * pointer ++ = fnt_ptr -> top ; * pointer ++ = fnt_ptr -> max_cell_width ; * pointer = fnt_ptr -> top + fnt_ptr -> bottom + 1 ; CONTRL [ 2 ] = 2 ; CONTRL [ 4 ] = 6 ; flip_y = 1 ; } | <S2SV_ModStart> vwk -> wrt_mode + 1 |
3,636 | CWE-000 static bool opt_intrinsics_impl ( nir_function_impl * impl ) { nir_builder b ; nir_builder_init ( & b , impl ) ; bool progress = false ; nir_foreach_block ( block , impl ) { nir_foreach_instr_safe ( instr , block ) { if ( instr -> type != nir_instr_type_intrinsic ) continue ; nir_intrinsic_instr * intrin = nir_instr_as_intrinsic ( instr ) ; nir_ssa_def * replacement = NULL ; b . cursor = nir_before_instr ( instr ) ; switch ( intrin -> intrinsic ) { case nir_intrinsic_vote_any : case nir_intrinsic_vote_all : { nir_const_value * val = nir_src_as_const_value ( intrin -> src [ 0 ] ) ; if ( ! val && ! b . shader -> options -> lower_vote_trivial ) continue ; replacement = nir_ssa_for_src ( & b , intrin -> src [ 0 ] , 1 ) ; break ; } case nir_intrinsic_vote_eq : { nir_const_value * val = nir_src_as_const_value ( intrin -> src [ 0 ] ) ; if ( ! val && ! b . shader -> options -> lower_vote_trivial ) continue ; replacement = nir_imm_int ( & b , NIR_TRUE ) ; break ; } case nir_intrinsic_ballot : { assert ( b . shader -> options -> max_subgroup_size != 0 ) ; if ( b . shader -> options -> max_subgroup_size > 32 || intrin -> dest . ssa . bit_size <= 32 ) continue ; nir_intrinsic_instr * ballot = nir_intrinsic_instr_create ( b . shader , nir_intrinsic_ballot ) ; nir_ssa_dest_init ( & ballot -> instr , & ballot -> dest , 1 , 32 , NULL ) ; nir_src_copy ( & ballot -> src [ 0 ] , & intrin -> src [ 0 ] , ballot ) ; nir_builder_instr_insert ( & b , & ballot -> instr ) ; replacement = nir_pack_64_2x32_split ( & b , & ballot -> dest . ssa , nir_imm_int ( & b , 0 ) ) ; break ; } case nir_intrinsic_load_subgroup_eq_mask : case nir_intrinsic_load_subgroup_ge_mask : case nir_intrinsic_load_subgroup_gt_mask : case nir_intrinsic_load_subgroup_le_mask : case nir_intrinsic_load_subgroup_lt_mask : { if ( ! b . shader -> options -> lower_subgroup_masks ) break ; nir_ssa_def * count = nir_load_subgroup_invocation ( & b ) ; switch ( intrin -> intrinsic ) { case nir_intrinsic_load_subgroup_eq_mask : replacement = nir_ishl ( & b , nir_imm_int64 ( & b , 1ull ) , count ) ; break ; case nir_intrinsic_load_subgroup_ge_mask : replacement = nir_ishl ( & b , nir_imm_int64 ( & b , ~ 0ull ) , count ) ; break ; case nir_intrinsic_load_subgroup_gt_mask : replacement = nir_ishl ( & b , nir_imm_int64 ( & b , ~ 1ull ) , count ) ; break ; case nir_intrinsic_load_subgroup_le_mask : replacement = nir_inot ( & b , nir_ishl ( & b , nir_imm_int64 ( & b , ~ 1ull ) , count ) ) ; break ; case nir_intrinsic_load_subgroup_lt_mask : replacement = nir_inot ( & b , nir_ishl ( & b , nir_imm_int64 ( & b , ~ 0ull ) , count ) ) ; break ; default : unreachable ( "you<S2SV_blank>seriously<S2SV_blank>can\'t<S2SV_blank>tell<S2SV_blank>this<S2SV_blank>is<S2SV_blank>unreachable?" ) ; } break ; } default : break ; } if ( ! replacement ) continue ; nir_ssa_def_rewrite_uses ( & intrin -> dest . ssa , nir_src_for_ssa ( replacement ) ) ; nir_instr_remove ( instr ) ; <S2SV_StartBug> nir_metadata_preserve ( impl , nir_metadata_block_index | <S2SV_EndBug> nir_metadata_dominance ) ; progress = true ; } } return progress ; } | <S2SV_ModStart> instr ) ; <S2SV_ModEnd> progress = true |
3,637 | CWE-000 static ssize_t show_kb_wake_angle ( struct device * dev , struct device_attribute * attr , char * buf ) { struct ec_response_motion_sense * resp ; struct ec_params_motion_sense * param ; struct cros_ec_command * msg ; int ret ; struct cros_ec_dev * ec = container_of ( dev , struct cros_ec_dev , class_dev ) ; msg = kmalloc ( sizeof ( * msg ) + EC_HOST_PARAM_SIZE , GFP_KERNEL ) ; if ( ! msg ) return - ENOMEM ; param = ( struct ec_params_motion_sense * ) msg -> data ; msg -> command = EC_CMD_MOTION_SENSE_CMD + ec -> cmd_offset ; msg -> version = 2 ; param -> cmd = MOTIONSENSE_CMD_KB_WAKE_ANGLE ; param -> kb_wake_angle . data = EC_MOTION_SENSE_NO_VALUE ; msg -> outsize = sizeof ( * param ) ; msg -> insize = sizeof ( * resp ) ; ret = cros_ec_cmd_xfer_status ( ec -> ec_dev , msg ) ; if ( ret < 0 ) <S2SV_StartBug> return ret ; <S2SV_EndBug> resp = ( struct ec_response_motion_sense * ) msg -> data ; <S2SV_StartBug> return scnprintf ( buf , PAGE_SIZE , "%d\\n" , <S2SV_EndBug> resp -> kb_wake_angle . ret ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> < 0 ) goto exit <S2SV_ModEnd> ; resp = <S2SV_ModStart> -> data ; ret = <S2SV_ModEnd> scnprintf ( buf <S2SV_ModStart> ret ) ; exit : kfree ( msg ) ; return ret ; |
3,638 | CWE-000 static int alloc_user_pages ( struct hmm_buffer_object * bo , void * userptr , bool cached ) { int page_nr ; int i ; struct vm_area_struct * vma ; struct page * * pages ; <S2SV_StartBug> pages = kmalloc ( sizeof ( struct page * ) * bo -> pgnr , GFP_KERNEL ) ; <S2SV_EndBug> if ( unlikely ( ! pages ) ) { dev_err ( atomisp_dev , "out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>pages...\\n" ) ; return - ENOMEM ; } <S2SV_StartBug> bo -> page_obj = kmalloc ( sizeof ( struct hmm_page_object ) * bo -> pgnr , <S2SV_EndBug> GFP_KERNEL ) ; if ( unlikely ( ! bo -> page_obj ) ) { dev_err ( atomisp_dev , "out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>bo->page_obj...\\n" ) ; kfree ( pages ) ; return - ENOMEM ; } mutex_unlock ( & bo -> mutex ) ; down_read ( & current -> mm -> mmap_sem ) ; vma = find_vma ( current -> mm , ( unsigned long ) userptr ) ; up_read ( & current -> mm -> mmap_sem ) ; if ( vma == NULL ) { dev_err ( atomisp_dev , "find_vma<S2SV_blank>failed\\n" ) ; kfree ( bo -> page_obj ) ; kfree ( pages ) ; mutex_lock ( & bo -> mutex ) ; return - EFAULT ; } mutex_lock ( & bo -> mutex ) ; if ( vma -> vm_flags & ( VM_IO | VM_PFNMAP ) ) { page_nr = get_pfnmap_pages ( current , current -> mm , ( unsigned long ) userptr , ( int ) ( bo -> pgnr ) , 1 , 0 , pages , NULL ) ; bo -> mem_type = HMM_BO_MEM_TYPE_PFN ; } else { mutex_unlock ( & bo -> mutex ) ; down_read ( & current -> mm -> mmap_sem ) ; page_nr = get_user_pages ( ( unsigned long ) userptr , ( int ) ( bo -> pgnr ) , 1 , pages , NULL ) ; up_read ( & current -> mm -> mmap_sem ) ; mutex_lock ( & bo -> mutex ) ; bo -> mem_type = HMM_BO_MEM_TYPE_USER ; } if ( page_nr != bo -> pgnr ) { dev_err ( atomisp_dev , "get_user_pages<S2SV_blank>err:<S2SV_blank>bo->pgnr<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>" "pgnr<S2SV_blank>actually<S2SV_blank>pinned<S2SV_blank>=<S2SV_blank>%d.\\n" , bo -> pgnr , page_nr ) ; goto out_of_mem ; } for ( i = 0 ; i < bo -> pgnr ; i ++ ) { bo -> page_obj [ i ] . page = pages [ i ] ; bo -> page_obj [ i ] . type = HMM_PAGE_TYPE_GENERAL ; } hmm_mem_stat . usr_size += bo -> pgnr ; kfree ( pages ) ; return 0 ; out_of_mem : for ( i = 0 ; i < page_nr ; i ++ ) put_page ( pages [ i ] ) ; kfree ( pages ) ; kfree ( bo -> page_obj ) ; return - ENOMEM ; } | <S2SV_ModStart> ; pages = kmalloc_array ( bo -> pgnr , <S2SV_ModEnd> sizeof ( struct <S2SV_ModStart> page * ) <S2SV_ModEnd> , GFP_KERNEL ) <S2SV_ModStart> -> page_obj = kmalloc_array ( bo -> pgnr , <S2SV_ModEnd> sizeof ( struct <S2SV_ModStart> struct hmm_page_object ) <S2SV_ModEnd> , GFP_KERNEL ) |
3,639 | CWE-000 PyObject * <S2SV_StartBug> glfw_post_empty_event ( PyObject UNUSED * self ) { <S2SV_EndBug> glfwPostEmptyEvent ( ) ; Py_RETURN_NONE ; } | <S2SV_ModStart> * glfw_post_empty_event ( PYNOARG <S2SV_ModEnd> ) { glfwPostEmptyEvent |
3,640 | CWE-000 static void parse_config_file ( char * cfg_file ) { char line [ 200 ] ; FILE * file = fopen ( cfg_file , "r" ) ; if ( file != NULL ) { while ( fgets ( line , 200 , file ) != NULL ) { char * arg , * val ; if ( line [ 0 ] == '#' ) continue ; if ( line [ 0 ] == '\\n' ) continue ; arg = strtok ( line , "=" ) ; if ( arg == NULL ) continue ; val = strtok ( NULL , "=" ) ; char * nl_check ; nl_check = strstr ( val , "\\n" ) ; if ( nl_check != NULL ) strncpy ( nl_check , "<S2SV_blank>" , 1 ) ; char * arg_val = strdup ( val ) ; if ( ! strcasecmp ( arg , "ipv6" ) ) { app_cfg . ipv6 = atoi ( val ) ; continue ; } if ( ! strcasecmp ( arg , "sd" ) ) { app_cfg . sip_domain = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "su" ) ) { app_cfg . sip_user = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "sp" ) ) { app_cfg . sip_password = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "ln" ) ) { app_cfg . language = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "rc" ) ) { app_cfg . record_calls = atoi ( val ) ; continue ; } if ( ! strcasecmp ( arg , "af" ) ) { app_cfg . announcement_file = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "cmd" ) ) { app_cfg . CallCmd = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "am" ) ) { app_cfg . AfterMath = trim_string ( arg_val ) ; continue ; } if ( ! strcasecmp ( arg , "s" ) ) { app_cfg . silent_mode = atoi ( val ) ; continue ; } if ( ! strcasecmp ( arg , "tts" ) ) { app_cfg . tts = arg_val ; continue ; } char dtmf_id [ 1 ] ; char dtmf_setting [ 25 ] ; <S2SV_StartBug> if ( sscanf ( arg , "dtmf.%d/*1[^.]*/.%s" , dtmf_id , dtmf_setting ) == 2 ) <S2SV_EndBug> { int d_id ; d_id = atoi ( dtmf_id ) ; if ( d_id >= MAX_DTMF_SETTINGS ) continue ; struct dtmf_config * d_cfg = & app_cfg . dtmf_cfg [ d_id ] ; if ( ! strcasecmp ( dtmf_setting , "active" ) ) { d_cfg -> active = atoi ( val ) ; continue ; } if ( ! strcasecmp ( dtmf_setting , "description" ) ) { d_cfg -> description = arg_val ; continue ; } if ( ! strcasecmp ( dtmf_setting , "tts-intro" ) ) { d_cfg -> tts_intro = arg_val ; continue ; } if ( ! strcasecmp ( dtmf_setting , "audio-response" ) ) { d_cfg -> audio_response_file = trim_string ( arg_val ) ; FILE * file ; if ( ( file = fopen ( d_cfg -> audio_response_file , "r" ) ) == NULL ) { if ( errno == ENOENT ) { log_message ( "Audio<S2SV_blank>file<S2SV_blank>doesn\'t<S2SV_blank>exist" ) ; } else { log_message ( "Audio<S2SV_blank>file:<S2SV_blank>some<S2SV_blank>other<S2SV_blank>error<S2SV_blank>occured" ) ; } d_cfg -> audio_response_file = NULL ; } continue ; } if ( ! strcasecmp ( dtmf_setting , "tts-answer" ) ) { d_cfg -> tts_answer = arg_val ; continue ; } if ( ! strcasecmp ( dtmf_setting , "cmd" ) ) { d_cfg -> cmd = arg_val ; continue ; } } char warning [ 200 ] ; sprintf ( warning , "Warning:<S2SV_blank>Unknown<S2SV_blank>configuration<S2SV_blank>with<S2SV_blank>arg<S2SV_blank>\'%s\'<S2SV_blank>and<S2SV_blank>val<S2SV_blank>\'%s\'\\n" , arg , val ) ; log_message ( warning ) ; } fclose ( file ) ; } else { log_message ( "Error<S2SV_blank>while<S2SV_blank>parsing<S2SV_blank>config<S2SV_blank>file:<S2SV_blank>Not<S2SV_blank>found.\\n" ) ; exit ( 1 ) ; } } | <S2SV_ModStart> ( arg , "dtmf.%2[^^.].%s" <S2SV_ModEnd> , dtmf_id , |
3,641 | CWE-000 f2fs_hash_t f2fs_dentry_hash ( const char * name , int len ) { __u32 hash , minor_hash ; f2fs_hash_t f2fs_hash ; const char * p ; __u32 in [ 8 ] , buf [ 4 ] ; buf [ 0 ] = 0x67452301 ; buf [ 1 ] = 0xefcdab89 ; buf [ 2 ] = 0x98badcfe ; buf [ 3 ] = 0x10325476 ; p = name ; while ( len > 0 ) { str2hashbuf ( p , len , in , 4 ) ; TEA_transform ( buf , in ) ; len -= 16 ; p += 16 ; } hash = buf [ 0 ] ; minor_hash = buf [ 1 ] ; <S2SV_StartBug> f2fs_hash = hash ; <S2SV_EndBug> f2fs_hash &= ~ F2FS_HASH_COL_BIT ; return f2fs_hash ; } | <S2SV_ModStart> ; f2fs_hash = cpu_to_le32 ( hash & ~ F2FS_HASH_COL_BIT ) <S2SV_ModEnd> ; return f2fs_hash |
3,642 | CWE-000 static gboolean gst_vaapi_video_buffer_pool_set_config ( GstBufferPool * pool , GstStructure * config ) { GstVaapiVideoBufferPoolPrivate * const priv = GST_VAAPI_VIDEO_BUFFER_POOL ( pool ) -> priv ; GstCaps * caps ; GstVideoInfo new_allocation_vinfo ; const GstVideoInfo * allocator_vinfo ; const GstVideoInfo * negotiated_vinfo ; GstVideoAlignment align ; GstAllocator * allocator ; gboolean ret , updated = FALSE ; guint size , min_buffers , max_buffers ; guint surface_alloc_flags ; GST_DEBUG_OBJECT ( pool , "config<S2SV_blank>%" GST_PTR_FORMAT , config ) ; caps = NULL ; if ( ! gst_buffer_pool_config_get_params ( config , & caps , & size , & min_buffers , & max_buffers ) ) goto error_invalid_config ; if ( ! caps ) goto error_no_caps ; if ( ! gst_video_info_from_caps ( & new_allocation_vinfo , caps ) ) goto error_invalid_caps ; allocator = NULL ; if ( ! gst_buffer_pool_config_get_allocator ( config , & allocator , NULL ) ) goto error_invalid_allocator ; if ( allocator && ( g_strcmp0 ( allocator -> mem_type , GST_VAAPI_VIDEO_MEMORY_NAME ) != 0 && g_strcmp0 ( allocator -> mem_type , GST_VAAPI_DMABUF_ALLOCATOR_NAME ) != 0 ) ) allocator = NULL ; if ( allocator ) { priv -> use_dmabuf_memory = gst_vaapi_is_dmabuf_allocator ( allocator ) ; negotiated_vinfo = gst_allocator_get_vaapi_negotiated_video_info ( allocator ) ; allocator_vinfo = gst_allocator_get_vaapi_video_info ( allocator , & surface_alloc_flags ) ; } else { priv -> use_dmabuf_memory = FALSE ; negotiated_vinfo = NULL ; allocator_vinfo = NULL ; surface_alloc_flags = 0 ; } if ( allocator_vinfo && gst_video_info_changed ( allocator_vinfo , & new_allocation_vinfo ) ) { gst_object_replace ( ( GstObject * * ) & priv -> allocator , NULL ) ; if ( allocator && priv -> use_dmabuf_memory ) { gst_allocator_set_vaapi_video_info ( allocator , & new_allocation_vinfo , surface_alloc_flags ) ; } else { allocator = NULL ; } } if ( ! gst_buffer_pool_config_has_option ( config , GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META ) ) goto error_no_vaapi_video_meta_option ; if ( ! allocator ) { if ( priv -> use_dmabuf_memory ) { allocator = gst_vaapi_dmabuf_allocator_new ( priv -> display , & new_allocation_vinfo , 0 , GST_PAD_SRC ) ; } else { allocator = gst_vaapi_video_allocator_new ( priv -> display , & new_allocation_vinfo , surface_alloc_flags , 0 ) ; } if ( ! allocator ) goto error_no_allocator ; if ( negotiated_vinfo ) { gst_allocator_set_vaapi_negotiated_video_info ( allocator , negotiated_vinfo ) ; } GST_INFO_OBJECT ( pool , "created<S2SV_blank>new<S2SV_blank>allocator<S2SV_blank>%" GST_PTR_FORMAT , allocator ) ; gst_buffer_pool_config_set_allocator ( config , allocator , NULL ) ; gst_object_unref ( allocator ) ; } if ( allocator ) { if ( priv -> allocator ) gst_object_unref ( priv -> allocator ) ; if ( ( priv -> allocator = allocator ) ) gst_object_ref ( allocator ) ; negotiated_vinfo = gst_allocator_get_vaapi_negotiated_video_info ( priv -> allocator ) ; <S2SV_StartBug> priv -> vmeta_vinfo = ( negotiated_vinfo ) ? <S2SV_EndBug> <S2SV_StartBug> * negotiated_vinfo : new_allocation_vinfo ; <S2SV_EndBug> allocator_vinfo = gst_allocator_get_vaapi_video_info ( allocator , NULL ) ; if ( GST_VIDEO_INFO_SIZE ( allocator_vinfo ) != size ) { gst_buffer_pool_config_set_params ( config , caps , GST_VIDEO_INFO_SIZE ( allocator_vinfo ) , min_buffers , max_buffers ) ; } } if ( ! priv -> allocator ) goto error_no_allocator ; priv -> options = 0 ; if ( gst_buffer_pool_config_has_option ( config , GST_BUFFER_POOL_OPTION_VIDEO_META ) ) { priv -> options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META ; } else { gint i ; for ( i = 0 ; i < GST_VIDEO_INFO_N_PLANES ( & new_allocation_vinfo ) ; i ++ ) { if ( GST_VIDEO_INFO_PLANE_OFFSET ( & new_allocation_vinfo , i ) != GST_VIDEO_INFO_PLANE_OFFSET ( & priv -> vmeta_vinfo , i ) || GST_VIDEO_INFO_PLANE_STRIDE ( & new_allocation_vinfo , i ) != GST_VIDEO_INFO_PLANE_STRIDE ( & priv -> vmeta_vinfo , i ) ) { priv -> options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META ; gst_buffer_pool_config_add_option ( config , GST_BUFFER_POOL_OPTION_VIDEO_META ) ; updated = TRUE ; break ; } } } if ( gst_buffer_pool_config_has_option ( config , GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT ) ) { fill_video_alignment ( GST_VAAPI_VIDEO_BUFFER_POOL ( pool ) , & align ) ; gst_buffer_pool_config_set_video_alignment ( config , & align ) ; } if ( ! priv -> use_dmabuf_memory && gst_buffer_pool_config_has_option ( config , GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META ) ) priv -> options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD ; ret = GST_BUFFER_POOL_CLASS ( gst_vaapi_video_buffer_pool_parent_class ) -> set_config ( pool , config ) ; return ! updated && ret ; error_invalid_config : { GST_ERROR_OBJECT ( pool , "invalid<S2SV_blank>config" ) ; return FALSE ; } error_no_caps : { GST_ERROR_OBJECT ( pool , "no<S2SV_blank>caps<S2SV_blank>in<S2SV_blank>config" ) ; return FALSE ; } error_invalid_caps : { GST_ERROR_OBJECT ( pool , "invalid<S2SV_blank>caps<S2SV_blank>%" GST_PTR_FORMAT , caps ) ; return FALSE ; } error_invalid_allocator : { GST_ERROR_OBJECT ( pool , "no<S2SV_blank>allocator<S2SV_blank>in<S2SV_blank>config" ) ; return FALSE ; } error_no_vaapi_video_meta_option : { GST_ERROR_OBJECT ( pool , "no<S2SV_blank>GstVaapiVideoMeta<S2SV_blank>option<S2SV_blank>in<S2SV_blank>config" ) ; return FALSE ; } error_no_allocator : { GST_ERROR_OBJECT ( pool , "no<S2SV_blank>allocator<S2SV_blank>defined" ) ; return FALSE ; } } | <S2SV_ModStart> allocator ) ; allocator_vinfo = gst_allocator_get_vaapi_video_info ( allocator , NULL ) ; <S2SV_ModStart> * negotiated_vinfo : * allocator_vinfo <S2SV_ModEnd> ; if ( |
3,643 | CWE-000 int hdd_wlan_start_modules ( hdd_context_t * hdd_ctx , hdd_adapter_t * adapter , bool reinit ) { int ret = 0 ; qdf_device_t qdf_dev ; QDF_STATUS status ; p_cds_contextType p_cds_context ; bool unint = false ; void * hif_ctx ; ENTER ( ) ; p_cds_context = cds_get_global_context ( ) ; if ( ! p_cds_context ) { hdd_err ( "Global<S2SV_blank>Context<S2SV_blank>is<S2SV_blank>NULL" ) ; QDF_ASSERT ( 0 ) ; return - EINVAL ; } hdd_debug ( "start<S2SV_blank>modules<S2SV_blank>called<S2SV_blank>in<S2SV_blank><S2SV_blank>state!<S2SV_blank>:%d<S2SV_blank>reinit:<S2SV_blank>%d" , hdd_ctx -> driver_status , reinit ) ; qdf_dev = cds_get_context ( QDF_MODULE_ID_QDF_DEVICE ) ; if ( ! qdf_dev ) { hdd_err ( "QDF<S2SV_blank>Device<S2SV_blank>Context<S2SV_blank>is<S2SV_blank>Invalid<S2SV_blank>return" ) ; return - EINVAL ; } qdf_cancel_delayed_work ( & hdd_ctx -> iface_idle_work ) ; mutex_lock ( & hdd_ctx -> iface_change_lock ) ; if ( hdd_ctx -> driver_status == DRIVER_MODULES_ENABLED ) { mutex_unlock ( & hdd_ctx -> iface_change_lock ) ; hdd_info ( "Driver<S2SV_blank>modules<S2SV_blank>already<S2SV_blank>Enabled" ) ; EXIT ( ) ; return 0 ; } hdd_ctx -> start_modules_in_progress = true ; switch ( hdd_ctx -> driver_status ) { case DRIVER_MODULES_UNINITIALIZED : hdd_info ( "Wlan<S2SV_blank>transition<S2SV_blank>(UNINITIALIZED<S2SV_blank>-><S2SV_blank>CLOSED)" ) ; unint = true ; case DRIVER_MODULES_CLOSED : hdd_info ( "Wlan<S2SV_blank>transition<S2SV_blank>(CLOSED<S2SV_blank>-><S2SV_blank>OPENED)" ) ; qdf_mem_set_domain ( QDF_MEM_DOMAIN_ACTIVE ) ; if ( ! reinit && ! unint ) { ret = pld_power_on ( qdf_dev -> dev ) ; if ( ret ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>Powerup<S2SV_blank>the<S2SV_blank>device:<S2SV_blank>%d" , ret ) ; goto release_lock ; } } pld_set_fw_log_mode ( hdd_ctx -> parent_dev , hdd_ctx -> config -> enable_fw_log ) ; ret = hdd_hif_open ( qdf_dev -> dev , qdf_dev -> drv_hdl , qdf_dev -> bid , qdf_dev -> bus_type , ( reinit == true ) ? HIF_ENABLE_TYPE_REINIT : HIF_ENABLE_TYPE_PROBE ) ; if ( ret ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>hif:<S2SV_blank>%d" , ret ) ; goto power_down ; } hif_ctx = cds_get_context ( QDF_MODULE_ID_HIF ) ; if ( ! hif_ctx ) { hdd_err ( "hif<S2SV_blank>context<S2SV_blank>is<S2SV_blank>null!!" ) ; goto power_down ; } status = ol_cds_init ( qdf_dev , hif_ctx ) ; if ( status != QDF_STATUS_SUCCESS ) { hdd_err ( "No<S2SV_blank>Memory<S2SV_blank>to<S2SV_blank>Create<S2SV_blank>BMI<S2SV_blank>Context<S2SV_blank>:%d" , status ) ; goto hif_close ; } ret = hdd_update_config ( hdd_ctx ) ; if ( ret ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>update<S2SV_blank>configuration<S2SV_blank>:%d" , ret ) ; goto ol_cds_free ; } status = cds_open ( ) ; if ( ! QDF_IS_STATUS_SUCCESS ( status ) ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>Open<S2SV_blank>CDS:<S2SV_blank>%d" , status ) ; ret = ( status == QDF_STATUS_E_NOMEM ) ? - ENOMEM : - EINVAL ; goto deinit_config ; } hdd_ctx -> hHal = cds_get_context ( QDF_MODULE_ID_SME ) ; status = cds_pre_enable ( hdd_ctx -> pcds_context ) ; if ( ! QDF_IS_STATUS_SUCCESS ( status ) ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>pre-enable<S2SV_blank>CDS:<S2SV_blank>%d" , status ) ; ret = ( status == QDF_STATUS_E_NOMEM ) ? - ENOMEM : - EINVAL ; goto close ; } hdd_ctx -> driver_status = DRIVER_MODULES_OPENED ; hdd_info ( "Wlan<S2SV_blank>transition<S2SV_blank>(now<S2SV_blank>OPENED)" ) ; hdd_update_hw_sw_info ( hdd_ctx ) ; if ( QDF_GLOBAL_FTM_MODE == hdd_get_conparam ( ) ) { sme_register_ftm_msg_processor ( hdd_ctx -> hHal , hdd_ftm_mc_process_msg ) ; break ; } if ( unint ) { hdd_debug ( "In<S2SV_blank>phase-1<S2SV_blank>initialization<S2SV_blank><S2SV_blank>don\'t<S2SV_blank>enable<S2SV_blank>modules" ) ; break ; } if ( reinit ) { if ( hdd_ipa_uc_ssr_reinit ( hdd_ctx ) ) { hdd_err ( "HDD<S2SV_blank>IPA<S2SV_blank>UC<S2SV_blank>reinit<S2SV_blank>failed" ) ; goto post_disable ; } } case DRIVER_MODULES_OPENED : hdd_info ( "Wlan<S2SV_blank>transition<S2SV_blank>(OPENED<S2SV_blank>-><S2SV_blank>ENABLED)" ) ; if ( ! adapter ) { hdd_err ( "adapter<S2SV_blank>is<S2SV_blank>Null" ) ; goto post_disable ; } if ( QDF_GLOBAL_FTM_MODE == hdd_get_conparam ( ) ) { hdd_err ( "in<S2SV_blank>ftm<S2SV_blank>mode,<S2SV_blank>no<S2SV_blank>need<S2SV_blank>to<S2SV_blank>configure<S2SV_blank>cds<S2SV_blank>modules" ) ; break ; } if ( hdd_configure_cds ( hdd_ctx , adapter ) ) { hdd_err ( "Failed<S2SV_blank>to<S2SV_blank>Enable<S2SV_blank>cds<S2SV_blank>modules" ) ; goto post_disable ; } hdd_enable_power_management ( ) ; hdd_info ( "Driver<S2SV_blank>Modules<S2SV_blank>Successfully<S2SV_blank>Enabled" ) ; hdd_ctx -> driver_status = DRIVER_MODULES_ENABLED ; break ; default : hdd_err ( "WLAN<S2SV_blank>start<S2SV_blank>invoked<S2SV_blank>in<S2SV_blank>wrong<S2SV_blank>state!<S2SV_blank>:%d\\n" , hdd_ctx -> driver_status ) ; goto release_lock ; } hdd_ctx -> start_modules_in_progress = false ; mutex_unlock ( & hdd_ctx -> iface_change_lock ) ; EXIT ( ) ; return 0 ; post_disable : <S2SV_StartBug> cds_post_disable ( ) ; <S2SV_EndBug> close : hdd_ctx -> driver_status = DRIVER_MODULES_CLOSED ; cds_close ( p_cds_context ) ; deinit_config : cds_deinit_ini_config ( ) ; ol_cds_free : ol_cds_free ( ) ; hif_close : hdd_hif_close ( p_cds_context -> pHIFContext ) ; power_down : if ( ! reinit && ! unint ) pld_power_off ( qdf_dev -> dev ) ; release_lock : hdd_ctx -> start_modules_in_progress = false ; mutex_unlock ( & hdd_ctx -> iface_change_lock ) ; <S2SV_StartBug> if ( ! reinit ) <S2SV_EndBug> hdd_check_for_leaks ( ) ; qdf_mem_set_domain ( QDF_MEM_DOMAIN_INIT ) ; EXIT ( ) ; return ret ; } | <S2SV_ModStart> ; post_disable : sme_destroy_config ( hdd_ctx -> hHal ) ; <S2SV_ModStart> ; if ( hdd_ctx -> target_hw_name ) { qdf_mem_free ( hdd_ctx -> target_hw_name ) ; hdd_ctx -> target_hw_name = NULL ; } if ( |
3,644 | CWE-000 void <S2SV_StartBug> deinit_wifi_conf_resource ( ) <S2SV_EndBug> { oc_delete_resource ( g_wificonf_resource . handle ) ; g_wificonf_resource . handle = NULL ; es_free_property ( g_wificonf_resource . ssid ) ; es_free_property ( g_wificonf_resource . cred ) ; } | <S2SV_ModStart> void deinit_wifi_conf_resource ( void |
3,645 | CWE-000 void scan_str ( void ) { assert ( * stream == \'"\' ) ; stream ++ ; char * str = NULL ; if ( stream [ 0 ] == \'"\' && stream [ 1 ] == \'"\' ) { stream += 2 ; while ( * stream ) { if ( stream [ 0 ] == \'"\' && stream [ 1 ] == \'"\' && stream [ 2 ] == \'"\' ) { stream += 3 ; break ; } if ( * stream != '\\r' ) { buf_push ( str , * stream ) ; } if ( * stream == '\\n' ) { token . pos . line ++ ; } stream ++ ; } if ( ! * stream ) { error_here ( "Unexpected<S2SV_blank>end<S2SV_blank>of<S2SV_blank>file<S2SV_blank>within<S2SV_blank>multi-line<S2SV_blank>string<S2SV_blank>literal" ) ; } token . mod = MOD_MULTILINE ; } else { while ( * stream && * stream != \'"\' ) { char val = * stream ; if ( val == '\\n' ) { error_here ( "String<S2SV_blank>literal<S2SV_blank>cannot<S2SV_blank>contain<S2SV_blank>newline" ) ; break ; } else if ( val == '\\\\' ) { stream ++ ; if ( * stream == 'x' ) { val = scan_hex_escape ( ) ; } else { val = escape_to_char [ ( unsigned char ) * stream ] ; if ( val == 0 && * stream != '0' ) { error_here ( "Invalid<S2SV_blank>string<S2SV_blank>literal<S2SV_blank>escape<S2SV_blank>\'\\\\%c\'" , * stream ) ; } stream ++ ; } } else { stream ++ ; } buf_push ( str , val ) ; } if ( * stream ) { <S2SV_StartBug> assert ( * stream == \'"\' ) ; <S2SV_EndBug> stream ++ ; } else { error_here ( "Unexpected<S2SV_blank>end<S2SV_blank>of<S2SV_blank>file<S2SV_blank>within<S2SV_blank>string<S2SV_blank>literal" ) ; } } buf_push ( str , 0 ) ; token . kind = TOKEN_STR ; token . str_val = str ; } | <S2SV_ModStart> stream ) { <S2SV_ModEnd> stream ++ ; |
3,646 | CWE-000 void DVS_forward_pc ( uint8_t forward , uint16_t timeout_ms ) { if ( forward == true ) { if ( xSemaphoreTake ( xFwdSemaphore , portMAX_DELAY ) == pdTRUE ) { forward_pc_flag = true ; if ( timeout_ms > 0 ) { xTimerChangePeriod ( reset_timer , timeout_ms / portTICK_PERIOD_MS , portMAX_DELAY ) ; } xSemaphoreGive ( xFwdSemaphore ) ; } } else { <S2SV_StartBug> xTimerStop ( reset_timer , portMAX_DELAY ) ; <S2SV_EndBug> reset_fwd_flag ( NULL ) ; } } | <S2SV_ModStart> } else { if ( xTimerIsTimerActive ( reset_timer ) ) { <S2SV_ModStart> portMAX_DELAY ) ; } |
3,647 | CWE-000 static inline void timer_free ( struct posix_timer_s * timer ) { irqstate_t flags ; flags = irqsave ( ) ; sq_rem ( ( FAR sq_entry_t * ) timer , ( sq_queue_t * ) & g_alloctimers ) ; # if CONFIG_PREALLOC_TIMERS > 0 if ( ( timer -> pt_flags & PT_FLAGS_PREALLOCATED ) != 0 ) { sq_addlast ( ( FAR sq_entry_t * ) timer , ( FAR sq_queue_t * ) & g_freetimers ) ; irqrestore ( flags ) ; } else # endif { irqrestore ( flags ) ; sched_kfree ( timer ) ; } <S2SV_StartBug> timer -> pt_flags &= ~ PT_FLAGS_INUSE ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,648 | CWE-000 static void pci_configure_device ( struct pci_dev * dev ) { struct hotplug_params hpp ; int ret ; pci_configure_mps ( dev ) ; <S2SV_StartBug> pci_configure_extended_tags ( dev ) ; <S2SV_EndBug> memset ( & hpp , 0 , sizeof ( hpp ) ) ; ret = pci_get_hp_params ( dev , & hpp ) ; if ( ret ) return ; program_hpp_type2 ( dev , hpp . t2 ) ; program_hpp_type1 ( dev , hpp . t1 ) ; program_hpp_type0 ( dev , hpp . t0 ) ; } | <S2SV_ModStart> pci_configure_extended_tags ( dev , NULL |
3,649 | CWE-000 static void <S2SV_StartBug> nvmet_fc_format_rsp_hdr ( void * buf , u8 ls_cmd , u32 desc_len , u8 rqst_ls_cmd ) <S2SV_EndBug> { struct fcnvme_ls_acc_hdr * acc = buf ; acc -> w0 . ls_cmd = ls_cmd ; acc -> desc_list_len = desc_len ; acc -> rqst . desc_tag = cpu_to_be32 ( FCNVME_LSDESC_RQST ) ; acc -> rqst . desc_len = fcnvme_lsdesc_len ( sizeof ( struct fcnvme_lsdesc_rqst ) ) ; acc -> rqst . w0 . ls_cmd = rqst_ls_cmd ; } | <S2SV_ModStart> u8 ls_cmd , __be32 <S2SV_ModEnd> desc_len , u8 |
3,650 | CWE-000 int main ( int argc , char * argv [ ] ) { int num_results = NUM_RESULTS ; if ( argc == 3 ) { num_results = atoi ( argv [ 2 ] ) ; if ( num_results > NUM_PAGES ) { num_results = NUM_PAGES ; } } else if ( argc != 2 ) { perror ( "Invalid<S2SV_blank>syntax:<S2SV_blank>driver<S2SV_blank>[filename]<S2SV_blank>(num_results)\\n" ) ; exit ( 2 ) ; } ui_init ( ) ; char * addr = argv [ 1 ] ; double rank_result [ NUM_PAGES ] ; construct_matrix ( addr , rank_result ) ; char * names [ NUM_PAGES ] ; get_names ( addr , names ) ; <S2SV_StartBug> char str [ 80 ] ; <S2SV_EndBug> sprintf ( str , "Starting<S2SV_blank>page<S2SV_blank>rank<S2SV_blank>calculation.<S2SV_blank>I<S2SV_blank>got<S2SV_blank>:<S2SV_blank>%.10f" , rank_result [ 0 ] ) ; <S2SV_StartBug> ui_add_message ( NULL , str ) ; <S2SV_EndBug> int search_session = 1 ; while ( true ) { char * message = ui_read_input ( ) ; for ( int i = 0 ; message [ i ] ; i ++ ) { message [ i ] = tolower ( message [ i ] ) ; } if ( strcmp ( message , "quit" ) == 0 ) { ui_shutdown ( ) ; return 0 ; } else { char initial_msg [ 50 ] ; sprintf ( initial_msg , "Search<S2SV_blank>session<S2SV_blank>#%d" , search_session ) ; search_session ++ ; <S2SV_StartBug> ui_add_message ( "Google<S2SV_blank>0.5<S2SV_blank>Presents<S2SV_blank>to<S2SV_blank>you<S2SV_blank>:<S2SV_blank>" , initial_msg ) ; <S2SV_EndBug> <S2SV_StartBug> int result_pages [ num_results * 256 ] ; <S2SV_EndBug> int page_count = 0 ; bool found = false ; <S2SV_StartBug> for ( int i = 0 ; i < NUM_PAGES ; i ++ ) { <S2SV_EndBug> if ( strstr ( names [ i ] , message ) != NULL && page_count < num_results ) { found = true ; result_pages [ page_count ] = i ; page_count ++ ; } } if ( found ) { for ( int i = 0 ; i < page_count ; i ++ ) { char output_message [ 128 ] ; sprintf ( output_message , "%s<S2SV_blank>was<S2SV_blank>found<S2SV_blank>with<S2SV_blank>Page<S2SV_blank>Rank<S2SV_blank>of<S2SV_blank>%.8f" , names [ result_pages [ i ] ] , rank_result [ result_pages [ i ] ] ) ; ui_add_message ( NULL , output_message ) ; ui_clear_input ( ) ; } free ( message ) ; continue ; } else { char * output_message = strcat ( message , "<S2SV_blank>is<S2SV_blank>not<S2SV_blank>known<S2SV_blank>to<S2SV_blank>The<S2SV_blank>Avengers" ) ; ui_add_message ( NULL , output_message ) ; ui_clear_input ( ) ; free ( message ) ; continue ; } } } } | <S2SV_ModStart> names ) ; <S2SV_ModEnd> ui_add_message ( NULL <S2SV_ModStart> ( NULL , "--------------------------<S2SV_blank>Welcome<S2SV_blank>to<S2SV_blank>HeroRank<S2SV_blank>---------------------------" ) ; ui_add_message ( NULL , "--------------<S2SV_blank>World\'s<S2SV_blank>Premier<S2SV_blank>Search<S2SV_blank>Engine<S2SV_blank>for<S2SV_blank>the<S2SV_blank>MCU<S2SV_blank>--------------" <S2SV_ModEnd> ) ; int <S2SV_ModStart> ; ui_add_message ( "HeroRank<S2SV_blank>Presents<S2SV_blank>to<S2SV_blank>you<S2SV_blank>:<S2SV_blank>" <S2SV_ModEnd> , initial_msg ) <S2SV_ModStart> result_pages [ num_results <S2SV_ModEnd> ] ; int <S2SV_ModStart> ++ ) { if ( page_count > num_results ) break ; |
3,651 | CWE-000 void swaynag_types_add_default ( list_t * types ) { struct swaynag_type * type_defaults ; type_defaults = calloc ( 1 , sizeof ( struct swaynag_type ) ) ; type_defaults -> name = strdup ( "<defaults>" ) ; type_defaults -> font = strdup ( "pango:Monospace<S2SV_blank>10" ) ; type_defaults -> anchors = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT ; <S2SV_StartBug> type_defaults -> bar_border_thickness = 2 ; <S2SV_EndBug> type_defaults -> message_padding = 8 ; type_defaults -> details_border_thickness = 3 ; type_defaults -> button_border_thickness = 3 ; type_defaults -> button_gap = 20 ; type_defaults -> button_gap_close = 15 ; type_defaults -> button_margin_right = 2 ; type_defaults -> button_padding = 3 ; list_add ( types , type_defaults ) ; struct swaynag_type * type_error ; type_error = calloc ( 1 , sizeof ( struct swaynag_type ) ) ; <S2SV_StartBug> type_error -> name = strdup ( "error" ) ; <S2SV_EndBug> type_error -> button_background = 0x680A0AFF ; type_error -> background = 0x900000FF ; type_error -> text = 0xFFFFFFFF ; type_error -> border = 0xD92424FF ; type_error -> border_bottom = 0x470909FF ; list_add ( types , type_error ) ; struct swaynag_type * type_warning ; type_warning = calloc ( 1 , sizeof ( struct swaynag_type ) ) ; type_warning -> name = strdup ( "warning" ) ; type_warning -> button_background = 0xFFC100FF ; type_warning -> background = 0xFFA800FF ; type_warning -> text = 0x000000FF ; type_warning -> border = 0xAB7100FF ; type_warning -> border_bottom = 0xAB7100FF ; list_add ( types , type_warning ) ; } | <S2SV_ModStart> ; type_defaults -> button_background = 0x680A0AFF ; type_defaults -> background = 0x900000FF ; type_defaults -> text = 0xFFFFFFFF ; type_defaults -> border = 0xD92424FF ; type_defaults -> border_bottom = 0x470909FF ; type_defaults -> <S2SV_ModStart> ( "error" ) <S2SV_ModEnd> ; list_add ( |
3,652 | CWE-000 static ssize_t lms_read ( struct file * filp , char * buff , size_t len , loff_t * off ) { list_elem me ; list_elem * aux ; const int MINOR_CURRENT = iminor ( filp -> f_path . dentry -> d_inode ) ; int ret ; DECLARE_WAIT_QUEUE_HEAD ( the_queue ) ; me . next = NULL ; me . prev = NULL ; me . task = current ; me . awake = NO ; me . already_hit = NO ; if ( * off > 0 ) { if ( DEBUG ) printk ( KERN_INFO "%s:<S2SV_blank>offset<S2SV_blank>less<S2SV_blank>than<S2SV_blank>zero<S2SV_blank>in<S2SV_blank>lms_read<S2SV_blank>off:<S2SV_blank>%Ld,<S2SV_blank>FAILURE" , MODNAME , * off ) ; return 0 ; } if ( len <= 0 ) { printk ( KERN_INFO "%s:<S2SV_blank>called<S2SV_blank>a<S2SV_blank>read<S2SV_blank>with<S2SV_blank>negative<S2SV_blank>buffer<S2SV_blank>len<S2SV_blank>\\n" , MODNAME ) ; return FAILURE ; } else if ( mailslots [ MINOR_CURRENT ] -> head == NULL ) { if ( DEBUG ) printk ( KERN_INFO "%s:<S2SV_blank>No<S2SV_blank>message<S2SV_blank>in<S2SV_blank>the<S2SV_blank>mailslot,<S2SV_blank>len<S2SV_blank>assigned<S2SV_blank>to<S2SV_blank>default<S2SV_blank>\\n" , MODNAME ) ; len = INIT_MESSAGE_SIZE ; } else if ( len < mailslots [ MINOR_CURRENT ] -> head -> size ) { printk ( KERN_INFO "%s:<S2SV_blank>called<S2SV_blank>a<S2SV_blank>read<S2SV_blank>with<S2SV_blank>a<S2SV_blank>len<S2SV_blank>not<S2SV_blank>compliant<S2SV_blank>with<S2SV_blank>the<S2SV_blank>message<S2SV_blank>size,<S2SV_blank>the<S2SV_blank>read<S2SV_blank>hs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>all<S2SV_blank>or<S2SV_blank>nothing<S2SV_blank>\\n" , MODNAME ) ; return FAILURE ; } else { len = mailslots [ MINOR_CURRENT ] -> head -> size ; } if ( DEBUG ) printk ( KERN_INFO "%s:<S2SV_blank>valid<S2SV_blank>lenght\\n" , MODNAME ) ; spin_lock ( & ( mailslots [ MINOR_CURRENT ] -> queue_lock ) ) ; while ( mailslots [ MINOR_CURRENT ] -> head == NULL ) { if ( mailslots [ MINOR_CURRENT ] -> blocking == NON_BLOCKING ) { printk ( KERN_INFO "%s:<S2SV_blank>No<S2SV_blank>messages<S2SV_blank>to<S2SV_blank>read<S2SV_blank>in<S2SV_blank>this<S2SV_blank>mailslot,<S2SV_blank>exiting...\\n" , MODNAME ) ; spin_unlock ( & ( mailslots [ MINOR_CURRENT ] -> queue_lock ) ) ; return FAILURE ; } aux = mailslots [ MINOR_CURRENT ] -> r_queue -> head ; if ( aux == NULL ) { mailslots [ MINOR_CURRENT ] -> r_queue -> head = & me ; mailslots [ MINOR_CURRENT ] -> r_queue -> tail = & me ; } else { aux = mailslots [ MINOR_CURRENT ] -> r_queue -> tail ; if ( aux == NULL || ( aux -> prev == NULL && aux != mailslots [ MINOR_CURRENT ] -> r_queue -> head ) ) { spin_unlock ( & ( mailslots [ MINOR_CURRENT ] -> queue_lock ) ) ; printk ( KERN_INFO "%s:<S2SV_blank>malformed<S2SV_blank>read<S2SV_blank>queue,<S2SV_blank>aborted" , MODNAME ) ; return FAILURE ; } aux -> next = & me ; me . prev = aux ; me . next = NULL ; mailslots [ MINOR_CURRENT ] -> r_queue -> tail = & me ; } spin_unlock ( & ( mailslots [ MINOR_CURRENT ] -> queue_lock ) ) ; ret = wait_event_interruptible ( the_queue , mailslots [ MINOR_CURRENT ] -> head != NULL ) ; if ( ret != 0 ) { printk ( KERN_INFO "%s:<S2SV_blank>The<S2SV_blank>process<S2SV_blank>[read]<S2SV_blank>%d<S2SV_blank>has<S2SV_blank>been<S2SV_blank>awaken<S2SV_blank>by<S2SV_blank>a<S2SV_blank>signal\\n" , MODNAME , current -> pid ) ; return FAILURE ; } spin_lock ( & ( mailslots [ MINOR_CURRENT ] ) -> queue_lock ) ; if ( me . next != NULL ) me . next -> prev = me . prev ; if ( me . prev != NULL ) me . prev -> next = me . next ; if ( me . prev == NULL && me . next == NULL ) { mailslots [ MINOR_CURRENT ] -> r_queue -> head = NULL ; mailslots [ MINOR_CURRENT ] -> r_queue -> tail = NULL ; } } if ( len < mailslots [ MINOR_CURRENT ] -> head -> size ) { spin_unlock ( & ( mailslots [ MINOR_CURRENT ] ) -> queue_lock ) ; <S2SV_StartBug> printk ( KERN_INFO "%s:<S2SV_blank>called<S2SV_blank>a<S2SV_blank>read<S2SV_blank>with<S2SV_blank>a<S2SV_blank>len<S2SV_blank>not<S2SV_blank>compliant<S2SV_blank>with<S2SV_blank>the<S2SV_blank>message<S2SV_blank>size,<S2SV_blank>the<S2SV_blank>read<S2SV_blank>hs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>all<S2SV_blank>or<S2SV_blank>nothing<S2SV_blank>" , MODNAME ) ; <S2SV_EndBug> return FAILURE ; } else { len = mailslots [ MINOR_CURRENT ] -> head -> size ; } pop_message ( mailslots [ MINOR_CURRENT ] , buff ) ; aux = mailslots [ MINOR_CURRENT ] -> w_queue -> head ; <S2SV_StartBug> while ( aux != NULL ) { <S2SV_EndBug> if ( aux -> already_hit == NO ) { aux -> awake = YES ; aux -> already_hit = YES ; wake_up_process ( aux -> task ) ; break ; } aux = aux -> next ; } spin_unlock ( & ( mailslots [ MINOR_CURRENT ] ) -> queue_lock ) ; if ( DEBUG ) printk ( KERN_INFO "%s:<S2SV_blank>read<S2SV_blank>performed,<S2SV_blank>read<S2SV_blank>%ld<S2SV_blank>bytes\\n" , MODNAME , len ) ; * off = len ; return len ; } | <S2SV_ModStart> queue_lock ) ; awake_queue ( mailslots [ MINOR_CURRENT ] -> r_queue -> head , MINOR_CURRENT ) ; <S2SV_ModStart> -> head ; awake_queue ( aux , MINOR_CURRENT ) ; <S2SV_ModEnd> spin_unlock ( & |
3,653 | CWE-000 <S2SV_StartBug> static void * print_section ( void * accum , const void * data , uint32_t size , uint32_t flags , const char * section_name ) <S2SV_EndBug> { <S2SV_StartBug> UNUSED ( data ) ; <S2SV_EndBug> <S2SV_StartBug> UNUSED ( size ) ; <S2SV_EndBug> printf ( "%s<S2SV_blank>%s\\n" , section_name , flags & BEAM_START_FLAG ? "*" : "" ) ; return accum ; } | <S2SV_ModStart> const void * section_ptr , uint32_t section_size , const void * beam_ptr <S2SV_ModEnd> , uint32_t flags <S2SV_ModStart> { UNUSED ( section_ptr <S2SV_ModEnd> ) ; UNUSED <S2SV_ModStart> ; UNUSED ( section_size ) ; UNUSED ( beam_ptr <S2SV_ModEnd> ) ; printf |
3,654 | CWE-000 bool binlog_next_file_exists ( const char * binlogdir , const char * binlog ) { bool rval = false ; int filenum = blr_file_get_next_binlogname ( binlog ) ; if ( filenum ) { char * sptr = strrchr ( binlog , '.' ) ; if ( sptr ) { char buf [ BLRM_BINLOG_NAME_STR_LEN + 1 ] ; char filename [ PATH_MAX + 1 ] ; <S2SV_StartBug> char next_file [ BLRM_BINLOG_NAME_STR_LEN + 1 ] ; <S2SV_EndBug> int offset = sptr - binlog ; memcpy ( buf , binlog , offset ) ; buf [ offset ] = '\\0' ; <S2SV_StartBug> sprintf ( next_file , BINLOG_NAMEFMT , buf , filenum ) ; <S2SV_EndBug> snprintf ( filename , PATH_MAX , "%s/%s" , binlogdir , next_file ) ; filename [ PATH_MAX ] = '\\0' ; if ( access ( filename , R_OK ) == - 1 ) { MXS_DEBUG ( "File<S2SV_blank>\'%s\'<S2SV_blank>does<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>exist." , filename ) ; } else { rval = true ; } } } return rval ; } | <S2SV_ModStart> BLRM_BINLOG_NAME_STR_LEN + 1 + 20 <S2SV_ModStart> = '\\0' ; snprintf ( next_file , sizeof ( next_file ) <S2SV_ModEnd> , BINLOG_NAMEFMT , |
3,655 | CWE-000 static struct crypto_poll_ctl * qcrypto_poll_ctl_alloc ( struct crypto_priv * cp , int cpu ) { struct crypto_poll_ctl * ctl = NULL ; list_for_each_entry ( ctl , & cp -> poll_ctl_list , list ) { if ( ctl -> cpu == cpu ) return ctl ; } ctl = kzalloc ( sizeof ( * ctl ) , GFP_KERNEL ) ; if ( ! ctl ) return NULL ; ctl -> wq = alloc_workqueue ( "qcrypto_poll_wq" , WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_CPU_INTENSIVE , 1 ) ; if ( ! ctl -> wq ) { pr_err ( "Error<S2SV_blank>allocating<S2SV_blank>workqueue\\n" ) ; kfree ( ctl ) ; return NULL ; } INIT_WORK ( & ctl -> work , qcrypto_poll_work ) ; <S2SV_StartBug> tasklet_hrtimer_init ( & ctl -> timer , qcrypto_poll_timeout , <S2SV_EndBug> CLOCK_MONOTONIC , HRTIMER_MODE_REL ) ; spin_lock_init ( & ctl -> lock ) ; INIT_LIST_HEAD ( & ctl -> engine_list ) ; ctl -> cp = cp ; <S2SV_StartBug> ctl -> cpu = cpu ; <S2SV_EndBug> ctl -> state = NOT_SCHEDULED ; ctl -> max_retry = DEFAULT_POLL_RETRY ; ctl -> pm_support = ( cp -> ce_support . clk_mgmt_sus_res || cp -> platform_support . bus_scale_table ) ? true : false ; list_add_tail ( & ctl -> list , & cp -> poll_ctl_list ) ; cp -> poll_ctl_num ++ ; return ctl ; } | <S2SV_ModStart> qcrypto_poll_work ) ; tasklet_init ( & ctl -> task , qcrypto_poll_task , ( unsigned long ) ctl ) ; hrtimer_init <S2SV_ModEnd> ( & ctl <S2SV_ModStart> -> timer , CLOCK_MONOTONIC , HRTIMER_MODE_REL | HRTIMER_MODE_PINNED ) ; ctl -> timer . function = qcrypto_poll_timeout <S2SV_ModEnd> ; spin_lock_init ( <S2SV_ModStart> cpu = cpu ; ctl -> intval = ns_to_ktime ( MICRO_TO_NS ( DEFAULT_POLL_INTVAL ) ) |
3,656 | CWE-000 static struct filenode * get_filenode ( const char * name , struct filenode * * prt ) { if ( ! ROOT ) return NULL ; if ( strcmp ( ROOT -> name , name + 1 ) == 0 ) { <S2SV_StartBug> if ( prt != NULL ) * prt = NULL ; <S2SV_EndBug> return ROOT ; } struct filenode * node = ROOT ; while ( node -> next ) { if ( strcmp ( node -> next -> name , name + 1 ) != 0 ) node = node -> next ; else { <S2SV_StartBug> if ( prt != NULL ) * prt = node ; <S2SV_EndBug> return node -> next ; } } return NULL ; } | <S2SV_ModStart> if ( prt <S2SV_ModEnd> ) * prt <S2SV_ModStart> if ( prt <S2SV_ModEnd> ) * prt |
3,657 | CWE-000 xmpp_stanza_t * xmpp_stanza_reply ( xmpp_stanza_t * const stanza ) { <S2SV_StartBug> xmpp_stanza_t * copy ; <S2SV_EndBug> copy = xmpp_stanza_new ( stanza -> ctx ) ; if ( ! copy ) goto copy_error ; copy -> type = stanza -> type ; if ( stanza -> data ) { copy -> data = xmpp_strdup ( stanza -> ctx , stanza -> data ) ; if ( ! copy -> data ) goto copy_error ; } if ( stanza -> attributes ) { <S2SV_StartBug> if ( _stanza_copy_attributes ( copy , stanza ) == - 1 ) <S2SV_EndBug> goto copy_error ; } <S2SV_StartBug> xmpp_stanza_set_to ( copy , xmpp_stanza_get_from ( stanza ) ) ; <S2SV_EndBug> <S2SV_StartBug> xmpp_stanza_del_attribute ( copy , "from" ) ; <S2SV_EndBug> return copy ; copy_error : if ( copy ) xmpp_stanza_release ( copy ) ; return NULL ; } | <S2SV_ModStart> xmpp_stanza_t * copy = NULL ; const char * from ; int rc ; from = xmpp_stanza_get_from ( stanza ) ; if ( ! from ) goto copy_error <S2SV_ModStart> , stanza ) < 0 <S2SV_ModEnd> ) goto copy_error <S2SV_ModStart> copy_error ; } xmpp_stanza_del_attribute <S2SV_ModEnd> ( copy , <S2SV_ModStart> ( copy , "to" <S2SV_ModEnd> ) ; xmpp_stanza_del_attribute <S2SV_ModStart> , "from" ) ; rc = xmpp_stanza_set_to ( copy , from ) ; if ( rc != XMPP_EOK ) goto copy_error |
3,658 | CWE-000 void netvsc_device_remove ( struct hv_device * device ) { struct net_device * ndev = hv_get_drvdata ( device ) ; struct net_device_context * net_device_ctx = netdev_priv ( ndev ) ; struct netvsc_device * net_device = rtnl_dereference ( net_device_ctx -> nvdev ) ; int i ; netvsc_revoke_buf ( device , net_device ) ; RCU_INIT_POINTER ( net_device_ctx -> nvdev , NULL ) ; for ( i = 0 ; i < net_device -> num_chn ; i ++ ) netif_napi_del ( & net_device -> chan_table [ i ] . napi ) ; netdev_dbg ( ndev , "net<S2SV_blank>device<S2SV_blank>safe<S2SV_blank>to<S2SV_blank>remove\\n" ) ; <S2SV_StartBug> if ( net_device -> nvsp_version < NVSP_PROTOCOL_VERSION_4 ) <S2SV_EndBug> netvsc_teardown_gpadl ( device , net_device ) ; vmbus_close ( device -> channel ) ; <S2SV_StartBug> if ( net_device -> nvsp_version >= NVSP_PROTOCOL_VERSION_4 ) <S2SV_EndBug> netvsc_teardown_gpadl ( device , net_device ) ; free_netvsc_device_rcu ( net_device ) ; } | <S2SV_ModStart> ; if ( vmbus_proto_version < VERSION_WIN10 <S2SV_ModEnd> ) netvsc_teardown_gpadl ( <S2SV_ModStart> ; if ( vmbus_proto_version >= VERSION_WIN10 <S2SV_ModEnd> ) netvsc_teardown_gpadl ( |
3,659 | CWE-000 <S2SV_StartBug> enum bus_error bus_memory_unmap ( struct bus_s * bus , uintptr_t address ) <S2SV_EndBug> { return BER_OTHER ; } | <S2SV_ModStart> * bus , uint32_t <S2SV_ModEnd> address ) { |
3,660 | CWE-000 void rgb_set_color_bg ( unsigned rgb ) { unsigned r , g , b ; <S2SV_StartBug> r = ( rgb & 0xFF0000 ) >> 4 ; <S2SV_EndBug> <S2SV_StartBug> g = ( rgb & 0x00FF00 ) >> 2 ; <S2SV_EndBug> b = ( rgb & 0x0000FF ) ; printf ( "\\x1b[48;2;%d;%d;%dm" , r , g , b ) ; } | <S2SV_ModStart> 0xFF0000 ) >> 16 <S2SV_ModEnd> ; g = <S2SV_ModStart> 0x00FF00 ) >> 8 <S2SV_ModEnd> ; b = |
3,661 | CWE-000 static int imxfb_of_read_mode ( struct device * dev , struct device_node * np , struct imx_fb_videomode * imxfb_mode ) { int ret ; struct fb_videomode * of_mode = & imxfb_mode -> mode ; u32 bpp ; u32 pcr ; ret = of_property_read_string ( np , "model" , & of_mode -> name ) ; if ( ret ) of_mode -> name = NULL ; ret = of_get_fb_videomode ( np , of_mode , OF_USE_NATIVE_MODE ) ; if ( ret ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>videomode<S2SV_blank>from<S2SV_blank>DT\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "bits-per-pixel" , & bpp ) ; ret |= of_property_read_u32 ( np , "fsl,pcr" , & pcr ) ; if ( ret ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>bpp<S2SV_blank>and<S2SV_blank>pcr<S2SV_blank>from<S2SV_blank>DT\\n" ) ; return - EINVAL ; } if ( bpp < 1 || bpp > 255 ) { dev_err ( dev , "Bits<S2SV_blank>per<S2SV_blank>pixel<S2SV_blank>have<S2SV_blank>to<S2SV_blank>be<S2SV_blank>between<S2SV_blank>1<S2SV_blank>and<S2SV_blank>255\\n" ) ; return - EINVAL ; } imxfb_mode -> bpp = bpp ; imxfb_mode -> pcr = pcr ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> = pcr ; imxfb_mode -> aus_mode = of_property_read_bool ( np , "fsl,aus-mode" ) ; |
3,662 | CWE-000 void CR_DefineObject ( void ) { unsigned short int nArg ; short int nDatum = 0 ; unsigned char cChar ; <S2SV_StartBug> if ( nEvent >= 0 && nEvent <= 19 ) <S2SV_EndBug> { EndEvent ( ) ; nEvent = - 1 ; } do { nArg = NextKeyword ( ) ; if ( nArg == INS_NUM ) { cChar = ( char ) GetNum ( 8 ) ; fwrite ( & cChar , 1 , 1 , pWorkObj ) ; nDatum ++ ; } else { Error ( "Missing<S2SV_blank>data<S2SV_blank>for<S2SV_blank>DEFINEOBJECT" ) ; nDatum = 36 ; } } while ( nDatum < 36 ) ; nObjects ++ ; } | <S2SV_ModStart> 0 && nEvent < NUM_EVENTS <S2SV_ModEnd> ) { EndEvent |
3,663 | CWE-000 static int window_copy_pagedown ( struct window_pane * wp , int half_page , int scroll_exit ) { struct window_copy_mode_data * data = wp -> modedata ; struct screen * s = & data -> screen ; u_int n , ox , oy , px , py ; oy = screen_hsize ( data -> backing ) + data -> cy - data -> oy ; ox = window_copy_find_length ( wp , oy ) ; <S2SV_StartBug> if ( data -> lineflag == LINE_SEL_RIGHT_LEFT && oy == data -> sely ) <S2SV_EndBug> window_copy_other_end ( wp ) ; if ( data -> cx != ox ) { data -> lastcx = data -> cx ; data -> lastsx = ox ; } data -> cx = data -> lastcx ; n = 1 ; if ( screen_size_y ( s ) > 2 ) { if ( half_page ) n = screen_size_y ( s ) / 2 ; else n = screen_size_y ( s ) - 2 ; } <S2SV_StartBug> if ( data -> oy < n ) <S2SV_EndBug> data -> oy = 0 ; <S2SV_StartBug> else <S2SV_EndBug> data -> oy -= n ; if ( data -> screen . sel == NULL || ! data -> rectflag ) { py = screen_hsize ( data -> backing ) + data -> cy - data -> oy ; px = window_copy_find_length ( wp , py ) ; if ( ( data -> cx >= data -> lastsx && data -> cx != px ) || data -> cx > px ) window_copy_cursor_end_of_line ( wp ) ; } if ( scroll_exit && data -> oy == 0 ) return ( 1 ) ; window_copy_update_selection ( wp , 1 ) ; window_copy_redraw_screen ( wp ) ; return ( 0 ) ; } | <S2SV_ModStart> ( data -> <S2SV_ModEnd> cx != ox <S2SV_ModStart> < n ) { <S2SV_ModStart> = 0 ; if ( data -> cy + ( n - data -> oy ) >= screen_size_y ( data -> backing ) ) data -> cy = screen_size_y ( data -> backing ) - 1 ; else data -> cy += n - data -> oy ; } |
3,664 | CWE-000 int ft_number_of_line ( char * grid ) { char * tab ; int len ; char * param_line ; param_line = ft_grid_get_line ( grid , 1 ) ; <S2SV_StartBug> len = ft_strlen ( param_line ) - 3 ; <S2SV_EndBug> if ( ! ( tab = ( char * ) malloc ( sizeof ( char ) * len + 1 ) ) ) return ( 0 ) ; tab [ len ] = '\\0' ; tab = ft_strncpy ( tab , param_line , len ) ; len = ft_atoi ( tab ) ; <S2SV_StartBug> free ( tab ) ; <S2SV_EndBug> return ( len ) ; } | <S2SV_ModStart> param_line ) - 4 <S2SV_ModEnd> ; if ( <S2SV_ModStart> tab ) ; printf ( "line<S2SV_blank>nbr,<S2SV_blank>tab:<S2SV_blank>%d\\n" , len ) ; |
3,665 | CWE-000 static inline void calc_nfrags_get ( mca_bml_base_btl_t * bml_btl , size_t size , unsigned int * frag_size , int * nfrags , int use_send ) { if ( use_send ) { * frag_size = bml_btl -> btl -> btl_max_send_size - SPML_YODA_SEND_CONTEXT_SIZE ; } else { <S2SV_StartBug> * frag_size = bml_btl -> btl -> btl_get_limit ; <S2SV_EndBug> } * nfrags = 1 + ( size - 1 ) / ( * frag_size ) ; } | <S2SV_ModStart> -> btl -> btl_max_send_size <S2SV_ModEnd> ; } * |
3,666 | CWE-000 static void undoCompound ( edge_t * e , graph_t * clg ) { node_t * t = agtail ( e ) ; node_t * h = aghead ( e ) ; node_t * ntail ; node_t * nhead ; <S2SV_StartBug> edge_t * ce ; <S2SV_EndBug> if ( ! ( IS_CLUST_NODE ( t ) || IS_CLUST_NODE ( h ) ) ) return ; ntail = mapN ( t , clg ) ; nhead = mapN ( h , clg ) ; ce = cloneEdge ( e , ntail , nhead ) ; ED_spl ( ce ) = ED_spl ( e ) ; ED_spl ( e ) = NULL ; ED_label ( ce ) = ED_label ( e ) ; ED_label ( e ) = NULL ; ED_xlabel ( ce ) = ED_xlabel ( e ) ; ED_xlabel ( e ) = NULL ; ED_head_label ( ce ) = ED_head_label ( e ) ; ED_head_label ( e ) = NULL ; ED_tail_label ( ce ) = ED_tail_label ( e ) ; ED_tail_label ( e ) = NULL ; gv_cleanup_edge ( e ) ; } | <S2SV_ModStart> edge_t * ce <S2SV_ModEnd> ; ntail = |
3,667 | CWE-000 int rmt_receive ( struct rmt * rmt , struct du * du , port_id_t from ) { pdu_type_t pdu_type ; address_t dst_addr ; qos_id_t qos_id ; struct rmt_n1_port * n1_port ; ssize_t bytes ; if ( ! rmt ) { LOG_ERR ( "No<S2SV_blank>RMT<S2SV_blank>passed" ) ; du_destroy ( du ) ; return - 1 ; } if ( ! is_port_id_ok ( from ) ) { LOG_ERR ( "Wrong<S2SV_blank>port-id<S2SV_blank>%d" , from ) ; du_destroy ( du ) ; return - 1 ; } bytes = du_len ( du ) ; du -> cfg = rmt -> efcpc -> config ; n1_port = n1pmap_find ( rmt , from ) ; if ( ! n1_port ) { LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>retrieve<S2SV_blank>N-1<S2SV_blank>port<S2SV_blank>for<S2SV_blank>the<S2SV_blank>received<S2SV_blank>PDU..." ) ; du_destroy ( du ) ; return - 1 ; } stats_inc ( rx , n1_port , bytes ) ; if ( sdup_unprotect_pdu ( n1_port -> sdup_port , du ) ) { LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>unprotect<S2SV_blank>PDU" ) ; du_destroy ( du ) ; return - 1 ; } if ( sdup_get_lifetime_limit ( n1_port -> sdup_port , du ) ) { LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>PDU\'s<S2SV_blank>TTL" ) ; du_destroy ( du ) ; return - 1 ; } n1pmap_release ( rmt , n1_port ) ; if ( unlikely ( du_decap ( du ) ) ) { LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>decap<S2SV_blank>PDU" ) ; du_destroy ( du ) ; return - 1 ; } <S2SV_StartBug> if ( ! pci_is_ok ( & du -> pci ) ) { <S2SV_EndBug> LOG_ERR ( "No<S2SV_blank>PCI<S2SV_blank>to<S2SV_blank>work<S2SV_blank>with,<S2SV_blank>dropping<S2SV_blank>SDU!" ) ; du_destroy ( du ) ; return - 1 ; } pdu_type = pci_type ( & du -> pci ) ; dst_addr = pci_destination ( & du -> pci ) ; qos_id = pci_qos_id ( & du -> pci ) ; if ( ! pdu_type_is_ok ( pdu_type ) || ! is_address_ok ( dst_addr ) || ! is_qos_id_ok ( qos_id ) ) { LOG_ERR ( "Wrong<S2SV_blank>PDU<S2SV_blank>type<S2SV_blank>(%u),<S2SV_blank>dst<S2SV_blank>address<S2SV_blank>(%u)<S2SV_blank>or<S2SV_blank>qos_id<S2SV_blank>(%u)" , pdu_type , dst_addr , qos_id ) ; du_destroy ( du ) ; return - 1 ; } if ( pdu_is_addressed_to_me ( rmt , dst_addr ) ) { switch ( pdu_type ) { case PDU_TYPE_MGMT : return process_mgmt_pdu ( rmt , from , du ) ; case PDU_TYPE_CACK : case PDU_TYPE_SACK : case PDU_TYPE_NACK : case PDU_TYPE_FC : case PDU_TYPE_ACK : case PDU_TYPE_ACK_AND_FC : case PDU_TYPE_DT : return process_dt_pdu ( rmt , from , du ) ; default : LOG_ERR ( "Unknown<S2SV_blank>PDU<S2SV_blank>type<S2SV_blank>%d" , pdu_type ) ; du_destroy ( du ) ; return - 1 ; } } else { if ( ! dst_addr ) return process_mgmt_pdu ( rmt , from , du ) ; else { if ( unlikely ( du_encap ( du , pdu_type ) ) ) return - 1 ; if ( sdup_dec_check_lifetime_limit ( n1_port -> sdup_port , du ) ) { LOG_ERR ( "Lifetime<S2SV_blank>of<S2SV_blank>PDU<S2SV_blank>reached<S2SV_blank>dropping<S2SV_blank>PDU!" ) ; du_destroy ( du ) ; return - 1 ; } return rmt_send ( rmt , du ) ; } } } | <S2SV_ModStart> 1 ; } <S2SV_ModEnd> pdu_type = pci_type |
3,668 | CWE-000 static GLboolean _mesa_remove_extra_moves ( struct gl_program * prog ) { GLboolean * removeInst ; GLuint i , rem = 0 , nesting = 0 ; if ( dbg ) { printf ( "Optimize:<S2SV_blank>Begin<S2SV_blank>remove<S2SV_blank>extra<S2SV_blank>moves\\n" ) ; _mesa_print_program ( prog ) ; } removeInst = <S2SV_StartBug> calloc ( 1 , prog -> NumInstructions * sizeof ( GLboolean ) ) ; <S2SV_EndBug> for ( i = 0 ; i < prog -> NumInstructions ; i ++ ) { const struct prog_instruction * mov = prog -> Instructions + i ; switch ( mov -> Opcode ) { case OPCODE_BGNLOOP : case OPCODE_BGNSUB : case OPCODE_IF : nesting ++ ; break ; case OPCODE_ENDLOOP : case OPCODE_ENDSUB : case OPCODE_ENDIF : nesting -- ; break ; case OPCODE_MOV : if ( i > 0 && can_downward_mov_be_modifed ( mov ) && mov -> SrcReg [ 0 ] . File == PROGRAM_TEMPORARY && nesting == 0 ) { const GLuint id = mov -> SrcReg [ 0 ] . Index ; struct prog_instruction * prevInst ; GLuint prevI ; prevI = i - 1 ; while ( prevI > 0 && removeInst [ prevI ] ) prevI -- ; prevInst = prog -> Instructions + prevI ; if ( prevInst -> DstReg . File == PROGRAM_TEMPORARY && prevInst -> DstReg . Index == id && prevInst -> DstReg . RelAddr == 0 && prevInst -> DstReg . CondMask == COND_TR ) { const GLuint dst_mask = prevInst -> DstReg . WriteMask ; enum inst_use next_use = find_next_use ( prog , i + 1 , id , dst_mask ) ; if ( next_use == WRITE || next_use == END ) { if ( _mesa_merge_mov_into_inst ( prevInst , mov ) ) { removeInst [ i ] = GL_TRUE ; if ( dbg ) { printf ( "Remove<S2SV_blank>MOV<S2SV_blank>at<S2SV_blank>%u\\n" , i ) ; printf ( "new<S2SV_blank>prev<S2SV_blank>inst<S2SV_blank>%u:<S2SV_blank>" , prevI ) ; _mesa_print_instruction ( prevInst ) ; } } } } } break ; default : ; } } rem = remove_instructions ( prog , removeInst ) ; free ( removeInst ) ; if ( dbg ) { printf ( "Optimize:<S2SV_blank>End<S2SV_blank>remove<S2SV_blank>extra<S2SV_blank>moves.<S2SV_blank><S2SV_blank>%u<S2SV_blank>instructions<S2SV_blank>removed\\n" , rem ) ; } return rem != 0 ; } | <S2SV_ModStart> = calloc ( <S2SV_ModEnd> prog -> NumInstructions <S2SV_ModStart> prog -> NumInstructions , <S2SV_ModEnd> sizeof ( GLboolean |
3,669 | CWE-000 static int <S2SV_StartBug> validate_pattern ( const char * val_str , struct lys_type * type , struct lyd_node * node ) <S2SV_EndBug> { int i , rc ; pcre * precomp ; <S2SV_StartBug> struct ly_ctx * ctx = node -> schema -> module -> ctx ; <S2SV_EndBug> assert ( type -> base == LY_TYPE_STRING ) ; if ( ! val_str ) { val_str = "" ; } <S2SV_StartBug> if ( type -> der && validate_pattern ( val_str , & type -> der -> type , node ) ) { <S2SV_EndBug> return EXIT_FAILURE ; } for ( i = 0 ; i < type -> info . str . pat_count ; ++ i ) { if ( lyp_check_pattern ( ctx , & type -> info . str . patterns [ i ] . expr [ 1 ] , & precomp ) ) { LOGINT ( ctx ) ; return EXIT_FAILURE ; } rc = pcre_exec ( precomp , NULL , val_str , strlen ( val_str ) , 0 , 0 , NULL , 0 ) ; if ( ( rc && type -> info . str . patterns [ i ] . expr [ 0 ] == 0x06 ) || ( ! rc && type -> info . str . patterns [ i ] . expr [ 0 ] == 0x15 ) ) { LOGVAL ( ctx , LYE_NOCONSTR , LY_VLOG_LYD , node , val_str , & type -> info . str . patterns [ i ] . expr [ 1 ] ) ; if ( type -> info . str . patterns [ i ] . emsg ) { LOGVAL ( ctx , LYE_SPEC , LY_VLOG_PREV , NULL , type -> info . str . patterns [ i ] . emsg ) ; } if ( type -> info . str . patterns [ i ] . eapptag ) { strncpy ( ( ( struct ly_err * ) & ly_errno ) -> apptag , type -> info . str . patterns [ i ] . eapptag , LY_APPTAG_LEN - 1 ) ; } free ( precomp ) ; return EXIT_FAILURE ; } free ( precomp ) ; } return EXIT_SUCCESS ; } | <S2SV_ModStart> lyd_node * node , <S2SV_ModEnd> struct ly_ctx * <S2SV_ModStart> ly_ctx * ctx ) { int i , rc ; pcre * precomp <S2SV_ModEnd> ; assert ( <S2SV_ModStart> type , node , ctx |
3,670 | CWE-000 int gtm_tls_connect ( gtm_tls_socket_t * socket ) { <S2SV_StartBug> int rv ; <S2SV_EndBug> long verify_result ; assert ( CLIENT_MODE ( socket -> flags ) ) ; DBG_VERIFY_SOCK_IS_BLOCKING ( GET_SOCKFD ( socket -> ssl ) ) ; if ( NULL != socket -> session ) { SSL_DPRINT ( stdout , "gtm_tls_connect(1):<S2SV_blank>references=%d\\n" , ( ( SSL_SESSION * ) ( socket -> session ) ) -> references ) ; if ( 0 >= ( rv = SSL_set_session ( socket -> ssl , socket -> session ) ) ) return ssl_error ( socket , rv , X509_V_OK ) ; SSL_DPRINT ( stdout , "gtm_tls_connect(2):<S2SV_blank>references=%d\\n" , ( ( SSL_SESSION * ) ( socket -> session ) ) -> references ) ; } <S2SV_StartBug> if ( 0 < ( rv = SSL_connect ( socket -> ssl ) ) ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> if ( NULL != socket -> session ) SSL_DPRINT ( stdout , "gtm_tls_connect(3):<S2SV_blank>references=%d\\n" , ( ( SSL_SESSION * ) ( socket -> session ) ) -> references ) ; <S2SV_StartBug> verify_result = SSL_get_verify_result ( socket -> ssl ) ; <S2SV_EndBug> <S2SV_StartBug> if ( X509_V_OK == verify_result ) <S2SV_EndBug> return 0 ; } else verify_result = SSL_get_verify_result ( socket -> ssl ) ; return ssl_error ( socket , rv , verify_result ) ; } | <S2SV_ModStart> { int rv <S2SV_ModEnd> ; assert ( <S2SV_ModStart> if ( 0 >= <S2SV_ModEnd> ( rv = <S2SV_ModStart> ) ) ) return ssl_error ( socket , rv , X509_V_OK ) ; <S2SV_ModEnd> if ( NULL <S2SV_ModStart> references ) ; return ydb_tls_is_supported <S2SV_ModEnd> ( socket -> <S2SV_ModStart> ssl ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,671 | CWE-000 int read_config_file ( char * fname ) { int rc , argc = 0 ; FILE * f ; char * buf , * bufp , * * argv ; char * delims = "<S2SV_blank>\\t\\r\\n" ; struct stat st ; size_t sz ; if ( stat ( fname , & st ) ) { logit ( LOG_ERR , "Error:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>stat<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s" , fname ) ; return ERROR ; } if ( ( f = fopen ( fname , "r" ) ) == NULL ) { logit ( LOG_ERR , "Error:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s" , fname ) ; return ERROR ; } if ( ( buf = ( char * ) calloc ( 1 , st . st_size + 2 ) ) == NULL ) { fclose ( f ) ; logit ( LOG_ERR , "Error:<S2SV_blank>read_config_file<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory" ) ; return ERROR ; } if ( ( sz = fread ( buf , 1 , st . st_size , f ) ) != st . st_size ) { fclose ( f ) ; free ( buf ) ; logit ( LOG_ERR , "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>completely<S2SV_blank>read<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s" , fname ) ; return ERROR ; } if ( ( argv = calloc ( 50 , sizeof ( char * ) ) ) == NULL ) { fclose ( f ) ; free ( buf ) ; logit ( LOG_ERR , "Error:<S2SV_blank>read_config_file<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory" ) ; return ERROR ; } argv [ argc ++ ] = "check_nrpe" ; bufp = buf ; while ( argc < 50 ) { while ( * bufp && strchr ( delims , * bufp ) ) ++ bufp ; if ( * bufp == '\\0' ) break ; argv [ argc ] = my_strsep ( & bufp , delims ) ; if ( ! argv [ argc ++ ] ) break ; <S2SV_StartBug> } <S2SV_EndBug> fclose ( f ) ; if ( argc == 50 ) { free ( buf ) ; free ( argv ) ; logit ( LOG_ERR , "Error:<S2SV_blank>too<S2SV_blank>many<S2SV_blank>parameters<S2SV_blank>in<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s" , fname ) ; return ERROR ; } rc = process_arguments ( argc , argv , 1 ) ; free ( buf ) ; free ( argv ) ; return rc ; } | <S2SV_ModStart> ) break ; if ( ! bufp ) break ; |
3,672 | CWE-000 int main ( ) { char * * command ; char * input ; pid_t child_pid ; int stat_loc ; while ( 1 ) { input = readline ( "unixsh><S2SV_blank>" ) ; <S2SV_StartBug> command = get_input ( input ) ; <S2SV_EndBug> child_pid = fork ( ) ; if ( child_pid == 0 ) { execvp ( command [ 0 ] , command ) ; printf ( "This<S2SV_blank>won\'t<S2SV_blank>be<S2SV_blank>printed<S2SV_blank>if<S2SV_blank>execvp<S2SV_blank>is<S2SV_blank>successul\\n" ) ; } else { waitpid ( child_pid , & stat_loc , WUNTRACED ) ; } free ( input ) ; free ( command ) ; } return 0 ; } | <S2SV_ModStart> input ) ; if ( ! command [ 0 ] ) { free ( input ) ; free ( command ) ; continue ; } |
3,673 | CWE-000 void mutex_lock ( MPI_Win win , int image_index , int index , int * stat , <S2SV_StartBug> int * acquired_lock , char * errmsg , int errmsg_len ) <S2SV_EndBug> { const char msg [ ] = "Already<S2SV_blank>locked" ; # if MPI_VERSION >= 3 int value = 0 , compare = 0 , newval = caf_this_image , ierr = 0 , i = 0 ; # ifdef WITH_FAILED_IMAGES int flag , check_failure = 100 , zero = 0 ; # endif if ( stat != NULL ) * stat = 0 ; # ifdef WITH_FAILED_IMAGES MPI_Test ( & alive_request , & flag , MPI_STATUS_IGNORE ) ; # endif locking_atomic_op ( win , & value , newval , compare , image_index , index ) ; if ( value == caf_this_image && image_index == caf_this_image ) goto stat_error ; if ( acquired_lock != NULL ) { if ( value == 0 ) * acquired_lock = 1 ; else * acquired_lock = 0 ; return ; } while ( value != 0 ) { ++ i ; # ifdef WITH_FAILED_IMAGES if ( i == check_failure ) { i = 1 ; MPI_Test ( & alive_request , & flag , MPI_STATUS_IGNORE ) ; } # endif locking_atomic_op ( win , & value , newval , compare , image_index , index ) ; # ifdef WITH_FAILED_IMAGES if ( image_stati [ value ] == STAT_FAILED_IMAGE ) { CAF_Win_lock ( MPI_LOCK_EXCLUSIVE , image_index - 1 , win ) ; MPI_Compare_and_swap ( & zero , & value , & newval , MPI_INT , image_index - 1 , index * sizeof ( int ) , win ) ; CAF_Win_unlock ( image_index - 1 , win ) ; break ; } # else usleep ( caf_this_image * i ) ; # endif } if ( stat ) * stat = ierr ; else if ( ierr == STAT_FAILED_IMAGE ) terminate_internal ( ierr , 0 ) ; return ; stat_error : if ( errmsg != NULL ) { memset ( errmsg , '<S2SV_blank>' , errmsg_len ) ; memcpy ( errmsg , msg , MIN ( errmsg_len , strlen ( msg ) ) ) ; } if ( stat != NULL ) * stat = 99 ; else terminate_internal ( 99 , 1 ) ; # else # warning Locking for MPI - 2 is not implemented printf ( "Locking<S2SV_blank>for<S2SV_blank>MPI-2<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported,<S2SV_blank>please<S2SV_blank>update<S2SV_blank>your<S2SV_blank>MPI<S2SV_blank>implementation\\n" ) ; # endif } | <S2SV_ModStart> * errmsg , size_t <S2SV_ModEnd> errmsg_len ) { |
3,674 | CWE-000 int quux_attach ( int u ) { int err ; struct quux * self = malloc ( sizeof ( struct quux ) ) ; if ( ! self ) { err = ENOMEM ; goto error1 ; } self -> hvfs . query = quux_hquery ; self -> hvfs . close = quux_hclose ; self -> hvfs . done = quux_hdone ; self -> mvfs . msendl = quux_msendl ; self -> mvfs . mrecvl = quux_mrecvl ; self -> u = u ; int h = hmake ( & self -> hvfs ) ; <S2SV_StartBug> if ( h < 0 ) { int err = errno ; goto error2 ; } <S2SV_EndBug> return h ; error2 : free ( self ) ; error1 : errno = err ; return - 1 ; } | <S2SV_ModStart> 0 ) { <S2SV_ModEnd> err = errno |
3,675 | CWE-000 GenericAgentConfig * GenericAgentConfigNewDefault ( AgentType agent_type , bool tty_interactive ) { GenericAgentConfig * config = xmalloc ( sizeof ( GenericAgentConfig ) ) ; LoggingSetAgentType ( CF_AGENTTYPES [ agent_type ] ) ; config -> agent_type = agent_type ; config -> tty_interactive = tty_interactive ; const char * color_env = getenv ( "CFENGINE_COLOR" ) ; config -> color = ( color_env && strcmp ( color_env , "1" ) == 0 ) ; config -> bundlesequence = NULL ; config -> original_input_file = NULL ; config -> input_file = NULL ; config -> input_dir = NULL ; config -> check_not_writable_by_others = agent_type != AGENT_TYPE_COMMON ; config -> check_runnable = agent_type != AGENT_TYPE_COMMON ; config -> ignore_missing_bundles = false ; config -> ignore_missing_inputs = false ; config -> heap_soft = NULL ; config -> heap_negated = NULL ; config -> ignore_locks = false ; config -> protocol_version = CF_PROTOCOL_UNDEFINED ; config -> agent_specific . agent . bootstrap_argument = NULL ; config -> agent_specific . agent . bootstrap_ip = NULL ; config -> agent_specific . agent . bootstrap_port = NULL ; config -> agent_specific . agent . bootstrap_host = NULL ; config -> agent_specific . agent . bootstrap_trust_server = true ; config -> agent_specific . agent . report_class_log = false ; <S2SV_StartBug> switch ( agent_type ) <S2SV_EndBug> { case AGENT_TYPE_COMMON : config -> agent_specific . common . eval_functions = true ; <S2SV_StartBug> config -> agent_specific . common . show_classes = false ; <S2SV_EndBug> config -> agent_specific . common . show_variables = false ; config -> agent_specific . common . policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE ; config -> agent_specific . common . parser_warnings = PARSER_WARNING_ALL ; config -> agent_specific . common . parser_warnings_error = 0 ; break ; default : break ; } return config ; } | <S2SV_ModStart> = false ; config -> agent_specific . common . show_classes = NULL ; config -> agent_specific . common . show_variables = NULL ; <S2SV_ModStart> . common . <S2SV_ModEnd> policy_output_format = GENERIC_AGENT_CONFIG_COMMON_POLICY_OUTPUT_FORMAT_NONE |
3,676 | CWE-000 int vr_assembler_table_scan_init ( void ( * scanner ) ( void * ) ) { struct vr_timer * vtimer ; vr_assembler_table_scan_timer = vr_zalloc ( sizeof ( * vtimer ) , VR_TIMER_OBJECT ) ; if ( ! vr_assembler_table_scan_timer ) return - ENOMEM ; vtimer = vr_assembler_table_scan_timer ; vtimer -> vt_timer = scanner ; vtimer -> vt_vr_arg = NULL ; vtimer -> vt_msecs = ( VR_ASSEMBLER_TIMEOUT_TIME * 1000 ) / VR_LINUX_ASSEMBLER_BUCKETS ; if ( vr_create_timer ( vtimer ) ) { vr_free ( vtimer , VR_TIMER_OBJECT ) ; vr_assembler_table_scan_timer = NULL ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> = NULL ; return - ENOMEM ; |
3,677 | CWE-000 int l_flux_kvs_get ( lua_State * L ) { char * json_str ; json_object * o ; flux_t * f = lua_get_flux ( L , 1 ) ; const char * key = lua_tostring ( L , 2 ) ; if ( key == NULL ) return lua_pusherror ( L , "key<S2SV_blank>required" ) ; <S2SV_StartBug> if ( kvs_get ( f , key , & json_str ) < 0 ) <S2SV_EndBug> <S2SV_StartBug> return lua_pusherror ( L , "kvs_get:<S2SV_blank>%s" , ( char * ) flux_strerror ( errno ) ) ; <S2SV_EndBug> if ( ! ( o = json_tokener_parse ( json_str ) ) || ( json_object_to_lua ( L , o ) < 0 ) ) { free ( json_str ) ; return lua_pusherror ( L , "json_tokener_parse:<S2SV_blank>%s" , ( char * ) flux_strerror ( errno ) ) ; } free ( json_str ) ; json_object_put ( o ) ; return ( 1 ) ; } | <S2SV_ModStart> ; if ( flux_kvs_get <S2SV_ModEnd> ( f , <S2SV_ModStart> ( L , "flux_kvs_get:<S2SV_blank>%s" <S2SV_ModEnd> , ( char |
3,678 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Image_Adapter , blur ) { <S2SV_EndBug> <S2SV_StartBug> zval * radius_param = NULL , _0 ; <S2SV_EndBug> zend_long radius , ZEPHIR_LAST_CALL_STATUS ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & _0 ) ; ZEPHIR_MM_GROW ( ) ; <S2SV_StartBug> zephir_fetch_params ( 1 , 1 , 0 , & radius_param ) ; <S2SV_EndBug> radius = zephir_get_intval ( radius_param ) ; if ( radius < 1 ) { radius = 1 ; } else if ( radius > 100 ) { radius = 100 ; } ZVAL_LONG ( & _0 , radius ) ; ZEPHIR_CALL_METHOD ( NULL , this_ptr , "_blur" , NULL , 0 , & _0 ) ; zephir_check_call_status ( ) ; RETURN_THIS ( ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Mvc_Router_Route , setHttpMethods <S2SV_ModEnd> ) { zval <S2SV_ModStart> { zval * httpMethods <S2SV_ModEnd> ; zephir_fetch_params ( <S2SV_ModStart> ; zephir_fetch_params ( 0 <S2SV_ModEnd> , 1 , <S2SV_ModStart> 0 , & httpMethods ) ; zephir_update_property_this ( getThis ( ) , SL ( "_methods" ) , httpMethods TSRMLS_CC ) ; RETURN_THISW <S2SV_ModEnd> ( ) ; |
3,679 | CWE-000 PUBLIC int ext_sys_stat ( struct exp_list * exproot ) { void * result ; struct string * name ; enum VAL_TYPE type ; int * flag ; char * cmd ; flag = is_flag ( exp_cmd ( exproot -> exp ) ) ; if ( flag ) { exproot = exproot -> next ; if ( ! exproot ) run_error ( SYS_ERR , "Expected<S2SV_blank>\'on\'<S2SV_blank>or<S2SV_blank>\'off\'" ) ; cmd = exp_cmd ( exproot -> exp ) ; if ( strcmp ( cmd , "on" ) == 0 ) * flag = 1 ; else if ( strcmp ( cmd , "off" ) == 0 ) * flag = 0 ; else run_error ( SYS_ERR , "Specify<S2SV_blank>\'on\'<S2SV_blank>or<S2SV_blank>\'off\'<S2SV_blank>please" ) ; return 0 ; } cmd = exp_cmd ( exproot -> exp ) ; if ( strcmp ( cmd , "sysin" ) == 0 ) { if ( ! exproot -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>few<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>sysin" ) ; if ( exproot -> next -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>much<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>sysin" ) ; calc_exp ( exproot -> next -> exp , ( void * * ) & name , & type ) ; if ( type != V_STRING ) run_error ( TYPE_ERR , "Sysin<S2SV_blank>parameter<S2SV_blank>not<S2SV_blank>a<S2SV_blank>string" ) ; if ( name -> len == 0 ) pop_all_inpfiles ( ) ; else { push_inpfile ( ) ; sys_inpfile = fopen ( name -> s , "rt" ) ; if ( ! sys_inpfile ) { pop_inpfile ( ) ; run_error ( SYS_ERR , "Error<S2SV_blank>opening<S2SV_blank>sysin:<S2SV_blank>%s" , <S2SV_StartBug> sys_errlist [ errno ] ) ; <S2SV_EndBug> } } val_free ( name , type ) ; return 0 ; } else if ( strcmp ( cmd , "sysout" ) == 0 ) { if ( ! exproot -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>few<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>sysout" ) ; if ( exproot -> next -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>much<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>sysout" ) ; calc_exp ( exproot -> next -> exp , ( void * * ) & name , & type ) ; if ( type != V_STRING ) run_error ( TYPE_ERR , "Sysin<S2SV_blank>parameter<S2SV_blank>not<S2SV_blank>a<S2SV_blank>string" ) ; if ( name -> s [ 0 ] == '\\0' ) { fclose ( sys_outfile ) ; sys_outfile = NULL ; } else sys_outfile = fopen ( name -> s , "wt" ) ; val_free ( name , type ) ; if ( ! sys_outfile && name -> s [ 0 ] ) run_error ( SYS_ERR , "Error<S2SV_blank>opening<S2SV_blank>sysout:<S2SV_blank>%s" , <S2SV_StartBug> sys_errlist [ errno ] ) ; <S2SV_EndBug> return 0 ; } else if ( strcmp ( cmd , "memdump" ) == 0 ) { if ( ! exproot -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>few<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>memdump" ) ; if ( exproot -> next -> next ) run_error ( SYS_ERR , "Too<S2SV_blank>much<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>SYS<S2SV_blank>memdump" ) ; calc_exp ( exproot -> next -> exp , & result , & type ) ; if ( type != V_INT ) run_error ( TYPE_ERR , "Integer<S2SV_blank>expected" ) ; mem_debug ( ( * ( long * ) result ) ) ; val_free ( result , type ) ; return 0 ; } return - 1 ; } | <S2SV_ModStart> , "Error<S2SV_blank>opening<S2SV_blank>sysin:<S2SV_blank>%s" , strerror ( errno ) <S2SV_ModEnd> ) ; } <S2SV_ModStart> , "Error<S2SV_blank>opening<S2SV_blank>sysout:<S2SV_blank>%s" , strerror ( errno ) <S2SV_ModEnd> ) ; return |
3,680 | CWE-000 int bochs_kms_init ( struct bochs_device * bochs ) { drm_mode_config_init ( bochs -> dev ) ; bochs -> mode_config_initialized = true ; bochs -> dev -> mode_config . max_width = 8192 ; bochs -> dev -> mode_config . max_height = 8192 ; bochs -> dev -> mode_config . fb_base = bochs -> fb_base ; bochs -> dev -> mode_config . preferred_depth = 24 ; bochs -> dev -> mode_config . prefer_shadow = 0 ; <S2SV_StartBug> bochs -> dev -> mode_config . funcs = & bochs_mode_funcs ; <S2SV_EndBug> bochs_crtc_init ( bochs -> dev ) ; bochs_encoder_init ( bochs -> dev ) ; bochs_connector_init ( bochs -> dev ) ; drm_connector_attach_encoder ( & bochs -> connector , & bochs -> encoder ) ; return 0 ; } | <S2SV_ModStart> -> mode_config . quirk_addfb_prefer_host_byte_order = true ; bochs -> dev -> mode_config . |
3,681 | CWE-000 void gst_base_transform_set_passthrough ( GstBaseTransform * trans , gboolean passthrough ) { GstBaseTransformClass * bclass ; g_return_if_fail ( GST_IS_BASE_TRANSFORM ( trans ) ) ; bclass = GST_BASE_TRANSFORM_GET_CLASS ( trans ) ; <S2SV_StartBug> GST_OBJECT_LOCK ( trans ) ; <S2SV_EndBug> if ( ! passthrough ) { if ( bclass -> transform_ip || bclass -> transform ) trans -> priv -> passthrough = FALSE ; } else { trans -> priv -> passthrough = TRUE ; } GST_DEBUG_OBJECT ( trans , "set<S2SV_blank>passthrough<S2SV_blank>%d" , trans -> priv -> passthrough ) ; <S2SV_StartBug> GST_OBJECT_UNLOCK ( trans ) ; <S2SV_EndBug> } | <S2SV_ModStart> trans ) ; PRIV_LOCK <S2SV_ModEnd> ( trans ) <S2SV_ModStart> passthrough ) ; PRIV_UNLOCK <S2SV_ModEnd> ( trans ) |
3,682 | CWE-000 int main ( int argc , char * argv [ ] ) { g_test_init ( & argc , & argv , NULL ) ; g_test_add_func ( "/paramspec/char" , test_param_spec_char ) ; g_test_add_func ( "/paramspec/string" , test_param_spec_string ) ; g_test_add_func ( "/paramspec/override" , test_param_spec_override ) ; g_test_add_func ( "/paramspec/gtype" , test_param_spec_gtype ) ; g_test_add_func ( "/paramspec/variant" , test_param_spec_variant ) ; <S2SV_StartBug> return g_test_run ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> test_param_spec_variant ) ; g_test_add_func ( "/paramspec/variant/cmp" , test_param_spec_variant_cmp ) ; |
3,683 | CWE-000 void * radix_tree_delete_item ( struct radix_tree_root * root , unsigned long index , void * item ) { struct radix_tree_node * node ; unsigned int offset ; void * * slot ; void * entry ; int tag ; <S2SV_StartBug> int prev = 0 ; <S2SV_EndBug> int right_prev [ RADIX_TREE_MAX_TAGS ] = { 0 , } ; entry = __radix_tree_lookup ( root , index , & node , & slot ) ; if ( ! entry ) goto out_none ; if ( item && entry != item ) goto out_none ; for ( tag = 0 ; tag < RADIX_TREE_MAX_TAGS ; tag ++ ) right_prev [ tag ] = radix_tree_tag_get ( root , index , tag ) ; if ( ! node ) { root_tag_move_all_to_prev ( root ) ; root -> rnode = NULL ; goto out ; } offset = get_slot_offset ( node , slot ) ; <S2SV_StartBug> for ( tag = 0 ; tag < RADIX_TREE_MAX_TAGS ; tag ++ ) { <S2SV_EndBug> <S2SV_StartBug> node_tag_clear ( root , node , tag , offset , & prev ) ; <S2SV_EndBug> if ( ! prev ) prev_tag_clear ( root , tag ) ; } delete_sibling_entries ( node , node_to_entry ( slot ) , offset ) ; node -> slots [ offset ] = NULL ; node -> count -- ; __radix_tree_delete_node ( root , node ) ; out : for ( tag = 0 ; tag < RADIX_TREE_MAX_TAGS ; tag ++ ) BUG_ON ( ! right_prev [ tag ] != ! prev_tag_get ( root , tag ) ) ; return entry ; out_none : prev_tag_clear_all ( root ) ; goto out ; } | <S2SV_ModStart> tag ; int <S2SV_ModEnd> right_prev [ RADIX_TREE_MAX_TAGS <S2SV_ModStart> tag ++ ) <S2SV_ModEnd> node_tag_clear ( root <S2SV_ModStart> tag , offset ) ; <S2SV_ModEnd> delete_sibling_entries ( node |
3,684 | CWE-000 <S2SV_StartBug> size_t parse2 ( va_list list , char * str , char type ) <S2SV_EndBug> { <S2SV_StartBug> size_t ret ; <S2SV_EndBug> ret = 0 ; if ( type == 'p' ) { str = uitoa_base ( ( unsigned long ) va_arg ( list , unsigned long int ) , 16 ) ; ret += len_putstr ( "0x" ) ; } else if ( type == 'c' ) ret += len_putchar ( ( char ) va_arg ( list , int ) ) ; else if ( type == 'o' ) str = uitoa_base ( va_arg ( list , unsigned int ) , 8 ) ; else if ( type == 'u' ) str = uitoa_base ( va_arg ( list , unsigned int ) , 10 ) ; else if ( type == 'x' ) str = uitoa_base ( va_arg ( list , unsigned int ) , 16 ) ; <S2SV_StartBug> return ( ret ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> char * <S2SV_ModEnd> parse2 ( va_list <S2SV_ModStart> type ) { <S2SV_ModEnd> if ( type <S2SV_ModStart> ; return ( str <S2SV_ModEnd> ) ; } |
3,685 | CWE-000 static void v4l2_renderer_flush_damage ( struct weston_surface * surface ) { struct v4l2_surface_state * vs = get_surface_state ( surface ) ; <S2SV_StartBug> struct weston_buffer * buffer = vs -> buffer_ref . buffer ; <S2SV_EndBug> DBG ( "%s:<S2SV_blank>flushing<S2SV_blank>damage..\\n" , __func__ ) ; v4l2_renderer_copy_buffer ( vs , buffer ) ; # ifdef V4L2_GL_FALLBACK_ENABLED if ( vs -> renderer -> gl_fallback ) { if ( vs -> renderer -> defer_attach ) { DBG ( "%s:<S2SV_blank>set<S2SV_blank>flush<S2SV_blank>damage<S2SV_blank>flag.\\n" , __func__ ) ; vs -> flush_damage = 1 ; pixman_region32_copy ( & vs -> damage , & surface -> damage ) ; } else { v4l2_gl_flush_damage ( surface ) ; } } # endif } | <S2SV_ModStart> struct weston_buffer * buffer ; if ( ! vs ) return ; |
3,686 | CWE-000 void Init_ensured ( VALUE klass ) { rb_define_module_function ( klass , "ensured" , ensured , 1 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 1 ) ; rb_define_module_function ( klass , "ensure_raise" , ensure_raise , 2 ) ; |
3,687 | CWE-000 int do_xattrop ( call_frame_t * frame , xlator_t * this , loc_t * loc , fd_t * fd , gf_xattrop_flags_t optype , dict_t * xattr , dict_t * xdata ) { int op_ret = 0 ; int op_errno = 0 ; int _fd = - 1 ; char * real_path = NULL ; struct posix_fd * pfd = NULL ; inode_t * inode = NULL ; posix_xattr_filler_t filler = { 0 , } ; dict_t * xattr_rsp = NULL ; dict_t * xdata_rsp = NULL ; struct iatt stbuf = { 0 } ; <S2SV_StartBug> struct posix_private * priv = NULL ; <S2SV_EndBug> VALIDATE_OR_GOTO ( frame , out ) ; VALIDATE_OR_GOTO ( xattr , out ) ; <S2SV_StartBug> VALIDATE_OR_GOTO ( this , out ) ; <S2SV_EndBug> priv = this -> private ; DISK_SPACE_CHECK_AND_GOTO ( frame , priv , xdata , op_ret , op_errno , out ) ; if ( fd ) { op_ret = posix_fd_ctx_get ( fd , this , & pfd , & op_errno ) ; if ( op_ret < 0 ) { gf_msg ( this -> name , GF_LOG_WARNING , fop_log_level ( GF_FOP_FXATTROP , op_errno ) , P_MSG_PFD_GET_FAILED , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>pfd<S2SV_blank>from" "<S2SV_blank>fd=%p" , fd ) ; goto out ; } _fd = pfd -> fd ; } if ( loc && ! gf_uuid_is_null ( loc -> gfid ) ) { MAKE_INODE_HANDLE ( real_path , this , loc , NULL ) ; if ( ! real_path ) { op_ret = - 1 ; op_errno = ESTALE ; goto out ; } } if ( real_path ) { inode = loc -> inode ; } else if ( fd ) { inode = fd -> inode ; } xattr_rsp = dict_new ( ) ; if ( xattr_rsp == NULL ) { op_ret = - 1 ; op_errno = ENOMEM ; goto out ; } filler . this = this ; filler . fdnum = _fd ; filler . real_path = real_path ; filler . flags = ( int ) optype ; filler . inode = inode ; filler . xattr = xattr_rsp ; op_ret = dict_foreach ( xattr , _posix_handle_xattr_keyvalue_pair , & filler ) ; op_errno = filler . op_errno ; if ( op_ret < 0 ) goto out ; if ( ! xdata ) goto out ; if ( fd ) { op_ret = posix_fdstat ( this , inode , _fd , & stbuf ) ; } else { op_ret = posix_pstat ( this , inode , inode -> gfid , real_path , & stbuf , _gf_false ) ; } if ( op_ret < 0 ) { op_errno = errno ; goto out ; } xdata_rsp = posix_xattr_fill ( this , real_path , loc , fd , _fd , xdata , & stbuf ) ; if ( ! xdata_rsp ) { op_ret = - 1 ; op_errno = ENOMEM ; } posix_set_mode_in_dict ( xdata , xdata_rsp , & stbuf ) ; out : STACK_UNWIND_STRICT ( xattrop , frame , op_ret , op_errno , xattr_rsp , xdata_rsp ) ; if ( xattr_rsp ) dict_unref ( xattr_rsp ) ; if ( xdata_rsp ) dict_unref ( xdata_rsp ) ; return 0 ; } | <S2SV_ModStart> 0 } ; <S2SV_ModEnd> VALIDATE_OR_GOTO ( frame <S2SV_ModStart> VALIDATE_OR_GOTO ( this <S2SV_ModEnd> , out ) |
3,688 | CWE-000 static void update ( object_tab_t * tab , const trc_obj_rev_head_t * rev_head , uint64_t revision ) { const trc_gl_program_rev_t * rev = ( const trc_gl_program_rev_t * ) rev_head ; program_data_t * data = tab -> data ; info_box_t * box = tab -> info_box ; if ( ! set_obj_common_at_info_box ( box , rev_head , revision ) ) return ; set_at_info_box ( box , "Separable" , "%s" , rev -> separable ? "True" : "False" ) ; set_at_info_box ( box , "Binary<S2SV_blank>Retrievable<S2SV_blank>Hint" , "%s" , ( const char * [ ] ) { "Unset" , "False" , "True" } [ rev -> binary_retrievable_hint + 1 ] ) ; set_at_info_box ( tab -> info_box , "Validation<S2SV_blank>Status" , "%s" , ( const char * [ ] ) { "Not<S2SV_blank>Done" , "Failed" , "Succeeded" } [ rev -> validation_status + 1 ] ) ; set_at_info_box ( tab -> info_box , "Link<S2SV_blank>Status" , "%s" , ( const char * [ ] ) { "Not<S2SV_blank>Done" , "Failed" , "Succeeded" } [ rev -> link_status + 1 ] ) ; const char * info_log = trc_map_data ( rev -> info_log , TRC_MAP_READ ) ; gtk_text_buffer_set_text ( gtk_text_view_get_buffer ( data -> info_log ) , info_log , - 1 ) ; trc_unmap_data ( info_log ) ; size_t shader_count = rev -> shaders -> size / sizeof ( trc_obj_ref_t ) ; const trc_obj_ref_t * shaders = trc_map_data ( rev -> shaders , TRC_MAP_READ ) ; gtk_tree_store_clear ( data -> attached_shaders ) ; for ( size_t i = 0 ; i < shader_count ; i ++ ) { GtkTreeIter row ; gtk_tree_store_append ( data -> attached_shaders , & row , NULL ) ; gtk_tree_store_set ( data -> attached_shaders , & row , 0 , static_format_obj ( shaders [ i ] . obj , revision ) , 1 , shaders [ i ] . obj , - 1 ) ; } trc_unmap_data ( shaders ) ; size_t linked_count = rev -> linked -> size / sizeof ( trc_obj_t * ) ; trc_obj_t * const * linked = trc_map_data ( rev -> linked , TRC_MAP_READ ) ; gtk_tree_store_clear ( data -> linked_shaders ) ; for ( size_t i = 0 ; i < linked_count ; i ++ ) { const char * rev_str = static_format ( "%lu" , rev -> link_revision ) ; GtkTreeIter row ; gtk_tree_store_append ( data -> linked_shaders , & row , NULL ) ; gtk_tree_store_set ( data -> linked_shaders , & row , 1 , rev_str , 0 , static_format_obj ( linked [ i ] , revision ) , 2 , linked [ i ] , 3 , rev -> link_revision , - 1 ) ; } trc_unmap_data ( linked ) ; size_t block_count = rev -> uniform_blocks -> size / sizeof ( trc_gl_program_uniform_block_t ) ; const trc_gl_program_uniform_block_t * blocks = trc_map_data ( rev -> uniform_blocks , TRC_MAP_READ ) ; gtk_tree_store_clear ( data -> uniform_blocks ) ; for ( size_t i = 0 ; i < block_count ; i ++ ) { char index_str [ 64 ] = { 0 } ; snprintf ( index_str , sizeof ( index_str ) - 1 , "%u" , blocks [ i ] . fake ) ; char binding_str [ 64 ] = { 0 } ; snprintf ( binding_str , sizeof ( index_str ) - 1 , "%u" , blocks [ i ] . binding ) ; <S2SV_StartBug> GtkTreeIter row ; <S2SV_EndBug> <S2SV_StartBug> gtk_tree_store_append ( data -> attached_shaders , & row , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> gtk_tree_store_set ( data -> attached_shaders , & row , 0 , index_str , 1 , binding_str , - 1 ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> trc_unmap_data ( blocks ) ; const trc_gl_uniform_t * uniforms = trc_map_data ( rev -> uniforms , TRC_MAP_READ ) ; const uint8_t * uniform_data = trc_map_data ( rev -> uniform_data , TRC_MAP_READ ) ; gtk_tree_store_clear ( data -> uniforms ) ; for ( size_t i = 0 ; i < rev -> root_uniform_count ; i ++ ) fill_uniform_tree ( uniforms , uniform_data , i , data -> uniforms , NULL , - 1 ) ; trc_unmap_data ( uniform_data ) ; trc_unmap_data ( uniforms ) ; } | <S2SV_ModStart> binding ) ; const char * name = trc_map_data ( blocks [ i ] . name , TRC_MAP_READ ) ; <S2SV_ModStart> ( data -> uniform_blocks <S2SV_ModEnd> , & row <S2SV_ModStart> ( data -> uniform_blocks <S2SV_ModEnd> , & row <S2SV_ModStart> , 0 , name , 1 , index_str , 2 <S2SV_ModEnd> , binding_str , <S2SV_ModStart> 1 ) ; trc_unmap_data ( name ) ; } trc_unmap_data ( <S2SV_ModEnd> blocks ) ; |
3,689 | CWE-000 int insert_command_identifier_command ( struct command_identifier_node * tree , struct command_map * command , size_t ch ) { struct command_identifier_node * child ; struct command_identifier_node * * alloc_children ; int returned_command ; int c ; child = 0 ; for ( c = 0 ; c < tree -> num_children ; ++ c ) { if ( tree -> children [ c ] -> character == command -> command_name [ ch ] ) { child = tree -> children [ c ] ; break ; } } if ( child == 0 ) { child = ( struct command_identifier_node * ) malloc ( sizeof ( struct command_identifier_node ) ) ; if ( child == 0 ) return COMMAND_RECOGNIZER_OUT_OF_MEMORY ; child -> command = COMMAND_UNDEFINED ; child -> character = command -> command_name [ ch ] ; child -> children = 0 ; child -> num_children = 0 ; <S2SV_StartBug> alloc_children = realloc ( tree -> children , sizeof ( struct command_identifier_node * ) * tree -> num_children + 1 ) ; <S2SV_EndBug> if ( alloc_children == 0 ) return COMMAND_RECOGNIZER_OUT_OF_MEMORY ; tree -> children = alloc_children ; tree -> children [ tree -> num_children ++ ] = child ; } if ( command -> command_name [ ch ] == L'\\0' ) { child -> command = command -> command ; return child -> command ; } else { returned_command = insert_command_identifier_command ( child , command , ch + 1 ) ; if ( tree -> command == COMMAND_UNDEFINED ) tree -> command = returned_command ; else tree -> command = COMMAND_AMBIGUOUS ; } return tree -> command ; } | <S2SV_ModStart> * ) * ( <S2SV_ModStart> + 1 ) ) |
3,690 | CWE-000 static void add_substitution ( t_strlist * * strlist_addr , char const * start , char const * end ) { int pipefds [ 2 ] ; char * * argv ; char * tmp ; <S2SV_StartBug> char * spath ; <S2SV_EndBug> char * * path ; char * * env ; argv = ( char * [ ] ) { ft_strdup ( get_shell_env ( ) -> path_to_42sh ) , "-c" , strdup_until ( start , end ) , NULL } ; pipe ( pipefds ) ; if ( enter_subshell ( ) == FORKED_IN_CHILD ) { close ( pipefds [ 0 ] ) ; dup2 ( pipefds [ 1 ] , STDOUT_FILENO ) ; close ( pipefds [ 1 ] ) ; <S2SV_StartBug> spath = get_variable ( "PATH" ) ; <S2SV_EndBug> path = ft_strsplit ( spath , ':' ) ; ft_strdel ( & spath ) ; env = get_variables_for_execution ( NULL ) ; execute ( argv , env , path ) ; ft_freetabchar ( path ) ; ft_freetabchar ( env ) ; fatal_error ( "failed<S2SV_blank>to<S2SV_blank>execute<S2SV_blank>recursively<S2SV_blank>in<S2SV_blank>add_substitution" ) ; } else { close ( pipefds [ 1 ] ) ; tmp = fd_to_str ( pipefds [ 0 ] ) ; rm_trailing_newlines ( tmp ) ; strlist_append ( strlist_addr , tmp ) ; free ( tmp ) ; wait_for_childs ( ) ; } free ( argv [ 0 ] ) ; free ( argv [ 2 ] ) ; } | <S2SV_ModStart> * tmp ; t_simple_command cmd <S2SV_ModEnd> ; argv = <S2SV_ModStart> ] ) ; ft_bzero ( & cmd , sizeof ( t_simple_command ) ) ; cmd . argv = argv ; pre_exec ( & cmd <S2SV_ModEnd> ) ; fatal_error |
3,691 | CWE-000 void * ap6_thread ( void * thread_context ) { struct ap6_context * c = ( struct ap6_context * ) thread_context ; unsigned i ; int ret ; struct timespec ts = { . tv_sec = 0 , . tv_nsec = 100000 } ; <S2SV_StartBug> fpga_token fme_token ; <S2SV_EndBug> fpga_handle fme_handle ; fpga_properties filter ; fpga_result res ; uint32_t num_matches = 0 ; struct bitstream_info null_gbs_info ; memset_s ( & null_gbs_info , sizeof ( null_gbs_info ) , 0 ) ; ON_GOTO ( c -> config -> num_null_gbs == 0 , out_exit , "no<S2SV_blank>NULL<S2SV_blank>bitstreams<S2SV_blank>registered." ) ; res = fpgaGetProperties ( NULL , & filter ) ; ON_GOTO ( res != FPGA_OK , out_exit , "enumeration<S2SV_blank>failed" ) ; for ( i = 0 ; i < c -> config -> num_null_gbs ; i ++ ) { ret = read_bitstream ( c -> config -> null_gbs [ i ] , & null_gbs_info ) ; if ( ret < 0 ) { dlog ( "ap6[%i]:<S2SV_blank>\\tfailed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>bitstream\\n" , c -> socket ) ; if ( null_gbs_info . data ) free ( ( void * ) null_gbs_info . data ) ; null_gbs_info . data = NULL ; continue ; } res = fpgaClearProperties ( filter ) ; ON_GOTO ( res != FPGA_OK , out_destroy_filter , "enumeration<S2SV_blank>failed" ) ; res = fpgaPropertiesSetObjectType ( filter , FPGA_DEVICE ) ; res += fpgaPropertiesSetSocketID ( filter , c -> socket ) ; res += fpgaPropertiesSetGUID ( filter , null_gbs_info . interface_id ) ; ON_GOTO ( res != FPGA_OK , out_destroy_filter , "enumeration<S2SV_blank>failed" ) ; res = fpgaEnumerate ( & filter , 1 , & fme_token , 1 , & num_matches ) ; ON_GOTO ( res != FPGA_OK , out_destroy_filter , "enumeration<S2SV_blank>failed" ) ; if ( num_matches > 0 ) break ; } res = fpgaDestroyProperties ( & filter ) ; ON_GOTO ( res != FPGA_OK , out_exit , "enumeration<S2SV_blank>failed" ) ; if ( i == c -> config -> num_null_gbs ) goto out_exit ; dlog ( "ap6[%i]:<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>AP6,<S2SV_blank>will<S2SV_blank>write<S2SV_blank>the<S2SV_blank>following<S2SV_blank>bitstream:<S2SV_blank>\\"%s\\"\\n" , c -> socket , c -> config -> null_gbs [ i ] ) ; while ( c -> config -> running ) { ret = sem_timedwait ( & ap6_sem [ c -> socket ] , & ts ) ; if ( ret == 0 ) { dlog ( "ap6[%i]:<S2SV_blank>writing<S2SV_blank>NULL<S2SV_blank>bitstreams.\\n" , c -> socket ) ; res = fpgaOpen ( fme_token , & fme_handle , 0 ) ; if ( res != FPGA_OK ) { dlog ( "ap6[%i]:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>FPGA.\\n" , c -> socket ) ; continue ; } res = fpgaReconfigureSlot ( fme_handle , 0 , null_gbs_info . data , null_gbs_info . data_len , 0 ) ; if ( res != FPGA_OK ) { dlog ( "ap6[%i]:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>bitstream.\\n" , c -> socket ) ; } res = fpgaClose ( fme_handle ) ; if ( res != FPGA_OK ) { dlog ( "ap6[%i]:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>close<S2SV_blank>FPGA.\\n" , c -> socket ) ; } } } out_exit : <S2SV_StartBug> if ( null_gbs_info . data ) <S2SV_EndBug> free ( null_gbs_info . data ) ; return NULL ; out_destroy_filter : fpgaDestroyProperties ( & filter ) ; goto out_exit ; } | <S2SV_ModStart> ; fpga_token fme_token = NULL <S2SV_ModStart> : if ( fme_token ) fpgaDestroyToken ( & fme_token ) ; if ( |
3,692 | CWE-000 struct dentry * msm_vidc_debugfs_init_core ( struct msm_vidc_core * core , struct dentry * parent ) { struct dentry * dir = NULL ; char debugfs_name [ MAX_DEBUGFS_NAME ] ; if ( ! core ) { <S2SV_StartBug> dprintk ( VIDC_ERR , "Invalid<S2SV_blank>params,<S2SV_blank>core:<S2SV_blank>%p\\n" , core ) ; <S2SV_EndBug> goto failed_create_dir ; } snprintf ( debugfs_name , MAX_DEBUGFS_NAME , "core%d" , core -> id ) ; dir = debugfs_create_dir ( debugfs_name , parent ) ; if ( ! dir ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>debugfs<S2SV_blank>for<S2SV_blank>msm_vidc\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_file ( "info" , S_IRUGO , dir , core , & core_info_fops ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "debug_level" , S_IRUGO | S_IWUSR , parent , & msm_vidc_debug ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "fw_level" , S_IRUGO | S_IWUSR , parent , & msm_fw_debug ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_file ( "trigger_ssr" , S_IWUSR , dir , core , & ssr_fops ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "fw_debug_mode" , S_IRUGO | S_IWUSR , parent , & msm_fw_debug_mode ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "fw_low_power_mode" , S_IRUGO | S_IWUSR , parent , & msm_fw_low_power_mode ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "debug_output" , S_IRUGO | S_IWUSR , parent , & msm_vidc_debug_out ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "hw_rsp_timeout" , S_IRUGO | S_IWUSR , parent , & msm_vidc_hw_rsp_timeout ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } if ( ! debugfs_create_u32 ( "firmware_unload_delay" , S_IRUGO | S_IWUSR , parent , & msm_vidc_firmware_unload_delay ) ) { dprintk ( VIDC_ERR , "debugfs_create_file:<S2SV_blank>firmware_unload_delay<S2SV_blank>fail\\n" ) ; goto failed_create_dir ; } failed_create_dir : return dir ; } | <S2SV_ModStart> ( VIDC_ERR , "Invalid<S2SV_blank>params,<S2SV_blank>core:<S2SV_blank>%pK\\n" <S2SV_ModEnd> , core ) |
3,693 | CWE-000 int main ( void ) { uint16_t adc_val = 0 ; uint8_t i2c_addr = 0 ; uint8_t i ; sequence_config current_seq_config ; uint32_t channel_timer_count [ 3 ] ; uint8_t channel_threshold_passed = 0 ; uint8_t used_analog_inputs = 0 ; uint8_t crossed_thresholds = 0 ; uint8_t channel_delay_done = 0 ; uint8_t used_enables = 0 ; uint8_t channel_enable_done = 0 ; init_adc ( ) ; init_seq_timer ( ) ; read_seq_config ( & current_seq_config ) ; init_seq_outputs ( current_seq_config . en_config ) ; adc_val = read_adc ( ) ; if ( adc_val > 0 ) { i2c_addr = adc_to_addr ( adc_val ) ; } if ( i2c_addr > 0 ) { USI_TWI_Slave_Initialise ( i2c_addr ) ; } init_i2c_timer ( ) ; sei ( ) ; for ( i = 0 ; i < 3 ; i ++ ) { used_analog_inputs |= current_seq_config . en_config [ i ] & 0x7 ; <S2SV_StartBug> used_enables |= ( ( current_seq_config . en_config [ i ] & ( 1 << EN_ENABLED_BIT ) ) ? 1 : 0 ) << i ; <S2SV_EndBug> } <S2SV_StartBug> while ( ( channel_enable_done & used_enables ) == used_enables ) { <S2SV_EndBug> for ( i = 0 ; i < 3 ; i ++ ) { if ( ( used_analog_inputs & ~ crossed_thresholds ) & ( 1 << i ) ) { crossed_thresholds |= test_threshold ( i , current_seq_config . threshold [ i ] ) << i ; } } for ( i = 0 ; i < 3 ; i ++ ) { if ( channel_delay_done & ( 1 << i ) ) { set_seq_enable ( i , current_seq_config . en_config [ i ] ) ; channel_enable_done |= 1 << i ; } else if ( channel_threshold_passed & ( 1 << i ) ) { channel_delay_done |= check_delay ( channel_timer_count [ i ] , current_seq_config . delay [ i ] ) << i ; } else if ( ( current_seq_config . en_config [ i ] & crossed_thresholds ) == ( current_seq_config . en_config [ i ] & 0x7 ) ) { channel_timer_count [ i ] = current_seq_time_ms ( ) ; channel_threshold_passed |= 1 << i ; } } } while ( 1 ) { } } | <S2SV_ModStart> ) ) ? 0 : 1 <S2SV_ModEnd> ) << i <S2SV_ModStart> & used_enables ) != <S2SV_ModEnd> used_enables ) { |
3,694 | CWE-000 static void bta_gattc_wait4_service_change_ccc_cback ( TIMER_LIST_ENT * p_tle ) { tBTA_GATTC_FIND_SERVICE_CB result ; BOOLEAN start_ccc_timer = FALSE ; UINT32 new_timeout ; tBTA_GATTC_WAIT_CCC_TIMER * p_timer_param = ( tBTA_GATTC_WAIT_CCC_TIMER * ) p_tle -> param ; if ( p_timer_param == NULL ) { APPL_TRACE_ERROR ( "p_timer_param<S2SV_blank>is<S2SV_blank>NULL<S2SV_blank>in<S2SV_blank>%s\\n" , __func__ ) ; return ; } tBTA_GATTC_CONN * p_conn = bta_gattc_conn_find ( p_timer_param -> remote_bda ) ; if ( p_conn == NULL ) { APPL_TRACE_ERROR ( "p_conn<S2SV_blank>is<S2SV_blank>NULL<S2SV_blank>in<S2SV_blank>%s\\n" , __func__ ) ; osi_free ( p_timer_param ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } result = bta_gattc_register_service_change_notify ( p_timer_param -> conn_id , p_timer_param -> remote_bda , & start_ccc_timer ) ; if ( ( result == p_timer_param -> last_status ) && ( ( result == SERVICE_CHANGE_CHAR_NOT_FOUND ) || ( result == SERVICE_CHANGE_CCC_NOT_FOUND ) ) ) { start_ccc_timer = FALSE ; } if ( ( start_ccc_timer == TRUE ) && ( p_timer_param -> count < 10 ) ) { TIMER_LIST_ENT * ccc_timer = & ( p_conn -> service_change_ccc_timer ) ; if ( result == SERVICE_CHANGE_WRITE_CCC_FAILED ) { new_timeout = 200 ; } else { new_timeout = 1000 ; p_timer_param -> count ++ ; } bta_gattc_start_service_change_ccc_timer ( p_timer_param -> conn_id , p_timer_param -> remote_bda , new_timeout , p_timer_param -> count , result , ccc_timer ) ; } else { p_conn -> ccc_timer_used = FALSE ; p_conn -> service_change_ccc_written = TRUE ; } osi_free ( p_timer_param ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> p_timer_param ) ; p_tle -> param = ( TIMER_PARAM_TYPE ) 0 ; <S2SV_ModStart> p_timer_param ) ; p_tle -> param = ( TIMER_PARAM_TYPE ) 0 ; |
3,695 | CWE-000 static void e1000_release_phy_80003es2lan ( struct e1000_hw * hw ) { u16 mask ; DEBUGFUNC ( "e1000_release_phy_80003es2lan" ) ; mask = hw -> bus . func ? E1000_SWFW_PHY1_SM : E1000_SWFW_PHY0_SM ; <S2SV_StartBug> e1000_release_swfw_sync_80003es2lan ( hw , mask ) ; <S2SV_EndBug> } | <S2SV_ModStart> : E1000_SWFW_PHY0_SM ; e1000_release_swfw_sync <S2SV_ModEnd> ( hw , |
3,696 | CWE-000 Datum gistgetbitmap ( PG_FUNCTION_ARGS ) { IndexScanDesc scan = ( IndexScanDesc ) PG_GETARG_POINTER ( 0 ) ; TIDBitmap * tbm = ( TIDBitmap * ) PG_GETARG_POINTER ( 1 ) ; GISTScanOpaque so = ( GISTScanOpaque ) scan -> opaque ; int64 ntids = 0 ; GISTSearchItem fakeItem ; if ( ! so -> qual_ok ) PG_RETURN_INT64 ( 0 ) ; pgstat_count_index_scan ( scan -> indexRelation ) ; <S2SV_StartBug> so -> curPageData = so -> nPageData = 0 ; <S2SV_EndBug> if ( so -> pageDataCxt ) MemoryContextReset ( so -> pageDataCxt ) ; fakeItem . blkno = GIST_ROOT_BLKNO ; memset ( & fakeItem . data . parentlsn , 0 , sizeof ( GistNSN ) ) ; gistScanPage ( scan , & fakeItem , NULL , tbm , & ntids ) ; for ( ; ; ) { GISTSearchItem * item = getNextGISTSearchItem ( so ) ; if ( ! item ) break ; CHECK_FOR_INTERRUPTS ( ) ; gistScanPage ( scan , item , item -> distances , tbm , & ntids ) ; pfree ( item ) ; } PG_RETURN_INT64 ( ntids ) ; } | <S2SV_ModStart> nPageData = 0 ; scan -> xs_itup = NULL |
3,697 | CWE-000 <S2SV_StartBug> DEFUN ( ospf_area_nssa_no_summary , <S2SV_EndBug> ospf_area_nssa_no_summary_cmd , "area<S2SV_blank><A.B.C.D|(0-4294967295)><S2SV_blank>nssa<S2SV_blank>no-summary" , "OSPF<S2SV_blank>area<S2SV_blank>parameters\\n" "OSPF<S2SV_blank>area<S2SV_blank>ID<S2SV_blank>in<S2SV_blank>IP<S2SV_blank>address<S2SV_blank>format\\n" "OSPF<S2SV_blank>area<S2SV_blank>ID<S2SV_blank>as<S2SV_blank>a<S2SV_blank>decimal<S2SV_blank>value\\n" "Configure<S2SV_blank>OSPF<S2SV_blank>area<S2SV_blank>as<S2SV_blank>nssa\\n" "Do<S2SV_blank>not<S2SV_blank>inject<S2SV_blank>inter-area<S2SV_blank>routes<S2SV_blank>into<S2SV_blank>nssa\\n" ) { <S2SV_StartBug> return ospf_area_nssa_cmd_handler ( vty , argc , argv , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> DEFUN ( no_ospf_area_nssa_no_summary , no_ospf_area_nssa_no_summary_cmd , "no<S2SV_blank>area<S2SV_blank><A.B.C.D|(0-4294967295)><S2SV_blank>nssa<S2SV_blank>no-summary" , NO_STR <S2SV_ModEnd> "OSPF<S2SV_blank>area<S2SV_blank>parameters\\n" "OSPF<S2SV_blank>area<S2SV_blank>ID<S2SV_blank>in<S2SV_blank>IP<S2SV_blank>address<S2SV_blank>format\\n" "OSPF<S2SV_blank>area<S2SV_blank>ID<S2SV_blank>as<S2SV_blank>a<S2SV_blank>decimal<S2SV_blank>value\\n" <S2SV_ModStart> "Do<S2SV_blank>not<S2SV_blank>inject<S2SV_blank>inter-area<S2SV_blank>routes<S2SV_blank>into<S2SV_blank>nssa\\n" ) { int idx_ipv4_number = 2 ; struct in_addr area_id ; int format ; VTY_DECLVAR_INSTANCE_CONTEXT ( ospf , ospf ) ; VTY_GET_OSPF_AREA_ID_NO_BB ( "nssa" , area_id , format , argv [ idx_ipv4_number ] -> arg ) ; ospf_area_display_format_set ( ospf , ospf_area_get ( ospf , area_id ) , format ) ; ospf_area_no_summary_unset ( ospf , area_id ) ; ospf_schedule_abr_task ( ospf ) ; return CMD_SUCCESS <S2SV_ModEnd> ; } <S2SV_null> |
3,698 | CWE-000 static int update_userspace_power ( struct sched_params __user * argp ) { int i ; int ret ; int cpu = - 1 ; struct cpu_activity_info * node ; struct cpu_static_info * sp , * clear_sp ; int cpumask , cluster , mpidr ; bool pdata_valid [ NR_CPUS ] = { 0 } ; get_user ( cpumask , & argp -> cpumask ) ; get_user ( cluster , & argp -> cluster ) ; mpidr = cluster << 8 ; pr_debug ( "%s:<S2SV_blank>cpumask<S2SV_blank>%d,<S2SV_blank>cluster:<S2SV_blank>%d\\n" , __func__ , cpumask , cluster ) ; for ( i = 0 ; i < MAX_CORES_PER_CLUSTER ; i ++ , cpumask >>= 1 ) { if ( ! ( cpumask & 0x01 ) ) continue ; mpidr |= i ; for_each_possible_cpu ( cpu ) { if ( cpu_logical_map ( cpu ) == mpidr ) break ; } } if ( ( cpu < 0 ) || ( cpu >= num_possible_cpus ( ) ) ) return - EINVAL ; node = & activity [ cpu ] ; sp = kzalloc ( sizeof ( * sp ) , GFP_KERNEL ) ; if ( ! sp ) return - ENOMEM ; mutex_lock ( & policy_update_mutex ) ; sp -> power = allocate_2d_array_uint32_t ( node -> sp -> num_of_freqs ) ; if ( IS_ERR_OR_NULL ( sp -> power ) ) { mutex_unlock ( & policy_update_mutex ) ; ret = PTR_ERR ( sp -> power ) ; kfree ( sp ) ; return ret ; } sp -> num_of_freqs = node -> sp -> num_of_freqs ; sp -> voltage = node -> sp -> voltage ; sp -> table = node -> sp -> table ; for ( i = 0 ; i < TEMP_DATA_POINTS ; i ++ ) { ret = copy_from_user ( sp -> power [ i ] , & argp -> power [ i ] [ 0 ] , sizeof ( sp -> power [ i ] [ 0 ] ) * node -> sp -> num_of_freqs ) ; if ( ret ) goto failed ; } get_user ( cpumask , & argp -> cpumask ) ; spin_lock ( & update_lock ) ; for ( i = 0 ; i < MAX_CORES_PER_CLUSTER ; i ++ , cpumask >>= 1 ) { if ( ! ( cpumask & 0x01 ) ) continue ; mpidr = ( cluster << CLUSTER_OFFSET_FOR_MPIDR ) ; mpidr |= i ; for_each_possible_cpu ( cpu ) { if ( ! ( cpu_logical_map ( cpu ) == mpidr ) ) continue ; node = & activity [ cpu ] ; clear_sp = node -> sp ; node -> sp = sp ; cpumask_set_cpu ( cpu , & sp -> mask ) ; if ( clear_sp ) { cpumask_clear_cpu ( cpu , & clear_sp -> mask ) ; clear_static_power ( clear_sp ) ; } cpu_stats [ cpu ] . ptable = per_cpu ( ptable , cpu ) ; repopulate_stats ( cpu ) ; pdata_valid [ cpu ] = true ; } } spin_unlock ( & update_lock ) ; mutex_unlock ( & policy_update_mutex ) ; for_each_possible_cpu ( cpu ) { if ( ! pdata_valid [ cpu ] ) continue ; blocking_notifier_call_chain ( & msm_core_stats_notifier_list , cpu , NULL ) ; } <S2SV_StartBug> activate_power_table = true ; <S2SV_EndBug> return 0 ; failed : mutex_unlock ( & policy_update_mutex ) ; for ( i = 0 ; i < TEMP_DATA_POINTS ; i ++ ) kfree ( sp -> power [ i ] ) ; kfree ( sp -> power ) ; kfree ( sp ) ; return ret ; } | <S2SV_ModStart> ) ; } # ifdef ENABLE_TSENS_SAMPLING <S2SV_ModStart> = true ; # endif |
3,699 | CWE-000 bool Curl_clone_primary_ssl_config ( struct ssl_primary_config * source , struct ssl_primary_config * dest ) { dest -> verifyhost = source -> verifyhost ; dest -> verifypeer = source -> verifypeer ; dest -> version = source -> version ; dest -> version_max = source -> version_max ; CLONE_STRING ( CAfile ) ; CLONE_STRING ( CApath ) ; CLONE_STRING ( cipher_list ) ; CLONE_STRING ( egdsocket ) ; CLONE_STRING ( random_file ) ; CLONE_STRING ( clientcert ) ; <S2SV_StartBug> return TRUE ; <S2SV_EndBug> } | <S2SV_ModStart> clientcert ) ; dest -> sessionid = ( dest -> clientcert ? false : source -> sessionid ) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.