libsysio/tests/sysio_stubs.c

   1 #define _BSD_SOURCE
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <unistd.h>
   9 #include <sys/uio.h>
  10 #include <sys/mount.h>
  11 #include <sys/stat.h>
  12 #include <sys/statvfs.h>
  13
  14 #include "test_driver.h"
  15 #include "sysio.h"
  16 #include "xtio.h"
  17
  18 /*
  19  * ################################################
  20  * # Function stubs                               #
  21  * #  These allow all of the different commands   #
  22  * #  to be called with the same format           #
  23  * ################################################
  24  */
  25
  26 int test_do_setdebug(int argc, char **argv)
  27 {
  28   int level;
  29
  30   if (argc != 1) {
  31     DBG(2, fprintf(outfp, "Invalid number of args (%d) for setdebug\n",
  32                    argc));
  33     return INVALID_ARGS;
  34   }
  35
  36   level = atoi(argv[0]);
  37
  38   if (level < 0) {
  39     DBG(2, fprintf(outfp, "Invalid debug level %d\n", level));
  40     return INVALID_ARGS;
  41   }
  42
  43   debug_level = level;
  44   return SUCCESS;
  45 }
  46
  47 int test_do_printline(int argc, char **argv)
  48 {
  49   int on;
  50
  51
  52   if (argc != 1) {
  53     DBG(2, fprintf(outfp, "Invalid number of args (%d) for printline\n",
  54                    argc));
  55     return INVALID_ARGS;
  56   }
  57
  58   on = atoi(argv[0]);
  59   if (on)
  60     print_line = 1;
  61   else
  62     print_line = 0;
  63
  64   return SUCCESS;
  65 }
  66
  67 /*
  68 int test_do_setoutput(int argc, char **argv)
  69 {
  70   FILE *newfp;
  71
  72   if (argc != 1) {
  73     fprintf(outfp, "Invalid number of args (%d) for setoutput\n",
  74             argc);
  75     return -1;
  76   }
  77
  78   newfp = fopen(argv[0], "w");
  79   if (!newfp) {
  80     fprintf(outfp, "Unable to open new output file %s\n", argv[0]);
  81     return -1;
  82   }
  83
  84   outfp = newfp;
  85
  86   return 0;
  87 }
  88
  89 */
  90
  91
  92 int test_do_fillbuff(int argc, char **argv)
  93 {
  94   char *typestr, *buf;
  95   void *valptr;
  96   int size, type, index, offset;
  97
  98   if (argc != 5) {
  99     DBG(2,
 100         fprintf(outfp,
 101                 "fillbuff requires a value, a type, a size, an offset, and the target buffer\n"));
 102     fprintf(stderr, "fillbuff requires 5 args, you gave %d\n", argc);
 103     return INVALID_ARGS;
 104   }
 105
 106   offset = get_obj(argv[3]);
 107   if (offset < 0) {
 108     DBG(2, fprintf(outfp, "Do not understand offset %s\n", argv[3]));
 109     return INVALID_VAR;
 110   }
 111
 112   index = get_obj(argv[4]);
 113   if (index < 0) {
 114     DBG(2, fprintf(outfp, "Can't find buffer at %s\n", argv[4]));
 115     return INVALID_VAR;
 116   }
 117   buf = (char *)(buflist[index]->buf)+offset;
 118
 119   DBG(4, fprintf(outfp, "Buffer start is at %p\n", (void *)buflist[index]));
 120
 121   typestr = argv[1];
 122   size = get_obj(argv[2]);
 123   if (size < 0) {
 124     DBG(2, fprintf(outfp, "Unable to understand size %s\n", argv[2]));
 125     return INVALID_VAR;
 126   }
 127
 128   if ( (!strcmp(typestr, "UINT")) || (!strcmp(typestr, "SINT")) ){
 129     int val = get_obj(argv[0]);
 130     valptr = &val;
 131     type = UINT;
 132     if (val < 0) { /* FIX THIS */
 133       DBG(2, fprintf(outfp, "Can't understand value %s\n", argv[0]));
 134       return INVALID_VAR;
 135     }
 136     DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %x\n",
 137                    size, buf, *((int *)valptr)));
 138     memcpy(buf, valptr, size);
 139
 140   } else if (!strcmp(typestr,"STR")) {
 141     type = STR;
 142     valptr = argv[0];
 143     DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %s\n",
 144                    size, buf, (char *)valptr));
 145     memcpy(buf, valptr, size);
 146   } else if (!strcmp(typestr, "PTR")) {
 147     unsigned long val;
 148     int index = get_obj(argv[0]);
 149     if (index < 0) {
 150       DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[0]));
 151       return INVALID_VAR;
 152     }
 153
 154     val = (unsigned long)buflist[index]->buf;
 155     valptr = &val;
 156     DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %p\n",
 157                    size, buf, valptr));
 158     memcpy(buf, valptr, size);
 159   } else {
 160     DBG(2, fprintf(outfp, "Unknown type %s.  Valid types are UINT, STR, and PTR\n",
 161                    typestr));
 162     fprintf(stderr, "Unknown type %s.  Valid types are UINT, STR, and PTR\n",
 163                    typestr);
 164     return INVALID_ARGS;
 165   }
 166
 167   return SUCCESS;
 168 }
 169
 170
 171 #define STR_TYPE       1
 172 #define INT_TYPE       2
 173 #define SHORT_TYPE     3
 174 #define CHAR_TYPE      4
 175 #define LONG_TYPE      5
 176
 177 void print_partial(char *buf, int offset, int len, int type)
 178 {
 179   int i;
 180
 181   if (type == STR_TYPE) {
 182     sprintf(output, "%s%s", output, (char *)(buf+offset));
 183     DBG(4, fprintf(outfp, "Printing str %s\n", (char *)(buf+offset)));
 184   } else {
 185     if (type == SHORT_TYPE) {
 186       for (i = 0; i < len; i+= 2) {
 187         short *ibuf = (short *)(buf + offset + i);
 188         sprintf(output, "%s%#04x ", output, *ibuf);
 189         DBG(4, fprintf(outfp, "Printing short %#04x\n", *ibuf));
 190       }
 191     } else if (type == CHAR_TYPE) {
 192       for (i = 0; i < len; i++) {
 193         short *ibuf = (short *)(buf+offset+i);
 194         sprintf(output, "%s%#02x ", output, (*ibuf & 0x00ff));
 195         DBG(4, fprintf(outfp, "Printing char %c\n", (*ibuf & 0x00ff)));
 196       }
 197     } else if (type == INT_TYPE) {
 198       for (i = 0; i < len; i+= 4) {
 199         int *ibuf = (int *)(buf + offset + i);
 200         sprintf(output, "%s%#08x ", output, *ibuf);
 201         DBG(4, fprintf(outfp, "Printing int %#08x\n", *ibuf));
 202       }
 203     } else {
 204       for (i = 0; i < len; i += 8) {
 205         unsigned long *lbuf = (unsigned long *)(buf + offset +i);
 206         sprintf(output, "%s%#08lx ", output, *lbuf);
 207         DBG(4, fprintf(outfp, "Printing int %#016lx\n", *lbuf));
 208       }
 209     }
 210   }
 211 }
 212
 213 int test_do_printbuf(int argc, char **argv)
 214 {
 215   int index, i, type, offset, len;
 216   struct buf_t *buf_st;
 217   void *buf;
 218   char *typestr;
 219   struct var_mapping *mobj;
 220
 221   if (argv[0][0] == '$') {
 222     if (argv[0][1] == '$') {
 223       sprintf(output, "\n%#010x", (unsigned int)last_ret_val);
 224       return SUCCESS;
 225     } else if (!strcmp("errno", &argv[0][1])) {
 226       sprintf(output, "\n%#010x", my_errno);
 227       return SUCCESS;
 228     }
 229   }
 230
 231   mobj = get_map(argv[0]);
 232   if (mobj == NULL) {
 233     DBG(2, fprintf(outfp, "Can't get var at %s\n", argv[0]));
 234     return INVALID_VAR;
 235   }
 236
 237   if (mobj->type == UINT)
 238     sprintf(output, "\n%#010x", mobj->obj);
 239   else if (mobj->type == SINT)
 240     sprintf(output, "%d", mobj->obj);
 241   else if ((mobj->type == STR) || (mobj->type == PTR)) {
 242     index = mobj->obj;
 243
 244     buf_st = buflist[index];
 245     DBG(2, fprintf(outfp, "buf_st is %p:\n", (void *)buf_st));
 246     buf = buf_st->buf;
 247     DBG(2, fprintf(outfp, "buf %s:\n", argv[0]));
 248     if (mobj->type == STR) {
 249       sprintf(output, "\n%s", (char *)buf);
 250      } else {
 251        sprintf(output,"%s\n", output);
 252        DBG(2, fprintf(outfp, "buf_st->len is %d, buf is %p\n", buf_st->len, buf));
 253        if (argc == 1) {
 254          for (i = 0; i < buf_st->len/4; i++)
 255            DBG(2, fprintf(outfp, "%#x ", ((int *)buf)[i]));
 256            sprintf(output, "%s%#x ", output, ((int *)buf)[i]);
 257
 258        }
 259
 260        for (i = 1; i < argc; i++) {
 261          offset = get_obj(argv[i++]);
 262          len = get_obj(argv[i++]);
 263          if ((offset < 0) || (len < 0)) {
 264            DBG(2, fprintf(outfp, "Invalid offset (%s) or len (%s)\n",
 265                           argv[i-2], argv[i-1]));
 266            return INVALID_VAR;
 267          }
 268          typestr = argv[i];
 269          if (!strcmp("STR", typestr))
 270            type = STR_TYPE;
 271          else if (!strcmp("INT", typestr))
 272            type = INT_TYPE;
 273          else if (!strcmp("SHORT", typestr))
 274            type = SHORT_TYPE;
 275          else if (!strcmp("CHAR", typestr))
 276            type = CHAR_TYPE;
 277          else if (!strcmp("LONG", typestr))
 278            type = LONG_TYPE;
 279          else {
 280            DBG(2, fprintf(outfp, "Unable to understand type %s\n",
 281                           typestr));
 282            return INVALID_ARGS;
 283          }
 284          print_partial(buf, offset, len, type);
 285        }
 286      }
 287   }
 288   DBG(3, fprintf(outfp, "output: %s \n", output));
 289   return SUCCESS;
 290 }
 291
 292 int test_do_mount(int argc, char **argv)
 293 {
 294   if (argc != 2) {
 295     DBG(2, fprintf(outfp, "Invalid number of args (%d) for test_do_mount\n",
 296                    argc));
 297     return INVALID_ARGS;
 298   }
 299
 300   DBG(4, fprintf(outfp, "Calling mount with from %s and to %s\n",
 301                  argv[0], argv[1]));
 302   last_ret_val = sysio_mount(argv[0], argv[1]);
 303   my_errno = errno;
 304   last_type = SINT;
 305   return SUCCESS;
 306 }
 307
 308 int test_do_clear(int argc, char **argv)
 309 {
 310   int index;
 311   struct buf_t *buf;
 312
 313   if (argc != 1) {
 314     DBG(2, fprintf(outfp, "Invalid number of args (%d) for clear\n",
 315                    argc));
 316     return INVALID_ARGS;
 317   }
 318   index = get_obj(argv[0]);
 319   if (index < 0) {
 320     fprintf(outfp, "Unable to locate buffer %s\n",
 321            argv[0]);
 322     return -1;
 323   }
 324   buf = buflist[index];
 325   bzero(buf->buf, buf->len);
 326
 327   return SUCCESS;
 328 }
 329
 330 int test_do_list(int argc, char **argv)
 331 {
 332   char *buf;
 333
 334   if ((argc) && (argc != 1)) {
 335     DBG(2, fprintf(outfp, "Invalid number of args (%d) for list\n",
 336                    argc));
 337     return INVALID_ARGS;
 338   }
 339
 340   DBG(5,fprintf(outfp, "In test_do_list with args %p\n", (void *)argv));
 341   if (!argv) {
 342     buf = getcwd(NULL, 0);
 343     DBG(4, fprintf(outfp, "Calling list with dir of %s\n", buf));
 344     last_ret_val =  sysio_list(buf);
 345     my_errno = errno;
 346     free(buf);
 347     return SUCCESS;
 348   }
 349
 350   last_type = SINT;
 351   return sysio_list(*argv);
 352 }
 353
 354 /*
 355  * Initlizes sysio library.  Will use default initlization
 356  * unless arguments are given
 357  */
 358 int test_do_init(int argc, char **argv)
 359 {
 360   if (argc > 0) {
 361     char *rdriver;
 362     char *mpath;
 363     int mflags, rsize, msize;
 364     if (argc != 3) {
 365       DBG(2, fprintf(outfp, "Invalid number of args (%d) for init\n",
 366                      argc));
 367       return INVALID_ARGS;
 368     }
 369
 370     rdriver = get_str(argv[0]);
 371     rsize = strlen(rdriver)+1;
 372     if (rsize > 75) {
 373       DBG(2, fprintf(outfp, "%s too long for root driver\n", rdriver));
 374       return INVALID_ARGS;
 375     }
 376     bzero(root_driver, 75);
 377     memcpy(root_driver, rdriver, rsize);
 378
 379     mpath = get_str(argv[1]);
 380     msize = strlen(mpath)+1;
 381     if (msize > 250) {
 382       DBG(2, fprintf(outfp, "%s too long for mount path\n", mpath));
 383       return INVALID_ARGS;
 384     }
 385     bzero(mntpath, 250);
 386     memcpy(mntpath, mpath, msize);
 387
 388     mflags = get_obj(argv[2]);
 389     if (mflags == -1) {
 390       DBG(2, fprintf(outfp, "Invalid flags argument %s\n", argv[2]));
 391       return INVALID_ARGS;
 392     }
 393   }
 394
 395   DBG(5, fprintf(outfp, "In test_do_init\n"));
 396   last_type = SINT;
 397   DBG(3, fprintf(outfp, "initializing\n"));
 398   return initilize_sysio();
 399 }
 400
 401
 402 /*
 403  * Returns 1 if the machine is big-endian, 0
 404  * otherwise
 405  */
 406 int get_endian(int argc, char **argv)
 407 {
 408   int x = 1;
 409
 410   if ((argc) || (argv)) {
 411     DBG(2, fprintf(outfp, "Expected no args for test_do_endian\n"));
 412     return INVALID_ARGS;
 413   }
 414
 415   if(*(char *)&x == 1) {
 416     /* little-endian, return 0 */
 417     last_ret_val= 0;
 418   } else {
 419     /* big endian, return 1 */
 420     last_ret_val= 1;
 421   }
 422   last_type = UINT;
 423   return SUCCESS;
 424 }
 425
 426 int do_setbuf(int argc, char **argv)
 427 {
 428         int val, size, index, offset;
 429         void *buf;
 430
 431         if (argc != 4) {
 432                 DBG(2, fprintf(outfp, "Need val, size, buffer, and offset for setbuf\n"));
 433                 return INVALID_ARGS;
 434         }
 435         val = get_obj(argv[0]);
 436         if (val < 0) {
 437                 DBG(2, fprintf(outfp, "Unable to understand val of %s\n",
 438                                                                          argv[0]));
 439                 return INVALID_VAR;
 440         }
 441
 442         size = get_obj(argv[1]);
 443         if( size <=0 ) {
 444                 DBG(2, fprintf(outfp, "Size of %s is invalid\n", argv[1]));
 445                 return INVALID_VAR;
 446         }
 447
 448   index = get_obj(argv[2]);
 449   if (index < 0) {
 450     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
 451                    argv[2]));
 452     return INVALID_VAR;
 453   }
 454
 455   buf = buflist[index]->buf;
 456
 457         offset = get_obj(argv[3]);
 458
 459         if (offset < 0) {
 460     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[3]));
 461     return INVALID_ARGS;
 462   }
 463
 464         buf = (void *)((char *)buf +offset);
 465
 466         memset(buf, val, size);
 467
 468         return SUCCESS;
 469 }
 470
 471
 472 int get_sizeof(int argc, char **argv)
 473 {
 474   char *type;
 475   int size;
 476
 477   if (argc != 1) {
 478     DBG(2, fprintf(outfp, "Number of args (%d) invalid for sizeof\n",
 479                    argc));
 480     return INVALID_ARGS;
 481   }
 482
 483   type = argv[0];
 484
 485   if (!strcmp(type, "char"))
 486     size =  sizeof(char);
 487   else if (!strcmp(type, "int"))
 488     size =  sizeof(int);
 489   else if (!strcmp(type, "long"))
 490     size =  sizeof(long);
 491   else if (!strcmp(type, "flock"))
 492     size =  sizeof(struct flock);
 493   else if (!strcmp(type, "stat"))
 494     size =  sizeof(struct stat);
 495   else if (!strcmp(type, "statvfs"))
 496     size =  sizeof(struct statvfs);
 497   else if (!strcmp(type, "iovec"))
 498     size =  sizeof(struct iovec);
 499  else if (!strcmp(type, "xtvec"))
 500     size =  sizeof(struct xtvec);
 501   else
 502     return INVALID_ARGS;
 503
 504   DBG(2, fprintf(outfp, "Size is %d\n", size));
 505
 506   last_type = UINT;
 507   last_ret_val = size;
 508   return SUCCESS;
 509 }
 510
 511 int test_do_exit(int argc, char **argv)
 512 {
 513   int val = 0;
 514
 515   if (argc) {
 516     /*
 517      * If argc is given, need to return the value of
 518      * the passed in variable
 519      */
 520     val = get_obj(argv[0]);
 521   }
 522
 523   /*
 524    * Clean up.
 525    */
 526   _sysio_shutdown();
 527
 528   if (argc)
 529     DBG(3, printf("Exiting with %d from %s\n", val, argv[0]));
 530
 531   exit(val);
 532
 533   return 0;
 534 }
 535
 536 int get_buffer(int argc, char **argv)
 537 {
 538   int size, align;
 539   struct buf_t *buf;
 540
 541   if (argc == 1) /* Just put size, not alignment */
 542     align = 16;
 543   else if (argc == 2)
 544     align = get_obj(argv[1]);
 545   else {
 546     DBG(2, fprintf(outfp, "Number of args (%d) invalid for alloc\n",
 547                    argc));
 548     return INVALID_ARGS;
 549   }
 550
 551   size = get_obj(argv[0]);
 552   if (size < 0) {
 553     DBG(2, fprintf(outfp, "Invalid size %s\n", argv[0]));
 554     return INVALID_ARGS;
 555   }
 556
 557   DBG(3, fprintf(outfp, "Getting buffer of size %d and aligned at %d\n",
 558                  size, align));
 559   buf = (struct buf_t *)malloc(sizeof(struct buf_t));
 560   buf->buf = alloc_buff32(size, align);
 561   buf->len = size;
 562   buflist[next] = buf;
 563   DBG(3, fprintf(outfp, "Your buffer (%p) (%p) is at index %d\n",
 564                  (void *)buf, buf->buf, next));
 565   next++;
 566
 567   last_type = PTR;
 568   last_ret_val = next-1;
 569   return SUCCESS;
 570 }
 571
 572 int free_buffer(int argc, char **argv)
 573 {
 574   int index;
 575   char *name = argv[0];
 576
 577   if (argc != 1) {
 578     DBG(2, fprintf(outfp, "Number of args (%d) invalid for free\n",
 579                    argc));
 580     return INVALID_ARGS;
 581   }
 582
 583   /*
 584    * Assume that there is one arg and it
 585    * is a variable name which maps to an
 586    * index into the buffer array
 587    */
 588    index = get_obj(name);
 589    if (index < 0) {
 590      DBG(2, fprintf(outfp, "Can't find buffer %s\n",
 591                     name));
 592      return INVALID_VAR;
 593    }
 594    DBG(4, fprintf(outfp, "Freeing buffer at index %d\n", index));
 595    free(buflist[index]);
 596
 597    free_obj(name);
 598    return SUCCESS;
 599 }
 600
 601 int cmp_bufs(int argc, char **argv)
 602 {
 603   int res, index1, index2;
 604   char *buf1, *buf2;
 605
 606   if (argc != 2) {
 607     fprintf(outfp, "Need two buffers to compare\n");
 608     return INVALID_ARGS;
 609   }
 610
 611   index1 = get_obj(argv[0]);
 612   if (index1 < 0) {
 613     fprintf(outfp, "Unable to locate buffer %s\n",
 614            argv[0]);
 615     return INVALID_VAR;
 616   }
 617   buf1 = buflist[index1]->buf;
 618
 619   index2 = get_obj(argv[1]);
 620   if (index2 < 0) {
 621     fprintf(outfp, "Unable to locate buffer %s\n",
 622            argv[1]);
 623     return INVALID_VAR;
 624   }
 625
 626   buf2 = buflist[index2]->buf;
 627   last_ret_val = strcmp(buf1, buf2);
 628
 629   DBG(3, fprintf(outfp, "strcmp returned %d\n", res));
 630   return SUCCESS;
 631 }
 632
 633 int test_do_chdir(int argc, char **argv)
 634 {
 635   if (argc != 1) {
 636     DBG(2, fprintf(outfp, "Number of args (%d) invalid for chdir\n",
 637                    argc));
 638     return INVALID_ARGS;
 639   }
 640   last_type = SINT;
 641   return sysio_chdir(argv[0]);
 642 }
 643
 644
 645 int test_do_chmod(int argc, char **argv)
 646 {
 647   if (argc != 2) {
 648     DBG(2, fprintf(outfp, "Number of args (%d) invalid for chmod\n",
 649                    argc));
 650     return INVALID_ARGS;
 651   }
 652   last_type = SINT;
 653   return sysio_chmod(argv[0], argv[1]);
 654 }
 655
 656 int test_do_chown(int argc, char **argv)
 657 {
 658   if (argc != 2) {
 659     DBG(2, fprintf(outfp, "Number of args (%d) invalid for chown\n",
 660                    argc));
 661     return INVALID_ARGS;
 662   }
 663   last_type = SINT;
 664   return sysio_chown(argv[0], argv[1]);
 665 }
 666
 667 int test_do_open(int argc, char **argv)
 668 {
 669   char *name = argv[0];
 670   int flags = O_RDWR;
 671
 672   if (argc > 1)
 673     flags = get_obj(argv[1]);
 674
 675   if (name[0] == '$') {
 676     int index = get_obj(name);
 677
 678     if (index < 0) {
 679       DBG(2, fprintf(outfp, "Unable to find buffer at %s\n",
 680                      name));
 681       return INVALID_VAR;
 682     }
 683
 684     name = buflist[index]->buf;
 685   }
 686
 687   DBG(4,  fprintf(outfp, "Opening file %s with flags %d\n", name, flags));
 688   if (argc == 2)
 689     return sysio_open(name, flags);
 690   else if (argc == 3)
 691     return sysio_open3(name, flags, argv[2]);
 692   else {
 693     DBG(2, fprintf(outfp, "Invalid number of arguments (%d)\n", argc));
 694     return INVALID_ARGS;
 695   }
 696   last_type = UINT;
 697   return SUCCESS;
 698 }
 699
 700 int test_do_close(int argc, char **argv)
 701 {
 702   int fd;
 703   char *name = argv[0];
 704
 705   if (argc != 1) {
 706     DBG(2, fprintf(outfp, "Number of args (%d) invalid for close\n",
 707                    argc));
 708     return INVALID_ARGS;
 709   }
 710
 711   /*
 712    * Assume that there is one arg and it
 713    * is a variable name which maps to a file
 714    * descriptor
 715    */
 716   fd = get_obj(name);
 717   if (fd < 0) {
 718     DBG(2, fprintf(outfp, "Unable to map var %s to anything\n", name));
 719     return INVALID_VAR;
 720   }
 721   sysio_close(fd);
 722   free_obj(name);
 723   return SUCCESS;
 724 }
 725
 726 int test_do_dup(int argc, char **argv)
 727 {
 728   int fd;
 729   char *var_name = argv[0];
 730
 731   if (argc != 1) {
 732     DBG(2, fprintf(outfp, "Number of args (%d) invalid for dup\n",
 733                    argc));
 734     return INVALID_ARGS;
 735   }
 736
 737
 738   fd = get_obj(var_name);
 739   if (fd < 0) {
 740     DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name));
 741     return INVALID_VAR;
 742   }
 743
 744   last_ret_val = dup(fd);
 745   my_errno = errno;
 746   last_type = SINT;
 747
 748   return SUCCESS;
 749 }
 750
 751 int test_do_dup2(int argc, char **argv)
 752 {
 753   int fd1, fd2;
 754   char *var_name1 = argv[0];
 755   char *var_name2 = argv[1];
 756
 757   if (argc != 2) {
 758     DBG(2, fprintf(outfp, "Number of args (%d) invalid for dup2\n",
 759                    argc));
 760     return INVALID_ARGS;
 761   }
 762
 763   fd1 = get_obj(var_name1);
 764   if (fd1 < 0) {
 765     DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name1));
 766     return INVALID_VAR;
 767   }
 768
 769   fd2 = get_obj(var_name2);
 770   if (fd2 < 0) {
 771     DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name2));
 772     return INVALID_VAR;
 773   }
 774
 775   last_ret_val = dup2(fd1, fd2);
 776   my_errno = errno;
 777   last_type = SINT;
 778
 779   return SUCCESS;
 780 }
 781
 782 struct cmd_map fcntl_cmds[] = {
 783   { "F_DUPFD", F_DUPFD, 3 },
 784   { "F_GETFD", F_GETFD, 2 },
 785   { "F_SETFD", F_SETFD, 3 },
 786   { "F_GETFL", F_GETFL, 2 },
 787   { "F_SETFL", F_SETFL, 3 },
 788   { "F_SETLK", F_SETLK, 3 },
 789   { "F_SETLKW", F_SETLKW, 3 },
 790   { "F_GETLK", F_GETLK, 3 },
 791 #if defined __USE_BSD || defined __USE_XOPEN2K
 792   { "F_GETOWN", F_GETOWN, 2 },
 793   { "F_SETOWN", F_SETOWN, 3 },
 794 #endif
 795 #ifdef __USE_GNU
 796   { "F_GETSIG", F_GETSIG, 2 },
 797   { "F_SETSIG", F_SETSIG, 3 },
 798   { "F_SETLEASE", F_SETLEASE, 3},
 799   { "F_GETLEASE", F_GETLEASE, 2},
 800   { "F_NOTIFY", F_NOTIFY, 3} ,
 801 #endif
 802   { NULL, -1, 0 }
 803 };
 804
 805 struct cmd_map* get_cmd(char *cmd_name, int argc)
 806 {
 807   int i =0;
 808
 809   while (fcntl_cmds[i].cmd_name) {
 810     if (!strcmp(fcntl_cmds[i].cmd_name, cmd_name)) {
 811       if (fcntl_cmds[i].num_args == argc)
 812         return &fcntl_cmds[i];
 813       else
 814         return NULL;
 815     }
 816     i++;
 817   }
 818   return NULL;
 819 }
 820
 821 int test_do_fcntl(int argc, char **argv)
 822 {
 823
 824   struct cmd_map *cmd;
 825   int fd;
 826
 827   /*
 828    * get_cmd translates a symbolic command into
 829    * into its numerical equivalent. It also
 830    * verifies that the number of args is the
 831    * correct number for the command. It returns
 832    * NULL on failure
 833    */
 834   cmd = get_cmd(argv[1], argc);
 835   if (!cmd) {
 836     DBG(2, fprintf(outfp, "Unable to get command %s\n", argv[1]));
 837     return INVALID_ARGS;
 838   }
 839
 840   fd = get_obj(argv[0]);
 841   if (fd < 0) {
 842     DBG(2, fprintf(outfp, "Unable to map %s to file descriptor \n", argv[0]));
 843     return INVALID_VAR;
 844   }
 845
 846   if (argc > 2)
 847     last_ret_val =  sysio_fcntl(fd, cmd, argv[2]);
 848   else
 849     last_ret_val = sysio_fcntl(fd, cmd, NULL);
 850   DBG(4, fprintf(outfp, "Got return value of %d\n", (int)last_ret_val));
 851   my_errno = errno;
 852   last_type = SINT;
 853
 854   return SUCCESS;
 855 }
 856
 857 int test_do_fstat(int argc, char **argv)
 858 {
 859   int fd, index;
 860   void *buf;
 861
 862   if (argc != 2) {
 863     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) for fstat\n",
 864                    argc));
 865     return INVALID_ARGS;
 866   }
 867
 868   fd = get_obj(argv[0]);
 869
 870   if (fd < 0) {
 871     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
 872                    argv[0]));
 873     return INVALID_VAR;
 874   }
 875
 876   index = get_obj(argv[1]);
 877   if (index < 0) {
 878     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
 879                    argv[1]));
 880     return INVALID_VAR;
 881   }
 882
 883   buf = buflist[index]->buf;
 884
 885   last_ret_val = sysio_fstat(fd, buf);
 886   my_errno = errno;
 887   last_type = SINT;
 888
 889   return SUCCESS;
 890 }
 891
 892 int test_do_lstat(int argc, char **argv)
 893 {
 894   char *name = argv[0];
 895   int index;
 896   void *buf;
 897
 898   if (argc != 2) {
 899     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) for lstat\n",
 900                    argc));
 901     return INVALID_ARGS;
 902   }
 903
 904   index = get_obj(argv[1]);
 905   if (index < 0) {
 906     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
 907                    argv[1]));
 908     return INVALID_VAR;
 909   }
 910
 911   buf = buflist[index]->buf;
 912   last_type = SINT;
 913
 914   return sysio_lstat(name, buf);
 915 }
 916
 917 int test_do_fsync(int argc, char **argv)
 918 {
 919   int fd;
 920
 921   if (argc != 1) {
 922     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to fsync\n", argc));
 923     return INVALID_ARGS;
 924   }
 925
 926
 927   fd = get_obj(argv[0]);
 928
 929   if (fd < 0) {
 930     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
 931                    argv[0]));
 932     return INVALID_VAR;
 933   }
 934
 935   last_ret_val = fsync(fd);
 936   my_errno = errno;
 937   last_type = SINT;
 938
 939   return SUCCESS;
 940 }
 941
 942
 943 int test_do_fdatasync(int argc, char **argv)
 944 {
 945   int fd;
 946
 947   if (argc != 1) {
 948     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to fdatasync\n", argc));
 949     return INVALID_ARGS;
 950   }
 951
 952
 953   fd = get_obj(argv[0]);
 954
 955   if (fd < 0) {
 956     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
 957                    argv[0]));
 958     return INVALID_VAR;
 959   }
 960
 961   last_ret_val = fdatasync(fd);
 962   my_errno = errno;
 963   last_type = SINT;
 964
 965   return SUCCESS;
 966 }
 967
 968
 969 int test_do_ftruncate(int argc, char **argv)
 970 {
 971   int fd;
 972   off_t length;
 973
 974   if (argc != 2) {
 975     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ftruncate\n", argc));
 976     return INVALID_ARGS;
 977   }
 978
 979
 980   fd = get_obj(argv[0]);
 981
 982   if (fd < 0) {
 983     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
 984                    argv[0]));
 985     return INVALID_VAR;
 986   }
 987
 988   length = (off_t)get_obj(argv[1]);
 989
 990   DBG(3, fprintf(outfp, "Setting file %d to %d\n", fd, (int) length));
 991
 992   last_ret_val = ftruncate(fd, length);
 993   my_errno = errno;
 994   last_type = SINT;
 995
 996   return SUCCESS;
 997 }
 998
 999 int test_do_getcwd(int argc, char **argv)
