src/makeextents.c

   1 /*
   2  * Copyright (c) 2000-2004 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 /*
  20  * Write a bunch of holes to create a bunch of extents.
  21  */
  22
  23 #include "global.h"
  24
  25 char *progname;
  26 __uint64_t num_holes = 1000;
  27 __uint64_t curr_holes;
  28 int verbose_opt = 0;
  29 char *filename;
  30 int status_num = 100;
  31 int wsync;
  32 int preserve;
  33 unsigned int blocksize;
  34 __uint64_t fileoffset;
  35
  36 #define JUMP_SIZE (128 * 1024)
  37 #define NUMHOLES_TO_SIZE(i) (i * JUMP_SIZE)
  38 #define SIZE_TO_NUMHOLES(s) (s / JUMP_SIZE)
  39
  40 void
  41 usage(void)
  42 {
  43         fprintf(stderr, "%s [-b blocksize] [-n num-holes] [-s status-num]"
  44                         " [-o start-offset] [-vwp] file\n", progname);
  45         exit(1);
  46 }
  47
  48 int
  49 main(int argc, char *argv[])
  50 {
  51         int c;
  52         int fd;
  53         int oflags;
  54         __uint64_t i;
  55         __uint64_t offset;
  56         int blocksize = 512;
  57         unsigned char *buffer = NULL;
  58         struct stat stat;
  59
  60         progname = argv[0];
  61
  62         while ((c = getopt(argc, argv, "b:n:o:ps:vw")) != -1) {
  63                 switch (c) {
  64                 case 'b':
  65                         blocksize = atoi(optarg);
  66                         break;
  67                 case 'n':
  68                         num_holes = atoll(optarg);
  69                         break;
  70                 case 'v':
  71                         verbose_opt = 1;
  72                         break;
  73                 case 'w':
  74                         wsync = 1;
  75                         break;
  76                 case 'p':
  77                         preserve = 1;
  78                         break;
  79                 case 's':
  80                         status_num = atoi(optarg);
  81                         break;
  82                 case 'o':
  83                         fileoffset = strtoull(optarg, NULL, 16);
  84                         break;
  85                 case '?':
  86                         usage();
  87                 }
  88         }
  89         if (optind == argc-1)
  90                 filename = argv[optind];
  91         else
  92                 usage();
  93
  94         buffer = malloc(blocksize);
  95         if (buffer == NULL) {
  96             fprintf(stderr, "%s: blocksize to big to allocate buffer\n", progname);
  97             return 1;
  98         }
  99
 100         oflags = O_RDWR | O_CREAT;
 101         oflags |=   (preserve ? 0 : O_TRUNC) |
 102                     (wsync ? O_SYNC : 0);
 103
 104         if ((fd = open(filename, oflags, 0666)) < 0) {
 105                 perror("open");
 106                 return 1;
 107         }
 108
 109         if (fstat(fd, &stat) < 0) {
 110                 perror("stat");
 111                 return 1;
 112         }
 113         if (preserve) {
 114                 curr_holes = SIZE_TO_NUMHOLES(stat.st_size);
 115                 if (num_holes < curr_holes) {
 116                         /* we need to truncate back */
 117                         if (ftruncate(fd, NUMHOLES_TO_SIZE(num_holes)) < 0) {
 118                                 perror("ftruncate");
 119                                 return 1;
 120                         }
 121                         if (verbose_opt) {
 122                                 printf("truncating back to %llu\n",
 123                                        (unsigned long long)
 124                                         NUMHOLES_TO_SIZE(num_holes));
 125                         }
 126                         return 0;
 127                 }
 128         }
 129         else {
 130                 curr_holes = 0;
 131         }
 132         if (curr_holes != 0 && verbose_opt) {
 133                 printf("creating %llu more holes\n",
 134                         (unsigned long long)num_holes - curr_holes);
 135         }
 136
 137         /* create holes by seeking and writing */
 138         for (i = curr_holes; i < num_holes; i++) {
 139
 140                 offset = NUMHOLES_TO_SIZE(i) + fileoffset;
 141
 142                 if (lseek64(fd, offset, SEEK_SET) < 0) {
 143                         perror("lseek");
 144                         return 1;
 145                 }
 146
 147                 if (write(fd, buffer, blocksize) < blocksize) {
 148                         perror("write");
 149                         return 1;
 150                 }
 151
 152                 if (verbose_opt && ((i+1) % status_num == 0)) {
 153                         printf("seeked and wrote %llu times\n",
 154                                 (unsigned long long)i + 1);
 155                 }
 156         }
 157
 158         close(fd);
 159
 160         return 0;
 161 }