/* Ein Datum in die Datenbank schreiben */ static void pg_insert(char *query){ PGresult *res; if(pg_connect()){ res = PQexec(connection, query); if(!res || PQresultStatus(res) != PGRES_COMMAND_OK){ DEBUGOUT2("Fehler beim INSERT: %s\n", query); #ifndef NO_LOGING snprintf(get_error_buffer(), ERR_BUFFERSIZE, "Fehler beim INSERT: %s", query); log_error(get_error_buffer()); #endif } else { DEBUGOUT2("Query: '%s' ausgefuehrt\n", query); } PQclear(res); } }
/** e1000_read_invm_word_i210 - Reads OTP * @hw: pointer to the HW structure * @address: the word address (aka eeprom offset) to read * @data: pointer to the data read * * Reads 16-bit words from the OTP. Return error when the word is not * stored in OTP. **/ static s32 e1000_read_invm_word_i210(struct e1000_hw *hw, u8 address, u16 *data) { s32 status = -E1000_ERR_INVM_VALUE_NOT_FOUND; u32 invm_dword; u16 i; u8 record_type, word_address; DEBUGFUNC("e1000_read_invm_word_i210"); for (i = 0; i < E1000_INVM_SIZE; i++) { invm_dword = E1000_READ_REG(hw, E1000_INVM_DATA_REG(i)); /* Get record type */ record_type = INVM_DWORD_TO_RECORD_TYPE(invm_dword); if (record_type == E1000_INVM_UNINITIALIZED_STRUCTURE) break; if (record_type == E1000_INVM_CSR_AUTOLOAD_STRUCTURE) i += E1000_INVM_CSR_AUTOLOAD_DATA_SIZE_IN_DWORDS; if (record_type == E1000_INVM_RSA_KEY_SHA256_STRUCTURE) i += E1000_INVM_RSA_KEY_SHA256_DATA_SIZE_IN_DWORDS; if (record_type == E1000_INVM_WORD_AUTOLOAD_STRUCTURE) { word_address = INVM_DWORD_TO_WORD_ADDRESS(invm_dword); if (word_address == address) { *data = INVM_DWORD_TO_WORD_DATA(invm_dword); DEBUGOUT2("Read INVM Word 0x%02x = %x", address, *data); status = E1000_SUCCESS; break; } } } if (status != E1000_SUCCESS) DEBUGOUT1("Requested word 0x%02x not found in OTP\n", address); return status; }
/* Guckt ob Verbindung da und versucht aufzubauen. * gibt 1 zurueck, wenn erfolgreich, sonst 0 */ static int pg_connect(){ if (PQstatus(connection) == CONNECTION_OK){ PQexec(connection,"SELECT 1"); /* Status neusetzen erzwingen */ } if(PQstatus(connection) != CONNECTION_OK){ if (connection == NULL){ if(conn_string == NULL){ conn_string = malloc(sizeof(char)*512); snprintf(conn_string, 512, "host=%s dbname=%s user=%s password=%s connect_timeout=%s", global_opts.pg_host, global_opts.pg_database, global_opts.pg_user, global_opts.pg_pass, global_opts.pg_timeout); } connection = PQconnectdb(conn_string); /* Connection aufbauen */ add_clean(clean_write, connection); /* Callbackfunktion zum Aufraeumen registrieren */ } else { PQreset(connection); /* Connecion resetten */ } if(PQstatus(connection) != CONNECTION_OK){ DEBUGOUT2("\nFehler beim Aufbau der Datenbankverbindung\n%s\n", PQerrorMessage(connection)); #ifndef NO_LOGING snprintf(get_error_buffer(), ERR_BUFFERSIZE, "Fehler beim Aufbau der Datenbankverbindung: %s", PQerrorMessage(connection)); log_error(get_error_buffer()); #endif return 0; } DEBUGOUT1("\nDatenbankverbindung erfolgreich hergestellt\n"); } return 1; }
/** * ixgbe_set_mac_type - Sets MAC type * @hw: pointer to the HW structure * * This function sets the mac type of the adapter based on the * vendor ID and device ID stored in the hw structure. **/ s32 ixgbe_set_mac_type(struct ixgbe_hw *hw) { s32 ret_val = IXGBE_SUCCESS; DEBUGFUNC("ixgbe_set_mac_type\n"); if (hw->vendor_id == IXGBE_INTEL_VENDOR_ID) { switch (hw->device_id) { case IXGBE_DEV_ID_82598: case IXGBE_DEV_ID_82598_BX: case IXGBE_DEV_ID_82598AF_SINGLE_PORT: case IXGBE_DEV_ID_82598AF_DUAL_PORT: case IXGBE_DEV_ID_82598AT: case IXGBE_DEV_ID_82598AT2: case IXGBE_DEV_ID_82598EB_CX4: case IXGBE_DEV_ID_82598_CX4_DUAL_PORT: case IXGBE_DEV_ID_82598_DA_DUAL_PORT: case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM: case IXGBE_DEV_ID_82598EB_XF_LR: case IXGBE_DEV_ID_82598EB_SFP_LOM: hw->mac.type = ixgbe_mac_82598EB; break; case IXGBE_DEV_ID_82599_KX4: case IXGBE_DEV_ID_82599_KX4_MEZZ: case IXGBE_DEV_ID_82599_XAUI_LOM: case IXGBE_DEV_ID_82599_COMBO_BACKPLANE: case IXGBE_DEV_ID_82599_KR: case IXGBE_DEV_ID_82599_SFP: case IXGBE_DEV_ID_82599_BACKPLANE_FCOE: case IXGBE_DEV_ID_82599_SFP_FCOE: case IXGBE_DEV_ID_82599_SFP_EM: case IXGBE_DEV_ID_82599_SFP_SF2: case IXGBE_DEV_ID_82599EN_SFP: case IXGBE_DEV_ID_82599_CX4: case IXGBE_DEV_ID_82599_T3_LOM: hw->mac.type = ixgbe_mac_82599EB; break; case IXGBE_DEV_ID_82599_VF: hw->mac.type = ixgbe_mac_82599_vf; break; case IXGBE_DEV_ID_X540_VF: hw->mac.type = ixgbe_mac_X540_vf; break; case IXGBE_DEV_ID_X540T: case IXGBE_DEV_ID_X540T1: hw->mac.type = ixgbe_mac_X540; break; default: ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED; break; } } else { ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED; } DEBUGOUT2("ixgbe_set_mac_type found mac: %d, returns: %d\n", hw->mac.type, ret_val); return ret_val; }
/* Wertkonvertierungen fuer den 'einfachen' Außensensor */ static auss1_data process_auss1(time_t timestamp, u_char address, u_char *buffer){ auss1_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */ DEBUGOUT2("Aussensensor1 an Addresse %i\n", address); DEBUGOUT2("Temp.: %3.1f\n", (data.temp*0.1)); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(AUSS1,address), "Temp: %3.1f°C",(data.temp*0.1)); log_data(timestamp, log_buffer); } #endif return data; }
/* Wertkonvertierungen fuer den Regensensor (ein Zaehlschritt = 370ml/m^2)*/ static regen_data process_regen(time_t timestamp, u_char address, u_char *buffer){ regen_data data; /* Datenstruktur */ int new_rain_count = 0; /* Neuer Zaehlerstand */ int now_rain_count = 0; /* Delta-Zaehlerstand */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ new_rain_count = ((buffer[2] & 0x1F) << 7) | remove_msb(buffer[3]); /* Niederschlagszaehler */ if (get_flag(NOT_USE_ADDR_FLAG)) address = 0; if(last_rain_count[address%16] == -1) /* Nach Programmstart Zaehler initialisieren */ last_rain_count[address%16] = new_rain_count; now_rain_count = new_rain_count - last_rain_count[address%16]; /* neuen Niederschlag berechnen */ if(now_rain_count < 0){ /* Wenn Integerueberlauf im Sensor */ now_rain_count = (0x3FFF - last_rain_count[address%16]) + new_rain_count; /* Dann letzten gemessenen Wert vom Max-Integer-Wert abziehen und neuen Zaehlwert dazurechnen */ DEBUGOUT1("Integer-Ueberlauf\n"); } data.counter = (now_rain_count * 370); /* Ein Zaehlschritt entspricht 370ml/m^2, also aenderung mit 370 multiplizieren und zuweisen */ last_rain_count[address%16] = new_rain_count; /* Zaehler neu setzen */ DEBUGOUT2("Regensensor an Addresse %i\n", data.address); DEBUGOUT3("Zaehler: %d Differenz: %d\n", new_rain_count,now_rain_count); DEBUGOUT2("Niederschlag: %dml/m^2\n", data.counter); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(REGEN,address), "Rain: %dml/m^2",data.counter); log_data(timestamp, log_buffer); } #endif return data; }
/****************************************************************************** * return the mac address from EEPROM * * hw - Struct containing variables accessed by shared code * mac_addr - Ethernet Address if EEPROM contents are valid, 0 otherwise * * Returns: None. ******************************************************************************/ void ixgb_get_ee_mac_addr(struct ixgb_hw *hw, uint8_t *mac_addr) { int i; struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom; DEBUGFUNC("ixgb_get_ee_mac_addr"); if(ixgb_check_and_get_eeprom_data(hw) == TRUE) { for(i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) { mac_addr[i] = ee_map->mac_addr[i]; DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]); } } }
/* Wertkonvertierungen fuer den 'besseren' Außensensor */ static auss2_data process_auss2(time_t timestamp, u_char address, u_char *buffer){ auss2_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */ data.hum = remove_msb(buffer[4]); /* Luftfeuchte */ DEBUGOUT2("Aussensensor2 an Addresse %i\n", address); DEBUGOUT3("Temp.: %3.1f°C Feuchte: %d%%\n",(data.temp*0.1),data.hum); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(AUSS2,address), "Temp: %3.1f°C Hum: %d%%",(data.temp*0.1),data.hum); log_data(timestamp, log_buffer); } #endif return data; }
/** * ixgbe_init_eeprom_params_X540 - Initialize EEPROM params * @hw: pointer to hardware structure * * Initializes the EEPROM parameters ixgbe_eeprom_info within the * ixgbe_hw struct in order to set up EEPROM access. **/ s32 ixgbe_init_eeprom_params_X540(struct ixgbe_hw *hw) { struct ixgbe_eeprom_info *eeprom = &hw->eeprom; u32 eec; u16 eeprom_size; DEBUGFUNC("ixgbe_init_eeprom_params_X540"); if (eeprom->type == ixgbe_eeprom_uninitialized) { eeprom->semaphore_delay = 10; eeprom->type = ixgbe_flash; eec = IXGBE_READ_REG(hw, IXGBE_EEC); eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >> IXGBE_EEC_SIZE_SHIFT); eeprom->word_size = 1 << (eeprom_size + IXGBE_EEPROM_WORD_SIZE_SHIFT); DEBUGOUT2("Eeprom params: type = %d, size = %d\n", eeprom->type, eeprom->word_size); }
/* Wertkonvertierungen fuer das Pyranometer */ static pyano_data process_pyano(time_t timestamp, u_char address, u_char *buffer){ pyano_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.rawrad = convert_unsigned_int(buffer[2],buffer[3]); /* 'Roh-Strahlung' - Strahlung ohne Multiplikator */ data.mult = buffer[4] & 0x03; /* Multiplikator */ data.absrad = (0x01 << data.mult) * data.rawrad; /* Absolute Strahlung */ DEBUGOUT2("Pyranometer an Addresse %i\n", address); DEBUGOUT4("Rel. Strahl.: %d Mult.: %d Abs. Strahl.: %d\n",data.rawrad,data.mult,data.absrad); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(PYANO,address), "Int: %d",data.absrad); log_data(timestamp, log_buffer); } #endif return data; }
/* Wertkonvertierungen fuer den Windsensor */ static winds_data process_winds(time_t timestamp, u_char address, u_char *buffer){ winds_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ data.geschw = convert_unsigned_int(buffer[2],buffer[3]); /* Windgeschwindigkeit */ data.schwank = buffer[4] & 0x03; /* Schwankungsbreite */ data.richt = convert_unsigned_int(buffer[5],buffer[6]); /* Windrichtung */ DEBUGOUT2("Windsensor an Addresse %i\n", address); DEBUGOUT4("Geschw.: %3.1fKm/h Schwank: %d Richtung: %d°\n",(data.geschw*0.1),data.schwank,data.richt); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(WINDS,address), "Spd: %3.1fKm/h Fluct: %d%% Dir:%d°",(data.geschw*0.1),data.schwank,data.richt); log_data(timestamp, log_buffer); } #endif return data; }
/* Wertkonvertierungen fuer den Helligkeitssensor */ static helli_data process_helli(time_t timestamp, u_char address, u_char *buffer){ helli_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ data.rawlum = convert_unsigned_int(buffer[2],buffer[3]); /* 'Roh-Helligkeit' - Helligkeit ohne Multiplikator */ data.mult = buffer[4] & 0x03; /* Multiplikator */ data.abslum = (0x01 << data.mult) * data.rawlum; /* Absolute Helligkeit */ DEBUGOUT2("Helligkeitssensor an Addresse %i\n", address); DEBUGOUT4("Rel. Hell.: %d Mult.: %d Abs. Hell.: %d\n",data.rawlum,data.mult,data.abslum); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(HELLI,address), "Bright: %d",data.abslum); log_data(timestamp, log_buffer); } #endif return data; }
/* Wertkonvertierungen fuer den Innensensor */ static innen_data process_innen(time_t timestamp, u_char address, u_char *buffer){ innen_data data; /* Datenstruktur */ data.timestamp = timestamp; /* Zeitstempel */ data.address = address; /* Addresse */ data.temp = convert_signed_int(buffer[2],buffer[3]); /* Temparatur */ data.hum = remove_msb(buffer[4]); /* Luftfeuchte */ data.press = convert_unsigned_int(buffer[5],buffer[6]); /* Luftdruck */ DEBUGOUT2("Innensensor an Addresse %i\n",address); DEBUGOUT4("Temp.: %3.1f°C Feuchte: %d%% Druck: %dhPa\n",(data.temp*0.1),data.hum,data.press); #ifndef NO_LOGING if(get_flag(LOG_DATA_FLAG)){ check_log_buffer(); sprintf(prepend_type_address(INNEN,address), "Temp: %3.1f°C Hum: %d%% Press: %dhPa",(data.temp*0.1),data.hum,data.press); log_data(timestamp, log_buffer); } #endif return data; }
/** * fm10k_set_mac_type - Sets MAC type * @hw: pointer to the HW structure * * This function sets the mac type of the adapter based on the * vendor ID and device ID stored in the hw structure. **/ s32 fm10k_set_mac_type(struct fm10k_hw *hw) { s32 ret_val = FM10K_SUCCESS; DEBUGFUNC("fm10k_set_mac_type"); if (hw->vendor_id != FM10K_INTEL_VENDOR_ID) { ERROR_REPORT2(FM10K_ERROR_UNSUPPORTED, "Unsupported vendor id: %x\n", hw->vendor_id); return FM10K_ERR_DEVICE_NOT_SUPPORTED; } switch (hw->device_id) { case FM10K_DEV_ID_PF: #ifdef BOULDER_RAPIDS_HW case FM10K_DEV_ID_SDI_FM10420_QDA2: #endif /* BOULDER_RAPIDS_HW */ #ifdef ATWOOD_CHANNEL_HW case FM10K_DEV_ID_SDI_FM10420_DA2: #endif /* ATWOOD_CHANNEL_HW */ hw->mac.type = fm10k_mac_pf; break; case FM10K_DEV_ID_VF: hw->mac.type = fm10k_mac_vf; break; default: ret_val = FM10K_ERR_DEVICE_NOT_SUPPORTED; ERROR_REPORT2(FM10K_ERROR_UNSUPPORTED, "Unsupported device id: %x\n", hw->device_id); break; } DEBUGOUT2("fm10k_set_mac_type found mac: %d, returns: %d\n", hw->mac.type, ret_val); return ret_val; }
/* Bestimmung der Sensoren und Weiterreichung an die Funktionen zum auswerten der Werte * sowie zum wegschreiben */ void process_data(time_t timestamp, u_char *buffer){ u_char type; /* Sensortyp */ u_char address; /* Sensoraddresse */ type = get_hi_nibble(remove_msb(buffer[1])); address = get_lo_nibble(buffer[1]); DEBUGOUT1(asctime(localtime(×tamp))); switch (type){ case FERNB : DEBUGOUT2("Fernbedienung an Addresse %i\n", address); DEBUGOUT1("\nnoch nix zu implementiert!\n\n"); break; case AUSS1 : write_auss1(process_auss1(timestamp,address, buffer)); break; case AUSS2 : write_auss2(process_auss2(timestamp,address, buffer)); break; case REGEN : write_regen(process_regen(timestamp,address, buffer)); break; case WINDS : write_winds(process_winds(timestamp,address, buffer)); break; case INNEN : write_innen(process_innen(timestamp,address, buffer)); break; case HELLI : write_helli(process_helli(timestamp,address, buffer)); break; case PYANO : write_pyano(process_pyano(timestamp,address, buffer)); break; } }
/** * ixgbe_set_mac_type - Sets MAC type * @hw: pointer to the HW structure * * This function sets the mac type of the adapter based on the * vendor ID and device ID stored in the hw structure. **/ s32 ixgbe_set_mac_type(struct ixgbe_hw *hw) { s32 ret_val = IXGBE_SUCCESS; DEBUGFUNC("ixgbe_set_mac_type\n"); if (hw->vendor_id != IXGBE_INTEL_VENDOR_ID) { ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED, "Unsupported vendor id: %x", hw->vendor_id); return IXGBE_ERR_DEVICE_NOT_SUPPORTED; } hw->mvals = ixgbe_mvals_base; switch (hw->device_id) { case IXGBE_DEV_ID_82598: case IXGBE_DEV_ID_82598_BX: case IXGBE_DEV_ID_82598AF_SINGLE_PORT: case IXGBE_DEV_ID_82598AF_DUAL_PORT: case IXGBE_DEV_ID_82598AT: case IXGBE_DEV_ID_82598AT2: case IXGBE_DEV_ID_82598EB_CX4: case IXGBE_DEV_ID_82598_CX4_DUAL_PORT: case IXGBE_DEV_ID_82598_DA_DUAL_PORT: case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM: case IXGBE_DEV_ID_82598EB_XF_LR: case IXGBE_DEV_ID_82598EB_SFP_LOM: hw->mac.type = ixgbe_mac_82598EB; break; case IXGBE_DEV_ID_82599_KX4: case IXGBE_DEV_ID_82599_KX4_MEZZ: case IXGBE_DEV_ID_82599_XAUI_LOM: case IXGBE_DEV_ID_82599_COMBO_BACKPLANE: case IXGBE_DEV_ID_82599_KR: case IXGBE_DEV_ID_82599_SFP: case IXGBE_DEV_ID_82599_BACKPLANE_FCOE: case IXGBE_DEV_ID_82599_SFP_FCOE: case IXGBE_DEV_ID_82599_SFP_EM: case IXGBE_DEV_ID_82599_SFP_SF2: case IXGBE_DEV_ID_82599_SFP_SF_QP: case IXGBE_DEV_ID_82599_QSFP_SF_QP: case IXGBE_DEV_ID_82599EN_SFP: case IXGBE_DEV_ID_82599_CX4: case IXGBE_DEV_ID_82599_BYPASS: case IXGBE_DEV_ID_82599_T3_LOM: hw->mac.type = ixgbe_mac_82599EB; break; case IXGBE_DEV_ID_82599_VF: case IXGBE_DEV_ID_82599_VF_HV: hw->mac.type = ixgbe_mac_82599_vf; break; case IXGBE_DEV_ID_X540_VF: case IXGBE_DEV_ID_X540_VF_HV: hw->mac.type = ixgbe_mac_X540_vf; hw->mvals = ixgbe_mvals_X540; break; case IXGBE_DEV_ID_X540T: case IXGBE_DEV_ID_X540T1: case IXGBE_DEV_ID_X540_BYPASS: hw->mac.type = ixgbe_mac_X540; hw->mvals = ixgbe_mvals_X540; break; case IXGBE_DEV_ID_X550T: case IXGBE_DEV_ID_X550T1: hw->mac.type = ixgbe_mac_X550; hw->mvals = ixgbe_mvals_X550; break; case IXGBE_DEV_ID_X550EM_X_KX4: case IXGBE_DEV_ID_X550EM_X_KR: case IXGBE_DEV_ID_X550EM_X_10G_T: case IXGBE_DEV_ID_X550EM_X_1G_T: case IXGBE_DEV_ID_X550EM_X_SFP: hw->mac.type = ixgbe_mac_X550EM_x; hw->mvals = ixgbe_mvals_X550EM_x; break; case IXGBE_DEV_ID_X550_VF: case IXGBE_DEV_ID_X550_VF_HV: hw->mac.type = ixgbe_mac_X550_vf; hw->mvals = ixgbe_mvals_X550; break; case IXGBE_DEV_ID_X550EM_X_VF: case IXGBE_DEV_ID_X550EM_X_VF_HV: hw->mac.type = ixgbe_mac_X550EM_x_vf; hw->mvals = ixgbe_mvals_X550EM_x; break; default: ret_val = IXGBE_ERR_DEVICE_NOT_SUPPORTED; ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED, "Unsupported device id: %x", hw->device_id); break; } DEBUGOUT2("ixgbe_set_mac_type found mac: %d, returns: %d\n", hw->mac.type, ret_val); return ret_val; }
static int read_and_compare(int ttyFd, DataPack *standartMessage) { DataPack buffer, decodedBuffer; char* buffPtr=(char*)&buffer; int buffFill=0; int pass = 1; long iteration = 0; struct timeval selectDelay; fd_set set, *fdSet = &set; int retval; long lastLength = 1; *((uint32_t*)buffPtr) = htonl(RECIVEREADYMAGIC); while(config.work) { retval = write(ttyFd, &buffer, sizeof(uint32_t)); if (-1 == retval) { perror("Client error write ready status: "); kill(0, SIGTERM); return EIO; } usleep(calculate_delay_in_usec(2 * WAITBASEDELAY, WAITBASEDELAY)); selectDelay.tv_sec = 0; selectDelay.tv_usec = BASEDELAY; FD_ZERO(fdSet); FD_SET(ttyFd, fdSet); select(ttyFd + 1, fdSet, NULL, NULL, &selectDelay); retval = read(ttyFd, &buffer, sizeof(buffer)); if (retval == -1) { if (errno == EAGAIN) continue; perror("Client: read data error"); kill(0, SIGTERM); return EIO; } buffer.magic = ntohl(buffer.magic); if (buffer.magic == RECIVEREADYMAGIC) { continue; } else if (buffer.magic == SENDMAGIC) { buffPtr = (char*)&buffer; buffFill = retval; break; } else if (buffer.magic == WAITMAGIC) { DEBUGOUT("Geting wait message - again"); DEBUGPARAMETRS("Unexpected value in buffer: %X", (uint32_t)buffer.magic); kill(0, SIGTERM); } else { DEBUGOUT("Unexpected value in buffer: %X", (uint32_t)buffer.magic); kill(0, SIGTERM); return EINVAL; } } DEBUGMSG("Ready to read status wrote"); while(/*config.work && */ lastLength > 0) { if (buffFill == sizeof(buffer)) { convert_network_string_to_datapack((char*)&buffer, &decodedBuffer); pass = pass && !compare_data_packages(standartMessage, &decodedBuffer); buffFill = 0; buffPtr = (char*)&buffer; DEBUGOUT2("Message decoded: left space %d", decodedBuffer.dataTotalLength); lastLength = (int)decodedBuffer.dataTotalLength; memset(&buffer, 0, sizeof(buffer)); ++iteration; continue; } selectDelay.tv_sec = 0; selectDelay.tv_usec = 20 * calculate_delay_from_speed_usec( tioGetDefL( "PORTSPEED", 115200 ) ); FD_ZERO(fdSet); FD_SET(ttyFd, fdSet); retval = select(ttyFd + 1, fdSet, NULL, NULL, &selectDelay); if (retval == -1) { if ( errno == EINTR ) continue; perror("Client compare failed: "); kill(0, SIGTERM); return EIO; } else if (retval == 0) { if (lastLength < 0) break; DEBUGOUT("Too long nothing happening: Waiting more bytes %ld\n", lastLength); kill(0, SIGTERM); break; } retval = read(ttyFd, buffPtr, sizeof(buffer) - buffFill); if (retval == -1) { if(errno == EAGAIN) { continue; } perror("Client read port data failed: "); kill(0,SIGTERM); return EIO; } buffFill += retval; buffPtr += retval; } DEBUGMSG("Client decode finished"); return (pass && (iteration > 0)) ? 0 : 1; }
/** * ixgbe_dcb_config - Struct containing DCB settings. * @dcb_config: Pointer to DCB config structure * * This function checks DCB rules for DCB settings. * The following rules are checked: * 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%. * 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth * Group must total 100. * 3. A Traffic Class should not be set to both Link Strict Priority * and Group Strict Priority. * 4. Link strict Bandwidth Groups can only have link strict traffic classes * with zero bandwidth. */ s32 ixgbe_dcb_check_config_cee(struct ixgbe_dcb_config *dcb_config) { struct ixgbe_dcb_tc_path *p; s32 ret_val = IXGBE_SUCCESS; u8 i, j, bw = 0, bw_id; u8 bw_sum[2][IXGBE_DCB_MAX_BW_GROUP]; bool link_strict[2][IXGBE_DCB_MAX_BW_GROUP]; memset(bw_sum, 0, sizeof(bw_sum)); memset(link_strict, 0, sizeof(link_strict)); /* First Tx, then Rx */ for (i = 0; i < 2; i++) { /* Check each traffic class for rule violation */ for (j = 0; j < IXGBE_DCB_MAX_TRAFFIC_CLASS; j++) { p = &dcb_config->tc_config[j].path[i]; bw = p->bwg_percent; bw_id = p->bwg_id; if (bw_id >= IXGBE_DCB_MAX_BW_GROUP) { ret_val = IXGBE_ERR_CONFIG; goto err_config; } if (p->tsa == ixgbe_dcb_tsa_strict) { link_strict[i][bw_id] = TRUE; /* Link strict should have zero bandwidth */ if (bw) { ret_val = IXGBE_ERR_CONFIG; goto err_config; } } else if (!bw) { /* * Traffic classes without link strict * should have non-zero bandwidth. */ ret_val = IXGBE_ERR_CONFIG; goto err_config; } bw_sum[i][bw_id] += bw; } bw = 0; /* Check each bandwidth group for rule violation */ for (j = 0; j < IXGBE_DCB_MAX_BW_GROUP; j++) { bw += dcb_config->bw_percentage[i][j]; /* * Sum of bandwidth percentages of all traffic classes * within a Bandwidth Group must total 100 except for * link strict group (zero bandwidth). */ if (link_strict[i][j]) { if (bw_sum[i][j]) { /* * Link strict group should have zero * bandwidth. */ ret_val = IXGBE_ERR_CONFIG; goto err_config; } } else if (bw_sum[i][j] != IXGBE_DCB_BW_PERCENT && bw_sum[i][j] != 0) { ret_val = IXGBE_ERR_CONFIG; goto err_config; } } if (bw != IXGBE_DCB_BW_PERCENT) { ret_val = IXGBE_ERR_CONFIG; goto err_config; } } err_config: DEBUGOUT2("DCB error code %d while checking %s settings.\n", ret_val, (i == IXGBE_DCB_TX_CONFIG) ? "Tx" : "Rx"); return ret_val; }