Merge branch 'master' into next

Conflicts:
	fs/namei.c

Manually merged per:

diff --cc fs/namei.c
index 734f2b5,bbc15c2..0000000
--- a/fs/namei.c
+++ b/fs/namei.c
@@@ -860,9 -848,8 +849,10 @@@ static int __link_path_walk(const char
  		nd->flags |= LOOKUP_CONTINUE;
  		err = exec_permission_lite(inode);
  		if (err == -EAGAIN)
- 			err = vfs_permission(nd, MAY_EXEC);
+ 			err = inode_permission(nd->path.dentry->d_inode,
+ 					       MAY_EXEC);
 +		if (!err)
 +			err = ima_path_check(&nd->path, MAY_EXEC);
   		if (err)
  			break;

@@@ -1525,14 -1506,9 +1509,14 @@@ int may_open(struct path *path, int acc
  		flag &= ~O_TRUNC;
  	}

- 	error = vfs_permission(nd, acc_mode);
+ 	error = inode_permission(inode, acc_mode);
  	if (error)
  		return error;
 +
- 	error = ima_path_check(&nd->path,
++	error = ima_path_check(path,
 +			       acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC));
 +	if (error)
 +		return error;
  	/*
  	 * An append-only file must be opened in append mode for writing.
  	 */

Signed-off-by: James Morris <jmorris@namei.org>

1 files changed, 29 insertions, 28 deletions

diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
index 724ddac91538..01e7d39c5fba 100644
--- a/fs/dlm/lock.c
+++ b/fs/dlm/lock.c
@@ -307,7 +307,7 @@ static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
         lkb->lkb_lksb->sb_status = rv;
         lkb->lkb_lksb->sb_flags = lkb->lkb_sbflags;
 
-        dlm_add_ast(lkb, AST_COMP);
+        dlm_add_ast(lkb, AST_COMP, 0);
 }
 
 static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
