1 files changed, 73 insertions, 32 deletions

diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h
index cf2849fc251..c868eb494a2 100644
--- a/xlators/features/locks/src/locks.h
+++ b/xlators/features/locks/src/locks.h
@@ -10,13 +10,13 @@
 #ifndef __POSIX_LOCKS_H__
 #define __POSIX_LOCKS_H__
 
-#include "compat-errno.h"
-#include "stack.h"
-#include "call-stub.h"
+#include <glusterfs/compat-errno.h>
+#include <glusterfs/stack.h>
+#include <glusterfs/call-stub.h>
 #include "locks-mem-types.h"
-#include "client_t.h"
+#include <glusterfs/client_t.h>
 
-#include "lkowner.h"
+#include <glusterfs/lkowner.h>
 
 typedef enum {
     MLK_NONE,
@@ -30,11 +30,11 @@ struct __pl_fd;
 struct __posix_lock {
     struct list_head list;
 
-    short fl_type;
     off_t fl_start;
     off_t fl_end;
     uint32_t lk_flags;
 
+    short fl_type;
     short blocked;              /* waiting to acquire */
     struct gf_flock user_flock; /* the flock supplied by the user */
     xlator_t *this;             /* required for blocked locks */
@@ -43,9 +43,8 @@ struct __posix_lock {
     fd_t *fd;
     call_frame_t *frame;
 
-    struct timeval blkd_time; /*time at which lock was queued into blkd list*/
-    struct timeval
-        granted_time; /*time at which lock was queued into active list*/
+    time_t blkd_time;    /* time at which lock was queued into blkd list */
+    time_t granted_time; /* time at which lock was queued into active list */
 
     /* These two together serve to uniquely identify each process
        across nodes */
@@ -74,7 +73,6 @@ struct __pl_inode_lock {
     struct list_head contend;       /* list of contending locks */
     int ref;
 
-    short fl_type;
     off_t fl_start;
     off_t fl_end;
 
@@ -86,9 +84,9 @@ struct __pl_inode_lock {
 
     call_frame_t *frame;
 
-    struct timeval blkd_time; /*time at which lock was queued into blkd list*/
-    struct timeval
-        granted_time; /*time at which lock was queued into active list*/
+    time_t blkd_time;    /* time at which lock was queued into blkd list */
+    time_t granted_time; /* time at which lock was queued into active list */
+
     /*last time at which lock contention was detected and notified*/
     struct timespec contention_time;
 
@@ -102,6 +100,10 @@ struct __pl_inode_lock {
     char *connection_id; /* stores the client connection id */
 
     struct list_head client_list; /* list of all locks from a client */
+    short fl_type;
+
+    int32_t status; /* Error code when we try to grant a lock in blocked
+                       state */
 };
 typedef struct __pl_inode_lock pl_inode_lock_t;
 
@@ -135,11 +137,10 @@ struct __entry_lock {
     const char *volume;
 
     const char *basename;
-    entrylk_type type;
 
-    struct timeval blkd_time; /*time at which lock was queued into blkd list*/
-    struct timeval
-        granted_time; /*time at which lock was queued into active list*/
+    time_t blkd_time;    /* time at which lock was queued into blkd list */
+    time_t granted_time; /* time at which lock was queued into active list */
+
     /*last time at which lock contention was detected and notified*/
     struct timespec contention_time;
 
@@ -150,6 +151,7 @@ struct __entry_lock {
     char *connection_id; /* stores the client connection id */
 
     struct list_head client_list; /* list of all locks from a client */
+    entrylk_type type;
 };
 typedef struct __entry_lock pl_entry_lock_t;
 
@@ -164,13 +166,14 @@ struct __pl_inode {
     struct list_head rw_list;            /* list of waiting r/w requests */
     struct list_head reservelk_list;     /* list of reservelks */
     struct list_head blocked_reservelks; /* list of blocked reservelks */
-    struct list_head
-        blocked_calls; /* List of blocked lock calls while a reserve is held*/
-    struct list_head metalk_list; /* Meta lock list */
-                                  /* This is to store the incoming lock
-                                     requests while meta lock is enabled */
-    struct list_head queued_locks;
-    int mandatory; /* if mandatory locking is enabled */
+    struct list_head blocked_calls;      /* List of blocked lock calls while a
+                                            reserve is held*/
+    struct list_head metalk_list;        /* Meta lock list */
+    struct list_head queued_locks;       /* This is to store the incoming lock
+                                            requests while meta lock is enabled */
+    struct list_head waiting; /* List of pending fops waiting to unlink/rmdir
+                                 the inode. */
+    int mandatory;            /* if mandatory locking is enabled */
 
     inode_t *refkeeper; /* hold refs on an inode while locks are
                            held to prevent pruning */
@@ -179,6 +182,31 @@ struct __pl_inode {
                            of inode_t as long as there are
                            locks on it */
     gf_boolean_t migrated;
+
+    /* Flag to indicate whether to read mlock-enforce xattr from disk */
+    gf_boolean_t check_mlock_info;
+
+    /* Mandatory_lock enforce: IO will be allowed if and only if the lkowner has
+       held the lock.
+
+       Note: An xattr is set on the file to recover this information post
+       reboot. If client does not want mandatory lock to be enforced, then it
+       should remove this xattr explicitly
+    */
+    gf_boolean_t mlock_enforced;
+    /* There are scenarios where mandatory lock is granted but there are IOs
+       pending at posix level. To avoid this before preempting the previous lock
+       owner, we wait for all the fops to be unwound.
+    */
+    int fop_wind_count;
+    pthread_cond_t check_fop_wind_count;
+
+    gf_boolean_t track_fop_wind_count;
+
+    int32_t links;           /* Number of hard links the inode has. */
+    uint32_t remove_running; /* Number of remove operations running. */
+    gf_boolean_t is_locked;  /* Regular locks will be blocked. */
+    gf_boolean_t removed;    /* The inode has been deleted. */
 };
 typedef struct __pl_inode pl_inode_t;
 
@@ -196,29 +224,33 @@ struct __pl_metalk {
 typedef struct __pl_metalk pl_meta_lock_t;
 
 typedef struct {
+    char *brickname;
+    uint32_t revocation_secs;
+    uint32_t revocation_max_blocked;
+    uint32_t notify_contention_delay;
     mlk_mode_t mandatory_mode; /* holds current mandatory locking mode */
     gf_boolean_t trace;        /* trace lock requests in and out */
-    char *brickname;
     gf_boolean_t monkey_unlocking;
-    uint32_t revocation_secs;
     gf_boolean_t revocation_clear_all;
-    uint32_t revocation_max_blocked;
     gf_boolean_t notify_contention;
-    uint32_t notify_contention_delay;
+    gf_boolean_t mlock_enforced;
 } posix_locks_private_t;
 
 typedef struct {
-    gf_boolean_t entrylk_count_req;
-    gf_boolean_t inodelk_count_req;
-    gf_boolean_t posixlk_count_req;
-    gf_boolean_t parent_entrylk_req;
     data_t *inodelk_dom_count_req;
 
     dict_t *xdata;
     loc_t loc[2];
     fd_t *fd;
+    inode_t *inode;
     off_t offset;
     glusterfs_fop_t op;
+    gf_boolean_t entrylk_count_req;
+    gf_boolean_t inodelk_count_req;
+    gf_boolean_t posixlk_count_req;
+    gf_boolean_t parent_entrylk_req;
+    gf_boolean_t multiple_dom_lk_requests;
+    int update_mlock_enforced_flag;
 } pl_local_t;
 
 typedef struct {
@@ -239,6 +271,15 @@ typedef struct _locks_ctx {
     struct list_head metalk_list;
 } pl_ctx_t;
 
+typedef struct _multi_dom_lk_data {
+    xlator_t *this;
+    inode_t *inode;
+    dict_t *xdata_rsp;
+    gf_boolean_t keep_max;
+} multi_dom_lk_data;
+
+typedef enum { DECREMENT, INCREMENT } pl_count_op_t;
+
 pl_ctx_t *
 pl_ctx_get(client_t *client, xlator_t *xlator);