staging/lustre/dlmlock: compress out unused space (f2145eae) · Commits · 戴 / test

drivers/staging/lustre/lustre/include/lustre_dlm.h

+5 −193

Original line number	Diff line number	Diff line
		@@ -57,6 +57,8 @@
		#include <interval_tree.h> /* for interval_node{}, ldlm_extent */
		#include <lu_ref.h>

		#include "lustre_dlm_flags.h"

		struct obd_ops;
		struct obd_device;

		@@ -95,161 +97,6 @@ typedef enum {
		LDLM_NAMESPACE_CLIENT = 1 << 1
		} ldlm_side_t;

		/**
		* Declaration of flags sent through the wire.
		**/
		#define LDLM_FL_LOCK_CHANGED 0x000001 /* extent, mode, or resource changed */

		/**
		* If the server returns one of these flags, then the lock was put on that list.
		* If the client sends one of these flags (during recovery ONLY!), it wants the
		* lock added to the specified list, no questions asked.
		*/
		#define LDLM_FL_BLOCK_GRANTED 0x000002
		#define LDLM_FL_BLOCK_CONV 0x000004
		#define LDLM_FL_BLOCK_WAIT 0x000008

		/* Used to be LDLM_FL_CBPENDING 0x000010 moved to non-wire flags */

		#define LDLM_FL_AST_SENT 0x000020 /* blocking or cancel packet was
		* queued for sending. */
		/* Used to be LDLM_FL_WAIT_NOREPROC 0x000040 moved to non-wire flags */
		/* Used to be LDLM_FL_CANCEL 0x000080 moved to non-wire flags */

		/**
		* Lock is being replayed. This could probably be implied by the fact that one
		* of BLOCK_{GRANTED,CONV,WAIT} is set, but that is pretty dangerous.
		*/
		#define LDLM_FL_REPLAY 0x000100

		#define LDLM_FL_INTENT_ONLY 0x000200 /* Don't grant lock, just do intent. */

		/* Used to be LDLM_FL_LOCAL_ONLY 0x000400 moved to non-wire flags */
		/* Used to be LDLM_FL_FAILED 0x000800 moved to non-wire flags */

		#define LDLM_FL_HAS_INTENT 0x001000 /* lock request has intent */

		/* Used to be LDLM_FL_CANCELING 0x002000 moved to non-wire flags */
		/* Used to be LDLM_FL_LOCAL 0x004000 moved to non-wire flags */

		#define LDLM_FL_DISCARD_DATA 0x010000 /* discard (no writeback) on cancel */

		#define LDLM_FL_NO_TIMEOUT 0x020000 /* Blocked by group lock - wait
		* indefinitely */

		/** file & record locking */
		#define LDLM_FL_BLOCK_NOWAIT 0x040000 /* Server told not to wait if blocked.
		* For AGL, OST will not send glimpse
		* callback. */
		#define LDLM_FL_TEST_LOCK 0x080000 // return blocking lock

		/* Used to be LDLM_FL_LVB_READY 0x100000 moved to non-wire flags */
		/* Used to be LDLM_FL_KMS_IGNORE 0x200000 moved to non-wire flags */
		/* Used to be LDLM_FL_NO_LRU 0x400000 moved to non-wire flags */

		/* Immediatelly cancel such locks when they block some other locks. Send
		* cancel notification to original lock holder, but expect no reply. This is
		* for clients (like liblustre) that cannot be expected to reliably response
		* to blocking AST. */
		#define LDLM_FL_CANCEL_ON_BLOCK 0x800000

		/* Flags flags inherited from parent lock when doing intents. */
		#define LDLM_INHERIT_FLAGS (LDLM_FL_CANCEL_ON_BLOCK)

		/* Used to be LDLM_FL_CP_REQD 0x1000000 moved to non-wire flags */
		/* Used to be LDLM_FL_CLEANED 0x2000000 moved to non-wire flags */
		/* Used to be LDLM_FL_ATOMIC_CB 0x4000000 moved to non-wire flags */
		/* Used to be LDLM_FL_BL_AST 0x10000000 moved to non-wire flags */
		/* Used to be LDLM_FL_BL_DONE 0x20000000 moved to non-wire flags */

		/* measure lock contention and return -EUSERS if locking contention is high */
		#define LDLM_FL_DENY_ON_CONTENTION 0x40000000

		/* These are flags that are mapped into the flags and ASTs of blocking locks */
		#define LDLM_AST_DISCARD_DATA 0x80000000 /* Add FL_DISCARD to blocking ASTs */

		/* Flags sent in AST lock_flags to be mapped into the receiving lock. */
		#define LDLM_AST_FLAGS (LDLM_FL_DISCARD_DATA)

		/*
		* --------------------------------------------------------------------------
		* NOTE! Starting from this point, that is, LDLM_FL_* flags with values above
		* 0x80000000 will not be sent over the wire.
		* --------------------------------------------------------------------------
		*/

		/**
		* Declaration of flags not sent through the wire.
		**/

		/**
		* Used for marking lock as a target for -EINTR while cp_ast sleep
		* emulation + race with upcoming bl_ast.
		*/
		#define LDLM_FL_FAIL_LOC 0x100000000ULL

		/**
		* Used while processing the unused list to know that we have already
		* handled this lock and decided to skip it.
		*/
		#define LDLM_FL_SKIPPED 0x200000000ULL
		/* this lock is being destroyed */
		#define LDLM_FL_CBPENDING 0x400000000ULL
		/* not a real flag, not saved in lock */
		#define LDLM_FL_WAIT_NOREPROC 0x800000000ULL
		/* cancellation callback already run */
		#define LDLM_FL_CANCEL 0x1000000000ULL
		#define LDLM_FL_LOCAL_ONLY 0x2000000000ULL
		/* don't run the cancel callback under ldlm_cli_cancel_unused */
		#define LDLM_FL_FAILED 0x4000000000ULL
		/* lock cancel has already been sent */
		#define LDLM_FL_CANCELING 0x8000000000ULL
		/* local lock (ie, no srv/cli split) */
		#define LDLM_FL_LOCAL 0x10000000000ULL
		/* XXX FIXME: This is being added to b_size as a low-risk fix to the fact that
		* the LVB filling happens _after_ the lock has been granted, so another thread
		* can match it before the LVB has been updated. As a dirty hack, we set
		* LDLM_FL_LVB_READY only after we've done the LVB poop.
		* this is only needed on LOV/OSC now, where LVB is actually used and callers
		* must set it in input flags.
		*
		* The proper fix is to do the granting inside of the completion AST, which can
		* be replaced with a LVB-aware wrapping function for OSC locks. That change is
		* pretty high-risk, though, and would need a lot more testing. */
		#define LDLM_FL_LVB_READY 0x20000000000ULL
		/* A lock contributes to the known minimum size (KMS) calculation until it has
		* finished the part of its cancelation that performs write back on its dirty
		* pages. It can remain on the granted list during this whole time. Threads
		* racing to update the KMS after performing their writeback need to know to
		* exclude each other's locks from the calculation as they walk the granted
		* list. */
		#define LDLM_FL_KMS_IGNORE 0x40000000000ULL
		/* completion AST to be executed */
		#define LDLM_FL_CP_REQD 0x80000000000ULL
		/* cleanup_resource has already handled the lock */
		#define LDLM_FL_CLEANED 0x100000000000ULL
		/* optimization hint: LDLM can run blocking callback from current context
		* w/o involving separate thread. in order to decrease cs rate */
		#define LDLM_FL_ATOMIC_CB 0x200000000000ULL

		/* It may happen that a client initiates two operations, e.g. unlink and
		* mkdir, such that the server sends a blocking AST for conflicting
		* locks to this client for the first operation, whereas the second
		* operation has canceled this lock and is waiting for rpc_lock which is
		* taken by the first operation. LDLM_FL_BL_AST is set by
		* ldlm_callback_handler() in the lock to prevent the Early Lock Cancel
		* (ELC) code from cancelling it.
		*
		* LDLM_FL_BL_DONE is to be set by ldlm_cancel_callback() when lock
		* cache is dropped to let ldlm_callback_handler() return EINVAL to the
		* server. It is used when ELC RPC is already prepared and is waiting
		* for rpc_lock, too late to send a separate CANCEL RPC. */
		#define LDLM_FL_BL_AST 0x400000000000ULL
		#define LDLM_FL_BL_DONE 0x800000000000ULL
		/* Don't put lock into the LRU list, so that it is not canceled due to aging.
		* Used by MGC locks, they are cancelled only at unmount or by callback. */
		#define LDLM_FL_NO_LRU 0x1000000000000ULL

		/**
		* The blocking callback is overloaded to perform two functions. These flags
		* indicate which operation should be performed.
		@@ -720,8 +567,6 @@ typedef int (ldlm_completion_callback)(struct ldlm_lock lock, __u64 flags,
		void *data);
		/** Type for glimpse callback function of a lock. */
		typedef int (ldlm_glimpse_callback)(struct ldlm_lock lock, void *data);
		/** Type for weight callback function of a lock. */
		typedef unsigned long (ldlm_weigh_callback)(struct ldlm_lock lock);

		/** Work list for sending GL ASTs to multiple locks. */
		struct ldlm_glimpse_work {
		@@ -890,9 +735,6 @@ struct ldlm_lock {
		*/
		ldlm_glimpse_callback l_glimpse_ast;

		/** XXX apparently unused "weight" handler. To be removed? */
		ldlm_weigh_callback l_weigh_ast;

		/**
		* Lock export.
		* This is a pointer to actual client export for locks that were granted
		@@ -919,11 +761,11 @@ struct ldlm_lock {
		ldlm_policy_data_t l_policy_data;

		/**
		* Lock state flags.
		* Like whenever we receive any blocking requests for this lock, etc.
		* Protected by lr_lock.
		* Lock state flags. Protected by lr_lock.
		* \see lustre_dlm_flags.h where the bits are defined.
		*/
		__u64 l_flags;

		/**
		* Lock r/w usage counters.
		* Protected by lr_lock.
		@@ -952,34 +794,6 @@ struct ldlm_lock {
		/** Originally requested extent for the extent lock. */
		struct ldlm_extent l_req_extent;

		unsigned int l_failed:1,
		/**
		* Set for locks that were removed from class hash table and will be
		* destroyed when last reference to them is released. Set by
		* ldlm_lock_destroy_internal().
		*
		* Protected by lock and resource locks.
		*/
		l_destroyed:1,
		/*
		* it's set in lock_res_and_lock() and unset in unlock_res_and_lock().
		*
		* NB: compared with check_res_locked(), checking this bit is cheaper.
		* Also, spin_is_locked() is deprecated for kernel code; one reason is
		* because it works only for SMP so user needs to add extra macros like
		* LASSERT_SPIN_LOCKED for uniprocessor kernels.
		*/
		l_res_locked:1,
		/*
		* It's set once we call ldlm_add_waiting_lock_res_locked()
		* to start the lock-timeout timer and it will never be reset.
		*
		* Protected by lock_res_and_lock().
		*/
		l_waited:1,
		/** Flag whether this is a server namespace lock. */
		l_ns_srv:1;

		/*
		* Client-side-only members.
		*/
		@@ -1230,7 +1044,6 @@ struct ldlm_enqueue_info {
		void ei_cb_bl; /* blocking lock callback */
		void ei_cb_cp; /* lock completion callback */
		void ei_cb_gl; /* lock glimpse callback */
		void ei_cb_wg; /* lock weigh callback */
		void ei_cbdata; /* Data to be passed into callbacks. */
		};

		@@ -1328,7 +1141,6 @@ struct ldlm_callback_suite {
		ldlm_completion_callback lcs_completion;
		ldlm_blocking_callback lcs_blocking;
		ldlm_glimpse_callback lcs_glimpse;
		ldlm_weigh_callback lcs_weigh;
		};

		/* ldlm_lockd.c */

drivers/staging/lustre/lustre/include/lustre_dlm_flags.h

0 → 100644

+460 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/lustre/lustre/ldlm/l_lock.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -51,12 +51,12 @@
		struct ldlm_resource lock_res_and_lock(struct ldlm_lock lock)
		{
		/* on server-side resource of lock doesn't change */
		if (!lock->l_ns_srv)
		if ((lock->l_flags & LDLM_FL_NS_SRV) == 0)
		spin_lock(&lock->l_lock);

		lock_res(lock->l_resource);

		lock->l_res_locked = 1;
		lock->l_flags \|= LDLM_FL_RES_LOCKED;
		return lock->l_resource;
		}
		EXPORT_SYMBOL(lock_res_and_lock);
		@@ -67,10 +67,10 @@ EXPORT_SYMBOL(lock_res_and_lock);
		void unlock_res_and_lock(struct ldlm_lock *lock)
		{
		/* on server-side resource of lock doesn't change */
		lock->l_res_locked = 0;
		lock->l_flags &= ~LDLM_FL_RES_LOCKED;

		unlock_res(lock->l_resource);
		if (!lock->l_ns_srv)
		if ((lock->l_flags & LDLM_FL_NS_SRV) == 0)
		spin_unlock(&lock->l_lock);
		}
		EXPORT_SYMBOL(unlock_res_and_lock);

drivers/staging/lustre/lustre/ldlm/ldlm_flock.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -639,7 +639,7 @@ ldlm_flock_completion_ast(struct ldlm_lock lock, __u64 flags, void data)
		granted:
		OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT, 10);

		if (lock->l_destroyed) {
		if (lock->l_flags & LDLM_FL_DESTROYED) {
		LDLM_DEBUG(lock, "client-side enqueue waking up: destroyed");
		RETURN(0);
		}

drivers/staging/lustre/lustre/ldlm/ldlm_lock.c

+23 −25

Original line number	Diff line number	Diff line
		@@ -199,7 +199,7 @@ void ldlm_lock_put(struct ldlm_lock *lock)
		"final lock_put on destroyed lock, freeing it.");

		res = lock->l_resource;
		LASSERT(lock->l_destroyed);
		LASSERT(lock->l_flags & LDLM_FL_DESTROYED);
		LASSERT(list_empty(&lock->l_res_link));
		LASSERT(list_empty(&lock->l_pending_chain));

		@@ -254,7 +254,7 @@ int ldlm_lock_remove_from_lru(struct ldlm_lock *lock)
		int rc;

		ENTRY;
		if (lock->l_ns_srv) {
		if (lock->l_flags & LDLM_FL_NS_SRV) {
		LASSERT(list_empty(&lock->l_lru));
		RETURN(0);
		}
		@@ -305,7 +305,7 @@ void ldlm_lock_touch_in_lru(struct ldlm_lock *lock)
		struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);

		ENTRY;
		if (lock->l_ns_srv) {
		if (lock->l_flags & LDLM_FL_NS_SRV) {
		LASSERT(list_empty(&lock->l_lru));
		EXIT;
		return;
		@@ -353,12 +353,12 @@ int ldlm_lock_destroy_internal(struct ldlm_lock *lock)
		LBUG();
		}

		if (lock->l_destroyed) {
		if (lock->l_flags & LDLM_FL_DESTROYED) {
		LASSERT(list_empty(&lock->l_lru));
		EXIT;
		return 0;
		}
		lock->l_destroyed = 1;
		lock->l_flags \|= LDLM_FL_DESTROYED;

		if (lock->l_export && lock->l_export->exp_lock_hash) {
		/* NB: it's safe to call cfs_hash_del() even lock isn't
		@@ -596,7 +596,7 @@ struct ldlm_lock __ldlm_handle2lock(const struct lustre_handle handle,

		/* It's unlikely but possible that someone marked the lock as
		* destroyed after we did handle2object on it */
		if (flags == 0 && !lock->l_destroyed) {
		if (flags == 0 && ((lock->l_flags & LDLM_FL_DESTROYED)== 0)) {
		lu_ref_add(&lock->l_reference, "handle", current);
		RETURN(lock);
		}
		@@ -606,7 +606,7 @@ struct ldlm_lock __ldlm_handle2lock(const struct lustre_handle handle,
		LASSERT(lock->l_resource != NULL);

		lu_ref_add_atomic(&lock->l_reference, "handle", current);
		if (unlikely(lock->l_destroyed)) {
		if (unlikely(lock->l_flags & LDLM_FL_DESTROYED)) {
		unlock_res_and_lock(lock);
		CDEBUG(D_INFO, "lock already destroyed: lock %p\n", lock);
		LDLM_LOCK_PUT(lock);
		@@ -695,7 +695,7 @@ void ldlm_add_bl_work_item(struct ldlm_lock lock, struct ldlm_lock new,
		lock->l_flags \|= LDLM_FL_AST_SENT;
		/* If the enqueuing client said so, tell the AST recipient to
		* discard dirty data, rather than writing back. */
		if (new->l_flags & LDLM_AST_DISCARD_DATA)
		if (new->l_flags & LDLM_FL_AST_DISCARD_DATA)
		lock->l_flags \|= LDLM_FL_DISCARD_DATA;
		LASSERT(list_empty(&lock->l_bl_ast));
		list_add(&lock->l_bl_ast, work_list);
		@@ -873,7 +873,7 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, __u32 mode)
		(lock->l_flags & LDLM_FL_CBPENDING)) {
		/* If we received a blocked AST and this was the last reference,
		* run the callback. */
		if (lock->l_ns_srv && lock->l_export)
		if ((lock->l_flags & LDLM_FL_NS_SRV) && lock->l_export)
		CERROR("FL_CBPENDING set on non-local lock--just a "
		"warning\n");

		@@ -1069,7 +1069,7 @@ static void ldlm_granted_list_add_lock(struct ldlm_lock *lock,
		ldlm_resource_dump(D_INFO, res);
		LDLM_DEBUG(lock, "About to add lock:");

		if (lock->l_destroyed) {
		if (lock->l_flags & LDLM_FL_DESTROYED) {
		CDEBUG(D_OTHER, "Lock destroyed, not adding to resource\n");
		return;
		}
		@@ -1203,9 +1203,7 @@ static struct ldlm_lock search_queue(struct list_head queue,
		policy->l_inodebits.bits))
		continue;

		if (!unref &&
		(lock->l_destroyed \|\| lock->l_flags & LDLM_FL_FAILED \|\|
		lock->l_failed))
		if (!unref && (lock->l_flags & LDLM_FL_GONE_MASK))
		continue;

		if ((flags & LDLM_FL_LOCAL_ONLY) &&
		@@ -1227,8 +1225,8 @@ static struct ldlm_lock search_queue(struct list_head queue,

		void ldlm_lock_fail_match_locked(struct ldlm_lock *lock)
		{
		if (!lock->l_failed) {
		lock->l_failed = 1;
		if ((lock->l_flags & LDLM_FL_FAIL_NOTIFIED) == 0) {
		lock->l_flags \|= LDLM_FL_FAIL_NOTIFIED;
		wake_up_all(&lock->l_waitq);
		}
		}
		@@ -1352,6 +1350,8 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, __u64 flags,
		ldlm_lock2handle(lock, lockh);
		if ((flags & LDLM_FL_LVB_READY) &&
		(!(lock->l_flags & LDLM_FL_LVB_READY))) {
		__u64 wait_flags = LDLM_FL_LVB_READY \|
		LDLM_FL_DESTROYED \| LDLM_FL_FAIL_NOTIFIED;
		struct l_wait_info lwi;
		if (lock->l_completion_ast) {
		int err = lock->l_completion_ast(lock,
		@@ -1373,8 +1373,7 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, __u64 flags,

		/* XXX FIXME see comment on CAN_MATCH in lustre_dlm.h */
		l_wait_event(lock->l_waitq,
		lock->l_flags & LDLM_FL_LVB_READY \|\|
		lock->l_destroyed \|\| lock->l_failed,
		lock->l_flags & wait_flags,
		&lwi);
		if (!(lock->l_flags & LDLM_FL_LVB_READY)) {
		if (flags & LDLM_FL_TEST_LOCK)
		@@ -1431,8 +1430,7 @@ ldlm_mode_t ldlm_revalidate_lock_handle(struct lustre_handle *lockh,
		lock = ldlm_handle2lock(lockh);
		if (lock != NULL) {
		lock_res_and_lock(lock);
		if (lock->l_destroyed \|\| lock->l_flags & LDLM_FL_FAILED \|\|
		lock->l_failed)
		if (lock->l_flags & LDLM_FL_GONE_MASK)
		GOTO(out, mode);

		if (lock->l_flags & LDLM_FL_CBPENDING &&
		@@ -1583,12 +1581,12 @@ struct ldlm_lock ldlm_lock_create(struct ldlm_namespace ns,
		lock->l_req_mode = mode;
		lock->l_ast_data = data;
		lock->l_pid = current_pid();
		lock->l_ns_srv = !!ns_is_server(ns);
		if (ns_is_server(ns))
		lock->l_flags \|= LDLM_FL_NS_SRV;
		if (cbs) {
		lock->l_blocking_ast = cbs->lcs_blocking;
		lock->l_completion_ast = cbs->lcs_completion;
		lock->l_glimpse_ast = cbs->lcs_glimpse;
		lock->l_weigh_ast = cbs->lcs_weigh;
		}

		lock->l_tree_node = NULL;
		@@ -1693,7 +1691,7 @@ ldlm_error_t ldlm_lock_enqueue(struct ldlm_namespace *ns,

		/* Some flags from the enqueue want to make it into the AST, via the
		* lock's l_flags. */
		lock->l_flags \|= *flags & LDLM_AST_DISCARD_DATA;
		lock->l_flags \|= *flags & LDLM_FL_AST_DISCARD_DATA;

		/* This distinction between local lock trees is very important; a client
		* namespace only has information about locks taken by that client, and
		@@ -2046,15 +2044,15 @@ void ldlm_lock_cancel(struct ldlm_lock *lock)
		LBUG();
		}

		if (lock->l_waited)
		if (lock->l_flags & LDLM_FL_WAITED)
		ldlm_del_waiting_lock(lock);

		/* Releases cancel callback. */
		ldlm_cancel_callback(lock);

		/* Yes, second time, just in case it was added again while we were
		running with no res lock in ldlm_cancel_callback */
		if (lock->l_waited)
		* running with no res lock in ldlm_cancel_callback */
		if (lock->l_flags & LDLM_FL_WAITED)
		ldlm_del_waiting_lock(lock);

		ldlm_resource_unlink_lock(lock);

Admin message