pThreads mit Echtzeit-Priorität

Question

Ich brauche einen Pool von Threads mit unterschiedlichen Prioritäten zu verwalten, so schrieb ich die folgende Threads Startprozedur:

static 
int startup(thrd_t *thrd, thrd_sync_t *sync, int prio) 
{ 
    pthread_attr_t attr; 
    int err; 
    struct sched_param param = { 
     .sched_priority = prio 
    }; 

    assert(pthread_attr_init(&attr) == 0); 
    assert(pthread_attr_setschedpolicy(&attr, SCHED_FIFO) == 0); 
    assert(pthread_attr_setschedparam(&attr, &param) == 0); 
    err = pthread_create(&thrd->handler, &attr, thread_routine, (void *)thrd); 
    pthread_attr_destroy(&attr); 

    return err; 
} 

Im Prinzip ist der unprivilegierten Benutzer soll nicht diesen Code auszuführen erlaubt sein: Der Aufruf pthread_create() sollte EPERM zurückliefern, da der Thread mit hoher Priorität ausgeführt wird.

Unerwartet funktioniert es für den normalen Benutzer, aber es respektiert die gegebene Priorität überhaupt nicht.

Ich habe versucht, den Code zu ändern, indem die pthread_attr_t zu entfernen und durch die Einplanung Attribut Einstellung, wenn der Thread erstellt wurde:

static 
int startup(thrd_t *thrd, thrd_sync_t *sync, int prio) 
{ 
    pthread_attr_t attr; 
    int err; 
    struct sched_param param = { 
     .sched_priority = prio 
    }; 

    err = pthread_create(&thrd->handler, NULL /*&attr*/, thread_routine, 
         (void *)thrd); 
    if (err != 0) return err; 

    err = pthread_setschedparam(thrd->handler, SCHED_FIFO, &param); 
    if (err != 0) return err; 

    return err; 
} 

Dieser Ansatz durch die Art und Weise schwierig ist, viel mehr zu verwalten, da im Fall von Fehler Ich muss den neu erstellten Thread beenden. Zumindest scheint es in Bezug auf Berechtigungsanforderungen korrekt zu funktionieren (nur root kann dies ausführen), aber die Prioritäten werden nicht eingehalten.

Mache ich etwas falsch?

EDIT

Ich habe soeben das folgende Stück Code, die von jedem Thread ausgeführt wird:

static 
void getinfo() 
{ 
    struct sched_param param; 
    int policy; 

    sched_getparam(0, &param); 
    DEBUG_FMT("Priority of this process: %d", param.sched_priority); 

    pthread_getschedparam(pthread_self(), &policy, &param); 

    DEBUG_FMT("Priority of the thread: %d, current policy is: %d and should be %d", 
       param.sched_priority, policy, SCHED_FIFO); 
} 

Bei der ersten Methode (nämlich pthread_attr_t Ansatz) es stellt sich heraus, dass der pthread_attr_setschedpolicy ist absolut nicht effektiv, da die Priorität 0 ist und die Richtlinie nicht SCHED_FIFO ist.

Mit der zweiten Methode (nämlich pthread_setschedparam Ansatz) druckt die Funktion die erwarteten Daten, aber die Ausführung verhält sich falsch.

Answer 1

Ich denke, Sie müssen auch pthread_attr_setinheritsched verwenden, um sicherzustellen, dass Ihre Änderungen an der Prioritätseinstellung berücksichtigt werden. Aus der Manpage:

PTHREAD_INHERIT_SCHED Gibt an, dass die Planungsrichtlinie und die zugehörigen Attribute sind von der Erstellung Thread vererbt werden, und die Scheduling-Attribut in diesem attr Argumente ist ignoriert werden.

PTHREAD_EXPLICIT_SCHED Gibt an, dass die Planungsrichtlinie und zugehörigen Attribute sind auf die entsprechenden Werte von diesem Attribut-Objekt gesetzt werden.

Und ein wenig weiter in der Manpage, Sie haben:

Die Standardeinstellung des inherit-Scheduler-Attribut in einem neu initialisiert Thread-Attribute Objekt PTHREAD_INHERIT_SCHED wird.