Posix Thread Fehler bei Übergabe mehrerer Parameter?

[Tuxi (Gast)]

Hallo Forum,

ich habe hier ein kleines Problem:

//In der main
int
main (void)
{
  Config * Config_PTR = NULL;
  SPI_Par * SPI_Param = NULL;
  //Initialisierung
  init_Soft (&Config_PTR, &SPI_Param); //Hiernach sind Zeiger mit Structs belegt!!
  Thread Thread_Struct =
    { Config_PTR, SPI_Param };
  pthread_t threads[5];
//Bis hierhin stimmt alles!!

while (pthread_create (&threads[5], NULL, state_get_Mess_Data, &Thread_Struct)
      != 0)
    printf ("Fehler Thread state_get_Mess_Data!");
.
.
.

//Hier Thread Anfang
void *
state_get_Mess_Data (void * Give_Thread_Struct)
{
  Thread * Thread_Struct = (Thread *) Give_Thread_Struct;//Diese Adresse stimmt noch!

  Config * Config_PTR = (Config *) (Thread_Struct->Config_PTR); //Die Adresse Stimmt plötzlich nicht mehr!
  SPI_Par * SPI_Param = (SPI_Par *) (Thread_Struct->SPI_Param); //Diese Adresse stimmt noch!
  int_fast8_t ret;
  while (1)
    {

In der main werden die Pointer mit structs belegt worin Parameter stehen 
die innerhalb des Threads benötigt werden.

Nach dem start des Threads stimmt auf einmal die Adresse für den 
Config_PTR nicht mehr und die Daten innerhalb dieses structs sind Müll. 
Komischweise stimmt aber die Adresse das SPI_Param structs noch.

Wo liegt denn hier mein Fehler?

[Tuxi (Gast)]

Achja ich habe noch einen 2. Thread der dieses struct übergeben bekommt:

//In der main()
    while (pthread_create (&threads[4], NULL, state_Flash_Firm,
           &Thread_Struct) != 0)
  printf ("Fehler Thread state_Flash_Firm!");


//Thread Anfang
void *
state_Flash_Firm (void * Give_Thread_Struct)
{
  Thread * Thread_Struct = (Thread *) Give_Thread_Struct;
  Config * Config_PTR =  (Config *) (Thread_Struct->Config_PTR);
  SPI_Par * SPI_Param = (SPI_Par *) (Thread_Struct->SPI_Param);
  int status = 0;
  while (1)

Hier stimmt aber alles und Config_PTR zeigt auf die richtige Adresse!

[Peter II (Gast)]

Tuxi schrieb:
> Thread Thread_Struct =
>     { Config_PTR, SPI_Param };
>   pthread_t threads[5];

kann es sein, das du den Gültigkeitsbereich der Variablen verlässt?

Leist zeigst du nicht wie der code weiter geht.

[Tuxi (Gast)]

int
main (void)
{
  Config * Config_PTR = NULL;
  SPI_Par * SPI_Param = NULL;
  //Initialisierung
  init_Soft (&Config_PTR, &SPI_Param);
  Thread Thread_Struct =
    { Config_PTR, SPI_Param };
  pthread_t threads[5];

   //TESTS
   //system("wvdial pin");
   //state_feed_Watchdog(&WD_feeding_time);
   //state_SD_mount_umount(NULL);
   //flash_dsp(Config_PTR ,SPI_Param);
   //state_get_Mess_Data(&Thread_Struct);
   //state_Flash_Firm(&Thread_Struct);
   //state_Transfer_Data( Config_PTR);

   //exit(0);
   //TESTS OFF

  //Threads starten
  //while (pthread_create (&threads[1], NULL, state_SD_mount_umount, NULL) != 0)
   // printf ("Fehler Thread state_SD_mount_umount!");
  //while (pthread_create (&threads[2], NULL, state_SD_copy, Config_PTR) != 0)
   // printf ("Fehler Thread state_SD_copy!");
/*
  if (!(Config_PTR->SD_Only))
    {
      while (pthread_create (&threads[3], NULL, state_Transfer_Data, Config_PTR)
    != 0)
  printf ("Fehler Thread state_Transfer_Data!");
      while (pthread_create (&threads[4], NULL, state_Flash_Firm,
           &Thread_Struct) != 0)
  printf ("Fehler Thread state_Flash_Firm!");
   }
*/
  //DSP Reset für definierten Anfangszustand
  dsp_reset ();

  while (pthread_create (&threads[5], NULL, state_get_Mess_Data, &Thread_Struct)
      != 0)
    printf ("Fehler Thread state_get_Mess_Data!");
while(1)
  sleep(1000);
  //Start / feed Watchdog
  size_t WD_feeding_time = 20; //in s
  state_feed_Watchdog (&WD_feeding_time);

  //Close bzw. sollte niemals hierhin kommen!
  deinit_Soft (&Config_PTR, &SPI_Param);
  exit (0);
}

[Tuxi (Gast)]

So sieht die Gesamte main() momentan aus.

Ich habe einmal nur den einen Thread (4) gestartet und dort passt alles.
Dann habe ich einmal nur Thread (5) gestartet und da ist dann der Zeiger 
auf Config_PTR innerhalb des Thread_Struct ganz woanders wo natürlich 
nur mist drin steht..

Obwohl ja beides mal der Code sehr ähnlich bzw. gleich ist.

Läuft übrigens unter Embedded Linux.

[Achim K. (aks)]

Mit oder ohne Optimierung compiliert?

[Karl H. (kbuchegg)]

Tuxi schrieb:

Zeig mal deine init_Soft.

Bei so etwas

>

>   Config * Config_PTR = NULL;
>   SPI_Par * SPI_Param = NULL;
>   //Initialisierung
>   init_Soft (&Config_PTR, &SPI_Param);

>

hab ich ein ganz schlechtes Bauchgefühl. Wozu die Adressen der Pointer 
übergeben? Normalerweise würde man in main einfach Strukturobjekte 
anlegen, deren Adressen an init_Soft übergeben, die dann die relevanten 
Informationen in die Strukturobjekte schreibt und gut ists. Wenn 
init_Soft aber die Adresse der Pointer kriegt, dann murmelt mein 
Bauchgefühl 'Der hat da sicher die Adresse von funktionslokalen 
Variablen in die Pointer geschrieben und wundert sich, dass die Objekte 
nicht mehr regulär existieren, nachdem die Funktion verlassen wurde'.

[Tuxi (Gast)]

//Struct mit allen nötigen Konfigurations Parametern!
struct Config_Var
{
  volatile int_least8_t SD_Only; //Flag wenn nur auf SD-Card
.
.
.
. 
  volatile char Junk_Folder[MAX];
  volatile char time_buffer[MAX];
  volatile char Flashed_Firmware[MAX];
  volatile pid_t UMTS_PID;
};
typedef struct Config_Var Config;

struct SPI_Parameter
{
  volatile char device[MAX];
  volatile int fd;
  volatile uint_least8_t mode;
  volatile uint_least8_t bits;
  volatile uint32_t speed;
  volatile uint16_t delay;
  volatile uint_least8_t cs;
};
typedef struct SPI_Parameter SPI_Par;

struct thread_data
{
  volatile Config * Config_PTR;
  volatile SPI_Par * SPI_Param;
};
typedef struct thread_data Thread;

[Peter II (Gast)]

> pthread_t threads[5];
> &threads[5]

was stimmt hier wohl nicht?

[Achim K. (aks)]

Peter II schrieb:
>> pthread_t threads[5];
>> &threads[5]
>
> was stimmt hier wohl nicht?

Sehr gut gesehen! Dann muss man das mit der Optimierung nicht mehr 
untersuchen ;-).

[Tuxi (Gast)]

void
init_Soft (Config ** Config_PTR, SPI_Par ** SPI_Param)
{
  
  *Config_PTR = start_param ();
  init_param (*Config_PTR);
  *SPI_Param = init_SPI ("/dev/spidev1.0", SPI_MODE_1, 16, 10000, 0, 1);
  //Not send Data?
  Config * TMP = *Config_PTR;
  if (not_send_Data_there ())
    TMP->Not_send_Data = 1;
  else
    TMP->Not_send_Data = 0;
}

Config *
start_param ()
{
  Config * Config_PTR = NULL;
  Config_PTR = (Config *) malloc (sizeof(Config));
  while (Config_PTR == NULL)
    {
      printf ("No Space left in RAM!");
      Config_PTR = (Config *) malloc (sizeof(Config));
    }
  load_default_param (Config_PTR);
  return (Config_PTR);
}

int_fast8_t
init_param (Config * const Config_PTR)
{
  int_fast8_t Loaded = 0;
  char * Param_Target = build_target (Config_PTR->ParamFile_Path,
                                      Config_PTR->ParamFile_File);
  FILE * Start_Param = NULL;
  Start_Param = fopen (Param_Target, "r");
  free (Param_Target);
  Param_Target = NULL;
  if (Start_Param == NULL) load_default_param (Config_PTR);
  else
    {
      while (Loaded == 0)
        {
          Loaded = load_param_file (Config_PTR, Start_Param);
          if (Loaded == 0)
            {
              load_default_param (Config_PTR);
              break;
            }
        }
    }
  if (Start_Param != NULL)
    {
      fclose (Start_Param);
      Start_Param = NULL;
    }
  return (Loaded);
}

void
load_default_param (Config * const Config_PTR)
{
  Config_PTR->SD_Only = Default_SD_Only_INT;
  Config_PTR->Clean_SD_Messdata = Default_Clean_SD_Messdata_INT;
  Config_PTR->Time_Lap = Default_Time_Lap;
.
.
.
}

int_fast8_t
load_param_file (Config * const Config_PTR, FILE* Start_Param)
{
  int8_t OPTSDONLY = 0, OPTSDCLEAN = 0, OPTTIMELAP = 0, OPTHOSTPORT = 0,
      OPTHOSTIP = 0, OPTUSERSFTP = 0, OPTPWSFTP = 0, OPTMESSPATH = 0,
      OPTFIRMPATH = 0, OPTFIRMFILE = 0, OPTFIRMFILESHA1 = 0, OPTPARAMPATH = 0,
      OPTPARAMFILE = 0, OPTPARAMFILESHA1 = 0,/* OPTPARNAM = 0,*/OPTFIRMNAM = 0;
  const char delim[] =
    { '=', ';' };
  volatile char * TMP = NULL;
  volatile char * TMP2 = NULL;
  volatile char * tok_buf;
  TMP = malloc (sizeof(char) * MAX);
  while (TMP == NULL)
    {
      printf ("No Space left in RAM!");
      TMP = malloc (sizeof(char) * MAX);
    }
  /*tok_buf = malloc(sizeof(char) * MAX);
   while (tok_buf == NULL) {
   printf("No Space left in RAM!");
   tok_buf = malloc(sizeof(char) * MAX);
   }*/
  /* TMP2 = malloc (sizeof(char) * MAX);
   while(TMP"" == NULL)
   {
   printf("No Space left in RAM!");
   TMP2 = malloc (sizeof(char) * MAX);
   }*/
  while (!OPTOK)
    {
      if ((fgets (TMP, (sizeof(char) * MAX), Start_Param) == NULL) && !OPTOK)
        {
          free (TMP);
          TMP = NULL;
          TMP2 = NULL;
          return (0);
        }
      del_n (TMP);
      TMP2 = strtok_r (TMP, delim, &tok_buf);
      if (TMP2 == NULL && !OPTOK)
        {
          printf ("Nothing in Token!\n");
          free (TMP);
          TMP = NULL;
          TMP2 = NULL;
          return (0);
        }
      if (!(strncmp (TMP2, "SDOnly", (sizeof(char) * strnlen ("SDOnly", NMAX)))))
        {
          TMP2 = strtok_r (NULL, delim, &tok_buf);
          if (!(strncmp (TMP2, "YES", (sizeof(char) * strnlen ("YES", NMAX))))) Config_PTR->SD_Only =
              1;
          else if (!(strncmp (TMP2, "NO", (sizeof(char) * strnlen ("NO", NMAX))))) Config_PTR->SD_Only =
              0;
          else Config_PTR->SD_Only = Default_SD_Only_INT;
          OPTSDONLY = 1;
          continue;
        }
      else if (!strncmp (TMP2, "CleanSDMessdata",
                         (sizeof(char) * strnlen ("CleanSDMessdata", NMAX))))
        {
          TMP2 = strtok_r (NULL, delim, &tok_buf);
          if (!(strncmp (TMP2, "YES", (sizeof(char) * strnlen ("YES", NMAX))))) Config_PTR->Clean_SD_Messdata =
              1;
          else if (!(strncmp (TMP2, "NO", (sizeof(char) * strnlen ("NO", NMAX))))) Config_PTR->Clean_SD_Messdata =
              0;
          else Config_PTR->Clean_SD_Messdata = Default_Clean_SD_Messdata_INT;
          OPTSDCLEAN = 1;
          continue;
        }
      else if (!strncmp (TMP2, "TimeLap",
                         (sizeof(char) * strnlen ("TimeLap", NMAX))))
        {
          TMP2 = strtok_r (NULL, delim, &tok_buf);
          Config_PTR->Time_Lap = (uint32_t) atoi (TMP2);
          OPTTIMELAP = 1;
          continue;
        }
.
.
.
}

[Peter II (Gast)]

Achim K. schrieb:
>>> &threads[5]
>>
>> was stimmt hier wohl nicht?
>
> Sehr gut gesehen! Dann muss man das mit der Optimierung nicht mehr
> untersuchen ;-).

ist mir nur aufgefallen weil

&threads[5]

schon selber merkwürdig ist.

[Tuxi (Gast)]

Okay.... habs verrafft...

Danke..

[Peter II (Gast)]

> volatile char * TMP = NULL;

funktionslokale variabel als volatile ist auch wenig sinn.

[Tuxi (Gast)]

Das mit init_Soft und so ist später dazugekommen... Daher ist es leider 
mittlerweile etwas unübersichtlicher geworden...

[Tuxi (Gast)]

Jap, das mit volatile sagt mir mein Compiler bereits.. aber er schluckt 
es..
Werde ich vll irgendwann überall noch rausnehmen.

[Karl H. (kbuchegg)]

Tuxi schrieb:

<C Code für init_Soft und weitere Funktionen>

ein bischen ein malloc Fetischist bist du zwar schon, aber das sieht 
erst mal in Ordnung aus.

[Tuxi (Gast)]

Läuft auch nachdem ich die Thread nochmal korrekt durchnummerriert habe.

Danke für die schnelle Hilfe, das hätte ich wahrscheinlich die nächsten 
3 Stunden überlesen..