src/fill2.c

   1 /*
   2  * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33
  34 /*
  35  * fill2:
  36  *   Derived from fill.c, adds command line options, block boundary marking
  37  *   and allows me to tweak to suit fill2fs without breaking other qa tests.
  38  *   This version marks block boundaries (512, 1k, 4k and 16k) within the file
  39  *   using characters guaranteed not to appear anywhere else, this may allow
  40  *   simple checks in future which can inspect these offsets and ensure one of
  41  *   of the four characters is present. Also fixes off-by-one error in fill.c
  42  *   and is more careful about checking when write operations fail - this is
  43  *   needed by fill2fs to ensure that the number of bytes written is accurately
  44  *   determined.
  45  *
  46  *   To compile standalone on IRIX: cc -DTOOL_ONLY -o fill2 fill2.c -lgen
  47  *
  48  *   $Id$
  49  */
  50
  51 #include <stdio.h>
  52 #include <string.h>
  53 #include <stdlib.h>
  54 #include <errno.h>
  55 #include <unistd.h>
  56 #include <libgen.h>
  57 #include <assert.h>
  58
  59 #ifndef TOOL_ONLY
  60 #include <platform_defs.h>
  61 #else
  62 #define constpp char * const *
  63 #endif /* TOOL_ONLY */
  64
  65 #define N(x) (sizeof(x)/sizeof(x[0]))
  66
  67 /* function prototypes */
  68 static void illegal(char *, char *);
  69 static void reqval(char, char * [], int);
  70 static void respec(char, char * [], int);
  71 static void unknown(char, char *);
  72 static void usage(void);
  73 static char *progname;
  74
  75 char *dopts[] =         { "nbytes", "linelength", "seed", "file", NULL };
  76 enum                    { D_NBYTES, D_LINELENGTH, D_SEED, D_FILE, D_ISSET, D_NUM };
  77 int dflags[D_NUM] =     { 0 };
  78 char *bopts[] =         { "512", "1k", "4k", "16k" };
  79 enum                    { B_512, B_1K, B_4K, B_16K, B_ISSET, B_NUM };
  80 int bflags[B_NUM] =     { 0 };
  81
  82
  83 /*
  84  * block boundaries
  85  *
  86  */
  87
  88 /* block boundaries which should be flagged in the output file */
  89 /* flag is the character that should be used to indicate each type */
  90 /* of block boundary */
  91
  92
  93 struct s_block_type {
  94     int mark;
  95     int size;
  96     char flag;
  97 };
  98
  99 static struct s_block_type btypes[] = {
 100     { 0, 512, '!' },    /* 512 */
 101     { 0, 1024, '"' },   /* 1k */
 102     { 0, 4096, '#' },   /* 4k */
 103     { 0, 16384, '$' },  /* 16k */
 104 };
 105
 106 /*
 107  * main
 108  *
 109  */
 110
 111 int
 112 main(int argc, char **argv)
 113 {
 114     int                 status = 0;     /* return status */
 115     int                 c;              /* current option character */
 116     char                *p;             /* for getsubopt calls */
 117     long                nbytes;         /* total number of bytes to write */
 118     int                 dlen;           /* length of normal output data line */
 119     const char          *dseed = NULL;  /* input string for seeding rand */
 120     unsigned int        seed;           /* seed for output data */
 121     char                *dfile = NULL;  /* where to write output */
 122
 123     FILE                *f;             /* output file */
 124     char                *dbuf;          /* output line buffer */
 125     char                bbuf[50];       /* block boundary string */
 126     char                *active = NULL; /* active buffer to copy out of */
 127     size_t              hlen;           /* header length (bytes+key) in output */
 128                                         /* lines */
 129     char                *hptr;          /* pointer to end of header */
 130     char                *ptr;           /* current position to copy from */
 131     int                 blktype = 0;    /* current block boundary type */
 132     int                 boundary;       /* set if current output char lies on */
 133                                         /* block boundary */
 134     long                i;
 135     int                 j;
 136     int                 l = 0;
 137
 138
 139     /* defaults */
 140     progname = basename(argv[0]);
 141     nbytes = 1024 * 1024;
 142     dlen = 73;  /* includes the trailing newline */
 143
 144     while ((c = getopt(argc, argv, "d:b:")) != EOF) {
 145         switch (c) {
 146         case 'd':
 147             if (dflags[D_ISSET])
 148                 respec('d', NULL, 0);
 149             dflags[D_ISSET] = 1;
 150
 151             p = optarg;
 152             while (*p != '\0') {
 153                 char *value;
 154                 switch (getsubopt(&p, (constpp)dopts, &value)) {
 155                 case D_NBYTES:
 156                     if (! value) reqval('d', dopts, D_NBYTES);
 157                     if (dflags[D_NBYTES]) respec('d', dopts, D_NBYTES);
 158                     dflags[D_NBYTES] = 1;
 159                     nbytes = strtol(value, &ptr, 10);
 160                     if (ptr == value) illegal(value, "d nbytes");
 161                     break;
 162
 163                 case D_LINELENGTH:
 164                     if (! value) reqval('d', dopts, D_LINELENGTH);
 165                     if (dflags[D_LINELENGTH]) respec('d', dopts, D_LINELENGTH);
 166                     dflags[D_LINELENGTH] = 1;
 167                     dlen = (int) strtol(value, &ptr, 10) + 1;
 168                     if (ptr == value) illegal(value, "d linelength");
 169                     break;
 170
 171                 case D_SEED:
 172                     if (! value) reqval('d', dopts, D_SEED);
 173                     if (dflags[D_SEED]) respec('D', dopts, D_SEED);
 174                     dflags[D_SEED] = 1;
 175                     dseed = value;
 176                     break;
 177
 178                 case D_FILE:
 179                     if (! value) reqval('d', dopts, D_FILE);
 180                     if (dflags[D_FILE]) respec('d', dopts, D_FILE);
 181                     dflags[D_FILE] = 1;
 182                     dfile = value;
 183                     break;
 184
 185                 default:
 186                     unknown('d', value);
 187                 }
 188             }
 189             break;
 190
 191         case 'b':
 192             if (bflags[B_ISSET])
 193                 respec('b', NULL, 0);
 194             bflags[B_ISSET] = 1;
 195
 196             p = optarg;
 197             while (*p != '\0') {
 198                 char *value;
 199                 switch (getsubopt(&p, (constpp)bopts, &value)) {
 200                 case B_512:
 201                     if (value) illegal(value, "b 512");
 202                     if (bflags[B_512]) respec('b', bopts, B_512);
 203                     bflags[B_512] = 1;
 204                     btypes[0].mark = 1;
 205                     break;
 206
 207                 case B_1K:
 208                     if (value) illegal(value, "b 1k");
 209                     if (bflags[B_1K]) respec('b', bopts, B_1K);
 210                     bflags[B_1K] = 1;
 211                     btypes[1].mark = 1;
 212                     break;
 213
 214                 case B_4K:
 215                     if (value) illegal(value, "b 4k");
 216                     if (bflags[B_4K]) respec('b', bopts, B_4K);
 217                     bflags[B_4K] = 1;
 218                     btypes[2].mark = 1;
 219                     break;
 220
 221                 case B_16K:
 222                     if (value) illegal(value, "b 16k");
 223                     if (bflags[B_16K]) respec('b', bopts, B_16K);
 224                     bflags[B_16K] = 1;
 225                     btypes[3].mark = 1;
 226                     break;
 227
 228                 default:
 229                     unknown('b', value);
 230                     break;
 231                 }
 232             }
 233             break;
 234
 235         case '?':
 236             usage();
 237         }
 238     }
 239
 240     if (dflags[D_FILE] && optind != argc)
 241         usage();
 242
 243     if (! dflags[D_FILE] && argc - optind != 1)
 244         usage();
 245
 246     if (! dflags[D_FILE])
 247         dfile = argv[optind];
 248
 249     if ((f = fopen(dfile, "w")) == NULL) {
 250         fprintf(stderr, "fill2: cannot create \"%s\": %s\n",
 251                 dfile, strerror(errno));
 252         status = 1;
 253         goto cleanup;
 254     }
 255
 256     if (! dflags[D_SEED])
 257         dseed = dfile;
 258
 259     /* seed is an ascii string */
 260     seed = 0;
 261     i = 0;
 262     while (dseed[i]) {
 263         seed <<= 8;
 264         seed |= dseed[i];
 265         i++;
 266     }
 267     srand(seed);
 268
 269
 270     /* normal data line format: XXXXXXXXXXXX CCCC...CCC CCCCCCCCCCCC...CCC */
 271     /* block boundary format: CXXXXXXX */
 272
 273     dbuf = (char *) malloc(dlen + 1);
 274     hlen = 12+1+strlen(dseed)+1;
 275     assert(hlen < dlen);
 276     hptr = dbuf + hlen;
 277
 278     for (i = 0; i < nbytes; i++) {
 279
 280
 281         /* is this a block boundary? check largest to smallest */
 282         boundary = 0;
 283         for (j = N(btypes) - 1; j >= 0; j--) {
 284             if (btypes[j].mark) {
 285                 /* first time through or just before a block boundary? */
 286                 if (i == 0 || i % btypes[j].size == btypes[j].size - 1) {
 287                     boundary = 1;
 288                     blktype = j;
 289                     break;
 290                 }
 291             }
 292         }
 293
 294
 295         /* are there block boundaries to check? */
 296         /* is this the first time through? */
 297         /* block boundaries take priority over other output */
 298         if (bflags[B_ISSET] && (i == 0 || boundary)) {
 299             sprintf(bbuf, "%s%c%07ld\n",
 300                     i ? "\n" : "",
 301                     btypes[blktype].flag,
 302                     /* remember i is one less than block boundary */
 303                     i ? (i+1) / btypes[blktype].size : 0);
 304             active = bbuf;
 305             ptr = bbuf;
 306         }
 307         /* are we at the start of a new line? */
 308         else if (i == 0
 309                  || (active == bbuf && *ptr == '\0')
 310                  || (active == dbuf && l == dlen))
 311         {
 312             sprintf(dbuf, "%012ld %s ", i, dseed);
 313             assert(*hptr == '\0');
 314             for (ptr = hptr; ptr != dbuf + dlen - 1; ptr++) {
 315                 /* characters upto 126 '~' are used */
 316                 /* do not use !"#$ - leave free for use as block markers */
 317                 *ptr = 37 + (rand() % (127 - 37));
 318             }
 319             *ptr++ = '\n';
 320             *ptr = '\0';
 321             assert(ptr == dbuf + dlen);
 322             active = dbuf;
 323             ptr = dbuf;
 324             l = 0;
 325         }
 326         else {
 327             /* continue copying from the active buffer */
 328         }
 329
 330         /* output one new character from current buffer */
 331         if (fputc(*ptr++, f) == EOF) {
 332             fprintf(stderr, "fill2: could not write character to \"%s\": %s\n",
 333                     dfile, strerror(errno));
 334             status = 1;
 335             goto cleanup;
 336         }
 337         if (active == dbuf) l++;
 338
 339     }
 340
 341  cleanup:
 342
 343     /* close file and flush buffers - check if this fails */
 344     if (fclose(f) != 0) {
 345         fprintf(stderr, "fill2: fclose() on \"%s\" failed: %s\n",
 346                 dfile, strerror(errno));
 347         status = 1;
 348     }
 349     exit(status);
 350 }
 351
 352
 353
 354 /*
 355  * suboption checking functions
 356  *
 357  */
 358
 359 static void
 360 illegal(char *value, char *opt)
 361 {
 362     fprintf(stderr, "%s: Error: Illegal value \"%s\" for -%s option\n",
 363             progname, value, opt);
 364     usage();
 365 }
 366 static void
 367 reqval(char opt, char *tab[], int idx)
 368 {
 369     fprintf(stderr, "%s: Error: -%c %s option requires a value\n",
 370             progname, opt, tab[idx]);
 371     usage();
 372 }
 373 static void
 374 respec(char opt, char *tab[], int idx)
 375 {
 376     fprintf(stderr, "%s: Error: ", progname);
 377     fprintf(stderr, "-%c ", opt);
 378     if (tab) fprintf(stderr, "%s ", tab[idx]);
 379     fprintf(stderr, "option respecified\n");
 380     usage();
 381 }
 382 static void
 383 unknown(char opt, char *s)
 384 {
 385     fprintf(stderr, "%s: Error: Unknown option -%c %s\n", progname, opt, s);
 386     usage();
 387 }
 388 static void
 389 usage(void)
 390 {
 391     fprintf(stderr, "Usage: %s [options] filename\n"
 392 "Options:\n"
 393 "  -d [nbytes=num,linelength=num,   output data properties\n"
 394 "      seed=string,file=name]\n"
 395 "  -b [512,1k,4k,16k]               where to mark block boundaries\n", progname);
 396     exit(2);
 397 }