1000 {
1001   char *buf;
1002   int size, index;
1003
1004   if (argc != 2) {
1005     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to getcwd\n", argc));
1006     return INVALID_ARGS;
1007   }
1008
1009   index = get_obj(argv[0]);
1010   if (index < 0) {
1011     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
1012                    argv[1]));
1013     return INVALID_VAR;
1014   }
1015
1016   buf = buflist[index]->buf;
1017
1018   size = get_obj(argv[1]);
1019
1020   DBG(4, fprintf(outfp, "Getting cwd with buffer size of %d\n", size));
1021
1022   last_ret_val = 0;
1023   if (!getcwd(buf, size)) {
1024       last_ret_val = -1;
1025       if (errno == ERANGE) {
1026           DBG(2, fprintf(outfp, "Need a bigger buffer!\n"));
1027       }
1028   }
1029
1030   my_errno = errno;
1031
1032
1033   DBG(3, fprintf(outfp, "cwd: %s\n", buf));
1034   last_type = SINT;
1035
1036   return SUCCESS;
1037 }
1038
1039 int test_do_lseek(int argc, char **argv)
1040 {
1041   int fd, whence;
1042   off_t offset;
1043
1044
1045   if (argc != 3) {
1046     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to lseek\n", argc));
1047     return INVALID_ARGS;
1048   }
1049
1050
1051   fd = get_obj(argv[0]);
1052
1053   if (fd < 0) {
1054     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
1055                    argv[0]));
1056     return INVALID_VAR;
1057   }
1058
1059   offset = (off_t)get_obj(argv[1]);
1060   whence = get_obj(argv[2]);
1061
1062   if (whence < 0 ) {
1063     DBG(2, fprintf(outfp, "Not familiar with whence of %s\n",
1064                    argv[2]));
1065     return INVALID_ARGS;
1066   }
1067
1068   last_ret_val = lseek(fd, offset, whence);
1069   my_errno = errno;
1070   last_type = SINT;
1071
1072   return SUCCESS;
1073 }
1074
1075 int test_do_getdirentries(int argc, char **argv)
1076 {
1077   int fd, nbytes;
1078   int bufindex;
1079   off_t basep;
1080   char *buf;
1081   struct var_mapping *base_map;
1082
1083   if (argc != 4) {
1084     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to getdirentries\n", argc));
1085     return INVALID_ARGS;
1086   }
1087
1088   fd = get_obj(argv[0]);
1089
1090   if (fd < 0) {
1091     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
1092                    argv[0]));
1093     return INVALID_VAR;
1094   }
1095
1096   bufindex = get_obj(argv[1]);
1097
1098   if (bufindex < 0) {
1099     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
1100                    argv[1]));
1101     return INVALID_VAR;
1102   }
1103
1104   buf = buflist[bufindex]->buf;
1105
1106   nbytes = get_obj(argv[2]);
1107
1108   if (nbytes < 0) {
1109     DBG(2, fprintf(outfp, "I don't understand %s\n",
1110                    argv[2]));
1111     return INVALID_ARGS;
1112   }
1113
1114   base_map = get_map(argv[3]);
1115   if (!base_map) {
1116     DBG(3, fprintf(outfp, "Resetting basep\n"));
1117     /*
1118      * Assume that this is the first getdirentries call
1119      * and we need to setup the base pointer
1120      */
1121     basep = 0;
1122   } else
1123     basep = base_map->obj;
1124
1125   DBG(3, fprintf(outfp, "basep is (starting) %d\n", (int) basep));
1126   last_ret_val = sysio_getdirentries(fd, buf, nbytes, &basep);
1127   if (base_map)
1128     base_map->obj = basep;
1129   else
1130     store_result(argv[3]+1, basep);
1131   DBG(3, fprintf(outfp, "basep is (ending) %d\n", (int) basep));
1132   my_errno = errno;
1133   last_type = SINT;
1134
1135   return SUCCESS;
1136 }
1137
1138 int test_do_mkdir(int argc, char **argv)
1139 {
1140   if (argc !=2) {
1141     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to mkdir\n", argc));
1142     return INVALID_ARGS;
1143   }
1144
1145   last_type = SINT;
1146   return sysio_mkdir(argv[0], argv[1]);
1147 }
1148
1149 int test_do_creat(int argc, char **argv)
1150 {
1151   if (argc !=2) {
1152     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to creat\n", argc));
1153     return INVALID_ARGS;
1154   }
1155
1156   last_type = UINT;
1157   return sysio_creat(argv[0], argv[1]);
1158 }
1159
1160 int test_do_stat(int argc, char **argv)
1161 {
1162   int index;
1163   void *buf;
1164   char *str;
1165
1166   if (argc != 2) {
1167     fprintf(outfp, "Invalid number of arguments (%d) for stat\n",
1168            argc);
1169     return -1;
1170   }
1171
1172
1173   index = get_obj(argv[1]);
1174   if (index < 0) {
1175     fprintf(outfp, "Unable to find buffer assocated with %s\n",
1176            argv[1]);
1177   }
1178
1179   buf = buflist[index]->buf;
1180   last_type = SINT;
1181
1182   str = get_str(argv[0]);
1183   return sysio_stat(str, buf);
1184 }
1185
1186 int test_do_statvfs(int argc, char **argv)
1187 {
1188   int index;
1189   void *buf;
1190
1191   if (argc != 2) {
1192     fprintf(outfp, "Invalid number of arguments (%d) for statvfs\n",
1193            argc);
1194     return -1;
1195   }
1196
1197
1198   index = get_obj(argv[1]);
1199   if (index < 0) {
1200     fprintf(outfp, "Unable to find buffer assocated with %s\n",
1201            argv[1]);
1202   }
1203
1204   buf = buflist[index]->buf;
1205   last_type = SINT;
1206
1207   return sysio_statvfs(argv[0], buf);
1208 }
1209
1210 int test_do_fstatvfs(int argc, char **argv)
1211 {
1212   int index, fd;
1213   void *buf;
1214
1215   if (argc != 2) {
1216     fprintf(outfp, "Invalid number of arguments (%d) for fstatvfs\n",
1217            argc);
1218     return -1;
1219   }
1220
1221
1222   fd = get_obj(argv[0]);
1223
1224   if (fd < 0) {
1225     fprintf(outfp, "Unable to find file assocated with %s\n",
1226            argv[0]);
1227   }
1228
1229
1230   index = get_obj(argv[1]);
1231   if (index < 0) {
1232     fprintf(outfp, "Unable to find buffer assocated with %s\n",
1233            argv[1]);
1234   }
1235
1236   buf = buflist[index]->buf;
1237   last_type = SINT;
1238
1239   return sysio_fstatvfs(fd, buf);
1240 }
1241
1242 int test_do_truncate(int argc, char **argv)
1243 {
1244   off_t length;
1245
1246   if (argc != 2) {
1247     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to truncate\n", argc));
1248     return INVALID_ARGS;
1249   }
1250
1251   length = (off_t)get_obj(argv[1]);
1252
1253   DBG(3, fprintf(outfp, "Setting file %s to %d\n", argv[0], (int) length));
1254
1255   last_ret_val = truncate(argv[0], length);
1256   my_errno = errno;
1257   last_type = SINT;
1258
1259   return SUCCESS;
1260 }
1261
1262 int test_do_rmdir(int argc, char **argv)
1263 {
1264
1265   if (argc != 1) {
1266     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to rmdir\n", argc));
1267     return INVALID_ARGS;
1268   }
1269
1270   DBG(3, fprintf(outfp, "Removing dir %s\n", argv[0]));
1271
1272   last_ret_val = rmdir(argv[0]);
1273   my_errno = errno;
1274   last_type = SINT;
1275
1276   return SUCCESS;
1277 }
1278
1279 int test_do_symlink(int argc, char **argv)
1280 {
1281   if (argc != 2) {
1282     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to symlink\n", argc));
1283     return INVALID_ARGS;
1284   }
1285
1286   DBG(3, fprintf(outfp, "Linking %s to %s\n", argv[0], argv[1]));
1287
1288   last_ret_val = symlink(argv[0], argv[1]);
1289   if (last_ret_val) {
1290     if (errno < 0)
1291       errno = errno*-1;
1292     my_perror("symlink");
1293   }
1294   my_errno = errno;
1295   last_type = SINT;
1296
1297   return SUCCESS;
1298 }
1299
1300
1301 struct cmd_map ioctl_cmds[] = {
1302 #if 0
1303   { "BLKROSET", BLKROSET, 3 },
1304   { "BLKROGET", BLKROGET, 3 },
1305   { "BLKRRPART", BLKRRPART, 3 },
1306   { "BLKGETSIZE", BLKGETSIZE, 3 },
1307   { "BLKRASET", BLKRASET, 3 },
1308   { "BLKRAGET", BLKRAGET, 3 },
1309   { "BLKSECTSET", BLKSECTSET, 3 },
1310   { "BLKSECTGET", BLKSECTGET, 3 },
1311   { "BLKSSZGET", BLKSSZGET, 3 },
1312   { "BLKGETLASTSECT", BLKGETLASTSECT, 3 },
1313   { "BLKSETLASTSECT", BLKSETLASTSECT, 3 },
1314   { "BLKBSZGET", BLKBSZGET, 3 },
1315   { "BLKBSZSET", BLKBSZSET, 3 },
1316   { "FIBMAP", FIBMAP, 3 },
1317   { "FIGETBSZ", FIGETBSZ, 3},
1318 #endif
1319   { NULL, -1, 0 }
1320 };
1321
1322 int get_ioctl_cmd(char *cmd)
1323 {
1324   int i = 0;
1325
1326   while (ioctl_cmds[i].cmd_name != NULL) {
1327     if (strcmp(ioctl_cmds[i].cmd_name, cmd))
1328       i++;
1329     else
1330       return ioctl_cmds[i].cmd;
1331   }
1332
1333   return -1;
1334 }
1335
1336 int test_do_ioctl(int argc, char **argv)
1337 {
1338   int fd, cmd;
1339
1340   if (argc != 3) {
1341     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ioctl\n", argc));
1342     return INVALID_ARGS;
1343   }
1344
1345
1346   fd = get_obj(argv[0]);
1347   if (fd < 0) {
1348     DBG(2, fprintf(outfp, "Unable to find file %s\n", argv[0]));
1349     return INVALID_VAR;
1350   }
1351
1352   cmd = get_ioctl_cmd(argv[1]);
1353   if (cmd == -1) {
1354     DBG(2, fprintf(outfp, "Do not understand command %s\n", argv[1]));
1355     return INVALID_ARGS;
1356   }
1357
1358   DBG(3, fprintf(outfp, "Executing command %s\n", argv[1]));
1359
1360   last_ret_val = ioctl(fd, cmd, argv[2]);
1361   my_errno = errno;
1362   if (last_ret_val)
1363     my_perror("ioctl");
1364   last_type = SINT;
1365
1366   return SUCCESS;
1367 }
1368
1369 int test_do_unlink(int argc, char **argv)
1370 {
1371   if (argc != 1) {
1372     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to unlink\n", argc));
1373     return INVALID_ARGS;
1374   }
1375
1376   DBG(4, fprintf(outfp, "Unlinking %s\n", argv[0]));
1377
1378   last_ret_val = unlink(argv[0]);
1379   my_errno = errno;
1380   if (last_ret_val)
1381     my_perror("unlink");
1382   last_type = SINT;
1383
1384   return SUCCESS;
1385 }
1386
1387 int test_do_umask(int argc, char **argv)
1388 {
1389   mode_t old_mask;
1390
1391   if (argc != 1) {
1392     DBG(2, fprintf(outfp, "Incorrect number of args (%d) for umask\n", argc));
1393     return INVALID_ARGS;
1394   }
1395
1396   last_ret_val = old_mask = sysio_umask(argv[0]);
1397   my_errno = errno;
1398   DBG(3, fprintf(outfp, "Previous umask was %o\n", old_mask));
1399   last_type = UINT;
1400
1401   return SUCCESS;
1402 }
1403
1404 int test_do_iowait(int argc, char **argv)
1405 {
1406   long err;
1407   ioid_t ioid;
1408
1409   if (argc != 1) {
1410     DBG(2, fprintf(outfp, "Incorrect amount of args (%d) for iowait\n", argc));
1411     return INVALID_ARGS;
1412   }
1413
1414   err = get_obj(argv[0]);
1415   if (err < 0) {
1416     DBG(2, fprintf(outfp, "Cannot find ioid at %s\n", argv[0]));
1417     return INVALID_VAR;
1418   }
1419
1420   ioid = (ioid_t)err;
1421
1422   last_ret_val =  iowait(ioid);
1423   my_errno = errno;
1424   if (last_ret_val < 0) {
1425     my_perror("iowait");
1426   }
1427   last_type = SINT;
1428
1429   return SUCCESS;
1430 }
1431
1432 int test_do_iodone(int argc, char **argv)
1433 {
1434   long err;
1435   ioid_t ioid;
1436
1437   if (argc != 1) {
1438     DBG(2, fprintf(outfp, "Incorrect amount of args (%d) for iodone\n", argc));
1439     return INVALID_ARGS;
1440   }
1441
1442   err = get_obj(argv[0]);
1443   if (err < 0) {
1444     DBG(2, fprintf(outfp, "Cannot find ioid at %s\n", argv[0]));
1445     return INVALID_VAR;
1446   }
1447   ioid = (ioid_t)err;
1448
1449   last_ret_val =  iowait(ioid);
1450   if (last_ret_val < 0) {
1451     my_perror("iodone");
1452   }
1453   my_errno = errno;
1454   last_type = SINT;
1455
1456   return SUCCESS;
1457
1458 }
1459
1460 int test_do_ipread(int argc, char **argv)
1461 {
1462   int fd, index, count, offset;
1463   char *buf;
1464
1465   if (argc != 4) {
1466     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipread\n", argc));
1467     return INVALID_ARGS;
1468   }
1469
1470   fd = get_obj(argv[0]);
1471   if (fd < 0) {
1472     DBG(2, fprintf(outfp, "Unable to find file at %s\n", argv[0]));
1473     return INVALID_VAR;
1474   }
1475
1476   index = get_obj(argv[1]);
1477   if (index < 0) {
1478     DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[1]));
1479     return INVALID_VAR;
1480   }
1481
1482   buf = buflist[index]->buf;
1483
1484   count = get_obj(argv[2]);
1485   if (count < 0) {
1486     DBG(2, fprintf(outfp, "Do not understand count %s\n", argv[2]));
1487     return INVALID_ARGS;
1488   }
1489
1490   offset = get_obj(argv[3]);
1491   if (offset < 0) {
1492     DBG(2, fprintf(outfp, "Unable to understand offset of %s\n", argv[3]));
1493     return INVALID_ARGS;
1494   }
1495
1496   last_ret_val = (long)ipread(fd, buf, count, offset);
1497   if (last_ret_val < 0) {
1498     my_perror("ipread");
1499   }
1500   my_errno = errno;
1501   last_type = SINT;
1502
1503   return SUCCESS;
1504 }
1505
1506 int test_do_iread(int argc, char **argv)
1507 {
1508   int fd, index, count;
1509   char *buf;
1510
1511   if (argc != 3) {
1512     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iread\n", argc));
1513     return INVALID_ARGS;
1514   }
1515
1516   fd = get_obj(argv[0]);
1517   if (fd < 0) {
1518     DBG(2, fprintf(outfp, "Unable to find file at %s\n", argv[0]));
1519     return INVALID_VAR;
1520   }
1521
1522   index = get_obj(argv[1]);
1523   if (index < 0) {
1524     DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[1]));
1525     return INVALID_VAR;
1526   }
1527
1528   buf = buflist[index]->buf;
1529
1530   count = get_obj(argv[2]);
1531   if (count < 0) {
1532     DBG(2, fprintf(outfp, "Do not understand count %s\n", argv[2]));
1533     return INVALID_ARGS;
1534   }
1535
1536   last_ret_val = (long) iread(fd, buf, count);
1537   if (last_ret_val < 0) {
1538     my_perror("iread");
1539   }
1540   my_errno = errno;
1541   last_type = SINT;
1542
1543   return SUCCESS;
1544 }
1545
1546
1547 int test_do_ipreadv(int argc, char **argv)
1548 {
1549   int fd, count, index;
1550   off_t offset;
1551   char *buf;
1552   struct iovec *iov;
1553
1554   if (argc != 4) {
1555     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipreadv\n", argc));
1556     return INVALID_ARGS;
1557   }
1558
1559   fd = get_obj(argv[0]);
1560
1561   if (fd < 0) {
1562     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1563     return INVALID_VAR;
1564   }
1565
1566   index = get_obj(argv[1]);
1567
1568   if (index < 0) {
1569     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1570     return INVALID_VAR;
1571   }
1572
1573   buf = buflist[index]->buf;
1574
1575   iov = (struct iovec *)buf;
1576   count = get_obj(argv[2]);
1577
1578   if (count < 0) {
1579     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
1580     return INVALID_ARGS;
1581   }
1582
1583   offset = get_obj(argv[3]);
1584   if (offset < 0) {
1585     DBG(2, fprintf(outfp, "Unable to understand offset value %s\n", argv[3]));
1586     return INVALID_ARGS;
1587   }
1588
1589   DBG(3, fprintf(outfp, "ipreadv(fd: %d vector:{iov_base: %p iov_len %d} count: %d offset: %d\n",
1590                  fd, iov->iov_base, (int)iov->iov_len, count, (int) offset));
1591
1592   last_ret_val = (long) ipreadv(fd, iov, count, offset);
1593   if (last_ret_val < 0)
1594     my_perror("ipreadv");
1595   my_errno = errno;
1596   last_type = SINT;
1597
1598   return SUCCESS;
1599 }
1600
1601
1602 int test_do_preadv(int argc, char **argv)
1603 {
1604   int fd, count, index;
1605   off_t offset;
1606   char *buf;
1607   struct iovec *iov;
1608
1609   if (argc != 4) {
1610     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to preadv\n", argc));
1611     return INVALID_ARGS;
1612   }
1613
1614   fd = get_obj(argv[0]);
1615
1616   if (fd < 0) {
1617     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1618     return INVALID_VAR;
1619   }
1620
1621   index = get_obj(argv[1]);
1622
1623   if (index < 0) {
1624     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1625     return INVALID_VAR;
1626   }
1627
1628   buf = buflist[index]->buf;
1629
1630   iov = (struct iovec *)buf;
1631   count = get_obj(argv[2]);
1632
1633   if (count < 0) {
1634     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
1635     return INVALID_ARGS;
1636   }
1637
1638   offset = get_obj(argv[3]);
1639   if (offset < 0) {
1640     DBG(2, fprintf(outfp, "Unable to understand offset value %s\n", argv[3]));
1641     return INVALID_ARGS;
1642   }
1643
1644   DBG(3, fprintf(outfp, "preadv(fd: %d vector:{iov_base: %p iov_len %d} count: %d offset: %d\n",
1645                  fd, iov->iov_base, (int) iov->iov_len, count, (int) offset));
1646
1647   last_ret_val = preadv(fd, iov, count, offset);
1648   my_errno = errno;
1649   if (last_ret_val < 0)
1650     my_perror("preadv");
1651   last_type = SINT;
1652
1653   return SUCCESS;
1654 }
1655
1656
1657 int test_do_pread(int argc, char **argv)
1658 {
1659   int fd, count, index, numbytes, offset;
1660   char *buf;
1661
1662   if (argc != 4) {
1663     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pread\n", argc));
1664     return INVALID_ARGS;
1665   }
1666
1667
1668   fd = get_obj(argv[0]);
1669
1670   if (fd < 0) {
1671     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
1672                    argv[0]));
1673     return INVALID_VAR;
1674   }
1675
1676   index = get_obj(argv[1]);
1677
1678   if (index < 0) {
1679     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
1680                    argv[1]));
1681     return INVALID_VAR;
1682   }
1683
1684   buf = buflist[index]->buf;
1685
1686   count = get_obj(argv[2]);
1687   if (count < 0) {
1688     DBG(2, fprintf(outfp, "Unable to understand count of %s\n", argv[1]));
1689     return INVALID_ARGS;
1690   }
1691
1692   offset = get_obj(argv[3]);
1693   if (count < 0) {
1694     DBG(2, fprintf(outfp, "Unable to understand offset of %s\n", argv[2]));
1695     return INVALID_ARGS;
1696   }
1697
1698
1699   last_ret_val = numbytes = (int) pread(fd, buf, count, offset);
1700   my_errno = errno;
1701   DBG(4, fprintf(outfp, "Read %d bytes out of %d starting at offset %x\n",
1702                  numbytes, count, offset));
1703   DBG(3, fprintf(outfp, "Got %s\n", buf));
1704   last_type = SINT;
1705
1706   return SUCCESS;
1707 }
1708
1709
1710 int test_do_ireadv(int argc, char **argv)
1711 {
1712   int fd, count, index;
1713   char *buf;
1714   struct iovec *iov;
1715
1716   if (argc != 3) {
1717     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ireadv\n", argc));
1718     return INVALID_ARGS;
1719   }
1720
1721   fd = get_obj(argv[0]);
1722
1723   if (fd < 0) {
1724     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1725     return INVALID_VAR;
1726   }
1727
1728   index = get_obj(argv[1]);
1729
1730   if (index < 0) {
1731     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1732     return INVALID_VAR;
1733   }
1734
1735   buf = buflist[index]->buf;
1736
1737   iov = (struct iovec *)buf;
1738   count = get_obj(argv[2]);
1739
1740   if (count < 0) {
1741     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
1742     return INVALID_ARGS;
1743   }
1744
1745   DBG(3, fprintf(outfp, "ireadv (fd: %d, vector:{ iov_base: %p iov_len %d }, count: %d\n",
1746                  fd, iov->iov_base, (int)iov->iov_len, count));
1747
1748   last_ret_val = (long) ireadv(fd, iov, count);
1749   if (last_ret_val < 0)
1750     my_perror("ireadv");
1751   my_errno = errno;
1752   last_type = SINT;
1753
1754   return SUCCESS;
1755 }
1756
1757 int test_do_readv(int argc, char **argv)
1758 {
1759   int fd, count, index;
1760   char *buf;
1761   struct iovec *iov;
1762
1763   if (argc != 3) {
1764     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to readv\n", argc));
1765     return INVALID_ARGS;
1766   }
1767
1768   fd = get_obj(argv[0]);
1769
1770   if (fd < 0) {
1771     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1772     return INVALID_VAR;
1773   }
1774
1775   index = get_obj(argv[1]);
1776
1777   if (index < 0) {
1778     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1779     return INVALID_VAR;
1780   }
1781
1782   buf = buflist[index]->buf;
1783
1784   iov = (struct iovec *)buf;
1785   count = get_obj(argv[2]);
1786
1787   if (count < 0) {
1788     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
1789     return INVALID_ARGS;
1790   }
1791
1792   DBG(3, fprintf(outfp, "ireadv (fd: %d, vector:{ iov_base: %p iov_len %d }, count: %d\n",
1793                  fd, iov->iov_base, (int)iov->iov_len, count));
1794
1795   last_ret_val = readv(fd, iov, count);
1796   if (last_ret_val < 0)
1797     my_perror("readv");
1798   my_errno = errno;
1799   last_type = SINT;
1800
1801   return SUCCESS;
1802 }
1803
1804 int test_do_read(int argc, char **argv)
1805 {
1806   int fd, count, index, numbytes=0;
1807   char *buf;
1808
1809   if (argc < 3) {
1810     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to read\n", argc));
1811     return INVALID_ARGS;
1812   }
1813
1814
1815   fd = get_obj(argv[0]);
1816
1817   if (fd < 0) {
1818     DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
1819                    argv[0]));
1820     return INVALID_VAR;
1821   }
1822
1823   index = get_obj(argv[1]);
1824
1825
1826   if (index < 0) {
1827     DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
1828                    argv[1]));
1829     return INVALID_VAR;
1830   }
1831
1832   buf = buflist[index]->buf;
1833
1834   count = get_obj(argv[2]);
1835
1836   if ( (argc == 4) && (!strcmp(argv[3], "delay")) ){
1837     int i;
1838     /* Wait a little while for input */
1839     for (i=0; i < count; i++) {
1840       sleep(0.005);
1841       numbytes += (int) read(fd, buf, 1);
1842       last_ret_val = numbytes;
1843
1844     }
1845   } else {
1846     last_ret_val = numbytes = (int) read(fd, buf, count);
1847   }
1848   my_errno = errno;
1849
1850   DBG(3, fprintf(outfp, "Read %d bytes out of %d\n", numbytes, count));
1851   DBG(3, fprintf(outfp, "Got %s\n", buf));
1852   last_type = SINT;
1853
1854   return SUCCESS;
1855 }
1856
1857 int test_do_ipwritev(int argc, char **argv)
1858 {
1859   int fd, count, index, offset;
1860   char *buf;
1861   struct iovec *iov;
1862
1863   if (argc != 4) {
1864     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipwritev\n", argc));
1865     return INVALID_ARGS;
1866   }
1867
1868   fd = get_obj(argv[0]);
1869
1870   if (fd < 0) {
1871     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1872     return INVALID_VAR;
1873   }
1874
1875   index = get_obj(argv[1]);
1876
1877   if (index < 0) {
1878     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1879     return INVALID_VAR;
1880   }
1881
1882   buf = buflist[index]->buf;
1883
1884   iov = (struct iovec *)buf;
1885
1886   count = get_obj(argv[2]);
1887   if (count < 0) {
1888     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
1889     return INVALID_ARGS;
1890   }
1891
1892   offset = get_obj(argv[3]);
1893   if (offset < 0) {
1894     DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
1895     return INVALID_ARGS;
1896   }
1897
1898   DBG(3, fprintf(outfp,
1899                  "ipwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d, offset: %d\n",
1900                  fd, iov->iov_base, (int)iov->iov_len, count, offset));
1901
1902   last_ret_val = (long) ipwritev(fd, iov, count, offset);
1903   my_errno = errno;
1904   if (last_ret_val < 0)
1905     my_perror("ipwritev");
1906   last_type = SINT;
1907
1908   return SUCCESS;
1909 }
1910
1911 int test_do_ipwrite(int argc, char **argv)
1912 {
1913   int fd, count, index, offset;
1914   char *buf;
1915
1916   if (argc != 4) {
1917     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipwrite\n", argc));
1918     return INVALID_ARGS;
1919   }
1920
1921   fd = get_obj(argv[0]);
1922
1923   if (fd < 0) {
1924     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1925     return INVALID_VAR;
1926   }
1927
1928   index = get_obj(argv[1]);
1929
1930   if (index < 0) {
1931     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1932     return INVALID_VAR;
1933   }
1934
1935   buf = buflist[index]->buf;
1936
1937   count = get_obj(argv[2]);
1938   if (count < 0) {
1939     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
1940     return INVALID_ARGS;
1941   }
1942
1943   offset = get_obj(argv[3]);
1944   if (offset < 0) {
1945     DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
1946     return INVALID_ARGS;
1947   }
1948
1949   last_ret_val = (long) ipwrite(fd, buf, count, offset);
1950   if (last_ret_val < 0)
1951     my_perror("ipwrite");
1952   my_errno = errno;
1953   last_type = SINT;
1954
1955   return SUCCESS;
1956 }
1957
1958 int test_do_pwritev(int argc, char **argv)
1959 {
1960   int fd, count, index, offset;
1961   char *buf;
1962   struct iovec *iov;
1963
1964   if (argc != 4) {
1965     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pwritev\n", argc));
1966     return INVALID_ARGS;
1967   }
1968
1969   fd = get_obj(argv[0]);
1970
1971   if (fd < 0) {
1972     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
1973     return INVALID_VAR;
1974   }
1975
1976   index = get_obj(argv[1]);
1977
1978   if (index < 0) {
1979     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
1980     return INVALID_VAR;
1981   }
1982
1983   buf = buflist[index]->buf;
1984
1985   iov = (struct iovec *)buf;
1986
1987   count = get_obj(argv[2]);
1988   if (count < 0) {
1989     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
1990     return INVALID_ARGS;
1991   }
1992
1993   offset = get_obj(argv[3]);
1994   if (offset < 0) {
1995     DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
1996     return INVALID_ARGS;
1997   }
1998
1999
2000   DBG(3, fprintf(outfp,
2001                  "pwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d, offset: %d\n",
2002                  fd, iov->iov_base, (int)iov->iov_len, count, offset));
2003
2004   last_ret_val = (long) pwritev(fd, iov, count, offset);
2005   if (last_ret_val < 0)
2006     my_perror("ipwritev");
2007   my_errno = errno;
2008   last_type = SINT;
2009
2010   return SUCCESS;
2011 }
2012
2013 int test_do_pwrite(int argc, char **argv)
2014 {
2015   int fd, count, index, offset;
2016   char *buf;
2017
2018   if (argc != 4) {
2019     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pwrite\n", argc));
2020     return INVALID_ARGS;
2021   }
2022
2023   fd = get_obj(argv[0]);
2024
2025   if (fd < 0) {
2026     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2027     return INVALID_VAR;
2028   }
2029
2030   index = get_obj(argv[1]);
2031
2032   if (index < 0) {
2033     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2034     return INVALID_VAR;
2035   }
2036
2037   buf = buflist[index]->buf;
2038
2039   count = get_obj(argv[2]);
2040   if (count < 0) {
2041     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
2042     return INVALID_ARGS;
2043   }
2044
2045   offset = get_obj(argv[3]);
2046   if (offset < 0) {
2047     DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
2048     return INVALID_ARGS;
2049   }
2050
2051   last_ret_val = pwrite(fd, buf, count, offset);
2052   my_errno = errno;
2053   if (last_ret_val < 0)
2054     my_perror("pwrite");
2055   last_type = SINT;
2056
2057   return SUCCESS;
2058 }
2059
2060
2061 int test_do_iwritev(int argc, char **argv)
2062 {
2063   int fd, count, index;
2064   char *buf;
2065   struct iovec *iov;
2066
2067   if (argc != 3) {
2068     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwritev\n", argc));
2069     return INVALID_ARGS;
2070   }
2071
2072   fd = get_obj(argv[0]);
2073
2074   if (fd < 0) {
2075     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2076     return INVALID_VAR;
2077   }
2078
2079   index = get_obj(argv[1]);
2080
2081   if (index < 0) {
2082     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2083     return INVALID_VAR;
2084   }
2085
2086   buf = buflist[index]->buf;
2087
2088   iov = (struct iovec *)buf;
2089
2090   count = get_obj(argv[2]);
2091   if (count < 0) {
2092     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
2093     return INVALID_ARGS;
2094   }
2095
2096   DBG(3, fprintf(outfp, "iwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d\n",
2097                  fd, iov->iov_base, (int)iov->iov_len, count));
2098
2099   last_ret_val = (long) iwritev(fd, iov, count);
2100   my_errno = errno;
2101   if (last_ret_val < 0)
2102     my_perror("iwritev");
2103   last_type = SINT;
2104
2105   return SUCCESS;
2106 }
2107
2108 int test_do_iwrite(int argc, char **argv)
2109 {
2110   int fd, count, index;
2111   char *buf;
2112
2113   if (argc != 3) {
2114     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwrite\n", argc));
2115     return INVALID_ARGS;
2116   }
2117
2118   fd = get_obj(argv[0]);
2119
2120   if (fd < 0) {
2121     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2122     return INVALID_VAR;
2123   }
2124
2125   index = get_obj(argv[1]);
2126
2127   if (index < 0) {
2128     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2129     return INVALID_VAR;
2130   }
2131
2132   buf = buflist[index]->buf;
2133
2134   count = get_obj(argv[2]);
2135   if (count < 0) {
2136     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
2137     return INVALID_ARGS;
2138   }
2139
2140   last_ret_val = (long) iwrite(fd, buf, count);
2141   my_errno = errno;
2142   if (last_ret_val < 0)
2143     my_perror("iwrite");
2144   last_type = SINT;
2145
2146   return SUCCESS;
2147 }
2148
2149
2150 int test_do_write(int argc, char **argv)
2151 {
2152   int fd, count, index, err;
2153   char *buf;
2154
2155   if (argc != 3) {
2156     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to write\n", argc));
2157     return INVALID_ARGS;
2158   }
2159
2160   fd = get_obj(argv[0]);
2161
2162   if (fd < 0) {
2163     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2164     return INVALID_VAR;
2165   }
2166
2167   index = get_obj(argv[1]);
2168
2169   if (index < 0) {
2170     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2171     return INVALID_VAR;
2172   }
2173
2174   buf = buflist[index]->buf;
2175
2176   count = get_obj(argv[2]);
2177   if (count < 0) {
2178     DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
2179     return INVALID_ARGS;
2180   }
2181
2182   DBG(4, fprintf(outfp, "Writing out %d bytes (%s) using fd of %x\n",
2183                  count, buf, fd));
2184   err = write(fd, buf, count);
2185   if (err < 0)
2186     my_perror("write");
2187
2188   last_ret_val = err;
2189   my_errno = errno;
2190   last_type = SINT;
2191
2192   return SUCCESS;
2193 }
2194
2195
2196 int test_do_writev(int argc, char **argv)
2197 {
2198   int fd, count, index;
2199   char *buf;
2200   struct iovec *iov;
2201
2202   if (argc != 3) {
2203     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to writev\n", argc));
2204     return INVALID_ARGS;
2205   }
2206
2207   fd = get_obj(argv[0]);
2208
2209   if (fd < 0) {
2210     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2211     return INVALID_ARGS;
2212   }
2213
2214   index = get_obj(argv[1]);
2215
2216   if (index < 0) {
2217     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2218     return INVALID_VAR;
2219   }
2220
2221   buf = buflist[index]->buf;
2222
2223   iov = (struct iovec *)buf;
2224   count = get_obj(argv[2]);
2225
2226   if (count < 0) {
2227     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2228     return INVALID_ARGS;
2229   }
2230
2231   DBG(3, fprintf(outfp, "writev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d\n",
2232                  fd, iov->iov_base, (int)iov->iov_len, count));
2233
2234   last_ret_val = writev(fd, iov, count);
2235   if (last_ret_val < 0)
2236     my_perror("writev");
2237   my_errno = errno;
2238   last_type = SINT;
2239
2240   return SUCCESS;
2241 }
2242
2243 int test_do_mknod(int argc, char **argv)
2244 {
2245   int dev;
2246
2247   if (argc != 3) {
2248     DBG(2, fprintf(outfp, "Invalid number of args (%d) for mknod\n", argc));
2249     return INVALID_ARGS;
2250   }
2251
2252   dev = get_obj(argv[2]);
2253   if (dev < 0) {
2254     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2255     return INVALID_ARGS;
2256   }
2257   last_type = SINT;
2258
2259
2260   return sysio_mknod(argv[0], argv[1], (dev_t) dev);
2261 }
2262
2263 int test_do_umount(int argc, char **argv)
2264 {
2265   int err;
2266
2267   if (argc != 1) {
2268     DBG(2, fprintf(outfp, "Invalid number (%d) of args for umount\n", argc));
2269     return INVALID_ARGS;
2270   }
2271
2272   err = umount(argv[0]);
2273   if (err)
2274     my_perror("umount");
2275
2276   my_errno = errno;
2277   last_ret_val = err;
2278   last_type = SINT;
2279
2280   return SUCCESS;
2281 }
2282
2283 int test_do_init_iovec(int argc, char **argv)
2284 {
2285         int iov_index, buf_index;
2286         int offset, len, pos;
2287         struct iovec *iov_ptr;
2288         char *base_ptr;
2289
2290         if (argc != 5) {
2291                 DBG(2, fprintf(outfp, "Need buffer, offset, len, array pos, and iov pointer\n"));
2292                 return INVALID_ARGS;
2293         }
2294
2295         if ((buf_index = get_obj(argv[0])) < 0) {
2296                 DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[0]));
2297                 return INVALID_VAR;
2298         }
2299         base_ptr = buflist[buf_index]->buf;
2300
2301         if ((offset = get_obj(argv[1])) < 0) {
2302                 DBG(2, fprintf(outfp, "Cannot understand offset of %s\n", argv[1]));
2303                 return INVALID_VAR;
2304         }
2305
2306         if ((len = get_obj(argv[2])) < 0) {
2307                 DBG(2, fprintf(outfp, "Cannot understand len of %s\n", argv[2]));
2308                 return INVALID_VAR;
2309         }
2310
2311         if ((pos = get_obj(argv[3])) < 0) {
2312                 DBG(2, fprintf(outfp, "Cannot understand array pos of %s\n", argv[3]));
2313                 return INVALID_VAR;
2314         }
2315
2316         if ((iov_index = get_obj(argv[4])) < 0) {
2317                 DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[4]));
2318                 return INVALID_VAR;
2319         }
2320         iov_ptr = (struct iovec *)(buflist[iov_index]->buf);
2321
2322         iov_ptr[pos].iov_len = len;
2323         iov_ptr[pos].iov_base = (void *)(base_ptr + offset);
2324
2325         DBG(3, fprintf(outfp, "iov_ptr.len is %d and base is %p\n",
2326                        (int)iov_ptr[pos].iov_len, iov_ptr[pos].iov_base));
2327    my_errno = errno;
2328   last_type = PTR;
2329
2330         return SUCCESS;
2331 }
2332
2333
2334 int test_do_init_xtvec(int argc, char **argv)
2335 {
2336         int xtv_index;
2337         int offset, len, pos;
2338         struct xtvec *xtv_ptr;
2339
2340         if (argc != 4) {
2341                 DBG(2, fprintf(outfp, "Need offset, len, array pos, and xtv pointer\n"));
2342                 return INVALID_ARGS;
2343         }
2344
2345         if ((offset = get_obj(argv[0])) < 0) {
2346                 DBG(2, fprintf(outfp, "Cannot understand offset of %s\n", argv[0]));
2347                 return INVALID_VAR;
2348         }
2349
2350         if ((len = get_obj(argv[1])) < 0) {
2351                 DBG(2, fprintf(outfp, "Cannot understand len of %s\n", argv[1]));
2352                 return INVALID_VAR;
2353         }
2354
2355         if ((pos = get_obj(argv[2])) < 0) {
2356                 DBG(2, fprintf(outfp, "Cannot understand array pos of %s\n", argv[2]));
2357                 return INVALID_VAR;
2358         }
2359
2360         if ((xtv_index = get_obj(argv[3])) < 0) {
2361                 DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[3]));
2362                 return INVALID_VAR;
2363         }
2364         xtv_ptr = (struct xtvec *)(buflist[xtv_index]->buf);
2365
2366         xtv_ptr[pos].xtv_len = len;
2367         xtv_ptr[pos].xtv_off = offset;
2368
2369         DBG(3, fprintf(outfp, "xtv_ptr.len is %d and offset is %d\n",
2370                        (int)xtv_ptr[pos].xtv_len, (int)xtv_ptr[pos].xtv_off));
2371
2372         my_errno = errno;
2373   last_type = PTR;
2374
2375         return SUCCESS;
2376 }
2377
2378 int test_do_writex(int argc, char **argv)
2379 {
2380   int fd, iov_count, xtv_count,index;
2381   char *buf;
2382   struct iovec *iov;
2383         struct xtvec *xtv;
2384
2385   if (argc != 5) {
2386     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to writex\n", argc));
2387     return INVALID_ARGS;
2388   }
2389
2390   fd = get_obj(argv[0]);
2391
2392   if (fd < 0) {
2393     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2394     return INVALID_ARGS;
2395   }
2396
2397   index = get_obj(argv[1]);
2398
2399   if (index < 0) {
2400     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2401     return INVALID_VAR;
2402   }
2403
2404   buf = buflist[index]->buf;
2405
2406   iov = (struct iovec *)buf;
2407   iov_count = get_obj(argv[2]);
2408
2409   if (iov_count < 0) {
2410     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2411     return INVALID_ARGS;
2412   }
2413
2414   index = get_obj(argv[3]);
2415
2416   if (index < 0) {
2417     DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
2418     return INVALID_VAR;
2419   }
2420
2421   buf = buflist[index]->buf;
2422
2423   xtv = (struct xtvec *)buf;
2424   xtv_count = get_obj(argv[4]);
2425
2426   if (xtv_count < 0) {
2427     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
2428     return INVALID_ARGS;
2429   }
2430
2431   DBG(3, fprintf(outfp, "writex(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
2432                  fd, (void *)iov, iov_count, (void *)xtv, xtv_count));
2433
2434   last_ret_val = writex(fd, iov, iov_count, xtv, xtv_count);
2435   if (last_ret_val < 0)
2436     my_perror("writex");
2437   my_errno = errno;
2438   last_type = SINT;
2439
2440   return SUCCESS;
2441 }
2442
2443
2444 int test_do_iwritex(int argc, char **argv)
2445 {
2446   int fd, iov_count, xtv_count,index;
2447   char *buf;
2448   struct iovec *iov;
2449         struct xtvec *xtv;
2450
2451   if (argc != 5) {
2452     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwritex\n", argc));
2453     return INVALID_ARGS;
2454   }
2455
2456   fd = get_obj(argv[0]);
2457
2458   if (fd < 0) {
2459     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2460     return INVALID_ARGS;
2461   }
2462
2463   index = get_obj(argv[1]);
2464
2465   if (index < 0) {
2466     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2467     return INVALID_VAR;
2468   }
2469
2470   buf = buflist[index]->buf;
2471
2472   iov = (struct iovec *)buf;
2473   iov_count = get_obj(argv[2]);
2474
2475   if (iov_count < 0) {
2476     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2477     return INVALID_ARGS;
2478   }
2479
2480   index = get_obj(argv[3]);
2481
2482   if (index < 0) {
2483     DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
2484     return INVALID_VAR;
2485   }
2486
2487   buf = buflist[index]->buf;
2488
2489   xtv = (struct xtvec *)buf;
2490   xtv_count = get_obj(argv[4]);
2491
2492   if (xtv_count < 0) {
2493     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
2494     return INVALID_ARGS;
2495   }
2496
2497   DBG(3, fprintf(outfp, "iwritex(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
2498                  fd, (void *)iov, iov_count, (void *)xtv, xtv_count));
2499
2500   last_ret_val = (long) iwritex(fd, iov, iov_count, xtv, xtv_count);
2501   if (last_ret_val < 0)
2502     my_perror("iwritex");
2503   my_errno = errno;
2504   last_type = SINT;
2505
2506         return SUCCESS;
2507 }
2508
2509
2510 int test_do_readx(int argc, char **argv)
2511 {
2512   int fd, iov_count, xtv_count,index;
2513   char *buf;
2514   struct iovec *iov;
2515         struct xtvec *xtv;
2516
2517   if (argc != 5) {
2518     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to readx\n", argc));
2519     return INVALID_ARGS;
2520   }
2521
2522   fd = get_obj(argv[0]);
2523
2524   if (fd < 0) {
2525     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2526     return INVALID_ARGS;
2527   }
2528
2529   index = get_obj(argv[1]);
2530
2531   if (index < 0) {
2532     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2533     return INVALID_VAR;
2534   }
2535
2536   buf = buflist[index]->buf;
2537
2538   iov = (struct iovec *)buf;
2539   iov_count = get_obj(argv[2]);
2540
2541   if (iov_count < 0) {
2542     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2543     return INVALID_ARGS;
2544   }
2545
2546   index = get_obj(argv[3]);
2547
2548   if (index < 0) {
2549     DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
2550     return INVALID_VAR;
2551   }
2552
2553   buf = buflist[index]->buf;
2554
2555   xtv = (struct xtvec *)buf;
2556   xtv_count = get_obj(argv[4]);
2557
2558   if (xtv_count < 0) {
2559     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
2560     return INVALID_ARGS;
2561   }
2562
2563   DBG(3, fprintf(outfp, "readx(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
2564                  fd, (void *)iov, iov_count, (void *)xtv, xtv_count));
2565
2566   last_ret_val = readx(fd, iov, iov_count, xtv, xtv_count);
2567   if (last_ret_val < 0)
2568     my_perror("readx");
2569   my_errno = errno;
2570   last_type = SINT;
2571
2572   return SUCCESS;
2573 }
2574
2575
2576 int test_do_ireadx(int argc, char **argv)
2577 {
2578   int fd, iov_count, xtv_count,index;
2579   char *buf;
2580   struct iovec *iov;
2581         struct xtvec *xtv;
2582
2583   if (argc != 5) {
2584     DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ireadx\n", argc));
2585     return INVALID_ARGS;
2586   }
2587
2588   fd = get_obj(argv[0]);
2589
2590   if (fd < 0) {
2591     DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
2592     return INVALID_ARGS;
2593   }
2594
2595   index = get_obj(argv[1]);
2596
2597   if (index < 0) {
2598     DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
2599     return INVALID_VAR;
2600   }
2601
2602   buf = buflist[index]->buf;
2603
2604   iov = (struct iovec *)buf;
2605   iov_count = get_obj(argv[2]);
2606
2607   if (iov_count < 0) {
2608     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2609     return INVALID_ARGS;
2610   }
2611
2612   index = get_obj(argv[3]);
2613
2614   if (index < 0) {
2615     DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
2616     return INVALID_VAR;
2617   }
2618
2619   buf = buflist[index]->buf;
2620
2621   xtv = (struct xtvec *)buf;
2622   xtv_count = get_obj(argv[4]);
2623
2624   if (xtv_count < 0) {
2625     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
2626     return INVALID_ARGS;
2627   }
2628
2629   DBG(3, fprintf(outfp, "ireadx(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
2630                  fd, (void *)iov, iov_count, (void *)xtv, xtv_count));
2631
2632   last_ret_val = (long) ireadx(fd, iov, iov_count, xtv, xtv_count);
2633   if (last_ret_val < 0)
2634     my_perror("ireadx");
2635   my_errno = errno;
2636   last_type = SINT;
2637
2638         return SUCCESS;
2639 }
2640
2641
2642 int do_checkbuf(int argc, char **argv)
2643 {
2644          int size, val, index, i, offset;
2645          int *ref_buf, *buf;
2646
2647         if (argc != 4) {
2648                 DBG(2, fprintf(outfp, "Need buffer, val, and offset for checkbuf\n"));
2649                 return INVALID_ARGS;
2650         }
2651
2652         index = get_obj(argv[0]);
2653
2654   if (index < 0) {
2655     DBG(2, fprintf(outfp, "Unable to find buf described by %s\n", argv[0]));
2656     return INVALID_VAR;
2657   }
2658
2659   buf = (int *)buflist[index]->buf;
2660
2661
2662         size = get_obj(argv[1]);
2663
2664         if (size < 0) {
2665     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[1]));
2666     return INVALID_ARGS;
2667   }
2668
2669         val = get_obj(argv[2]);
2670
2671   if (val < 0) {
2672     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
2673     return INVALID_ARGS;
2674   }
2675
2676
2677         offset = get_obj(argv[3]);
2678
2679         if (offset < 0) {
2680     DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[3]));
2681     return INVALID_ARGS;
2682   }
2683
2684
2685         ref_buf = (int *)malloc(size);
2686         memset((void *)ref_buf, val, size);
2687
2688         last_ret_val =0;
2689         buf = (int *)((char *)buf + offset);
2690         for (i=0; (unsigned)i < size/sizeof(int); i++) {
2691                 if (buf[i] != ref_buf[i]) {
2692                         DBG(2, fprintf(stderr, "At pos %d I found a 0x%08x instead of 0x%08x\n",
2693                                                                                  i, buf[i], ref_buf[i]));
2694                         fprintf(stderr, "At pos %d I found a 0x%08x instead of 0x%08x (val was %d)\n",
2695                                                                                  i, buf[i], ref_buf[i], val);
2696                         last_ret_val = 1;
2697                         break;
2698                 }
2699         }
2700
2701   my_errno = errno;
2702   last_type = SINT;
2703
2704         return SUCCESS;
2705 }