fadvise/fadvise.c

   1 /******************************************************************************
   2  * fadvise.c
   3  *****************************************************************************/
   4
   5 #define _GNU_SOURCE
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <fcntl.h>
  12 #include <stdarg.h>
  13 #include <dlfcn.h>
  14
  15 #include "fadvise.h"
  16
  17 static real_close_t real_close;
  18 static real_write_t real_write;
  19 static real_read_t real_read;
  20
  21 static real_fclose_t real_fclose;
  22 static real_fwrite_t real_fwrite;
  23 static real_fread_t real_fread;
  24 static real_fwrite_t real_fwrite_unlocked;
  25 static real_fread_t real_fread_unlocked;
  26
  27 static pid_t mypid;
  28
  29 static int fadvise_init_done=0;
  30 static int fadvise_debug=0;
  31 static int fadvise_advice=POSIX_FADV_DONTNEED;
  32
  33 void do_log(char *str, ...)
  34 {
  35     va_list arglist;
  36
  37     va_start(arglist, str);
  38     vfprintf(stderr, str, arglist);
  39     fflush(stderr);
  40     va_end(arglist);
  41 } /* do_log() */
  42
  43
  44
  45 static void lib_init(void)
  46 {
  47     char *temp;
  48
  49     if(fadvise_init_done) return;
  50     fadvise_init_done=1;
  51
  52     *(void **) (&real_close) = dlsym(RTLD_NEXT, "close");
  53     if(!real_close)
  54     {
  55         fprintf(stderr, "(fadvise) Cannot load symbol 'close' %s\n", dlerror());
  56         _exit(1);
  57     }
  58     *(void **) (&real_write) = dlsym(RTLD_NEXT, "write");
  59     if(!real_write)
  60     {
  61         fprintf(stderr, "(fadvise) Cannot load symbol 'write' %s\n", dlerror());
  62         _exit(1);
  63     }
  64     *(void **) (&real_read) = dlsym(RTLD_NEXT, "read");
  65     if(!real_read)
  66     {
  67         fprintf(stderr, "(fadvise) Cannot load symbol 'read' %s\n", dlerror());
  68         _exit(1);
  69     }
  70     *(void **) (&real_fclose) = dlsym(RTLD_NEXT, "fclose");
  71     if(!real_fclose)
  72     {
  73         fprintf(stderr, "(fadvise) Cannot load symbol 'fclose' %s\n", dlerror());
  74         _exit(1);
  75     }
  76     *(void **) (&real_fwrite) = dlsym(RTLD_NEXT, "fwrite");
  77     if(!real_fwrite)
  78     {
  79         fprintf(stderr, "(fadvise) Cannot load symbol 'fwrite' %s\n", dlerror());
  80         _exit(1);
  81     }
  82     *(void **) (&real_fread) = dlsym(RTLD_NEXT, "fread");
  83     if(!real_fread)
  84     {
  85         fprintf(stderr, "(fadvise) Cannot load symbol 'fread' %s\n", dlerror());
  86         _exit(1);
  87     }
  88     *(void **) (&real_fwrite_unlocked) = dlsym(RTLD_NEXT, "fwrite_unlocked");
  89     if(!real_fwrite_unlocked)
  90     {
  91         fprintf(stderr, "(fadvise) Cannot load symbol 'fwrite_unlocked' %s\n", dlerror());
  92         _exit(1);
  93     }
  94     *(void **) (&real_fread_unlocked) = dlsym(RTLD_NEXT, "fread_unlocked");
  95     if(!real_fread_unlocked)
  96     {
  97         fprintf(stderr, "(fadvise) Cannot load symbol 'fread_unlocked' %s\n", dlerror());
  98         _exit(1);
  99     }
 100
 101     temp = getenv("FADVISE_ADVICE"); if(!temp) temp = getenv("FADV");
 102     if(temp)
 103     {
 104         if(strcasestr(temp, "NORM")) fadvise_advice = POSIX_FADV_NORMAL;
 105         else if(strcasestr(temp, "SEQ")) fadvise_advice = POSIX_FADV_SEQUENTIAL;
 106         else if(strcasestr(temp, "RAND")) fadvise_advice = POSIX_FADV_RANDOM;
 107         else if(strcasestr(temp, "NORE")) fadvise_advice = POSIX_FADV_NOREUSE;
 108         else if(strcasestr(temp, "WILL")) fadvise_advice = POSIX_FADV_WILLNEED;
 109         else if(strcasestr(temp, "DONT")) fadvise_advice = POSIX_FADV_DONTNEED;
 110     }
 111
 112 #ifndef NDEBUG
 113     temp = getenv("FADVISE_DEBUG"); if(!temp) temp = getenv("FADD");
 114     if(temp) fadvise_debug = strtoul(temp, NULL, 10);
 115 #endif /* NDEBUG */
 116
 117
 118 } /* lib_init() */
 119
 120
 121
 122 ssize_t write(int fd, const void *buf, size_t count)
 123 {
 124     ssize_t ret;
 125     off_t pos;
 126
 127     DEBUG("write(%d, ,%u)\n", fd, count);
 128     if(!fadvise_init_done) lib_init();
 129
 130     ret = real_write(fd, buf, count);
 131
 132     if(ret > 0)
 133     {
 134         pos = lseek(fd, 0, SEEK_CUR);
 135         if((off_t)-1 == pos) pos = 0;
 136         posix_fadvise(fd, 0, pos, fadvise_advice);
 137     }
 138
 139     return ret;
 140 }
 141
 142
 143
 144 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
 145 {
 146     size_t ret;
 147     off_t pos;
 148
 149     DEBUG("fwrite(, %u, %u, %d)\n", size, nmemb, stream ? fileno(stream) : -1);
 150     if(!fadvise_init_done) lib_init();
 151
 152     ret = real_fwrite(ptr, size, nmemb, stream);
 153
 154     if(ret > 0)
 155     {
 156         pos = (long) ftell(stream);
 157         if(-1 == pos) pos = 0;
 158         posix_fadvise(fileno(stream), 0, pos, fadvise_advice);
 159     }
 160
 161     return ret;
 162 }
 163
 164
 165
 166 size_t fwrite_unlocked(const void *ptr, size_t size, size_t nmemb, FILE *stream)
 167 {
 168     size_t ret;
 169     off_t pos;
 170
 171     DEBUG("fwrite_unlocked(, %u, %u, %d)\n", size, nmemb, stream ? fileno(stream) : -1);
 172     if(!fadvise_init_done) lib_init();
 173
 174     ret = real_fwrite_unlocked(ptr, size, nmemb, stream);
 175
 176     if(ret > 0)
 177     {
 178         pos = (long) ftell(stream);
 179         if(-1 == pos) pos = 0;
 180         posix_fadvise(fileno(stream), 0, pos, fadvise_advice);
 181     }
 182
 183     return ret;
 184 }
 185
 186
 187
 188 ssize_t read(int fd, void *buf, size_t count)
 189 {
 190     ssize_t ret;
 191     off_t pos;
 192
 193     DEBUG("read(%d, ,%u)\n", fd, count);
 194     if(!fadvise_init_done) lib_init();
 195
 196     ret = real_read(fd, buf, count);
 197
 198     if(ret > 0)
 199     {
 200         pos = lseek(fd, 0, SEEK_CUR);
 201         if((off_t)-1 == pos) pos = 0;
 202         posix_fadvise(fd, 0, pos, fadvise_advice);
 203     }
 204
 205     return ret;
 206 }
 207
 208
 209
 210 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
 211 {
 212     size_t ret;
 213     off_t pos;
 214
 215     DEBUG("fread(, %u, %u, %d)\n", size, nmemb, stream ? fileno(stream) : -1);
 216     if(!fadvise_init_done) lib_init();
 217
 218     ret = real_fread(ptr, size, nmemb, stream);
 219
 220     if(ret > 0)
 221     {
 222         pos = (long) ftell(stream);
 223         if(-1 == pos) pos = 0;
 224         posix_fadvise(fileno(stream), 0, pos, fadvise_advice);
 225     }
 226
 227     return ret;
 228 }
 229
 230
 231
 232 size_t fread_unlocked(void *ptr, size_t size, size_t nmemb, FILE *stream)
 233 {
 234     size_t ret;
 235     off_t pos;
 236
 237     DEBUG("fread_unlocked(, %u, %u, %d)\n", size, nmemb, stream ? fileno(stream) : -1);
 238     if(!fadvise_init_done) lib_init();
 239
 240     ret = real_fread_unlocked(ptr, size, nmemb, stream);
 241
 242     if(ret > 0)
 243     {
 244         pos = (long) ftell(stream);
 245         if(-1 == pos) pos = 0;
 246         posix_fadvise(fileno(stream), 0, pos, fadvise_advice);
 247     }
 248
 249     return ret;
 250 }
 251
 252
 253
 254
 255 int close(int fd)
 256 {
 257     off_t pos;
 258
 259     DEBUG("close(%d)\n", fd);
 260     if(!fadvise_init_done) lib_init();
 261
 262     pos = lseek(fd, 0, SEEK_CUR);
 263     if((off_t)-1 == pos) pos = 0;
 264     posix_fadvise(fd, 0, pos, fadvise_advice);
 265     return real_close(fd);
 266 }
 267
 268
 269
 270 int fclose(FILE *fp)
 271 {
 272     off_t pos;
 273
 274     DEBUG("fclose(%d)\n", fp ? fileno(fp) : -1);
 275     if(!fadvise_init_done) lib_init();
 276
 277     pos = (long) ftell(fp);
 278     if(-1 == pos) pos = 0;
 279     posix_fadvise(fileno(fp), 0, pos, fadvise_advice);
 280     return real_fclose(fp);
 281 }
 282
 283