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