dmapi/src/suite2/src/test_invis.c

   1 /*
   2  * Copyright (c) 2000-2001 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 #include <sys/types.h>
  34 #include <sys/stat.h>
  35
  36 #include <limits.h>
  37
  38 #include <lib/hsm.h>
  39 #include <lib/errtest.h>
  40
  41 #include <getopt.h>
  42 #include <string.h>
  43 #include <time.h>
  44
  45 /*---------------------------------------------------------------------------
  46
  47 Automated test of the DMAPI functions dm_write_invis() and dm_read_invis()
  48
  49 The command line is:
  50
  51         test_invis [-s sid] [-v] ls_path pathname
  52
  53 where:
  54    sid
  55       is the session ID whose events you you are interested in.
  56    ls_path
  57       is the path to a specific copy of ls, important only for its size
  58    pathname
  59       is the filesystem to use for the test.
  60
  61 DM_WRITE_SYNC is is not supported.
  62 ----------------------------------------------------------------------------*/
  63
  64 #define OFF_MAX  50
  65 #define OFF_STEP 5
  66 #define LEN_MAX  50
  67 #define LEN_STEP 5
  68
  69 #ifndef linux
  70 extern  char    *sys_errlist[];
  71 #endif
  72 extern  int     optind;
  73 extern  char    *optarg;
  74
  75
  76 char    *Progname;
  77
  78
  79 static void
  80 usage(void)
  81 {
  82         fprintf(stderr, "usage:\t%s [-v] [-s sid] ls_path pathname\n",
  83                 Progname);
  84         exit(1);
  85 }
  86
  87
  88 int
  89 main(
  90         int     argc,
  91         char    **argv)
  92 {
  93         dm_sessid_t     sid = DM_NO_SESSION;
  94         char            *dir_name = NULL;
  95         char            *ls_path = NULL;
  96         dm_off_t        offset = 0;
  97         dm_size_t       length = 1;
  98         dm_size_t       curlength = 0;
  99         u_char          ch;
 100         void            *bufp = NULL;
 101         void            *hanp;
 102         size_t          hlen;
 103         dm_ssize_t      rc;
 104         char            *name;
 105         char            test_file[128];
 106         char            command[128];
 107         int             opt;
 108         int             i;
 109         int             j;
 110         int             k;
 111         int             Vflag=0;
 112         struct stat     statbuf;
 113         struct stat     checkbuf;
 114         dm_token_t      test_token;
 115         void*           test_vp;
 116         int             cont;
 117         int             error_reported;
 118
 119         if (Progname = strrchr(argv[0], '/')) {
 120                 Progname++;
 121         } else {
 122                 Progname = argv[0];
 123         }
 124
 125         /* Crack and validate the command line options. */
 126
 127         while ((opt = getopt(argc, argv, "vs:")) != EOF) {
 128                 switch (opt) {
 129                 case 'v':
 130                         Vflag++;
 131                         break;
 132                 case 's':
 133                         sid = atol(optarg);
 134                         break;
 135                 case '?':
 136                         usage();
 137                 }
 138         }
 139         if (optind + 2 != argc)
 140                 usage();
 141         ls_path = argv[optind];
 142         dir_name = argv[optind+1];
 143
 144         if (dm_init_service(&name) == -1)  {
 145                 fprintf(stderr, "Can't initialize the DMAPI\n");
 146                 exit(1);
 147         }
 148         if (sid == DM_NO_SESSION)
 149                 find_test_session(&sid);
 150
 151         /* Get a random character for read/write tests */
 152         srand((unsigned int)time(NULL));
 153         ch = (char)rand();
 154
 155         printf("Invisible read/write tests beginning...\n");
 156
 157         /* File creation loop*/
 158         for(i=0; i<LEN_MAX; i+=LEN_STEP) {
 159           for (j=0; j<OFF_MAX; j+=OFF_STEP) {
 160             sprintf(test_file, "%s/DMAPI_invis_test_file.%02d%02d",
 161                     dir_name, i, j);
 162             sprintf(command, "cp %s %s\n", ls_path, test_file);
 163             system(command);
 164           }
 165         }
 166
 167         /* Write to files, then read them to check for correct results.
 168            Do timestamp checking along the way. */
 169
 170         for(i=0; i<LEN_MAX; i+=LEN_STEP) {
 171           for (j=0; j<OFF_MAX; j+=OFF_STEP) {
 172
 173 #define max(a,b) ((a) > (b) ? (a) : (b))
 174             length = max((dm_size_t)(i), length);
 175             offset = (dm_off_t)(j);
 176
 177             sprintf(test_file, "%s/DMAPI_invis_test_file.%02d%02d",
 178                     dir_name, i, j);
 179
 180             if (stat(test_file, &statbuf)){
 181               fprintf(stdout,
 182                       "Error: unable to stat test file; %s (before test)\n",
 183                       test_file);
 184               continue;
 185             }
 186
 187             if (dm_path_to_handle(test_file, &hanp, &hlen)) {
 188               fprintf(stderr, "can't get handle for %s; bypassing test\n",
 189                       test_file);
 190               continue;
 191             }
 192
 193             if (length > curlength) {
 194               if(curlength>0)
 195                 free(bufp);
 196               if ((bufp = malloc(length)) == NULL) {
 197                 fprintf(stderr, "malloc of %llu bytes failed\n", length);
 198                 continue;
 199               }
 200               curlength = length;
 201               memset(bufp, ch, length);
 202             }
 203
 204             rc = dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN,
 205                                 0, offset, length, bufp);
 206             cont = 0;
 207             if (rc < 0) {
 208               fprintf(stderr, "dm_write_invis failed, %s\n", ERR_NAME);
 209               cont=1;
 210             } else if (rc != length) {
 211               fprintf(stderr, "expected to write %lld bytes, actually "
 212                       "wrote %lld\n", length, rc);
 213               cont=1;
 214             }
 215             if(cont)
 216                 continue;
 217
 218             /* Timestamp checking, part 1 */
 219             if (stat(test_file, &checkbuf)){
 220               fprintf(stdout,
 221                       "Error: unable to stat the test file; %s (after write)\n",
 222                       test_file);
 223             }
 224             else {
 225 #ifdef __sgi
 226               if ((statbuf.st_atim.tv_sec == checkbuf.st_atim.tv_sec) &&
 227               (statbuf.st_atim.tv_nsec == checkbuf.st_atim.tv_nsec) &&
 228               (statbuf.st_mtim.tv_sec == checkbuf.st_mtim.tv_sec) &&
 229               (statbuf.st_mtim.tv_nsec == checkbuf.st_mtim.tv_nsec) &&
 230               (statbuf.st_ctim.tv_sec == checkbuf.st_ctim.tv_sec) &&
 231               (statbuf.st_ctim.tv_nsec == checkbuf.st_ctim.tv_nsec))
 232 #else
 233               if ((statbuf.st_atime == checkbuf.st_atime) &&
 234               (statbuf.st_mtime == checkbuf.st_mtime) &&
 235               (statbuf.st_ctime == checkbuf.st_ctime))
 236 #endif
 237                 {
 238                 if (Vflag) {
 239                   printf("Report: time stamp unchanged by write\n");
 240                 }
 241               }
 242               else {
 243                 printf("Error: time stamp changed by write\n");
 244               }
 245             }
 246
 247             rc = dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
 248                                 offset, length, bufp);
 249             if (rc < 0) {
 250               fprintf(stderr, "dm_read_invis failed, %s\n", ERR_NAME);
 251               continue;
 252             }
 253             else if (rc != length) {
 254               fprintf(stderr, "expected to read %lld bytes, actually "
 255                       "wrote %lld\n", length, rc);
 256               continue;
 257             }
 258             else {
 259               /* Be sure the buffer is filled with the test char */
 260               error_reported = 0;
 261               for (k=0; k<i; k++){
 262                 if (((char *)bufp)[k] == ch) {
 263                   if (Vflag) printf(".");
 264                 }
 265                 else {
 266                   if(!error_reported){
 267                         printf("Error!(line=%d)\n", __LINE__);
 268                         error_reported++;
 269                   }
 270                 }
 271               }
 272               if (Vflag) printf("\n");
 273             }
 274
 275             /* Timestamp checking, part 2 */
 276             if (stat(test_file, &statbuf)){
 277               fprintf(stdout,
 278                       "Error: unable to stat the test file; %s (after write)\n",
 279                       test_file);
 280             }
 281             else {
 282 #ifdef __sgi
 283               if ((statbuf.st_atim.tv_sec == checkbuf.st_atim.tv_sec) &&
 284               (statbuf.st_atim.tv_nsec == checkbuf.st_atim.tv_nsec) &&
 285               (statbuf.st_mtim.tv_sec == checkbuf.st_mtim.tv_sec) &&
 286               (statbuf.st_mtim.tv_nsec == checkbuf.st_mtim.tv_nsec) &&
 287               (statbuf.st_ctim.tv_sec == checkbuf.st_ctim.tv_sec) &&
 288               (statbuf.st_ctim.tv_nsec == checkbuf.st_ctim.tv_nsec))
 289 #else
 290               if ((statbuf.st_atime == checkbuf.st_atime) &&
 291               (statbuf.st_mtime == checkbuf.st_mtime) &&
 292               (statbuf.st_ctime == checkbuf.st_ctime))
 293 #endif
 294                 {
 295                 if (Vflag) {
 296                   printf("Report: time stamp unchanged by read\n");
 297                 }
 298               }
 299               else {
 300                 printf("Error: time stamp changed by read\n");
 301               }
 302             }
 303           } /* for (j=0; j<OFF_MAX; j+=OFF_STEP) */
 304         } /* for(i=0; i<LEN_MAX; i+=LEN_STEP) */
 305
 306         /* File deletion loop*/
 307         for(i=0; i<LEN_MAX; i+=LEN_STEP) {
 308           for(j=0; j<OFF_MAX; j+=OFF_STEP) {
 309             sprintf(test_file, "%s/DMAPI_invis_test_file.%02d%02d",
 310                     dir_name, i, j);
 311             sprintf(command, "rm %s\n", test_file);
 312             system(command);
 313           }
 314         }
 315
 316         /*************************************\
 317         |* Correct-input testing complete.   *|
 318         |* Beginning improper-input testing. *|
 319         \*************************************/
 320         sprintf(test_file, "%s/DMAPI_invis_test_file.ERRNO",
 321                 dir_name);
 322         sprintf(command, "cp %s %s\n", ls_path, test_file);
 323         system(command);
 324
 325         if (dm_path_to_handle(test_file, &hanp, &hlen)) {
 326           fprintf(stderr, "can't get handle for %s; bypassing errno tests\n",
 327                   test_file);
 328         }
 329         else {
 330
 331           /* Try writing a character waaaaaay up in the millions range */
 332           sprintf(bufp, "%c", ch);
 333           if (dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN, 0,
 334                              (1000000*(unsigned int)(ch)), 1, bufp)==-1){
 335             printf("Error invis-writing %s at byte %u million: %s\n",
 336                    (char*)bufp, (unsigned int)ch, ERR_NAME);
 337           }
 338           else if (dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
 339                                  (1000000*(unsigned int)(ch)), 1, bufp)==-1){
 340             printf("Error invis-reading at byte %u million: %s\n",
 341                    (unsigned int)ch, ERR_NAME);
 342           }
 343           else if (((char*)bufp)[0]!=ch) {
 344             printf("Error: wanted to read %c and instead got %s.\n",
 345                    ch, (char*)bufp);
 346           }
 347           else if (Vflag) {
 348             printf("Report: \"%c\" was written and \"%s\" was read "
 349                    "at byte %d million.\n", ch, (char*)bufp, ch);
 350           }
 351
 352 #ifdef __sgi
 353           /* Try writing a character in the 2 gigabyte (2^31) range */
 354           sprintf(bufp, "%c", ch);
 355           if (dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN, 0,
 356                              2147840000, 1, bufp)==-1){
 357             printf("Error invis-writing %s at 2 gigabytes: %s\n",
 358                    (char*)bufp, ERR_NAME);
 359           }
 360           else if (dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
 361                                  2147840000, 1, bufp)==-1){
 362             printf("Error invis-reading at 2 gigabytes: %s\n",
 363                    ERR_NAME);
 364           }
 365           else if (((char*)bufp)[0]!=ch) {
 366             printf("Error: wanted to read %c and instead got %s.\n",
 367                    ch, (char*)bufp);
 368           }
 369           else if (Vflag) {
 370             printf("Report: \"%c\" was written and \"%s\" was read "
 371                    "at 2147840000 bytes\n\t(a bit over 2 gigabytes).\n",
 372                    ch, (char*)bufp);
 373           }
 374 #endif
 375
 376           printf("\t(errno subtests beginning...)\n");
 377           /**** WRITE tests ****/
 378           /*---------------------------------------------------------*/
 379           EXCLTEST("write", hanp, hlen, test_token,
 380                    dm_write_invis(sid, hanp, hlen, test_token,
 381                                   0, 0, 13, "write test 1"))
 382           /*---------------------------------------------------------*/
 383             if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
 384             fprintf(stderr,
 385                     "Cannot create a test handle (%s); skipping EBADF test\n",
 386                     ERR_NAME);
 387           }
 388           else {
 389             ((char *) test_vp)[hlen/2]++;
 390             ERRTEST(EBADF,
 391                     "write",
 392                     dm_write_invis(sid, test_vp, hlen, DM_NO_TOKEN,
 393                                    0, 0, 0, bufp))
 394             ERRTEST(EBADF,
 395                     "read",
 396                     dm_read_invis(sid, test_vp, hlen, DM_NO_TOKEN,
 397                                   0, 0, bufp))
 398             dm_handle_free(test_vp, hlen);
 399           }
 400
 401           /*---------------------------------------------------------*/
 402           ERRTEST(EBADF,
 403                   "write",
 404                   dm_write_invis(sid, hanp, hlen-1, DM_NO_TOKEN,
 405                                  0, 0, 0, NULL))
 406           /*---------------------------------------------------------*/
 407           ERRTEST(EFAULT,
 408                   "write",
 409                   dm_write_invis(sid, NULL, hlen, DM_NO_TOKEN,
 410                                  0, 0, 0, NULL))
 411           /*---------------------------------------------------------*/
 412 #if 0
 413           PROBLEM: write_invis refuses to produce EINVAL for
 414           lengths that will not fit in a dm_size_t.
 415
 416           ERRTEST(EINVAL,
 417                   "(bad length) write",
 418                   dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN,
 419                                  0, 4096, (long long)0xFFFFFFFFFFFFFFFFLL,
 420                                  "write invalid length test"))
 421 #endif
 422           /*---------------------------------------------------------*/
 423 #if 0
 424           PROBLEM (somewhat fixed): A signal is sent, rather than EFBIG.
 425           Presumably, this signal is needed to comply with...something.
 426           If this is uncommented, the program will abort here, with the
 427           error message "exceeded file size limit".
 428
 429           ERRTEST(EFBIG,
 430                   "write",
 431                   dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN,
 432                                  0, (long long)0xFFFFFFFFFFLL,
 433                                  (long long)0xFFFFFFFFFFLL,
 434                                  "foo foo foo"))
 435 #endif
 436           /*---------------------------------------------------------*/
 437 #ifdef VERITAS_21
 438           ERRTEST(EINVAL,
 439                   "(bad offset) write",
 440                   dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN,
 441                                  0, (dm_size_t) ULONG_MAX, 5,
 442                                  "write invalid offset test"))
 443 #else
 444 #ifndef linux
 445           ERRTEST(EINVAL,
 446                   "(bad offset) write",
 447                   dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN,
 448                                  0, (dm_size_t) ULONGLONG_MAX, 5,
 449                                  "write invalid offset test"))
 450 #endif
 451 #endif
 452
 453           /*---------------------------------------------------------*/
 454           ERRTEST(EINVAL,
 455                   "(bad sid) write",
 456                   dm_write_invis(-100, hanp, hlen, DM_NO_TOKEN,
 457                                  0, 0, 26, "write invalid offset test"))
 458
 459
 460           /**** READ tests ****/
 461           /*---------------------------------------------------------*/
 462           SHAREDTEST("read", hanp, hlen, test_token,
 463                      dm_read_invis(sid, hanp, hlen, test_token,
 464                                    0, 13, bufp))
 465           /*---------------------------------------------------------*/
 466           ERRTEST(EBADF,
 467                   "read",
 468                   dm_read_invis(sid, hanp, hlen-1, DM_NO_TOKEN,
 469                                  0, 0, bufp))
 470           /*---------------------------------------------------------*/
 471           ERRTEST(EFAULT,
 472                   "read",
 473                   dm_read_invis(sid, NULL, hlen, DM_NO_TOKEN,
 474                                  0, 0, bufp))
 475           /*---------------------------------------------------------*/
 476 #ifdef  VERITAS_21
 477           ERRTEST(EINVAL,
 478                   "(bad offset) read",
 479                   dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
 480                                 ULONG_MAX, 5, bufp));
 481 #else
 482 #ifndef linux
 483           ERRTEST(EINVAL,
 484                   "(bad offset) read",
 485                   dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
 486                                 ULONGLONG_MAX, 5, bufp));
 487 #endif
 488 #endif
 489
 490           /*---------------------------------------------------------*/
 491           ERRTEST(EINVAL,
 492                   "(bad sid) read",
 493                   dm_read_invis(-100, hanp, hlen, DM_NO_TOKEN,
 494                                 0, 5, bufp))
 495           /*---------------------------------------------------------*/
 496           printf("\t(errno subtests complete!)\n");
 497         }
 498         sprintf(test_file, "%s/DMAPI_invis_test_file.ERRNO",
 499                 dir_name);
 500         sprintf(command, "rm %s \n", test_file);
 501         system(command);
 502
 503         printf("Invisible read/write tests complete.\n");
 504
 505         dm_handle_free(hanp, hlen);
 506         exit(0);
 507 }