fixed for newer perl
[tridge/junkcode.git] / fstest.c
1 /* filesystem verification tool, designed to detect data corruption on a filesystem
2
3    tridge@samba.org, March 2002
4  */
5 #define _GNU_SOURCE
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <unistd.h>
10 #include <sys/stat.h>
11 #include <sys/wait.h>
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <sys/mman.h>
15 #include <dirent.h>
16 #include <fcntl.h>
17 #include <errno.h>
18
19 /* variables settable on the command line */
20 static int loop_count = 100;
21 static int num_files = 1;
22 static int file_size = 1024*1024;
23 static int block_size = 1024;
24 static char *base_dir = ".";
25 static int use_mmap;
26 static int use_sync;
27
28 typedef unsigned char uchar;
29
30 #ifndef MIN
31 #define MIN(a,b) ((a)<(b)?(a):(b))
32 #endif
33
34 static void *x_malloc(int size)
35 {
36         void *ret = malloc(size);
37         if (!ret) {
38                 fprintf(stderr,"Out of memory for size %d!\n", size);
39                 exit(1);
40         }
41         return ret;
42 }
43
44
45 /* generate a buffer for a particular child, fnum etc. Just use a simple buffer
46    to make debugging easy 
47 */
48 static void gen_buffer(uchar *buf, int loop, int child, int fnum, int ofs)
49 {
50         uchar v = (loop+child+fnum+(ofs/block_size)) % 256;
51         memset(buf, v, block_size);
52 }
53
54 /* 
55    check if a buffer from disk is correct
56 */
57 static void check_buffer(uchar *buf, int loop, int child, int fnum, int ofs)
58 {
59         uchar *buf2;
60
61         buf2 = x_malloc(block_size);
62
63         gen_buffer(buf2, loop, child, fnum, ofs);
64         
65         if (memcmp(buf, buf2, block_size) != 0) {
66                 int i, j;
67                 for (i=0;buf[i] == buf2[i] && i<block_size;i++) ;
68                 fprintf(stderr,"Corruption in child %d fnum %d at offset %d\n",
69                         child, fnum, ofs+i);
70
71                 printf("Correct:   ");
72                 for (j=0;j<MIN(20, block_size-i);j++) {
73                         printf("%02x ", buf2[j+i]);
74                 }
75                 printf("\n");
76
77                 printf("Incorrect: ");
78                 for (j=0;j<MIN(20, block_size-i);j++) {
79                         printf("%02x ", buf[j+i]);
80                 }
81                 printf("\n");
82                 exit(1);
83         }
84
85         free(buf2);
86 }
87
88 /*
89   create a file with a known data set for a child
90  */
91 static void create_file(const char *dir, int loop, int child, int fnum)
92 {
93         uchar *buf;
94         int size, fd;
95         char fname[1024];
96
97         buf = x_malloc(block_size);
98         sprintf(fname, "%s/file%d", dir, fnum);
99         fd = open(fname, O_RDWR|O_CREAT|O_TRUNC | (use_sync?O_SYNC:0), 0644);
100         if (fd == -1) {
101                 perror(fname);
102                 exit(1);
103         }
104                 
105         if (!use_mmap) {
106                 for (size=0; size<file_size; size += block_size) {
107                         gen_buffer(buf, loop, child, fnum, size);
108                         if (pwrite(fd, buf, block_size, size) != block_size) {
109                                 fprintf(stderr,"Write failed at offset %d\n", size);
110                                 exit(1);
111                         }
112                 }
113         } else {
114                 char *p;
115                 if (ftruncate(fd, file_size) != 0) {
116                         perror("ftruncate");
117                         exit(1);
118                 }
119                 p = mmap(NULL, file_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
120                 if (p == (char *)-1) {
121                         perror("mmap");
122                         exit(1);
123                 }
124                 for (size=0; size<file_size; size += block_size) {
125                         gen_buffer(p+size, loop, child, fnum, size);
126                 }
127                 munmap(p, file_size);
128         }
129
130         free(buf);
131         close(fd);
132 }
133
134 /* 
135    check that a file has the right data
136  */
137 static void check_file(const char *dir, int loop, int child, int fnum)
138 {
139         uchar *buf;
140         int size, fd;
141         char fname[1024];
142
143         buf = x_malloc(block_size);
144
145         sprintf(fname, "%s/file%d", dir, fnum);
146         fd = open(fname, O_RDONLY);
147         if (fd == -1) {
148                 perror(fname);
149                 exit(1);
150         }
151
152         for (size=0; size<file_size; size += block_size) {
153                 if (pread(fd, buf, block_size, size) != block_size) {
154                         fprintf(stderr,"read failed at offset %d\n", size);
155                         exit(1);
156                 }
157                 check_buffer(buf, loop, child, fnum, size);
158         }
159
160         free(buf);
161         close(fd);
162 }
163
164 /* 
165    revsusive directory traversal - used for cleanup
166    fn() is called on all files/dirs in the tree
167  */
168 void traverse(const char *dir, int (*fn)(const char *))
169 {
170         DIR *d;
171         struct dirent *de;
172
173         d = opendir(dir);
174         if (!d) return;
175
176         while ((de = readdir(d))) {
177                 char fname[1024];
178                 struct stat st;
179
180                 if (strcmp(de->d_name,".") == 0) continue;
181                 if (strcmp(de->d_name,"..") == 0) continue;
182
183                 sprintf(fname, "%s/%s", dir, de->d_name);
184                 if (lstat(fname, &st)) {
185                         perror(fname);
186                         continue;
187                 }
188
189                 if (S_ISDIR(st.st_mode)) {
190                         traverse(fname, fn);
191                 }
192
193                 fn(fname);
194         }
195
196         closedir(d);
197 }
198
199 /* the main child function - this creates/checks the file for one child */
200 static void run_child(int child)
201 {
202         int i, loop;
203         char dir[1024];
204
205         sprintf(dir, "%s/child%d", base_dir, child);
206
207         /* cleanup any old files */
208         if (remove(dir) != 0 && errno != ENOENT) {
209                 printf("Child %d cleaning %s\n", child, dir);
210                 traverse(dir, remove);
211                 remove(dir);
212         }
213
214         if (mkdir(dir, 0755) != 0) {
215                 perror(dir);
216                 exit(1);
217         }
218
219         for (loop = 0; loop < loop_count; loop++) {
220                 printf("Child %d loop %d\n", child, loop);
221                 for (i=0;i<num_files;i++) {
222                         create_file(dir, loop, child, i);
223                 }
224                 for (i=0;i<num_files;i++) {
225                         check_file(dir, loop, child, i);
226                 }
227         }
228
229         /* cleanup afterwards */
230         printf("Child %d cleaning up %s\n", child, dir);
231         traverse(dir, remove);
232         remove(dir);
233
234         exit(0);
235 }
236
237 static void usage(void)
238 {
239         printf("\n"
240 "Usage: fstest [options]\n"
241 "\n"
242 " -n num_children       set number of child processes\n"
243 " -f num_files          set number of files\n"
244 " -s file_size          set file sizes\n"
245 " -b block_size         set block (IO) size\n"
246 " -p path               set base path\n"
247 " -l loops              set loop count\n"
248 " -m                    use mmap\n"
249 " -S                    use synchronous IO\n"
250 " -h                    show this help message\n");
251 }
252
253 /* main program */
254 int main(int argc, char *argv[])
255 {
256         int c;
257         extern char *optarg;
258         extern int optind;
259         int num_children = 1;
260         int i, status, ret;
261
262         while ((c = getopt(argc, argv, "n:s:f:p:l:b:Shm")) != -1) {
263                 switch (c) {
264                 case 'n':
265                         num_children = strtol(optarg, NULL, 0);
266                         break;
267                 case 'b':
268                         block_size = strtol(optarg, NULL, 0);
269                         break;
270                 case 'f':
271                         num_files = strtol(optarg, NULL, 0);
272                         break;
273                 case 's':
274                         file_size = strtol(optarg, NULL, 0);
275                         break;
276                 case 'p':
277                         base_dir = optarg;
278                         break;
279                 case 'm':
280                         use_mmap = 1;
281                         break;
282                 case 'S':
283                         use_sync = 1;
284                         break;
285                 case 'l':
286                         loop_count = strtol(optarg, NULL, 0);
287                         break;
288                 case 'h':
289                         usage();
290                         exit(0);
291                 default:
292                         usage();
293                         exit(1);
294                 }
295         }
296
297         argc -= optind;
298         argv += optind;
299
300         /* round up the file size */
301         if (file_size % block_size != 0) {
302                 file_size = (file_size + (block_size-1)) / block_size;
303                 file_size *= block_size;
304                 printf("Rounded file size to %d\n", file_size);
305         }
306
307         printf("num_children=%d file_size=%d num_files=%d loop_count=%d block_size=%d\nmmap=%d sync=%d\n",
308                num_children, file_size, num_files, loop_count, block_size, use_mmap, use_sync);
309
310         printf("Total data size %.1f Mbyte\n",
311                num_files * num_children * 1.0e-6 * file_size);
312
313         /* fork and run run_child() for each child */
314         for (i=0;i<num_children;i++) {
315                 if (fork() == 0) {
316                         run_child(i);
317                         exit(0);
318                 }
319         }
320
321         ret = 0;
322
323         /* wait for children to exit */
324         while (waitpid(0, &status, 0) == 0 || errno != ECHILD) {
325                 if (WEXITSTATUS(status) != 0) {
326                         ret = WEXITSTATUS(status);
327                         printf("Child exited with status %d\n", ret);
328                 }
329         }
330
331         if (ret != 0) {
332                 printf("fstest failed with status %d\n", ret);
333         }
334
335         return ret;
336 }