@@ -318,12 +318,12 @@ static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
 
 static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
 {
+        lkb->lkb_time_bast = ktime_get();
+
         if (is_master_copy(lkb))
                 send_bast(r, lkb, rqmode);
-        else {
-                lkb->lkb_bastmode = rqmode;
-                dlm_add_ast(lkb, AST_BAST);
-        }
+        else
+                dlm_add_ast(lkb, AST_BAST, rqmode);
 }
 
 /*
@@ -412,9 +412,9 @@ static int search_rsb(struct dlm_ls *ls, char *name, int len, int b,
                       unsigned int flags, struct dlm_rsb **r_ret)
 {
         int error;
-        write_lock(&ls->ls_rsbtbl[b].lock);
+        spin_lock(&ls->ls_rsbtbl[b].lock);
         error = _search_rsb(ls, name, len, b, flags, r_ret);
-        write_unlock(&ls->ls_rsbtbl[b].lock);
+        spin_unlock(&ls->ls_rsbtbl[b].lock);
         return error;
 }
 
@@ -478,16 +478,16 @@ static int find_rsb(struct dlm_ls *ls, char *name, int namelen,
                 r->res_nodeid = nodeid;
         }
 
-        write_lock(&ls->ls_rsbtbl[bucket].lock);
+        spin_lock(&ls->ls_rsbtbl[bucket].lock);
         error = _search_rsb(ls, name, namelen, bucket, 0, &tmp);
         if (!error) {
-                write_unlock(&ls->ls_rsbtbl[bucket].lock);
+                spin_unlock(&ls->ls_rsbtbl[bucket].lock);
                 dlm_free_rsb(r);
                 r = tmp;
                 goto out;
         }
         list_add(&r->res_hashchain, &ls->ls_rsbtbl[bucket].list);
-        write_unlock(&ls->ls_rsbtbl[bucket].lock);
+        spin_unlock(&ls->ls_rsbtbl[bucket].lock);
         error = 0;
  out:
         *r_ret = r;
@@ -530,9 +530,9 @@ static void put_rsb(struct dlm_rsb *r)
         struct dlm_ls *ls = r->res_ls;
         uint32_t bucket = r->res_bucket;
 
-        write_lock(&ls->ls_rsbtbl[bucket].lock);
+        spin_lock(&ls->ls_rsbtbl[bucket].lock);
         kref_put(&r->res_ref, toss_rsb);
-        write_unlock(&ls->ls_rsbtbl[bucket].lock);
+        spin_unlock(&ls->ls_rsbtbl[bucket].lock);
 }
 
 void dlm_put_rsb(struct dlm_rsb *r)
@@ -744,6 +744,8 @@ static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
 
         DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
 
+        lkb->lkb_timestamp = ktime_get();
+
         lkb->lkb_status = status;
 
         switch (status) {
@@ -965,7 +967,7 @@ static int shrink_bucket(struct dlm_ls *ls, int b)
 
         for (;;) {
                 found = 0;
-                write_lock(&ls->ls_rsbtbl[b].lock);
+                spin_lock(&ls->ls_rsbtbl[b].lock);
                 list_for_each_entry_reverse(r, &ls->ls_rsbtbl[b].toss,
                                             res_hashchain) {
                         if (!time_after_eq(jiffies, r->res_toss_time +
@@ -976,20 +978,20 @@ static int shrink_bucket(struct dlm_ls *ls, int b)
                 }
 
                 if (!found) {
-                        write_unlock(&ls->ls_rsbtbl[b].lock);
+                        spin_unlock(&ls->ls_rsbtbl[b].lock);
                         break;
                 }
 
                 if (kref_put(&r->res_ref, kill_rsb)) {
                         list_del(&r->res_hashchain);
-                        write_unlock(&ls->ls_rsbtbl[b].lock);
+                        spin_unlock(&ls->ls_rsbtbl[b].lock);
 
                         if (is_master(r))
                                 dir_remove(r);
                         dlm_free_rsb(r);
                         count++;
                 } else {
-                        write_unlock(&ls->ls_rsbtbl[b].lock);
+                        spin_unlock(&ls->ls_rsbtbl[b].lock);
                         log_error(ls, "tossed rsb in use %s", r->res_name);
                 }
         }
@@ -1013,10 +1015,8 @@ static void add_timeout(struct dlm_lkb *lkb)
 {
         struct dlm_ls *ls = lkb->lkb_resource->res_ls;
 
-        if (is_master_copy(lkb)) {
-                lkb->lkb_timestamp = jiffies;
+        if (is_master_copy(lkb))
                 return;
-        }
 
         if (test_bit(LSFL_TIMEWARN, &ls->ls_flags) &&
             !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
@@ -1031,7 +1031,6 @@ static void add_timeout(struct dlm_lkb *lkb)
         DLM_ASSERT(list_empty(&lkb->lkb_time_list), dlm_print_lkb(lkb););
         mutex_lock(&ls->ls_timeout_mutex);
         hold_lkb(lkb);
-        lkb->lkb_timestamp = jiffies;
         list_add_tail(&lkb->lkb_time_list, &ls->ls_timeout);
         mutex_unlock(&ls->ls_timeout_mutex);
 }
@@ -1059,6 +1058,7 @@ void dlm_scan_timeout(struct dlm_ls *ls)
         struct dlm_rsb *r;
         struct dlm_lkb *lkb;
         int do_cancel, do_warn;
+        s64 wait_us;
 
         for (;;) {
                 if (dlm_locking_stopped(ls))
@@ -1069,14 +1069,15 @@ void dlm_scan_timeout(struct dlm_ls *ls)
                 mutex_lock(&ls->ls_timeout_mutex);
                 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list) {
 
+                        wait_us = ktime_to_us(ktime_sub(ktime_get(),
+                                                        lkb->lkb_timestamp));
+
                         if ((lkb->lkb_exflags & DLM_LKF_TIMEOUT) &&
-                            time_after_eq(jiffies, lkb->lkb_timestamp +
-                                          lkb->lkb_timeout_cs * HZ/100))
+                            wait_us >= (lkb->lkb_timeout_cs * 10000))
                                 do_cancel = 1;
 
                         if ((lkb->lkb_flags & DLM_IFL_WATCH_TIMEWARN) &&
-                            time_after_eq(jiffies, lkb->lkb_timestamp +
-                                           dlm_config.ci_timewarn_cs * HZ/100))
+                            wait_us >= dlm_config.ci_timewarn_cs * 10000)
                                 do_warn = 1;
 
                         if (!do_cancel && !do_warn)
@@ -1122,12 +1123,12 @@ void dlm_scan_timeout(struct dlm_ls *ls)
 void dlm_adjust_timeouts(struct dlm_ls *ls)
 {
         struct dlm_lkb *lkb;
-        long adj = jiffies - ls->ls_recover_begin;
+        u64 adj_us = jiffies_to_usecs(jiffies - ls->ls_recover_begin);
 
         ls->ls_recover_begin = 0;
         mutex_lock(&ls->ls_timeout_mutex);
         list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list)
-                lkb->lkb_timestamp += adj;
+                lkb->lkb_timestamp = ktime_add_us(lkb->lkb_timestamp, adj_us);
         mutex_unlock(&ls->ls_timeout_mutex);
 }
 
@@ -4223,7 +4224,7 @@ static struct dlm_rsb *find_purged_rsb(struct dlm_ls *ls, int bucket)
 {
         struct dlm_rsb *r, *r_ret = NULL;
 
-        read_lock(&ls->ls_rsbtbl[bucket].lock);
+        spin_lock(&ls->ls_rsbtbl[bucket].lock);
         list_for_each_entry(r, &ls->ls_rsbtbl[bucket].list, res_hashchain) {
                 if (!rsb_flag(r, RSB_LOCKS_PURGED))
                         continue;
@@ -4232,7 +4233,7 @@ static struct dlm_rsb *find_purged_rsb(struct dlm_ls *ls, int bucket)
                 r_ret = r;
                 break;
         }
-        read_unlock(&ls->ls_rsbtbl[bucket].lock);
+        spin_unlock(&ls->ls_rsbtbl[bucket].lock);
         return r_ret;
 }