Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,800 | CWE-000 int process_3a_data ( cam_3a_params_t * p_3a_params , QOMX_EXIF_INFO * exif_info ) { int rc = 0 ; srat_t val_srat ; rat_t val_rat ; double shutter_speed_value ; if ( NULL == p_3a_params ) { LOGE ( "3A<S2SV_blank>params<S2SV_blank>are<S2SV_blank>null" ) ; return 0 ; } LOGD ( "exp_time<S2SV_blank>%f,<S2SV_blank>iso_value<S2SV_blank>%d,<S2SV_blank>wb_mode<S2SV_blank>%d" , p_3a_params -> exp_time , p_3a_params -> iso_value , p_3a_params -> wb_mode ) ; if ( p_3a_params -> exp_time <= 0.0f ) { val_rat . num = 0 ; val_rat . denom = 0 ; <S2SV_StartBug> } else if ( p_3a_params -> exp_time < 1.0f ) { <S2SV_EndBug> <S2SV_StartBug> val_rat . num = 1 ; <S2SV_EndBug> <S2SV_StartBug> val_rat . denom = ROUND ( 1.0 / p_3a_params -> exp_time ) ; <S2SV_EndBug> } else { val_rat . num = ROUND ( p_3a_params -> exp_time ) ; val_rat . denom = 1 ; } LOGD ( "numer<S2SV_blank>%d<S2SV_blank>denom<S2SV_blank>%d<S2SV_blank>%zd" , val_rat . num , val_rat . denom , sizeof ( val_rat ) / ( 8 ) ) ; rc = addExifEntry ( exif_info , EXIFTAGID_EXPOSURE_TIME , EXIF_RATIONAL , ( sizeof ( val_rat ) / ( 8 ) ) , & val_rat ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry<S2SV_blank>Exposure<S2SV_blank>time" ) ; } if ( p_3a_params -> exp_time > 0 ) { shutter_speed_value = log10 ( 1 / p_3a_params -> exp_time ) / log10 ( 2 ) ; val_srat . num = ( int32_t ) ( shutter_speed_value * 1000 ) ; val_srat . denom = 1000 ; } else { val_srat . num = 0 ; val_srat . denom = 0 ; } rc = addExifEntry ( exif_info , EXIFTAGID_SHUTTER_SPEED , EXIF_SRATIONAL , ( sizeof ( val_srat ) / ( 8 ) ) , & val_srat ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } short val_short ; val_short = ( short ) p_3a_params -> iso_value ; rc = addExifEntry ( exif_info , EXIFTAGID_ISO_SPEED_RATING , EXIF_SHORT , sizeof ( val_short ) / 2 , & val_short ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } if ( p_3a_params -> wb_mode == CAM_WB_MODE_AUTO ) val_short = 0 ; else val_short = 1 ; rc = addExifEntry ( exif_info , EXIFTAGID_WHITE_BALANCE , EXIF_SHORT , sizeof ( val_short ) / 2 , & val_short ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } val_short = ( short ) p_3a_params -> metering_mode ; rc = addExifEntry ( exif_info , EXIFTAGID_METERING_MODE , EXIF_SHORT , sizeof ( val_short ) / 2 , & val_short ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } val_short = ( short ) p_3a_params -> exposure_program ; rc = addExifEntry ( exif_info , EXIFTAGID_EXPOSURE_PROGRAM , EXIF_SHORT , sizeof ( val_short ) / 2 , & val_short ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } val_short = ( short ) p_3a_params -> exposure_mode ; rc = addExifEntry ( exif_info , EXIFTAGID_EXPOSURE_MODE , EXIF_SHORT , sizeof ( val_short ) / 2 , & val_short ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } uint8_t val_undef ; val_undef = ( uint8_t ) p_3a_params -> scenetype ; rc = addExifEntry ( exif_info , EXIFTAGID_SCENE_TYPE , EXIF_UNDEFINED , sizeof ( val_undef ) , & val_undef ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } LOGD ( "brightness<S2SV_blank>%f" , p_3a_params -> brightness ) ; val_srat . num = ( int32_t ) ( p_3a_params -> brightness * 100.0f ) ; val_srat . denom = 100 ; rc = addExifEntry ( exif_info , EXIFTAGID_BRIGHTNESS , EXIF_SRATIONAL , ( sizeof ( val_srat ) / ( 8 ) ) , & val_srat ) ; if ( rc ) { LOGE ( ":<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>Exif<S2SV_blank>Entry" ) ; } return rc ; } | <S2SV_ModStart> p_3a_params -> exp_time <= <S2SV_ModEnd> 1.0f ) { <S2SV_ModStart> . num = ( uint32_t ) p_3a_params -> exp_time ; val_rat . denom = 1 ; } else { val_rat . num = 1 ; <S2SV_ModEnd> val_rat . denom <S2SV_ModStart> -> exp_time ) <S2SV_ModEnd> ; } LOGD |
5,801 | CWE-000 double disasm__calc_percent ( struct annotation * notes , int evidx , s64 offset , s64 end , const char * * path , struct sym_hist_entry * sample ) { struct source_line * src_line = notes -> src -> lines ; double percent = 0.0 ; sample -> nr_samples = sample -> period = 0 ; if ( src_line ) { size_t sizeof_src_line = sizeof ( * src_line ) + sizeof ( src_line -> samples ) * ( src_line -> nr_pcnt - 1 ) ; while ( offset < end ) { src_line = ( void * ) notes -> src -> lines + ( sizeof_src_line * offset ) ; if ( * path == NULL ) * path = src_line -> path ; percent += src_line -> samples [ evidx ] . percent ; sample -> nr_samples += src_line -> samples [ evidx ] . nr ; offset ++ ; } } else { struct sym_hist * h = annotation__histogram ( notes , evidx ) ; unsigned int hits = 0 ; u64 period = 0 ; while ( offset < end ) { <S2SV_StartBug> hits += h -> addr [ offset ++ ] . nr_samples ; <S2SV_EndBug> period += h -> addr [ offset ++ ] . period ; } if ( h -> nr_samples ) { sample -> period = period ; sample -> nr_samples = hits ; percent = 100.0 * hits / h -> nr_samples ; } } return percent ; } | <S2SV_ModStart> addr [ offset ] . nr_samples ; period += h -> addr [ offset ] . period ; ++ offset <S2SV_ModEnd> ; } if |
5,802 | CWE-000 Split * pick_best ( Split * * splits , AABB * parent ) { float min_SAH = FLT_MAX ; int min_ind = - 1 ; for ( int i = 0 ; i < SPLIT_TEST_NUM ; i ++ ) { if ( splits [ i ] -> left_count == 0 || splits [ i ] -> right_count == 0 ) continue ; float res = SAH ( splits [ i ] , parent ) ; if ( res < min_SAH ) { min_SAH = res ; min_ind = i ; } } Split * winner = min_ind == - 1 ? NULL : splits [ min_ind ] ; for ( int i = 0 ; i < SPLIT_TEST_NUM ; i ++ ) if ( i == min_ind ) continue ; else free_split ( splits [ i ] ) ; free ( splits ) ; <S2SV_StartBug> return winner ; <S2SV_EndBug> } | <S2SV_ModStart> splits ) ; if ( winner -> both_count ) printf ( "parent<S2SV_blank>had<S2SV_blank>%d,<S2SV_blank>left<S2SV_blank>%d<S2SV_blank>right<S2SV_blank>%d<S2SV_blank>both<S2SV_blank>%d\\n" , parent -> member_count , winner -> left_count , winner -> right_count , winner -> both_count ) ; |
5,803 | CWE-000 static int vcn_v1_0_start_dpg_mode ( struct amdgpu_device * adev ) { struct amdgpu_ring * ring = & adev -> vcn . ring_dec ; uint32_t rb_bufsz , tmp ; uint32_t lmi_swap_cntl ; lmi_swap_cntl = 0 ; vcn_1_0_enable_static_power_gating ( adev ) ; tmp = RREG32_SOC15 ( UVD , 0 , mmUVD_POWER_STATUS ) ; tmp |= UVD_POWER_STATUS__UVD_PG_MODE_MASK ; tmp |= UVD_POWER_STATUS__UVD_PG_EN_MASK ; WREG32_SOC15 ( UVD , 0 , mmUVD_POWER_STATUS , tmp ) ; vcn_v1_0_clock_gating_dpg_mode ( adev , 0 ) ; tmp = ( 0xFF << UVD_VCPU_CNTL__PRB_TIMEOUT_VAL__SHIFT ) ; tmp |= UVD_VCPU_CNTL__CLK_EN_MASK ; tmp |= UVD_VCPU_CNTL__MIF_WR_LOW_THRESHOLD_BP_MASK ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_VCPU_CNTL , tmp , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MASTINT_EN , 0 , UVD_MASTINT_EN__VCPU_EN_MASK , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_LMI_CTRL , ( 8 << UVD_LMI_CTRL__WRITE_CLEAN_TIMER__SHIFT ) | UVD_LMI_CTRL__WRITE_CLEAN_TIMER_EN_MASK | UVD_LMI_CTRL__DATA_COHERENCY_EN_MASK | UVD_LMI_CTRL__VCPU_DATA_COHERENCY_EN_MASK | UVD_LMI_CTRL__REQ_MODE_MASK | UVD_LMI_CTRL__CRC_RESET_MASK | UVD_LMI_CTRL__MASK_MC_URGENT_MASK | 0x00100000L , 0xFFFFFFFF , 0 ) ; # ifdef __BIG_ENDIAN lmi_swap_cntl = 0xa ; # endif WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_LMI_SWAP_CNTL , lmi_swap_cntl , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MPC_CNTL , 0x2 << UVD_MPC_CNTL__REPLACEMENT_MODE__SHIFT , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MPC_SET_MUXA0 , ( ( 0x1 << UVD_MPC_SET_MUXA0__VARA_1__SHIFT ) | ( 0x2 << UVD_MPC_SET_MUXA0__VARA_2__SHIFT ) | ( 0x3 << UVD_MPC_SET_MUXA0__VARA_3__SHIFT ) | ( 0x4 << UVD_MPC_SET_MUXA0__VARA_4__SHIFT ) ) , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MPC_SET_MUXB0 , ( ( 0x1 << UVD_MPC_SET_MUXB0__VARB_1__SHIFT ) | ( 0x2 << UVD_MPC_SET_MUXB0__VARB_2__SHIFT ) | ( 0x3 << UVD_MPC_SET_MUXB0__VARB_3__SHIFT ) | ( 0x4 << UVD_MPC_SET_MUXB0__VARB_4__SHIFT ) ) , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MPC_SET_MUX , ( ( 0x0 << UVD_MPC_SET_MUX__SET_0__SHIFT ) | ( 0x1 << UVD_MPC_SET_MUX__SET_1__SHIFT ) | ( 0x2 << UVD_MPC_SET_MUX__SET_2__SHIFT ) ) , 0xFFFFFFFF , 0 ) ; vcn_v1_0_mc_resume_dpg_mode ( adev ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_REG_XX_MASK , 0x10 , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_RBC_XX_IB_REG_CHECK , 0x3 , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_SOFT_RESET , 0 , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_LMI_CTRL2 , 0x1F << UVD_LMI_CTRL2__RE_OFLD_MIF_WR_REQ_NUM__SHIFT , 0xFFFFFFFF , 0 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_MASTINT_EN , UVD_MASTINT_EN__VCPU_EN_MASK , UVD_MASTINT_EN__VCPU_EN_MASK , 0 ) ; vcn_v1_0_clock_gating_dpg_mode ( adev , 1 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_LMI_CTRL , ( 8 << UVD_LMI_CTRL__WRITE_CLEAN_TIMER__SHIFT ) | UVD_LMI_CTRL__WRITE_CLEAN_TIMER_EN_MASK | UVD_LMI_CTRL__DATA_COHERENCY_EN_MASK | UVD_LMI_CTRL__VCPU_DATA_COHERENCY_EN_MASK | UVD_LMI_CTRL__REQ_MODE_MASK | UVD_LMI_CTRL__CRC_RESET_MASK | UVD_LMI_CTRL__MASK_MC_URGENT_MASK | 0x00100000L , 0xFFFFFFFF , 1 ) ; tmp = adev -> gfx . config . gb_addr_config ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_JPEG_ADDR_CONFIG , tmp , 0xFFFFFFFF , 1 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_JPEG_UV_ADDR_CONFIG , tmp , 0xFFFFFFFF , 1 ) ; WREG32_SOC15_DPG_MODE ( UVD , 0 , mmUVD_SYS_INT_EN , UVD_SYS_INT_EN__UVD_JRBC_EN_MASK , 0xFFFFFFFF , 1 ) ; rb_bufsz = order_base_2 ( ring -> ring_size ) ; tmp = REG_SET_FIELD ( 0 , UVD_RBC_RB_CNTL , RB_BUFSZ , rb_bufsz ) ; tmp = REG_SET_FIELD ( tmp , UVD_RBC_RB_CNTL , RB_BLKSZ , 1 ) ; tmp = REG_SET_FIELD ( tmp , UVD_RBC_RB_CNTL , RB_NO_FETCH , 1 ) ; tmp = REG_SET_FIELD ( tmp , UVD_RBC_RB_CNTL , RB_NO_UPDATE , 1 ) ; tmp = REG_SET_FIELD ( tmp , UVD_RBC_RB_CNTL , RB_RPTR_WR_EN , 1 ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_CNTL , tmp ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_WPTR_CNTL , 0 ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_RPTR_ADDR , ( upper_32_bits ( ring -> gpu_addr ) >> 2 ) ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_LMI_RBC_RB_64BIT_BAR_LOW , lower_32_bits ( ring -> gpu_addr ) ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_LMI_RBC_RB_64BIT_BAR_HIGH , upper_32_bits ( ring -> gpu_addr ) ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_RPTR , 0 ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_SCRATCH2 , 0 ) ; ring -> wptr = RREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_RPTR ) ; WREG32_SOC15 ( UVD , 0 , mmUVD_RBC_RB_WPTR , lower_32_bits ( ring -> wptr ) ) ; WREG32_P ( SOC15_REG_OFFSET ( UVD , 0 , mmUVD_RBC_RB_CNTL ) , 0 , ~ UVD_RBC_RB_CNTL__RB_NO_FETCH_MASK ) ; <S2SV_StartBug> ring -> wptr = RREG32_SOC15 ( UVD , 0 , mmUVD_JRBC_RB_WPTR ) ; <S2SV_EndBug> vcn_v1_0_jpeg_ring_set_patch_ring ( ring , ( ring -> wptr + ring -> max_dw * amdgpu_sched_hw_submission ) ) ; return 0 ; } | <S2SV_ModStart> ) ; ring = & adev -> vcn . ring_jpeg ; ring |
5,804 | CWE-000 void send_neighbour_solicitation ( int fd , ip6_addr_t * dest_ip6 ) { ip6_addr_t snma ; <S2SV_StartBug> uint8_t ether_packet [ ETH_MTU_SIZE ] ; <S2SV_EndBug> struct packeth headers ; memset ( ether_packet , 0 , ETH_MTU_SIZE ) ; headers . ethh = ( struct ethhdr * ) ether_packet ; headers . ip6h = ( struct ip6hdr * ) ( ether_packet + sizeof ( struct ethhdr ) ) ; headers . icmp6h = ( struct icmp6hdr * ) ( ether_packet + sizeof ( struct ethhdr ) + sizeof ( struct ip6hdr ) ) ; snma . part . prefix = IPV6_SOLIC_NODE_PREFIX ; snma . part . interface_id = IPV6_SOLIC_NODE_IFACE_ID ; snma . addr [ 13 ] = dest_ip6 -> addr [ 13 ] ; snma . addr [ 14 ] = dest_ip6 -> addr [ 14 ] ; snma . addr [ 15 ] = dest_ip6 -> addr [ 15 ] ; fill_ip6hdr ( ( uint8_t * ) headers . ip6h , ICMPv6_HEADER_SIZE + sizeof ( struct neighbour_solicitation ) , 0x3a , get_ipv6_address ( ) , & snma ) ; headers . icmp6h -> type = ICMPV6_NEIGHBOUR_SOLICITATION ; headers . icmp6h -> code = 0 ; memcpy ( & ( headers . icmp6h -> icmp6body . nghb_solicit . target ) , dest_ip6 , IPV6_ADDR_LENGTH ) ; headers . icmp6h -> icmp6body . nghb_solicit . lladdr . type = 1 ; headers . icmp6h -> icmp6body . nghb_solicit . lladdr . length = 1 ; memcpy ( & ( headers . icmp6h -> icmp6body . nghb_solicit . lladdr . mac ) , get_mac_address ( ) , 6 ) ; send_ip ( fd , ether_packet + sizeof ( struct ethhdr ) , sizeof ( struct ip6hdr ) + ICMPv6_HEADER_SIZE + <S2SV_StartBug> sizeof ( struct neighbour_solicitation ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> snma ; uint8_t * ether_packet ; struct packeth headers ; ether_packet = malloc ( ETH_MTU_SIZE ) ; if ( ! ether_packet ) { fprintf ( stderr , "send_neighbour_solicitation:<S2SV_blank>Out<S2SV_blank>of<S2SV_blank>memory\\n" ) ; return ; } <S2SV_ModEnd> memset ( ether_packet <S2SV_ModStart> struct neighbour_solicitation ) ) ; free ( ether_packet |
5,805 | CWE-000 <S2SV_StartBug> u32 * display_init_framebuffer ( u32 * fb ) <S2SV_EndBug> { memset ( ( u32 * ) 0xC0000000 , 0 , 0x400000 ) ; exec_cfg ( ( u32 * ) DISPLAY_A_BASE , cfg_display_framebuffer , 32 ) ; sleep ( 35000 ) ; return ( u32 * ) 0xC0000000 ; } | <S2SV_ModStart> * display_init_framebuffer ( <S2SV_ModEnd> ) { memset |
5,806 | CWE-000 <S2SV_StartBug> int main ( int argc , char * argv [ ] ) <S2SV_EndBug> { int a , i , sum = 0 ; for ( i = 1 ; i < argc ; i ++ ) { a = _atoi ( argv [ i ] ) ; if ( argv [ i ] [ 0 ] != '0' && a == 0 ) { printf ( "Error\\n" ) ; <S2SV_StartBug> return ( 1 ) ; <S2SV_EndBug> } sum += a ; } printf ( "%d\\n" , sum ) ; return ( 0 ) ; } | <S2SV_ModStart> , char * * argv ) { frontend_init ( ) ; test_visitors ( ) ; test_semantic ( ) ; test_expression ( ) ; frontend_term ( <S2SV_ModEnd> ) ; return <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
5,807 | CWE-000 int sfc_attach ( struct sfc_adapter * sa ) { const efx_nic_cfg_t * encp ; efx_nic_t * enp = sa -> nic ; int rc ; sfc_log_init ( sa , "entry" ) ; SFC_ASSERT ( sfc_adapter_is_locked ( sa ) ) ; efx_mcdi_new_epoch ( enp ) ; sfc_log_init ( sa , "reset<S2SV_blank>nic" ) ; rc = efx_nic_reset ( enp ) ; if ( rc != 0 ) goto fail_nic_reset ; encp = efx_nic_cfg_get ( sa -> nic ) ; if ( sa -> dp_tx -> features & SFC_DP_TX_FEAT_TSO ) { sa -> tso = encp -> enc_fw_assisted_tso_v2_enabled ; if ( ! sa -> tso ) sfc_warn ( sa , "TSO<S2SV_blank>support<S2SV_blank>isn\'t<S2SV_blank>available<S2SV_blank>on<S2SV_blank>this<S2SV_blank>adapter" ) ; } sfc_log_init ( sa , "estimate<S2SV_blank>resource<S2SV_blank>limits" ) ; rc = sfc_estimate_resource_limits ( sa ) ; if ( rc != 0 ) goto fail_estimate_rsrc_limits ; sa -> txq_max_entries = encp -> enc_txq_max_ndescs ; SFC_ASSERT ( rte_is_power_of_2 ( sa -> txq_max_entries ) ) ; rc = sfc_intr_attach ( sa ) ; if ( rc != 0 ) goto fail_intr_attach ; rc = sfc_ev_attach ( sa ) ; if ( rc != 0 ) goto fail_ev_attach ; <S2SV_StartBug> efx_phy_adv_cap_get ( sa -> nic , EFX_PHY_CAP_PERM , <S2SV_EndBug> & sa -> port . phy_adv_cap_mask ) ; rc = sfc_set_rss_defaults ( sa ) ; if ( rc != 0 ) goto fail_set_rss_defaults ; rc = sfc_filter_attach ( sa ) ; if ( rc != 0 ) goto fail_filter_attach ; sfc_log_init ( sa , "fini<S2SV_blank>nic" ) ; efx_nic_fini ( enp ) ; sfc_flow_init ( sa ) ; sa -> state = SFC_ADAPTER_INITIALIZED ; sfc_log_init ( sa , "done" ) ; return 0 ; fail_filter_attach : <S2SV_StartBug> fail_set_rss_defaults : <S2SV_EndBug> sfc_ev_detach ( sa ) ; fail_ev_attach : sfc_intr_detach ( sa ) ; fail_intr_attach : efx_nic_fini ( sa -> nic ) ; fail_estimate_rsrc_limits : fail_nic_reset : sfc_log_init ( sa , "failed<S2SV_blank>%d" , rc ) ; return rc ; } | <S2SV_ModStart> goto fail_ev_attach ; rc = sfc_port_attach ( sa ) ; if ( rc != 0 ) goto fail_port_attach <S2SV_ModEnd> ; rc = <S2SV_ModStart> fail_filter_attach : fail_set_rss_defaults : sfc_port_detach ( sa ) ; fail_port_attach |
5,808 | CWE-000 static void launcher_saved ( GtkWidget * dialog , Launcher * launcher ) { const char * uri ; <S2SV_StartBug> const gchar * location ; <S2SV_EndBug> uri = panel_ditem_editor_get_uri ( PANEL_DITEM_EDITOR ( dialog ) ) ; <S2SV_StartBug> if ( panel_launcher_get_filename ( uri ) != NULL ) <S2SV_EndBug> uri = panel_launcher_get_filename ( uri ) ; <S2SV_StartBug> location = g_desktop_app_info_get_filename ( launcher -> app_info ) ; <S2SV_EndBug> if ( uri && location && strcmp ( uri , location ) ) { <S2SV_StartBug> g_settings_set_string ( launcher -> info -> settings , PANEL_OBJECT_LAUNCHER_LOCATION_KEY , uri ) ; <S2SV_EndBug> g_object_unref ( launcher -> app_info ) ; <S2SV_StartBug> launcher -> app_info = g_desktop_app_info_new_from_filename ( uri ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * uri ; <S2SV_ModEnd> gchar * location <S2SV_ModStart> gchar * location ; char * filename <S2SV_ModStart> ) ) ; filename <S2SV_ModEnd> = panel_launcher_get_filename ( <S2SV_ModStart> uri ) ; <S2SV_ModEnd> g_settings_set_string ( launcher <S2SV_ModStart> , PANEL_OBJECT_LAUNCHER_LOCATION_KEY , filename ) ; g_free ( filename <S2SV_ModEnd> ) ; g_object_unref <S2SV_ModStart> app_info ) ; location = g_filename_from_uri ( uri , NULL , NULL ) ; <S2SV_ModStart> = g_desktop_app_info_new_from_filename ( location ) ; g_free ( location <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,809 | CWE-000 void secondPass ( vector * linked , unsigned char labels [ ] ) { qsort ( linked , linked -> position , sizeof ( int ) , cmpfunc ) ; <S2SV_StartBug> int min , j ; <S2SV_EndBug> for ( int h = 0 ; h < _height ; h ++ ) { currentRow = h * _width ; for ( int currentColumn = 0 ; currentColumn < _width ; currentColumn ++ ) { position = currentRow + currentColumn ; if ( ( int ) labels [ position ] != 0 ) { for ( int i = 0 ; i < linked -> position ; i ++ ) { } } } } } | <S2SV_ModStart> min , j , currentRow , position |
5,810 | CWE-000 static struct r1conf * setup_conf ( struct mddev * mddev ) { struct r1conf * conf ; int i ; struct mirror_info * disk ; struct md_rdev * rdev ; int err = - ENOMEM ; conf = kzalloc ( sizeof ( struct r1conf ) , GFP_KERNEL ) ; if ( ! conf ) goto abort ; conf -> mirrors = kzalloc ( sizeof ( struct mirror_info ) * mddev -> raid_disks * 2 , GFP_KERNEL ) ; if ( ! conf -> mirrors ) goto abort ; conf -> tmppage = alloc_page ( GFP_KERNEL ) ; if ( ! conf -> tmppage ) goto abort ; conf -> poolinfo = kzalloc ( sizeof ( * conf -> poolinfo ) , GFP_KERNEL ) ; if ( ! conf -> poolinfo ) goto abort ; conf -> poolinfo -> raid_disks = mddev -> raid_disks * 2 ; conf -> r1bio_pool = mempool_create ( NR_RAID1_BIOS , r1bio_pool_alloc , r1bio_pool_free , conf -> poolinfo ) ; if ( ! conf -> r1bio_pool ) goto abort ; conf -> poolinfo -> mddev = mddev ; err = - EINVAL ; spin_lock_init ( & conf -> device_lock ) ; rdev_for_each ( rdev , mddev ) { struct request_queue * q ; int disk_idx = rdev -> raid_disk ; if ( disk_idx >= mddev -> raid_disks || disk_idx < 0 ) continue ; if ( test_bit ( Replacement , & rdev -> flags ) ) <S2SV_StartBug> disk = conf -> mirrors + conf -> raid_disks + disk_idx ; <S2SV_EndBug> else disk = conf -> mirrors + disk_idx ; if ( disk -> rdev ) goto abort ; disk -> rdev = rdev ; q = bdev_get_queue ( rdev -> bdev ) ; if ( q -> merge_bvec_fn ) mddev -> merge_check_needed = 1 ; disk -> head_position = 0 ; } conf -> raid_disks = mddev -> raid_disks ; conf -> mddev = mddev ; INIT_LIST_HEAD ( & conf -> retry_list ) ; spin_lock_init ( & conf -> resync_lock ) ; init_waitqueue_head ( & conf -> wait_barrier ) ; bio_list_init ( & conf -> pending_bio_list ) ; conf -> pending_count = 0 ; conf -> recovery_disabled = mddev -> recovery_disabled - 1 ; err = - EIO ; conf -> last_used = - 1 ; for ( i = 0 ; i < conf -> raid_disks * 2 ; i ++ ) { disk = conf -> mirrors + i ; if ( i < conf -> raid_disks && disk [ conf -> raid_disks ] . rdev ) { if ( ! disk -> rdev ) { disk -> rdev = disk [ conf -> raid_disks ] . rdev ; disk [ conf -> raid_disks ] . rdev = NULL ; } else if ( ! test_bit ( In_sync , & disk -> rdev -> flags ) ) goto abort ; } if ( ! disk -> rdev || ! test_bit ( In_sync , & disk -> rdev -> flags ) ) { disk -> head_position = 0 ; if ( disk -> rdev ) conf -> fullsync = 1 ; } else if ( conf -> last_used < 0 ) conf -> last_used = i ; } if ( conf -> last_used < 0 ) { printk ( KERN_ERR "md/raid1:%s:<S2SV_blank>no<S2SV_blank>operational<S2SV_blank>mirrors\\n" , mdname ( mddev ) ) ; goto abort ; } err = - ENOMEM ; conf -> thread = md_register_thread ( raid1d , mddev , NULL ) ; if ( ! conf -> thread ) { printk ( KERN_ERR "md/raid1:%s:<S2SV_blank>couldn\'t<S2SV_blank>allocate<S2SV_blank>thread\\n" , mdname ( mddev ) ) ; goto abort ; } return conf ; abort : if ( conf ) { if ( conf -> r1bio_pool ) mempool_destroy ( conf -> r1bio_pool ) ; kfree ( conf -> mirrors ) ; safe_put_page ( conf -> tmppage ) ; kfree ( conf -> poolinfo ) ; kfree ( conf ) ; } return ERR_PTR ( err ) ; } | <S2SV_ModStart> -> mirrors + mddev <S2SV_ModEnd> -> raid_disks + |
5,811 | CWE-000 bool hd44780lcd_handler ( hd44780_instance * instance ) { uint8_t LCDMSN , LCDRS , LCDRW , LCDE , LCDdatabyte ; bool dataInvalid = 1 ; dataInvalid = hd44780_getFromTxBuffer ( instance , & LCDMSN , & LCDRS , & LCDRW , & LCDE ) ; while ( dataInvalid == 0 ) { l11uxx_i2c_sendStart ( ) ; LCDdatabyte = 0 ; l11uxx_i2c_sendAddr ( instance -> I2C_addr , 0 ) ; <S2SV_StartBug> delay ( 1 ) ; <S2SV_EndBug> LCDdatabyte |= ( ( LCDMSN & 0x0F ) << 4 ) ; LCDdatabyte |= ( ( LCDE & 0x01 ) << instance -> I2C_pinE_offset ) ; LCDdatabyte |= ( ( LCDRW & 0x01 ) << 1 ) ; LCDdatabyte |= ( ( LCDRS & 0x01 ) << 0 ) ; l11uxx_i2c_sendByte ( LCDdatabyte ) ; <S2SV_StartBug> delay ( 1 ) ; <S2SV_EndBug> l11uxx_i2c_sendStop ( ) ; dataInvalid = hd44780_getFromTxBuffer ( instance , & LCDMSN , & LCDRS , & LCDRW , & LCDE ) ; } return dataInvalid ; } | <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> LCDdatabyte |= ( <S2SV_ModStart> LCDdatabyte ) ; l11uxx_i2c_sendStop ( ) ; <S2SV_ModStart> delay ( 1 <S2SV_ModEnd> ) ; dataInvalid |
5,812 | CWE-000 int pal_nic_otp_disable ( float val ) { <S2SV_StartBug> int ret = - 1 ; <S2SV_EndBug> <S2SV_StartBug> uint8_t slot = 0xFF , status = 0xFF , slot_type = 0xFF , pwr_state = 0xFF ; <S2SV_EndBug> for ( slot = 1 ; slot <= 4 ; slot ++ ) { slot_type = fby2_get_slot_type ( slot ) ; if ( SLOT_TYPE_SERVER == slot_type ) { pal_get_server_power ( slot , & status ) ; <S2SV_StartBug> if ( ( SERVER_12V_ON != status ) && ( 1 == otp_server_12v_off_flag ) ) { <S2SV_EndBug> <S2SV_StartBug> syslog ( LOG_CRIT , "Due<S2SV_blank>to<S2SV_blank>NIC<S2SV_blank>temp<S2SV_blank>UNC<S2SV_blank>deassert.<S2SV_blank>Power<S2SV_blank>On<S2SV_blank>Server<S2SV_blank>12V.<S2SV_blank>(val<S2SV_blank>=<S2SV_blank>%.2f)" , val ) ; <S2SV_EndBug> ret = server_12v_on ( slot ) ; if ( ret ) { syslog ( LOG_ERR , "server_12v_on()<S2SV_blank>failed,<S2SV_blank>slot%d" , slot ) ; } else { <S2SV_StartBug> pal_power_policy_control ( slot , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> otp_server_12v_off_flag = 0 ; <S2SV_EndBug> } } } } return 0 ; } | <S2SV_ModStart> { int ret <S2SV_ModEnd> ; uint8_t slot <S2SV_ModStart> ; uint8_t slot <S2SV_ModEnd> , status = <S2SV_ModStart> slot_type = 0xFF ; char pwr_state [ MAX_VALUE_LEN ] = { 0 } <S2SV_ModEnd> ; for ( <S2SV_ModStart> 1 == otp_server_12v_off_flag [ slot ] <S2SV_ModStart> ( LOG_CRIT , "FRU:<S2SV_blank>%u,<S2SV_blank>Power<S2SV_blank>On<S2SV_blank>Server<S2SV_blank>12V<S2SV_blank>due<S2SV_blank>to<S2SV_blank>NIC<S2SV_blank>temp<S2SV_blank>UCR<S2SV_blank>deassert.<S2SV_blank>(val<S2SV_blank>=<S2SV_blank>%.2f)" , slot , val ) ; pal_get_last_pwr_state ( slot , pwr_state <S2SV_ModEnd> ) ; ret <S2SV_ModStart> ( slot , pwr_state <S2SV_ModEnd> ) ; otp_server_12v_off_flag <S2SV_ModStart> ) ; otp_server_12v_off_flag [ slot ] |
5,813 | CWE-000 void transform_u ( t_data * data , uintmax_t varUIntMax ) { if ( varUIntMax == 0 ) { if ( data -> current -> precision == 0 && data -> current -> flagDot == 1 ) data -> current -> outputArg = ft_strdup ( "" ) ; else <S2SV_StartBug> data -> current -> outputArg = malloc_prec_zero_doux ( data -> current -> precision , data ) ; <S2SV_EndBug> } else data -> current -> outputArg = ft_itoa_base_printf ( varUIntMax , 10 , "0123456789abcdef" , data -> current -> precision ) ; } | <S2SV_ModStart> precision , data , 'u' |
5,814 | CWE-000 static void serv_pass ( void ) { ptag_t * msg_out ; int exitstatus ; int lookback , newlines , nsend ; char * pc = NULL , * psend = NULL ; if ( g . conn . sock < 0 || ! g . conn . passing ) { return ; } # if 1 lookback = g . conn . pass . lookback ; <S2SV_StartBug> if ( lookback == 0 ) { <S2SV_EndBug> psend = g . rawnew ; } else { g . conn . pass . lookback = 0 ; newlines = 0 ; for ( pc = g . rawnew + g . newcnt - 1 ; pc >= g . rawbuf ; -- pc ) { if ( pc [ 0 ] == '\\n' ) { if ( ++ newlines >= lookback ) { break ; } } } if ( newlines == 0 ) { psend = g . rawbuf ; } else if ( newlines < lookback ) { if ( g . rawoffset == 0 ) { psend = g . rawbuf ; } else { pc = strchr ( g . rawbuf , '\\n' ) ; if ( pc < g . rawnew ) { psend = pc + 1 ; } else { psend = g . rawnew ; } } } else { if ( pc < g . rawnew ) { psend = pc + 1 ; } else { psend = g . rawnew ; for ( pc = g . rawnew - 1 ; pc >= g . rawbuf ; -- pc ) { if ( pc [ 0 ] == '\\n' ) { psend = pc + 1 ; break ; } } if ( pc < g . rawbuf ) { if ( g . rawoffset == 0 ) { psend = g . rawbuf ; } } } } } nsend = g . rawnew + g . newcnt - psend ; if ( nsend > 0 ) { msg_out = ptag_new_raw ( PTAG_OUTPUT , nsend , psend ) ; if ( serv_msg_send ( & msg_out , true ) < 0 ) { return ; } g . rawnew += g . newcnt ; g . newcnt = 0 ; } # else if ( g . newcnt > 0 ) { msg_out = ptag_new_raw ( PTAG_OUTPUT , g . newcnt , g . rawnew ) ; if ( serv_msg_send ( & msg_out , true ) < 0 ) { return ; } g . rawnew += g . newcnt ; g . newcnt = 0 ; } # endif if ( g . conn . pass . subcmd == PASS_SUBCMD_EXPECT ) { buf_raw2expect ( ) ; } if ( ( g . conn . pass . expflags & ( PASS_EXPECT_EXACT | PASS_EXPECT_GLOB | PASS_EXPECT_ERE ) ) != 0 ) { if ( serv_expect ( ) ) { msg_out = ptag_new_bool ( PTAG_MATCHED , 1 ) ; serv_msg_send ( & msg_out , true ) ; g . conn . passing = false ; return ; } } else if ( g . conn . pass . subcmd == PASS_SUBCMD_INTERACT || g . conn . pass . subcmd == PASS_SUBCMD_WAIT ) { g . expoffset = g . ntotal ; g . expcnt = 0 ; } if ( g . fd_ptm < 0 && g . expoffset >= g . ntotal ) { if ( ( g . conn . pass . expflags & PASS_EXPECT_EOF ) != 0 ) { g . expoffset = g . ntotal ; g . expcnt = 0 ; msg_out = ptag_new_struct ( PTAG_EOF ) ; serv_msg_send ( & msg_out , true ) ; g . conn . passing = false ; } else if ( ( g . conn . pass . expflags & PASS_EXPECT_EXIT ) != 0 ) { if ( ! g . waited && g . SIGCHLDed ) { waitpid ( g . child , & exitstatus , 0 ) ; g . waited = true ; msg_out = ptag_new_int ( PTAG_EXITED , exitstatus ) ; serv_msg_send ( & msg_out , true ) ; g . conn . passing = false ; } else { } } else { msg_out = serv_new_error ( ERROR_EOF , "PTY<S2SV_blank>closed" ) ; serv_msg_send ( & msg_out , true ) ; g . conn . passing = false ; } return ; } if ( exp_timed_out ( ) ) { msg_out = serv_new_error ( ERROR_TIMEOUT , "expect<S2SV_blank>timed<S2SV_blank>out" ) ; serv_msg_send ( & msg_out , true ) ; g . conn . passing = false ; return ; } } | <S2SV_ModStart> if ( lookback <= 0 ) { psend = g . rawnew ; } else { g . conn . pass . lookback = 0 ; if ( g . ntotal > 0 && g . rawnew [ g . newcnt - 1 ] == '\\n' ) { ++ lookback ; } <S2SV_ModEnd> newlines = 0 |
5,815 | CWE-000 void uart_send_fsm ( ) { static int send_count = 0 ; if ( uart_busy ( ) ) return ; send_count ++ ; switch ( send_count ) { <S2SV_StartBug> case 4 : <S2SV_EndBug> { int bat_v = get_bat_v ( ) ; int bat_percentage = ( 100 * ( bat_v - 15500 ) ) / ( 21000 - 15500 ) ; if ( bat_percentage < 0 ) bat_percentage = 0 ; if ( bat_percentage > 127 ) bat_percentage = 127 ; txbuf [ 0 ] = ( ( CHA_RUNNING ( ) ) ? 1 : 0 ) | ( ( CHA_FINISHED ( ) ) ? 2 : 0 ) ; txbuf [ 1 ] = I16_MS ( bat_v ) ; txbuf [ 2 ] = I16_LS ( bat_v ) ; txbuf [ 3 ] = bat_percentage ; send_uart ( txbuf , 0xa2 , 4 ) ; } break ; <S2SV_StartBug> case 8 : <S2SV_EndBug> { for ( int i = 0 ; i < 10 ; i ++ ) { int tm = dbg [ i ] ; txbuf [ 5 * i + 0 ] = I32_I7_4 ( tm ) ; txbuf [ 5 * i + 1 ] = I32_I7_3 ( tm ) ; txbuf [ 5 * i + 2 ] = I32_I7_2 ( tm ) ; txbuf [ 5 * i + 3 ] = I32_I7_1 ( tm ) ; txbuf [ 5 * i + 4 ] = I32_I7_0 ( tm ) ; } send_uart ( txbuf , 0xd2 , 50 ) ; } break ; <S2SV_StartBug> case 12 : <S2SV_EndBug> { extern int cur_compass_angle ; extern volatile int compass_round_on ; txbuf [ 0 ] = compass_round_on ; int tm = cur_compass_angle >> 16 ; txbuf [ 1 ] = I16_MS ( tm ) ; txbuf [ 2 ] = I16_LS ( tm ) ; send_uart ( txbuf , 0xa3 , 3 ) ; } break ; <S2SV_StartBug> case 1 : <S2SV_EndBug> case 3 : case 5 : case 7 : case 9 : case 11 : case 13 : { txbuf [ 0 ] = 1 ; txbuf [ 1 ] = get_xy_id ( ) ; int tm = get_xy_left ( ) ; if ( tm < 0 ) tm *= - 1 ; else if ( tm > 30000 ) tm = 30000 ; txbuf [ 2 ] = I16_MS ( tm ) ; txbuf [ 3 ] = I16_LS ( tm ) ; uint32_t t = get_obstacle_avoidance_stop_flags ( ) ; txbuf [ 4 ] = I32_I7_4 ( t ) ; txbuf [ 5 ] = I32_I7_3 ( t ) ; txbuf [ 6 ] = I32_I7_2 ( t ) ; txbuf [ 7 ] = I32_I7_1 ( t ) ; txbuf [ 8 ] = I32_I7_0 ( t ) ; t = get_obstacle_avoidance_action_flags ( ) ; txbuf [ 9 ] = I32_I7_4 ( t ) ; txbuf [ 10 ] = I32_I7_3 ( t ) ; txbuf [ 11 ] = I32_I7_2 ( t ) ; txbuf [ 12 ] = I32_I7_1 ( t ) ; txbuf [ 13 ] = I32_I7_0 ( t ) ; extern uint8_t feedback_stop_flags ; extern int feedback_stop_param1 , feedback_stop_param2 ; txbuf [ 14 ] = feedback_stop_flags & 0x7f ; tm = feedback_stop_param1 ; txbuf [ 15 ] = I16_MS ( tm ) ; txbuf [ 16 ] = I16_LS ( tm ) ; tm = feedback_stop_param2 ; txbuf [ 17 ] = I16_MS ( tm ) ; txbuf [ 18 ] = I16_LS ( tm ) ; send_uart ( txbuf , 0xa5 , 19 ) ; } break ; case 0 : case 2 : case 6 : case 10 : { txbuf [ 0 ] = 1 ; __disable_irq ( ) ; int tm = cur_pos . ang ; __enable_irq ( ) ; tm >>= 16 ; txbuf [ 1 ] = I16_MS ( tm ) ; txbuf [ 2 ] = I16_LS ( tm ) ; __disable_irq ( ) ; tm = cur_pos . x ; __enable_irq ( ) ; if ( tm < - 1000000 || tm > 1000000 ) tm = 123456789 ; txbuf [ 3 ] = I32_I7_4 ( tm ) ; txbuf [ 4 ] = I32_I7_3 ( tm ) ; txbuf [ 5 ] = I32_I7_2 ( tm ) ; txbuf [ 6 ] = I32_I7_1 ( tm ) ; txbuf [ 7 ] = I32_I7_0 ( tm ) ; __disable_irq ( ) ; tm = cur_pos . y ; __enable_irq ( ) ; if ( tm < - 1000000 || tm > 1000000 ) tm = 123456789 ; txbuf [ 8 ] = I32_I7_4 ( tm ) ; txbuf [ 9 ] = I32_I7_3 ( tm ) ; txbuf [ 10 ] = I32_I7_2 ( tm ) ; txbuf [ 11 ] = I32_I7_1 ( tm ) ; txbuf [ 12 ] = I32_I7_0 ( tm ) ; send_uart ( txbuf , 0xa0 , 13 ) ; } break ; default : send_count = 0 ; break ; } } | <S2SV_ModStart> ) { case 0 <S2SV_ModEnd> : { int <S2SV_ModStart> break ; case 1 <S2SV_ModEnd> : { for <S2SV_ModStart> break ; case 2 <S2SV_ModEnd> : { extern <S2SV_ModStart> } break ; default : send_count = 0 ; break ; <S2SV_ModEnd> } } <S2SV_null> |
5,816 | CWE-000 <S2SV_StartBug> ql_error_t ql_get_user_data ( struct qaul * state , struct ql_auth_token * token , const char * key , void * * value ) <S2SV_EndBug> { } | <S2SV_ModStart> state , struct qaul_auth_token <S2SV_ModEnd> * token , |
5,817 | CWE-000 static void * generate_pem_file ( EVP_PKEY * evp_pkey ) { FILE * fp ; if ( ( fp = fopen ( PUBLIC_KEY_FILENAME , "w" ) ) == NULL ) goto err ; if ( ! PEM_write_PUBKEY ( fp , evp_pkey ) ) goto err ; if ( ( fp = fopen ( PRIVATE_KEY_FILENAME , "w" ) ) == NULL ) goto err ; if ( ! PEM_write_PrivateKey ( fp , evp_pkey , NULL , NULL , 0 , 0 , NULL ) ) goto err ; <S2SV_StartBug> printf ( "✅\\tGenerated<S2SV_blank>EC<S2SV_blank>Key<S2SV_blank>Pair<S2SV_blank>and<S2SV_blank>written<S2SV_blank>PEM<S2SV_blank>files\\n" ) ; <S2SV_EndBug> goto end ; err : ERR_print_errors_fp ( stderr ) ; goto end ; end : fclose ( fp ) ; return ( 0 ) ; } | <S2SV_ModStart> ; printf ( "✅\\tGenerated<S2SV_blank>EC<S2SV_blank>Key<S2SV_blank>Pair.\\n✅\\tWritten<S2SV_blank>PEM<S2SV_blank>files.\\n" <S2SV_ModEnd> ) ; goto |
5,818 | CWE-000 static void color_update_stream ( void ) { uint8 temp [ 3 ] ; <S2SV_StartBug> uint8 i = 0 ; <S2SV_EndBug> memcpy ( current_color . led_data , target_color . led_data , LED_NUM ) ; memcpy ( initial_color . led_data , target_color . led_data , LED_NUM ) ; memcpy ( temp , target_color . rgb_data [ i ] , 3 ) ; for ( i = 0 ; i < RGB_NUM - 1 ; i ++ ) { memcpy ( target_color . rgb_data [ i ] , target_color . rgb_data [ i + 1 ] , 3 ) ; } memcpy ( target_color . rgb_data [ i ] , temp , 3 ) ; } | <S2SV_ModStart> i = 0 <S2SV_ModEnd> ; memcpy ( |
5,819 | CWE-000 void * listen_to_other_processes ( ) { int sockfd , n ; socklen_t clilen ; struct sockaddr_in serv_addr , cli_addr ; char buf [ MAX_PACKAGE_DATA_LENGTH ] ; if ( ( sockfd = socket ( AF_INET , SOCK_DGRAM , 0 ) ) == - 1 ) printf ( "ERROR<S2SV_blank>opening<S2SV_blank>socket" ) ; serv_addr . sin_family = AF_INET ; serv_addr . sin_port = htons ( self . port ) ; serv_addr . sin_addr . s_addr = INADDR_ANY ; bzero ( & ( serv_addr . sin_zero ) , 8 ) ; if ( bind ( sockfd , ( struct sockaddr * ) & serv_addr , sizeof ( struct sockaddr ) ) < 0 ) { printf ( "ERROR<S2SV_blank>on<S2SV_blank>binding\\n" ) ; } internal_socket_id = sockfd ; message_t * msg = malloc ( sizeof ( message_t ) ) ; char message_buffer [ sizeof ( message_t ) ] ; <S2SV_StartBug> while ( 1 ) { <S2SV_EndBug> n = recvfrom ( sockfd , message_buffer , sizeof ( message_t ) , 0 , ( struct sockaddr * ) & cli_addr , & clilen ) ; if ( n < 0 ) printf ( "ERROR<S2SV_blank>on<S2SV_blank>recvfrom" ) ; memcpy ( msg , message_buffer , sizeof ( message_t ) ) ; if ( msg -> type == _MSG_TYPE_CONNECT_PLEASE ) { process_t * new_backup = get_process_from_message ( msg , cli_addr ) ; new_backup -> socket_id = sockfd ; new_backup -> socket_id_2 = create_socket ( new_backup -> ip , new_backup -> port - PORT_OFFSET , & ( new_backup -> address_2 ) ) ; list_insert ( & other_processes , new_backup ) ; message_t message ; config_message ( & message , _MSG_TYPE_CONNECTED , 0 , "" , "" ) ; send_message2 ( sockfd , message , & ( new_backup -> address ) ) ; printf ( BACKUP_CONNECTION_SUCCEDED , new_backup -> pid ) ; } else if ( msg -> type == _MSG_TYPE_PLEASE_GIVE_ME_PROCESSESS_DATA ) { int has_sent_self = FALSE ; char buffer [ MAX_PACKAGE_DATA_LENGTH ] ; char buffer_ip [ MAXNAME ] ; message_t message ; process_t * p ; list_t * aux = other_processes ; while ( aux != NULL ) { p = ( process_t * ) aux -> value ; if ( ! has_sent_self ) { p = & self ; has_sent_self = TRUE ; } else { aux = aux -> next ; } memcpy ( buffer , p , sizeof ( process_t ) ) ; config_message2 ( & message , _MSG_TYPE_PROCESS_DATA , 0 , buffer , "" ) ; send_message2 ( sockfd , message , & cli_addr ) ; n = recvfrom ( sockfd , message_buffer , sizeof ( message_t ) , 0 , ( struct sockaddr * ) & cli_addr , & clilen ) ; if ( n < 0 ) printf ( "ERROR<S2SV_blank>on<S2SV_blank>recvfrom" ) ; } config_message ( & message , _MSG_TYPE_END_OF_PROCESS_DATA , 0 , "" , "" ) ; send_message2 ( sockfd , message , & cli_addr ) ; } else if ( msg -> type == _MSG_TYPE_BACKUP_TO_BACKUP_CONNECT_PLEASE ) { process_t * new_backup = get_process_from_message ( msg , cli_addr ) ; new_backup -> socket_id = sockfd ; list_insert ( & other_processes , new_backup ) ; print_processes_list ( ) ; message_t message ; config_message ( & message , _MSG_TYPE_CONNECTED , 0 , "" , "" ) ; send_message2 ( sockfd , message , & ( new_backup -> address ) ) ; } else if ( msg -> type == _MSG_TYPE_ARE_YOU_OK ) { message_t message ; config_message ( & message , MSG_TYPE_OK , 0 , "" , "" ) ; send_message2 ( sockfd , message , & cli_addr ) ; } else if ( msg -> type == _MSG_TYPE_LEADER_HAS_FAILED ) { printf ( BACKUP_HAS_BEEN_WARNED_OF_PRIMARY_FAILURE ) ; pthread_cancel ( tid_healthcheck ) ; } else if ( msg -> type == _MSG_TYPE_ELECTION ) { printf ( BACKUP_RECEIVED_ELECTION_MESSAGE ) ; create_election ( ) ; } else if ( msg -> type == _MSG_TYPE_I_AM_THE_LEADER ) { process_t * new_leader = get_process_from_message ( msg , cli_addr ) ; process_t * new_leader_in_list = get_process_from_pid ( & other_processes , new_leader -> pid ) ; remove_primary ( ) ; new_leader_in_list -> role = new_leader -> role ; new_leader_in_list -> port = new_leader -> port ; new_leader_in_list -> socket_id = create_socket ( new_leader_in_list -> ip , new_leader_in_list -> port , & ( new_leader_in_list -> address ) ) ; printf ( NEW_PRIMARY_CONNECTION_SUCCEDED , new_leader_in_list -> pid ) ; print_processes_list ( ) ; pthread_create ( & tid_healthcheck , NULL , primary_healthcheck , NULL ) ; free ( new_leader ) ; } } } | <S2SV_ModStart> ) ] ; clilen = sizeof ( struct sockaddr_in ) ; |
5,820 | CWE-000 void RB_SetGL2D ( void ) { backEnd . projection2D = qtrue ; qglViewport ( 0 , 0 , glConfig . vidWidth , glConfig . vidHeight ) ; qglScissor ( 0 , 0 , glConfig . vidWidth , glConfig . vidHeight ) ; qglMatrixMode ( GL_PROJECTION ) ; qglLoadIdentity ( ) ; qglOrtho ( 0 , glConfig . vidWidth , glConfig . vidHeight , 0 , 0 , 1 ) ; qglMatrixMode ( GL_MODELVIEW ) ; qglLoadIdentity ( ) ; GL_State ( GLS_DEPTHTEST_DISABLE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ) ; GL_Cull ( CT_TWO_SIDED ) ; qglDisable ( GL_CLIP_PLANE0 ) ; backEnd . refdef . time = ri . Milliseconds ( ) ; <S2SV_StartBug> backEnd . refdef . floatTime = backEnd . refdef . time * 0.001f ; <S2SV_EndBug> } | <S2SV_ModStart> . floatTime = ( double ) |
5,821 | CWE-000 int64_t assume_int ( tree_t t ) { switch ( tree_kind ( t ) ) { case T_LITERAL : assert ( tree_subkind ( t ) == L_INT ) ; return tree_ival ( t ) ; case T_REF : { tree_t ref = tree_ref ( t ) ; if ( tree_kind ( ref ) == T_CONST_DECL ) return assume_int ( tree_value ( ref ) ) ; else { assert ( tree_kind ( ref ) == T_ENUM_LIT ) ; return tree_pos ( ref ) ; } <S2SV_StartBug> } <S2SV_EndBug> case T_FCALL : { const eval_flags_t flags = EVAL_FCALL | EVAL_BOUNDS | EVAL_WARN | EVAL_REPORT | EVAL_LOWER ; tree_t new = eval ( t , flags ) ; const tree_kind_t new_kind = tree_kind ( new ) ; <S2SV_StartBug> if ( new_kind == T_LITERAL || new_kind == T_REF ) <S2SV_EndBug> <S2SV_StartBug> return assume_int ( new ) ; <S2SV_EndBug> } default : fatal_at ( tree_loc ( t ) , "expression<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>folded<S2SV_blank>to<S2SV_blank>" "an<S2SV_blank>integer<S2SV_blank>constant" ) ; } } | <S2SV_ModStart> ; } } case T_TYPE_CONV : case T_QUALIFIED : <S2SV_ModStart> new ) ; switch ( new_kind ) { case T_LITERAL : case T_REF : case T_TYPE_CONV : case T_QUALIFIED : <S2SV_ModEnd> return assume_int ( <S2SV_ModStart> new ) ; default : break ; } |
5,822 | CWE-000 void cpu_loop ( CPUCRISState * env ) { CPUState * cs = CPU ( cris_env_get_cpu ( env ) ) ; int trapnr , ret ; target_siginfo_t info ; while ( 1 ) { cpu_exec_start ( cs ) ; trapnr = cpu_exec ( cs ) ; cpu_exec_end ( cs ) ; process_queued_cpu_work ( cs ) ; switch ( trapnr ) { case 0xaa : { info . si_signo = TARGET_SIGSEGV ; info . si_errno = 0 ; info . si_code = TARGET_SEGV_MAPERR ; info . _sifields . _sigfault . _addr = env -> pregs [ PR_EDA ] ; queue_signal ( env , info . si_signo , QEMU_SI_FAULT , & info ) ; } break ; case EXCP_INTERRUPT : break ; case EXCP_BREAK : ret = do_syscall ( env , env -> regs [ 9 ] , env -> regs [ 10 ] , env -> regs [ 11 ] , env -> regs [ 12 ] , env -> regs [ 13 ] , env -> pregs [ 7 ] , env -> pregs [ 11 ] , 0 , 0 ) ; if ( ret == - TARGET_ERESTARTSYS ) { env -> pc -= 2 ; } else if ( ret != - TARGET_QEMU_ESIGRETURN ) { env -> regs [ 10 ] = ret ; } break ; case EXCP_DEBUG : <S2SV_StartBug> { <S2SV_EndBug> int sig ; sig = gdb_handlesig ( cs , TARGET_SIGTRAP ) ; if ( sig ) { <S2SV_StartBug> info . si_signo = sig ; <S2SV_EndBug> info . si_errno = 0 ; info . si_code = TARGET_TRAP_BRKPT ; queue_signal ( env , info . si_signo , QEMU_SI_FAULT , & info ) ; <S2SV_StartBug> } <S2SV_EndBug> } break ; case EXCP_ATOMIC : cpu_exec_step_atomic ( cs ) ; break ; default : fprintf ( stderr , "Unhandled<S2SV_blank>trap:<S2SV_blank>0x%x\\n" , trapnr ) ; cpu_dump_state ( cs , stderr , fprintf , 0 ) ; exit ( EXIT_FAILURE ) ; } process_pending_signals ( env ) ; } } | <S2SV_ModStart> case EXCP_DEBUG : info . si_signo = TARGET_SIGTRAP ; info . si_errno = 0 ; info . si_code = TARGET_TRAP_BRKPT ; queue_signal ( env , <S2SV_ModEnd> info . si_signo <S2SV_ModStart> info . si_signo <S2SV_ModEnd> , QEMU_SI_FAULT , <S2SV_ModStart> info ) ; <S2SV_ModEnd> break ; case |
5,823 | CWE-000 static gboolean is_supported_tailcall ( MonoCompile * cfg , const guint8 * ip , MonoMethod * method , MonoMethod * cmethod , MonoMethodSignature * fsig , gboolean virtual_ , gboolean extra_arg , gboolean * ptailcall_calli ) { gboolean tailcall = TRUE ; gboolean tailcall_calli = TRUE ; if ( IS_NOT_SUPPORTED_TAILCALL ( virtual_ && ! cfg -> backend -> have_op_tailcall_membase ) ) tailcall = FALSE ; if ( IS_NOT_SUPPORTED_TAILCALL ( ! cfg -> backend -> have_op_tailcall_reg ) ) tailcall_calli = FALSE ; if ( ! tailcall && ! tailcall_calli ) goto exit ; <S2SV_StartBug> if ( IS_NOT_SUPPORTED_TAILCALL ( fsig -> hasthis && m_class_is_valuetype ( cmethod -> klass ) ) <S2SV_EndBug> <S2SV_StartBug> || IS_NOT_SUPPORTED_TAILCALL ( cmethod -> flags & METHOD_ATTRIBUTE_PINVOKE_IMPL ) <S2SV_EndBug> || IS_NOT_SUPPORTED_TAILCALL ( cfg -> method -> save_lmf ) <S2SV_StartBug> || IS_NOT_SUPPORTED_TAILCALL ( cmethod -> wrapper_type && cmethod -> wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD ) <S2SV_EndBug> || IS_NOT_SUPPORTED_TAILCALL ( extra_arg && ! cfg -> backend -> have_volatile_non_param_register ) ) { tailcall_calli = FALSE ; tailcall = FALSE ; goto exit ; } for ( int i = 0 ; i < fsig -> param_count ; ++ i ) { if ( IS_NOT_SUPPORTED_TAILCALL ( fsig -> params [ i ] -> byref || fsig -> params [ i ] -> type == MONO_TYPE_PTR || fsig -> params [ i ] -> type == MONO_TYPE_FNPTR ) ) { tailcall_calli = FALSE ; tailcall = FALSE ; goto exit ; } } MonoMethodSignature * caller_signature ; MonoMethodSignature * callee_signature ; caller_signature = mono_method_signature ( method ) ; <S2SV_StartBug> callee_signature = mono_method_signature ( cmethod ) ; <S2SV_EndBug> g_assert ( caller_signature ) ; g_assert ( callee_signature ) ; if ( IS_NOT_SUPPORTED_TAILCALL ( mini_get_underlying_type ( caller_signature -> ret ) -> type != mini_get_underlying_type ( callee_signature -> ret ) -> type ) || IS_NOT_SUPPORTED_TAILCALL ( ! mono_arch_tailcall_supported ( cfg , caller_signature , callee_signature ) ) ) { tailcall_calli = FALSE ; tailcall = FALSE ; goto exit ; } # if 0 if ( ! mono_debug_count ( ) ) { tailcall_calli = FALSE ; tailcall = FALSE ; goto exit ; } # endif if ( tailcall_calli && IS_NOT_SUPPORTED_TAILCALL ( should_check_stack_pointer ( cfg ) ) ) tailcall_calli = FALSE ; exit : tailcall_print ( "tail.%s<S2SV_blank>%s<S2SV_blank>-><S2SV_blank>%s<S2SV_blank>tailcall:%d<S2SV_blank>tailcall_calli:%d<S2SV_blank>gshared:%d<S2SV_blank>extra_arg:%d<S2SV_blank>virtual_:%d\\n" , <S2SV_StartBug> mono_opcode_name ( * ip ) , method -> name , cmethod -> name , tailcall , tailcall_calli , <S2SV_EndBug> cfg -> gshared , extra_arg , virtual_ ) ; * ptailcall_calli = tailcall_calli ; return tailcall ; } | <S2SV_ModStart> ( IS_NOT_SUPPORTED_TAILCALL ( cmethod && <S2SV_ModStart> ) || IS_NOT_SUPPORTED_TAILCALL ( cmethod && <S2SV_ModStart> & METHOD_ATTRIBUTE_PINVOKE_IMPL ) ) || IS_NOT_SUPPORTED_TAILCALL ( fsig -> pinvoke ) <S2SV_ModStart> || IS_NOT_SUPPORTED_TAILCALL ( ! cmethod && fsig -> hasthis ) || IS_NOT_SUPPORTED_TAILCALL ( cmethod && <S2SV_ModStart> ; callee_signature = cmethod ? <S2SV_ModStart> ( cmethod ) : fsig <S2SV_ModStart> name , cmethod ? cmethod -> name : "calli" <S2SV_ModEnd> , tailcall , |
5,824 | CWE-000 SQLITE_PRIVATE int sqlite3VdbeTransferError ( Vdbe * p ) { sqlite3 * db = p -> db ; int rc = p -> rc ; if ( p -> zErrMsg ) { u8 mallocFailed = db -> mallocFailed ; <S2SV_StartBug> sqlite3BeginBenignMalloc ( ) ; <S2SV_EndBug> sqlite3ValueSetStr ( db -> pErr , - 1 , p -> zErrMsg , SQLITE_UTF8 , SQLITE_TRANSIENT ) ; sqlite3EndBenignMalloc ( ) ; db -> mallocFailed = mallocFailed ; db -> errCode = rc ; } else { sqlite3Error ( db , rc , 0 ) ; } return rc ; } | <S2SV_ModStart> ; sqlite3BeginBenignMalloc ( ) ; if ( db -> pErr == 0 ) db -> pErr = sqlite3ValueNew ( db |
5,825 | CWE-000 void swap ( stack_t * * stack , unsigned int line_number ) { stack_t * temp = * stack ; stack_t * storage ; size_t i = 0 ; if ( checkfortwo ( stack ) ) { fprintf ( stderr , "L%u:<S2SV_blank>can\'t<S2SV_blank>swap,<S2SV_blank>stack<S2SV_blank>too<S2SV_blank>short\\n" , line_number ) ; freeit ( stack ) ; exit ( EXIT_FAILURE ) ; } while ( temp -> next != NULL ) { i ++ ; temp = temp -> next ; } if ( ++ i == 2 ) { storage = temp -> prev ; storage -> prev = temp ; <S2SV_StartBug> temp -> prev = NULL ; <S2SV_EndBug> storage -> next = NULL ; <S2SV_StartBug> } <S2SV_EndBug> else { storage = temp -> prev ; storage -> prev -> next = temp ; temp -> prev = storage -> prev ; storage -> prev = temp ; storage -> next = temp -> next ; temp -> next = storage ; } } | <S2SV_ModStart> ; temp -> next = storage ; temp -> <S2SV_ModStart> = NULL ; * stack = temp ; |
5,826 | CWE-000 void bta_fs_co_open ( const char * p_path , int oflags , UINT32 size , UINT16 evt , UINT8 app_id ) { tBTA_FS_CO_STATUS status ; UINT32 file_size = 0 ; struct stat file_stat ; int fd = - 1 ; int err = 0 ; oflags = bta_fs_convert_bta_oflags ( oflags ) ; if ( oflags & ( O_RDWR | O_WRONLY ) ) { err = btapp_fs_check_space ( p_path , size , app_id ) ; } if ( 0 == err ) { <S2SV_StartBug> if ( ( fd = open ( p_path , oflags | O_NONBLOCK , 0666 ) ) >= 0 ) <S2SV_EndBug> { if ( fstat ( fd , & file_stat ) == 0 ) { file_size = file_stat . st_size ; if ( oflags & O_CREAT ) { fchown ( fd , BT_UID , BT_GID ) ; BTIF_TRACE_DEBUG ( "\\n<S2SV_blank>******CHANGED<S2SV_blank>OWNERSHIP<S2SV_blank>SUCCESSFULLY**********" ) ; } } } else { err = errno ; } } BTIF_TRACE_DEBUG ( "[CO]<S2SV_blank>bta_fs_co_open:<S2SV_blank>handle:%d<S2SV_blank>err:%d,<S2SV_blank>flags:%x,<S2SV_blank>app<S2SV_blank>id:%d" , fd , err , oflags , app_id ) ; BTIF_TRACE_DEBUG ( "file=%s" , p_path ) ; switch ( err ) { case 0 : status = BTA_FS_CO_OK ; break ; case EACCES : status = BTA_FS_CO_EACCES ; break ; case EFBIG : status = BTA_FS_CO_ENOSPACE ; break ; default : status = BTA_FS_CO_FAIL ; break ; } bta_fs_ci_open ( fd , status , file_size , evt ) ; } | <S2SV_ModStart> ( fd = TEMP_FAILURE_RETRY ( <S2SV_ModStart> O_NONBLOCK , 0666 ) |
5,827 | CWE-000 int rds_tcp_conn_path_connect ( struct rds_conn_path * cp ) { struct socket * sock = NULL ; struct sockaddr_in src , dest ; int ret ; struct rds_connection * conn = cp -> cp_conn ; struct rds_tcp_connection * tc = cp -> cp_transport_data ; if ( cp -> cp_index > 0 && cp -> cp_conn -> c_npaths < 2 ) return - EAGAIN ; mutex_lock ( & tc -> t_conn_path_lock ) ; if ( rds_conn_path_up ( cp ) ) { mutex_unlock ( & tc -> t_conn_path_lock ) ; return 0 ; } ret = sock_create_kern ( rds_conn_net ( conn ) , PF_INET , SOCK_STREAM , IPPROTO_TCP , & sock ) ; if ( ret < 0 ) goto out ; rds_tcp_tune ( sock ) ; src . sin_family = AF_INET ; src . sin_addr . s_addr = ( __force u32 ) conn -> c_laddr ; src . sin_port = ( __force u16 ) htons ( 0 ) ; ret = sock -> ops -> bind ( sock , ( struct sockaddr * ) & src , sizeof ( src ) ) ; if ( ret ) { rdsdebug ( "bind<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>%d<S2SV_blank>at<S2SV_blank>address<S2SV_blank>%pI4\\n" , ret , & conn -> c_laddr ) ; goto out ; } dest . sin_family = AF_INET ; dest . sin_addr . s_addr = ( __force u32 ) conn -> c_faddr ; dest . sin_port = ( __force u16 ) htons ( RDS_TCP_PORT ) ; rds_tcp_set_callbacks ( sock , cp ) ; ret = sock -> ops -> connect ( sock , ( struct sockaddr * ) & dest , sizeof ( dest ) , O_NONBLOCK ) ; <S2SV_StartBug> cp -> cp_outgoing = 1 ; <S2SV_EndBug> rdsdebug ( "connect<S2SV_blank>to<S2SV_blank>address<S2SV_blank>%pI4<S2SV_blank>returned<S2SV_blank>%d\\n" , & conn -> c_faddr , ret ) ; if ( ret == - EINPROGRESS ) ret = 0 ; if ( ret == 0 ) { rds_tcp_keepalive ( sock ) ; sock = NULL ; } else { rds_tcp_restore_callbacks ( sock , cp -> cp_transport_data ) ; } out : mutex_unlock ( & tc -> t_conn_path_lock ) ; if ( sock ) sock_release ( sock ) ; return ret ; } | <S2SV_ModStart> O_NONBLOCK ) ; <S2SV_ModEnd> rdsdebug ( "connect<S2SV_blank>to<S2SV_blank>address<S2SV_blank>%pI4<S2SV_blank>returned<S2SV_blank>%d\\n" |
5,828 | CWE-000 void bl2u_main ( void ) { NOTICE ( "BL2U:<S2SV_blank>%s\\n" , version_string ) ; NOTICE ( "BL2U:<S2SV_blank>%s\\n" , build_message ) ; # if SCP_BL2U_BASE int rc ; rc = bl2u_plat_handle_scp_bl2u ( ) ; if ( rc ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>SCP_BL2U<S2SV_blank>(%i)\\n" , rc ) ; panic ( ) ; } # endif bl2u_platform_setup ( ) ; <S2SV_StartBug> smc ( FWU_SMC_SEC_IMAGE_DONE , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ; <S2SV_EndBug> wfi ( ) ; } | <S2SV_ModStart> ( ) ; console_flush ( ) ; |
5,829 | CWE-000 int do_huge_pmd_wp_page ( struct vm_fault * vmf , pmd_t orig_pmd ) { struct vm_area_struct * vma = vmf -> vma ; struct page * page = NULL , * new_page ; struct mem_cgroup * memcg ; unsigned long haddr = vmf -> address & HPAGE_PMD_MASK ; unsigned long mmun_start ; unsigned long mmun_end ; gfp_t huge_gfp ; int ret = 0 ; vmf -> ptl = pmd_lockptr ( vma -> vm_mm , vmf -> pmd ) ; VM_BUG_ON_VMA ( ! vma -> anon_vma , vma ) ; if ( is_huge_zero_pmd ( orig_pmd ) ) goto alloc ; spin_lock ( vmf -> ptl ) ; if ( unlikely ( ! pmd_same ( * vmf -> pmd , orig_pmd ) ) ) goto out_unlock ; page = pmd_page ( orig_pmd ) ; VM_BUG_ON_PAGE ( ! PageCompound ( page ) || ! PageHead ( page ) , page ) ; if ( ! trylock_page ( page ) ) { get_page ( page ) ; spin_unlock ( vmf -> ptl ) ; lock_page ( page ) ; spin_lock ( vmf -> ptl ) ; if ( unlikely ( ! pmd_same ( * vmf -> pmd , orig_pmd ) ) ) { unlock_page ( page ) ; put_page ( page ) ; goto out_unlock ; } put_page ( page ) ; } if ( reuse_swap_page ( page , NULL ) ) { pmd_t entry ; entry = pmd_mkyoung ( orig_pmd ) ; entry = maybe_pmd_mkwrite ( pmd_mkdirty ( entry ) , vma ) ; if ( pmdp_set_access_flags ( vma , haddr , vmf -> pmd , entry , 1 ) ) update_mmu_cache_pmd ( vma , vmf -> address , vmf -> pmd ) ; ret |= VM_FAULT_WRITE ; unlock_page ( page ) ; goto out_unlock ; } unlock_page ( page ) ; get_page ( page ) ; spin_unlock ( vmf -> ptl ) ; alloc : if ( transparent_hugepage_enabled ( vma ) && ! transparent_hugepage_debug_cow ( ) ) { huge_gfp = alloc_hugepage_direct_gfpmask ( vma ) ; new_page = alloc_hugepage_vma ( huge_gfp , vma , haddr , HPAGE_PMD_ORDER ) ; } else new_page = NULL ; if ( likely ( new_page ) ) { prep_transhuge_page ( new_page ) ; } else { if ( ! page ) { split_huge_pmd ( vma , vmf -> pmd , vmf -> address ) ; ret |= VM_FAULT_FALLBACK ; } else { ret = do_huge_pmd_wp_page_fallback ( vmf , orig_pmd , page ) ; if ( ret & VM_FAULT_OOM ) { split_huge_pmd ( vma , vmf -> pmd , vmf -> address ) ; ret |= VM_FAULT_FALLBACK ; } put_page ( page ) ; } count_vm_event ( THP_FAULT_FALLBACK ) ; goto out ; } if ( unlikely ( mem_cgroup_try_charge ( new_page , vma -> vm_mm , <S2SV_StartBug> huge_gfp , & memcg , true ) ) ) { <S2SV_EndBug> put_page ( new_page ) ; split_huge_pmd ( vma , vmf -> pmd , vmf -> address ) ; if ( page ) put_page ( page ) ; ret |= VM_FAULT_FALLBACK ; count_vm_event ( THP_FAULT_FALLBACK ) ; goto out ; } count_vm_event ( THP_FAULT_ALLOC ) ; if ( ! page ) clear_huge_page ( new_page , vmf -> address , HPAGE_PMD_NR ) ; else copy_user_huge_page ( new_page , page , haddr , vma , HPAGE_PMD_NR ) ; __SetPageUptodate ( new_page ) ; mmun_start = haddr ; mmun_end = haddr + HPAGE_PMD_SIZE ; mmu_notifier_invalidate_range_start ( vma -> vm_mm , mmun_start , mmun_end ) ; spin_lock ( vmf -> ptl ) ; if ( page ) put_page ( page ) ; if ( unlikely ( ! pmd_same ( * vmf -> pmd , orig_pmd ) ) ) { spin_unlock ( vmf -> ptl ) ; mem_cgroup_cancel_charge ( new_page , memcg , true ) ; put_page ( new_page ) ; goto out_mn ; } else { pmd_t entry ; entry = mk_huge_pmd ( new_page , vma -> vm_page_prot ) ; entry = maybe_pmd_mkwrite ( pmd_mkdirty ( entry ) , vma ) ; pmdp_huge_clear_flush_notify ( vma , haddr , vmf -> pmd ) ; page_add_new_anon_rmap ( new_page , vma , haddr , true ) ; mem_cgroup_commit_charge ( new_page , memcg , false , true ) ; lru_cache_add_active_or_unevictable ( new_page , vma ) ; set_pmd_at ( vma -> vm_mm , haddr , vmf -> pmd , entry ) ; update_mmu_cache_pmd ( vma , vmf -> address , vmf -> pmd ) ; if ( ! page ) { add_mm_counter ( vma -> vm_mm , MM_ANONPAGES , HPAGE_PMD_NR ) ; } else { VM_BUG_ON_PAGE ( ! PageHead ( page ) , page ) ; page_remove_rmap ( page , true ) ; put_page ( page ) ; } ret |= VM_FAULT_WRITE ; } spin_unlock ( vmf -> ptl ) ; out_mn : mmu_notifier_invalidate_range_end ( vma -> vm_mm , mmun_start , mmun_end ) ; out : return ret ; out_unlock : spin_unlock ( vmf -> ptl ) ; return ret ; } | <S2SV_ModStart> vm_mm , huge_gfp | __GFP_NORETRY |
5,830 | CWE-000 static ssize_t write_ssl ( struct io * io , void * buf , size_t nbytes ) { <S2SV_StartBug> SSL * ssl ; <S2SV_EndBug> fd_set fds ; struct timeval timeout ; int e , fd , nfds , ret ; char tag [ 256 ] ; # define LOG_ERROR do { io -> io_error = EIO ; snprintf ( tag , sizeof ( tag ) , "SSL_write:<S2SV_blank>nbytes=%zu" , nbytes ) ; log_error_ssl ( io , ret , tag ) ; } while ( 0 ) ssl = io -> io_ssl ; <S2SV_StartBug> ret = SSL_write ( ssl , buf , nbytes ) ; <S2SV_EndBug> if ( ret <= 0 ) { <S2SV_StartBug> if ( SSL_get_error ( ssl , ret ) == SSL_ERROR_WANT_WRITE ) { <S2SV_EndBug> fd = SSL_get_fd ( ssl ) ; FD_ZERO ( & fds ) ; FD_SET ( fd , & fds ) ; timeout . tv_sec = 120 ; timeout . tv_usec = 0 ; nfds = select ( fd + 1 , NULL , & fds , NULL , & timeout ) ; switch ( nfds ) { case - 1 : e = errno ; io -> io_error = e ; log ( io -> io_vlog , LOG_ERR , "select(2)<S2SV_blank>for<S2SV_blank>SSL_ERROR_WANT_WRITE<S2SV_blank>failed:" "<S2SV_blank>errno=%d<S2SV_blank>(%s,<S2SV_blank>%s)" , e , get_error_name ( e ) , strerror ( e ) ) ; break ; case 0 : log ( io -> io_vlog , LOG_ERR , "select(2)<S2SV_blank>for<S2SV_blank>SSL_ERROR_WANT_WRITE<S2SV_blank>timeout" "ed" ) ; break ; case 1 : ret = SSL_write ( ssl , buf , nbytes ) ; if ( ret <= 0 ) LOG_ERROR ; break ; default : log ( io -> io_vlog , LOG_ERR , "select(2)<S2SV_blank>for<S2SV_blank>SSL_ERROR_WANT_WRITE<S2SV_blank>returne" "d<S2SV_blank>invalid<S2SV_blank>value,<S2SV_blank>%d" , nfds ) ; break ; } } else LOG_ERROR ; } # undef LOG_ERROR return ( ret ) ; } | <S2SV_ModStart> nbytes ) { int ret ; while ( ( <S2SV_ModEnd> ret = SSL_write <S2SV_ModStart> = SSL_write ( io -> io_ssl <S2SV_ModEnd> , buf , <S2SV_ModStart> , nbytes ) ) <= 0 ) if ( handle_error_ssl ( io , "SSL_write" <S2SV_ModEnd> , ret ) <S2SV_ModStart> ret ) == - 1 ) return ( - 1 ) ; <S2SV_ModEnd> return ( ret |
5,831 | CWE-000 static void handle_expected_type_function_call ( struct mCc_ast_function_call * call , enum mCc_ast_data_type expected , enum mCc_ast_data_type actual , int arg_nr , struct mCc_symtab_and_validation_holder * info_holder ) { char error_msg [ ERROR_MSG_BUF_SIZE ] ; snprintf ( error_msg , ERROR_MSG_BUF_SIZE , "Incompatible<S2SV_blank>types<S2SV_blank>at<S2SV_blank>argument<S2SV_blank>%d:<S2SV_blank>Expected<S2SV_blank>\'%s\'<S2SV_blank>but<S2SV_blank>have<S2SV_blank>\'%s\'" , arg_nr , mCc_ast_print_data_type ( expected ) , mCc_ast_print_data_type ( actual ) ) ; struct mCc_validation_status_result * error = mCc_validator_new_validation_result ( MCC_VALIDATION_STATUS_INVALID_PARAMETER , <S2SV_StartBug> strndup ( error_msg , strlen ( error_msg ) ) ) ; <S2SV_EndBug> append_error_to_function_call ( call , error ) ; info_holder -> error_count ++ ; } | <S2SV_ModStart> ( error_msg ) + 1 |
5,832 | CWE-000 void NET_DBIPX_ArbitrateGame ( net_vanilla_settings_t * settings , int want_nodes ) { setupdata_t setup , tmp ; setupdata_t node_data [ MAXNETNODES ] ; char buf [ 32 ] ; net_packet_t * packet ; net_addr_t * addr ; int node_num , game_id ; packet_id = SETUP_TIME ; game_id = 0 ; settings -> num_nodes = 0 ; printf ( "Looking<S2SV_blank>for<S2SV_blank>%i<S2SV_blank>nodes:\\n" , want_nodes ) ; IPXAddrToString ( local_addr , buf , sizeof ( buf ) ) ; printf ( "Local<S2SV_blank>address<S2SV_blank>%s<S2SV_blank>(1/%i)\\n" , buf , want_nodes ) ; while ( settings -> num_nodes + 1 < want_nodes || ! AllNodesReady ( node_data , settings -> num_nodes ) ) { <S2SV_StartBug> if ( ! NET_DBIPX_RecvPacket ( & addr , & packet ) ) <S2SV_EndBug> { <S2SV_StartBug> setup . game_id = game_id ; <S2SV_EndBug> setup . drone = 0 ; setup . nodes_found = settings -> num_nodes + 1 ; setup . nodes_wanted = want_nodes ; packet = MakeSetupPacket ( & setup ) ; NET_DBIPX_SendPacket ( & net_broadcast_addr , packet ) ; NET_FreePacket ( packet ) ; I_Sleep ( 1000 ) ; continue ; } if ( ReadSetupData ( packet , & tmp ) ) { node_num = FindOrAddAddr ( settings , addr , want_nodes ) ; node_data [ node_num ] = tmp ; } NET_FreePacket ( packet ) ; } <S2SV_StartBug> SetPlayerNumber ( settings , node_data ) ; <S2SV_EndBug> packet_id = 0 ; } | <S2SV_ModStart> ) ) { while ( <S2SV_ModEnd> NET_DBIPX_RecvPacket ( & <S2SV_ModStart> ) ) { <S2SV_ModEnd> if ( ReadSetupData <S2SV_ModStart> ) ; } setup . game_id = game_id ; setup . drone = 0 ; setup . nodes_found = settings -> num_nodes + 1 ; setup . nodes_wanted = want_nodes ; packet = MakeSetupPacket ( & setup ) ; NET_DBIPX_SendPacket ( & net_broadcast_addr , packet ) ; NET_FreePacket ( packet ) ; I_Sleep ( 1000 ) ; } |
5,833 | CWE-000 int main ( int argc , char * * argv ) { int optc ; char * opta ; int opti = 1 ; const char * path = CONFIG ; int rv ; char * err ; while ( nng_opts_parse ( argc , argv , opts , & optc , & opta , & opti ) == 0 ) { switch ( optc ) { case 'c' : path = opta ; break ; case 'd' : debug ++ ; break ; } } if ( ( ! worker_register_ops ( "controller" , & controller_ops ) ) || ( ! worker_register_ops ( "central" , & central_ops ) ) ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>worker<S2SV_blank>ops\\n" ) ; exit ( 1 ) ; } if ( ( rv = nng_zt_register ( ) ) != 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>ZT<S2SV_blank>transport:<S2SV_blank>%s\\n" , nng_strerror ( rv ) ) ; } <S2SV_StartBug> if ( ( cfg = load_config2 ( path , & err ) ) == NULL ) { <S2SV_EndBug> fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>config:<S2SV_blank>%s\\n" , err ) ; exit ( 1 ) ; } if ( ! apply_config ( cfg , & err ) ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>apply<S2SV_blank>config:<S2SV_blank>%s\\n" , err ) ; exit ( 1 ) ; } ; <S2SV_StartBug> load_config ( path ) ; <S2SV_EndBug> start_proxies ( cfg ) ; if ( debug ) { printf ( "Waiting<S2SV_blank>for<S2SV_blank>requests...\\n" ) ; } for ( ; ; ) { nng_msleep ( 3600000 ) ; } exit ( 0 ) ; } | <S2SV_ModStart> ( cfg = load_config <S2SV_ModEnd> ( path , <S2SV_ModStart> ; } ; <S2SV_ModEnd> start_proxies ( cfg |
5,834 | CWE-000 static void rmcb_handler ( struct sigcontext * scp , const struct RealModeCallStructure * rmreg , int is_32 , void * arg ) { switch ( RM_LO ( ax ) ) { case 0 : { unsigned int offs = E_RMREG ( edi ) ; unsigned int size = E_RMREG ( ecx ) ; unsigned int dos_ptr = SEGOFF2LINEAR ( RMREG ( ds ) , RMLWORD ( dx ) ) ; D_printf ( "MSDOS:<S2SV_blank>read<S2SV_blank>%x<S2SV_blank>%x\\n" , offs , size ) ; if ( offs + size <= io_buffer_size ) <S2SV_StartBug> memcpy_dos2dos ( io_buffer + offs , dos_ptr , size ) ; <S2SV_EndBug> else error ( "MSDOS:<S2SV_blank>bad<S2SV_blank>read<S2SV_blank>(%x<S2SV_blank>%x<S2SV_blank>%x)\\n" , offs , size , io_buffer_size ) ; break ; } case 1 : { unsigned int offs = E_RMREG ( edi ) ; unsigned int size = E_RMREG ( ecx ) ; unsigned int dos_ptr = SEGOFF2LINEAR ( RMREG ( ds ) , RMLWORD ( dx ) ) ; D_printf ( "MSDOS:<S2SV_blank>write<S2SV_blank>%x<S2SV_blank>%x\\n" , offs , size ) ; if ( offs + size <= io_buffer_size ) <S2SV_StartBug> memcpy_dos2dos ( dos_ptr , io_buffer + offs , size ) ; <S2SV_EndBug> else error ( "MSDOS:<S2SV_blank>bad<S2SV_blank>write<S2SV_blank>(%x<S2SV_blank>%x<S2SV_blank>%x)\\n" , offs , size , io_buffer_size ) ; break ; } case 2 : io_error = 1 ; io_error_code = RMLWORD ( cx ) ; D_printf ( "MSDOS:<S2SV_blank>set<S2SV_blank>I/O<S2SV_blank>error<S2SV_blank>%x\\n" , io_error_code ) ; break ; default : error ( "MSDOS:<S2SV_blank>unknown<S2SV_blank>rmcb<S2SV_blank>0x%x\\n" , RM_LO ( ax ) ) ; break ; } } | <S2SV_ModStart> <= io_buffer_size ) memcpy_2unix <S2SV_ModEnd> ( io_buffer + <S2SV_ModStart> <= io_buffer_size ) memcpy_2dos <S2SV_ModEnd> ( dos_ptr , |
5,835 | CWE-000 int module_finalize ( const Elf_Ehdr * hdr , const Elf_Shdr * sechdrs , struct module * me ) { const Elf_Shdr * s , * se ; const char * secstrs = ( void * ) hdr + sechdrs [ hdr -> e_shstrndx ] . sh_offset ; for ( s = sechdrs , se = sechdrs + hdr -> e_shnum ; s < se ; s ++ ) { <S2SV_StartBug> if ( strcmp ( ".altinstructions" , secstrs + s -> sh_name ) == 0 ) { <S2SV_EndBug> apply_alternatives ( ( void * ) s -> sh_addr , s -> sh_size ) ; <S2SV_StartBug> } <S2SV_EndBug> # ifdef CONFIG_ARM64_MODULE_PLTS if ( IS_ENABLED ( CONFIG_DYNAMIC_FTRACE ) && ! strcmp ( ".text.ftrace_trampoline" , secstrs + s -> sh_name ) ) me -> arch . ftrace_trampoline = ( void * ) s -> sh_addr ; # endif } return 0 ; } | <S2SV_ModStart> == 0 ) apply_alternatives_module <S2SV_ModEnd> ( ( void <S2SV_ModStart> sh_size ) ; <S2SV_ModEnd> # ifdef CONFIG_ARM64_MODULE_PLTS |
5,836 | CWE-000 static struct spdk_nvmf_fc_buffer_desc * ocs_alloc_nvme_buffers ( int size , int num_entries ) { int i ; void * virt ; uint64_t phys ; struct spdk_nvmf_fc_buffer_desc * buffers = NULL , * buffer ; buffers = calloc ( num_entries , sizeof ( struct spdk_nvmf_fc_buffer_desc ) ) ; if ( ! buffers ) { goto error ; } virt = spdk_dma_zmalloc ( ( size * num_entries ) , 4096 , & phys ) ; if ( ! virt ) { goto error ; } for ( i = 0 ; i < num_entries ; i ++ ) { buffer = buffers + i ; buffer -> len = size ; buffer -> virt = ( uint8_t * ) virt + ( i * size ) ; buffer -> phys = phys + ( i * size ) ; } return buffers ; error : if ( buffers ) { <S2SV_StartBug> spdk_free ( buffers ) ; <S2SV_EndBug> } return NULL ; } | <S2SV_ModStart> buffers ) { free <S2SV_ModEnd> ( buffers ) |
5,837 | CWE-000 int move_cursor_left ( t_tracker * tr , char * input ) { <S2SV_StartBug> int lim ; <S2SV_EndBug> int i ; lim = tr -> line == 0 ? tr -> msg_size : 0 ; if ( tr -> col > lim ) { ft_putstr_fd ( tgetstr ( "le" , 0 ) , 1 ) ; tr -> col -= 1 ; if ( tr -> pos > 0 ) tr -> pos -= 1 ; } <S2SV_StartBug> else if ( tr -> col == 0 && tr -> line > 0 ) <S2SV_EndBug> { tr -> line -= 1 ; tr -> pos -= 1 ; tr -> col = find_eol ( input , tr -> line ) ; if ( tr -> line == 0 ) tr -> col += tr -> msg_size ; ft_putstr_fd ( tgetstr ( "up" , 0 ) , 1 ) ; i = - 1 ; while ( ++ i < tr -> col ) ft_putstr_fd ( tgetstr ( "nd" , 0 ) , 1 ) ; } return ( 1 ) ; } | <S2SV_ModStart> { int lim <S2SV_ModEnd> ; lim = <S2SV_ModStart> ; } else go_prev_line ( tr , input ) ; <S2SV_ModEnd> return ( 1 |
5,838 | CWE-000 static void _init_rtp ( ) { init_rtp ( 9002 , "192.168.4.1" , 9004 , 0 ) ; rtp_set_callback ( ( RTP_CALLBACK ) rtp_callback ) ; <S2SV_StartBug> init_status ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> rtp_callback ) ; init_rtcp ( 9003 , "192.168.4.1" , 9005 , 0 ) ; rtcp_set_callback ( ( RTCP_CALLBACK ) rtcp_callback ) ; |
5,839 | CWE-000 static int hns_roce_v2_modify_qp ( struct ib_qp * ibqp , const struct ib_qp_attr * attr , int attr_mask , enum ib_qp_state cur_state , enum ib_qp_state new_state ) { struct hns_roce_dev * hr_dev = to_hr_dev ( ibqp -> device ) ; struct hns_roce_qp * hr_qp = to_hr_qp ( ibqp ) ; struct hns_roce_v2_qp_context * context ; struct hns_roce_v2_qp_context * qpc_mask ; struct device * dev = hr_dev -> dev ; int ret = - EINVAL ; context = kzalloc ( 2 * sizeof ( * context ) , GFP_KERNEL ) ; if ( ! context ) return - ENOMEM ; qpc_mask = context + 1 ; memset ( qpc_mask , 0xff , sizeof ( * qpc_mask ) ) ; if ( cur_state == IB_QPS_RESET && new_state == IB_QPS_INIT ) { modify_qp_reset_to_init ( ibqp , attr , attr_mask , context , qpc_mask ) ; } else if ( cur_state == IB_QPS_INIT && new_state == IB_QPS_INIT ) { modify_qp_init_to_init ( ibqp , attr , attr_mask , context , qpc_mask ) ; } else if ( cur_state == IB_QPS_INIT && new_state == IB_QPS_RTR ) { ret = modify_qp_init_to_rtr ( ibqp , attr , attr_mask , context , qpc_mask ) ; if ( ret ) goto out ; } else if ( cur_state == IB_QPS_RTR && new_state == IB_QPS_RTS ) { ret = modify_qp_rtr_to_rts ( ibqp , attr , attr_mask , context , qpc_mask ) ; if ( ret ) goto out ; } else if ( ( cur_state == IB_QPS_RTS && new_state == IB_QPS_RTS ) || ( cur_state == IB_QPS_SQE && new_state == IB_QPS_RTS ) || ( cur_state == IB_QPS_RTS && new_state == IB_QPS_SQD ) || ( cur_state == IB_QPS_SQD && new_state == IB_QPS_SQD ) || ( cur_state == IB_QPS_SQD && new_state == IB_QPS_RTS ) || ( cur_state == IB_QPS_INIT && new_state == IB_QPS_RESET ) || ( cur_state == IB_QPS_RTR && new_state == IB_QPS_RESET ) || ( cur_state == IB_QPS_RTS && new_state == IB_QPS_RESET ) || ( cur_state == IB_QPS_ERR && new_state == IB_QPS_RESET ) || ( cur_state == IB_QPS_INIT && new_state == IB_QPS_ERR ) || ( cur_state == IB_QPS_RTR && new_state == IB_QPS_ERR ) || ( cur_state == IB_QPS_RTS && new_state == IB_QPS_ERR ) || ( cur_state == IB_QPS_SQD && new_state == IB_QPS_ERR ) || <S2SV_StartBug> ( cur_state == IB_QPS_SQE && new_state == IB_QPS_ERR ) ) { <S2SV_EndBug> ; } else { dev_err ( dev , "Illegal<S2SV_blank>state<S2SV_blank>for<S2SV_blank>QP!\\n" ) ; goto out ; } if ( attr_mask & ( IB_QP_ACCESS_FLAGS | IB_QP_MAX_DEST_RD_ATOMIC ) ) set_access_flags ( hr_qp , context , qpc_mask , attr , attr_mask ) ; roce_set_field ( context -> byte_60_qpst_mapid , V2_QPC_BYTE_60_QP_ST_M , V2_QPC_BYTE_60_QP_ST_S , new_state ) ; roce_set_field ( qpc_mask -> byte_60_qpst_mapid , V2_QPC_BYTE_60_QP_ST_M , V2_QPC_BYTE_60_QP_ST_S , 0 ) ; ret = hns_roce_v2_qp_modify ( hr_dev , & hr_qp -> mtt , cur_state , new_state , context , hr_qp ) ; if ( ret ) { dev_err ( dev , "hns_roce_qp_modify<S2SV_blank>failed(%d)\\n" , ret ) ; goto out ; } hr_qp -> state = new_state ; if ( attr_mask & IB_QP_ACCESS_FLAGS ) hr_qp -> atomic_rd_en = attr -> qp_access_flags ; if ( attr_mask & IB_QP_MAX_DEST_RD_ATOMIC ) hr_qp -> resp_depth = attr -> max_dest_rd_atomic ; if ( attr_mask & IB_QP_PORT ) { hr_qp -> port = attr -> port_num - 1 ; hr_qp -> phy_port = hr_dev -> iboe . phy_port [ hr_qp -> port ] ; } if ( new_state == IB_QPS_RESET && ! ibqp -> uobject ) { hns_roce_v2_cq_clean ( to_hr_cq ( ibqp -> recv_cq ) , hr_qp -> qpn , ibqp -> srq ? to_hr_srq ( ibqp -> srq ) : NULL ) ; if ( ibqp -> send_cq != ibqp -> recv_cq ) hns_roce_v2_cq_clean ( to_hr_cq ( ibqp -> send_cq ) , hr_qp -> qpn , NULL ) ; hr_qp -> rq . head = 0 ; hr_qp -> rq . tail = 0 ; hr_qp -> sq . head = 0 ; hr_qp -> sq . tail = 0 ; hr_qp -> sq_next_wqe = 0 ; hr_qp -> next_sge = 0 ; if ( hr_qp -> rq . wqe_cnt ) * hr_qp -> rdb . db_record = 0 ; } out : kfree ( context ) ; return ret ; } | <S2SV_ModStart> cur_state == IB_QPS_SQE && new_state == IB_QPS_ERR ) || ( cur_state == IB_QPS_ERR |
5,840 | CWE-000 void machine_step ( struct machine_s * m ) { uint8_t ins = m -> memory [ m -> ip ++ ] ; uint8_t ponet = PAR_NAME ; uint64_t ponev = 0 ; uint8_t ptwot = PAR_NAME ; uint64_t ptwov = 0 ; switch ( ins ) { case INS_ALLO : case INS_POPE : case INS_PUSH : case INS_JUMZ : case INS_JUMP : case INS_CMPZ : case INS_MOVZ : case INS_MOVE : case INS_SUBI : case INS_ADDI : ponet = m -> memory [ m -> ip ++ ] ; if ( ponet == PAR_REGISTER ) { ponev = ( uint8_t ) m -> memory [ m -> ip ++ ] ; } else if ( ponet == PAR_ADDRESS ) { ponev = ( uint32_t ) m -> memory [ m -> ip ] ; m -> ip += 4 ; } else if ( ponet == PAR_VALUE ) { ponev = ( uint64_t ) m -> memory [ m -> ip ] ; m -> ip += 8 ; } break ; } switch ( ins ) { case INS_ALLO : case INS_MOVE : case INS_SUBI : case INS_ADDI : ptwot = m -> memory [ m -> ip ++ ] ; if ( ptwot == PAR_REGISTER ) { <S2SV_StartBug> ptwov = m -> registers [ m -> memory [ m -> ip ++ ] ] ; <S2SV_EndBug> } else if ( ptwot == PAR_ADDRESS ) { <S2SV_StartBug> ptwov = ( uint64_t ) m -> memory [ ( uint32_t ) m -> memory [ m -> ip ] ] ; <S2SV_EndBug> m -> ip += 4 ; } else if ( ptwot == PAR_VALUE ) { ptwov = ( uint64_t ) m -> memory [ m -> ip ] ; m -> ip += 8 ; } } switch ( ins ) { case INS_HALT : m -> running = false ; break ; <S2SV_StartBug> case INS_MOVE : <S2SV_EndBug> if ( ponet == PAR_REGISTER ) { m -> registers [ ( uint8_t ) ponev ] = ptwov ; } else if ( ponet == PAR_ADDRESS ) { m -> memory [ ponev ] = ptwov ; } break ; } for ( uint8_t r = 0 ; r < 20 ; r ++ ) { printf ( "Register<S2SV_blank>#%d<S2SV_blank>=<S2SV_blank>%lu\\n" , r , m -> registers [ r ] ) ; } } | <S2SV_ModStart> { ptwov = ( uint8_t ) m -> memory [ m -> ip ++ <S2SV_ModEnd> ] ; } <S2SV_ModStart> ptwov = ( <S2SV_ModEnd> uint32_t ) m <S2SV_ModStart> m -> ip <S2SV_ModEnd> ] ; m <S2SV_ModStart> ; break ; <S2SV_ModEnd> } for ( |
5,841 | CWE-000 struct dwin_gbk_input * dwin_gbk_input_create ( struct dwin_page * page , rt_uint16_t addr , void ( * cb ) ( char * str , rt_uint8_t len ) ) { struct dwin_gbk_input * input = RT_NULL ; input = ( struct dwin_gbk_input * ) rt_malloc ( sizeof ( struct dwin_gbk_input ) ) ; if ( input == RT_NULL ) { DWIN_DBG ( "Create<S2SV_blank>gbk<S2SV_blank>input<S2SV_blank>failed<S2SV_blank>memory<S2SV_blank>is<S2SV_blank>not<S2SV_blank>enough.\\n" ) ; goto failed ; } dwin_obj_init ( & ( input -> obj ) , addr , DWIN_OBJ_VARY_LENGHT , DWIN_WIDGET_TYPE_GBK_INPUT ) ; dwin_page_add_obj ( page , & ( input -> obj ) ) ; input -> input_cb = cb ; <S2SV_StartBug> return input ; <S2SV_EndBug> failed : if ( input != RT_NULL ) { rt_free ( input ) ; } return RT_NULL ; } | <S2SV_ModStart> = cb ; dwin_gbk_input_write ( input , "<S2SV_blank>" , 1 ) ; |
5,842 | CWE-000 static bool madvise_behavior_valid ( int behavior ) { switch ( behavior ) { case MADV_DOFORK : case MADV_DONTFORK : case MADV_NORMAL : case MADV_SEQUENTIAL : case MADV_RANDOM : case MADV_REMOVE : case MADV_WILLNEED : case MADV_DONTNEED : case MADV_FREE : # ifdef CONFIG_KSM case MADV_MERGEABLE : case MADV_UNMERGEABLE : # endif # ifdef CONFIG_TRANSPARENT_HUGEPAGE case MADV_HUGEPAGE : case MADV_NOHUGEPAGE : # endif case MADV_DONTDUMP : case MADV_DODUMP : <S2SV_StartBug> return true ; <S2SV_EndBug> default : return false ; } } | <S2SV_ModStart> case MADV_DODUMP : # ifdef CONFIG_VAS case MADV_VAS_PRIVATE : case MADV_VAS_SHARED : # endif |
5,843 | CWE-000 CLASS_METHOD ( ION_Listener , whenAccepted ) { <S2SV_StartBug> ion_listener * listener = get_this_instance ( ion_listener ) ; <S2SV_EndBug> if ( ! listener -> accept ) { listener -> accept = ion_promisor_sequence_new ( NULL ) ; } ion_object_addref ( listener -> accept ) ; RETURN_ION_OBJ ( listener -> accept ) ; } | <S2SV_ModStart> * listener = ION_THIS_OBJECT <S2SV_ModEnd> ( ion_listener ) |
5,844 | CWE-000 uint8_t parseFunction2Args ( uint24_t index , uint8_t outputReturnRegister , uint8_t amountOfArguments , bool orderDoesMatter ) { element_t * outputPtr = ( element_t * ) outputStack , * outputPrev , * outputPrevPrev ; uint8_t outputPrevType , outputPrevPrevType ; uint24_t outputPrevOperand , outputPrevPrevOperand ; outputPrev = & outputPtr [ getIndexOffset ( - 2 ) ] ; outputPrevPrev = & outputPtr [ getIndexOffset ( - 3 ) ] ; outputPrevType = outputPrev -> type ; outputPrevPrevType = outputPrevPrev -> type ; outputPrevOperand = outputPrev -> operand ; outputPrevPrevOperand = outputPrevPrev -> operand ; if ( amountOfArguments != 2 ) { return E_ARGUMENTS ; } if ( outputPrevPrevType == TYPE_NUMBER ) { if ( outputPrevType == TYPE_VARIABLE ) { LD_HL_NUMBER ( outputPrevPrevOperand ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IND_IX_OFF ( outputPrevOperand ) ; } else { LD_BC_IND_IX_OFF ( outputPrevOperand ) ; } } else if ( outputPrevType == TYPE_FUNCTION_RETURN ) { if ( orderDoesMatter ) { insertFunctionReturnNoPush ( outputPrevOperand , outputReturnRegister ) ; LD_HL_NUMBER ( outputPrevPrevOperand ) ; } else { insertFunctionReturnNoPush ( outputPrevOperand , OUTPUT_IN_HL ) ; LD_DE_IMM ( outputPrevPrevOperand ) ; } } else if ( outputPrevType == TYPE_CHAIN_ANS ) { if ( orderDoesMatter ) { if ( outputReturnRegister == OUTPUT_IN_DE ) { AnsToDE ( ) ; } else { PushHLDE ( ) ; POP_BC ( ) ; } LD_HL_NUMBER ( outputPrevPrevOperand ) ; } else { if ( expr . outputRegister == OUTPUT_IN_HL ) { LD_DE_IMM ( outputPrevPrevOperand ) ; } else { LD_HL_NUMBER ( outputPrevPrevOperand ) ; } } } else { return E_ICE_ERROR ; } } else if ( outputPrevPrevType == TYPE_VARIABLE ) { if ( outputPrevType == TYPE_NUMBER ) { if ( orderDoesMatter ) { LD_HL_IND_IX_OFF ( outputPrevPrevOperand ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IMM ( outputPrevOperand ) ; } else { LD_BC_IMM ( outputPrevOperand ) ; } } else { <S2SV_StartBug> LD_HL_NUMBER ( outputPrevPrevOperand ) ; <S2SV_EndBug> <S2SV_StartBug> LD_DE_IND_IX_OFF ( outputPrevOperand ) ; <S2SV_EndBug> } } else if ( outputPrevType == TYPE_VARIABLE ) { LD_HL_IND_IX_OFF ( outputPrevPrevOperand ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IND_IX_OFF ( outputPrevOperand ) ; } else { LD_BC_IND_IX_OFF ( outputPrevOperand ) ; } } else if ( outputPrevType == TYPE_FUNCTION_RETURN ) { if ( orderDoesMatter ) { insertFunctionReturnNoPush ( outputPrevOperand , outputReturnRegister ) ; LD_HL_IND_IX_OFF ( outputPrevPrevOperand ) ; } else { insertFunctionReturnNoPush ( outputPrevOperand , OUTPUT_IN_HL ) ; LD_DE_IND_IX_OFF ( outputPrevPrevOperand ) ; } } else if ( outputPrevType == TYPE_CHAIN_ANS ) { if ( orderDoesMatter ) { if ( outputReturnRegister == OUTPUT_IN_DE ) { AnsToDE ( ) ; } else { PushHLDE ( ) ; POP_BC ( ) ; } LD_HL_IND_IX_OFF ( outputPrevPrevOperand ) ; } else { if ( expr . outputRegister == OUTPUT_IN_HL ) { LD_DE_IND_IX_OFF ( outputPrevPrevOperand ) ; } else { LD_HL_IND_IX_OFF ( outputPrevPrevOperand ) ; } } } else { return E_ICE_ERROR ; } } else if ( outputPrevPrevType == TYPE_FUNCTION_RETURN ) { if ( outputPrevType == TYPE_NUMBER ) { insertFunctionReturnNoPush ( outputPrevPrevOperand , OUTPUT_IN_HL ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IMM ( outputPrevOperand ) ; } else { LD_BC_IMM ( outputPrevOperand ) ; } } else if ( outputPrevType == TYPE_VARIABLE ) { insertFunctionReturnNoPush ( outputPrevPrevOperand , OUTPUT_IN_HL ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IND_IX_OFF ( outputPrevOperand ) ; } else { LD_BC_IND_IX_OFF ( outputPrevOperand ) ; } } else if ( outputPrevType == TYPE_FUNCTION_RETURN ) { insertFunctionReturnNoPush ( outputPrevOperand , outputReturnRegister ) ; insertFunctionReturnNoPush ( outputPrevPrevOperand , OUTPUT_IN_HL ) ; } else if ( outputPrevType == TYPE_CHAIN_ANS ) { if ( orderDoesMatter ) { PushHLDE ( ) ; insertFunctionReturnNoPush ( outputPrevPrevOperand , OUTPUT_IN_HL ) ; if ( outputReturnRegister == OUTPUT_IN_DE ) { POP_DE ( ) ; } else { POP_BC ( ) ; } } else { if ( expr . outputRegister == OUTPUT_IN_HL ) { PushHLDE ( ) ; insertFunctionReturnNoPush ( outputPrevPrevOperand , OUTPUT_IN_HL ) ; POP_DE ( ) ; } else { AnsToDE ( ) ; insertFunctionReturn ( outputPrevPrevOperand , OUTPUT_IN_HL , NEED_PUSH ) ; } } } else { return E_ICE_ERROR ; } } else if ( outputPrevPrevType == TYPE_CHAIN_ANS ) { if ( outputPrevType == TYPE_NUMBER ) { AnsToHL ( ) ; if ( orderDoesMatter ) { if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IMM ( outputPrevOperand ) ; } else { LD_BC_IMM ( outputPrevOperand ) ; } } else { if ( expr . outputRegister == OUTPUT_IN_HL ) { LD_DE_IMM ( outputPrevOperand ) ; } else { LD_HL_NUMBER ( outputPrevOperand ) ; } } } else if ( outputPrevType == TYPE_VARIABLE ) { AnsToHL ( ) ; if ( orderDoesMatter ) { if ( outputReturnRegister == OUTPUT_IN_DE ) { LD_DE_IND_IX_OFF ( outputPrevOperand ) ; } else { LD_BC_IND_IX_OFF ( outputPrevOperand ) ; } } else { if ( expr . outputRegister == OUTPUT_IN_HL ) { LD_DE_IND_IX_OFF ( outputPrevOperand ) ; } else { LD_HL_IND_IX_OFF ( outputPrevOperand ) ; } } } else if ( outputPrevType == TYPE_FUNCTION_RETURN ) { if ( orderDoesMatter ) { PushHLDE ( ) ; insertFunctionReturnNoPush ( outputPrevOperand , outputReturnRegister ) ; POP_HL ( ) ; } else { MaybeAToHL ( ) ; if ( expr . outputRegister == OUTPUT_IN_HL ) { PUSH_HL ( ) ; insertFunctionReturnNoPush ( outputPrevOperand , OUTPUT_IN_HL ) ; POP_DE ( ) ; } else { insertFunctionReturn ( outputPrevOperand , OUTPUT_IN_HL , NEED_PUSH ) ; } } } else { return E_ICE_ERROR ; } } else if ( outputPrevPrevType == TYPE_CHAIN_PUSH ) { if ( outputPrevType != TYPE_CHAIN_ANS ) { return E_ICE_ERROR ; } if ( orderDoesMatter ) { if ( outputReturnRegister == OUTPUT_IN_DE ) { AnsToDE ( ) ; } else { PushHLDE ( ) ; POP_BC ( ) ; } POP_HL ( ) ; } else { MaybeAToHL ( ) ; if ( expr . outputRegister == OUTPUT_IN_HL ) { POP_DE ( ) ; } else { POP_HL ( ) ; } } } else { return E_SYNTAX ; } return VALID ; } | <S2SV_ModStart> { LD_HL_NUMBER ( outputPrevOperand <S2SV_ModEnd> ) ; LD_DE_IND_IX_OFF <S2SV_ModStart> ; LD_DE_IND_IX_OFF ( outputPrevPrevOperand <S2SV_ModEnd> ) ; } |
5,845 | CWE-000 void InitTrees ( void ) { g_printf ( "InitTrees\\n" ) ; # ifdef HOST_ARCH_X86 if ( ! CONFIG_CPUSIM ) TNodePool = calloc ( NODES_IN_POOL , sizeof ( TNode ) ) ; # endif <S2SV_StartBug> avltr_reinit ( ) ; <S2SV_EndBug> # ifdef HOST_ARCH_X86 if ( ! CONFIG_CPUSIM && debug_level ( 'e' ) > 1 ) { e_printf ( "Root<S2SV_blank>tree<S2SV_blank>node<S2SV_blank>at<S2SV_blank>%p\\n" , & CollectTree . root ) ; e_printf ( "TNode<S2SV_blank>pool<S2SV_blank>at<S2SV_blank>%p\\n" , TNodePool ) ; } # endif NodesParsed = NodesExecd = 0 ; CleanFreq = 8 ; cstx = xCS1 = 0 ; CreationIndex = 0 ; # ifdef PROFILE if ( debug_level ( 'e' ) ) { MaxDepth = MaxNodes = MaxNodeSize = 0 ; TotalNodesParsed = TotalNodesExecd = 0 ; NodesFound = NodesFastFound = NodesNotFound = 0 ; TreeCleanups = 0 ; } # endif } | <S2SV_ModStart> ; # endif avltr_init <S2SV_ModEnd> ( ) ; |
5,846 | CWE-000 long getVoltage ( voltage_sources_t selVoltage ) { float x ; float adcValue = 0.0 ; float normalizedVoltage = 0 ; long returnValue = 0 ; int MUX0_VALUE = selVoltage & 0x01 ; int MUX1_VALUE = ( selVoltage >> 1 ) & 0x01 ; mgos_gpio_write ( GPIO_MUX0 , MUX0_VALUE ) ; mgos_gpio_write ( GPIO_MUX1 , MUX1_VALUE ) ; mgos_usleep ( 1000 ) ; adcValue = ( float ) mgos_adc_read ( 0 ) ; switch ( selVoltage ) { case eBATT_VOLTAGE : case ePS_VOLTAGE : case eOUT_VOLTAGE : x = adcValue / 1023.0 ; x = x * 1220000.0 / 220000.0 ; normalizedVoltage = x * 12.0 / 2.0 ; printf ( "Normalized<S2SV_blank>Voltage<S2SV_blank>at<S2SV_blank>Divider<S2SV_blank>%f\\n\\r" , normalizedVoltage ) ; returnValue = ( long ) ( normalizedVoltage * 100.0 ) ; break ; case eOUT_CURRENT : <S2SV_StartBug> out_cur_readings [ ocr_idx ] = ( adcValue - 461.0 ) * 1 / ( 0.008 * 1024.0 ) ; <S2SV_EndBug> printf ( "ADC<S2SV_blank>Value:<S2SV_blank>%f,<S2SV_blank>Current:<S2SV_blank>%f\\r\\n" , adcValue , out_cur_readings [ ocr_idx ] ) ; ocr_idx = ( ( ocr_idx + 1 ) % 20 ) ; float sum = 0.0 ; for ( int i = 0 ; i < 20 ; i ++ ) { sum += out_cur_readings [ i ] ; } normalizedVoltage = sum / 20.0 ; normalizedVoltage = normalizedVoltage * 1000 ; returnValue = ( long ) normalizedVoltage ; break ; } printf ( "Return<S2SV_blank>Value<S2SV_blank>:<S2SV_blank>%li\\n\\r" , returnValue ) ; return returnValue ; } | <S2SV_ModStart> ( adcValue - 462.0 <S2SV_ModEnd> ) * 1 <S2SV_ModStart> * 1024.0 ) ; if ( out_cur_readings [ ocr_idx ] < 0 ) out_cur_readings [ ocr_idx ] = 0 |
5,847 | CWE-000 static struct io_plan * release_peer ( struct io_conn * conn , struct daemon * daemon , const u8 * msg ) { struct pubkey id ; struct peer * peer ; if ( ! fromwire_gossipctl_release_peer ( msg , NULL , & id ) ) master_badmsg ( WIRE_GOSSIPCTL_RELEASE_PEER , msg ) ; peer = find_peer ( daemon , & id ) ; <S2SV_StartBug> if ( ! peer || ! peer -> local ) { <S2SV_EndBug> <S2SV_StartBug> status_trace ( "release_peer:<S2SV_blank>peer<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>%s" , <S2SV_EndBug> type_to_string ( trc , struct pubkey , & id ) , <S2SV_StartBug> peer ? "local" : "found" ) ; <S2SV_EndBug> msg = towire_gossipctl_release_peer_replyfail ( msg ) ; daemon_conn_send ( & daemon -> master , take ( msg ) ) ; } else { <S2SV_StartBug> msg = towire_gossipctl_release_peer_reply ( msg , <S2SV_EndBug> & peer -> pcs . cs , peer -> gfeatures , peer -> lfeatures ) ; <S2SV_StartBug> send_peer_with_fds ( peer , take ( msg ) ) ; <S2SV_EndBug> io_close_taken_fd ( peer -> conn ) ; } return daemon_conn_read_next ( conn , & daemon -> master ) ; } | <S2SV_ModStart> peer -> local || peer -> send_to_master <S2SV_ModStart> { status_trace ( "release_peer:<S2SV_blank>peer<S2SV_blank>%s<S2SV_blank>%s" <S2SV_ModEnd> , type_to_string ( <S2SV_ModStart> id ) , ! peer ? "not<S2SV_blank>found" : ! peer -> send_to_master ? "already<S2SV_blank>releasing" : "not<S2SV_blank>local" <S2SV_ModEnd> ) ; msg <S2SV_ModStart> = towire_gossipctl_release_peer_reply ( peer <S2SV_ModEnd> , & peer <S2SV_ModStart> lfeatures ) ; peer -> send_to_master = msg ; msg_wake ( & peer -> peer_out <S2SV_ModEnd> ) ; } |
5,848 | CWE-000 uint8_t FACT_INTERNAL_UpdateSound ( FACTSoundInstance * sound , uint32_t elapsed ) { uint8_t i , j ; uint32_t waveState ; FACTEventInstance * evtInst ; FAudioFilterParameters filterParams ; uint8_t finished = 1 ; float fadeVolume ; if ( sound -> fadeType == 1 ) { if ( ( elapsed - sound -> fadeStart ) >= sound -> fadeTarget ) { fadeVolume = 1.0f ; sound -> fadeStart = 0 ; sound -> fadeTarget = 0 ; sound -> fadeType = 0 ; } else { fadeVolume = ( ( float ) ( elapsed - sound -> fadeStart ) / ( float ) sound -> fadeTarget ) ; } } else if ( sound -> fadeType == 2 ) { if ( ( elapsed - sound -> fadeStart ) >= sound -> fadeTarget ) { return 1 ; } fadeVolume = 1.0f - ( ( float ) ( elapsed - sound -> fadeStart ) / ( float ) sound -> fadeTarget ) ; } else { fadeVolume = 1.0f ; } elapsed -= sound -> parentCue -> start - sound -> parentCue -> elapsed ; <S2SV_StartBug> if ( sound -> sound == NULL ) <S2SV_EndBug> { return 0 ; } FACT_INTERNAL_UpdateRPCs ( sound -> parentCue , sound -> sound -> rpcCodeCount , sound -> sound -> rpcCodes , & sound -> rpcData ) ; for ( i = 0 ; i < sound -> sound -> trackCount ; i += 1 ) { FACT_INTERNAL_UpdateRPCs ( sound -> parentCue , sound -> sound -> tracks [ i ] . rpcCodeCount , sound -> sound -> tracks [ i ] . rpcCodes , & sound -> tracks [ i ] . rpcData ) ; } for ( i = 0 ; i < sound -> sound -> trackCount ; i += 1 ) { for ( j = 0 ; j < sound -> sound -> tracks [ i ] . eventCount ; j += 1 ) { evtInst = & sound -> tracks [ i ] . events [ j ] ; if ( ! evtInst -> finished ) { finished = 0 ; if ( elapsed > evtInst -> timestamp ) { FACT_INTERNAL_ActivateEvent ( sound , & sound -> sound -> tracks [ i ] , & sound -> tracks [ i ] , & sound -> sound -> tracks [ i ] . events [ j ] , evtInst , elapsed ) ; } } } if ( sound -> tracks [ i ] . activeWave . wave == NULL ) { continue ; } finished = 0 ; FACTWave_GetState ( sound -> tracks [ i ] . activeWave . wave , & waveState ) ; if ( waveState & FACT_STATE_STOPPED ) { FACTWave_Destroy ( sound -> tracks [ i ] . activeWave . wave ) ; FAudio_memcpy ( & sound -> tracks [ i ] . activeWave , & sound -> tracks [ i ] . upcomingWave , sizeof ( sound -> tracks [ i ] . activeWave ) ) ; sound -> tracks [ i ] . upcomingWave . wave = NULL ; if ( sound -> tracks [ i ] . activeWave . wave == NULL ) { continue ; } FACTWave_Play ( sound -> tracks [ i ] . activeWave . wave ) ; } FACTWave_SetVolume ( sound -> tracks [ i ] . activeWave . wave , FACT_INTERNAL_CalculateAmplitudeRatio ( sound -> tracks [ i ] . activeWave . baseVolume + sound -> rpcData . rpcVolume + sound -> tracks [ i ] . rpcData . rpcVolume ) * sound -> parentCue -> parentBank -> parentEngine -> categories [ sound -> sound -> category ] . currentVolume * fadeVolume ) ; FACTWave_SetPitch ( sound -> tracks [ i ] . activeWave . wave , ( int16_t ) ( sound -> tracks [ i ] . activeWave . basePitch + sound -> rpcData . rpcPitch + sound -> tracks [ i ] . rpcData . rpcPitch ) ) ; if ( sound -> sound -> tracks [ i ] . filter != 0xFF ) { filterParams . Type = ( FAudioFilterType ) sound -> sound -> tracks [ i ] . filter ; filterParams . Frequency = ( sound -> tracks [ i ] . activeWave . baseFrequency * sound -> rpcData . rpcFilterFreq * sound -> tracks [ i ] . rpcData . rpcFilterFreq ) ; filterParams . OneOverQ = 1.0f / ( sound -> tracks [ i ] . activeWave . baseQFactor + sound -> rpcData . rpcFilterQFactor + sound -> tracks [ i ] . rpcData . rpcFilterQFactor ) ; FAudioVoice_SetFilterParameters ( sound -> tracks [ i ] . activeWave . wave -> voice , & filterParams , 0 ) ; } } return finished ; } | <S2SV_ModStart> -> elapsed ; <S2SV_ModEnd> FACT_INTERNAL_UpdateRPCs ( sound |
5,849 | CWE-000 void multigrid_data_destroy ( multigrid_data_t * mg_data ) { <S2SV_StartBug> multigrid_profiler_basic_destroy ( mg_data -> profiler ) ; <S2SV_EndBug> multigrid_logger_residual_destroy ( mg_data -> logger ) ; multigrid_element_data_updater_destroy ( mg_data -> elem_data_updater , mg_data -> num_of_levels ) ; multigrid_destroy_smoother ( mg_data ) ; multigrid_destroy_bottom_solver ( mg_data ) ; P4EST_FREE ( mg_data ) ; } | <S2SV_ModStart> mg_data ) { if ( mg_data -> profiler != NULL ) { <S2SV_ModStart> profiler ) ; } |
5,850 | CWE-000 bool manage_archive ( t_gatherer func_ptr , const char * filename ) { <S2SV_StartBug> const t_loop_archive loop_archive [ 2 ] = <S2SV_EndBug> { & loop_archive_unsorted , & loop_archive_sorted } ; t_archive_header * header ; t_archive_symtab * symtab_arr ; uint32_t i ; <S2SV_StartBug> bool no_error ; <S2SV_EndBug> ft_printf ( "Archive<S2SV_blank>:<S2SV_blank>%s\\n" , filename ) ; if ( ! ( header = safe ( 0 , sizeof ( * header ) ) ) ) return ( errors ( ERR_FILE , "missing<S2SV_blank>archive<S2SV_blank>header" ) ) ; if ( ! ( symtab_arr = malloc ( header -> symbol_tab_size ) ) ) return ( errors ( ERR_SYS , "malloc<S2SV_blank>failed" ) ) ; <S2SV_StartBug> no_error = loop_archive [ ! ft_strncmp ( header -> long_name , "__.SYMDEF<S2SV_blank>SORTED" , sizeof ( header -> long_name ) ) ] ( header , symtab_arr ) ; <S2SV_EndBug> i = 0 ; <S2SV_StartBug> while ( no_error && i < header -> symbol_tab_size / sizeof ( t_archive_symtab ) ) <S2SV_EndBug> <S2SV_StartBug> no_error = parse_object_header ( func_ptr , symtab_arr [ i ++ ] . obj_offset , filename , ( header -> magic == ARCHIVE_CIGAM ) ) ; <S2SV_EndBug> <S2SV_StartBug> free ( symtab_arr ) ; <S2SV_EndBug> <S2SV_StartBug> return ( no_error || errors ( ERR_THROW , __func__ ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> filename ) { <S2SV_ModEnd> t_archive_header * header <S2SV_ModStart> i ; bool success <S2SV_ModEnd> ; ft_printf ( <S2SV_ModStart> ) ) ; success = loop_archive_sorted <S2SV_ModEnd> ( header , <S2SV_ModStart> ; while ( success <S2SV_ModEnd> && i < <S2SV_ModStart> t_archive_symtab ) ) { success <S2SV_ModEnd> = parse_object_header ( <S2SV_ModStart> symtab_arr [ i <S2SV_ModEnd> ] . obj_offset <S2SV_ModStart> ) ) ; i ++ ; } <S2SV_ModStart> ; return ( success <S2SV_ModEnd> || errors ( |
5,851 | CWE-000 void ADC_init ( void ) { MAP_ADC14_enableModule ( ) ; MAP_ADC14_initModule ( ADC_CLOCKSOURCE_MCLK , ADC_PREDIVIDER_4 , ADC_DIVIDER_1 , 0 ) ; MAP_GPIO_setAsPeripheralModuleFunctionInputPin ( GPIO_PORT_P5 , GPIO_PIN5 | GPIO_PIN4 , GPIO_TERTIARY_MODULE_FUNCTION ) ; MAP_ADC14_configureMultiSequenceMode ( ADC_MEM0 , ADC_MEM1 , false ) ; MAP_ADC14_configureConversionMemory ( ADC_MEM0 , ADC_VREFPOS_AVCC_VREFNEG_VSS , ADC_INPUT_A0 , false ) ; MAP_ADC14_configureConversionMemory ( ADC_MEM1 , ADC_VREFPOS_AVCC_VREFNEG_VSS , <S2SV_StartBug> ADC_INPUT_A0 , true ) ; <S2SV_EndBug> <S2SV_StartBug> MAP_ADC14_enableSampleTimer ( ADC_MANUAL_ITERATION ) ; <S2SV_EndBug> MAP_ADC14_enableInterrupt ( ADC_INT1 ) ; MAP_ADC14_enableConversion ( ) ; } | <S2SV_ModStart> , ADC_VREFPOS_AVCC_VREFNEG_VSS , ADC_INPUT_A1 <S2SV_ModEnd> , true ) <S2SV_ModStart> ; MAP_ADC14_enableSampleTimer ( ADC_AUTOMATIC_ITERATION <S2SV_ModEnd> ) ; MAP_ADC14_enableConversion |
5,852 | CWE-000 static int _bnx2fc_create ( struct net_device * netdev , enum fip_mode fip_mode , enum bnx2fc_create_link_state link_state ) { struct fcoe_ctlr_device * cdev ; struct fcoe_ctlr * ctlr ; struct bnx2fc_interface * interface ; struct bnx2fc_hba * hba ; struct net_device * phys_dev = netdev ; struct fc_lport * lport ; struct ethtool_drvinfo drvinfo ; int rc = 0 ; int vlan_id = 0 ; BNX2FC_MISC_DBG ( "Entered<S2SV_blank>bnx2fc_create\\n" ) ; if ( fip_mode != FIP_MODE_FABRIC ) { printk ( KERN_ERR "fip<S2SV_blank>mode<S2SV_blank>not<S2SV_blank>FABRIC\\n" ) ; return - EIO ; } rtnl_lock ( ) ; mutex_lock ( & bnx2fc_dev_lock ) ; if ( ! try_module_get ( THIS_MODULE ) ) { rc = - EINVAL ; goto mod_err ; } if ( is_vlan_dev ( netdev ) ) phys_dev = vlan_dev_real_dev ( netdev ) ; if ( phys_dev -> ethtool_ops && phys_dev -> ethtool_ops -> get_drvinfo ) { memset ( & drvinfo , 0 , sizeof ( drvinfo ) ) ; phys_dev -> ethtool_ops -> get_drvinfo ( phys_dev , & drvinfo ) ; if ( strncmp ( drvinfo . driver , "bnx2x" , strlen ( "bnx2x" ) ) ) { printk ( KERN_ERR PFX "Not<S2SV_blank>a<S2SV_blank>netxtreme2<S2SV_blank>device\\n" ) ; rc = - EINVAL ; goto netdev_err ; } } else { printk ( KERN_ERR PFX "unable<S2SV_blank>to<S2SV_blank>obtain<S2SV_blank>drv_info\\n" ) ; rc = - EINVAL ; goto netdev_err ; } hba = bnx2fc_hba_lookup ( phys_dev ) ; if ( ! hba ) { rc = - ENODEV ; printk ( KERN_ERR PFX "bnx2fc_create:<S2SV_blank>hba<S2SV_blank>not<S2SV_blank>found\\n" ) ; goto netdev_err ; } if ( bnx2fc_interface_lookup ( netdev ) ) { rc = - EEXIST ; goto netdev_err ; } interface = bnx2fc_interface_create ( hba , netdev , fip_mode ) ; if ( ! interface ) { printk ( KERN_ERR PFX "bnx2fc_interface_create<S2SV_blank>failed\\n" ) ; rc = - ENOMEM ; <S2SV_StartBug> goto ifput_err ; <S2SV_EndBug> } if ( is_vlan_dev ( netdev ) ) { vlan_id = vlan_dev_vlan_id ( netdev ) ; interface -> vlan_enabled = 1 ; } ctlr = bnx2fc_to_ctlr ( interface ) ; cdev = fcoe_ctlr_to_ctlr_dev ( ctlr ) ; interface -> vlan_id = vlan_id ; interface -> tm_timeout = BNX2FC_TM_TIMEOUT ; interface -> timer_work_queue = create_singlethread_workqueue ( "bnx2fc_timer_wq" ) ; if ( ! interface -> timer_work_queue ) { printk ( KERN_ERR PFX "ulp_init<S2SV_blank>could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>timer_wq\\n" ) ; rc = - EINVAL ; goto ifput_err ; } lport = bnx2fc_if_create ( interface , & cdev -> dev , 0 ) ; if ( ! lport ) { printk ( KERN_ERR PFX "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>interface<S2SV_blank>(%s)\\n" , netdev -> name ) ; rc = - EINVAL ; goto if_create_err ; } list_add_tail ( & interface -> list , & if_list ) ; lport -> boot_time = jiffies ; ctlr -> lp = lport ; if ( link_state == BNX2FC_CREATE_LINK_UP ) cdev -> enabled = FCOE_CTLR_ENABLED ; else cdev -> enabled = FCOE_CTLR_DISABLED ; if ( link_state == BNX2FC_CREATE_LINK_UP && ! bnx2fc_link_ok ( lport ) ) { fcoe_ctlr_link_up ( ctlr ) ; fc_host_port_type ( lport -> host ) = FC_PORTTYPE_NPORT ; set_bit ( ADAPTER_STATE_READY , & interface -> hba -> adapter_state ) ; } BNX2FC_HBA_DBG ( lport , "create:<S2SV_blank>START<S2SV_blank>DISC\\n" ) ; bnx2fc_start_disc ( interface ) ; if ( link_state == BNX2FC_CREATE_LINK_UP ) interface -> enabled = true ; bnx2fc_interface_put ( interface ) ; mutex_unlock ( & bnx2fc_dev_lock ) ; rtnl_unlock ( ) ; return 0 ; if_create_err : destroy_workqueue ( interface -> timer_work_queue ) ; ifput_err : bnx2fc_net_cleanup ( interface ) ; bnx2fc_interface_put ( interface ) ; goto mod_err ; netdev_err : module_put ( THIS_MODULE ) ; mod_err : mutex_unlock ( & bnx2fc_dev_lock ) ; rtnl_unlock ( ) ; return rc ; } | <S2SV_ModStart> ENOMEM ; goto netdev_err <S2SV_ModEnd> ; } if |
5,853 | CWE-000 gboolean hev_scgi_response_write_header ( HevSCGIResponse * self , GError * * error ) { HevSCGIResponsePrivate * priv = NULL ; gpointer key = NULL , value = NULL ; gboolean run = TRUE ; g_debug ( "%s:%d[%s]" , __FILE__ , __LINE__ , __FUNCTION__ ) ; g_return_val_if_fail ( HEV_IS_SCGI_RESPONSE ( self ) , FALSE ) ; priv = HEV_SCGI_RESPONSE_GET_PRIVATE ( self ) ; g_return_val_if_fail ( NULL != priv -> output_stream , FALSE ) ; g_return_val_if_fail ( HEADER_STATUS_UNWRITE == priv -> header_status , FALSE ) ; priv -> header_status = HEADER_STATUS_WRITING ; g_hash_table_iter_init ( & priv -> header_hash_table_iter , priv -> header_hash_table ) ; for ( ; run ; ) { gchar buffer [ 1024 ] ; gint i = 0 , len ; if ( g_hash_table_iter_next ( & priv -> header_hash_table_iter , & key , & value ) ) { <S2SV_StartBug> len = g_snprintf ( buffer , 1024 , "%s:<S2SV_blank>%s\\r\\n" , key , value ) ; <S2SV_EndBug> } else { len = g_snprintf ( buffer , 1024 , "\\r\\n" ) ; run = FALSE ; } do { gssize ret = g_output_stream_write ( priv -> output_stream , buffer + i , len - i , NULL , error ) ; if ( - 1 == ret ) return FALSE ; i += ret ; } while ( i < len ) ; } priv -> header_status = HEADER_STATUS_WRITED ; return TRUE ; } | <S2SV_ModStart> , "%s:<S2SV_blank>%s\\r\\n" , ( char * ) key , ( char * ) <S2SV_ModEnd> value ) ; |
5,854 | CWE-000 int nvram_init ( void ) { <S2SV_StartBug> FILE * f ; <S2SV_EndBug> PRINT_MSG ( "%s\\n" , "Initializing<S2SV_blank>NVRAM..." ) ; if ( init ) { PRINT_MSG ( "%s\\n" , "Early<S2SV_blank>termination!" ) ; return E_SUCCESS ; } init = 1 ; sem_lock ( ) ; if ( mount ( "tmpfs" , MOUNT_POINT , "tmpfs" , MS_NOEXEC | MS_NOSUID | MS_SYNCHRONOUS , "" ) == - 1 ) { sem_unlock ( ) ; PRINT_MSG ( "Unable<S2SV_blank>to<S2SV_blank>mount<S2SV_blank>tmpfs<S2SV_blank>on<S2SV_blank>mount<S2SV_blank>point<S2SV_blank>%s!\\n" , MOUNT_POINT ) ; return E_FAILURE ; } if ( ( f = fopen ( "/var/run/nvramd.pid" , "w+" ) ) == NULL ) { PRINT_MSG ( "Unable<S2SV_blank>to<S2SV_blank>touch<S2SV_blank>Ralink<S2SV_blank>PID<S2SV_blank>file:<S2SV_blank>%s!\\n" , "/var/run/nvramd.pid" ) ; PRINT_MSG ( "Error:<S2SV_blank>%d<S2SV_blank>(%s)\\n" , errno , strerror ( errno ) ) ; } else { fclose ( f ) ; } sem_unlock ( ) ; <S2SV_StartBug> return nvram_set_default ( ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> FILE * f ; int ret <S2SV_ModStart> ( ) ; ret = <S2SV_ModEnd> nvram_set_default ( ) <S2SV_ModStart> ( ) ; PRINT_MSG ( "%s\\n" , "Done<S2SV_blank>initializing<S2SV_blank>NVRAM" ) ; return ret ; |
5,855 | CWE-000 void update_index ( struct index_ent * meta ) { char * key = meta -> key ; uint64_t hashval = hashkey ( key , strlen ( key ) ) % MAX_ENTRIES ; struct index_ent * oldent = indx [ hashval ] ; if ( oldent != NULL ) { if ( strncmp ( oldent -> key , key , strlen ( key ) ) != 0 ) { struct index_ent * prev = oldent ; oldent = oldent -> next ; while ( oldent ) { if ( strncmp ( oldent -> key , key , strlen ( key ) ) == 0 ) { break ; } prev = oldent ; oldent = oldent -> next ; } if ( ! oldent ) { prev -> next = meta ; return ; } } else { indx [ hashval ] = meta ; } free_blk ( oldent -> lba , calc_numblks ( oldent -> val_len ) ) ; <S2SV_StartBug> meta -> next = oldent -> next ; <S2SV_EndBug> free ( oldent ) ; } else { printf ( "DEBUG:<S2SV_blank>inserting<S2SV_blank>key<S2SV_blank>%s<S2SV_blank>with<S2SV_blank>hash<S2SV_blank>%lu\\n" , key , hashval ) ; indx [ hashval ] = meta ; } } | <S2SV_ModStart> ) ) ; printf ( "DEBUG:<S2SV_blank>freeing<S2SV_blank>LBA<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>%lu<S2SV_blank>blocks\\n" , oldent -> lba , calc_numblks ( oldent -> val_len ) ) ; print_freelist ( ) ; |
5,856 | CWE-000 void * jtherad_loader ( void * para ) { Instance * jthread = ( Instance * ) para ; s32 ret = 0 ; Runtime runtime ; runtime_create ( & runtime ) ; localvar_init ( & runtime , 1 ) ; runtime . clazz = jthread -> mb . clazz ; runtime . threadInfo -> jthread = jthread ; runtime . threadInfo -> pthread = pthread_self ( ) ; Utf8String * methodName = utf8_create_c ( "run" ) ; Utf8String * methodType = utf8_create_c ( "()V" ) ; MethodInfo * method = NULL ; method = find_instance_methodInfo_by_name ( jthread , methodName , methodType ) ; utf8_destory ( methodName ) ; utf8_destory ( methodType ) ; # if _JVM_DEBUG > 5 jvm_printf ( "therad_loader<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s.%s%s<S2SV_blank><S2SV_blank>\\n" , utf8_cstr ( method -> _this_class -> name ) , utf8_cstr ( method -> name ) , utf8_cstr ( method -> descriptor ) ) ; # endif if ( method ) { if ( java_debug ) event_on_thread_start ( & runtime ) ; jthread_set_threadq_value ( jthread , & runtime ) ; <S2SV_StartBug> arraylist_append ( thread_list , & runtime ) ; <S2SV_EndBug> push_ref ( runtime . stack , ( __refer ) jthread ) ; ret = execute_method ( method , & runtime , method -> _this_class ) ; arraylist_remove ( thread_list , & runtime ) ; runtime . threadInfo -> thread_status = THREAD_STATUS_ZOMBIE ; if ( java_debug ) event_on_thread_death ( & runtime ) ; } jthread_set_threadq_value ( jthread , NULL ) ; runtime_destory ( & runtime ) ; garbage_derefer ( jthread , main_thread ) ; return ( void * ) ( long ) ret ; } | <S2SV_ModStart> runtime ) ; runtime . threadInfo -> thread_status = THREAD_STATUS_RUNNING ; |
5,857 | CWE-000 MODRET set_sqlcassandraconsistency ( cmd_rec * cmd ) { CassConsistency consistency ; const char * consistency_str ; config_rec * c ; CHECK_ARGS ( cmd , 1 ) ; CHECK_CONF ( cmd , CONF_ROOT | CONF_GLOBAL | CONF_VIRTUAL ) ; <S2SV_StartBug> consistency_str = cmd -> argv [ 0 ] ; <S2SV_EndBug> if ( strcasecmp ( consistency_str , "All" ) == 0 ) { consistency = CASS_CONSISTENCY_ALL ; } else if ( strcasecmp ( consistency_str , "Any" ) == 0 ) { consistency = CASS_CONSISTENCY_ANY ; } else if ( strcasecmp ( consistency_str , "EachQuorum" ) == 0 || strcasecmp ( consistency_str , "EACH_QUORUM" ) == 0 ) { consistency = CASS_CONSISTENCY_EACH_QUORUM ; } else if ( strcasecmp ( consistency_str , "LocalOne" ) == 0 || strcasecmp ( consistency_str , "LOCAL_ONE" ) == 0 ) { consistency = CASS_CONSISTENCY_LOCAL_ONE ; } else if ( strcasecmp ( consistency_str , "LocalQuorum" ) == 0 || strcasecmp ( consistency_str , "LOCAL_QUORUM" ) == 0 ) { consistency = CASS_CONSISTENCY_LOCAL_QUORUM ; } else if ( strcasecmp ( consistency_str , "One" ) == 0 || strcasecmp ( consistency_str , "1" ) == 0 ) { consistency = CASS_CONSISTENCY_ONE ; } else if ( strcasecmp ( consistency_str , "Quorum" ) == 0 ) { consistency = CASS_CONSISTENCY_QUORUM ; } else if ( strcasecmp ( consistency_str , "Three" ) == 0 || strcasecmp ( consistency_str , "3" ) == 0 ) { consistency = CASS_CONSISTENCY_THREE ; } else if ( strcasecmp ( consistency_str , "Two" ) == 0 || strcasecmp ( consistency_str , "2" ) == 0 ) { consistency = CASS_CONSISTENCY_TWO ; } else { CONF_ERROR ( cmd , pstrcat ( cmd -> tmp_pool , "unknown/supported<S2SV_blank>Cassandra<S2SV_blank>consistency:<S2SV_blank>" , consistency_str , NULL ) ) ; } c = add_config_param ( cmd -> argv [ 0 ] , 1 , NULL ) ; c -> argv [ 0 ] = palloc ( c -> pool , sizeof ( CassConsistency ) ) ; * ( ( CassConsistency * ) c -> argv [ 0 ] ) = consistency ; return PR_HANDLED ( cmd ) ; } | <S2SV_ModStart> -> argv [ 1 <S2SV_ModEnd> ] ; if |
5,858 | CWE-000 static int ath9k_htc_ampdu_action ( struct ieee80211_hw * hw , struct ieee80211_vif * vif , struct ieee80211_ampdu_params * params ) { struct ath9k_htc_priv * priv = hw -> priv ; struct ath9k_htc_sta * ista ; int ret = 0 ; struct ieee80211_sta * sta = params -> sta ; enum ieee80211_ampdu_mlme_action action = params -> action ; u16 tid = params -> tid ; mutex_lock ( & priv -> mutex ) ; ath9k_htc_ps_wakeup ( priv ) ; switch ( action ) { case IEEE80211_AMPDU_RX_START : break ; case IEEE80211_AMPDU_RX_STOP : break ; case IEEE80211_AMPDU_TX_START : ret = ath9k_htc_tx_aggr_oper ( priv , vif , sta , action , tid ) ; if ( ! ret ) ieee80211_start_tx_ba_cb_irqsafe ( vif , sta -> addr , tid ) ; break ; case IEEE80211_AMPDU_TX_STOP_CONT : case IEEE80211_AMPDU_TX_STOP_FLUSH : case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT : ath9k_htc_tx_aggr_oper ( priv , vif , sta , action , tid ) ; ieee80211_stop_tx_ba_cb_irqsafe ( vif , sta -> addr , tid ) ; break ; case IEEE80211_AMPDU_TX_OPERATIONAL : <S2SV_StartBug> ista = ( struct ath9k_htc_sta * ) sta -> drv_priv ; <S2SV_EndBug> spin_lock_bh ( & priv -> tx . tx_lock ) ; ista -> tid_state [ tid ] = AGGR_OPERATIONAL ; spin_unlock_bh ( & priv -> tx . tx_lock ) ; break ; default : ath_err ( ath9k_hw_common ( priv -> ah ) , "Unknown<S2SV_blank>AMPDU<S2SV_blank>action\\n" ) ; } ath9k_htc_ps_restore ( priv ) ; mutex_unlock ( & priv -> mutex ) ; return ret ; } | <S2SV_ModStart> case IEEE80211_AMPDU_TX_OPERATIONAL : if ( tid >= ATH9K_HTC_MAX_TID ) { ret = - EINVAL ; break ; } |
5,859 | CWE-000 int ext4_map_blocks ( handle_t * handle , struct inode * inode , struct ext4_map_blocks * map , int flags ) { struct extent_status es ; int retval ; # ifdef ES_AGGRESSIVE_TEST struct ext4_map_blocks orig_map ; memcpy ( & orig_map , map , sizeof ( * map ) ) ; # endif map -> m_flags = 0 ; ext_debug ( "ext4_map_blocks():<S2SV_blank>inode<S2SV_blank>%lu,<S2SV_blank>flag<S2SV_blank>%d,<S2SV_blank>max_blocks<S2SV_blank>%u," "logical<S2SV_blank>block<S2SV_blank>%lu\\n" , inode -> i_ino , flags , map -> m_len , ( unsigned long ) map -> m_lblk ) ; if ( ext4_es_lookup_extent ( inode , map -> m_lblk , & es ) ) { if ( ext4_es_is_written ( & es ) || ext4_es_is_unwritten ( & es ) ) { map -> m_pblk = ext4_es_pblock ( & es ) + map -> m_lblk - es . es_lblk ; map -> m_flags |= ext4_es_is_written ( & es ) ? EXT4_MAP_MAPPED : EXT4_MAP_UNWRITTEN ; retval = es . es_len - ( map -> m_lblk - es . es_lblk ) ; if ( retval > map -> m_len ) retval = map -> m_len ; map -> m_len = retval ; } else if ( ext4_es_is_delayed ( & es ) || ext4_es_is_hole ( & es ) ) { retval = 0 ; } else { BUG_ON ( 1 ) ; } # ifdef ES_AGGRESSIVE_TEST ext4_map_blocks_es_recheck ( handle , inode , map , & orig_map , flags ) ; # endif goto found ; } if ( ! ( flags & EXT4_GET_BLOCKS_NO_LOCK ) ) down_read ( ( & EXT4_I ( inode ) -> i_data_sem ) ) ; if ( ext4_test_inode_flag ( inode , EXT4_INODE_EXTENTS ) ) { retval = ext4_ext_map_blocks ( handle , inode , map , flags & EXT4_GET_BLOCKS_KEEP_SIZE ) ; } else { retval = ext4_ind_map_blocks ( handle , inode , map , flags & EXT4_GET_BLOCKS_KEEP_SIZE ) ; } if ( retval > 0 ) { int ret ; unsigned long long status ; # ifdef ES_AGGRESSIVE_TEST if ( retval != map -> m_len ) { printk ( "ES<S2SV_blank>len<S2SV_blank>assertation<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>inode:<S2SV_blank>%lu<S2SV_blank>" "retval<S2SV_blank>%d<S2SV_blank>!=<S2SV_blank>map->m_len<S2SV_blank>%d<S2SV_blank>" "in<S2SV_blank>%s<S2SV_blank>(lookup)\\n" , inode -> i_ino , retval , map -> m_len , __func__ ) ; } # endif status = map -> m_flags & EXT4_MAP_UNWRITTEN ? EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN ; if ( ! ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) && ! ( status & EXTENT_STATUS_WRITTEN ) && ext4_find_delalloc_range ( inode , map -> m_lblk , map -> m_lblk + map -> m_len - 1 ) ) status |= EXTENT_STATUS_DELAYED ; ret = ext4_es_insert_extent ( inode , map -> m_lblk , map -> m_len , map -> m_pblk , status ) ; if ( ret < 0 ) retval = ret ; } if ( ! ( flags & EXT4_GET_BLOCKS_NO_LOCK ) ) up_read ( ( & EXT4_I ( inode ) -> i_data_sem ) ) ; found : if ( retval > 0 && map -> m_flags & EXT4_MAP_MAPPED ) { int ret = check_block_validity ( inode , map ) ; if ( ret != 0 ) return ret ; } if ( ( flags & EXT4_GET_BLOCKS_CREATE ) == 0 ) return retval ; if ( retval > 0 && map -> m_flags & EXT4_MAP_MAPPED ) return retval ; map -> m_flags &= ~ EXT4_MAP_FLAGS ; down_write ( ( & EXT4_I ( inode ) -> i_data_sem ) ) ; if ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) ext4_set_inode_state ( inode , EXT4_STATE_DELALLOC_RESERVED ) ; if ( ext4_test_inode_flag ( inode , EXT4_INODE_EXTENTS ) ) { retval = ext4_ext_map_blocks ( handle , inode , map , flags ) ; } else { retval = ext4_ind_map_blocks ( handle , inode , map , flags ) ; if ( retval > 0 && map -> m_flags & EXT4_MAP_NEW ) { ext4_clear_inode_state ( inode , EXT4_STATE_EXT_MIGRATE ) ; } if ( ( retval > 0 ) && ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) ) ext4_da_update_reserve_space ( inode , retval , 1 ) ; } if ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) ext4_clear_inode_state ( inode , EXT4_STATE_DELALLOC_RESERVED ) ; if ( retval > 0 ) { int ret ; unsigned long long status ; # ifdef ES_AGGRESSIVE_TEST if ( retval != map -> m_len ) { printk ( "ES<S2SV_blank>len<S2SV_blank>assertation<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>inode:<S2SV_blank>%lu<S2SV_blank>" "retval<S2SV_blank>%d<S2SV_blank>!=<S2SV_blank>map->m_len<S2SV_blank>%d<S2SV_blank>" "in<S2SV_blank>%s<S2SV_blank>(allocation)\\n" , inode -> i_ino , retval , map -> m_len , __func__ ) ; } # endif if ( ( flags & EXT4_GET_BLOCKS_PRE_IO ) && ext4_es_lookup_extent ( inode , map -> m_lblk , & es ) ) { if ( ext4_es_is_written ( & es ) ) goto has_zeroout ; } status = map -> m_flags & EXT4_MAP_UNWRITTEN ? EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN ; if ( ! ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) && ! ( status & EXTENT_STATUS_WRITTEN ) && ext4_find_delalloc_range ( inode , map -> m_lblk , map -> m_lblk + map -> m_len - 1 ) ) status |= EXTENT_STATUS_DELAYED ; ret = ext4_es_insert_extent ( inode , map -> m_lblk , map -> m_len , map -> m_pblk , status ) ; if ( ret < 0 ) retval = ret ; } has_zeroout : up_write ( ( & EXT4_I ( inode ) -> i_data_sem ) ) ; if ( retval > 0 && map -> m_flags & EXT4_MAP_MAPPED ) { int ret = check_block_validity ( inode , map ) ; if ( ret != 0 ) return ret ; <S2SV_StartBug> } <S2SV_EndBug> return retval ; } | <S2SV_ModStart> return ret ; if ( map -> m_flags & EXT4_MAP_NEW && ! ( map -> m_flags & EXT4_MAP_UNWRITTEN ) && ! IS_NOQUOTA ( inode ) && ext4_should_order_data ( inode ) ) { ret = ext4_jbd2_file_inode ( handle , inode ) ; if ( ret ) return ret ; } } return <S2SV_ModEnd> retval ; } |
5,860 | CWE-000 static int t_tst_callFinalize ( lua_State * L ) { size_t len ; lua_pushvalue ( L , lua_upvalueindex ( 1 ) ) ; <S2SV_StartBug> t_tst_check ( L , 1 , 1 ) ; <S2SV_EndBug> len = luaL_len ( L , 1 ) ; t_tst_getMetrics ( L ) ; printf ( "---------------------------------------------------------\\n" <S2SV_StartBug> "Handled<S2SV_blank>%lu<S2SV_blank>tests<S2SV_blank>in<S2SV_blank>%.3f<S2SV_blank>seconds\\n\\n" <S2SV_EndBug> "Executed<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lld\\n" "Skipped<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lld\\n" "Expected<S2SV_blank>to<S2SV_blank>fail<S2SV_blank>:<S2SV_blank>%lld\\n" "Failed<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lld\\n" "status<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" <S2SV_StartBug> , len , lua_tointeger ( L , - 1 ) / 1000.0 <S2SV_EndBug> , len - lua_tointeger ( L , - 3 ) <S2SV_StartBug> , lua_tointeger ( L , - 3 ) <S2SV_EndBug> , lua_tointeger ( L , - 2 ) , len - lua_tointeger ( L , - 4 ) <S2SV_StartBug> , ( lua_toboolean ( L , - 5 ) ) ? "OK" : "FAIL" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> L , 1 <S2SV_ModEnd> ) ; len <S2SV_ModStart> printf ( "---------------------------------------------------------\\n" "Handled<S2SV_blank>%lu<S2SV_blank>tests<S2SV_blank>in<S2SV_blank>?????<S2SV_blank>seconds\\n\\n" <S2SV_ModEnd> "Executed<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lld\\n" "Skipped<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lld\\n" "Expected<S2SV_blank>to<S2SV_blank>fail<S2SV_blank>:<S2SV_blank>%lld\\n" <S2SV_ModStart> "status<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" , len , len - lua_tointeger ( L , - 2 ) , lua_tointeger ( L , - 2 ) <S2SV_ModStart> - 1 ) <S2SV_ModEnd> , len - <S2SV_ModStart> 3 ) , <S2SV_ModEnd> ( lua_toboolean ( <S2SV_ModStart> L , - 4 <S2SV_ModEnd> ) ) ? |
5,861 | CWE-000 static ocxl_err afu_open ( ocxl_afu * afu ) { if ( afu -> fd != - 1 ) { return OCXL_ALREADY_DONE ; } ocxl_err rc ; int fd = open ( afu -> device_path , O_RDWR | O_CLOEXEC | O_NONBLOCK ) ; if ( fd < 0 ) { if ( errno == ENOSPC ) { rc = OCXL_NO_MORE_CONTEXTS ; <S2SV_StartBug> errmsg ( afu , rc , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>AFU<S2SV_blank>device<S2SV_blank>\'%s\',<S2SV_blank>the<S2SV_blank>maximum<S2SV_blank>number<S2SV_blank>of<S2SV_blank>contexts<S2SV_blank>has<S2SV_blank>been<S2SV_blank>reached:<S2SV_blank>Error<S2SV_blank>%d:<S2SV_blank>%s" , <S2SV_EndBug> afu -> device_path , errno , strerror ( errno ) ) ; return rc ; } rc = OCXL_NO_DEV ; <S2SV_StartBug> errmsg ( afu , rc , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>AFU<S2SV_blank>device<S2SV_blank>\'%s\':<S2SV_blank>Error<S2SV_blank>%d:<S2SV_blank>%s" , afu -> device_path , errno , strerror ( errno ) ) ; <S2SV_EndBug> return rc ; } afu -> fd = fd ; rc = global_mmio_open ( afu ) ; if ( rc != OCXL_OK ) { <S2SV_StartBug> errmsg ( afu , rc , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>global<S2SV_blank>MMIO<S2SV_blank>descriptor" ) ; <S2SV_EndBug> return rc ; } fd = epoll_create1 ( EPOLL_CLOEXEC ) ; if ( fd < 0 ) { ocxl_err rc = OCXL_NO_DEV ; <S2SV_StartBug> errmsg ( afu , rc , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>epoll<S2SV_blank>descriptor.<S2SV_blank>Error<S2SV_blank>%d:<S2SV_blank>%s" , <S2SV_EndBug> errno , strerror ( errno ) ) ; return rc ; } afu -> epoll_fd = fd ; struct epoll_event ev ; ev . events = EPOLLIN ; ev . data . ptr = & afu -> fd_info ; if ( epoll_ctl ( afu -> epoll_fd , EPOLL_CTL_ADD , afu -> fd , & ev ) == - 1 ) { ocxl_err rc = OCXL_NO_DEV ; <S2SV_StartBug> errmsg ( afu , rc , "Could<S2SV_blank>not<S2SV_blank>add<S2SV_blank>device<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>epoll<S2SV_blank>fd<S2SV_blank>%d:<S2SV_blank>%d:<S2SV_blank>\'%s\'" , <S2SV_EndBug> afu -> fd , afu -> epoll_fd , errno , strerror ( errno ) ) ; return rc ; } struct ocxl_ioctl_metadata metadata ; if ( ioctl ( afu -> fd , OCXL_IOCTL_GET_METADATA , & metadata ) ) { ocxl_err rc = OCXL_NO_DEV ; <S2SV_StartBug> errmsg ( afu , rc , "OCXL_IOCTL_GET_METADATA<S2SV_blank>failed<S2SV_blank>%d:%s" , errno , strerror ( errno ) ) ; <S2SV_EndBug> return rc ; } afu -> version_major = metadata . afu_version_major ; afu -> version_minor = metadata . afu_version_minor ; afu -> per_pasid_mmio . length = metadata . pp_mmio_size ; afu -> global_mmio . length = metadata . global_mmio_size ; afu -> pasid = metadata . pasid ; <S2SV_StartBug> if ( afu -> tracing ) { <S2SV_EndBug> trace_metadata ( afu ) ; <S2SV_StartBug> } <S2SV_EndBug> return OCXL_OK ; } | <S2SV_ModStart> ; errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> ; errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> { errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> ; errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> ; errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> ; errmsg ( NULL <S2SV_ModEnd> , rc , <S2SV_ModStart> . pasid ; <S2SV_ModEnd> trace_metadata ( afu <S2SV_ModStart> afu ) ; <S2SV_ModEnd> return OCXL_OK ; |
5,862 | CWE-000 int afs_fs_store_data ( struct afs_server * server , struct afs_writeback * wb , pgoff_t first , pgoff_t last , unsigned offset , unsigned to , bool async ) { struct afs_vnode * vnode = wb -> vnode ; struct afs_call * call ; loff_t size , pos , i_size ; __be32 * bp ; _enter ( ",%x,{%x:%u},," , key_serial ( wb -> key ) , vnode -> fid . vid , vnode -> fid . vnode ) ; <S2SV_StartBug> size = to - offset ; <S2SV_EndBug> if ( first != last ) size += ( loff_t ) ( last - first ) << PAGE_SHIFT ; pos = ( loff_t ) first << PAGE_SHIFT ; pos += offset ; i_size = i_size_read ( & vnode -> vfs_inode ) ; if ( pos + size > i_size ) i_size = size + pos ; _debug ( "size<S2SV_blank>%llx,<S2SV_blank>at<S2SV_blank>%llx,<S2SV_blank>i_size<S2SV_blank>%llx" , ( unsigned long long ) size , ( unsigned long long ) pos , ( unsigned long long ) i_size ) ; if ( pos >> 32 || i_size >> 32 || size >> 32 || ( pos + size ) >> 32 ) return afs_fs_store_data64 ( server , wb , first , last , offset , to , size , pos , i_size , async ) ; call = afs_alloc_flat_call ( & afs_RXFSStoreData , ( 4 + 6 + 3 ) * 4 , ( 21 + 6 ) * 4 ) ; if ( ! call ) return - ENOMEM ; call -> wb = wb ; call -> key = wb -> key ; call -> reply = vnode ; call -> service_id = FS_SERVICE ; call -> port = htons ( AFS_FS_PORT ) ; call -> mapping = vnode -> vfs_inode . i_mapping ; call -> first = first ; call -> last = last ; call -> first_offset = offset ; call -> last_to = to ; call -> send_pages = true ; call -> store_version = vnode -> status . data_version + 1 ; bp = call -> request ; * bp ++ = htonl ( FSSTOREDATA ) ; * bp ++ = htonl ( vnode -> fid . vid ) ; * bp ++ = htonl ( vnode -> fid . vnode ) ; * bp ++ = htonl ( vnode -> fid . unique ) ; <S2SV_StartBug> * bp ++ = 0 ; <S2SV_EndBug> * bp ++ = 0 ; * bp ++ = 0 ; * bp ++ = 0 ; * bp ++ = 0 ; * bp ++ = 0 ; * bp ++ = htonl ( pos ) ; * bp ++ = htonl ( size ) ; * bp ++ = htonl ( i_size ) ; return afs_make_call ( & server -> addr , call , GFP_NOFS , async ) ; } | <S2SV_ModStart> ; size = ( loff_t ) to - ( loff_t ) <S2SV_ModEnd> offset ; if <S2SV_ModStart> bp ++ = htonl ( AFS_SET_MTIME ) ; * bp ++ = htonl ( vnode -> vfs_inode . i_mtime . tv_sec ) <S2SV_ModEnd> ; * bp |
5,863 | CWE-000 struct rxrpc_connection * rxrpc_prealloc_service_connection ( struct rxrpc_net * rxnet , gfp_t gfp ) { struct rxrpc_connection * conn = rxrpc_alloc_connection ( gfp ) ; if ( conn ) { conn -> state = RXRPC_CONN_SERVICE_PREALLOC ; <S2SV_StartBug> atomic_set ( & conn -> usage , 2 ) ; <S2SV_EndBug> write_lock ( & rxnet -> conn_lock ) ; list_add_tail ( & conn -> link , & rxnet -> service_conns ) ; list_add_tail ( & conn -> proc_link , & rxnet -> conn_proc_list ) ; write_unlock ( & rxnet -> conn_lock ) ; trace_rxrpc_conn ( conn , rxrpc_conn_new_service , atomic_read ( & conn -> usage ) , __builtin_return_address ( 0 ) ) ; } return conn ; } | <S2SV_ModStart> usage , 2 ) ; atomic_inc ( & rxnet -> nr_conns |
5,864 | CWE-000 BaseType_t xQueueGenericReset ( QueueHandle_t xQueue , BaseType_t xNewQueue ) { Queue_t * const pxQueue = ( Queue_t * ) xQueue ; configASSERT ( pxQueue ) ; if ( xNewQueue == pdTRUE ) { vPortCPUInitializeMutex ( & pxQueue -> mux ) ; } taskENTER_CRITICAL ( & pxQueue -> mux ) ; { pxQueue -> pcTail = pxQueue -> pcHead + ( pxQueue -> uxLength * pxQueue -> uxItemSize ) ; pxQueue -> uxMessagesWaiting = ( UBaseType_t ) 0U ; pxQueue -> pcWriteTo = pxQueue -> pcHead ; pxQueue -> u . pcReadFrom = pxQueue -> pcHead + ( ( pxQueue -> uxLength - ( UBaseType_t ) 1U ) * pxQueue -> uxItemSize ) ; if ( xNewQueue == pdFALSE ) { if ( listLIST_IS_EMPTY ( & ( pxQueue -> xTasksWaitingToSend ) ) == pdFALSE ) { if ( xTaskRemoveFromEventList ( & ( pxQueue -> xTasksWaitingToSend ) ) == pdTRUE ) { <S2SV_StartBug> queueYIELD_IF_USING_PREEMPTION_MUX ( & pxQueue -> mux ) ; <S2SV_EndBug> } else { mtCOVERAGE_TEST_MARKER ( ) ; } } else { mtCOVERAGE_TEST_MARKER ( ) ; } } else { vListInitialise ( & ( pxQueue -> xTasksWaitingToSend ) ) ; vListInitialise ( & ( pxQueue -> xTasksWaitingToReceive ) ) ; } } taskEXIT_CRITICAL ( & pxQueue -> mux ) ; return pdPASS ; } | <S2SV_ModStart> pdTRUE ) { queueYIELD_IF_USING_PREEMPTION ( <S2SV_ModEnd> ) ; } |
5,865 | CWE-000 static int qemuBuildShmemCommandLine ( virLogManagerPtr logManager , virSecurityManagerPtr secManager , virCommandPtr cmd , virQEMUDriverConfigPtr cfg , virDomainDefPtr def , virDomainShmemDefPtr shmem , virQEMUCapsPtr qemuCaps , bool chardevStdioLogd ) { virJSONValuePtr memProps = NULL ; virBuffer buf = VIR_BUFFER_INITIALIZER ; char * devstr = NULL ; int rc ; <S2SV_StartBug> unsigned int cdevflags = QEMU_BUILD_CHARDEV_TCP_NOWAIT ; <S2SV_EndBug> if ( chardevStdioLogd ) cdevflags |= QEMU_BUILD_CHARDEV_FILE_LOGD ; if ( shmem -> size ) { if ( shmem -> size & ( shmem -> size - 1 ) ) { virReportError ( VIR_ERR_XML_ERROR , "%s" , _ ( "shmem<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>power<S2SV_blank>of<S2SV_blank>two" ) ) ; return - 1 ; } if ( shmem -> size < 1024 * 1024 ) { virReportError ( VIR_ERR_XML_ERROR , "%s" , _ ( "shmem<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>at<S2SV_blank>least<S2SV_blank>1<S2SV_blank>MiB<S2SV_blank>(1024<S2SV_blank>KiB)" ) ) ; return - 1 ; } } if ( shmem -> info . type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ) { virReportError ( VIR_ERR_CONFIG_UNSUPPORTED , "%s" , _ ( "only<S2SV_blank>\'pci\'<S2SV_blank>addresses<S2SV_blank>are<S2SV_blank>supported<S2SV_blank>for<S2SV_blank>the<S2SV_blank>" "shared<S2SV_blank>memory<S2SV_blank>device" ) ) ; return - 1 ; } switch ( ( virDomainShmemModel ) shmem -> model ) { case VIR_DOMAIN_SHMEM_MODEL_IVSHMEM : devstr = qemuBuildShmemDevLegacyStr ( def , shmem , qemuCaps ) ; break ; case VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_PLAIN : if ( ! ( memProps = qemuBuildShmemBackendMemProps ( shmem ) ) ) return - 1 ; rc = virQEMUBuildObjectCommandlineFromJSON ( & buf , memProps ) ; virJSONValueFree ( memProps ) ; if ( rc < 0 ) return - 1 ; virCommandAddArg ( cmd , "-object" ) ; virCommandAddArgBuffer ( cmd , & buf ) ; ATTRIBUTE_FALLTHROUGH ; case VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL : devstr = qemuBuildShmemDevStr ( def , shmem , qemuCaps ) ; break ; case VIR_DOMAIN_SHMEM_MODEL_LAST : break ; } if ( ! devstr ) return - 1 ; virCommandAddArgList ( cmd , "-device" , devstr , NULL ) ; VIR_FREE ( devstr ) ; if ( shmem -> server . enabled ) { devstr = qemuBuildChrChardevStr ( logManager , secManager , cmd , cfg , def , & shmem -> server . chr , shmem -> info . alias , qemuCaps , cdevflags ) ; if ( ! devstr ) return - 1 ; virCommandAddArgList ( cmd , "-chardev" , devstr , NULL ) ; VIR_FREE ( devstr ) ; } return 0 ; } | <S2SV_ModStart> cdevflags = QEMU_BUILD_CHARDEV_TCP_NOWAIT | QEMU_BUILD_CHARDEV_UNIX_FD_PASS |
5,866 | CWE-000 void saveNetworkSettings ( char * Message ) { char firstline [ 50 ] ; extern char ip [ 16 ] ; extern char netmask [ 16 ] ; extern char gw [ 16 ] ; int out_fd , in_fd ; <S2SV_StartBug> int ret = 0 , i = 0 ; <S2SV_EndBug> int size , sizeleft = 0 ; char * ipconfigfile = 0 ; char path [ MAX_PATH ] ; sprintf ( Message , "%s" , LNG ( Saved_Failed ) ) ; sprintf ( firstline , "%s<S2SV_blank>%s<S2SV_blank>%s\\n\\r" , ip , netmask , gw ) ; if ( genFixPath ( "uLE:/IPCONFIG.DAT" , path ) >= 0 ) in_fd = genOpen ( path , O_RDONLY ) ; else in_fd = - 1 ; if ( strncmp ( path , "mc" , 2 ) ) { mcSync ( 0 , NULL , NULL ) ; mcMkDir ( 0 , 0 , "SYS-CONF" ) ; mcSync ( 0 , NULL , & ret ) ; } if ( in_fd >= 0 ) { size = genLseek ( in_fd , 0 , SEEK_END ) ; printf ( "size<S2SV_blank>of<S2SV_blank>existing<S2SV_blank>file<S2SV_blank>is<S2SV_blank>%ibytes\\n\\r" , size ) ; ipconfigfile = ( char * ) malloc ( size ) ; genLseek ( in_fd , 0 , SEEK_SET ) ; genRead ( in_fd , ipconfigfile , size ) ; for ( i = 0 ; ( ipconfigfile [ i ] != 0 && i <= size ) ; i ++ ) { } sizeleft = size - i ; genClose ( in_fd ) ; } else <S2SV_StartBug> strcpy ( path , "mc0:/SYS-CONF/IPCONFIG.DAT" ) ; <S2SV_EndBug> out_fd = genOpen ( path , O_WRONLY | O_TRUNC | O_CREAT ) ; if ( out_fd >= 0 ) { mcSync ( 0 , NULL , & ret ) ; genWrite ( out_fd , firstline , strlen ( firstline ) ) ; mcSync ( 0 , NULL , & ret ) ; if ( sizeleft > 0 ) { mcSync ( 0 , NULL , & ret ) ; genWrite ( out_fd , & ipconfigfile [ i ] , sizeleft ) ; mcSync ( 0 , NULL , & ret ) ; } sprintf ( Message , "%s<S2SV_blank>%s" , LNG ( Saved ) , path ) ; genClose ( out_fd ) ; } } | <S2SV_ModStart> i = 0 , port <S2SV_ModStart> ; } else { port = CheckMC ( ) ; if ( port < 0 ) port = 0 ; sprintf ( path , "mc%d:/SYS-CONF/IPCONFIG.DAT" , port ) ; } <S2SV_ModEnd> out_fd = genOpen |
5,867 | CWE-000 struct ALIKEC_res ALIKEC_compare_dims ( SEXP target , SEXP current , SEXP tar_obj , SEXP cur_obj , struct VALC_settings set ) { if ( ( TYPEOF ( target ) != INTSXP && target != R_NilValue ) || ( TYPEOF ( current ) != INTSXP && current != R_NilValue ) ) return ALIKEC_alike_attr ( target , current , R_DimSymbol , set ) ; R_xlen_t target_len = xlength ( target ) , target_len_cap ; target_len_cap = target_len > ( R_xlen_t ) 3 ? ( R_xlen_t ) 3 : target_len ; R_xlen_t current_len = xlength ( current ) , current_len_cap ; current_len_cap = current_len > ( R_xlen_t ) 3 ? ( R_xlen_t ) 3 : current_len ; struct ALIKEC_res res = ALIKEC_res_init ( ) ; const char * class_err_target = "" ; const char * class_err_actual = "" ; if ( target_len_cap > 1 && isVectorAtomic ( tar_obj ) ) { if ( current == R_NilValue ) { class_err_target = target_len_cap > 2 ? "array" : "matrix" ; class_err_actual = CHAR ( asChar ( ALIKEC_mode ( cur_obj ) ) ) ; } else if ( isVectorAtomic ( cur_obj ) && current_len_cap != target_len_cap ) { class_err_target = target_len_cap > 2 ? "array" : "matrix" ; class_err_actual = current_len_cap == 2 ? "matrix" : ( current_len_cap == 1 ? "vector" : "array" ) ; } else if ( ! isVectorAtomic ( cur_obj ) ) { class_err_target = CHAR ( asChar ( ALIKEC_mode ( tar_obj ) ) ) ; class_err_actual = type2char ( TYPEOF ( cur_obj ) ) ; } } else if ( current_len_cap > 1 && isVectorAtomic ( cur_obj ) ) { if ( isVectorAtomic ( tar_obj ) ) { class_err_target = CHAR ( asChar ( ALIKEC_mode ( tar_obj ) ) ) ; class_err_actual = current_len_cap == 2 ? "matrix" : "array" ; } else { class_err_target = CHAR ( asChar ( ALIKEC_mode ( tar_obj ) ) ) ; class_err_actual = CHAR ( asChar ( ALIKEC_mode ( cur_obj ) ) ) ; } } if ( class_err_target [ 0 ] ) { res . success = 0 ; res . lvl = 1 ; res . strings . target [ 0 ] = "\\"%s\\"%s%s%s" ; res . strings . target [ 1 ] = class_err_target ; res . strings . current [ 0 ] = "\\"%s\\"%s%s%s" ; res . strings . current [ 1 ] = class_err_actual ; return res ; } if ( current == R_NilValue ) { res . success = 0 ; res . strings . tar_pre = "have" ; res . strings . target [ 1 ] = "a<S2SV_blank>\\"dim\\"<S2SV_blank>attribute" ; return res ; } if ( target_len != current_len ) { res . success = 0 ; res . strings . tar_pre = "have" ; res . strings . target [ 0 ] = "%s<S2SV_blank>dimension%s%s%s" ; <S2SV_StartBug> res . strings . target [ 1 ] = class_err_target ; <S2SV_EndBug> res . strings . target [ 2 ] = CSR_len_as_chr ( target_len ) ; res . strings . target [ 2 ] = target_len == ( R_xlen_t ) 1 ? "" : "s" ; res . strings . cur_pre = "has" ; res . strings . current [ 1 ] = CSR_len_as_chr ( current_len ) ; return res ; } R_xlen_t attr_i ; int tar_dim_val ; for ( attr_i = ( R_xlen_t ) 0 ; attr_i < target_len ; attr_i ++ ) { tar_dim_val = INTEGER ( target ) [ attr_i ] ; const char * tar_dim_chr = CSR_len_as_chr ( ( R_xlen_t ) tar_dim_val ) ; char * err_dim1 , * err_dim2 ; if ( tar_dim_val && tar_dim_val != INTEGER ( current ) [ attr_i ] ) { res . success = 0 ; res . strings . tar_pre = "have" ; res . strings . cur_pre = "has" ; res . strings . current [ 1 ] = CSR_len_as_chr ( ( R_xlen_t ) ( INTEGER ( current ) [ attr_i ] ) ) ; if ( target_len == 2 ) { err_dim1 = "" ; switch ( attr_i ) { case ( R_xlen_t ) 0 : err_dim2 = tar_dim_val == 1 ? "<S2SV_blank>row" : "<S2SV_blank>rows" ; break ; case ( R_xlen_t ) 1 : err_dim2 = tar_dim_val == 1 ? "<S2SV_blank>column" : "<S2SV_blank>columns" ; break ; default : error ( "%s%s" , "Internal<S2SV_blank>Error:<S2SV_blank>inconsistent<S2SV_blank>matrix<S2SV_blank>dimensions;<S2SV_blank>contact<S2SV_blank><S2SV_blank>" , "maintainer." ) ; } res . strings . target [ 1 ] = tar_dim_chr ; res . strings . target [ 2 ] = err_dim2 ; } else { res . strings . target [ 0 ] = "size<S2SV_blank>%s<S2SV_blank>at<S2SV_blank>dimension<S2SV_blank>%s%s%s" ; res . strings . target [ 1 ] = tar_dim_chr ; res . strings . target [ 2 ] = CSR_len_as_chr ( ( R_xlen_t ) ( attr_i + 1 ) ) ; } return res ; } } return ALIKEC_alike_attr ( target , current , R_DimSymbol , set ) ; } | <S2SV_ModStart> target [ 1 <S2SV_ModEnd> ] = CSR_len_as_chr |
5,868 | CWE-000 void rt_hw_interrupt_init ( void ) { uint32_t index ; IRQ_DISABLE_BASIC = 0x000000ff ; IRQ_DISABLE1 = 0xffffffff ; IRQ_DISABLE2 = 0xffffffff ; for ( index = 0 ; index < MAX_HANDLERS ; index ++ ) { isr_table [ index ] . handler = default_isr_handler ; <S2SV_StartBug> isr_table [ index ] . param = NULL ; <S2SV_EndBug> # ifdef RT_USING_INTERRUPT_INFO rt_strncpy ( isr_table [ index ] . name , "unknown" , RT_NAME_MAX ) ; isr_table [ index ] . counter = 0 ; # endif } rt_interrupt_nest = 0 ; rt_interrupt_from_thread = 0 ; rt_interrupt_to_thread = 0 ; rt_thread_switch_interrupt_flag = 0 ; } | <S2SV_ModStart> . param = RT_NULL <S2SV_ModEnd> ; # ifdef |
5,869 | CWE-000 <S2SV_StartBug> struct Component InitializeOComponent ( enum ComponentType type , struct Register * reg , unsigned char * ddreg , unsigned char * port , unsigned char mask ) <S2SV_EndBug> { <S2SV_StartBug> struct Component comp = { type , * reg , * ddreg , * port , mask , 0x00 } ; <S2SV_EndBug> * ddreg |= mask ; * port &= ~ mask ; return comp ; } | <S2SV_ModStart> * reg , volatile uint8_t <S2SV_ModEnd> * ddreg , <S2SV_ModStart> * ddreg , volatile uint8_t <S2SV_ModEnd> * port , <S2SV_ModStart> { type , reg , ddreg , <S2SV_ModEnd> port , mask |
5,870 | CWE-000 void * cloud_data_cb_esm ( es_cloud_prov_data_s * event_data ) { THINGS_LOG_D ( TAG , THINGS_FUNC_ENTRY ) ; THINGS_LOG_D ( TAG , "g_qis_cloud_thread_running<S2SV_blank>=<S2SV_blank>%d" , g_qis_cloud_thread_running ) ; pthread_t cthread_handler ; es_cloud_event_timeout_s * cloned_data = NULL ; <S2SV_StartBug> # if 0 <S2SV_EndBug> if ( ci_cp_cas_is_there_cp_if_false ( ) == true ) { THINGS_LOG_D ( TAG , "Already<S2SV_blank>exist<S2SV_blank>data<S2SV_blank>of<S2SV_blank>Cloud<S2SV_blank>Provisioning." ) ; return NULL ; } # endif switch ( g_qis_cloud_thread_running ) { case CISESS_APDISCON : ci_cp_pend_event_data ( event_data ) ; return NULL ; case CISESS_BUSY : case CISESS_STOP_TRIGGER : case CISESS_SIGNOUT : break ; case CISESS_STOP : things_del_all_request_handle ( ) ; send_cnt_sign_up = 0 ; ci_cp_pend_event_data ( event_data ) ; g_qis_cloud_thread_running = CISESS_BUSY ; if ( ( cloned_data = clone_data_add_timeout ( event_data , NULL ) ) != NULL ) { int retp = pthread_create_rtos ( & cthread_handler , NULL , ( pthread_func_type ) ci_connection_init_loop , ( void * ) cloned_data , THINGS_STACK_CICONNETION_INIT_THREAD ) ; if ( retp != 0 ) { THINGS_LOG_E ( TAG , "Create<S2SV_blank>thread<S2SV_blank>is<S2SV_blank>failed." ) ; things_free ( cloned_data ) ; cloned_data = NULL ; g_qis_cloud_thread_running = CISESS_STOP ; es_cloud_state_set_and_notify ( ES_STATE_FAILED_TO_REGISTER_TO_CLOUD , ER_ERRCODE_SYSTEM_ERROR , NULL , NULL ) ; } } else { THINGS_LOG_E ( TAG , "clone_data_add_timeout<S2SV_blank>is<S2SV_blank>failed." ) ; } return NULL ; default : THINGS_LOG_E ( TAG , "Not<S2SV_blank>Surpport<S2SV_blank>value(%d)<S2SV_blank>of<S2SV_blank>g_qis_cloud_thread_running." , g_qis_cloud_thread_running ) ; return NULL ; } things_del_all_request_handle ( ) ; send_cnt_sign_up = 0 ; if ( cloud_retry_sign_up ( event_data , NULL ) == 0 ) { THINGS_LOG_E ( TAG , "cloud_retry_sign_up<S2SV_blank>is<S2SV_blank>failed." ) ; ci_cp_del_pended_data ( ) ; ci_cp_del_is_there_cp ( ) ; es_cloud_state_set_and_notify ( ES_STATE_FAILED_TO_REGISTER_TO_CLOUD , ER_ERRCODE_SYSTEM_ERROR , NULL , NULL ) ; esm_get_network_status ( ) ; } THINGS_LOG_D ( TAG , THINGS_FUNC_EXIT ) ; return NULL ; } | <S2SV_ModStart> = NULL ; <S2SV_ModEnd> switch ( g_qis_cloud_thread_running |
5,871 | CWE-000 <S2SV_StartBug> static int do_report ( int fd , uint64_t lba , uint32_t len , int verbose ) <S2SV_EndBug> { <S2SV_StartBug> int rc = - 4 ; <S2SV_EndBug> struct blk_zone_report * zi ; zi = xmalloc ( sizeof ( struct blk_zone_report ) + ( len * sizeof ( struct blk_zone ) ) ) ; zi -> nr_zones = len ; zi -> sector = lba ; rc = ioctl ( fd , BLKREPORTZONE , zi ) ; if ( rc != - 1 ) { if ( verbose ) printf ( _ ( "Found<S2SV_blank>%d<S2SV_blank>zones\\n" ) , zi -> nr_zones ) ; print_zones ( zi -> zones , zi -> nr_zones ) ; <S2SV_StartBug> } else { <S2SV_EndBug> warn ( _ ( "ERR:<S2SV_blank>%d<S2SV_blank>-><S2SV_blank>%s" ) , errno , strerror ( errno ) ) ; } free ( zi ) ; return rc ; } | <S2SV_ModStart> int do_report ( const <S2SV_ModStart> int fd , const <S2SV_ModStart> uint32_t len , const <S2SV_ModStart> { int rc <S2SV_ModEnd> ; struct blk_zone_report <S2SV_ModStart> ) ; } <S2SV_ModEnd> free ( zi |
5,872 | CWE-000 int solDfa_add_rule ( SolDfa * d , void * s1 , void * s2 , void * c ) { SolDfaState * ds1 = solHash_get ( solDfa_all_states ( d ) , s1 ) ; if ( ds1 == NULL ) { ds1 = solDfaState_new ( s1 ) ; if ( ds1 == NULL ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } } solDfa_register_state ( d , s1 , ds1 ) ; <S2SV_StartBug> if ( solDfaState_rules ( ds1 ) == NULL ) { <S2SV_EndBug> solDfaState_set_rules ( ds1 , solHash_new ( ) ) ; if ( solDfaState_rules ( ds1 ) == NULL ) { <S2SV_StartBug> return 2 ; <S2SV_EndBug> } <S2SV_StartBug> solHash_set_hash_func1 ( solDfaState_rules ( ds1 ) , solDfa_character_hash_func1 ( d ) ) ; <S2SV_EndBug> solHash_set_hash_func2 ( solDfaState_rules ( ds1 ) , solDfa_character_hash_func2 ( d ) ) ; solHash_set_equal_func ( solDfaState_rules ( ds1 ) , solDfa_character_match_func ( d ) ) ; } SolDfaState * ds2 = solHash_get ( solDfa_all_states ( d ) , s2 ) ; if ( ds2 == NULL ) { ds2 = solDfaState_new ( s2 ) ; if ( ds2 == NULL ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } } <S2SV_StartBug> solDfa_register_state ( d , s2 , ds2 ) ; <S2SV_EndBug> if ( solDfaState_add_rule ( ds1 , ds2 , c ) == 0 ) { return 0 ; } <S2SV_StartBug> return 3 ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return - 1 ; <S2SV_ModEnd> } solDfa_register_state ( <S2SV_ModStart> ds1 ) ; } <S2SV_ModEnd> if ( solDfaState_rules <S2SV_ModStart> NULL ) { if ( solDfa_init_dfa_state_rule ( d , ds1 ) != 0 ) { return - <S2SV_ModEnd> 2 ; } <S2SV_ModStart> 2 ; } <S2SV_ModEnd> } SolDfaState * <S2SV_ModStart> ) { return - 1 ; <S2SV_ModEnd> } solDfa_register_state ( <S2SV_ModStart> ds2 ) ; } <S2SV_ModStart> ; } return - |
5,873 | CWE-000 static void UpdateStringOfMM ( register Tcl_Obj * objPtr ) { MMRep * mmPtr ; char buffer [ TCL_DOUBLE_SPACE ] ; register int len ; mmPtr = ( MMRep * ) objPtr -> internalRep . otherValuePtr ; if ( ( mmPtr -> units != - 1 ) || ( objPtr -> bytes != NULL ) ) { Tcl_Panic ( "UpdateStringOfMM:<S2SV_blank>false<S2SV_blank>precondition" ) ; } Tcl_PrintDouble ( NULL , mmPtr -> value , buffer ) ; <S2SV_StartBug> len = strlen ( buffer ) ; <S2SV_EndBug> objPtr -> bytes = ( char * ) ckalloc ( ( unsigned ) len + 1 ) ; strcpy ( objPtr -> bytes , buffer ) ; objPtr -> length = len ; } | <S2SV_ModStart> ; len = ( int ) |
5,874 | CWE-000 void acceptTcpHandler ( aeEventLoop * el , int fd , void * privdata , int mask ) { int cport , cfd , max = MAX_ACCEPTS_PER_CALL ; char cip [ NET_IP_STR_LEN ] ; UNUSED ( el ) ; UNUSED ( mask ) ; UNUSED ( privdata ) ; <S2SV_StartBug> printf ( "acceptTcpHandler\\n" ) ; <S2SV_EndBug> while ( max -- ) { <S2SV_StartBug> cfd = mtcp_anetTcpAccept ( server . el -> mctx , server . neterr , fd , cip , sizeof ( cip ) , & cport ) ; <S2SV_EndBug> printf ( "cfd<S2SV_blank>in<S2SV_blank>tcpAccept:%d\\n" , cfd ) ; if ( cfd == ANET_ERR ) { if ( errno != EWOULDBLOCK ) serverLog ( LL_WARNING , "Accepting<S2SV_blank>client<S2SV_blank>connection:<S2SV_blank>%s" , server . neterr ) ; return ; } serverLog ( LL_VERBOSE , "Accepted<S2SV_blank>%s:%d" , cip , cport ) ; acceptCommonHandler ( cfd , 0 , cip ) ; } } | <S2SV_ModStart> privdata ) ; <S2SV_ModEnd> while ( max <S2SV_ModStart> , & cport <S2SV_ModEnd> ) ; if |
5,875 | CWE-000 static void build_setup_pgd ( void ) { const int a0 = 4 ; const int __maybe_unused a1 = 5 ; const int __maybe_unused a2 = 6 ; <S2SV_StartBug> u32 * p = tlbmiss_handler_setup_pgd_start ; <S2SV_EndBug> const int tlbmiss_handler_setup_pgd_size = tlbmiss_handler_setup_pgd_end - tlbmiss_handler_setup_pgd_start ; # ifndef CONFIG_MIPS_PGD_C0_CONTEXT long pgdc = ( long ) pgd_current ; # endif memset ( tlbmiss_handler_setup_pgd , 0 , tlbmiss_handler_setup_pgd_size * sizeof ( tlbmiss_handler_setup_pgd [ 0 ] ) ) ; memset ( labels , 0 , sizeof ( labels ) ) ; memset ( relocs , 0 , sizeof ( relocs ) ) ; pgd_reg = allocate_kscratch ( ) ; # ifdef CONFIG_MIPS_PGD_C0_CONTEXT if ( pgd_reg == - 1 ) { struct uasm_label * l = labels ; struct uasm_reloc * r = relocs ; UASM_i_SRA ( & p , a1 , a0 , 29 ) ; UASM_i_ADDIU ( & p , a1 , a1 , 4 ) ; uasm_il_bnez ( & p , & r , a1 , label_tlbl_goaround1 ) ; uasm_i_nop ( & p ) ; uasm_i_dinsm ( & p , a0 , 0 , 29 , 64 - 29 ) ; uasm_l_tlbl_goaround1 ( & l , p ) ; UASM_i_SLL ( & p , a0 , a0 , 11 ) ; uasm_i_jr ( & p , 31 ) ; UASM_i_MTC0 ( & p , a0 , C0_CONTEXT ) ; } else { uasm_i_jr ( & p , 31 ) ; if ( cpu_has_ldpte ) UASM_i_MTC0 ( & p , a0 , C0_PWBASE ) ; else UASM_i_MTC0 ( & p , a0 , c0_kscratch ( ) , pgd_reg ) ; } # else # ifdef CONFIG_SMP UASM_i_CPUID_MFC0 ( & p , a1 , SMP_CPUID_REG ) ; UASM_i_SRL_SAFE ( & p , a1 , a1 , SMP_CPUID_PTRSHIFT ) ; UASM_i_LA_mostly ( & p , a2 , pgdc ) ; UASM_i_ADDU ( & p , a2 , a2 , a1 ) ; UASM_i_SW ( & p , a0 , uasm_rel_lo ( pgdc ) , a2 ) ; # else UASM_i_LA_mostly ( & p , a2 , pgdc ) ; UASM_i_SW ( & p , a0 , uasm_rel_lo ( pgdc ) , a2 ) ; # endif uasm_i_jr ( & p , 31 ) ; if ( pgd_reg != - 1 ) UASM_i_MTC0 ( & p , a0 , c0_kscratch ( ) , pgd_reg ) ; else uasm_i_nop ( & p ) ; # endif <S2SV_StartBug> if ( p >= tlbmiss_handler_setup_pgd_end ) <S2SV_EndBug> panic ( "tlbmiss_handler_setup_pgd<S2SV_blank>space<S2SV_blank>exceeded" ) ; uasm_resolve_relocs ( relocs , labels ) ; pr_debug ( "Wrote<S2SV_blank>tlbmiss_handler_setup_pgd<S2SV_blank>(%u<S2SV_blank>instructions).\\n" , <S2SV_StartBug> ( unsigned int ) ( p - tlbmiss_handler_setup_pgd ) ) ; <S2SV_EndBug> dump_handler ( "tlbmiss_handler" , tlbmiss_handler_setup_pgd , <S2SV_StartBug> tlbmiss_handler_setup_pgd_size ) ; <S2SV_EndBug> } | <S2SV_ModStart> * p = ( u32 * ) msk_isa16_mode ( ( ulong ) tlbmiss_handler_setup_pgd ) ; # ifndef CONFIG_MIPS_PGD_C0_CONTEXT long pgdc = ( long ) pgd_current ; # endif memset ( p , 0 , tlbmiss_handler_setup_pgd_end - ( char * ) p <S2SV_ModEnd> ) ; memset <S2SV_ModStart> ( p >= ( u32 * ) <S2SV_ModStart> ( p - ( u32 * ) <S2SV_ModStart> , tlbmiss_handler_setup_pgd , tlbmiss_handler_setup_pgd_end <S2SV_ModEnd> ) ; } |
5,876 | CWE-000 int main ( ) { int j , k , index , n ; printf ( "enter<S2SV_blank>number<S2SV_blank>of<S2SV_blank>processes" ) ; scanf ( "%d" , & n ) ; int pno [ n ] , BT [ n ] , WT [ n ] , AT [ n ] ; float pri [ n ] ; for ( i = 0 ; i < n ; i ++ ) { pno [ i ] = i + 1 ; } for ( i = 0 ; i < n ; i ++ ) { printf ( "enter<S2SV_blank>burst<S2SV_blank>time<S2SV_blank>for<S2SV_blank>P%d<S2SV_blank>" , i + 1 ) ; scanf ( "%d" , & BT [ i ] ) ; } for ( i = 0 ; i < n ; i ++ ) { printf ( "enter<S2SV_blank>arrival<S2SV_blank>time<S2SV_blank>for<S2SV_blank>P%d<S2SV_blank>" , i + 1 ) ; scanf ( "%d" , & AT [ i ] ) ; } for ( i = 0 ; i < n ; i ++ ) { k = i ; for ( j = i + 1 ; j < n ; j ++ ) { if ( AT [ j ] < AT [ k ] ) k = j ; } swap ( & pno [ i ] , & pno [ k ] ) ; swap ( & BT [ i ] , & BT [ k ] ) ; swap ( & AT [ i ] , & AT [ k ] ) ; } <S2SV_StartBug> for ( i = 0 ; i < n ; i ++ ) <S2SV_EndBug> { printf ( "\\nP<S2SV_blank>%d<S2SV_blank>bt<S2SV_blank>%d" , pno [ i ] , BT [ i ] ) ; } T = AT [ 0 ] ; for ( i = 1 ; i < n ; i ++ ) { if ( AT [ i ] < T ) { T = AT [ i ] ; } } int n1 = n ; for ( j = 0 ; j < n ; j ++ ) { calcwt ( AT , WT , n ) ; calcpriority ( BT , WT , pri , n ) ; <S2SV_StartBug> printf ( "\\nP<S2SV_blank>%d<S2SV_blank>wt<S2SV_blank>%d<S2SV_blank>pri<S2SV_blank>%f" , pno [ j ] , WT [ j ] , pri [ j ] ) ; <S2SV_EndBug> index = max ( pri , n ) ; printf ( "\\nexecuting<S2SV_blank>p%d<S2SV_blank>........" , pno [ index ] ) ; T = T + BT [ index ] ; remoove ( pno , index , n ) ; remoove ( BT , index , n ) ; remoove ( WT , index , n ) ; remoovep ( pri , index , n ) ; n = n - 1 ; } return 0 ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> T = AT <S2SV_ModStart> n ) ; <S2SV_ModEnd> index = max |
5,877 | CWE-000 <S2SV_StartBug> void set_lapack_b ( DATA_LAPACK * lapack_data , const omsi_algebraic_system_t * linearSystem ) { <S2SV_EndBug> <S2SV_StartBug> omsi_int i ; <S2SV_EndBug> omsi_real * zero_array ; zero_array = global_allocateMemory ( lapack_data -> n , sizeof ( omsi_real ) ) ; <S2SV_StartBug> for ( i = 0 ; i < lapack_data -> n ; i ++ ) { <S2SV_EndBug> zero_array = 0 ; } <S2SV_StartBug> linearSystem -> residual_function ( linearSystem -> functions , zero_array , lapack_data -> b ) ; <S2SV_EndBug> for ( i = 0 ; i < lapack_data -> ldb ; i ++ ) { lapack_data -> b [ i ] = - lapack_data -> b [ i ] ; } <S2SV_StartBug> global_freeMemory ( zero_array ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> omsi_status <S2SV_ModEnd> set_lapack_b ( DATA_LAPACK <S2SV_ModStart> linearSystem ) { omsi_unsigned_int i ; omsi_unsigned_int j <S2SV_ModEnd> = 0 ; <S2SV_ModStart> = 0 ; if ( ! omsu_set_omsi_value ( linearSystem -> functions -> function_vars , * ( linearSystem -> iteration_vars_indices ) , linearSystem -> n_iteration_vars , 0 ) ) { return omsi_error <S2SV_ModEnd> ; } linearSystem <S2SV_ModStart> } linearSystem -> functions -> evaluate <S2SV_ModEnd> ( linearSystem -> <S2SV_ModStart> linearSystem -> functions <S2SV_ModEnd> , lapack_data -> <S2SV_ModStart> ] ; } return omsi_ok <S2SV_ModEnd> ; } <S2SV_null> |
5,878 | CWE-000 int pcm_init ( void ) { # ifdef USE_DL_PLUGINS int ca = - 1 , cs = - 1 ; # endif pcm_printf ( "PCM:<S2SV_blank>init\\n" ) ; pthread_mutex_init ( & pcm . strm_mtx , NULL ) ; pthread_mutex_init ( & pcm . time_mtx , NULL ) ; # ifdef USE_DL_PLUGINS <S2SV_StartBug> # define LOAD_PLUGIN_C ( x , c ) dl_handles [ num_dl_handles ] = load_plugin ( x ) ; if ( dl_handles [ num_dl_handles ] ) { num_dl_handles ++ ; c } <S2SV_EndBug> # define LOAD_PLUGIN ( x ) LOAD_PLUGIN_C ( x , ) # ifdef USE_LIBAO LOAD_PLUGIN_C ( "libao" , { ca = pcm_get_cfg ( "ao" ) ; } ) ; # endif # ifdef SDL_SUPPORT if ( ca == - 1 || config . sdl ) LOAD_PLUGIN_C ( "sdl" , { cs = pcm_get_cfg ( "sdl" ) ; } ) ; # endif if ( ! ca && ! cs ) { assert ( config . sdl ) ; config . sdl_sound = 1 ; } else if ( ca == PCM_CF_ENABLED ) config . libao_sound = 1 ; else if ( cs == PCM_CF_ENABLED ) config . sdl_sound = 1 ; else if ( cs != ca ) { if ( ! ca ) config . libao_sound = 1 ; else config . sdl_sound = 1 ; } # ifdef USE_ALSA LOAD_PLUGIN ( "alsa" ) ; # endif # ifdef LADSPA_SUPPORT LOAD_PLUGIN ( "ladspa" ) ; # endif # endif assert ( num_dl_handles <= MAX_DL_HANDLES ) ; pcm . get_volume = get_vol_dummy ; pcm . is_connected = is_connected_dummy ; pcm . checkid2 = checkid2_dummy ; if ( ! pcm_init_plugins ( pcm . efps , pcm . num_efps ) ) pcm_printf ( "no<S2SV_blank>PCM<S2SV_blank>effect<S2SV_blank>processors<S2SV_blank>initialized\\n" ) ; if ( ! pcm_init_plugins ( pcm . players , pcm . num_players ) ) pcm_printf ( "ERROR:<S2SV_blank>no<S2SV_blank>PCM<S2SV_blank>output<S2SV_blank>plugins<S2SV_blank>initialized\\n" ) ; if ( ! pcm_init_plugins ( pcm . recorders , pcm . num_recorders ) ) pcm_printf ( "ERROR:<S2SV_blank>no<S2SV_blank>PCM<S2SV_blank>input<S2SV_blank>plugins<S2SV_blank>initialized\\n" ) ; return 1 ; } | <S2SV_ModStart> , c ) do { <S2SV_ModStart> ; c } } while ( 0 ) |
5,879 | CWE-000 static int ctl_do_mode_select ( union ctl_io * io ) { struct scsi_mode_page_header * page_header ; struct ctl_page_index * page_index ; struct ctl_scsiio * ctsio ; int page_len , page_len_offset , page_len_size ; union ctl_modepage_info * modepage_info ; struct ctl_lun * lun ; int * len_left , * len_used ; int retval , i ; ctsio = & io -> scsiio ; page_index = NULL ; page_len = 0 ; lun = ( struct ctl_lun * ) ctsio -> io_hdr . ctl_private [ CTL_PRIV_LUN ] . ptr ; modepage_info = ( union ctl_modepage_info * ) ctsio -> io_hdr . ctl_private [ CTL_PRIV_MODEPAGE ] . bytes ; len_left = & modepage_info -> header . len_left ; len_used = & modepage_info -> header . len_used ; do_next_page : page_header = ( struct scsi_mode_page_header * ) ( ctsio -> kern_data_ptr + * len_used ) ; if ( * len_left == 0 ) { free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_set_success ( ctsio ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } else if ( * len_left < sizeof ( struct scsi_mode_page_header ) ) { free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_set_param_len_error ( ctsio ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } else if ( ( page_header -> page_code & SMPH_SPF ) && ( * len_left < sizeof ( struct scsi_mode_page_header_sp ) ) ) { free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_set_param_len_error ( ctsio ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } for ( i = 0 ; i < CTL_NUM_MODE_PAGES ; i ++ ) { page_index = & lun -> mode_pages . index [ i ] ; if ( lun -> be_lun -> lun_type == T_DIRECT && ( page_index -> page_flags & CTL_PAGE_FLAG_DIRECT ) == 0 ) continue ; if ( lun -> be_lun -> lun_type == T_PROCESSOR && ( page_index -> page_flags & CTL_PAGE_FLAG_PROC ) == 0 ) continue ; if ( lun -> be_lun -> lun_type == T_CDROM && ( page_index -> page_flags & CTL_PAGE_FLAG_CDROM ) == 0 ) continue ; if ( ( page_index -> page_code & SMPH_PC_MASK ) != ( page_header -> page_code & SMPH_PC_MASK ) ) continue ; if ( ( ( page_index -> page_code & SMPH_SPF ) == 0 ) && ( ( page_header -> page_code & SMPH_SPF ) == 0 ) ) { page_len = page_header -> page_length ; break ; } if ( ( page_index -> page_code & SMPH_SPF ) && ( page_header -> page_code & SMPH_SPF ) ) { struct scsi_mode_page_header_sp * sph ; sph = ( struct scsi_mode_page_header_sp * ) page_header ; if ( page_index -> subpage == sph -> subpage ) { page_len = scsi_2btoul ( sph -> page_length ) ; break ; } } } if ( ( i >= CTL_NUM_MODE_PAGES ) || ( page_index -> select_handler == NULL ) ) { ctl_set_invalid_field ( ctsio , 1 , 0 , * len_used , 0 , 0 ) ; free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } if ( page_index -> page_code & SMPH_SPF ) { page_len_offset = 2 ; page_len_size = 2 ; } else { page_len_size = 1 ; page_len_offset = 1 ; } <S2SV_StartBug> if ( ( page_len != ( page_index -> page_len - page_len_offset - <S2SV_EndBug> <S2SV_StartBug> page_len_size ) ) <S2SV_EndBug> || ( * len_left < page_index -> page_len ) ) { ctl_set_invalid_field ( ctsio , 1 , 0 , * len_used + page_len_offset , 0 , 0 ) ; free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } <S2SV_StartBug> for ( i = 0 ; i < page_index -> page_len ; i ++ ) { <S2SV_EndBug> uint8_t * user_byte , * change_mask , * current_byte ; int bad_bit ; int j ; user_byte = ( uint8_t * ) page_header + i ; change_mask = page_index -> page_data + ( page_index -> page_len * CTL_PAGE_CHANGEABLE ) + i ; current_byte = page_index -> page_data + ( page_index -> page_len * CTL_PAGE_CURRENT ) + i ; if ( ( * user_byte & ~ ( * change_mask ) ) == ( * current_byte & ~ ( * change_mask ) ) ) continue ; bad_bit = 0 ; for ( j = 7 ; j >= 0 ; j -- ) { if ( ( ( ( 1 << i ) & ~ ( * change_mask ) ) & * user_byte ) != ( ( ( 1 << i ) & ~ ( * change_mask ) ) & * current_byte ) ) { bad_bit = i ; break ; } } ctl_set_invalid_field ( ctsio , 1 , 0 , * len_used + i , 1 , bad_bit ) ; free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } * len_left -= page_index -> page_len ; * len_used += page_index -> page_len ; retval = page_index -> select_handler ( ctsio , page_index , ( uint8_t * ) page_header ) ; if ( retval != CTL_RETVAL_COMPLETE ) goto bailout_no_done ; if ( * len_left > 0 ) goto do_next_page ; ctl_set_success ( ctsio ) ; free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; bailout_no_done : return ( CTL_RETVAL_COMPLETE ) ; } | <S2SV_ModStart> } if ( page_len != <S2SV_ModEnd> page_index -> page_len <S2SV_ModStart> page_len_offset - page_len_size <S2SV_ModEnd> ) { ctl_set_invalid_field <S2SV_ModStart> ) ; } if ( * len_left < page_index -> page_len ) { free ( ctsio -> kern_data_ptr , M_CTL ) ; ctl_set_param_len_error ( ctsio ) ; ctl_done ( ( union ctl_io * ) ctsio ) ; return ( CTL_RETVAL_COMPLETE ) ; } |
5,880 | CWE-000 <S2SV_StartBug> int handle_command ( sem_t * sem , struct packet * p ) { <S2SV_EndBug> int ret = CLERR_NONE ; ifcmd ( TERMINATE , p ) { ret = callcmd ( TERMINATE , p ) ; } else { pset ( p , - 1 , "Unknown<S2SV_blank>command:<S2SV_blank>\\"%s\\"" , strdup ( p -> data ) ) ; } return ret ; } | <S2SV_ModStart> int handle_command ( <S2SV_ModEnd> struct packet * |
5,881 | CWE-000 static int snd_timer_user_params ( struct file * file , struct snd_timer_params __user * _params ) { struct snd_timer_user * tu ; struct snd_timer_params params ; struct snd_timer * t ; struct snd_timer_read * tr ; struct snd_timer_tread * ttr ; int err ; tu = file -> private_data ; if ( ! tu -> timeri ) return - EBADFD ; t = tu -> timeri -> timer ; if ( ! t ) return - EBADFD ; if ( copy_from_user ( & params , _params , sizeof ( params ) ) ) return - EFAULT ; if ( ! ( t -> hw . flags & SNDRV_TIMER_HW_SLAVE ) && params . ticks < 1 ) { err = - EINVAL ; goto _end ; } if ( params . queue_size > 0 && ( params . queue_size < 32 || params . queue_size > 1024 ) ) { err = - EINVAL ; goto _end ; } if ( params . filter & ~ ( ( 1 << SNDRV_TIMER_EVENT_RESOLUTION ) | ( 1 << SNDRV_TIMER_EVENT_TICK ) | ( 1 << SNDRV_TIMER_EVENT_START ) | ( 1 << SNDRV_TIMER_EVENT_STOP ) | ( 1 << SNDRV_TIMER_EVENT_CONTINUE ) | ( 1 << SNDRV_TIMER_EVENT_PAUSE ) | ( 1 << SNDRV_TIMER_EVENT_SUSPEND ) | ( 1 << SNDRV_TIMER_EVENT_RESUME ) | ( 1 << SNDRV_TIMER_EVENT_MSTART ) | ( 1 << SNDRV_TIMER_EVENT_MSTOP ) | ( 1 << SNDRV_TIMER_EVENT_MCONTINUE ) | ( 1 << SNDRV_TIMER_EVENT_MPAUSE ) | ( 1 << SNDRV_TIMER_EVENT_MSUSPEND ) | ( 1 << SNDRV_TIMER_EVENT_MRESUME ) ) ) { err = - EINVAL ; goto _end ; } snd_timer_stop ( tu -> timeri ) ; spin_lock_irq ( & t -> lock ) ; tu -> timeri -> flags &= ~ ( SNDRV_TIMER_IFLG_AUTO | SNDRV_TIMER_IFLG_EXCLUSIVE | SNDRV_TIMER_IFLG_EARLY_EVENT ) ; if ( params . flags & SNDRV_TIMER_PSFLG_AUTO ) tu -> timeri -> flags |= SNDRV_TIMER_IFLG_AUTO ; if ( params . flags & SNDRV_TIMER_PSFLG_EXCLUSIVE ) tu -> timeri -> flags |= SNDRV_TIMER_IFLG_EXCLUSIVE ; if ( params . flags & SNDRV_TIMER_PSFLG_EARLY_EVENT ) tu -> timeri -> flags |= SNDRV_TIMER_IFLG_EARLY_EVENT ; spin_unlock_irq ( & t -> lock ) ; if ( params . queue_size > 0 && ( unsigned int ) tu -> queue_size != params . queue_size ) { if ( tu -> tread ) { ttr = kmalloc ( params . queue_size * sizeof ( * ttr ) , GFP_KERNEL ) ; if ( ttr ) { kfree ( tu -> tqueue ) ; tu -> queue_size = params . queue_size ; tu -> tqueue = ttr ; } } else { tr = kmalloc ( params . queue_size * sizeof ( * tr ) , GFP_KERNEL ) ; if ( tr ) { kfree ( tu -> queue ) ; tu -> queue_size = params . queue_size ; tu -> queue = tr ; } } } tu -> qhead = tu -> qtail = tu -> qused = 0 ; if ( tu -> timeri -> flags & SNDRV_TIMER_IFLG_EARLY_EVENT ) { if ( tu -> tread ) { struct snd_timer_tread tread ; <S2SV_StartBug> tread . event = SNDRV_TIMER_EVENT_EARLY ; <S2SV_EndBug> tread . tstamp . tv_sec = 0 ; tread . tstamp . tv_nsec = 0 ; tread . val = 0 ; snd_timer_user_append_to_tqueue ( tu , & tread ) ; } else { struct snd_timer_read * r = & tu -> queue [ 0 ] ; r -> resolution = 0 ; r -> ticks = 0 ; tu -> qused ++ ; tu -> qtail ++ ; } } tu -> filter = params . filter ; tu -> ticks = params . ticks ; err = 0 ; _end : if ( copy_to_user ( _params , & params , sizeof ( params ) ) ) return - EFAULT ; return err ; } | <S2SV_ModStart> snd_timer_tread tread ; memset ( & tread , 0 , sizeof ( tread ) ) ; |
5,882 | CWE-000 <S2SV_StartBug> static int event_abort_on_panic_set ( const char * val , struct kernel_param * kp ) <S2SV_EndBug> { int ret ; ret = param_set_int ( val , kp ) ; if ( ret ) { pr_err ( "coresight_event:<S2SV_blank>error<S2SV_blank>setting<S2SV_blank>val<S2SV_blank>on<S2SV_blank>panic<S2SV_blank>%d\\n" , ret ) ; return ret ; } if ( event_abort_early_panic ) { unregister_trace_kernel_panic_late ( event_abort_kernel_panic , NULL ) ; ret = register_trace_kernel_panic ( event_abort_kernel_panic , NULL ) ; if ( ret ) goto err ; } else { unregister_trace_kernel_panic ( event_abort_kernel_panic , NULL ) ; ret = register_trace_kernel_panic_late ( event_abort_kernel_panic , NULL ) ; if ( ret ) goto err ; } return 0 ; err : pr_err ( "coresight_event:<S2SV_blank>error<S2SV_blank>registering<S2SV_blank>panic<S2SV_blank>event<S2SV_blank>%d\\n" , ret ) ; return ret ; } | <S2SV_ModStart> * val , const |
5,883 | CWE-000 <S2SV_StartBug> int * generateP ( list pList , int i ) { <S2SV_EndBug> int temp = pList [ i ] ; pList [ i ] = pList [ i + 1 ] ; pList [ i + 1 ] = temp ; return pList ; } | <S2SV_ModStart> * generateP ( int * <S2SV_ModEnd> pList , int |
5,884 | CWE-000 static dma_addr_t csky_dma_map_page ( struct device * dev , struct page * page , unsigned long offset , size_t size , enum dma_data_direction direction , unsigned long attrs ) { unsigned long addr ; <S2SV_StartBug> BUG_ON ( direction == DMA_NONE ) ; <S2SV_EndBug> addr = ( unsigned long ) page_address ( page ) + offset ; __dma_sync ( addr , size , direction ) ; return page_to_phys ( page ) + offset ; } | <S2SV_ModStart> long addr ; <S2SV_ModEnd> addr = ( |
5,885 | CWE-000 <S2SV_StartBug> BOOLEAN BTM_SecDeleteDevice ( BD_ADDR bd_addr ) <S2SV_EndBug> { tBTM_SEC_DEV_REC * p_dev_rec ; <S2SV_StartBug> if ( BTM_IsAclConnectionUp ( bd_addr , BT_TRANSPORT_LE ) || <S2SV_EndBug> BTM_IsAclConnectionUp ( bd_addr , BT_TRANSPORT_BR_EDR ) ) { BTM_TRACE_WARNING ( "%s<S2SV_blank>FAILED:<S2SV_blank>Cannot<S2SV_blank>Delete<S2SV_blank>when<S2SV_blank>connection<S2SV_blank>is<S2SV_blank>active\\n" , __func__ ) ; return FALSE ; } if ( ( p_dev_rec = btm_find_dev ( bd_addr ) ) != NULL ) { <S2SV_StartBug> btm_sec_free_dev ( p_dev_rec ) ; <S2SV_EndBug> BTM_DeleteStoredLinkKey ( p_dev_rec -> bd_addr , NULL ) ; } return TRUE ; } | <S2SV_ModStart> ( BD_ADDR bd_addr , tBT_TRANSPORT transport <S2SV_ModStart> ( bd_addr , transport <S2SV_ModEnd> ) ) { <S2SV_ModStart> btm_sec_free_dev ( p_dev_rec , transport |
5,886 | CWE-000 static int spu2_hash_xlate ( enum hash_alg hash_alg , enum hash_mode hash_mode , enum hash_type hash_type , enum spu_cipher_type ciph_type , enum spu2_hash_type * spu2_type , enum spu2_hash_mode * spu2_mode ) { int err ; err = spu2_hash_mode_xlate ( hash_mode , spu2_mode ) ; if ( err ) { flow_log ( "Invalid<S2SV_blank>hash<S2SV_blank>mode<S2SV_blank>%d\\n" , hash_mode ) ; return err ; } switch ( hash_alg ) { case HASH_ALG_NONE : * spu2_type = SPU2_HASH_TYPE_NONE ; break ; case HASH_ALG_MD5 : * spu2_type = SPU2_HASH_TYPE_MD5 ; break ; case HASH_ALG_SHA1 : * spu2_type = SPU2_HASH_TYPE_SHA1 ; break ; case HASH_ALG_SHA224 : * spu2_type = SPU2_HASH_TYPE_SHA224 ; break ; case HASH_ALG_SHA256 : * spu2_type = SPU2_HASH_TYPE_SHA256 ; break ; case HASH_ALG_SHA384 : * spu2_type = SPU2_HASH_TYPE_SHA384 ; break ; case HASH_ALG_SHA512 : * spu2_type = SPU2_HASH_TYPE_SHA512 ; break ; case HASH_ALG_AES : switch ( ciph_type ) { case CIPHER_TYPE_AES128 : * spu2_type = SPU2_HASH_TYPE_AES128 ; break ; case CIPHER_TYPE_AES192 : * spu2_type = SPU2_HASH_TYPE_AES192 ; break ; case CIPHER_TYPE_AES256 : * spu2_type = SPU2_HASH_TYPE_AES256 ; break ; default : err = - EINVAL ; } break ; case HASH_ALG_SHA3_224 : * spu2_type = SPU2_HASH_TYPE_SHA3_224 ; break ; case HASH_ALG_SHA3_256 : * spu2_type = SPU2_HASH_TYPE_SHA3_256 ; break ; case HASH_ALG_SHA3_384 : * spu2_type = SPU2_HASH_TYPE_SHA3_384 ; break ; case HASH_ALG_SHA3_512 : * spu2_type = SPU2_HASH_TYPE_SHA3_512 ; <S2SV_StartBug> case HASH_ALG_LAST : <S2SV_EndBug> default : err = - EINVAL ; break ; } if ( err ) flow_log ( "Invalid<S2SV_blank>hash<S2SV_blank>alg<S2SV_blank>%d<S2SV_blank>or<S2SV_blank>type<S2SV_blank>%d\\n" , hash_alg , hash_type ) ; return err ; } | <S2SV_ModStart> = SPU2_HASH_TYPE_SHA3_512 ; break ; |
5,887 | CWE-000 TreeNode * write_stmt ( void ) { TreeNode * t = newStmtNode ( WriteK ) ; match ( WRITE ) ; <S2SV_StartBug> if ( t != NULL ) t -> child [ 0 ] = exp ( ) ; <S2SV_EndBug> return t ; } | <S2SV_ModStart> 0 ] = exp_r <S2SV_ModEnd> ( ) ; |
5,888 | CWE-000 int menu ( void ) { int res ; printf ( "\\nMenu:\\n\\t1<S2SV_blank>-<S2SV_blank>Gerir<S2SV_blank>Areas\\n\\t2<S2SV_blank>-<S2SV_blank>Gerir<S2SV_blank>Animais\\n\\t0<S2SV_blank>-<S2SV_blank>Sair\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 0 ) { return 0 ; } else if ( res == 1 ) { printf ( "Areas:\\n\\t1<S2SV_blank>-<S2SV_blank>Adicionar<S2SV_blank>Area\\n\\t2<S2SV_blank>-<S2SV_blank>Remover<S2SV_blank>Area\\n\\t3<S2SV_blank>-<S2SV_blank>Listagem<S2SV_blank>todas<S2SV_blank>as<S2SV_blank>areas\\n\\t4<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) return 11 ; if ( res == 2 ) return 12 ; if ( res == 3 ) return 13 ; if ( res == 4 ) return - 1 ; } else if ( res == 2 ) { <S2SV_StartBug> printf ( "Animais:\\n\\t1<S2SV_blank>-<S2SV_blank>Adicionar<S2SV_blank>Animal\\n\\t2<S2SV_blank>-<S2SV_blank>Remover<S2SV_blank>Animal\\n\\t3<S2SV_blank>-<S2SV_blank>Listagem<S2SV_blank>Animais\\n\\t4<S2SV_blank>-<S2SV_blank>Info\\n\\t5<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; <S2SV_EndBug> printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) { printf ( "\\n\\t1<S2SV_blank>-<S2SV_blank>Adicionar<S2SV_blank>via<S2SV_blank>ficheiro\\n\\t2<S2SV_blank>-<S2SV_blank>Adicionar<S2SV_blank>via<S2SV_blank>terminal\\n\\t3<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) return 211 ; if ( res == 2 ) return 212 ; if ( res == 3 ) return - 1 ; } ; <S2SV_StartBug> if ( res == 2 ) return 22 ; <S2SV_EndBug> if ( res == 3 ) { printf ( "Listagem<S2SV_blank>de:\\n\\t1<S2SV_blank>-<S2SV_blank>Todos<S2SV_blank>os<S2SV_blank>animais\\n\\t2<S2SV_blank>-<S2SV_blank>Animais<S2SV_blank>na<S2SV_blank>Area<S2SV_blank>X\\n\\t3<S2SV_blank>-<S2SV_blank>Animais<S2SV_blank>da<S2SV_blank>especie<S2SV_blank>X\\n\\t4<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) return 231 ; if ( res == 2 ) return 232 ; if ( res == 3 ) return 233 ; if ( res == 4 ) return - 1 ; } if ( res == 4 ) { printf ( "Info:\\n\\t1<S2SV_blank>-<S2SV_blank>Animal<S2SV_blank>por<S2SV_blank>ID\\n\\t2<S2SV_blank>-<S2SV_blank>Animais<S2SV_blank>por<S2SV_blank>nome\\n\\t3<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) return 241 ; if ( res == 2 ) return 242 ; if ( res == 3 ) return - 1 ; } <S2SV_StartBug> if ( res == 5 ) return - 1 ; <S2SV_EndBug> } } | <S2SV_ModStart> { printf ( "Animais:\\n\\t1<S2SV_blank>-<S2SV_blank>Adicionar<S2SV_blank>Animal\\n\\t2<S2SV_blank>-<S2SV_blank>Remover<S2SV_blank>Animal\\n\\t3<S2SV_blank>-<S2SV_blank>Listagem<S2SV_blank>Animais\\n\\t4<S2SV_blank>-<S2SV_blank>Info\\n\\t5<S2SV_blank>-<S2SV_blank>Transferir<S2SV_blank>animal\\n\\t6<S2SV_blank>-<S2SV_blank>Cancelar\\n" <S2SV_ModEnd> ) ; printf <S2SV_ModStart> == 2 ) { printf ( "Remover<S2SV_blank>animal<S2SV_blank>por:\\n\\t1<S2SV_blank>-<S2SV_blank>ID\\n\\t2<S2SV_blank>-<S2SV_blank>Nome\\n\\t3<S2SV_blank>-<S2SV_blank>Cancelar\\n" ) ; printf ( "Escolha:<S2SV_blank>" ) ; fflush ( stdin ) ; scanf ( "%d" , & res ) ; if ( res == 1 ) return 221 ; if ( res == 2 ) return 222 ; if ( res == 3 ) return - 1 ; } <S2SV_ModEnd> if ( res <S2SV_ModStart> 5 ) return 25 ; if ( res == 6 ) return |
5,889 | CWE-000 void rtl92c_dm_bt_coexist ( struct ieee80211_hw * hw ) { <S2SV_StartBug> struct rtl_pci_priv * rtlpcipriv = rtl_pcipriv ( hw ) ; <S2SV_EndBug> bool wifi_connect_change ; bool bt_state_change ; bool rssi_state_change ; <S2SV_StartBug> if ( ( rtlpcipriv -> bt_coexist . bt_coexistence ) && <S2SV_EndBug> <S2SV_StartBug> ( rtlpcipriv -> bt_coexist . bt_coexist_type == BT_CSR_BC4 ) ) { <S2SV_EndBug> wifi_connect_change = rtl92c_bt_wifi_connect_change ( hw ) ; bt_state_change = rtl92c_bt_state_change ( hw ) ; rssi_state_change = rtl92c_bt_rssi_state_change ( hw ) ; if ( wifi_connect_change || bt_state_change || rssi_state_change ) rtl92c_check_bt_change ( hw ) ; } } | <S2SV_ModStart> ) { struct rtl_priv * rtlpriv = rtl_priv <S2SV_ModEnd> ( hw ) <S2SV_ModStart> if ( ( rtlpriv -> btcoexist <S2SV_ModEnd> . bt_coexistence ) <S2SV_ModStart> ) && ( rtlpriv -> btcoexist <S2SV_ModEnd> . bt_coexist_type == |
5,890 | CWE-000 void hal_sleep ( void ) { LPC_SC -> PCON = 0x0 ; SCB -> SCR &= ~ SCB_SCR_SLEEPDEEP_Msk ; __WFI ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; __NOP ( ) ; |
5,891 | CWE-000 static void insert_to_list ( int fd , struct pbuf * p ) { pbuf_send_list_t * tmp_pbuf_list1 ; pbuf_send_list_t * tmp_pbuf_list2 ; if ( pbuf_send_list_num > ( TCP_SND_QUEUELEN * MEMP_NUM_TCP_PCB + MEMP_NUM_TCP_PCB ) ) { return ; } if ( ! check_pbuf_to_insert ( p ) ) { return ; } LWIP_DEBUGF ( PBUF_CACHE_DEBUG , ( "Insert<S2SV_blank>%p,%d\\n" , p , pbuf_send_list_num ) ) ; if ( pbuf_list_head == NULL ) { tmp_pbuf_list1 = ( pbuf_send_list_t * ) malloc ( sizeof ( pbuf_send_list_t ) ) ; if ( ! tmp_pbuf_list1 ) { <S2SV_StartBug> LWIP_DEBUGF ( PBUF_CACHE_DEBUG , ( "no<S2SV_blank>menory<S2SV_blank>malloc<S2SV_blank>pbuf<S2SV_blank>list<S2SV_blank>error\\n" ) ) ; <S2SV_EndBug> return ; } pbuf_ref ( p ) ; tmp_pbuf_list1 -> aiofd = fd ; tmp_pbuf_list1 -> p = p ; tmp_pbuf_list1 -> next = NULL ; tmp_pbuf_list1 -> err_cnt = 0 ; pbuf_list_head = tmp_pbuf_list1 ; pbuf_send_list_num ++ ; return ; } tmp_pbuf_list1 = pbuf_list_head ; tmp_pbuf_list2 = tmp_pbuf_list1 ; while ( tmp_pbuf_list1 != NULL ) { if ( tmp_pbuf_list1 -> p == p ) { tmp_pbuf_list1 -> err_cnt ++ ; return ; } tmp_pbuf_list2 = tmp_pbuf_list1 ; tmp_pbuf_list1 = tmp_pbuf_list2 -> next ; } tmp_pbuf_list1 = ( pbuf_send_list_t * ) malloc ( sizeof ( pbuf_send_list_t ) ) ; if ( ! tmp_pbuf_list1 ) { <S2SV_StartBug> LWIP_DEBUGF ( PBUF_CACHE_DEBUG , ( "no<S2SV_blank>menory<S2SV_blank>malloc<S2SV_blank>pbuf<S2SV_blank>list<S2SV_blank>error\\n" ) ) ; <S2SV_EndBug> return ; } pbuf_ref ( p ) ; tmp_pbuf_list1 -> aiofd = fd ; tmp_pbuf_list1 -> p = p ; tmp_pbuf_list1 -> next = NULL ; tmp_pbuf_list1 -> err_cnt = 0 ; tmp_pbuf_list2 -> next = tmp_pbuf_list1 ; pbuf_send_list_num ++ ; } | <S2SV_ModStart> PBUF_CACHE_DEBUG , ( "no<S2SV_blank>memory<S2SV_blank>malloc<S2SV_blank>pbuf<S2SV_blank>list<S2SV_blank>error\\n" <S2SV_ModEnd> ) ) ; <S2SV_ModStart> PBUF_CACHE_DEBUG , ( "no<S2SV_blank>memory<S2SV_blank>malloc<S2SV_blank>pbuf<S2SV_blank>list<S2SV_blank>error\\n" <S2SV_ModEnd> ) ) ; |
5,892 | CWE-000 static int nexthop_active ( afi_t afi , struct route_entry * re , struct nexthop * nexthop , int set , struct route_node * top ) { struct prefix p ; struct route_table * table ; struct route_node * rn ; struct route_entry * match = NULL ; int resolved ; struct nexthop * newhop ; struct interface * ifp ; rib_dest_t * dest ; if ( ( nexthop -> type == NEXTHOP_TYPE_IPV4 ) || nexthop -> type == NEXTHOP_TYPE_IPV6 ) nexthop -> ifindex = 0 ; if ( set ) { UNSET_FLAG ( nexthop -> flags , NEXTHOP_FLAG_RECURSIVE ) ; zebra_deregister_rnh_static_nexthops ( nexthop -> vrf_id , nexthop -> resolved , top ) ; nexthops_free ( nexthop -> resolved ) ; nexthop -> resolved = NULL ; re -> nexthop_mtu = 0 ; } if ( CHECK_FLAG ( nexthop -> flags , NEXTHOP_FLAG_FILTERED ) ) return 0 ; if ( CHECK_FLAG ( nexthop -> flags , NEXTHOP_FLAG_ONLINK ) ) { ifp = if_lookup_by_index ( nexthop -> ifindex , nexthop -> vrf_id ) ; if ( ifp && connected_is_unnumbered ( ifp ) ) { if ( if_is_operative ( ifp ) ) return 1 ; else return 0 ; } else return 0 ; } memset ( & p , 0 , sizeof ( struct prefix ) ) ; switch ( afi ) { case AFI_IP : p . family = AF_INET ; p . prefixlen = IPV4_MAX_PREFIXLEN ; p . u . prefix4 = nexthop -> gate . ipv4 ; break ; case AFI_IP6 : p . family = AF_INET6 ; p . prefixlen = IPV6_MAX_PREFIXLEN ; p . u . prefix6 = nexthop -> gate . ipv6 ; break ; default : assert ( afi != AFI_IP && afi != AFI_IP6 ) ; break ; } table = zebra_vrf_table ( afi , SAFI_UNICAST , nexthop -> vrf_id ) ; if ( ! table ) return 0 ; rn = route_node_match ( table , ( struct prefix * ) & p ) ; while ( rn ) { route_unlock_node ( rn ) ; if ( top && rn == top ) if ( ( ( afi == AFI_IP ) && ( rn -> p . prefixlen != 32 ) ) || ( ( afi == AFI_IP6 ) && ( rn -> p . prefixlen != 128 ) ) ) return 0 ; if ( is_default_prefix ( & rn -> p ) <S2SV_StartBug> && ! nh_resolve_via_default ( p . family ) ) <S2SV_EndBug> return 0 ; dest = rib_dest_from_rnode ( rn ) ; if ( dest && dest -> selected_fib && ! CHECK_FLAG ( dest -> selected_fib -> status , ROUTE_ENTRY_REMOVED ) && dest -> selected_fib -> type != ZEBRA_ROUTE_TABLE ) match = dest -> selected_fib ; if ( ! match ) { do { rn = rn -> parent ; } while ( rn && rn -> info == NULL ) ; if ( rn ) route_lock_node ( rn ) ; continue ; } if ( match -> type == ZEBRA_ROUTE_CONNECT ) { newhop = match -> nexthop ; if ( newhop ) { if ( nexthop -> type == NEXTHOP_TYPE_IPV4 || nexthop -> type == NEXTHOP_TYPE_IPV6 ) nexthop -> ifindex = newhop -> ifindex ; } return 1 ; } else if ( CHECK_FLAG ( re -> flags , ZEBRA_FLAG_INTERNAL ) ) { resolved = 0 ; for ( ALL_NEXTHOPS ( match -> nexthop , newhop ) ) { if ( ! CHECK_FLAG ( newhop -> flags , NEXTHOP_FLAG_FIB ) ) continue ; if ( CHECK_FLAG ( newhop -> flags , NEXTHOP_FLAG_RECURSIVE ) ) continue ; if ( set ) { SET_FLAG ( nexthop -> flags , NEXTHOP_FLAG_RECURSIVE ) ; SET_FLAG ( re -> status , ROUTE_ENTRY_NEXTHOPS_CHANGED ) ; nexthop_set_resolved ( afi , newhop , nexthop ) ; } resolved = 1 ; } if ( resolved && set ) re -> nexthop_mtu = match -> mtu ; return resolved ; } else if ( re -> type == ZEBRA_ROUTE_STATIC ) { resolved = 0 ; for ( ALL_NEXTHOPS ( match -> nexthop , newhop ) ) { if ( ! CHECK_FLAG ( newhop -> flags , NEXTHOP_FLAG_FIB ) ) continue ; if ( set ) { SET_FLAG ( nexthop -> flags , NEXTHOP_FLAG_RECURSIVE ) ; nexthop_set_resolved ( afi , newhop , nexthop ) ; } resolved = 1 ; } if ( resolved && set ) re -> nexthop_mtu = match -> mtu ; return resolved ; } else { return 0 ; } } return 0 ; } | <S2SV_ModStart> ) && ! rnh_resolve_via_default <S2SV_ModEnd> ( p . |
5,893 | CWE-000 static VkResult radv_physical_device_init ( struct radv_physical_device * device , struct radv_instance * instance , drmDevicePtr drm_device ) { const char * path = drm_device -> nodes [ DRM_NODE_RENDER ] ; VkResult result ; drmVersionPtr version ; int fd ; <S2SV_StartBug> fd = open ( path , O_RDWR | O_CLOEXEC ) ; <S2SV_EndBug> if ( fd < 0 ) return vk_error ( VK_ERROR_INCOMPATIBLE_DRIVER ) ; version = drmGetVersion ( fd ) ; if ( ! version ) { close ( fd ) ; return vk_errorf ( VK_ERROR_INCOMPATIBLE_DRIVER , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>version<S2SV_blank>%s:<S2SV_blank>%m" , path ) ; } if ( strcmp ( version -> name , "amdgpu" ) ) { drmFreeVersion ( version ) ; <S2SV_StartBug> close ( fd ) ; <S2SV_EndBug> return VK_ERROR_INCOMPATIBLE_DRIVER ; } drmFreeVersion ( version ) ; device -> _loader_data . loaderMagic = ICD_LOADER_MAGIC ; device -> instance = instance ; assert ( strlen ( path ) < ARRAY_SIZE ( device -> path ) ) ; strncpy ( device -> path , path , ARRAY_SIZE ( device -> path ) ) ; device -> ws = radv_amdgpu_winsys_create ( fd , instance -> debug_flags , instance -> perftest_flags ) ; if ( ! device -> ws ) { result = VK_ERROR_INCOMPATIBLE_DRIVER ; goto fail ; <S2SV_StartBug> } <S2SV_EndBug> device -> local_fd = fd ; device -> ws -> query_info ( device -> ws , & device -> rad_info ) ; radv_handle_env_var_force_family ( device ) ; radv_get_device_name ( device -> rad_info . family , device -> name , sizeof ( device -> name ) ) ; if ( radv_device_get_cache_uuid ( device -> rad_info . family , device -> cache_uuid ) ) { device -> ws -> destroy ( device -> ws ) ; result = vk_errorf ( VK_ERROR_INITIALIZATION_FAILED , "cannot<S2SV_blank>generate<S2SV_blank>UUID" ) ; goto fail ; } uint64_t shader_env_flags = ( device -> instance -> perftest_flags & RADV_PERFTEST_SISCHED ? 0x1 : 0 ) | ( device -> instance -> debug_flags & RADV_DEBUG_UNSAFE_MATH ? 0x2 : 0 ) ; char buf [ VK_UUID_SIZE * 2 + 1 ] ; disk_cache_format_hex_id ( buf , device -> cache_uuid , VK_UUID_SIZE * 2 ) ; device -> disk_cache = disk_cache_create ( device -> name , buf , shader_env_flags ) ; if ( device -> rad_info . chip_class < VI || device -> rad_info . chip_class > GFX9 ) fprintf ( stderr , "WARNING:<S2SV_blank>radv<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>conformant<S2SV_blank>vulkan<S2SV_blank>implementation,<S2SV_blank>testing<S2SV_blank>use<S2SV_blank>only.\\n" ) ; radv_get_driver_uuid ( & device -> device_uuid ) ; radv_get_device_uuid ( & device -> rad_info , & device -> device_uuid ) ; if ( device -> rad_info . family == CHIP_STONEY || device -> rad_info . chip_class >= GFX9 ) { device -> has_rbplus = true ; device -> rbplus_allowed = device -> rad_info . family == CHIP_STONEY || device -> rad_info . family == CHIP_VEGA12 ; } device -> has_clear_state = device -> rad_info . chip_class >= CIK ; device -> cpdma_prefetch_writes_memory = device -> rad_info . chip_class <= VI ; device -> has_scissor_bug = device -> rad_info . family == CHIP_VEGA10 || device -> rad_info . family == CHIP_RAVEN ; device -> has_out_of_order_rast = device -> rad_info . chip_class >= VI && device -> rad_info . max_se >= 2 ; device -> out_of_order_rast_allowed = device -> has_out_of_order_rast && ( device -> instance -> perftest_flags & RADV_PERFTEST_OUT_OF_ORDER ) ; radv_physical_device_init_mem_types ( device ) ; radv_fill_device_extension_table ( device , & device -> supported_extensions ) ; result = radv_init_wsi ( device ) ; if ( result != VK_SUCCESS ) { device -> ws -> destroy ( device -> ws ) ; goto fail ; } return VK_SUCCESS ; fail : close ( fd ) ; <S2SV_StartBug> return result ; <S2SV_EndBug> } | <S2SV_ModStart> int fd ; int master_fd = - 1 ; <S2SV_ModStart> version ) ; if ( master_fd != - 1 ) close ( master_fd ) ; <S2SV_ModStart> fail ; } device -> master_fd = master_fd ; <S2SV_ModStart> fd ) ; if ( master_fd != - 1 ) close ( master_fd ) ; |
5,894 | CWE-000 void av1_rc_set_gf_interval_range ( const AV1_COMP * const cpi , RATE_CONTROL * const rc ) { const AV1EncoderConfig * const oxcf = & cpi -> oxcf ; if ( ( oxcf -> pass == 0 ) && ( oxcf -> rc_mode == AOM_Q ) ) { rc -> max_gf_interval = FIXED_GF_INTERVAL ; rc -> min_gf_interval = FIXED_GF_INTERVAL ; rc -> static_scene_max_gf_interval = FIXED_GF_INTERVAL ; } else { rc -> max_gf_interval = oxcf -> max_gf_interval ; rc -> min_gf_interval = oxcf -> min_gf_interval ; if ( rc -> min_gf_interval == 0 ) rc -> min_gf_interval = av1_rc_get_default_min_gf_interval ( oxcf -> width , oxcf -> height , cpi -> framerate ) ; if ( rc -> max_gf_interval == 0 ) rc -> max_gf_interval = av1_rc_get_default_max_gf_interval ( <S2SV_StartBug> cpi -> framerate , rc -> min_gf_interval ) ; <S2SV_EndBug> rc -> static_scene_max_gf_interval = MAX_STATIC_GF_GROUP_LENGTH ; if ( rc -> max_gf_interval > rc -> static_scene_max_gf_interval ) rc -> max_gf_interval = rc -> static_scene_max_gf_interval ; rc -> min_gf_interval = AOMMIN ( rc -> min_gf_interval , rc -> max_gf_interval ) ; } } | <S2SV_ModStart> rc -> min_gf_interval , oxcf -> gf_max_pyr_height |
5,895 | CWE-000 void final_cost_hashjoin ( PlannerInfo * root , HashPath * path , JoinCostWorkspace * workspace , JoinPathExtraData * extra ) { Path * outer_path = path -> jpath . outerjoinpath ; Path * inner_path = path -> jpath . innerjoinpath ; double outer_path_rows = outer_path -> rows ; double inner_path_rows = inner_path -> rows ; double inner_path_rows_total = workspace -> inner_rows_total ; List * hashclauses = path -> path_hashclauses ; Cost startup_cost = workspace -> startup_cost ; Cost run_cost = workspace -> run_cost ; int numbuckets = workspace -> numbuckets ; int numbatches = workspace -> numbatches ; Cost cpu_per_tuple ; QualCost hash_qual_cost ; QualCost qp_qual_cost ; double hashjointuples ; double virtualbuckets ; Selectivity innerbucketsize ; Selectivity innermcvfreq ; ListCell * hcl ; if ( path -> jpath . path . param_info ) path -> jpath . path . rows = path -> jpath . path . param_info -> ppi_rows ; else path -> jpath . path . rows = path -> jpath . path . parent -> rows ; if ( path -> jpath . path . parallel_workers > 0 ) { double parallel_divisor = get_parallel_divisor ( & path -> jpath . path ) ; path -> jpath . path . rows = clamp_row_est ( path -> jpath . path . rows / parallel_divisor ) ; } if ( ! enable_hashjoin ) startup_cost += disable_cost ; path -> num_batches = numbatches ; path -> inner_rows_total = inner_path_rows_total ; virtualbuckets = ( double ) numbuckets * ( double ) numbatches ; if ( IsA ( inner_path , UniquePath ) ) { innerbucketsize = 1.0 / virtualbuckets ; innermcvfreq = 0.0 ; } else { innerbucketsize = 1.0 ; innermcvfreq = 1.0 ; foreach ( hcl , hashclauses ) { RestrictInfo * restrictinfo = lfirst_node ( RestrictInfo , hcl ) ; Selectivity thisbucketsize ; Selectivity thismcvfreq ; if ( bms_is_subset ( restrictinfo -> right_relids , inner_path -> parent -> relids ) ) { thisbucketsize = restrictinfo -> right_bucketsize ; if ( thisbucketsize < 0 ) { estimate_hash_bucket_stats ( root , get_rightop ( restrictinfo -> clause ) , virtualbuckets , & restrictinfo -> right_mcvfreq , & restrictinfo -> right_bucketsize ) ; thisbucketsize = restrictinfo -> right_bucketsize ; } thismcvfreq = restrictinfo -> right_mcvfreq ; } else { Assert ( bms_is_subset ( restrictinfo -> left_relids , inner_path -> parent -> relids ) ) ; thisbucketsize = restrictinfo -> left_bucketsize ; if ( thisbucketsize < 0 ) { estimate_hash_bucket_stats ( root , get_leftop ( restrictinfo -> clause ) , virtualbuckets , & restrictinfo -> left_mcvfreq , & restrictinfo -> left_bucketsize ) ; thisbucketsize = restrictinfo -> left_bucketsize ; } thismcvfreq = restrictinfo -> left_mcvfreq ; } if ( innerbucketsize > thisbucketsize ) innerbucketsize = thisbucketsize ; if ( innermcvfreq > thismcvfreq ) innermcvfreq = thismcvfreq ; } } if ( relation_byte_size ( clamp_row_est ( inner_path_rows * innermcvfreq ) , inner_path -> pathtarget -> width ) > ( work_mem * 1024L ) ) startup_cost += disable_cost ; cost_qual_eval ( & hash_qual_cost , hashclauses , root ) ; cost_qual_eval ( & qp_qual_cost , path -> jpath . joinrestrictinfo , root ) ; qp_qual_cost . startup -= hash_qual_cost . startup ; qp_qual_cost . per_tuple -= hash_qual_cost . per_tuple ; if ( path -> jpath . jointype == JOIN_SEMI || path -> jpath . jointype == JOIN_ANTI || extra -> inner_unique ) { double outer_matched_rows ; Selectivity inner_scan_frac ; outer_matched_rows = rint ( outer_path_rows * extra -> semifactors . outer_match_frac ) ; inner_scan_frac = 2.0 / ( extra -> semifactors . match_count + 1.0 ) ; startup_cost += hash_qual_cost . startup ; run_cost += hash_qual_cost . per_tuple * outer_matched_rows * clamp_row_est ( inner_path_rows * innerbucketsize * inner_scan_frac ) * 0.5 ; run_cost += hash_qual_cost . per_tuple * ( outer_path_rows - outer_matched_rows ) * clamp_row_est ( inner_path_rows / virtualbuckets ) * 0.05 ; <S2SV_StartBug> if ( path -> jpath . jointype == JOIN_SEMI ) <S2SV_EndBug> hashjointuples = outer_matched_rows ; else hashjointuples = outer_path_rows - outer_matched_rows ; <S2SV_StartBug> } <S2SV_EndBug> else { startup_cost += hash_qual_cost . startup ; run_cost += hash_qual_cost . per_tuple * outer_path_rows * clamp_row_est ( inner_path_rows * innerbucketsize ) * 0.5 ; hashjointuples = approx_tuple_count ( root , & path -> jpath , hashclauses ) ; } startup_cost += qp_qual_cost . startup ; cpu_per_tuple = cpu_tuple_cost + qp_qual_cost . per_tuple ; run_cost += cpu_per_tuple * hashjointuples ; startup_cost += path -> jpath . path . pathtarget -> cost . startup ; run_cost += path -> jpath . path . pathtarget -> cost . per_tuple * path -> jpath . path . rows ; path -> jpath . path . startup_cost = startup_cost ; path -> jpath . path . total_cost = startup_cost + run_cost ; } | <S2SV_ModStart> . jointype == JOIN_ANTI ) <S2SV_ModEnd> hashjointuples = outer_path_rows <S2SV_ModStart> - outer_matched_rows ; else hashjointuples = outer_matched_rows ; |
5,896 | CWE-000 static int at86rf230_set_hw_addr_filt ( struct ieee802154_hw * hw , struct ieee802154_hw_addr_filt * filt , unsigned long changed ) { struct at86rf230_local * lp = hw -> priv ; if ( changed & IEEE802154_AFILT_SADDR_CHANGED ) { u16 addr = le16_to_cpu ( filt -> short_addr ) ; dev_vdbg ( & lp -> spi -> dev , <S2SV_StartBug> "at86rf230_set_hw_addr_filt<S2SV_blank>called<S2SV_blank>for<S2SV_blank>saddr\\n" ) ; <S2SV_EndBug> __at86rf230_write ( lp , RG_SHORT_ADDR_0 , addr ) ; __at86rf230_write ( lp , RG_SHORT_ADDR_1 , addr >> 8 ) ; } if ( changed & IEEE802154_AFILT_PANID_CHANGED ) { u16 pan = le16_to_cpu ( filt -> pan_id ) ; dev_vdbg ( & lp -> spi -> dev , <S2SV_StartBug> "at86rf230_set_hw_addr_filt<S2SV_blank>called<S2SV_blank>for<S2SV_blank>pan<S2SV_blank>id\\n" ) ; <S2SV_EndBug> __at86rf230_write ( lp , RG_PAN_ID_0 , pan ) ; __at86rf230_write ( lp , RG_PAN_ID_1 , pan >> 8 ) ; } if ( changed & IEEE802154_AFILT_IEEEADDR_CHANGED ) { u8 i , addr [ 8 ] ; memcpy ( addr , & filt -> ieee_addr , 8 ) ; dev_vdbg ( & lp -> spi -> dev , <S2SV_StartBug> "at86rf230_set_hw_addr_filt<S2SV_blank>called<S2SV_blank>for<S2SV_blank>IEEE<S2SV_blank>addr\\n" ) ; <S2SV_EndBug> for ( i = 0 ; i < 8 ; i ++ ) __at86rf230_write ( lp , RG_IEEE_ADDR_0 + i , addr [ i ] ) ; } if ( changed & IEEE802154_AFILT_PANC_CHANGED ) { dev_vdbg ( & lp -> spi -> dev , <S2SV_StartBug> "at86rf230_set_hw_addr_filt<S2SV_blank>called<S2SV_blank>for<S2SV_blank>panc<S2SV_blank>change\\n" ) ; <S2SV_EndBug> if ( filt -> pan_coord ) at86rf230_write_subreg ( lp , SR_AACK_I_AM_COORD , 1 ) ; else at86rf230_write_subreg ( lp , SR_AACK_I_AM_COORD , 0 ) ; } return 0 ; } | <S2SV_ModStart> -> dev , "%s<S2SV_blank>called<S2SV_blank>for<S2SV_blank>saddr\\n" , __func__ <S2SV_ModEnd> ) ; __at86rf230_write <S2SV_ModStart> -> dev , "%s<S2SV_blank>called<S2SV_blank>for<S2SV_blank>pan<S2SV_blank>id\\n" , __func__ <S2SV_ModEnd> ) ; __at86rf230_write <S2SV_ModStart> -> dev , "%s<S2SV_blank>called<S2SV_blank>for<S2SV_blank>IEEE<S2SV_blank>addr\\n" , __func__ <S2SV_ModEnd> ) ; for <S2SV_ModStart> -> dev , "%s<S2SV_blank>called<S2SV_blank>for<S2SV_blank>panc<S2SV_blank>change\\n" , __func__ <S2SV_ModEnd> ) ; if |
5,897 | CWE-000 long point_triangle_intersection ( Point3 p , Triangle3 t ) { long sign12 , sign23 , sign31 ; Point3 vect12 , vect23 , vect31 , vect1h , vect2h , vect3h ; Point3 cross12_1p , cross23_2p , cross31_3p ; <S2SV_StartBug> if ( p . x > MAX3 ( t . v1 . x , t . v2 . x , t . v3 . x ) ) return ( OUTSIDE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p . y > MAX3 ( t . v1 . y , t . v2 . y , t . v3 . y ) ) return ( OUTSIDE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p . z > MAX3 ( t . v1 . z , t . v2 . z , t . v3 . z ) ) return ( OUTSIDE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p . x < MIN3 ( t . v1 . x , t . v2 . x , t . v3 . x ) ) return ( OUTSIDE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p . y < MIN3 ( t . v1 . y , t . v2 . y , t . v3 . y ) ) return ( OUTSIDE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p . z < MIN3 ( t . v1 . z , t . v2 . z , t . v3 . z ) ) return ( OUTSIDE ) ; <S2SV_EndBug> SUB ( t . v1 , t . v2 , vect12 ) SUB ( t . v1 , p , vect1h ) ; CROSS ( vect12 , vect1h , cross12_1p ) sign12 = SIGN3 ( cross12_1p ) ; SUB ( t . v2 , t . v3 , vect23 ) SUB ( t . v2 , p , vect2h ) ; CROSS ( vect23 , vect2h , cross23_2p ) sign23 = SIGN3 ( cross23_2p ) ; SUB ( t . v3 , t . v1 , vect31 ) SUB ( t . v3 , p , vect3h ) ; CROSS ( vect31 , vect3h , cross31_3p ) sign31 = SIGN3 ( cross31_3p ) ; # ifdef OLD_TEST if ( ( sign12 == sign23 ) && ( sign23 == sign31 ) ) return ( INSIDE ) ; else return ( OUTSIDE ) ; # else return ( ( sign12 & sign23 & sign31 ) == 0 ) ? OUTSIDE : INSIDE ; # endif } | <S2SV_ModStart> . x ) + EPS <S2SV_ModStart> . y ) + EPS <S2SV_ModStart> . z ) + EPS <S2SV_ModStart> . x ) - EPS <S2SV_ModStart> . y ) - EPS <S2SV_ModStart> . z ) - EPS |
5,898 | CWE-000 void printLog ( File log , bool gzOut , Chrom * chr , <S2SV_StartBug> uint32_t * start , int n , uint32_t m , uint32_t * j , <S2SV_EndBug> <S2SV_StartBug> uint32_t * k , uint32_t idx [ ] , bool qvalOpt , <S2SV_EndBug> bool sig ) { if ( ! n ) { printInterval ( log , gzOut , chr -> name , <S2SV_StartBug> * start , chr -> pval [ n ] -> end [ m ] , <S2SV_EndBug> <S2SV_StartBug> chr -> treat -> cov [ * j ] , chr -> ctrl -> cov [ * k ] , <S2SV_EndBug> chr -> pval [ n ] -> cov [ m ] , qvalOpt ? chr -> qval -> cov [ m ] : - 1.0f , sig ) ; <S2SV_StartBug> if ( chr -> ctrl -> end [ * k ] < chr -> treat -> end [ * j ] ) <S2SV_EndBug> ( * k ) ++ ; else { if ( chr -> ctrl -> end [ * k ] == chr -> treat -> end [ * j ] ) ( * k ) ++ ; ( * j ) ++ ; } } else { printIntervalN ( log , gzOut , chr -> name , <S2SV_StartBug> * start , chr -> pval [ n ] -> end [ m ] , <S2SV_EndBug> chr -> pval , n , idx , chr -> pval [ n ] -> cov [ m ] , qvalOpt ? chr -> qval -> cov [ m ] : - 1.0f , sig ) ; for ( int r = 0 ; r < n ; r ++ ) if ( chr -> pval [ r ] != NULL && chr -> pval [ r ] -> end [ idx [ r ] ] == chr -> pval [ n ] -> end [ m ] ) idx [ r ] ++ ; } <S2SV_StartBug> * start = chr -> pval [ n ] -> end [ m ] ; <S2SV_EndBug> } | <S2SV_ModStart> chr , uint32_t <S2SV_ModEnd> start , int <S2SV_ModStart> m , uint32_t <S2SV_ModEnd> j , uint32_t <S2SV_ModStart> j , uint32_t <S2SV_ModEnd> k , uint32_t <S2SV_ModStart> -> name , <S2SV_ModEnd> start , chr <S2SV_ModStart> -> cov [ <S2SV_ModEnd> j ] , <S2SV_ModStart> -> cov [ <S2SV_ModEnd> k ] , <S2SV_ModStart> sig ) ; <S2SV_ModEnd> } else { <S2SV_ModStart> -> name , <S2SV_ModEnd> start , chr <S2SV_ModStart> ++ ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,899 | CWE-000 void SPVM_HASH_maybe_extend_key_buffer ( SPVM_HASH * hash , int32_t length ) { assert ( hash ) ; int32_t key_buffer_length = hash -> key_buffer_length ; assert ( key_buffer_length >= 0 ) ; int32_t key_buffer_capacity = hash -> key_buffer_capacity ; if ( key_buffer_length + length >= key_buffer_capacity ) { <S2SV_StartBug> int32_t new_key_buffer_capacity = key_buffer_capacity * 2 ; <S2SV_EndBug> <S2SV_StartBug> int64_t new_key_buffer_byte_size = ( int64_t ) new_key_buffer_capacity * ( int64_t ) sizeof ( SPVM_HASH_ENTRY ) ; <S2SV_EndBug> char * new_key_buffer = SPVM_UTIL_ALLOCATOR_safe_malloc_zero ( new_key_buffer_byte_size ) ; memcpy ( new_key_buffer , hash -> key_buffer , key_buffer_capacity ) ; free ( hash -> key_buffer ) ; hash -> key_buffer = new_key_buffer ; hash -> key_buffer_capacity = new_key_buffer_capacity ; } } | <S2SV_ModStart> int32_t new_key_buffer_capacity = ( key_buffer_length + length ) <S2SV_ModEnd> * 2 ; <S2SV_ModStart> int64_t ) new_key_buffer_capacity <S2SV_ModEnd> ; char * |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.