Quelle taille dois-je prévoir pour strerror_r?

Avoir une assez grande statique limite est probablement assez bon pour toutes les situations.
Si vous avez vraiment besoin pour obtenir l'intégralité du message d'erreur, vous pouvez utiliser le Version GNU de strerror_r, ou vous pouvez utiliser la version standard
et sondage avec successivement plus grands tampons jusqu'à ce que vous obtenez ce que vous avez besoin. Par exemple,
vous pouvez utiliser quelque chose comme le code ci-dessous.

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Call strerror_r and get the full error message. Allocate memory for the
 * entire string with malloc. Return string. Caller must free string.
 * If malloc fails, return NULL.
 */
char *all_strerror(int n)
{
    char *s;
    size_t size;

    size = 1024;
    s = malloc(size);
    if (s == NULL)
        return NULL;

    while (strerror_r(n, s, size) == -1 && errno == ERANGE) {
        size *= 2;
        s = realloc(s, size);
        if (s == NULL)
            return NULL;
    }

    return s;
}

int main(int argc, char **argv)
{
    for (int i = 1; i < argc; ++i) {
        int n = atoi(argv[i]);
        char *s = all_strerror(n);
        printf("[%d]: %s\n", n, s);
        free(s);
    }

    return 0;
}

Ce programme (exécuter en ligne (comme C++) ici (d'ailleurs, quelqu'un sait comment faire pour compiler pur C en ligne?):

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main(){
        const int limit = 5;
        int unknowns = 0;
        int maxlen = 0;
        int i=0; char* s = strerror(i);
        while(1){
            if (maxlen<strlen(s)) maxlen = strlen(s);
            if (/*BEGINS WITH "Unknown "*/ 0==strncmp("Unknown ", s , sizeof("Unknown ")-1) )
                unknowns++;
            printf("%.3d\t%s\n", i, s);
            i++; s=strerror(i);
            if ( limit == unknowns ) break;
        }
        printf("Max: %d\n", maxlen);
        return 0;
}

listes et imprime toutes les erreurs sur le système et de garder une trace de la longueur maximale. Par les regards de celui-ci, la longueur ne dépasse pas 49 caractères (pur strlen's sans \0) donc avec une certaine marge de manœuvre, 64-100 devrait être plus que suffisant.

Je suis curieux de savoir si l'ensemble de la taille de la mémoire tampon de négociation ne pouvait pas simplement être évitée par un retour aux structures et s'il y a une raison fondamentale pour ne pas revenir les structures. Donc je comparés:

#define _POSIX_C_SOURCE 200112L //or else the GNU version of strerror_r gets used
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

typedef struct { char data[64]; } error_str_t;
error_str_t strerror_reent(int errn) __attribute__((const));
error_str_t strerror_reent(int errn){
    error_str_t ret;
    strerror_r(errn, ret.data, sizeof(ret));
    return ret;
}


int main(int argc, char** argv){
    int reps = atoi(argv[1]);
    char buf[64];
    volatile int errn = 1;
    for(int i=0; i<reps; i++){
#ifdef VAL
        error_str_t err = strerror_reent(errn);
#else
        strerror_r(errn, buf, 64);
#endif
    }
    return 0;
}

et la différence de performance entre les deux au -O2 est minime:

gcc -O2 : The VAL version is slower by about 5%
g++ -O2 -x c++ : The VAL version is faster by about 1% than the standard version compiled as C++ and by about 4% faster than the standard version compiled as C (surprisingly, even the slower C++ version beats the faster C version by about 3%).

En tout cas, je pense que c'est extrêmement bizarre que strerror est même permis de thread dangereux. Ces chaînes renvoyées doivent être des pointeurs vers des chaînes de caractères littérales. (Merci de m'éclairer, mais je ne peux pas penser à un cas où ils devraient être synthétisés à l'exécution). Et les littéraux de chaîne sont, par définition, en lecture seule et l'accès à la lecture seule des données est toujours thread-safe.