Whamcloud - gitweb
fe2f0456dbe51dec81635254f33c184624fa3c3d
[fs/lustre-release.git] / lustre / tests / flocks_test.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <pthread.h>
44 #include <sys/file.h>
45 #include <stdarg.h>
46
47 #define MAX_PATH_LENGTH 4096
48 /**
49  * helper functions
50  */
51 int t_fcntl(int fd, int cmd, ...)
52 {
53         va_list ap;
54         long arg;
55         struct flock *lock;
56         int rc = -1;
57
58         va_start(ap, cmd);
59         switch (cmd) {
60         case F_GETFL:
61                 va_end(ap);
62                 rc = fcntl(fd, cmd);
63                 if (rc == -1) {
64                         fprintf(stderr, "fcntl GETFL failed: %s\n",
65                                 strerror(errno));
66                         return(1);
67                 }
68                 break;
69         case F_SETFL:
70                 arg = va_arg(ap, long);
71                 va_end(ap);
72                 rc = fcntl(fd, cmd, arg);
73                 if (rc == -1) {
74                         fprintf(stderr, "fcntl SETFL %ld failed: %s\n",
75                                 arg, strerror(errno));
76                         return(1);
77                 }
78                 break;
79         case F_GETLK:
80         case F_SETLK:
81         case F_SETLKW:
82                 lock = va_arg(ap, struct flock *);
83                 va_end(ap);
84                 rc = fcntl(fd, cmd, lock);
85                 if (rc == -1) {
86                         fprintf(stderr, "fcntl cmd %d failed: %s\n",
87                                 cmd, strerror(errno));
88                         return(1);
89                 }
90                 break;
91         case F_DUPFD:
92                 arg = va_arg(ap, long);
93                 va_end(ap);
94                 rc = fcntl(fd, cmd, arg);
95                 if (rc == -1) {
96                         fprintf(stderr, "fcntl F_DUPFD %d failed: %s\n",
97                                 (int)arg, strerror(errno));
98                         return(1);
99                 }
100                 break;
101         default:
102                 va_end(ap);
103                 fprintf(stderr, "fcntl cmd %d not supported\n", cmd);
104                 return(1);
105         }
106         return rc;
107 }
108
109 int t_unlink(const char *path)
110 {
111         int rc;
112
113         rc = unlink(path);
114         if (rc)
115                 fprintf(stderr, "unlink(%s) error: %s\n", path, strerror(errno));
116         return rc;
117 }
118
119 /** =================================================================
120  * test number 1
121  * 
122  * normal flock test
123  */
124 void t1_usage(void)
125 {
126         fprintf(stderr, "usage: ./flocks_test 1 on|off -c|-f|-l /path/to/file\n");
127 }
128
129 int t1(int argc, char *argv[])
130 {
131         int fd;
132         int mount_with_flock = 0;
133         int error = 0;
134
135         if (argc != 5) {
136                 t1_usage();
137                 return EXIT_FAILURE;
138         }
139
140         if (!strncmp(argv[2], "on", 3)) {
141                 mount_with_flock = 1;
142         } else if (!strncmp(argv[2], "off", 4)) {
143                 mount_with_flock = 0;
144         } else {
145                 t1_usage();
146                 return EXIT_FAILURE;
147         }
148
149         if ((fd = open(argv[4], O_RDWR)) < 0) {
150                 fprintf(stderr, "Couldn't open file: %s\n", argv[3]);
151                 return EXIT_FAILURE;
152         }
153
154         if (!strncmp(argv[3], "-c", 3)) {
155                 struct flock fl;
156
157                 fl.l_type = F_RDLCK;
158                 fl.l_whence = SEEK_SET;
159                 fl.l_start = 0;
160                 fl.l_len = 1;
161
162                 error = fcntl(fd, F_SETLK, &fl);
163         } else if (!strncmp(argv[3], "-l", 3)) {
164                 error = lockf(fd, F_LOCK, 1);
165         } else if (!strncmp(argv[3], "-f", 3)) {
166                 error = flock(fd, LOCK_EX);
167         } else {
168                 t1_usage();
169                 return EXIT_FAILURE;
170         }
171
172         if (mount_with_flock)
173                 return((error == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
174         else
175                 return((error == 0) ? EXIT_FAILURE : EXIT_SUCCESS);
176 }
177
178 /** ===============================================================
179  * test number 2
180  * 
181  * 2 threads flock ops interweave
182  */
183 typedef struct {
184         struct flock* lock;
185         int fd;
186 } th_data;
187
188 void* t2_thread1(void *arg)
189 {
190         struct flock *lock = ((th_data *)arg)->lock;
191         int fd             = ((th_data *)arg)->fd;
192
193         printf("thread 1: set write lock (blocking)\n");
194         lock->l_type = F_WRLCK;
195         t_fcntl(fd, F_SETLKW, lock);
196         printf("thread 1: set write lock done\n");
197         t_fcntl(fd, F_GETLK, lock);
198         printf("thread 1: unlock\n");
199         lock->l_type = F_UNLCK;
200         t_fcntl(fd, F_SETLK, lock);
201         printf("thread 1: unlock done\n");
202         return 0;
203 }
204
205 void* t2_thread2(void *arg)
206 {
207         struct flock *lock = ((th_data *)arg)->lock;
208         int fd             = ((th_data *)arg)->fd;
209
210         sleep(2);
211         printf("thread 2: unlock\n");
212         lock->l_type = F_UNLCK;
213         t_fcntl(fd, F_SETLK, lock);
214         printf("thread 2: unlock done\n");
215         printf("thread 2: set write lock (non-blocking)\n");
216         lock->l_type = F_WRLCK;
217         t_fcntl(fd, F_SETLK, lock);
218         printf("thread 2: set write lock done\n");
219         t_fcntl(fd, F_GETLK, lock);
220         return 0;
221 }
222
223 int t2(int argc, char* argv[])
224 {
225         struct flock lock = {
226                 .l_type = F_RDLCK,
227                 .l_whence = SEEK_SET,
228         };
229         char file[MAX_PATH_LENGTH] = "";
230         int  fd, rc;
231         pthread_t th1, th2;
232         th_data   ta;
233
234         snprintf(file, MAX_PATH_LENGTH, "%s/test_t2_file", argv[2]);
235
236         fd = open(file, O_RDWR|O_CREAT, (mode_t)0666);
237         if (fd < 0) {
238                 fprintf(stderr, "error open file: %s\n", file);
239                 return EXIT_FAILURE;
240         }
241
242         t_fcntl(fd, F_SETFL, O_APPEND);
243         rc = t_fcntl(fd, F_GETFL);
244         if ((rc & O_APPEND) == 0) {
245                 fprintf(stderr, "error get flag: ret %x\n", rc);
246                 return EXIT_FAILURE;
247         }
248
249         ta.lock = &lock;
250         ta.fd   = fd;
251         rc = pthread_create(&th1, NULL, t2_thread1, &ta);
252         if (rc) {
253                 fprintf(stderr, "error create thread 1\n");
254                 rc = EXIT_FAILURE;
255                 goto out;
256         }
257         rc = pthread_create(&th2, NULL, t2_thread2, &ta);
258         if (rc) {
259                 fprintf(stderr, "error create thread 2\n");
260                 rc = EXIT_FAILURE;
261                 goto out;
262         }
263         (void)pthread_join(th1, NULL);
264         (void)pthread_join(th2, NULL);
265 out:
266         t_unlink(file);
267         close(fd);
268         return rc;
269 }
270
271 /** ==============================================================
272  * program entry
273  */
274 void usage(void)
275 {
276         fprintf(stderr, "usage: ./flocks_test test# [corresponding arguments]\n");
277 }
278
279 int main(int argc, char* argv[])
280 {
281         int test_no;
282         int rc = EXIT_SUCCESS;
283
284         if (argc < 1) {
285                 usage();
286                 exit(EXIT_FAILURE);
287         }
288         test_no = atoi(argv[1]);
289
290         switch(test_no) {
291         case 1:
292                 rc = t1(argc, argv);
293                 break;
294         case 2:
295                 rc = t2(argc, argv);
296                 break;
297         default:
298                 fprintf(stderr, "unknow test number %s\n", argv[1]);
299                 break;
300         }
301         return rc;
302 }