--- /dev/null
+/*
+ * GPL HEADER START
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see http://www.gnu.org/licenses
+ *
+ * Please visit http://www.xyratex.com/contact if you need additional
+ * information or have any questions.
+ *
+ * GPL HEADER END
+*/
+
+/*
+ * Copyright 2012 Xyratex Technology Limited
+*/
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/file.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/sem.h>
+#include <semaphore.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#define LOCK_LEN 100
+
+struct flock flocks[4] = {
+ /* 1st region */
+ {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = 0,
+ .l_len = LOCK_LEN,
+ .l_pid = 0,
+ },
+ /* 2nd region */
+ {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = LOCK_LEN,
+ .l_len = LOCK_LEN,
+ .l_pid = 0,
+ },
+ /* 3rd region */
+ {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = 2 * LOCK_LEN,
+ .l_len = LOCK_LEN,
+ .l_pid = 0,
+ },
+ /* 2nd & 3rd regions */
+ {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ .l_start = LOCK_LEN,
+ .l_len = 2 * LOCK_LEN,
+ .l_pid = 0,
+ },
+};
+
+enum {
+ FLOCK_GET = 0,
+ FLOCK_PUT = 1,
+};
+
+#define flock_call(fd, num, get, label) \
+ flocks[num].l_type = get == FLOCK_GET ? F_WRLCK : F_UNLCK; \
+ printf("%d: %s lock%d [%llu, %llu]\n", pid, \
+ get == FLOCK_GET ? "taking" : "putting", \
+ num, (unsigned long long)flocks[num].l_start, \
+ (unsigned long long)flocks[num].l_start + flocks[num].l_len); \
+ rc = fcntl(fd, F_SETLKW, &flocks[num]); \
+ if (rc < 0) { \
+ rc = errno; \
+ fprintf(stderr, "%d: failed to %s lock%d, %s\n", \
+ pid, get == FLOCK_GET ? "take" : "put", \
+ num, strerror(errno)); \
+ goto label; \
+ } else { \
+ printf("%d: done\n", pid); \
+ }
+
+void catch_alarm()
+{
+ fprintf(stderr, "lock timeout\n");
+ exit(124);
+}
+
+int main(int argc, char* argv[])
+{
+ struct sigaction act;
+ int status;
+ pid_t wpid = 0;
+ int fd, i, pid, num = 0, rc = 0;
+
+ if (argc != 2) {
+ fprintf(stderr, "usage: %s <file>\n", argv[0]);
+ return EXIT_FAILURE;
+ }
+ fd = open(argv[1], O_RDWR|O_CREAT, (mode_t)0666);
+ if (fd < 0) {
+ fprintf(stderr, "error open file %s\n", argv[1]);
+ return EXIT_FAILURE;
+ }
+
+ for (i = 0; i < 2; i++) {
+ fflush(stdout);
+ pid = fork();
+ if (pid && i == 0)
+ wpid = pid;
+ if (pid == 0)
+ wpid = 0;
+ if (pid == 0 && i == 0) {
+ pid = getpid();
+
+ flock_call(fd, num, FLOCK_GET, err_lock0);
+
+ printf("%d sleeping 1\n", pid);
+ sleep(1);
+
+ /* First of all, it should get blocked on flocks[1]
+ * 2nd child. Later, should deadlock with flocks[2]
+ * parent, after cancelling flocks[1] 2nd child. */
+ printf("%d: taking lock3 [%llu, %llu]\n", pid,
+ (unsigned long long)flocks[3].l_start,
+ (unsigned long long)flocks[3].l_start +
+ flocks[3].l_len);
+ memset(&act, 0, sizeof(act));
+ act.sa_handler = catch_alarm;
+ sigemptyset(&act.sa_mask);
+ sigaddset(&act.sa_mask, SIGALRM);
+ if (sigaction(SIGALRM, &act, NULL) < 0) {
+ fprintf(stderr, "SIGALRM signal setup failed"
+ ", errno: %d", errno);
+ rc = 3;
+ goto err_lock1;
+ }
+ alarm(5);
+ rc = fcntl(fd, F_SETLKW, &flocks[3]);
+ if (rc >= 0) {
+ fprintf(stderr, "%d: should not succeed to "
+ "take lock3\n", pid);
+
+ flock_call(fd, 3, FLOCK_PUT, err_lock1);
+ rc = EINVAL;
+ goto err_lock1;
+ }
+ if (errno != EDEADLK) {
+ rc = errno;
+ fprintf(stderr, "%d: failed to take lock3: "
+ "%s\n", pid, strerror(errno));
+ goto err_lock1;
+ }
+
+ printf("%d: expected deadlock\n", pid);
+
+ flock_call(fd, num, FLOCK_PUT, err_lock0);
+ break;
+ } else if (pid == 0 && i == 1) {
+ pid = getpid();
+
+ flock_call(fd, 1, FLOCK_GET, err_lock0);
+
+ /* Let flocks[2] 2nd child get granted and
+ * flocks[3] 1st child, flocks[0] parent get blocked.*/
+ printf("%d sleeping 2\n", pid);
+ sleep(2);
+
+ flock_call(fd, 1, FLOCK_PUT, err_lock0);
+ break;
+ } else if (pid && i == 1) {
+ pid = getpid();
+ num = 2;
+
+ /* Let flocks[1] 2nd child get granted first */
+ printf("%d: sleeping 1\n", pid);
+ sleep(1);
+
+ flock_call(fd, num, FLOCK_GET, err_lock0);
+
+ /* Should get blocked on flocks[0], 1st shild
+ * and succeed later. */
+ flock_call(fd, 0, FLOCK_GET, err_lock1);
+
+ flock_call(fd, 0, FLOCK_PUT, err_lock1);
+ flock_call(fd, num, FLOCK_PUT, err_lock0);
+ break;
+ }
+ }
+
+ if (pid == 0)
+ sleep(2);
+ if (wpid) {
+ waitpid(wpid, &status, 0);
+ rc = WEXITSTATUS(status);
+ }
+ printf("%d Exit\n", pid);
+ close(fd);
+ return rc;
+
+err_lock1:
+ flocks[num].l_type = F_UNLCK;
+ fcntl(fd, F_SETLKW, &flocks[num]);
+err_lock0:
+ close(fd);
+ return rc;
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff