Whamcloud - gitweb
LU-4629 ldlm: fix uninitialized variable
[fs/lustre-release.git] / lustre / tests / rename_many.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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 version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  * Lustre is a trademark of Sun Microsystems, Inc.
33  */
34
35 #define PATH_LENGTH 35
36 #include <math.h>
37 #include <signal.h>
38 #include <unistd.h>
39 #include <time.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <stdio.h>
43 #include <fcntl.h>
44 #include <stdlib.h>
45 #include <getopt.h>
46
47 struct names {
48         char from[PATH_LENGTH];
49         char to[PATH_LENGTH];
50 } *names;
51
52 unsigned int loop_count = 500;
53 int file_count = 1000;
54 int seed;
55 int loops;
56 int stop;
57 long start;
58
59 int opt_exit_on_err;
60 int opt_verbose;
61 int opt_create_only;
62 int opt_rename_only;
63 int creat_errors;
64 int rename_errors;
65 int unlink_errors;
66
67 void usage(const char *progname)
68 {
69         fprintf(stderr, "usage: %s [-n numfiles] [-s seed] [-v] [-x] [dir]\n"
70                 "\t-c: only do the create step of first loop\n"
71                 "\t-f: number of files to create/rename/unlink per loop\n"
72                 "\t-n: number of test loops (0 to run forever)\n"
73                 "\t-r: only do the rename step of first loop\n"
74                 "\t-s: starting seed (equals loop number by default)\n"
75                 "\t-v: verbose\n"
76                 "\t-x: don't exit on error\n", progname);
77 }
78
79 void handler(int sig) {
80         static long last_time;
81         long now = time(0);
82
83         signal(SIGINT, handler);
84         signal(SIGALRM, handler);
85         printf("%6lds %8d iterations %d/%d/%d errors",
86                now - start, loops, creat_errors, rename_errors, unlink_errors);
87         if (sig != 0)
88                 printf(" - use SIGQUIT (^\\) or ^C^C to kill\n");
89         else
90                 printf("\n");
91
92         if (sig == SIGQUIT)
93                 stop = 1;
94         else if (sig == SIGINT) {
95                 if (now - last_time < 2)
96                         stop = 1;
97                 last_time = now;
98         }
99         alarm(60);
100 }
101
102 extern char *optarg;
103 extern int optind;
104
105 int main(int argc, char *argv[])
106 {
107         unsigned long n;
108         char msg[100], *end = NULL;
109         int h1, h2;
110         int i, c;
111
112         while ((c = getopt(argc, argv, "cf:n:rs:vx")) != EOF) {
113                 switch(c) {
114                 case 'c':
115                         ++opt_create_only;
116                         break;
117                 case 'f':
118                         i = strtoul(optarg, &end, 0);
119                         if (i && end != NULL && *end == '\0') {
120                                 file_count = i;
121                         } else {
122                                 fprintf(stderr, "bad file count '%s'\n",optarg);
123                                 usage(argv[0]);
124                                 return 1;
125                         }
126                         break;
127                 case 'n':
128                         i = strtoul(optarg, &end, 0);
129                         if (i && end != NULL && *end == '\0') {
130                                 loop_count = i;
131                         } else {
132                                 fprintf(stderr, "bad loop count '%s'\n",optarg);
133                                 usage(argv[0]);
134                                 return 1;
135                         }
136                         break;
137                 case 'r':
138                         ++opt_rename_only;
139                         break;
140                 case 's':
141                         i = strtoul(optarg, &end, 0);
142                         if (end && *end == '\0') {
143                                 seed = i;
144                         } else {
145                                 seed = random();
146                                 fprintf(stderr, "using random seed %u\n", seed);
147                         }
148                         break;
149                 case 'v':
150                         ++opt_verbose;
151                         break;
152                 case 'x':
153                         ++opt_exit_on_err;
154                         break;
155                 default:
156                         usage(argv[0]);
157                         return 1;
158                 }
159         }
160
161         names = malloc(sizeof(struct names) * file_count);
162         if (names == NULL) {
163                 perror("calloc");
164                 return(1);
165         }
166
167         h2 = sprintf(msg, "%x", file_count); /* just to figure length */
168         h1 = (PATH_LENGTH - h2 - 2) / 4;
169
170         n = (1ULL << h1 * 4) - 1;
171
172         //printf("h1 = %d, h2 = %d n = %lu\n", h1, h2, n);
173
174         start = time(0);
175
176         signal(SIGQUIT, handler);
177         signal(SIGINT, handler);
178         signal(SIGALRM, handler);
179         signal(SIGUSR1, handler);
180         alarm(60);
181
182         if (argc > optind + 1) {
183                 fprintf(stderr, "too many extra args %d\n", argc - optind);
184                 usage(argv[0]);
185                 return 1;
186         } else if (argv[optind] != NULL) {
187                 if (chdir(argv[optind]) < 0) {
188                         snprintf(msg, sizeof(msg),
189                                  "chdir '%s'\n", argv[optind]);
190                         perror(msg);
191                         return 2;
192                 }
193         }
194
195         while (!stop && loop_count != 0 && loops < loop_count) {
196                 int j,k,l,m;
197
198                 srand(seed + loops);
199                 if (mkdir("tmp", S_IRWXU) == -1) {
200                         perror("mkdir tmp");
201                         return(1);
202                 }
203                 if (chdir("tmp") == -1) {
204                         perror("chdir tmp");
205                         return(1);
206                 }
207
208                 for (i = 0; i < file_count ; i++) {
209                         j = random() & n;
210                         k = random() & n;
211                         l = random() & n;
212                         m = random() & n;
213                         sprintf(names[i].from, "%0*x%0*x%0*x%0*x0%0*x",
214                                 h1, j, h1, k, h1, l, h1, m, h2, i);
215                         sprintf(names[i].to, "%0*x%0*x%0*x%0*x1%0*x",
216                                 h1, j, h1, k, h1, l, h1, m, h2, i);
217
218                 }
219
220                 for (i = 0; i < file_count; i++) {
221                         if (mknod(names[i].from, S_IFREG | S_IRWXU, 0) == -1) {
222                                 sprintf(msg, "loop %d.%d: creat %s",
223                                         loops, i, names[i].from);
224                                 perror(msg);
225                                 creat_errors++;
226                                 if (!opt_exit_on_err)
227                                         return 4;
228                         }
229                 }
230
231                 if (opt_create_only)
232                         return 0;
233
234                 for (i = 0; i < file_count; i++) {
235                         if (rename(names[i].from, names[i].to) == -1) {
236                                 sprintf(msg, "loop %d.%d: rename %s to %s",
237                                         loops, i, names[i].from, names[i].to);
238                                 perror(msg);
239                                 rename_errors++;
240                                 if (!opt_exit_on_err)
241                                         return 4;
242                         }
243                 }
244
245                 if (opt_rename_only)
246                         return 0;
247
248                 for (i = 0; i < file_count; i++) {
249                         if (unlink(names[i].to) == -1) {
250                                 sprintf(msg, "loop %d.%d: unlink %s",
251                                         loops, i, names[i].to);
252                                 perror(msg);
253                                 unlink_errors++;
254                                 if (!opt_exit_on_err)
255                                         return 4;
256                         }
257                 }
258
259                 if (chdir("..") == -1) {
260                         perror("chdir ..");
261                         return(1);
262                 }
263
264                 if (rmdir("tmp") == -1) {
265                         if (chdir("tmp") == -1) {
266                                 perror("chdir tmp 2");
267                                 return(1);
268                         }
269                         for (i = 0; i < file_count; i++) {
270                                 if (unlink(names[i].from) != -1) {
271                                         fprintf(stderr, "loop %d.%d: "
272                                                 "unexpected file %s\n",
273                                                 loops, i, names[i].to);
274                                         unlink_errors++;
275                                         if (!opt_exit_on_err)
276                                                 return 4;
277                                 }
278                         }
279                         if (chdir("..") == -1) {
280                                 perror("chdir .. 2");
281                                 return(1);
282                         }
283                         if (rmdir("tmp") == -1) {
284                                 perror("rmdir tmp");
285                                 return(1);
286                         }
287                 }
288
289                 loops++;
290                 if (opt_verbose)
291                         handler(0);
292         }
293
294         if (!opt_verbose)
295                 handler(0);
296         return(0);
297 }