1/*
2 *
3 *   Copyright (c) International Business Machines  Corp., 2002
4 *   Copyright (c) Cyril Hrubis chrubis@suse.cz 2009
5 *
6 *   This program is free software;  you can redistribute it and/or modify
7 *   it under the terms of the GNU General Public License as published by
8 *   the Free Software Foundation; either version 2 of the License, or
9 *   (at your option) any later version.
10 *
11 *   This program is distributed in the hope that it will be useful,
12 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
14 *   the GNU General Public License for more details.
15 *
16 *   You should have received a copy of the GNU General Public License
17 *   along with this program;  if not, write to the Free Software
18 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21/*
22 * NAME
23 *	ftest03.c -- test file I/O with readv and writev (ported from SPIE section2/filesuite/ftest4.c, by Airong Zhang)
24 *
25 * CALLS
26 *	lseek, readv, writev,
27 *	truncate, ftruncate, fsync, sync, fstat
28 *
29 * ALGORITHM
30 *	A bitmap is used to map pieces of a file.
31 *      Loop: pick a random piece of the file
32 *            if we haven't seen it before make sure it is zero,
33 *            write pattern
34 *            if we have seen it before make sure correct pattern.
35 *
36 *      This was originally written by rbk - was program tfio.c
37 *	Modified by dale to integrate with test suites.
38 *	Modified by G. Stevens to use readv and writev.
39 *	Modofied by K. Hakim to integrate with SPIES.
40 *
41 * RESTRICTIONS
42 *  1.  Runs a long time with default args - can take others on input
43 *	line.  Use with "term mode".
44 *	If run on vax the ftruncate will not be random - will always go to
45 *	start of file.  NOTE: produces a very high load average!!
46 *
47 *  2.  The "csize" argument must be evenly divisible by MAXIOVCNT.
48 *
49 * CAUTION!!
50 *	If a file is supplied to this program with the "-f" option
51 *	it will be removed with a system("rm -rf filename") call.
52 *
53 */
54
55#define _XOPEN_SOURCE 500
56#include <sys/types.h>
57#include <sys/param.h>
58#include <sys/wait.h>
59#include <sys/stat.h>
60#include <errno.h>
61#include <sys/uio.h>
62#include <fcntl.h>
63#include <signal.h>
64#include <stdio.h>
65#include <inttypes.h>
66#include "test.h"
67#include "safe_macros.h"
68#include "libftest.h"
69
70char *TCID = "ftest03";
71int TST_TOTAL = 1;
72
73#define PASSED 1
74#define FAILED 0
75
76static void setup(void);
77static void runtest(void);
78static void dotest(int, int, int);
79static void domisc(int, int, char *);
80static void term(int sig);
81
82#define MAXCHILD	25
83#define K_1		1024
84#define K_2		2048
85#define K_4		4096
86#define	MAXIOVCNT	16
87
88static int csize;		/* chunk size */
89static int iterations;		/* # total iterations */
90static int max_size;		/* max file size */
91static int misc_intvl;		/* for doing misc things; 0 ==> no */
92static int nchild;		/* how many children */
93static int fd;			/* file descriptor used by child */
94static int parent_pid;
95static int pidlist[MAXCHILD];
96static char test_name[2];	/* childs test directory name */
97
98static char fuss[MAXPATHLEN];	/* directory to do this in */
99static char homedir[MAXPATHLEN];	/* where we started */
100
101static int local_flag;
102
103int main(int ac, char *av[])
104{
105	int lc;
106
107	tst_parse_opts(ac, av, NULL, NULL);
108
109	setup();
110
111	for (lc = 0; TEST_LOOPING(lc); lc++) {
112
113		local_flag = PASSED;
114
115		runtest();
116
117		if (local_flag == PASSED) {
118			tst_resm(TPASS, "Test passed.");
119		} else {
120			tst_resm(TFAIL, "Test failed.");
121		}
122
123		tst_rmdir();
124		/* ??? so we are doing only one loop here ??? */
125		tst_exit();
126	}
127
128	tst_exit();
129}
130
131static void setup(void)
132{
133	char wdbuf[MAXPATHLEN];
134
135	/*
136	 * Make a directory to do this in; ignore error if already exists.
137	 * Save starting directory.
138	 */
139	tst_tmpdir();
140
141	if (getcwd(homedir, sizeof(homedir)) == NULL) {
142		tst_brkm(TBROK | TERRNO, NULL, "getcwd() failed");
143	}
144
145	parent_pid = getpid();
146
147	if (!fuss[0])
148		sprintf(fuss, "%s/ftest03.%d", getcwd(wdbuf, sizeof(wdbuf)),
149			getpid());
150
151	mkdir(fuss, 0755);
152
153	SAFE_CHDIR(NULL, fuss);
154
155	/*
156	 * Default values for run conditions.
157	 */
158	iterations = 10;
159	nchild = 5;
160	csize = K_2;		/* should run with 1, 2, and 4 K sizes */
161	max_size = K_1 * K_1;
162	misc_intvl = 10;
163
164	if (sigset(SIGTERM, term) == SIG_ERR) {
165		perror("sigset failed");
166		tst_brkm(TBROK, NULL, " sigset failed: signo = 15");
167	}
168}
169
170static void runtest(void)
171{
172	pid_t pid;
173	int child, count, i, nwait, status;
174
175	nwait = 0;
176
177	for (i = 0; i < nchild; i++) {
178
179		test_name[0] = 'a' + i;
180		test_name[1] = '\0';
181
182		fd = SAFE_OPEN(NULL, test_name, O_RDWR | O_CREAT | O_TRUNC,
183			       0666);
184
185		if ((child = fork()) == 0) {
186			dotest(nchild, i, fd);
187			tst_exit();
188		}
189
190		close(fd);
191
192		if (child < 0) {
193			tst_brkm(TBROK | TERRNO, NULL, "fork failed");
194		} else {
195			pidlist[i] = child;
196			nwait++;
197		}
198	}
199
200	/*
201	 * Wait for children to finish.
202	 */
203	count = 0;
204
205	while (1) {
206		if ((child = wait(&status)) >= 0) {
207			//tst_resm(TINFO, "\tTest{%d} exited status = 0x%x", child, status);
208			if (status) {
209				tst_resm(TFAIL,
210					 "\tTest{%d} failed, expected 0 exit.",
211					 child);
212				local_flag = FAILED;
213			}
214			++count;
215		} else {
216			if (errno != EINTR)
217				break;
218		}
219	}
220
221	/*
222	 * Should have collected all children.
223	 */
224	if (count != nwait) {
225		tst_resm(TFAIL, "\tWrong # children waited on, count = %d",
226			 count);
227		local_flag = FAILED;
228	}
229
230	chdir(homedir);
231
232	pid = fork();
233
234	if (pid < 0) {
235		tst_brkm(TBROK | TERRNO, sync, "fork failed");
236		tst_exit();
237	}
238
239	if (pid == 0) {
240		execl("/bin/rm", "rm", "-rf", fuss, NULL);
241		exit(1);
242	} else
243		wait(&status);
244
245	if (status) {
246		tst_resm(TINFO, "CAUTION - ftest03, '%s' may not be removed",
247			 fuss);
248	}
249
250	sync();
251}
252
253/*
254 * dotest()
255 *	Children execute this.
256 *
257 * Randomly read/mod/write chunks with known pattern and check.
258 * When fill sectors, iterate.
259 */
260
261#define	NMISC	4
262enum m_type { m_fsync, m_trunc, m_fstat };
263char *m_str[] = {
264	"fsync", "trunc", "sync", "fstat"
265};
266
267int misc_cnt[NMISC];		/* counts # of each kind of misc */
268int file_max;			/* file-max size */
269int nchunks;
270int last_trunc = -1;
271int tr_flag;
272enum m_type type = m_fsync;
273
274#define	CHUNK(i)	((i) * csize)
275#define	NEXTMISC	((rand() % misc_intvl) + 5)
276
277static void dotest(int testers, int me, int fd)
278{
279	char *bits, *hold_bits;
280	char val;
281	int chunk, whenmisc, xfr, count, collide, i;
282
283	/* Stuff for the readv call */
284	struct iovec r_iovec[MAXIOVCNT];
285	int r_ioveclen;
286
287	/* Stuff for the writev call */
288	struct iovec val_iovec[MAXIOVCNT];
289	struct iovec zero_iovec[MAXIOVCNT];
290	int w_ioveclen;
291	struct stat stat;
292
293	nchunks = max_size / csize;
294	whenmisc = 0;
295
296	if ((bits = malloc((nchunks + 7) / 8)) == 0) {
297		tst_brkm(TBROK, NULL, "\tmalloc failed");
298	}
299
300	if ((hold_bits = malloc((nchunks + 7) / 8)) == 0) {
301		tst_brkm(TBROK, NULL, "\tmalloc failed");
302	}
303
304	/*Allocate memory for the iovec buffers and init the iovec arrays */
305	r_ioveclen = w_ioveclen = csize / MAXIOVCNT;
306
307	/* Please note that the above statement implies that csize
308	 * be evenly divisible by MAXIOVCNT.
309	 */
310	for (i = 0; i < MAXIOVCNT; i++) {
311		if ((r_iovec[i].iov_base = calloc(r_ioveclen, 1)) == 0) {
312			tst_brkm(TBROK, NULL, "\tmalloc failed");
313			/* tst_exit(); */
314		}
315		r_iovec[i].iov_len = r_ioveclen;
316
317		/* Allocate unused memory areas between all the buffers to
318		 * make things more diffult for the OS.
319		 */
320		if (malloc((i + 1) * 8) == NULL) {
321			tst_brkm(TBROK, NULL, "\tmalloc failed");
322		}
323
324		if ((val_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
325			tst_brkm(TBROK, NULL, "\tmalloc failed");
326		}
327
328		val_iovec[i].iov_len = w_ioveclen;
329
330		if (malloc((i + 1) * 8) == NULL) {
331			tst_brkm(TBROK, NULL, "\tmalloc failed");
332		}
333
334		if ((zero_iovec[i].iov_base = calloc(w_ioveclen, 1)) == 0) {
335			tst_brkm(TBROK, NULL, "\tmalloc failed");
336		}
337
338		zero_iovec[i].iov_len = w_ioveclen;
339
340		if (malloc((i + 1) * 8) == NULL) {
341			tst_brkm(TBROK, NULL, "\tmalloc failed");
342		}
343	}
344	/*
345	 * No init sectors; allow file to be sparse.
346	 */
347	val = (64 / testers) * me + 1;
348
349	/*
350	 * For each iteration:
351	 *      zap bits array
352	 *      loop
353	 *              pick random chunk, read it.
354	 *              if corresponding bit off {
355	 *                      verify = 0. (sparse file)
356	 *                      ++count;
357	 *              } else
358	 *                      verify = val.
359	 *              write "val" on it.
360	 *              repeat unitl count = nchunks.
361	 *      ++val.
362	 */
363
364	srand(getpid());
365
366	if (misc_intvl)
367		whenmisc = NEXTMISC;
368
369	while (iterations-- > 0) {
370
371		for (i = 0; i < NMISC; i++)
372			misc_cnt[i] = 0;
373
374		ftruncate(fd, 0);
375		file_max = 0;
376		memset(bits, 0, (nchunks + 7) / 8);
377		memset(hold_bits, 0, (nchunks + 7) / 8);
378
379		/* Have to fill the val and zero iov buffers in a different manner
380		 */
381		for (i = 0; i < MAXIOVCNT; i++) {
382			memset(val_iovec[i].iov_base, val,
383			       val_iovec[i].iov_len);
384			memset(zero_iovec[i].iov_base, 0,
385			       zero_iovec[i].iov_len);
386
387		}
388
389		count = 0;
390		collide = 0;
391
392		while (count < nchunks) {
393			chunk = rand() % nchunks;
394			/*
395			 * Read it.
396			 */
397			if (lseek(fd, CHUNK(chunk), 0) < 0) {
398				tst_brkm(TFAIL,
399					 NULL,
400					 "\tTest[%d]: lseek(0) fail at %x, errno = %d.",
401					 me, CHUNK(chunk), errno);
402			}
403			if ((xfr = readv(fd, &r_iovec[0], MAXIOVCNT)) < 0) {
404				tst_brkm(TFAIL,
405					 NULL,
406					 "\tTest[%d]: readv fail at %x, errno = %d.",
407					 me, CHUNK(chunk), errno);
408			}
409			/*
410			 * If chunk beyond EOF just write on it.
411			 * Else if bit off, haven't seen it yet.
412			 * Else, have.  Verify values.
413			 */
414			if (CHUNK(chunk) >= file_max) {
415				bits[chunk / 8] |= (1 << (chunk % 8));
416				++count;
417			} else if ((bits[chunk / 8] & (1 << (chunk % 8))) == 0) {
418				if (xfr != csize) {
419					tst_brkm(TFAIL,
420						 NULL,
421						 "\tTest[%d]: xfr=%d != %d, zero read.",
422						 me, xfr, csize);
423				}
424				for (i = 0; i < MAXIOVCNT; i++) {
425					if (memcmp
426					    (r_iovec[i].iov_base,
427					     zero_iovec[i].iov_base,
428					     r_iovec[i].iov_len)) {
429						tst_resm(TFAIL,
430							 "\tTest[%d] bad verify @ 0x%x for val %d count %d xfr %d file_max 0x%x, should be 0.",
431							 me, CHUNK(chunk), val,
432							 count, xfr, file_max);
433						tst_resm(TINFO,
434							 "\tTest[%d]: last_trunc = 0x%x.",
435							 me, last_trunc);
436						fstat(fd, &stat);
437						tst_resm(TINFO,
438							 "\tStat: size=%llx, ino=%x",
439							 stat.st_size, (unsigned)stat.st_ino);
440						sync();
441						ft_dumpiov(&r_iovec[i]);
442						ft_dumpbits(bits,
443							    (nchunks + 7) / 8);
444						ft_orbits(hold_bits, bits,
445							  (nchunks + 7) / 8);
446						tst_resm(TINFO, "\tHold ");
447						ft_dumpbits(hold_bits,
448							    (nchunks + 7) / 8);
449						tst_exit();
450					}
451				}
452				bits[chunk / 8] |= (1 << (chunk % 8));
453				++count;
454			} else {
455				if (xfr != csize) {
456					tst_brkm(TFAIL,
457						 NULL,
458						 "\tTest[%d]: xfr=%d != %d, val read.",
459						 me, xfr, csize);
460				}
461				++collide;
462				for (i = 0; i < MAXIOVCNT; i++) {
463					if (memcmp
464					    (r_iovec[i].iov_base,
465					     val_iovec[i].iov_base,
466					     r_iovec[i].iov_len)) {
467						tst_resm(TFAIL,
468							 "\tTest[%d] bad verify @ 0x%x for val %d count %d xfr %d file_max 0x%x.",
469							 me, CHUNK(chunk), val,
470							 count, xfr, file_max);
471						tst_resm(TINFO,
472							 "\tTest[%d]: last_trunc = 0x%x.",
473							 me, last_trunc);
474						fstat(fd, &stat);
475						tst_resm(TINFO,
476							 "\tStat: size=%llx, ino=%x",
477							 stat.st_size, (unsigned)stat.st_ino);
478						sync();
479						ft_dumpiov(&r_iovec[i]);
480						ft_dumpbits(bits,
481							    (nchunks + 7) / 8);
482						ft_orbits(hold_bits, bits,
483							  (nchunks + 7) / 8);
484						tst_resm(TINFO, "\tHold ");
485						ft_dumpbits(hold_bits,
486							    (nchunks + 7) / 8);
487						tst_exit();
488					}
489				}
490			}
491			/*
492			 * Writev it.
493			 */
494			if (lseek(fd, -xfr, 1) < 0) {
495				tst_brkm(TFAIL,
496					 NULL,
497					 "\tTest[%d]: lseek(1) fail at %x, errno = %d.",
498					 me, CHUNK(chunk), errno);
499			}
500			if ((xfr =
501			     writev(fd, &val_iovec[0], MAXIOVCNT)) < csize) {
502				if (errno == ENOSPC) {
503					tst_resm(TFAIL,
504						 "\tTest[%d]: no space, exiting.",
505						 me);
506					fsync(fd);
507					tst_exit();
508				}
509				tst_brkm(TFAIL,
510					 NULL,
511					 "\tTest[%d]: writev fail at %x xfr %d, errno = %d.",
512					 me, CHUNK(chunk), xfr, errno);
513			}
514			if (CHUNK(chunk) + csize > file_max)
515				file_max = CHUNK(chunk) + csize;
516			/*
517			 * If hit "misc" interval, do it.
518			 */
519			if (misc_intvl && --whenmisc <= 0) {
520				ft_orbits(hold_bits, bits, (nchunks + 7) / 8);
521				domisc(me, fd, bits);
522				whenmisc = NEXTMISC;
523			}
524			if (count + collide > 2 * nchunks)
525				break;
526		}
527
528		/*
529		 * End of iteration, maybe before doing all chunks.
530		 */
531
532		fsync(fd);
533		++misc_cnt[m_fsync];
534		//tst_resm(TINFO, "\tTest{%d} val %d done, count = %d, collide = {%d}",
535		//              me, val, count, collide);
536		//for (i = 0; i < NMISC; i++)
537		//      tst_resm(TINFO, "\t\tTest{%d}: {%d} %s's.", me, misc_cnt[i], m_str[i]);
538		++val;
539	}
540}
541
542/*
543 *	Inject misc syscalls into the thing.
544 */
545static void domisc(int me, int fd, char *bits)
546{
547	int chunk;
548	struct stat sb;
549
550	if (type > m_fstat)
551		type = m_fsync;
552
553	switch (type) {
554	case m_fsync:
555		if (fsync(fd) < 0) {
556			tst_brkm(TFAIL, NULL, "\tTest[%d]: fsync error %d.",
557				 me,
558				 errno);
559		}
560		break;
561	case m_trunc:
562		chunk = rand() % (file_max / csize);
563		file_max = CHUNK(chunk);
564		last_trunc = file_max;
565		if (tr_flag) {
566			if (ftruncate(fd, file_max) < 0) {
567				tst_brkm(TFAIL,
568					 NULL,
569					 "\tTest[%d]: ftruncate error %d @ 0x%x.",
570					 me, errno, file_max);
571			}
572			tr_flag = 0;
573		} else {
574			if (truncate(test_name, file_max) < 0) {
575				tst_brkm(TFAIL,
576					 NULL,
577					 "\tTest[%d]: truncate error %d @ 0x%x.",
578					 me, errno, file_max);
579			}
580			tr_flag = 1;
581		}
582		for (; chunk % 8 != 0; chunk++)
583			bits[chunk / 8] &= ~(1 << (chunk % 8));
584		for (; chunk < nchunks; chunk += 8)
585			bits[chunk / 8] = 0;
586		break;
587	case m_fstat:
588		if (fstat(fd, &sb) < 0) {
589			tst_brkm(TFAIL, NULL, "\tTest[%d]: fstat() error %d.",
590				 me,
591				 errno);
592		}
593		if (sb.st_size != file_max) {
594			tst_brkm(TFAIL,
595				 NULL, "\tTest[%d]: fstat() mismatch; st_size=%"
596				 PRIx64 ",file_max=%x.", me,
597				 (int64_t) sb.st_size, file_max);
598		}
599		break;
600	}
601
602	++misc_cnt[type];
603	++type;
604}
605
606/*
607 * SIGTERM signal handler.
608 */
609static void term(int sig LTP_ATTRIBUTE_UNUSED)
610{
611	int i;
612
613	tst_resm(TINFO, "\tterm -[%d]- got sig term.", getpid());
614
615	/*
616	 * If run by hand we like to have the parent send the signal to
617	 * the child processes.  This makes life easy.
618	 */
619	if (parent_pid == getpid()) {
620		for (i = 0; i < nchild; i++)
621			if (pidlist[i])
622				kill(pidlist[i], SIGTERM);
623		return;
624	}
625
626	tst_resm(TINFO, "\tunlinking '%s'", test_name);
627
628	close(fd);
629
630	if (unlink(test_name))
631		tst_resm(TBROK, "Unlink of '%s' failed, errno = %d.",
632			 test_name, errno);
633	else
634		tst_resm(TBROK, "Unlink of '%s' successful.", test_name);
635
636	tst_exit();
637}
638