__u64 bits;
};
-struct ldlm_flock {
- __u64 start;
- __u64 end;
- __u64 blocking_export; /* not actually used over the wire */
- __u32 blocking_pid; /* not actually used over the wire */
- __u32 pid;
+struct ldlm_flock_wire {
+ __u64 lfw_start;
+ __u64 lfw_end;
+ __u64 lfw_owner;
+ __u32 lfw_padding;
+ __u32 lfw_pid;
};
/* it's important that the fields of the ldlm_extent structure match
typedef union {
struct ldlm_extent l_extent;
- struct ldlm_flock l_flock;
+ struct ldlm_flock_wire l_flock;
struct ldlm_inodebits l_inodebits;
-} ldlm_policy_data_t;
+} ldlm_wire_policy_data_t;
-extern void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d);
+extern void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d);
struct ldlm_intent {
__u64 opc;
struct ldlm_resource_desc l_resource;
ldlm_mode_t l_req_mode;
ldlm_mode_t l_granted_mode;
- ldlm_policy_data_t l_policy_data;
+ ldlm_wire_policy_data_t l_policy_data;
};
extern void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l);
* in the same RPC */
} ldlm_cancel_flags_t;
+struct ldlm_flock {
+ __u64 start;
+ __u64 end;
+ __u64 owner;
+ __u64 blocking_owner;
+ void *blocking_export;
+ __u32 pid;
+};
+
+typedef union {
+ struct ldlm_extent l_extent;
+ struct ldlm_flock l_flock;
+ struct ldlm_inodebits l_inodebits;
+} ldlm_policy_data_t;
+
+void ldlm_convert_policy_to_wire(ldlm_type_t type,
+ const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy);
+void ldlm_convert_policy_to_local(ldlm_type_t type,
+ const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy);
+
struct ldlm_lock {
/**
* Must be first in the structure.
ldlm_interval_free(node);
}
}
+
+void ldlm_extent_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy)
+{
+ memset(lpolicy, 0, sizeof(*lpolicy));
+ lpolicy->l_extent.start = wpolicy->l_extent.start;
+ lpolicy->l_extent.end = wpolicy->l_extent.end;
+ lpolicy->l_extent.gid = wpolicy->l_extent.gid;
+}
+
+void ldlm_extent_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy)
+{
+ memset(wpolicy, 0, sizeof(*wpolicy));
+ wpolicy->l_extent.start = lpolicy->l_extent.start;
+ wpolicy->l_extent.end = lpolicy->l_extent.end;
+ wpolicy->l_extent.gid = lpolicy->l_extent.gid;
+}
+
static inline int
ldlm_same_flock_owner(struct ldlm_lock *lock, struct ldlm_lock *new)
{
- return((new->l_policy_data.l_flock.pid ==
- lock->l_policy_data.l_flock.pid) &&
+ return((new->l_policy_data.l_flock.owner ==
+ lock->l_policy_data.l_flock.owner) &&
(new->l_export == lock->l_export));
}
{
struct obd_export *req_export = req->l_export;
struct obd_export *blocking_export = blocking_lock->l_export;
- pid_t req_pid = req->l_policy_data.l_flock.pid;
- pid_t blocking_pid = blocking_lock->l_policy_data.l_flock.pid;
+ __u64 req_owner = req->l_policy_data.l_flock.owner;
+ __u64 blocking_owner = blocking_lock->l_policy_data.l_flock.owner;
struct ldlm_lock *lock;
cfs_spin_lock(&ldlm_flock_waitq_lock);
restart:
cfs_list_for_each_entry(lock, &ldlm_flock_waitq, l_flock_waitq) {
- if ((lock->l_policy_data.l_flock.pid != blocking_pid) ||
+ if ((lock->l_policy_data.l_flock.owner != blocking_owner) ||
(lock->l_export != blocking_export))
continue;
- blocking_pid = lock->l_policy_data.l_flock.blocking_pid;
- blocking_export = (struct obd_export *)(long)
+ blocking_owner = lock->l_policy_data.l_flock.blocking_owner;
+ blocking_export = (struct obd_export *)
lock->l_policy_data.l_flock.blocking_export;
- if (blocking_pid == req_pid && blocking_export == req_export) {
+ if (blocking_owner == req_owner &&
+ blocking_export == req_export) {
cfs_spin_unlock(&ldlm_flock_waitq_lock);
return 1;
}
const struct ldlm_callback_suite null_cbs = { NULL };
ENTRY;
- CDEBUG(D_DLMTRACE, "flags %#x pid %u mode %u start "LPU64" end "LPU64
- "\n", *flags, new->l_policy_data.l_flock.pid, mode,
+ CDEBUG(D_DLMTRACE, "flags %#x owner "LPU64" pid %u mode %u start "LPU64
+ " end "LPU64"\n", *flags, new->l_policy_data.l_flock.owner,
+ new->l_policy_data.l_flock.pid, mode,
req->l_policy_data.l_flock.start,
req->l_policy_data.l_flock.end);
RETURN(LDLM_ITER_STOP);
}
- req->l_policy_data.l_flock.blocking_pid =
- lock->l_policy_data.l_flock.pid;
+ req->l_policy_data.l_flock.blocking_owner =
+ lock->l_policy_data.l_flock.owner;
req->l_policy_data.l_flock.blocking_export =
- (long)(void *)lock->l_export;
+ lock->l_export;
LASSERT(cfs_list_empty(&req->l_flock_waitq));
cfs_spin_lock(&ldlm_flock_waitq_lock);
new2->l_granted_mode = lock->l_granted_mode;
new2->l_policy_data.l_flock.pid =
new->l_policy_data.l_flock.pid;
+ new2->l_policy_data.l_flock.owner =
+ new->l_policy_data.l_flock.owner;
new2->l_policy_data.l_flock.start =
lock->l_policy_data.l_flock.start;
new2->l_policy_data.l_flock.end =
cfs_spin_unlock(&ldlm_flock_waitq_lock);
RETURN(0);
}
+
+void ldlm_flock_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy)
+{
+ memset(lpolicy, 0, sizeof(*lpolicy));
+ lpolicy->l_flock.start = wpolicy->l_flock.lfw_start;
+ lpolicy->l_flock.end = wpolicy->l_flock.lfw_end;
+ lpolicy->l_flock.pid = wpolicy->l_flock.lfw_pid;
+ lpolicy->l_flock.owner = wpolicy->l_flock.lfw_owner;
+ /* Compat code, old clients had no idea about owner field and
+ * relied solely on pid for ownership. Introduced in 2.1, April 2011 */
+ if (!lpolicy->l_flock.owner)
+ lpolicy->l_flock.owner = wpolicy->l_flock.lfw_pid;
+}
+
+void ldlm_flock_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy)
+{
+ memset(wpolicy, 0, sizeof(*wpolicy));
+ wpolicy->l_flock.lfw_start = lpolicy->l_flock.start;
+ wpolicy->l_flock.lfw_end = lpolicy->l_flock.end;
+ wpolicy->l_flock.lfw_pid = lpolicy->l_flock.pid;
+ wpolicy->l_flock.lfw_owner = lpolicy->l_flock.owner;
+}
}
RETURN(0);
}
+
+void ldlm_ibits_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy)
+{
+ memset(lpolicy, 0, sizeof(*lpolicy));
+ lpolicy->l_inodebits.bits = wpolicy->l_inodebits.bits;
+}
+
+void ldlm_ibits_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy)
+{
+ memset(wpolicy, 0, sizeof(*wpolicy));
+ wpolicy->l_inodebits.bits = lpolicy->l_inodebits.bits;
+}
return ret;
}
+
+typedef void (*ldlm_policy_wire_to_local_t)(const ldlm_wire_policy_data_t *,
+ ldlm_policy_data_t *);
+
+typedef void (*ldlm_policy_local_to_wire_t)(const ldlm_policy_data_t *,
+ ldlm_wire_policy_data_t *);
+
+void ldlm_plain_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy);
+void ldlm_plain_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy);
+void ldlm_ibits_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy);
+void ldlm_ibits_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy);
+void ldlm_extent_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy);
+void ldlm_extent_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy);
+void ldlm_flock_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy);
+void ldlm_flock_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy);
[LDLM_IBITS] "IBT",
};
+static ldlm_policy_wire_to_local_t ldlm_policy_wire_to_local[] = {
+ [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_wire_to_local,
+ [LDLM_EXTENT - LDLM_MIN_TYPE] ldlm_extent_policy_wire_to_local,
+ [LDLM_FLOCK - LDLM_MIN_TYPE] ldlm_flock_policy_wire_to_local,
+ [LDLM_IBITS - LDLM_MIN_TYPE] ldlm_ibits_policy_wire_to_local,
+};
+
+static ldlm_policy_local_to_wire_t ldlm_policy_local_to_wire[] = {
+ [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_local_to_wire,
+ [LDLM_EXTENT - LDLM_MIN_TYPE] ldlm_extent_policy_local_to_wire,
+ [LDLM_FLOCK - LDLM_MIN_TYPE] ldlm_flock_policy_local_to_wire,
+ [LDLM_IBITS - LDLM_MIN_TYPE] ldlm_ibits_policy_local_to_wire,
+};
+
+/**
+ * Converts lock policy from local format to on the wire lock_desc format
+ */
+void ldlm_convert_policy_to_wire(ldlm_type_t type,
+ const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy)
+{
+ ldlm_policy_local_to_wire_t convert;
+
+ convert = ldlm_policy_local_to_wire[type - LDLM_MIN_TYPE];
+
+ convert(lpolicy, wpolicy);
+}
+
+/**
+ * Converts lock policy from on the wire lock_desc format to local format
+ */
+void ldlm_convert_policy_to_local(ldlm_type_t type,
+ const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy)
+{
+ ldlm_policy_wire_to_local_t convert;
+
+ convert = ldlm_policy_wire_to_local[type - LDLM_MIN_TYPE];
+
+ convert(wpolicy, lpolicy);
+}
+
char *ldlm_it2str(int it)
{
switch (it) {
ldlm_res2desc(lock->l_resource, &desc->l_resource);
desc->l_req_mode = lock->l_req_mode;
desc->l_granted_mode = lock->l_granted_mode;
- desc->l_policy_data = lock->l_policy_data;
+ ldlm_convert_policy_to_wire(lock->l_resource->lr_type,
+ &lock->l_policy_data,
+ &desc->l_policy_data);
}
}
}
if (dlm_req->lock_desc.l_resource.lr_type != LDLM_PLAIN)
- lock->l_policy_data = dlm_req->lock_desc.l_policy_data;
+ ldlm_convert_policy_to_local(
+ dlm_req->lock_desc.l_resource.lr_type,
+ &dlm_req->lock_desc.l_policy_data,
+ &lock->l_policy_data);
if (dlm_req->lock_desc.l_resource.lr_type == LDLM_EXTENT)
lock->l_req_extent = lock->l_policy_data.l_extent;
}
if (lock->l_resource->lr_type != LDLM_PLAIN) {
- lock->l_policy_data = dlm_req->lock_desc.l_policy_data;
+ ldlm_convert_policy_to_local(
+ dlm_req->lock_desc.l_resource.lr_type,
+ &dlm_req->lock_desc.l_policy_data,
+ &lock->l_policy_data);
LDLM_DEBUG(lock, "completion AST, new policy data");
}
}
RETURN(0);
}
+
+void ldlm_plain_policy_wire_to_local(const ldlm_wire_policy_data_t *wpolicy,
+ ldlm_policy_data_t *lpolicy)
+{
+ /* No policy for plain locks */
+}
+
+void ldlm_plain_policy_local_to_wire(const ldlm_policy_data_t *lpolicy,
+ ldlm_wire_policy_data_t *wpolicy)
+{
+ /* No policy for plain locks */
+}
if (with_policy)
if (!(type == LDLM_IBITS && !(exp->exp_connect_flags &
OBD_CONNECT_IBITS)))
- lock->l_policy_data =
- reply->lock_desc.l_policy_data;
+ /* We assume lock type cannot change on server*/
+ ldlm_convert_policy_to_local(
+ lock->l_resource->lr_type,
+ &reply->lock_desc.l_policy_data,
+ &lock->l_policy_data);
if (type != LDLM_PLAIN)
LDLM_DEBUG(lock,"client-side enqueue, new policy data");
}
.ei_cbdata = file_lock };
struct md_op_data *op_data;
struct lustre_handle lockh = {0};
- ldlm_policy_data_t flock;
+ ldlm_policy_data_t flock = {{0}};
int flags = 0;
int rc;
ENTRY;
if (file_lock->fl_flags & FL_FLOCK) {
LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
- /* set missing params for flock() calls */
- file_lock->fl_end = OFFSET_MAX;
- file_lock->fl_pid = current->tgid;
+ /* flocks are whole-file locks */
+ flock.l_flock.end = OFFSET_MAX;
+ /* For flocks owner is determined by the local file desctiptor*/
+ flock.l_flock.owner = (unsigned long)file_lock->fl_file;
+ } else if (file_lock->fl_flags & FL_POSIX) {
+ flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
+ flock.l_flock.start = file_lock->fl_start;
+ flock.l_flock.end = file_lock->fl_end;
+ } else {
+ RETURN(-EINVAL);
}
flock.l_flock.pid = file_lock->fl_pid;
- flock.l_flock.start = file_lock->fl_start;
- flock.l_flock.end = file_lock->fl_end;
switch (file_lock->fl_type) {
case F_RDLCK:
__swab64s (&id->name[i]);
}
-void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d)
+void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d)
{
/* the lock data is a union and the first two fields are always an
* extent so it's ok to process an LDLM_EXTENT and LDLM_FLOCK lock
__swab64s(&d->l_extent.start);
__swab64s(&d->l_extent.end);
__swab64s(&d->l_extent.gid);
- __swab32s(&d->l_flock.pid);
+ __swab64s(&d->l_flock.lfw_owner);
+ __swab32s(&d->l_flock.lfw_pid);
}
void lustre_swab_ldlm_intent (struct ldlm_intent *i)
{
/* Wire protocol assertions generated by 'wirecheck'
* (make -C lustre/utils newwiretest)
- * running on Linux vl1 2.6.18-prep #3 SMP Mon Apr 19 06:11:00 CDT 2010 x86_64 x86_64 x86_64
- * with gcc version 4.1.2 20070626 (Red Hat 4.1.2-14) */
+ * running on Linux centos5.localhost 2.6.18-prep #3 SMP Mon Mar 22 08:28:01 EDT 2010 x86_64
+ * with gcc version 4.1.2 20071124 (Red Hat 4.1.2-42) */
/* Constants... */
LASSERTF((int)sizeof(((struct ldlm_extent *)0)->gid) == 8, " found %lld\n",
(long long)(int)sizeof(((struct ldlm_extent *)0)->gid));
- /* Checks for struct ldlm_flock */
- LASSERTF((int)sizeof(struct ldlm_flock) == 32, " found %lld\n",
- (long long)(int)sizeof(struct ldlm_flock));
- LASSERTF((int)offsetof(struct ldlm_flock, start) == 0, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, start));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->start) == 8, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->start));
- LASSERTF((int)offsetof(struct ldlm_flock, end) == 8, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, end));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->end) == 8, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->end));
- LASSERTF((int)offsetof(struct ldlm_flock, blocking_pid) == 24, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, blocking_pid));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->blocking_pid) == 4, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->blocking_pid));
- LASSERTF((int)offsetof(struct ldlm_flock, pid) == 28, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, pid));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->pid) == 4, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->pid));
+ /* Checks for struct ldlm_flock_wire */
+ LASSERTF((int)sizeof(struct ldlm_flock_wire) == 32, " found %lld\n",
+ (long long)(int)sizeof(struct ldlm_flock_wire));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_start) == 0, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_start));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_start) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_start));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_end) == 8, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_end));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_end) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_end));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_owner) == 16, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_owner));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_owner) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_owner));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_pid) == 28, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_pid));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_pid) == 4, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_pid));
/* Checks for struct ldlm_inodebits */
LASSERTF((int)sizeof(struct ldlm_inodebits) == 8, " found %lld\n",
noinst_PROGRAMS += small_write multiop ll_sparseness_verify
noinst_PROGRAMS += ll_sparseness_write mrename ll_dirstripe_verify mkdirmany
noinst_PROGRAMS += openfilleddirunlink rename_many memhog
-noinst_PROGRAMS += mmap_sanity flock_test writemany reads flocks_test
+noinst_PROGRAMS += mmap_sanity writemany reads flocks_test
noinst_PROGRAMS += write_time_limit rwv copytool
# noinst_PROGRAMS += copy_attr mkdirdeep
bin_PROGRAMS = mcreate munlink
+++ /dev/null
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
- * 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.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
- * Use is subject to license terms.
- */
-/*
- * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/file.h>
-#include <sys/wait.h>
-
-void chd_lock_unlock(int);
-char fname[1024];
-
-int main(int argc, char **argv)
-{
- pid_t pid;
- int cfd, fd, rc;
-
- if (argc != 2) {
- fprintf(stderr, "\nUSAGE: flock_test filepath\n");
- exit(2);
- }
- strncpy(fname, argv[1], 1023);
- fname[1023] ='\0';
- fd = open(fname, O_RDWR|O_CREAT, (mode_t)0666);
- if (fd == -1) {
- fprintf(stderr, "flock_test: failed to open %s : ", fname);
- perror("");
- exit(1);
- }
- if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
- fprintf(stderr, "flock_test: parent attempt to lock %s failed : ", \
- fname);
- perror("");
- exit(1);
- }
-
- pid = fork();
- if (pid == -1) {
- fprintf(stderr, "flock_test: fork failed : ");
- perror("");
- exit(1);
- }
-
- if (pid == 0) {
- pid = getpid();
- sleep(2);
- if ((cfd = open(fname, O_RDWR)) == -1) {
- fprintf(stderr, "flock_test child (%d) cannot open %s: ", \
- pid, fname);
- perror("");
- exit(1);
- }
- if(flock(cfd, LOCK_EX | LOCK_NB) != -1) {
- fprintf(stderr, "flock_test child (%d): %s not yet locked : ", \
- pid, fname);
- exit(1);
- }
- if(flock(fd, LOCK_UN) == -1) {
- fprintf(stderr, "flock_test child (%d): cannot unlock %s: ", \
- pid, fname);
- perror("");
- exit(1);
- }
- if(flock(cfd, LOCK_EX | LOCK_NB) == -1 ) {
- fprintf(stderr, \
- "flock_test: child (%d) cannot re-lock %s after unlocking : ", \
- pid, fname);
- perror("");
- exit(1);
- }
- close(cfd);
- exit(0);
- }
-
- waitpid(pid, &rc, 0);
- close(fd);
- unlink(fname);
- if (WIFEXITED(rc) && WEXITSTATUS(rc) != 0) {
- fprintf(stderr, "flock_test: child (%d) exit code = %d\n", \
- pid, WEXITSTATUS(rc));
- exit(1);
- }
- exit(0);
-}
#include <unistd.h>
#include <pthread.h>
#include <sys/file.h>
+#include <sys/wait.h>
#include <stdarg.h>
#define MAX_PATH_LENGTH 4096
return rc;
}
+/** =================================================================
+ * test number 3
+ *
+ * Bug 24040: Two conflicting flocks from same process different fds should fail
+ * two conflicting flocks from different processes but same fs
+ * should succeed.
+ */
+int t3(int argc, char *argv[])
+{
+ int fd, fd2;
+ int pid;
+ int rc = EXIT_SUCCESS;
+
+ if (argc != 3) {
+ fprintf(stderr, "Usage: ./flocks_test 3 filename\n");
+ return EXIT_FAILURE;
+ }
+
+ if ((fd = open(argv[2], O_RDWR)) < 0) {
+ fprintf(stderr, "Couldn't open file: %s\n", argv[1]);
+ return EXIT_FAILURE;
+ }
+ if (flock(fd, LOCK_EX | LOCK_NB) < 0) {
+ perror("first flock failed");
+ rc = EXIT_FAILURE;
+ goto out;
+ }
+ if ((fd2 = open(argv[2], O_RDWR)) < 0) {
+ fprintf(stderr, "Couldn't open file: %s\n", argv[1]);
+ rc = EXIT_FAILURE;
+ goto out;
+ }
+ if (flock(fd2, LOCK_EX | LOCK_NB) >= 0) {
+ fprintf(stderr, "Second flock succeeded - FAIL\n");
+ rc = EXIT_FAILURE;
+ close(fd2);
+ goto out;
+ }
+
+ close(fd2);
+
+ pid = fork();
+ if (pid == -1) {
+ perror("fork");
+ rc = EXIT_FAILURE;
+ goto out;
+ }
+
+ if (pid == 0) {
+ if ((fd2 = open(argv[2], O_RDWR)) < 0) {
+ fprintf(stderr, "Couldn't open file: %s\n", argv[1]);
+ rc = EXIT_FAILURE;
+ exit(rc);
+ }
+ if (flock(fd2, LOCK_EX | LOCK_NB) >= 0) {
+ fprintf(stderr, "Second flock succeeded - FAIL\n");
+ rc = EXIT_FAILURE;
+ goto out_child;
+ }
+ if (flock(fd, LOCK_UN) == -1) {
+ fprintf(stderr, "Child unlock on parent fd failed\n");
+ rc = EXIT_FAILURE;
+ goto out_child;
+ }
+ if (flock(fd2, LOCK_EX | LOCK_NB) == -1) {
+ fprintf(stderr, "Relock after parent unlock failed!\n");
+ rc = EXIT_FAILURE;
+ goto out_child;
+ }
+ out_child:
+ close(fd2);
+ exit(rc);
+ }
+
+ waitpid(pid, &rc, 0);
+out:
+ close(fd);
+ return rc;
+}
+
+
/** ==============================================================
* program entry
*/
case 2:
rc = t2(argc, argv);
break;
+ case 3:
+ rc = t3(argc, argv);
+ break;
default:
fprintf(stderr, "unknow test number %s\n", argv[1]);
break;
}
run_test 105d "flock race (should not freeze) ========"
+test_105e() { # bug 22660 && 22040
+ [ -z "`mount | grep \"$DIR.*flock\" | grep -v noflock`" ] && \
+ skip "mount w/o flock enabled" && return
+ touch $DIR/$tfile
+ flocks_test 3 $DIR/$tfile
+}
+run_test 105e "Two conflicting flocks from same process ======="
+
test_106() { #bug 10921
mkdir -p $DIR/$tdir
$DIR/$tdir && error "exec $DIR/$tdir succeeded"
check_ldlm_flock(void)
{
BLANK_LINE();
- CHECK_STRUCT(ldlm_flock);
- CHECK_MEMBER(ldlm_flock, start);
- CHECK_MEMBER(ldlm_flock, end);
- CHECK_MEMBER(ldlm_flock, blocking_pid);
- CHECK_MEMBER(ldlm_flock, pid);
+ CHECK_STRUCT(ldlm_flock_wire);
+ CHECK_MEMBER(ldlm_flock_wire, lfw_start);
+ CHECK_MEMBER(ldlm_flock_wire, lfw_end);
+ CHECK_MEMBER(ldlm_flock_wire, lfw_owner);
+ CHECK_MEMBER(ldlm_flock_wire, lfw_pid);
}
static void
{
/* Wire protocol assertions generated by 'wirecheck'
* (make -C lustre/utils newwiretest)
- * running on Linux vl1 2.6.18-prep #3 SMP Mon Apr 19 06:11:00 CDT 2010 x86_64 x86_64 x86_64
- * with gcc version 4.1.2 20070626 (Red Hat 4.1.2-14) */
+ * running on Linux centos5.localhost 2.6.18-prep #3 SMP Mon Mar 22 08:28:01 EDT 2010 x86_64
+ * with gcc version 4.1.2 20071124 (Red Hat 4.1.2-42) */
/* Constants... */
LASSERTF((int)sizeof(((struct ldlm_extent *)0)->gid) == 8, " found %lld\n",
(long long)(int)sizeof(((struct ldlm_extent *)0)->gid));
- /* Checks for struct ldlm_flock */
- LASSERTF((int)sizeof(struct ldlm_flock) == 32, " found %lld\n",
- (long long)(int)sizeof(struct ldlm_flock));
- LASSERTF((int)offsetof(struct ldlm_flock, start) == 0, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, start));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->start) == 8, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->start));
- LASSERTF((int)offsetof(struct ldlm_flock, end) == 8, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, end));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->end) == 8, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->end));
- LASSERTF((int)offsetof(struct ldlm_flock, blocking_pid) == 24, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, blocking_pid));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->blocking_pid) == 4, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->blocking_pid));
- LASSERTF((int)offsetof(struct ldlm_flock, pid) == 28, " found %lld\n",
- (long long)(int)offsetof(struct ldlm_flock, pid));
- LASSERTF((int)sizeof(((struct ldlm_flock *)0)->pid) == 4, " found %lld\n",
- (long long)(int)sizeof(((struct ldlm_flock *)0)->pid));
+ /* Checks for struct ldlm_flock_wire */
+ LASSERTF((int)sizeof(struct ldlm_flock_wire) == 32, " found %lld\n",
+ (long long)(int)sizeof(struct ldlm_flock_wire));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_start) == 0, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_start));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_start) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_start));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_end) == 8, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_end));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_end) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_end));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_owner) == 16, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_owner));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_owner) == 8, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_owner));
+ LASSERTF((int)offsetof(struct ldlm_flock_wire, lfw_pid) == 28, " found %lld\n",
+ (long long)(int)offsetof(struct ldlm_flock_wire, lfw_pid));
+ LASSERTF((int)sizeof(((struct ldlm_flock_wire *)0)->lfw_pid) == 4, " found %lld\n",
+ (long long)(int)sizeof(((struct ldlm_flock_wire *)0)->lfw_pid));
/* Checks for struct ldlm_inodebits */
LASSERTF((int)sizeof(struct ldlm_inodebits) == 8, " found %lld\n",