fadvise.c

   1 #include "compat-util.h"
   2
   3 static struct fa_advice {
   4         const char *name;
   5         const int nr;
   6 } advice_table[] = {
   7         { "normal", POSIX_FADV_NORMAL },
   8         { "sequential", POSIX_FADV_SEQUENTIAL },
   9         { "random", POSIX_FADV_RANDOM },
  10         { "noreuse", POSIX_FADV_NOREUSE },
  11         { "willneed", POSIX_FADV_WILLNEED },
  12         { "dontneed" , POSIX_FADV_DONTNEED }
  13 };
  14
  15 static void apply_fadvise(const char *path, off_t offset, off_t len, int advice)
  16 {
  17         int fd;
  18
  19         if ((fd = open(path, O_RDONLY)) < 0) {
  20                 fprintf(stderr, "%s: open(): %s\n", path, strerror(errno));
  21                 return;
  22         }
  23
  24         if (len <= 0) {
  25                 /* for compatibility with kernels < 2.6.6 */
  26                 struct stat sb;
  27
  28                 if (fstat(fd, &sb) < 0) {
  29                         fprintf(stderr, "%s: fstat(%d): %s\n",
  30                                 path, fd, strerror(errno));
  31                         goto out;
  32                 }
  33                 len = sb.st_size;
  34         }
  35
  36         if (posix_fadvise(fd, offset, len, advice) < 0)
  37                 fprintf(stderr,
  38                         "%s: posix_fadvise("
  39                         "offset=%lu,len=%lu,advice=%d): %s\n",
  40                         path,
  41                         (unsigned long)offset,
  42                         (unsigned long)len,
  43                         advice, strerror(errno));
  44
  45 out:
  46         close(fd);
  47 }
  48
  49 int main(int argc, char * const argv[])
  50 {
  51         off_t offset = 0;
  52         off_t len = 0;
  53         int advice = POSIX_FADV_NORMAL;
  54         int opt;
  55         int argi = 1;
  56
  57         while ((opt = getopt(argc, argv, "o:l:a:")) != -1) {
  58                 int i;
  59                 char *err;
  60
  61                 argi += 2;
  62                 switch(opt) {
  63                 case 'o':
  64                         offset = strtol(optarg, &err, 10);
  65                         if (*err || offset < 0) {
  66                                 fprintf(stderr, "offset must be >= 0\n");
  67                                 return 1;
  68                         }
  69                         break;
  70                 case 'l':
  71                         len = strtol(optarg, &err, 10);
  72                         if (*err || len < 0) {
  73                                 fprintf(stderr, "length must be >= 0\n");
  74                                 return 1;
  75                         }
  76                         break;
  77                 case 'a':
  78                         for (i = 0; i < ARRAY_SIZE(advice_table); ++i) {
  79                                 if (strcmp(advice_table[i].name, optarg))
  80                                         continue;
  81                                 advice = advice_table[i].nr;
  82                                 break;
  83                         }
  84                         if (i < ARRAY_SIZE(advice_table))
  85                                 break;
  86                         fprintf(stderr, "advice '%s' not understood\n", optarg);
  87                         /* fall-through */
  88                 default:
  89                         fprintf(stderr,
  90                                 "Usage: %s [-a advice] [-o offset] "
  91                                 "[-l length] <files>\n", argv[0]);
  92                         fprintf(stderr, "\nPossible values for advice:\n");
  93                         for (i = 0; i < ARRAY_SIZE(advice_table); ++i)
  94                                 fprintf(stderr, "\t%s\n", advice_table[i].name);
  95                         return 1;
  96                 }
  97         }
  98
  99         for (; argi < argc; ++argi)
 100                 apply_fadvise(argv[argi], offset, len, advice);
 101         return 0;
 102 }