Changeset 1523


Ignore:
Timestamp:
Dec 28, 2006, 9:22:32 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Improved zfd_register() and zfd_* function performances.
  • Changed function names here and there.
Location:
zzuf/trunk/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • zzuf/trunk/src/debug.c

    r1504 r1523  
    3131#include "debug.h"
    3232
    33 extern int _zzuf_debug;
     33extern int _zz_hasdebug;
    3434
    35 void zzuf_debug(const char *format, ...)
     35void _zz_debug(const char *format, ...)
    3636{
    3737    va_list args;
    3838    int saved_errno;
    3939
    40     if(!_zzuf_debug)
     40    if(!_zz_hasdebug)
    4141        return;
    4242
  • zzuf/trunk/src/debug.h

    r1480 r1523  
    1717 */
    1818
    19 extern void zzuf_debug(const char *format, ...)
     19extern void _zz_debug(const char *format, ...)
    2020       __attribute__((__format__(__printf__, 1, 2)));
    2121
    22 #define debug zzuf_debug
     22#define debug _zz_debug
    2323
  • zzuf/trunk/src/fuzz.c

    r1520 r1523  
    3636#define MAGIC2 0x783bc31f
    3737
    38 void zzuf_fuzz(int fd, uint8_t *buf, uint64_t len)
     38void _zz_fuzz(int fd, uint8_t *buf, uint64_t len)
    3939{
    4040    uint64_t start, stop;
     
    6060
    6161            /* Add some random dithering to handle ratio < 1.0/CHUNKBYTES */
    62             zzuf_srand(_zzuf_seed ^ chunkseed);
    63             todo = (int)((_zzuf_ratio * (8 * CHUNKBYTES * 1000)
    64                                                 + zzuf_rand(1000)) / 1000.0);
    65             zzuf_srand(_zzuf_seed ^ chunkseed ^ (todo * MAGIC2));
     62            _zz_srand(_zz_seed ^ chunkseed);
     63            todo = (int)((_zz_ratio * (8 * CHUNKBYTES * 1000)
     64                                                + _zz_rand(1000)) / 1000.0);
     65            _zz_srand(_zz_seed ^ chunkseed ^ (todo * MAGIC2));
    6666
    6767            while(todo--)
    6868            {
    69                 unsigned int idx = zzuf_rand(CHUNKBYTES);
    70                 uint8_t byte = (1 << zzuf_rand(8));
     69                unsigned int idx = _zz_rand(CHUNKBYTES);
     70                uint8_t byte = (1 << _zz_rand(8));
    7171
    7272                fuzz->data[idx] ^= byte;
  • zzuf/trunk/src/fuzz.h

    r1470 r1523  
    1717 */
    1818
    19 extern void zzuf_fuzz(int, uint8_t *, uint64_t);
     19extern void _zz_fuzz(int, uint8_t *, uint64_t);
    2020
  • zzuf/trunk/src/libzzuf.c

    r1520 r1523  
    3939
    4040/* Global variables */
    41 int   _zzuf_ready   = 0;
    42 int   _zzuf_debug   = 0;
    43 int   _zzuf_seed    = 0;
    44 float _zzuf_ratio   = 0.004f;
    45 regex_t * _zzuf_include = NULL;
    46 regex_t * _zzuf_exclude = NULL;
    47 
    48 #define MAXFD 1024
    49 struct zzuf
     41int   _zz_ready    = 0;
     42int   _zz_hasdebug = 0;
     43int   _zz_seed     = 0;
     44float _zz_ratio    = 0.004f;
     45regex_t * _zz_include = NULL;
     46regex_t * _zz_exclude = NULL;
     47
     48/* Library initialisation shit */
     49void _zz_init(void)
     50{
     51    char *tmp;
     52
     53    tmp = getenv("ZZUF_DEBUG");
     54    if(tmp && *tmp)
     55        _zz_hasdebug = 1;
     56
     57    tmp = getenv("ZZUF_SEED");
     58    if(tmp && *tmp)
     59        _zz_seed = atol(tmp);
     60
     61    tmp = getenv("ZZUF_RATIO");
     62    if(tmp && *tmp)
     63        _zz_ratio = atof(tmp);
     64    if(_zz_ratio < 0.0f)
     65        _zz_ratio = 0.0f;
     66    else if(_zz_ratio > 5.0f)
     67        _zz_ratio = 5.0f;
     68
     69    tmp = getenv("ZZUF_INCLUDE");
     70    if(tmp && *tmp)
     71    {
     72        _zz_include = malloc(sizeof(*_zz_include));
     73        regcomp(_zz_include, tmp, 0);
     74    }
     75
     76    tmp = getenv("ZZUF_EXCLUDE");
     77    if(tmp && *tmp)
     78    {
     79        _zz_exclude = malloc(sizeof(*_zz_exclude));
     80        regcomp(_zz_exclude, tmp, 0);
     81    }
     82
     83    zfd_init();
     84
     85    _zz_load_fd();
     86    _zz_load_stream();
     87
     88    _zz_ready = 1;
     89
     90    debug("libzzuf initialised");
     91}
     92
     93/* Deinitialisation */
     94void _zz_fini(void)
     95{
     96    zfd_fini();
     97}
     98
     99/* File descriptor stuff */
     100struct files
    50101{
    51102    int managed;
     
    55106    struct fuzz fuzz;
    56107}
    57 files[MAXFD];
    58 
    59 /* Library initialisation shit */
    60 void zzuf_init(void)
    61 {
    62     char *tmp;
     108*files;
     109
     110int *fds;
     111
     112int maxfd, nfiles;
     113
     114void zfd_init(void)
     115{
     116    files = NULL;
     117    nfiles = 0;
     118
     119    /* Start with one fd in the lookup table */
     120    fds = malloc(1 * sizeof(int));
     121    for(maxfd = 0; maxfd < 1; maxfd++)
     122        fds[maxfd] = -1;
     123}
     124
     125void zfd_fini(void)
     126{
    63127    int i;
    64128
    65     tmp = getenv("ZZUF_DEBUG");
    66     if(tmp && *tmp)
    67         _zzuf_debug = 1;
    68 
    69     tmp = getenv("ZZUF_SEED");
    70     if(tmp && *tmp)
    71         _zzuf_seed = atol(tmp);
    72 
    73     tmp = getenv("ZZUF_RATIO");
    74     if(tmp && *tmp)
    75         _zzuf_ratio = atof(tmp);
    76     if(_zzuf_ratio < 0.0f)
    77         _zzuf_ratio = 0.0f;
    78     else if(_zzuf_ratio > 5.0f)
    79         _zzuf_ratio = 5.0f;
    80 
    81     tmp = getenv("ZZUF_INCLUDE");
    82     if(tmp && *tmp)
    83     {
    84         _zzuf_include = malloc(sizeof(*_zzuf_include));
    85         regcomp(_zzuf_include, tmp, 0);
    86     }
    87 
    88     tmp = getenv("ZZUF_EXCLUDE");
    89     if(tmp && *tmp)
    90     {
    91         _zzuf_exclude = malloc(sizeof(*_zzuf_exclude));
    92         regcomp(_zzuf_exclude, tmp, 0);
    93     }
    94 
    95     for(i = 0; i < MAXFD; i++)
    96         files[i].managed = 0;
    97 
    98     zzuf_load_fd();
    99     zzuf_load_stream();
    100 
    101     _zzuf_ready = 1;
    102 
    103     debug("libzzuf initialised");
    104 }
    105 
    106 /* Deinitialisation */
    107 void zzuf_fini(void)
    108 {
    109     int i;
    110 
    111     for(i = 0; i < MAXFD; i++)
    112     {
    113         if(!files[i].managed)
     129    for(i = 0; i < maxfd; i++)
     130    {
     131        if(!files[fds[i]].managed)
    114132            continue;
    115133
     
    117135         * closed properly, there's a leak, but it's not our problem. */
    118136    }
    119 }
    120 
    121 /* fd stuff */
     137
     138    free(files);
     139    free(fds);
     140}
     141
    122142int zfd_ismanaged(int fd)
    123143{
    124     return files[fd].managed;
    125 }
    126 
    127 void zfd_manage(int fd)
    128 {
    129     files[fd].managed = 1;
    130     files[fd].pos = 0;
    131     files[fd].fuzz.cur = -1;
    132     files[fd].fuzz.data = malloc(CHUNKBYTES);
    133 }
    134 
    135 void zfd_unmanage(int fd)
    136 {
    137     files[fd].managed = 0;
    138     free(files[fd].fuzz.data);
     144    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     145        return 0;
     146
     147    return 1;
     148}
     149
     150void zfd_register(int fd)
     151{
     152    int i;
     153
     154    if(fd < 0 || fd > 65535 || (fd < maxfd && fds[fd] != -1))
     155        return;
     156
     157    while(fd >= maxfd)
     158    {
     159        fds = realloc(fds, 2 * maxfd * sizeof(int));
     160        for(i = maxfd; i < maxfd * 2; i++)
     161            fds[i] = -1;
     162        maxfd *= 2;
     163    }
     164           
     165    /* Find an empty slot */
     166    for(i = 0; i < nfiles; i++)
     167        if(files[i].managed == 0)
     168            break;
     169
     170    /* No slot found, allocate memory */
     171    if(i == nfiles)
     172    {
     173        nfiles++;
     174        files = realloc(files, nfiles * sizeof(struct files));
     175    }
     176
     177    files[i].managed = 1;
     178    files[i].pos = 0;
     179    files[i].fuzz.cur = -1;
     180    files[i].fuzz.data = malloc(CHUNKBYTES);
     181
     182    fds[fd] = i;
     183}
     184
     185void zfd_unregister(int fd)
     186{
     187    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     188        return;
     189
     190    files[fds[fd]].managed = 0;
     191    free(files[fds[fd]].fuzz.data);
     192
     193    fds[fd] = -1;
    139194}
    140195
    141196long int zfd_getpos(int fd)
    142197{
    143     return files[fd].pos;
     198    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     199        return 0;
     200
     201    return files[fds[fd]].pos;
    144202}
    145203
    146204void zfd_setpos(int fd, long int pos)
    147205{
    148     files[fd].pos = pos;
     206    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     207        return;
     208
     209    files[fds[fd]].pos = pos;
    149210}
    150211
    151212void zfd_addpos(int fd, long int off)
    152213{
    153     files[fd].pos += off;
     214    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     215        return;
     216
     217    files[fds[fd]].pos += off;
    154218}
    155219
    156220struct fuzz *zfd_getfuzz(int fd)
    157221{
    158     return &files[fd].fuzz;
    159 }
    160 
     222    if(fd < 0 || fd >= maxfd || fds[fd] == -1)
     223        return NULL;
     224
     225    return &files[fds[fd]].fuzz;
     226}
     227
  • zzuf/trunk/src/libzzuf.h

    r1520 r1523  
    3030
    3131/* Internal variables */
    32 extern int       _zzuf_ready;
    33 extern int       _zzuf_debug;
    34 extern int       _zzuf_seed;
    35 extern float     _zzuf_ratio;
    36 extern regex_t * _zzuf_include;
    37 extern regex_t * _zzuf_exclude;
     32extern int       _zz_ready;
     33extern int       _zz_hasdebug;
     34extern int       _zz_seed;
     35extern float     _zz_ratio;
     36extern regex_t * _zz_include;
     37extern regex_t * _zz_exclude;
    3838
    3939/* Library initialisation shit */
    40 extern void zzuf_init(void) __attribute__((constructor));
    41 extern void zzuf_fini(void) __attribute__((destructor));
     40extern void _zz_init(void) __attribute__((constructor));
     41extern void _zz_fini(void) __attribute__((destructor));
    4242
    4343/* File descriptor handling */
     44extern void zfd_init(void);
     45extern void zfd_fini(void);
    4446extern int zfd_ismanaged(int);
    45 extern void zfd_manage(int);
    46 extern void zfd_unmanage(int);
     47extern void zfd_register(int);
     48extern void zfd_unregister(int);
    4749extern long int zfd_getpos(int);
    4850extern void zfd_setpos(int, long int);
  • zzuf/trunk/src/load-fd.c

    r1522 r1523  
    5151static int     (*close_orig)   (int fd);
    5252
    53 void zzuf_load_fd(void)
     53void _zz_load_fd(void)
    5454{
    5555    LOADSYM(open);
     
    6565    { \
    6666        int mode = 0; \
    67         if(!_zzuf_ready) \
     67        if(!_zz_ready) \
    6868            LOADSYM(fn); \
    6969        if(oflag & O_CREAT) \
     
    7979            ret = ORIG(fn)(file, oflag); \
    8080        } \
    81         if(!_zzuf_ready) \
     81        if(!_zz_ready) \
    8282            return ret; \
    8383        if(ret >= 0 \
    8484            && ((oflag & (O_RDONLY | O_RDWR | O_WRONLY)) != O_WRONLY)) \
    8585        { \
    86             if(_zzuf_include && \
    87                 regexec(_zzuf_include, file, 0, NULL, 0) == REG_NOMATCH) \
     86            if(_zz_include && \
     87                regexec(_zz_include, file, 0, NULL, 0) == REG_NOMATCH) \
    8888                /* not included: ignore */ ; \
    89             else if(_zzuf_exclude && \
    90                     regexec(_zzuf_exclude, file, 0, NULL, 0) != REG_NOMATCH) \
     89            else if(_zz_exclude && \
     90                    regexec(_zz_exclude, file, 0, NULL, 0) != REG_NOMATCH) \
    9191                /* excluded: ignore */ ; \
    9292            else \
     
    9797                else \
    9898                    debug(STR(fn) "(\"%s\", %i) = %i", file, oflag, ret); \
    99                 zfd_manage(ret); \
     99                zfd_register(ret); \
    100100            } \
    101101        } \
     
    116116    int ret;
    117117
    118     if(!_zzuf_ready)
     118    if(!_zz_ready)
    119119        LOADSYM(read);
    120120    ret = read_orig(fd, buf, count);
    121     if(!_zzuf_ready || !zfd_ismanaged(fd))
     121    if(!_zz_ready || !zfd_ismanaged(fd))
    122122        return ret;
    123123
     
    125125    if(ret > 0)
    126126    {
    127         zzuf_fuzz(fd, buf, ret);
     127        _zz_fuzz(fd, buf, ret);
    128128        zfd_addpos(fd, ret);
    129129    }
     
    138138#define LSEEK(fn, off_t) \
    139139    do { \
    140         if(!_zzuf_ready) \
     140        if(!_zz_ready) \
    141141            LOADSYM(fn); \
    142142        ret = ORIG(fn)(fd, offset, whence); \
    143         if(!_zzuf_ready || !zfd_ismanaged(fd)) \
     143        if(!_zz_ready || !zfd_ismanaged(fd)) \
    144144            return ret; \
    145145        debug(STR(fn)"(%i, %lli, %i) = %lli", \
     
    167167    int ret;
    168168
    169     if(!_zzuf_ready)
     169    if(!_zz_ready)
    170170        LOADSYM(close);
    171171    ret = close_orig(fd);
    172     if(!_zzuf_ready || !zfd_ismanaged(fd))
     172    if(!_zz_ready || !zfd_ismanaged(fd))
    173173        return ret;
    174174
    175175    debug("close(%i) = %i", fd, ret);
    176     zfd_unmanage(fd);
     176    zfd_unregister(fd);
    177177
    178178    return ret;
  • zzuf/trunk/src/load-stream.c

    r1522 r1523  
    5656                                   FILE *stream);
    5757
    58 void zzuf_load_stream(void)
     58void _zz_load_stream(void)
    5959{
    6060    LOADSYM(fopen);
     
    7777    do \
    7878    { \
    79         if(!_zzuf_ready) \
     79        if(!_zz_ready) \
    8080        { \
    8181            LOADSYM(fn); \
     
    8585        if(ret) \
    8686        { \
    87             if(_zzuf_include && \
    88                 regexec(_zzuf_include, path, 0, NULL, 0) == REG_NOMATCH) \
     87            if(_zz_include && \
     88                regexec(_zz_include, path, 0, NULL, 0) == REG_NOMATCH) \
    8989                /* not included: ignore */ ; \
    90             else if(_zzuf_exclude && \
    91                     regexec(_zzuf_exclude, path, 0, NULL, 0) != REG_NOMATCH) \
     90            else if(_zz_exclude && \
     91                    regexec(_zz_exclude, path, 0, NULL, 0) != REG_NOMATCH) \
    9292                /* excluded: ignore */ ; \
    9393            else \
    9494            { \
    9595                int fd = fileno(ret); \
    96                 zfd_manage(fd); \
     96                zfd_register(fd); \
    9797                debug(STR(fn) "(\"%s\", \"%s\") = %p", path, mode, ret); \
    9898            } \
     
    114114    int ret, fd;
    115115
    116     if(!_zzuf_ready)
     116    if(!_zz_ready)
    117117        LOADSYM(fseek);
    118118    fd = fileno(stream);
    119     if(!_zzuf_ready || !zfd_ismanaged(fd))
     119    if(!_zz_ready || !zfd_ismanaged(fd))
    120120        return fseek_orig(stream, offset, whence);
    121121
     
    146146    int fd;
    147147
    148     if(!_zzuf_ready)
     148    if(!_zz_ready)
    149149        LOADSYM(fread);
    150150    fd = fileno(stream);
    151     if(!_zzuf_ready || !zfd_ismanaged(fd))
     151    if(!_zz_ready || !zfd_ismanaged(fd))
    152152        return fread_orig(ptr, size, nmemb, stream);
    153153
     
    161161         * a partial read may have advanced the stream pointer */
    162162        long int newpos = ftell(stream);
    163         zzuf_fuzz(fd, ptr, newpos - pos);
     163        _zz_fuzz(fd, ptr, newpos - pos);
    164164        zfd_setpos(fd, newpos);
    165165    }
     
    170170    do { \
    171171        int fd; \
    172         if(!_zzuf_ready) \
     172        if(!_zz_ready) \
    173173            LOADSYM(fn); \
    174174        fd = fileno(stream); \
    175         if(!_zzuf_ready || !zfd_ismanaged(fd)) \
     175        if(!_zz_ready || !zfd_ismanaged(fd)) \
    176176            return ORIG(fn)(stream); \
    177177        ret = ORIG(fn)(stream); \
     
    179179        { \
    180180            uint8_t ch = ret; \
    181             zzuf_fuzz(fd, &ch, 1); \
     181            _zz_fuzz(fd, &ch, 1); \
    182182            zfd_addpos(fd, 1); \
    183183            ret = ch; \
     
    201201    int i, fd;
    202202
    203     if(!_zzuf_ready)
     203    if(!_zz_ready)
    204204        LOADSYM(fgets);
    205205    fd = fileno(stream);
    206     if(!_zzuf_ready || !zfd_ismanaged(fd))
     206    if(!_zz_ready || !zfd_ismanaged(fd))
    207207        return fgets_orig(s, size, stream);
    208208
     
    225225            }
    226226            s[i] = (char)(unsigned char)ch;
    227             zzuf_fuzz(fd, (uint8_t *)s + i, 1); /* rather inefficient */
     227            _zz_fuzz(fd, (uint8_t *)s + i, 1); /* rather inefficient */
    228228            zfd_addpos(fd, 1);
    229229            if(s[i] == '\n')
     
    244244    int ret, fd;
    245245
    246     if(!_zzuf_ready)
     246    if(!_zz_ready)
    247247        LOADSYM(ungetc);
    248248    fd = fileno(stream);
    249     if(!_zzuf_ready || !zfd_ismanaged(fd))
     249    if(!_zz_ready || !zfd_ismanaged(fd))
    250250        return ungetc_orig(c, stream);
    251251
    252252    zfd_addpos(fd, -1);
    253     zzuf_fuzz(fd, &ch, 1);
     253    _zz_fuzz(fd, &ch, 1);
    254254    ret = ungetc_orig((int)ch, stream);
    255255    if(ret >= 0)
     
    265265    int ret, fd;
    266266
    267     if(!_zzuf_ready)
     267    if(!_zz_ready)
    268268        LOADSYM(fclose);
    269269    fd = fileno(fp);
    270     if(!_zzuf_ready || !zfd_ismanaged(fd))
     270    if(!_zz_ready || !zfd_ismanaged(fd))
    271271        return fclose_orig(fp);
    272272
    273273    ret = fclose_orig(fp);
    274274    debug("fclose(%p) = %i", fp, ret);
    275     zfd_unmanage(fd);
     275    zfd_unregister(fd);
    276276
    277277    return ret;
     
    283283        ssize_t done, size; \
    284284        int fd, finished = 0; \
    285         if(!_zzuf_ready) \
     285        if(!_zz_ready) \
    286286            LOADSYM(fn); \
    287287        fd = fileno(stream); \
    288         if(!_zzuf_ready || !zfd_ismanaged(fd)) \
     288        if(!_zz_ready || !zfd_ismanaged(fd)) \
    289289            return getdelim_orig(lineptr, n, delim, stream); \
    290290        line = *lineptr; \
     
    312312            { \
    313313                unsigned char c = ch; \
    314                 zzuf_fuzz(fd, &c, 1); /* even more inefficient */ \
     314                _zz_fuzz(fd, &c, 1); /* even more inefficient */ \
    315315                line[done++] = c; \
    316316                zfd_addpos(fd, 1); \
  • zzuf/trunk/src/load.h

    r1494 r1523  
    2727    } while(0)
    2828
    29 extern void zzuf_load_fd(void);
    30 extern void zzuf_load_stream(void);
     29extern void _zz_load_fd(void);
     30extern void _zz_load_stream(void);
    3131
  • zzuf/trunk/src/random.c

    r1484 r1523  
    2828#include "random.h"
    2929
    30 void zzuf_srand(uint32_t seed)
     30void _zz_srand(uint32_t seed)
    3131{
    3232    srand(seed ^ 0x12345678);
    3333}
    3434
    35 uint32_t zzuf_rand(uint32_t max)
     35uint32_t _zz_rand(uint32_t max)
    3636{
    3737    if(max <= RAND_MAX)
  • zzuf/trunk/src/random.h

    r1484 r1523  
    1717 */
    1818
    19 void zzuf_srand(uint32_t);
    20 uint32_t zzuf_rand(uint32_t);
     19void _zz_srand(uint32_t);
     20uint32_t _zz_rand(uint32_t);
    2121
Note: See TracChangeset for help on using the changeset viewer.