The noncontroversial portion of the last few days of changes:

[fs/lustre-release.git] / lustre / ldlm / ldlm_extent.c

diff --git a/lustre/ldlm/ldlm_extent.c b/lustre/ldlm/ldlm_extent.c
index 3e1724d..e24a457 100644 (file)
--- a/lustre/ldlm/ldlm_extent.c
+++ b/lustre/ldlm/ldlm_extent.c
@@ -12,16 +12,8 @@
  */
 
 #define EXPORT_SYMTAB
-
-#include <linux/version.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <asm/unistd.h>
-
 #define DEBUG_SUBSYSTEM S_LDLM
 
-#include <linux/obd_support.h>
-#include <linux/obd_class.h>
 #include <linux/lustre_dlm.h>
 
 /* This function will be called to judge if the granted queue of another child
@@ -30,18 +22,41 @@
  *
  * This helps to find conflicts between read and write locks on overlapping
  * extents. */
-int ldlm_extent_compat(struct ldlm_resource *child, struct ldlm_resource *new)
+int ldlm_extent_compat(struct ldlm_lock *a, struct ldlm_lock *b)
 {
-        struct ldlm_extent *child_ex, *new_ex;
+        if (MAX(a->l_extent.start, b->l_extent.start) <=
+            MIN(a->l_extent.end, b->l_extent.end))
+                return 0;
+
+        return 1;
+}
 
-       child_ex = ldlm_res2extent(child);
-       new_ex = ldlm_res2extent(new);
+static void policy_internal(struct list_head *queue, struct ldlm_extent *req_ex,
+                            struct ldlm_extent *new_ex, ldlm_mode_t mode)
+{
+        struct list_head *tmp;
 
-       if (MAX(child_ex->start, new_ex->start) >
-           MIN(child_ex->end, new_ex->end))
-               return 0;
+        list_for_each(tmp, queue) {
+                struct ldlm_lock *lock;
+                lock = list_entry(tmp, struct ldlm_lock, l_res_link);
 
-        return 1;
+                if (lock->l_extent.end < req_ex->start)
+                        new_ex->start = MIN(lock->l_extent.end, new_ex->start);
+                else {
+                        if (lock->l_extent.start < req_ex->start &&
+                            !lockmode_compat(lock->l_req_mode, mode))
+                                /* Policy: minimize conflict overlap */
+                                new_ex->start = req_ex->start;
+                }
+                if (lock->l_extent.start > req_ex->end)
+                        new_ex->end = MAX(lock->l_extent.start, new_ex->end);
+                else {
+                        if (lock->l_extent.end > req_ex->end &&
+                            !lockmode_compat(lock->l_req_mode, mode))
+                                /* Policy: minimize conflict overlap */
+                                new_ex->end = req_ex->end;
+                }
+        }
 }
 
 /* The purpose of this function is to return:
@@ -52,42 +67,20 @@ int ldlm_extent_compat(struct ldlm_resource *child, struct ldlm_resource *new)
  * An alternative policy is to not shrink the new extent when conflicts exist.
  *
  * To reconstruct our formulas, take a deep breath. */
-int ldlm_extent_policy(struct ldlm_resource *parent,
-                      __u64 *res_id_in, __u64 *res_id_out,
-                      ldlm_mode_t mode, void *data)
+int ldlm_extent_policy(struct ldlm_resource *res, struct ldlm_extent *req_ex,
+                       struct ldlm_extent *new_ex, ldlm_mode_t mode, void *data)
 {
-        struct ldlm_extent *new_ex, *req_ex;
-        struct list_head *tmp;
-
-        req_ex = (struct ldlm_extent *)res_id_in;
-
-        new_ex = (struct ldlm_extent *)res_id_out;
         new_ex->start = 0;
         new_ex->end = ~0;
 
-        list_for_each(tmp, &parent->lr_children) {
-                struct ldlm_resource *res;
-                struct ldlm_extent *res_ex;
-                res = list_entry(tmp, struct ldlm_resource, lr_childof);
+        if (!res)
+                LBUG();
 
-                res_ex = ldlm_res2extent(res);
+        policy_internal(&res->lr_granted, req_ex, new_ex, mode);
+        policy_internal(&res->lr_converting, req_ex, new_ex, mode);
+        policy_internal(&res->lr_waiting, req_ex, new_ex, mode);
 
-                if (res_ex->end < req_ex->start)
-                        new_ex->start = MIN(res_ex->end, new_ex->start);
-                else {
-                        if (res_ex->start < req_ex->start)
-                                /* Policy: minimize conflict overlap */
-                                new_ex->start = req_ex->start;
-                }
-                if (res_ex->start > req_ex->end)
-                        new_ex->end = MAX(res_ex->start, new_ex->end);
-                else {
-                        if (res_ex->end > req_ex->end)
-                                /* Policy: minimize conflict overlap */
-                                new_ex->end = req_ex->end;
-                }
-        }
-
-       return 0;
+        if (new_ex->end != req_ex->end || new_ex->start != req_ex->start)
+                return ELDLM_LOCK_CHANGED;
+        return 0;
 }
-