Compile-time thread-safety checking

index a9604ba3c805..f0746db92ca6 100644
@@ -2915,14 +2915,14 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
 		timeout = 10;
 		break;
 
-	case RESERVE:
+	case RESERVE_6:
 		cmdLen = 6;
 		dir = MPI_SCSIIO_CONTROL_READ;
 		CDB[0] = cmd;
 		timeout = 10;
 		break;
 
-	case RELEASE:
+	case RELEASE_6:
 		cmdLen = 6;
 		dir = MPI_SCSIIO_CONTROL_READ;
 		CDB[0] = cmd;

index abf6a82b74af..0be719f38377 100644
@@ -3221,8 +3221,8 @@ int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
 			break;
 		}
 		fallthrough;
-	case RESERVE:
-	case RELEASE:
+	case RESERVE_6:
+	case RELEASE_6:
 	case REZERO_UNIT:
 	case REASSIGN_BLOCKS:
 	case SEEK_10:

index e50a3dbf9de3..ef21b85cf014 100644
@@ -591,7 +591,7 @@ datadir_t acornscsi_datadirection(int command)
     case CHANGE_DEFINITION:	case COMPARE:		case COPY:
     case COPY_VERIFY:		case LOG_SELECT:	case MODE_SELECT:
     case MODE_SELECT_10:	case SEND_DIAGNOSTIC:	case WRITE_BUFFER:
-    case FORMAT_UNIT:		case REASSIGN_BLOCKS:	case RESERVE:
+    case FORMAT_UNIT:		case REASSIGN_BLOCKS:	case RESERVE_6:
     case SEARCH_EQUAL:		case SEARCH_HIGH:	case SEARCH_LOW:
     case WRITE_6:		case WRITE_10:		case WRITE_VERIFY:
     case UPDATE_BLOCK:		case WRITE_LONG:	case WRITE_SAME:

index cce6c6b409ad..94adb6ac02a4 100644
@@ -3631,8 +3631,8 @@ ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
 
 			break;
 
-		case RESERVE:
-		case RELEASE:
+		case RESERVE_6:
+		case RELEASE_6:
 			scb->scsi_cmd->result = DID_OK << 16;
 			break;
 

@@ -3899,8 +3899,8 @@ ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
 			case WRITE_6:
 			case READ_10:
 			case WRITE_10:
-			case RESERVE:
-			case RELEASE:
+			case RESERVE_6:
+			case RELEASE_6:
 				break;
 
 			case MODE_SENSE:

index adab151663dd..2006094af418 100644
@@ -855,8 +855,8 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
 			return scb;
 
 #if MEGA_HAVE_CLUSTERING
-		case RESERVE:
-		case RELEASE:
+		case RESERVE_6:
+		case RELEASE_6:
 
 			/*
 			 * Do we support clustering and is the support enabled

@@ -875,7 +875,7 @@ mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
 			}
 
 			scb->raw_mbox[0] = MEGA_CLUSTER_CMD;
-			scb->raw_mbox[2] = ( *cmd->cmnd == RESERVE ) ?
+			scb->raw_mbox[2] = *cmd->cmnd == RESERVE_6 ?
 				MEGA_RESERVE_LD : MEGA_RELEASE_LD;
 
 			scb->raw_mbox[3] = ldrv_num;

@@ -1618,8 +1618,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
 			 * failed or the input parameter is invalid
 			 */
 			if( status == 1 &&
-				(cmd->cmnd[0] == RESERVE ||
-					 cmd->cmnd[0] == RELEASE) ) {
+			    (cmd->cmnd[0] == RESERVE_6 ||
+			     cmd->cmnd[0] == RELEASE_6) ) {
 
 				cmd->result |= (DID_ERROR << 16) |
 					SAM_STAT_RESERVATION_CONFLICT;

index 60cc3372991f..3ba837b3093f 100644
@@ -1725,8 +1725,8 @@ megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp, int *busy)
 
 			return scb;
 
-		case RESERVE:
-		case RELEASE:
+		case RESERVE_6:
+		case RELEASE_6:
 			/*
 			 * Do we support clustering and is the support enabled
 			 */

@@ -1748,7 +1748,7 @@ megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp, int *busy)
 			scb->dev_channel	= 0xFF;
 			scb->dev_target		= target;
 			ccb->raw_mbox[0]	= CLUSTER_CMD;
-			ccb->raw_mbox[2]	=  (scp->cmnd[0] == RESERVE) ?
+			ccb->raw_mbox[2]	= scp->cmnd[0] == RESERVE_6 ?
 						RESERVE_LD : RELEASE_LD;
 
 			ccb->raw_mbox[3]	= target;

@@ -2334,8 +2334,8 @@ megaraid_mbox_dpc(unsigned long devp)
 			 * Error code returned is 1 if Reserve or Release
 			 * failed or the input parameter is invalid
 			 */
-			if (status == 1 && (scp->cmnd[0] == RESERVE ||
-					 scp->cmnd[0] == RELEASE)) {
+			if (status == 1 && (scp->cmnd[0] == RESERVE_6 ||
+					    scp->cmnd[0] == RELEASE_6)) {
 
 				scp->result = DID_ERROR << 16 |
 					SAM_STAT_RESERVATION_CONFLICT;

index d1ae3df069a4..cc2da086f96e 100644
@@ -1078,8 +1078,8 @@ passthrough_parse_cdb(struct se_cmd *cmd,
 	if (!dev->dev_attrib.emulate_pr &&
 	    ((cdb[0] == PERSISTENT_RESERVE_IN) ||
 	     (cdb[0] == PERSISTENT_RESERVE_OUT) ||
-	     (cdb[0] == RELEASE || cdb[0] == RELEASE_10) ||
-	     (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) {
+	     (cdb[0] == RELEASE_6 || cdb[0] == RELEASE_10) ||
+	     (cdb[0] == RESERVE_6 || cdb[0] == RESERVE_10))) {
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 

@@ -1101,7 +1101,7 @@ passthrough_parse_cdb(struct se_cmd *cmd,
 			return target_cmd_size_check(cmd, size);
 		}
 
-		if (cdb[0] == RELEASE || cdb[0] == RELEASE_10) {
+		if (cdb[0] == RELEASE_6 || cdb[0] == RELEASE_10) {
 			cmd->execute_cmd = target_scsi2_reservation_release;
 			if (cdb[0] == RELEASE_10)
 				size = get_unaligned_be16(&cdb[7]);

@@ -1109,7 +1109,7 @@ passthrough_parse_cdb(struct se_cmd *cmd,
 				size = cmd->data_length;
 			return target_cmd_size_check(cmd, size);
 		}
-		if (cdb[0] == RESERVE || cdb[0] == RESERVE_10) {
+		if (cdb[0] == RESERVE_6 || cdb[0] == RESERVE_10) {
 			cmd->execute_cmd = target_scsi2_reservation_reserve;
 			if (cdb[0] == RESERVE_10)
 				size = get_unaligned_be16(&cdb[7]);

index 4f4ad6af416c..34cf2c399b39 100644
@@ -91,7 +91,7 @@ target_scsi2_reservation_check(struct se_cmd *cmd)
 
 	switch (cmd->t_task_cdb[0]) {
 	case INQUIRY:
-	case RELEASE:
+	case RELEASE_6:
 	case RELEASE_10:
 		return 0;
 	default:

@@ -418,12 +418,12 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			return -EINVAL;
 		}
 		break;
-	case RELEASE:
+	case RELEASE_6:
 	case RELEASE_10:
 		/* Handled by CRH=1 in target_scsi2_reservation_release() */
 		ret = 0;
 		break;
-	case RESERVE:
+	case RESERVE_6:
 	case RESERVE_10:
 		/* Handled by CRH=1 in target_scsi2_reservation_reserve() */
 		ret = 0;

index ea14a3835681..278ff93eff24 100644
@@ -1674,9 +1674,9 @@ static bool tcm_is_pr_enabled(struct target_opcode_descriptor *descr,
 		return true;
 
 	switch (descr->opcode) {
-	case RESERVE:
+	case RESERVE_6:
 	case RESERVE_10:
-	case RELEASE:
+	case RELEASE_6:
 	case RELEASE_10:
 		/*
 		 * The pr_ops which are used by the backend modules don't

@@ -1828,9 +1828,9 @@ static struct target_opcode_descriptor tcm_opcode_pro_register_move = {
 
 static struct target_opcode_descriptor tcm_opcode_release = {
 	.support = SCSI_SUPPORT_FULL,
-	.opcode = RELEASE,
+	.opcode = RELEASE_6,
 	.cdb_size = 6,
-	.usage_bits = {RELEASE, 0x00, 0x00, 0x00,
+	.usage_bits = {RELEASE_6, 0x00, 0x00, 0x00,
 		       0x00, SCSI_CONTROL_MASK},
 	.enabled = tcm_is_pr_enabled,
 };

@@ -1847,9 +1847,9 @@ static struct target_opcode_descriptor tcm_opcode_release10 = {
 
 static struct target_opcode_descriptor tcm_opcode_reserve = {
 	.support = SCSI_SUPPORT_FULL,
-	.opcode = RESERVE,
+	.opcode = RESERVE_6,
 	.cdb_size = 6,
-	.usage_bits = {RESERVE, 0x00, 0x00, 0x00,
+	.usage_bits = {RESERVE_6, 0x00, 0x00, 0x00,
 		       0x00, SCSI_CONTROL_MASK},
 	.enabled = tcm_is_pr_enabled,
 };

@@ -2267,9 +2267,9 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
 	unsigned char *cdb = cmd->t_task_cdb;
 
 	switch (cdb[0]) {
-	case RESERVE:
+	case RESERVE_6:
 	case RESERVE_10:
-	case RELEASE:
+	case RELEASE_6:
 	case RELEASE_10:
 		if (!dev->dev_attrib.emulate_pr)
 			return TCM_UNSUPPORTED_SCSI_OPCODE;

@@ -2313,7 +2313,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
 		*size = get_unaligned_be32(&cdb[5]);
 		cmd->execute_cmd = target_scsi3_emulate_pr_out;
 		break;
-	case RELEASE:
+	case RELEASE_6:
 	case RELEASE_10:
 		if (cdb[0] == RELEASE_10)
 			*size = get_unaligned_be16(&cdb[7]);

@@ -2322,7 +2322,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
 
 		cmd->execute_cmd = target_scsi2_reservation_release;
 		break;
-	case RESERVE:
+	case RESERVE_6:
 	case RESERVE_10:
 		/*
 		 * The SPC-2 RESERVE does not contain a size in the SCSI CDB.

index 2eae8fc2e0db..94d478b6bcd3 100644
@@ -2142,8 +2142,8 @@ static int do_scsi_command(struct fsg_common *common)
 	 * of Posix locks.
 	 */
 	case FORMAT_UNIT:
-	case RELEASE:
-	case RESERVE:
+	case RELEASE_6:
+	case RESERVE_6:
 	case SEND_DIAGNOSTIC:
 
 	default:

index 576be66ad962..dda610f689b7 100644
@@ -58,8 +58,8 @@ void usb_stor_show_command(const struct us_data *us, struct scsi_cmnd *srb)
 	case INQUIRY: what = "INQUIRY"; break;
 	case RECOVER_BUFFERED_DATA: what = "RECOVER_BUFFERED_DATA"; break;
 	case MODE_SELECT: what = "MODE_SELECT"; break;
-	case RESERVE: what = "RESERVE"; break;
-	case RELEASE: what = "RELEASE"; break;
+	case RESERVE_6: what = "RESERVE"; break;
+	case RELEASE_6: what = "RELEASE"; break;
 	case COPY: what = "COPY"; break;
 	case ERASE: what = "ERASE"; break;
 	case MODE_SENSE: what = "MODE_SENSE"; break;

index 70e1262b2e20..aeca37816506 100644
@@ -33,8 +33,8 @@
 #define INQUIRY               0x12
 #define RECOVER_BUFFERED_DATA 0x14
 #define MODE_SELECT           0x15
-#define RESERVE               0x16
-#define RELEASE               0x17
+#define RESERVE_6             0x16
+#define RELEASE_6             0x17
 #define COPY                  0x18
 #define ERASE                 0x19
 #define MODE_SENSE            0x1a

index 05f1945ed204..bf6cc98d9122 100644
@@ -29,8 +29,8 @@
 		scsi_opcode_name(INQUIRY),			\
 		scsi_opcode_name(RECOVER_BUFFERED_DATA),	\
 		scsi_opcode_name(MODE_SELECT),			\
-		scsi_opcode_name(RESERVE),			\
-		scsi_opcode_name(RELEASE),			\
+		scsi_opcode_name(RESERVE_6),			\
+		scsi_opcode_name(RELEASE_6),			\
 		scsi_opcode_name(COPY),				\
 		scsi_opcode_name(ERASE),			\
 		scsi_opcode_name(MODE_SENSE),			\

index a13cbf2b3405..7e2e20ba26f1 100644
@@ -31,8 +31,8 @@
 		scsi_opcode_name(INQUIRY),			\
 		scsi_opcode_name(RECOVER_BUFFERED_DATA),	\
 		scsi_opcode_name(MODE_SELECT),			\
-		scsi_opcode_name(RESERVE),			\
-		scsi_opcode_name(RELEASE),			\
+		scsi_opcode_name(RESERVE_6),			\
+		scsi_opcode_name(RELEASE_6),			\
 		scsi_opcode_name(COPY),				\
 		scsi_opcode_name(ERASE),			\
 		scsi_opcode_name(MODE_SENSE),			\

index dcc63ff587f9..0e3e7afc200c 100644
@@ -53,7 +53,9 @@
 #define READ_BLOCK_ID		0x22	/* 3420 REJECT,3480 OK */
 #define READ_BUFFER		0x12	/* 3420 REJECT,3480 OK */
 #define READ_BUFF_LOG		0x24	/* 3420 REJECT,3480 OK */
+#if 0
 #define RELEASE			0xD4	/* 3420 NOP, 3480 REJECT */
+#endif
 #define REQ_TRK_IN_ERROR	0x1B	/* 3420 NOP, 3480 REJECT */
 #define RESERVE			0xF4	/* 3420 NOP, 3480 REJECT */
 #define SENSE_GROUP_ID		0x34	/* 3420 REJECT,3480 OK */

new file mode 100644
index 000000000000..e23175223a18
@@ -0,0 +1,141 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _THREAD_SAFETY_H_
+#define _THREAD_SAFETY_H_
+
+/* See also https://clang.llvm.org/docs/ThreadSafetyAnalysis.html */
+
+/*
+ * Enable thread safety attributes only for clang. The attributes can be safely
+ * ignored when compiling with other compilers.
+ */
+#if defined(__clang__)
+#define THREAD_ANNOTATION_ATTRIBUTE_(...) __attribute__((__VA_ARGS__))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE_(...)
+#endif
+
+/*
+ * Macro for applying a capability as an attribute to a type definition.
+ * This macro can be used in struct definitions and also in typedefs.
+ * @x must be a string.
+ */
+#define CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE_(capability(x))
+
+/*
+ * Macro for defining a capability name that is not tied to an existing type.
+ * @capability_name is declared as an external variable. Any attempt to
+ * read or modify that external variable will result in a linker error.
+ */
+#define DEFINE_CAPABILITY(capability_name)	      \
+	extern const struct {} CAPABILITY(#capability_name) capability_name
+
+/*
+ * Attribute for structure members that declares that the structure members are
+ * protected by the given capability.
+ */
+#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE_(guarded_by(x))
+
+/*
+ * Attribute for pointer structure members that declares that the contents
+ * of these pointers are protected by the given capability.
+ */
+#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE_(pt_guarded_by(x))
+
+/*
+ * Attribute for instances of data structures that declares that the given
+ * capabilities must be acquired before the annotated data structure.
+ */
+#define ACQUIRED_BEFORE(...)					\
+	THREAD_ANNOTATION_ATTRIBUTE_(acquired_before(__VA_ARGS__))
+
+/*
+ * Attribute for instances of data structures that declares that the given
+ * capabilities must be acquired after the annotated data structure.
+ */
+#define ACQUIRED_AFTER(...)					\
+	THREAD_ANNOTATION_ATTRIBUTE_(acquired_after(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the caller must have exclusive access
+ * to the given capabilities.
+ */
+#define REQUIRES(...)							\
+	THREAD_ANNOTATION_ATTRIBUTE_(requires_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the caller must have shared access
+ * to the given capabilities.
+ */
+#define REQUIRES_SHARED(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(requires_shared_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the function acquires the given
+ * capability.
+ */
+#define ACQUIRE(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(acquire_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the function acquires the given
+ * shared capability.
+ */
+#define ACQUIRE_SHARED(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(acquire_shared_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the function releases the given
+ * capability.
+ */
+#define RELEASE(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(release_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the function releases the given
+ * shared capability.
+ */
+#define RELEASE_SHARED(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(release_shared_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that a function only acquires the given
+ * capability (2nd argument) for a given return value (first argument).
+ */
+#define TRY_ACQUIRE(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(try_acquire_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that a function only acquires the given
+ * shared capability (2nd argument) for a given return value (first argument).
+ */
+#define TRY_ACQUIRE_SHARED(...)						\
+	THREAD_ANNOTATION_ATTRIBUTE_(try_acquire_shared_capability(__VA_ARGS__))
+
+/*
+ * Function attribute that declares that the caller must not hold the given
+ * capabilities.
+ */
+#define EXCLUDES(...) THREAD_ANNOTATION_ATTRIBUTE_(locks_excluded(__VA_ARGS__))
+
+/*
+ * Tell the compiler that the given capability is held.
+ */
+#define ASSERT_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE_(assert_capability(x))
+
+/*
+ * Tell the compiler that the given shared capability is held.
+ */
+#define ASSERT_SHARED_CAPABILITY(x)				\
+	THREAD_ANNOTATION_ATTRIBUTE_(assert_shared_capability(x))
+
+/*
+ * Function attribute that declares that a function returns a pointer to a
+ * capability.
+ */
+#define RETURN_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE_(lock_returned(x))
+
+/* Function attribute that disables thread-safety analysis. */
+#define NO_THREAD_SAFETY_ANALYSIS				\
+	THREAD_ANNOTATION_ATTRIBUTE_(no_thread_safety_analysis)
+
+#endif /* _THREAD_SAFETY_H_ */

index ec00e3f7af2b..f6a42cac81c6 100644
@@ -3,6 +3,7 @@
 #define _LINUX_CLEANUP_H
 
 #include <linux/compiler.h>
+#include <linux/thread_safety.h>
 
 /**
  * DOC: scope-based cleanup helpers

@@ -195,7 +196,8 @@
  */
 
 #define DEFINE_FREE(_name, _type, _free) \
-	static inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }
+	static inline void __free_##_name(void *p) NO_THREAD_SAFETY_ANALYSIS \
+	{ _type _T = *(_type *)p; _free; }
 
 #define __free(_name)	__cleanup(__free_##_name)
 

@@ -241,17 +243,25 @@ const volatile void * __must_check_fn(const volatile void *val)
  */
 
 #define DEFINE_CLASS(_name, _type, _exit, _init, _init_args...)		\
+	DEFINE_CLASS_ATTR(_name, _type, _exit,				\
+			  _init, NO_THREAD_SAFETY_ANALYSIS, _init_args)
+
+#define DEFINE_CLASS_ATTR(_name, _type, _exit, _init, _init_attr,	\
+			  _init_args...)				\
 typedef _type class_##_name##_t;					\
 static inline void class_##_name##_destructor(_type *p)			\
+	NO_THREAD_SAFETY_ANALYSIS					\
 { _type _T = *p; _exit; }						\
-static inline _type class_##_name##_constructor(_init_args)		\
+static inline _type class_##_name##_constructor(_init_args) _init_attr	\
 { _type t = _init; return t; }
 
-#define EXTEND_CLASS(_name, ext, _init, _init_args...)			\
+#define EXTEND_CLASS(_name, ext, _init, _init_attr, _init_args...)	\
 typedef class_##_name##_t class_##_name##ext##_t;			\
 static inline void class_##_name##ext##_destructor(class_##_name##_t *p)\
+	NO_THREAD_SAFETY_ANALYSIS					\
 { class_##_name##_destructor(p); }					\
 static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \
+	_init_attr							\
 { class_##_name##_t t = _init; return t; }
 
 #define CLASS(_name, var)						\

@@ -291,17 +301,25 @@ static inline class_##_name##_t class_##_name##ext##_constructor(_init_args) \
 #define __DEFINE_CLASS_IS_CONDITIONAL(_name, _is_cond)	\
 static __maybe_unused const bool class_##_name##_is_conditional = _is_cond
 
-#define DEFINE_GUARD(_name, _type, _lock, _unlock) \
-	__DEFINE_CLASS_IS_CONDITIONAL(_name, false); \
-	DEFINE_CLASS(_name, _type, if (_T) { _unlock; }, ({ _lock; _T; }), _type _T); \
+#define DEFINE_GUARD(_name, _type, _lock, _unlock)			\
+	DEFINE_GUARD_ATTR(_name, _type, _lock, NO_THREAD_SAFETY_ANALYSIS,\
+			  _unlock)
+
+#define DEFINE_GUARD_ATTR(_name, _type, _lock, _lock_attr, _unlock)	\
+	__DEFINE_CLASS_IS_CONDITIONAL(_name, false);			\
+	DEFINE_CLASS_ATTR(_name, _type, if (_T) { _unlock; },		\
+		     ({ _lock; _T; }), _lock_attr, _type _T);		\
 	static inline void * class_##_name##_lock_ptr(class_##_name##_t *_T) \
 	{ return (void *)(__force unsigned long)*_T; }
 
 #define DEFINE_GUARD_COND(_name, _ext, _condlock) \
+	DEFINE_GUARD_COND_ATTR(_name, _ext, _condlock, )
+
+#define DEFINE_GUARD_COND_ATTR(_name, _ext, _condlock, _condlock_attr)	  \
 	__DEFINE_CLASS_IS_CONDITIONAL(_name##_ext, true); \
 	EXTEND_CLASS(_name, _ext, \
 		     ({ void *_t = _T; if (_T && !(_condlock)) _t = NULL; _t; }), \
-		     class_##_name##_t _T) \
+		     _condlock_attr, class_##_name##_t _T)		\
 	static inline void * class_##_name##_ext##_lock_ptr(class_##_name##_t *_T) \
 	{ return class_##_name##_lock_ptr(_T); }
 

@@ -413,7 +431,7 @@ __DEFINE_LOCK_GUARD_0(_name, _lock)
 	EXTEND_CLASS(_name, _ext,					\
 		     ({ class_##_name##_t _t = { .lock = l }, *_T = &_t;\
 		        if (_T->lock && !(_condlock)) _T->lock = NULL;	\
-			_t; }),						\
+			_t; }),	,					\
 		     typeof_member(class_##_name##_t, lock) l)		\
 	static inline void * class_##_name##_ext##_lock_ptr(class_##_name##_t *_T) \
 	{ return class_##_name##_lock_ptr(_T); }

index 2bf91b57591b..6c0a8a843a29 100644
@@ -196,7 +196,7 @@ extern void mutex_lock_io(struct mutex *lock);
 extern int mutex_trylock(struct mutex *lock);
 extern void mutex_unlock(struct mutex *lock);
 
-extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
+bool atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 
 DEFINE_GUARD(mutex, struct mutex *, mutex_lock(_T), mutex_unlock(_T))
 DEFINE_GUARD_COND(mutex, _try, mutex_trylock(_T))

index b36f23de48f1..0af175f5f031 100644
@@ -1118,19 +1118,19 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(contention_end);
  *
  * return true and hold lock if we dec to 0, return false otherwise
  */
-int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
+bool atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
 {
 	/* dec if we can't possibly hit 0 */
 	if (atomic_add_unless(cnt, -1, 1))
-		return 0;
+		return false;
 	/* we might hit 0, so take the lock */
 	mutex_lock(lock);
 	if (!atomic_dec_and_test(cnt)) {
 		/* when we actually did the dec, we didn't hit 0 */
 		mutex_unlock(lock);
-		return 0;
+		return false;
 	}
 	/* we hit 0, and we hold the lock */
-	return 1;
+	return true;
 }
 EXPORT_SYMBOL(atomic_dec_and_mutex_lock);

index 6c0a8a843a29..b7669baeffe9 100644
@@ -21,6 +21,7 @@
 #include <linux/debug_locks.h>
 #include <linux/cleanup.h>
 #include <linux/mutex_types.h>
+#include <linux/thread_safety.h>
 
 struct device;
 

@@ -154,14 +155,18 @@ static inline int __devm_mutex_init(struct device *dev, struct mutex *lock)
  * Also see Documentation/locking/mutex-design.rst.
  */
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
-extern void _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock);
+void mutex_lock_nested(struct mutex *lock, unsigned int subclass) ACQUIRE(*lock);
+void _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock)
+	ACQUIRE(*lock);
 
 extern int __must_check mutex_lock_interruptible_nested(struct mutex *lock,
-					unsigned int subclass);
+					unsigned int subclass)
+	TRY_ACQUIRE(0, *lock);
 extern int __must_check mutex_lock_killable_nested(struct mutex *lock,
-					unsigned int subclass);
-extern void mutex_lock_io_nested(struct mutex *lock, unsigned int subclass);
+					unsigned int subclass)
+	TRY_ACQUIRE(0, *lock);
+extern void mutex_lock_io_nested(struct mutex *lock, unsigned int subclass)
+	ACQUIRE(*lock);
 
 #define mutex_lock(lock) mutex_lock_nested(lock, 0)
 #define mutex_lock_interruptible(lock) mutex_lock_interruptible_nested(lock, 0)

@@ -175,10 +180,11 @@ do {									\
 } while (0)
 
 #else
-extern void mutex_lock(struct mutex *lock);
-extern int __must_check mutex_lock_interruptible(struct mutex *lock);
-extern int __must_check mutex_lock_killable(struct mutex *lock);
-extern void mutex_lock_io(struct mutex *lock);
+void mutex_lock(struct mutex *lock) ACQUIRE(*lock);
+int __must_check mutex_lock_interruptible(struct mutex *lock)
+	TRY_ACQUIRE(0, *lock);
+int __must_check mutex_lock_killable(struct mutex *lock) TRY_ACQUIRE(0, *lock);
+void mutex_lock_io(struct mutex *lock) ACQUIRE(*lock);
 
 # define mutex_lock_nested(lock, subclass) mutex_lock(lock)
 # define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)

@@ -193,13 +199,19 @@ extern void mutex_lock_io(struct mutex *lock);
  *
  * Returns 1 if the mutex has been acquired successfully, and 0 on contention.
  */
-extern int mutex_trylock(struct mutex *lock);
-extern void mutex_unlock(struct mutex *lock);
-
-bool atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
-
-DEFINE_GUARD(mutex, struct mutex *, mutex_lock(_T), mutex_unlock(_T))
-DEFINE_GUARD_COND(mutex, _try, mutex_trylock(_T))
-DEFINE_GUARD_COND(mutex, _intr, mutex_lock_interruptible(_T) == 0)
+int mutex_trylock(struct mutex *lock) TRY_ACQUIRE(1, *lock);
+void mutex_unlock(struct mutex *lock) RELEASE(*lock);
+
+bool atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
+	TRY_ACQUIRE(true, *lock);
+
+DEFINE_GUARD_ATTR(mutex, struct mutex *,
+		  mutex_lock(_T),
+		  ASSERT_CAPABILITY(*_T) NO_THREAD_SAFETY_ANALYSIS,
+		  mutex_unlock(_T))
+DEFINE_GUARD_COND_ATTR(mutex, _try, mutex_trylock(_T),
+		       ASSERT_CAPABILITY(*_T) NO_THREAD_SAFETY_ANALYSIS)
+DEFINE_GUARD_COND_ATTR(mutex, _intr, mutex_lock_interruptible(_T) == 0,
+		       ASSERT_CAPABILITY(*_T) NO_THREAD_SAFETY_ANALYSIS)
 
 #endif /* __LINUX_MUTEX_H */

index fdf7f515fde8..59469956426a 100644
@@ -6,6 +6,7 @@
 #include <linux/lockdep_types.h>
 #include <linux/osq_lock.h>
 #include <linux/spinlock_types.h>
+#include <linux/thread_safety.h>
 #include <linux/types.h>
 
 #ifndef CONFIG_PREEMPT_RT

@@ -38,7 +39,7 @@
  * - detects multi-task circular deadlocks and prints out all affected
  *   locks and tasks (and only those tasks)
  */
-struct mutex {
+struct CAPABILITY("mutex") mutex {
 	atomic_long_t		owner;
 	raw_spinlock_t		wait_lock;
 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER

@@ -59,7 +60,7 @@ struct mutex {
  */
 #include <linux/rtmutex.h>
 
-struct mutex {
+struct CAPABILITY("mutex") mutex {
 	struct rt_mutex_base	rtmutex;
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 	struct lockdep_map	dep_map;

index 0af175f5f031..e44becde2610 100644
@@ -254,6 +254,7 @@ static void __sched __mutex_lock_slowpath(struct mutex *lock);
  * This function is similar to (but not equivalent to) down().
  */
 void __sched mutex_lock(struct mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	might_sleep();
 

@@ -515,6 +516,7 @@ static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigne
  * This function is similar to (but not equivalent to) up().
  */
 void __sched mutex_unlock(struct mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 #ifndef CONFIG_DEBUG_LOCK_ALLOC
 	if (__mutex_unlock_fast(lock))

@@ -536,6 +538,7 @@ EXPORT_SYMBOL(mutex_unlock);
  * of a unlocked mutex is not allowed.
  */
 void __sched ww_mutex_unlock(struct ww_mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	__ww_mutex_unlock(lock);
 	mutex_unlock(&lock->base);

@@ -751,6 +754,7 @@ __ww_mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,
  * A mutex acquired with this function must be released with ww_mutex_unlock.
  */
 int ww_mutex_trylock(struct ww_mutex *ww, struct ww_acquire_ctx *ww_ctx)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	if (!ww_ctx)
 		return mutex_trylock(&ww->base);

@@ -778,6 +782,7 @@ EXPORT_SYMBOL(ww_mutex_trylock);
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 void __sched
 mutex_lock_nested(struct mutex *lock, unsigned int subclass)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	__mutex_lock(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);
 }

@@ -786,6 +791,7 @@ EXPORT_SYMBOL_GPL(mutex_lock_nested);
 
 void __sched
 _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	__mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, nest, _RET_IP_);
 }

@@ -807,6 +813,7 @@ EXPORT_SYMBOL_GPL(mutex_lock_interruptible_nested);
 
 void __sched
 mutex_lock_io_nested(struct mutex *lock, unsigned int subclass)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	int token;
 

@@ -957,6 +964,7 @@ __mutex_lock_interruptible_slowpath(struct mutex *lock);
  * signal arrived.
  */
 int __sched mutex_lock_interruptible(struct mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	might_sleep();
 

@@ -981,6 +989,7 @@ EXPORT_SYMBOL(mutex_lock_interruptible);
  * fatal signal arrived.
  */
 int __sched mutex_lock_killable(struct mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	might_sleep();
 

@@ -1061,6 +1070,7 @@ __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,
  * mutex must be released by the same task that acquired it.
  */
 int __sched mutex_trylock(struct mutex *lock)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	bool locked;
 

@@ -1077,6 +1087,7 @@ EXPORT_SYMBOL(mutex_trylock);
 #ifndef CONFIG_DEBUG_LOCK_ALLOC
 int __sched
 ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	might_sleep();
 

@@ -1092,6 +1103,7 @@ EXPORT_SYMBOL(ww_mutex_lock);
 
 int __sched
 ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	might_sleep();
 

index 80a5b3268986..125b89fda3af 100644
@@ -31,6 +31,7 @@
 #include <linux/device/class.h>
 #include <linux/device/driver.h>
 #include <linux/cleanup.h>
+#include <linux/thread_safety.h>
 #include <asm/device.h>
 
 struct device;

@@ -1026,21 +1027,25 @@ static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
 }
 
 static inline void device_lock(struct device *dev)
+	ACQUIRE(dev->mutex)
 {
 	mutex_lock(&dev->mutex);
 }
 
 static inline int device_lock_interruptible(struct device *dev)
+	TRY_ACQUIRE(0, dev->mutex)
 {
 	return mutex_lock_interruptible(&dev->mutex);
 }
 
 static inline int device_trylock(struct device *dev)
+	TRY_ACQUIRE(1, dev->mutex)
 {
 	return mutex_trylock(&dev->mutex);
 }
 
 static inline void device_unlock(struct device *dev)
+	RELEASE(dev->mutex)
 {
 	mutex_unlock(&dev->mutex);
 }

@@ -1182,9 +1187,11 @@ do { \
 				  _THIS_IP_);                          \
 } while (0)
 
-void lock_device_hotplug(void);
-void unlock_device_hotplug(void);
-int lock_device_hotplug_sysfs(void);
+DEFINE_CAPABILITY(device_hotplug_capability);
+
+void lock_device_hotplug(void) ACQUIRE(device_hotplug_capability);
+void unlock_device_hotplug(void) RELEASE(device_hotplug_capability);
+int lock_device_hotplug_sysfs(void) TRY_ACQUIRE(0, device_hotplug_capability);
 int device_offline(struct device *dev);
 int device_online(struct device *dev);
 

index 88e82ab1367c..29c31b103557 100644
@@ -15,6 +15,7 @@
 
 #include <linux/spinlock.h>
 #include <linux/refcount.h>
+#include <linux/thread_safety.h>
 
 struct kref {
 	refcount_t refcount;

@@ -81,6 +82,8 @@ static inline int kref_put(struct kref *kref, void (*release)(struct kref *kref)
 static inline int kref_put_mutex(struct kref *kref,
 				 void (*release)(struct kref *kref),
 				 struct mutex *mutex)
+	EXCLUDES(*mutex)
+	NO_THREAD_SAFETY_ANALYSIS
 {
 	if (refcount_dec_and_mutex_lock(&kref->refcount, mutex)) {
 		release(kref);

index 35f039ecb272..dd854ad27df8 100644
@@ -98,6 +98,7 @@
 #include <linux/limits.h>
 #include <linux/refcount_types.h>
 #include <linux/spinlock_types.h>
+#include <linux/thread_safety.h>
 
 struct mutex;
 

@@ -353,7 +354,9 @@ static inline void refcount_dec(refcount_t *r)
 
 extern __must_check bool refcount_dec_if_one(refcount_t *r);
 extern __must_check bool refcount_dec_not_one(refcount_t *r);
-extern __must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock) __cond_acquires(lock);
+__must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock)
+	__cond_acquires(lock)
+	TRY_ACQUIRE(true, *lock);
 extern __must_check bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock) __cond_acquires(lock);
 extern __must_check bool refcount_dec_and_lock_irqsave(refcount_t *r,
 						       spinlock_t *lock,

index 6f3dda6b635f..5ae07367955f 100644
@@ -191,7 +191,7 @@ static int mlxbf2_gpio_direction_input(struct gpio_chip *chip,
 	 * if it is still enabled to be able to write to the ModeX registers.
 	 */
 	ret = mlxbf2_gpio_lock_acquire(gs);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	writel(BIT(offset), gs->gpio_io + YU_GPIO_MODE0_CLEAR);

@@ -219,7 +219,7 @@ static int mlxbf2_gpio_direction_output(struct gpio_chip *chip,
 	 * ModeX registers.
 	 */
 	ret = mlxbf2_gpio_lock_acquire(gs);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	writel(BIT(offset), gs->gpio_io + YU_GPIO_MODE1_CLEAR);

index e5e93a20723c..26387286a5c6 100644
@@ -198,7 +198,7 @@ static int rog_ryujin_get_status(struct rog_ryujin_data *priv)
 {
 	int ret = mutex_lock_interruptible(&priv->status_report_request_mutex);
 
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (!time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {

@@ -304,7 +304,7 @@ static int rog_ryujin_write_fixed_duty(struct rog_ryujin_data *priv, int channel
 		 * together, then write back with one of them modified.
 		 */
 		ret = mutex_lock_interruptible(&priv->status_report_request_mutex);
-		if (ret < 0)
+		if (ret)
 			return ret;
 		ret =
 		    rog_ryujin_execute_cmd(priv, get_cooler_duty_cmd, GET_CMD_LENGTH,

index 27487e215bdd..43c3b300e11f 100644
@@ -125,7 +125,7 @@ static int waterforce_get_status(struct waterforce_data *priv)
 {
 	int ret = mutex_lock_interruptible(&priv->status_report_request_mutex);
 
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (!time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {

index d00409bcab93..9a3be62fef62 100644
@@ -251,7 +251,7 @@ static int kraken3_read_z53(struct kraken3_data *priv)
 {
 	int ret = mutex_lock_interruptible(&priv->z53_status_request_lock);
 
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (!time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {

index 1378651735f6..cf84e7423bb6 100644
@@ -3731,7 +3731,7 @@ static ssize_t add_target_store(struct device *dev,
 	scsi_host_get(target->scsi_host);
 
 	ret = mutex_lock_interruptible(&host->add_target_mutex);
-	if (ret < 0)
+	if (ret)
 		goto put;
 
 	ret = srp_parse_options(target->net, buf, target);

index 5dfb4644446b..0557617daa75 100644
@@ -3647,10 +3647,10 @@ static ssize_t srpt_tpg_attrib_use_srq_store(struct config_item *item,
 		return -EINVAL;
 
 	ret = mutex_lock_interruptible(&sdev->sdev_mutex);
-	if (ret < 0)
+	if (ret)
 		return ret;
 	ret = mutex_lock_interruptible(&sport->mutex);
-	if (ret < 0)
+	if (ret)
 		goto unlock_sdev;
 	enabled = sport->enabled;
 	/* Log out all initiator systems before changing 'use_srq'. */

index 577497b9d426..79552b41f2c1 100644
@@ -357,7 +357,7 @@ static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
 
 	/* We start hardware transfers which are not to be
 	 * mixed with other commands. Aquire a lock now. */
-	if (mutex_lock_interruptible(&data->update_lock) < 0)
+	if (mutex_lock_interruptible(&data->update_lock))
 		return -EAGAIN;
 
 	/* switch cmd - usually write before reads */

index d935fb10e620..f9f853e2ef80 100644
@@ -225,7 +225,7 @@ static int bcm3510_do_hab_cmd(struct bcm3510_state *st, u8 cmd, u8 msgid, u8 *ob
 	dbufout(ob,olen+2,deb_hab);
 	deb_hab("\n");
 
-	if (mutex_lock_interruptible(&st->hab_mutex) < 0)
+	if (mutex_lock_interruptible(&st->hab_mutex))
 		return -EAGAIN;
 
 	if ((ret = bcm3510_hab_send_request(st, ob, olen+2)) < 0 ||

index 9a8e7cdd2a24..ddbea15d69bb 100644
@@ -70,7 +70,7 @@ static u16 dib0070_read_reg(struct dib0070_state *state, u8 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -102,7 +102,7 @@ static int dib0070_write_reg(struct dib0070_state *state, u8 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

index 6cbbb351d545..de9bbdec07ab 100644
@@ -201,7 +201,7 @@ static u16 dib0090_read_reg(struct dib0090_state *state, u8 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -233,7 +233,7 @@ static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

@@ -262,7 +262,7 @@ static u16 dib0090_fw_read_reg(struct dib0090_fw_state *state, u8 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -289,7 +289,7 @@ static int dib0090_fw_write_reg(struct dib0090_fw_state *state, u8 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

index fdb22f32e3a1..b5cab2df9478 100644
@@ -77,7 +77,7 @@ static u16 dib7000m_read_word(struct dib7000m_state *state, u16 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -108,7 +108,7 @@ static int dib7000m_write_word(struct dib7000m_state *state, u16 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

index c5582d4fa5be..28c224a450cb 100644
@@ -96,7 +96,7 @@ static u16 dib7000p_read_word(struct dib7000p_state *state, u16 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -126,7 +126,7 @@ static int dib7000p_write_word(struct dib7000p_state *state, u16 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

index 2f5165918163..cae8686042a8 100644
@@ -150,7 +150,7 @@ static u16 dib8000_i2c_read16(struct i2c_device *i2c, u16 reg)
 		{.addr = i2c->addr >> 1, .flags = I2C_M_RD, .len = 2},
 	};
 
-	if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(i2c->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -197,7 +197,7 @@ static u16 dib8000_read_word(struct dib8000_state *state, u16 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -213,7 +213,7 @@ static u32 dib8000_read32(struct dib8000_state *state, u16 reg)
 {
 	u16 rw[2];
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -231,7 +231,7 @@ static int dib8000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
 	struct i2c_msg msg = {.addr = i2c->addr >> 1, .flags = 0, .len = 4};
 	int ret = 0;
 
-	if (mutex_lock_interruptible(i2c->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(i2c->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

@@ -252,7 +252,7 @@ static int dib8000_write_word(struct dib8000_state *state, u16 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&state->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

162 lines not on this page · raw message

index 63a4c6a4afb5..1db6a1dbeb01 100644
@@ -21,7 +21,7 @@ static int dibx000_write_word(struct dibx000_i2c_master *mst, u16 reg, u16 val)
 {
 	int ret;
 
-	if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&mst->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

@@ -47,7 +47,7 @@ static u16 dibx000_read_word(struct dibx000_i2c_master *mst, u16 reg)
 {
 	u16 ret;
 
-	if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&mst->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return 0;
 	}

@@ -296,7 +296,7 @@ static int dibx000_i2c_gated_gpio67_xfer(struct i2c_adapter *i2c_adap,
 
 	dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_GPIO_6_7);
 
-	if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&mst->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

@@ -343,7 +343,7 @@ static int dibx000_i2c_gated_tuner_xfer(struct i2c_adapter *i2c_adap,
 
 	dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);
 
-	if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&mst->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

@@ -440,7 +440,7 @@ int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev,
 	int ret;
 
 	mutex_init(&mst->i2c_buffer_lock);
-	if (mutex_lock_interruptible(&mst->i2c_buffer_lock) < 0) {
+	if (mutex_lock_interruptible(&mst->i2c_buffer_lock)) {
 		dprintk("could not acquire lock\n");
 		return -EINVAL;
 	}

index 218f712f56b1..b873e39dbbbe 100644
@@ -271,7 +271,7 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
 	struct state *state = d_to_priv(d);
 	int ret;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	/*

index bea12cdc85e8..a5b2832f0a24 100644
@@ -188,7 +188,7 @@ static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
 	int ret = 0, inc, i = 0;
 	u8 buf[52]; /* 4 + 48 (I2C WR USB command header + I2C WR max) */
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	while (i < num) {

index be223fc8aa14..016f37c0bb70 100644
@@ -89,7 +89,7 @@ static int au6610_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	if (num > 2)
 		return -EINVAL;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 2410054ddb2c..24eb74f521e5 100644
@@ -128,7 +128,7 @@ static int az6007_read(struct dvb_usb_device *d, u8 req, u16 value,
 	struct az6007_device_state *st = d->priv;
 	int ret;
 
-	if (mutex_lock_interruptible(&st->mutex) < 0)
+	if (mutex_lock_interruptible(&st->mutex))
 		return -EAGAIN;
 
 	ret = __az6007_read(d->udev, req, value, index, b, blen);

@@ -175,7 +175,7 @@ static int az6007_write(struct dvb_usb_device *d, u8 req, u16 value,
 	struct az6007_device_state *st = d->priv;
 	int ret;
 
-	if (mutex_lock_interruptible(&st->mutex) < 0)
+	if (mutex_lock_interruptible(&st->mutex))
 		return -EAGAIN;
 
 	ret = __az6007_write(d->udev, req, value, index, b, blen);

@@ -752,7 +752,7 @@ static int az6007_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
 	int length;
 	u8 req, addr;
 
-	if (mutex_lock_interruptible(&st->mutex) < 0)
+	if (mutex_lock_interruptible(&st->mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index d3b5cb4a24da..615c6b9f4b75 100644
@@ -94,7 +94,7 @@ static int ce6230_i2c_master_xfer(struct i2c_adapter *adap,
 
 	memset(&req, 0, sizeof(req));
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	while (i < num) {

index 1221c924312a..bfe05efdd1e8 100644
@@ -103,7 +103,7 @@ static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	int ret = 0;
 	u8 ibuf[64], obuf[64];
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	if (num > 2) {

index 0e4773fc025c..5cbafdc8e0aa 100644
@@ -109,7 +109,7 @@ static int ec168_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	if (num > 2)
 		return -EINVAL;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	while (i < num) {

index f0537b741d13..2a7db30a50c6 100644
@@ -147,7 +147,7 @@ static int lme2510_usb_talk(struct dvb_usb_device *d,
 		return -EINVAL;
 
 	ret = mutex_lock_interruptible(&d->usb_mutex);
-	if (ret < 0)
+	if (ret)
 		return -EAGAIN;
 
 	memcpy(st->usb_buffer, wbuf, wlen);

index 100a1052dcbc..2804c6dc27c1 100644
@@ -804,7 +804,7 @@ int mxl111sf_i2c_xfer(struct i2c_adapter *adap,
 	int hwi2c = (state->chip_rev > MXL111SF_V6);
 	int i, ret;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index f7884bb56fcc..1bb5453bcbd7 100644
@@ -166,7 +166,7 @@ static int rtl28xxu_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	 * where write is more than one byte.
 	 */
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	if (num == 2 && !(msg[0].flags & I2C_M_RD) &&

index 13604e6acdb8..69fd71e0f7bd 100644
@@ -407,7 +407,7 @@ static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	u8 reg, addr;
 	u8 *value;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	if (num > 2)

index 2bc27710427d..4bef1850b598 100644
@@ -962,7 +962,7 @@ static int az6027_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int n
 	if (!data)
 		return -ENOMEM;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->i2c_mutex)) {
 		kfree(data);
 		return -EAGAIN;
 	}

index 1d98d3465e28..23f7931ccd95 100644
@@ -183,7 +183,7 @@ static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	int ret;
 	int i;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 1caabb51ea47..38fae706a7ff 100644
@@ -24,7 +24,7 @@ int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
 	struct dib0700_state *st = d->priv;
 	int ret;
 
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		return -EINTR;
 	}

@@ -110,7 +110,7 @@ int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_
 	struct dib0700_state *st = d->priv;
 	int ret;
 
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		return -EINTR;
 	}

@@ -131,7 +131,7 @@ static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
 	int ret;
 
 	if (st->fw_version >= 0x10201) {
-		if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+		if (mutex_lock_interruptible(&d->usb_mutex)) {
 			err("could not acquire lock");
 			return -EINTR;
 		}

@@ -171,7 +171,7 @@ static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
 
 	/* Ensure nobody else hits the i2c bus while we're sending our
 	   sequence of messages, (such as the remote control thread) */
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EINTR;
 
 	for (i = 0; i < num; i++) {

@@ -229,7 +229,7 @@ static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
 
 		} else {
 			/* Write request */
-			if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+			if (mutex_lock_interruptible(&d->usb_mutex)) {
 				err("could not acquire lock");
 				result = -EINTR;
 				goto unlock;

@@ -286,9 +286,9 @@ static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
 	struct dib0700_state *st = d->priv;
 	int i, len, result;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EINTR;
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		mutex_unlock(&d->i2c_mutex);
 		return -EINTR;

@@ -404,7 +404,7 @@ static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll,
 	struct dib0700_state *st = d->priv;
 	int ret;
 
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		return -EINTR;
 	}

@@ -436,7 +436,7 @@ int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
 	if (scl_kHz == 0)
 		return -EINVAL;
 
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		return -EINTR;
 	}

@@ -641,7 +641,7 @@ int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto)
 	struct dib0700_state *st = d->priv;
 	int new_proto, ret;
 
-	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->usb_mutex)) {
 		err("could not acquire lock");
 		return -EINTR;
 	}

index 20f1ef3393a5..6b7de78d0d71 100644
@@ -181,7 +181,7 @@ static int dibusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
 	struct dvb_usb_device *d = i2c_get_adapdata(adap);
 	int i;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 32134be16914..8ea758176fda 100644
@@ -56,7 +56,7 @@ static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
 	struct dvb_usb_device *d = i2c_get_adapdata(adap);
 	int i;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	if (num > 2)

index 56c9d521a34a..dace8196fb61 100644
@@ -72,7 +72,7 @@ static int dtv5100_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	if (num > 2)
 		return -EINVAL;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 2aabf90d8697..6a35a218d4de 100644
@@ -22,7 +22,8 @@ int dvb_usb_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
 		return -EINVAL;
 	}
 
-	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+	ret = mutex_lock_interruptible(&d->usb_mutex);
+	if (ret)
 		return ret;
 
 	deb_xfer(">>> ");

index 79e2ccf974c9..fea99192c627 100644
@@ -121,7 +121,7 @@ static int dw2102_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	switch (num) {

@@ -216,7 +216,7 @@ static int dw2102_serit_i2c_transfer(struct i2c_adapter *adap,
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	switch (num) {

@@ -291,7 +291,7 @@ static int dw2102_earda_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg ms
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	switch (num) {

@@ -399,7 +399,7 @@ static int dw2104_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], i
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (j = 0; j < num; j++) {

@@ -501,7 +501,7 @@ static int dw3101_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	switch (num) {

@@ -589,7 +589,7 @@ static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 	if (!d)
 		return -ENODEV;
 	udev = d->udev;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (j = 0; j < num; j++) {

@@ -726,9 +726,9 @@ static int su3000_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 
 	state = d->priv;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
-	if (mutex_lock_interruptible(&d->data_mutex) < 0) {
+	if (mutex_lock_interruptible(&d->data_mutex)) {
 		mutex_unlock(&d->i2c_mutex);
 		return -EAGAIN;
 	}

index 4cd21bb8805e..c0d617536127 100644
@@ -35,7 +35,8 @@ static int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value,
 	if (blen > sizeof(st->data))
 		return -EIO;
 
-	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+	ret = mutex_lock_interruptible(&d->usb_mutex);
+	if (ret)
 		return ret;
 
 	while (ret >= 0 && ret != blen && try < 3) {

@@ -77,7 +78,8 @@ static int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
 	if (blen > sizeof(st->data))
 		return -EIO;
 
-	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+	ret = mutex_lock_interruptible(&d->usb_mutex);
+	if (ret)
 		return ret;
 
 	memcpy(st->data, b, blen);

index a2054b1b100f..0536d3d7152a 100644
@@ -252,7 +252,7 @@ static int m920x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int nu
 	int i, j;
 	int ret = 0;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 268f05fc8691..075c1153e2ab 100644
@@ -92,7 +92,7 @@ static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
 		info("no usb_device");
 		return -EINVAL;
 	}
-	if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
+	if (mutex_lock_interruptible(&dev->usb_mutex))
 		return -EAGAIN;
 
 	switch (addr>>1){

@@ -132,7 +132,7 @@ static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 
 	if (!d)
 		return -ENODEV;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

index 2aab49003493..71e4503968a8 100644
@@ -478,7 +478,7 @@ static int pctv452e_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msg,
 	struct dvb_usb_device *d = i2c_get_adapdata(adapter);
 	int i;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

@@ -623,7 +623,7 @@ static int pctv452e_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
 	int ret;
 
 	ret = -EAGAIN;
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		goto failed;
 
 	ret = pctv452e_i2c_msg(d, I2C_ADDR_24C16,

index df90c6c5f3b9..265059be66e1 100644
@@ -166,7 +166,7 @@ static int technisat_usb2_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg
 
 	/* Ensure nobody else hits the i2c bus while we're sending our
 	   sequence of messages, (such as the remote control thread) */
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	for (i = 0; i < num; i++) {

@@ -259,7 +259,7 @@ static int technisat_usb2_set_led(struct dvb_usb_device *d, int red,
 		break;
 	}
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),

@@ -280,7 +280,7 @@ static int technisat_usb2_set_led_timer(struct dvb_usb_device *d, u8 red, u8 gre
 
 	b[0] = 0;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),

@@ -550,7 +550,7 @@ static int technisat_usb2_frontend_attach(struct dvb_usb_adapter *a)
 			if (a->fe_adap[0].fe->ops.init)
 				a->fe_adap[0].fe->ops.init(a->fe_adap[0].fe);
 
-			if (mutex_lock_interruptible(&a->dev->i2c_mutex) < 0)
+			if (mutex_lock_interruptible(&a->dev->i2c_mutex))
 				return -EAGAIN;
 
 			ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),

@@ -618,7 +618,7 @@ static int technisat_usb2_get_ir(struct dvb_usb_device *d)
 	buf[3] = MINIMUM_IR_BIT_TRANSITION_TICK_COUNT;
 	buf[4] = MAXIMUM_IR_BIT_TIME_TICK_COUNT;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 	ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
 			GET_IR_DATA_VENDOR_REQUEST,

index 373ffa7f641e..3e0e4917f6a3 100644
@@ -371,7 +371,7 @@ static int ttusb2_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
 	static u8 obuf[60], ibuf[60];
 	int i, write_read, read;
 
-	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+	if (mutex_lock_interruptible(&d->i2c_mutex))
 		return -EAGAIN;
 
 	if (num > 2)

index 5b6740cbd1d1..3c513c3ac578 100644
@@ -99,7 +99,8 @@ int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int il
 {
 	int ret;
 
-	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
+	ret = mutex_lock_interruptible(&d->usb_mutex);
+	if (ret)
 		return ret;
 
 	ret = vp702x_usb_out_op_unlocked(d, REQUEST_OUT, 0, 0, o, olen);

@@ -119,7 +120,7 @@ static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o,
 	int buflen = max(olen + 2, ilen + 1);
 
 	ret = mutex_lock_interruptible(&st->buf_mutex);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (buflen > st->buf_len) {

index 9e016b71aa91..7a25e823f1f5 100644
@@ -143,7 +143,7 @@ static int ttusb_cmd(struct ttusb *ttusb, u8 *data, int len, int len_result)
 	int actual_len;
 	int err;
 
-	if (mutex_lock_interruptible(&ttusb->semusb) < 0)
+	if (mutex_lock_interruptible(&ttusb->semusb))
 		return -EAGAIN;
 
 	if (debug >= 3)

@@ -236,7 +236,7 @@ static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num
 	int i = 0;
 	int inc;
 
-	if (mutex_lock_interruptible(&ttusb->semi2c) < 0)
+	if (mutex_lock_interruptible(&ttusb->semi2c))
 		return -EAGAIN;
 
 	while (i < num) {

index 4e58476d305e..043dceb77754 100644
@@ -1392,7 +1392,7 @@ int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
 	int ret;
 
 	ret = mutex_lock_interruptible(&chain->ctrl_mutex);
-	if (ret < 0)
+	if (ret)
 		return -ERESTARTSYS;
 
 	/* Check if the ctrl is a know class */

@@ -1453,7 +1453,7 @@ int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
 		return -EINVAL;
 
 	ret = mutex_lock_interruptible(&chain->ctrl_mutex);
-	if (ret < 0)
+	if (ret)
 		return -ERESTARTSYS;
 
 	ctrl = uvc_find_control(chain, query_menu->id, &mapping);

@@ -1760,7 +1760,7 @@ static int uvc_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
 	int ret;
 
 	ret = mutex_lock_interruptible(&handle->chain->ctrl_mutex);
-	if (ret < 0)
+	if (ret)
 		return -ERESTARTSYS;
 
 	if (__uvc_query_v4l2_class(handle->chain, sev->id, 0) >= 0) {

index f9f565c1036d..f1675908253c 100644
@@ -426,7 +426,7 @@ mlxsw_i2c_cmd(struct device *dev, u16 opcode, u32 in_mod, size_t in_mbox_size,
 		reg_size = mlxsw_i2c_get_reg_size(in_mbox);
 		num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);
 
-		if (mutex_lock_interruptible(&mlxsw_i2c->cmd.lock) < 0) {
+		if (mutex_lock_interruptible(&mlxsw_i2c->cmd.lock)) {
 			dev_err(&client->dev, "Could not acquire lock");
 			return -EINVAL;
 		}

@@ -445,7 +445,7 @@ mlxsw_i2c_cmd(struct device *dev, u16 opcode, u32 in_mod, size_t in_mbox_size,
 		reg_size = MLXSW_I2C_MAX_DATA_SIZE;
 		num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);
 
-		if (mutex_lock_interruptible(&mlxsw_i2c->cmd.lock) < 0) {
+		if (mutex_lock_interruptible(&mlxsw_i2c->cmd.lock)) {
 			dev_err(&client->dev, "Could not acquire lock");
 			return -EINVAL;
 		}

index f4a44f05c6ab..09e2c3bc1315 100644
@@ -80,7 +80,7 @@ static void m5632_recover(struct usbnet *dev)
 	int r;
 
 	r = usb_lock_device_for_reset(udev, intf);
-	if (r < 0)
+	if (r)
 		return;
 
 	usb_reset_device(udev);

index cae47663b17b..a1c056612a83 100644
@@ -455,7 +455,7 @@ static int p54u_device_reset(struct ieee80211_hw *dev)
 
 	if (lock) {
 		ret = usb_lock_device_for_reset(priv->udev, priv->intf);
-		if (ret < 0) {
+		if (ret) {
 			dev_err(&priv->udev->dev, "(p54usb) unable to lock "
 				"device for reset (%d)!\n", ret);
 			return ret;

index 7c57d4c8744a..037d7dba9800 100644
@@ -97,7 +97,7 @@ static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
 	int ret;
 
 	ret = mutex_lock_interruptible(&wl->mutex);
-	if (ret < 0)
+	if (ret)
 		return -ERESTARTSYS;
 
 	/* Check if the fwlog is still valid */

index 1fcb0f99695a..e4b823dbc996 100644
@@ -6462,7 +6462,7 @@ static void tpacpi_brightness_checkpoint_nvram(void)
 	vdbg_printk(TPACPI_DBG_BRGHT,
 		"trying to checkpoint backlight level to NVRAM...\n");
 
-	if (mutex_lock_killable(&brightness_mutex) < 0)
+	if (mutex_lock_killable(&brightness_mutex))
 		return;
 
 	if (unlikely(!acpi_ec_read(TP_EC_BACKLIGHT, &lec)))

@@ -6565,7 +6565,7 @@ static int brightness_set(unsigned int value)
 			"set backlight level to %d\n", value);
 
 	res = mutex_lock_killable(&brightness_mutex);
-	if (res < 0)
+	if (res)
 		return res;
 
 	switch (brightness_mode) {

@@ -6604,7 +6604,7 @@ static int brightness_get(struct backlight_device *bd)
 	int status, res;
 
 	res = mutex_lock_killable(&brightness_mutex);
-	if (res < 0)
+	if (res)
 		return 0;
 
 	res = tpacpi_brightness_get_raw(&status);

@@ -7075,7 +7075,7 @@ static void tpacpi_volume_checkpoint_nvram(void)
 	else
 		ec_mask = TP_EC_AUDIO_MUTESW_MSK | TP_EC_AUDIO_LVL_MSK;
 
-	if (mutex_lock_killable(&volume_mutex) < 0)
+	if (mutex_lock_killable(&volume_mutex))
 		return;
 
 	if (unlikely(!acpi_ec_read(TP_EC_AUDIO, &lec)))

@@ -7147,7 +7147,7 @@ static int __volume_set_mute_ec(const bool mute)
 	int rc;
 	u8 s, n;
 
-	if (mutex_lock_killable(&volume_mutex) < 0)
+	if (mutex_lock_killable(&volume_mutex))
 		return -EINTR;
 
 	rc = volume_get_status_ec(&s);

@@ -7195,7 +7195,7 @@ static int __volume_set_volume_ec(const u8 vol)
 	if (vol > TP_EC_VOLUME_MAX)
 		return -EINVAL;
 
-	if (mutex_lock_killable(&volume_mutex) < 0)
+	if (mutex_lock_killable(&volume_mutex))
 		return -EINTR;
 
 	rc = volume_get_status_ec(&s);

index 84d8de07b7ae..aff155682242 100644
@@ -3176,7 +3176,7 @@ static int hpsa_do_reset(struct ctlr_info *h, struct hpsa_scsi_dev_t *dev,
 	int rc = 0;
 
 	/* We can really only handle one reset at a time */
-	if (mutex_lock_interruptible(&h->reset_mutex) == -EINTR) {
+	if (mutex_lock_interruptible(&h->reset_mutex)) {
 		dev_warn(&h->pdev->dev, "concurrent reset wait interrupted.\n");
 		return -EINTR;
 	}

index 85322af62c23..2939b9666729 100644
@@ -1175,7 +1175,7 @@ static int usb_gpib_init_module(struct usb_interface *interface)
 	int j, mask, rv;
 
 	rv = mutex_lock_interruptible(&minors_lock);
-	if (rv < 0)
+	if (rv)
 		return rv;
 
 	if (!assigned_usb_minors) {

@@ -1513,7 +1513,7 @@ static ssize_t skel_do_read(struct usb_skel *dev, char *buffer, size_t count)
 	DIA_LOG(2, "restart with %zd %zd.\n", dev->bulk_in_filled, dev->bulk_in_copied);
 
 	rv = mutex_lock_interruptible(&dev->io_mutex);
-	if (rv < 0)
+	if (rv)
 		return rv;
 
 	if (!dev->interface) {		      /* disconnect() was called */

index 449dbd216460..6f152d483123 100644
@@ -965,7 +965,7 @@ static ssize_t iterate_tty_write(struct tty_ldisc *ld, struct tty_struct *tty,
 	ssize_t ret, written = 0;
 
 	ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	/*

@@ -1154,7 +1154,7 @@ int tty_send_xchar(struct tty_struct *tty, u8 ch)
 		return 0;
 	}
 
-	if (tty_write_lock(tty, false) < 0)
+	if (tty_write_lock(tty, false))
 		return -ERESTARTSYS;
 
 	down_read(&tty->termios_rwsem);

@@ -2486,7 +2486,7 @@ static int send_break(struct tty_struct *tty, unsigned int duration)
 		return tty->ops->break_ctl(tty, duration);
 
 	/* Do the work ourselves */
-	if (tty_write_lock(tty, false) < 0)
+	if (tty_write_lock(tty, false))
 		return -EINTR;
 
 	retval = tty->ops->break_ctl(tty, -1);

index 86ee39db013f..0f77547438d3 100644
@@ -523,9 +523,8 @@ static ssize_t wdm_read
 	int i = 0;
 	struct wdm_device *desc = file->private_data;
 
-
 	rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
-	if (rv < 0)
+	if (rv)
 		return -ERESTARTSYS;
 
 	cntr = READ_ONCE(desc->length);

index e2527faa6592..c197e81e0307 100644
@@ -849,7 +849,7 @@ static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, lo
 		return -EINVAL;
 
 	rv = usblp_rwait_and_lock(usblp, !!(file->f_flags & O_NONBLOCK));
-	if (rv < 0)
+	if (rv)
 		return rv;
 
 	if (!usblp->present) {

index d2b2787be409..137e1dd964d0 100644
@@ -1900,7 +1900,7 @@ static void __usb_queue_reset_device(struct work_struct *ws)
 	struct usb_device *udev = interface_to_usbdev(iface);
 
 	rc = usb_lock_device_for_reset(udev, iface);
-	if (rc >= 0) {
+	if (rc == 0) {
 		usb_reset_device(udev);
 		usb_unlock_device(udev);
 	}

index 23f3cb1989f4..0cff7f540c3a 100644
@@ -32,7 +32,7 @@ static ssize_t field##_show(struct device *dev,				\
 									\
 	udev = to_usb_device(dev);					\
 	rc = usb_lock_device_interruptible(udev);			\
-	if (rc < 0)							\
+	if (rc)								\
 		return -EINTR;						\
 	actconfig = udev->actconfig;					\
 	if (actconfig)							\

@@ -58,7 +58,7 @@ static ssize_t bMaxPower_show(struct device *dev,
 
 	udev = to_usb_device(dev);
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 	actconfig = udev->actconfig;
 	if (actconfig)

@@ -77,7 +77,7 @@ static ssize_t configuration_show(struct device *dev,
 
 	udev = to_usb_device(dev);
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 	actconfig = udev->actconfig;
 	if (actconfig && actconfig->string)

@@ -100,7 +100,7 @@ static ssize_t bConfigurationValue_store(struct device *dev,
 	if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
 		return -EINVAL;
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 	value = usb_set_configuration(udev, config);
 	usb_unlock_device(udev);

@@ -130,7 +130,7 @@ static ssize_t  name##_show(struct device *dev,				\
 									\
 	udev = to_usb_device(dev);					\
 	retval = usb_lock_device_interruptible(udev);			\
-	if (retval < 0)							\
+	if (retval)							\
 		return -EINTR;						\
 	retval = sysfs_emit(buf, "%s\n", udev->name);			\
 	usb_unlock_device(udev);					\

@@ -279,7 +279,7 @@ static ssize_t avoid_reset_quirk_store(struct device *dev,
 	if (kstrtobool(buf, &val) != 0)
 		return -EINVAL;
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 	if (val)
 		udev->quirks |= USB_QUIRK_RESET;

@@ -334,7 +334,7 @@ static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
 		return -EINVAL;
 
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 	udev->persist_enabled = !!value;
 	usb_unlock_device(udev);

@@ -460,7 +460,7 @@ static ssize_t level_store(struct device *dev, struct device_attribute *attr,
 		len = cp - buf;
 
 	rv = usb_lock_device_interruptible(udev);
-	if (rv < 0)
+	if (rv)
 		return -EINTR;
 
 	if (len == sizeof on_string - 1 &&

@@ -502,7 +502,7 @@ static ssize_t usb2_hardware_lpm_store(struct device *dev,
 	int ret;
 
 	ret = usb_lock_device_interruptible(udev);
-	if (ret < 0)
+	if (ret)
 		return -EINTR;
 
 	ret = kstrtobool(buf, &value);

@@ -579,7 +579,7 @@ static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
 	int rc;
 
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 
 	if (udev->usb3_lpm_u1_enabled)

@@ -601,7 +601,7 @@ static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
 	int rc;
 
 	rc = usb_lock_device_interruptible(udev);
-	if (rc < 0)
+	if (rc)
 		return -EINTR;
 
 	if (udev->usb3_lpm_u2_enabled)

@@ -1188,7 +1188,7 @@ static ssize_t supports_autosuspend_show(struct device *dev,
 	int s;
 
 	s = device_lock_interruptible(dev);
-	if (s < 0)
+	if (s)
 		return -EINTR;
 	/* Devices will be autosuspended even when an interface isn't claimed */
 	s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);

index b6a30d88a800..c4c9ad6d8596 100644
@@ -313,7 +313,7 @@ get_ready_ep (unsigned f_flags, struct ep_data *epdata, bool is_write)
 	}
 
 	val = mutex_lock_interruptible(&epdata->lock);
-	if (val < 0)
+	if (val)
 		return val;
 
 	switch (epdata->state) {

@@ -386,7 +386,7 @@ ep_release (struct inode *inode, struct file *fd)
 	int value;
 
 	value = mutex_lock_interruptible(&data->lock);
-	if (value < 0)
+	if (value)
 		return value;
 
 	/* clean up if this can be reopened */

@@ -406,7 +406,8 @@ static long ep_ioctl(struct file *fd, unsigned code, unsigned long value)
 	struct ep_data		*data = fd->private_data;
 	int			status;
 
-	if ((status = get_ready_ep (fd->f_flags, data, false)) < 0)
+	status = get_ready_ep(fd->f_flags, data, false);
+	if (status)
 		return status;
 
 	spin_lock_irq (&data->dev->lock);

@@ -587,7 +588,8 @@ ep_read_iter(struct kiocb *iocb, struct iov_iter *to)
 	ssize_t value;
 	char *buf;
 
-	if ((value = get_ready_ep(file->f_flags, epdata, false)) < 0)
+	value = get_ready_ep(file->f_flags, epdata, false);
+	if (value)
 		return value;
 
 	/* halt any endpoint by doing a "wrong direction" i/o call */

@@ -647,7 +649,8 @@ ep_write_iter(struct kiocb *iocb, struct iov_iter *from)
 	ssize_t value;
 	char *buf;
 
-	if ((value = get_ready_ep(file->f_flags, epdata, true)) < 0)
+	value = get_ready_ep(file->f_flags, epdata, true);
+	if (value)
 		return value;
 
 	configured = epdata->state == STATE_EP_ENABLED;

index 70dff0db5354..b0a1357c7941 100644
@@ -442,7 +442,7 @@ static ssize_t yurex_write(struct file *file, const char __user *user_buffer,
 		goto error;
 
 	retval = mutex_lock_interruptible(&dev->io_mutex);
-	if (retval < 0)
+	if (retval)
 		return -EINTR;
 
 	if (dev->disconnected) {		/* already disconnected */

index e6bc8ecaecbb..52b85acaf756 100644
@@ -1427,7 +1427,7 @@ int usb_stor_port_reset(struct us_data *us)
 		return -EPERM;
 
 	result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
-	if (result < 0)
+	if (result)
 		usb_stor_dbg(us, "unable to lock device for reset: %d\n",
 			     result);
 	else {

index 900a64ad25e4..dba27776a037 100644
@@ -235,7 +235,7 @@ static ssize_t skel_read(struct file *file, char *buffer, size_t count,
 
 	/* no concurrent readers */
 	rv = mutex_lock_interruptible(&dev->io_mutex);
-	if (rv < 0)
+	if (rv)
 		return rv;
 
 	if (dev->disconnected) {		/* disconnect() was called */

index ce625b1ce9a5..2139930f25cb 100644
@@ -218,7 +218,7 @@ static void stub_device_reset(struct usbip_device *ud)
 	dev_dbg(&udev->dev, "device reset");
 
 	ret = usb_lock_device_for_reset(udev, NULL);
-	if (ret < 0) {
+	if (ret) {
 		dev_err(&udev->dev, "lock for reset\n");
 		spin_lock_irq(&ud->lock);
 		ud->status = SDEV_ST_ERROR;

index 9aa30ef76f3b..cecc3972c64a 100644
@@ -156,7 +156,7 @@ static int tweak_reset_device_cmd(struct urb *urb)
 	dev_info(&urb->dev->dev, "usb_queue_reset_device\n");
 
 	err = usb_lock_device_for_reset(sdev->udev, NULL);
-	if (err < 0) {
+	if (err) {
 		dev_err(&urb->dev->dev, "could not obtain lock to reset device\n");
 		return err;
 	}

index 69b1d145657a..f285368d3961 100644
@@ -135,7 +135,7 @@ static int hdq_write_byte(struct hdq_data *hdq_data, u8 val, u8 *status)
 	u8 tmp_status;
 
 	ret = mutex_lock_interruptible(&hdq_data->hdq_mutex);
-	if (ret < 0) {
+	if (ret) {
 		ret = -EINTR;
 		goto rtn;
 	}

@@ -235,7 +235,7 @@ static int omap_hdq_break(struct hdq_data *hdq_data)
 	u8 tmp_status;
 
 	ret = mutex_lock_interruptible(&hdq_data->hdq_mutex);
-	if (ret < 0) {
+	if (ret) {
 		dev_dbg(hdq_data->dev, "Could not acquire mutex\n");
 		ret = -EINTR;
 		goto rtn;

@@ -305,7 +305,7 @@ static int hdq_read_byte(struct hdq_data *hdq_data, u8 *val)
 	u8 status;
 
 	ret = mutex_lock_interruptible(&hdq_data->hdq_mutex);
-	if (ret < 0) {
+	if (ret) {
 		ret = -EINTR;
 		goto rtn;
 	}

@@ -374,7 +374,7 @@ static u8 omap_w1_triplet(void *_hdq, u8 bdir)
 	}
 
 	err = mutex_lock_interruptible(&hdq_data->hdq_mutex);
-	if (err < 0) {
+	if (err) {
 		dev_dbg(hdq_data->dev, "Could not acquire mutex\n");
 		goto rtn;
 	}

index 0ba8336c9025..f7ff7a5b1b99 100644
@@ -420,7 +420,7 @@ int afs_validate(struct afs_vnode *vnode, struct key *key)
 	if (volume->cb_expires_at <= deadline ||
 	    atomic_read(&volume->cb_v_check) != atomic_read(&volume->cb_v_break)) {
 		ret = mutex_lock_interruptible(&volume->cb_check_lock);
-		if (ret < 0)
+		if (ret)
 			goto error_unlock;
 		locked_vol = true;
 	}

index f9e76b604f31..e1c6a1df2745 100644
@@ -188,7 +188,7 @@ static int afs_query_for_alias(struct afs_cell *cell, struct key *key)
 
 	_enter("%s", cell->name);
 
-	if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0)
+	if (mutex_lock_interruptible(&cell->net->proc_cells_lock))
 		return -ERESTARTSYS;
 
 	hlist_for_each_entry(p, &cell->net->proc_cells, proc_link) {

@@ -204,7 +204,7 @@ static int afs_query_for_alias(struct afs_cell *cell, struct key *key)
 		if (afs_query_for_alias_one(cell, key, p) != 0)
 			goto is_alias;
 
-		if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) {
+		if (mutex_lock_interruptible(&cell->net->proc_cells_lock)) {
 			afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);
 			return -ERESTARTSYS;
 		}

@@ -318,7 +318,7 @@ int afs_cell_detect_alias(struct afs_cell *cell, struct key *key)
 	struct afs_net *net = cell->net;
 	int ret;
 
-	if (mutex_lock_interruptible(&net->cells_alias_lock) < 0)
+	if (mutex_lock_interruptible(&net->cells_alias_lock))
 		return -ERESTARTSYS;
 
 	if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &cell->flags)) {

index 094a7f510edf..ec97bc018090 100644
@@ -33,7 +33,7 @@ static ssize_t fscontext_read(struct file *file,
 	int index, n;
 
 	ret = mutex_lock_interruptible(&fc->uapi_mutex);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (log->head == log->tail) {

index a3ed3f2980cb..dce085d51944 100644
@@ -4198,7 +4198,7 @@ SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
 	fc = fd_file(f)->private_data;
 
 	ret = mutex_lock_interruptible(&fc->uapi_mutex);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	/* There must be a valid superblock or we can't mount it */

index 33ee8cb32f83..faf655549aff 100644
@@ -637,7 +637,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
 		 * mounts to fail)
 		 */
 		ret = mutex_lock_interruptible(&orangefs_request_mutex);
-		if (ret < 0)
+		if (ret)
 			return ret;
 		gossip_debug(GOSSIP_DEV_DEBUG,
 			     "%s: priority remount in progress\n",

index cd89e956c322..630fad43d4d3 100644
@@ -2841,7 +2841,7 @@ static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
 
 	/* Guard against adverse ptrace interaction */
 	rv = mutex_lock_interruptible(&current->signal->cred_guard_mutex);
-	if (rv < 0)
+	if (rv)
 		goto out_free;
 
 	rv = security_setprocattr(PROC_I(inode)->op.lsmid,

index f59381c4a2ff..84c9b42f11ef 100644
@@ -1603,7 +1603,7 @@ static long seccomp_notify_send(struct seccomp_filter *filter,
 		return -EINVAL;
 
 	ret = mutex_lock_interruptible(&filter->notify_lock);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	knotif = find_notification(filter, resp.id);

@@ -1643,7 +1643,7 @@ static long seccomp_notify_id_valid(struct seccomp_filter *filter,
 		return -EFAULT;
 
 	ret = mutex_lock_interruptible(&filter->notify_lock);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	knotif = find_notification(filter, id);

@@ -1665,7 +1665,7 @@ static long seccomp_notify_set_flags(struct seccomp_filter *filter,
 		return -EINVAL;
 
 	ret = mutex_lock_interruptible(&filter->notify_lock);
-	if (ret < 0)
+	if (ret)
 		return ret;
 	filter->notif->flags = flags;
 	mutex_unlock(&filter->notify_lock);

@@ -1711,7 +1711,7 @@ static long seccomp_notify_addfd(struct seccomp_filter *filter,
 	init_completion(&kaddfd.completion);
 
 	ret = mutex_lock_interruptible(&filter->notify_lock);
-	if (ret < 0)
+	if (ret)
 		goto out;
 
 	knotif = find_notification(filter, addfd.id);

@@ -1824,7 +1824,7 @@ static __poll_t seccomp_notify_poll(struct file *file,
 
 	poll_wait(file, &filter->wqh, poll_tab);
 
-	if (mutex_lock_interruptible(&filter->notify_lock) < 0)
+	if (mutex_lock_interruptible(&filter->notify_lock))
 		return EPOLLERR;
 
 	list_for_each_entry(cur, &filter->notif->notifications, list) {

index c6ed68604136..9f81f4f30fca 100644
@@ -1916,7 +1916,7 @@ static void *kmemleak_seq_start(struct seq_file *seq, loff_t *pos)
 	int err;
 
 	err = mutex_lock_interruptible(&scan_mutex);
-	if (err < 0)
+	if (err)
 		return ERR_PTR(err);
 
 	rcu_read_lock();

@@ -2074,7 +2074,7 @@ static ssize_t kmemleak_write(struct file *file, const char __user *user_buf,
 	buf[buf_size] = 0;
 
 	ret = mutex_lock_interruptible(&scan_mutex);
-	if (ret < 0)
+	if (ret)
 		return ret;
 
 	if (strncmp(buf, "clear", 5) == 0) {

index 32cd5f1d541d..bb385070a729 100644
@@ -368,7 +368,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 		if (flags & MSG_DONTWAIT)
 			goto error_requeue_call;
 		ret = -ERESTARTSYS;
-		if (mutex_lock_interruptible(&call->user_mutex) < 0)
+		if (mutex_lock_interruptible(&call->user_mutex))
 			goto error_requeue_call;
 	}
 

index 0e8da909d4f2..216d9db6b9ac 100644
@@ -487,7 +487,7 @@ static int rxrpc_send_data(struct rxrpc_sock *rx,
 	if (ret < 0)
 		goto maybe_error;
 	if (call->interruptibility == RXRPC_INTERRUPTIBLE) {
-		if (mutex_lock_interruptible(&call->user_mutex) < 0) {
+		if (mutex_lock_interruptible(&call->user_mutex)) {
 			ret = sock_intr_errno(timeo);
 			goto maybe_error;
 		}

index e4a79a9b2d58..42e0b2716483 100644
@@ -370,7 +370,7 @@ static ssize_t ima_write_policy(struct file *file, const char __user *buf,
 	}
 
 	result = mutex_lock_interruptible(&ima_write_mutex);
-	if (result < 0)
+	if (result)
 		goto out_free;
 
 	if (data[0] == '/') {

index 92ffe9dc20c5..02c4c05d1492 100644
@@ -203,7 +203,7 @@ static void oxygen_proc_read(struct snd_info_entry *entry,
 			snd_iprintf(buffer, " %02x", oxygen_read8(chip, i + j));
 		snd_iprintf(buffer, "\n");
 	}
-	if (mutex_lock_interruptible(&chip->mutex) < 0)
+	if (mutex_lock_interruptible(&chip->mutex))
 		return;
 	if (chip->has_ac97_0) {
 		snd_iprintf(buffer, "\nAC97:\n");

index c43d8ad02529..261bf85b0200 100644
@@ -851,7 +851,9 @@ static int isapnp_get_resources(struct pnp_dev *dev)
 
 	pnp_dbg(&dev->dev, "get resources\n");
 	pnp_init_resources(dev);
-	isapnp_cfg_begin(dev->card->number, dev->number);
+	ret = isapnp_cfg_begin(dev->card->number, dev->number);
+	if (ret)
+		return ret;
 	dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
 	if (!dev->active)
 		goto __end;

@@ -885,10 +887,12 @@ static int isapnp_get_resources(struct pnp_dev *dev)
 static int isapnp_set_resources(struct pnp_dev *dev)
 {
 	struct resource *res;
-	int tmp;
+	int tmp, ret;
 
 	pnp_dbg(&dev->dev, "set resources\n");
-	isapnp_cfg_begin(dev->card->number, dev->number);
+	ret = isapnp_cfg_begin(dev->card->number, dev->number);
+	if (ret)
+		return ret;
 	dev->active = 1;
 	for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
 		res = pnp_get_resource(dev, IORESOURCE_IO, tmp);

@@ -934,9 +938,13 @@ static int isapnp_set_resources(struct pnp_dev *dev)
 
 static int isapnp_disable_resources(struct pnp_dev *dev)
 {
+	int ret;
+
 	if (!dev->active)
 		return -EINVAL;
-	isapnp_cfg_begin(dev->card->number, dev->number);
+	ret = isapnp_cfg_begin(dev->card->number, dev->number);
+	if (ret)
+		return ret;
 	isapnp_deactivate(dev->number);
 	dev->active = 0;
 	isapnp_cfg_end();

index 7589f48aebc8..f4b5813e6fc4 100644
@@ -2339,6 +2339,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
 	}
 
 	if (!mrioc->ioctl_sges_allocated) {
+		mutex_unlock(&mrioc->bsg_cmds.mutex);
 		dprint_bsg_err(mrioc, "%s: DMA memory was not allocated\n",
 			       __func__);
 		return -ENOMEM;

index dc43cfa83088..212e3b86bb81 100644
@@ -8018,7 +8018,7 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc)
 
 	mutex_lock(&ioc->hostdiag_unlock_mutex);
 	if (mpt3sas_base_unlock_and_get_host_diagnostic(ioc, &host_diagnostic))
-		goto out;
+		goto unlock;
 
 	hcb_size = ioc->base_readl(&ioc->chip->HCBSize);
 	drsprintk(ioc, ioc_info(ioc, "diag reset: issued\n"));

@@ -8038,7 +8038,7 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc)
 			ioc_info(ioc,
 			    "Invalid host diagnostic register value\n");
 			_base_dump_reg_set(ioc);
-			goto out;
+			goto unlock;
 		}
 		if (!(host_diagnostic & MPI2_DIAG_RESET_ADAPTER))
 			break;

@@ -8074,17 +8074,19 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc)
 		ioc_err(ioc, "%s: failed going to ready state (ioc_state=0x%x)\n",
 			__func__, ioc_state);
 		_base_dump_reg_set(ioc);
-		goto out;
+		goto fail;
 	}
 
 	pci_cfg_access_unlock(ioc->pdev);
 	ioc_info(ioc, "diag reset: SUCCESS\n");
 	return 0;
 
- out:
+unlock:
+	mutex_unlock(&ioc->hostdiag_unlock_mutex);
+
+fail:
 	pci_cfg_access_unlock(ioc->pdev);
 	ioc_err(ioc, "diag reset: FAILED\n");
-	mutex_unlock(&ioc->hostdiag_unlock_mutex);
 	return -EFAULT;
 }
 

index a7c510832824..69a4b84f935f 100644
@@ -526,6 +526,30 @@ ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 	return need_reconfig;
 }
 
+static void disable_dcb(struct ice_pf *pf)
+{
+	struct ice_dcbx_cfg *err_cfg;
+	struct device *dev = ice_pf_to_dev(pf);
+
+	dev_err(dev, "Disabling DCB until new settings occur\n");
+	err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
+	if (!err_cfg)
+		return;
+
+	err_cfg->etscfg.willing = true;
+	err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
+	err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
+	memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec));
+	/* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
+	 * here as is done for other calls to that function. That check is
+	 * not necessary since this is in this function's error cleanup path.
+	 * Suppress the Coverity warning with the following comment...
+	 */
+	/* coverity[check_return] */
+	ice_pf_dcb_cfg(pf, err_cfg, false);
+	kfree(err_cfg);
+}
+
 /**
  * ice_dcb_rebuild - rebuild DCB post reset
  * @pf: physical function instance

@@ -534,7 +558,6 @@ void ice_dcb_rebuild(struct ice_pf *pf)
 {
 	struct ice_aqc_port_ets_elem buf = { 0 };
 	struct device *dev = ice_pf_to_dev(pf);
-	struct ice_dcbx_cfg *err_cfg;
 	int ret;
 
 	ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);

@@ -574,26 +597,7 @@ void ice_dcb_rebuild(struct ice_pf *pf)
 	return;
 
 dcb_error:
-	dev_err(dev, "Disabling DCB until new settings occur\n");
-	err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
-	if (!err_cfg) {
-		mutex_unlock(&pf->tc_mutex);
-		return;
-	}
-
-	err_cfg->etscfg.willing = true;
-	err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
-	err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
-	memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec));
-	/* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
-	 * here as is done for other calls to that function. That check is
-	 * not necessary since this is in this function's error cleanup path.
-	 * Suppress the Coverity warning with the following comment...
-	 */
-	/* coverity[check_return] */
-	ice_pf_dcb_cfg(pf, err_cfg, false);
-	kfree(err_cfg);
-
+	disable_dcb(pf);
 	mutex_unlock(&pf->tc_mutex);
 }
 

index 69a4b84f935f..65545613e1e8 100644
@@ -563,7 +563,8 @@ void ice_dcb_rebuild(struct ice_pf *pf)
 	ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 	if (ret) {
 		dev_err(dev, "Query Port ETS failed\n");
-		goto dcb_error;
+		disable_dcb(pf);
+		return;
 	}
 
 	mutex_lock(&pf->tc_mutex);

index a7c510832824..d185b1aba7a4 100644
@@ -537,14 +537,14 @@ void ice_dcb_rebuild(struct ice_pf *pf)
 	struct ice_dcbx_cfg *err_cfg;
 	int ret;
 
+	mutex_lock(&pf->tc_mutex);
+
 	ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 	if (ret) {
 		dev_err(dev, "Query Port ETS failed\n");
 		goto dcb_error;
 	}
 
-	mutex_lock(&pf->tc_mutex);
-
 	if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
 		ice_cfg_etsrec_defaults(pf->hw.port_info);
 

index 6ab02f3fc291..97d8fcde3648 100644
@@ -510,12 +510,11 @@ static int mlx5e_macsec_add_txsa(struct macsec_context *ctx)
 	struct mlx5_core_dev *mdev = priv->mdev;
 	u8 assoc_num = ctx->sa.assoc_num;
 	struct mlx5e_macsec_sa *tx_sa;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
+	mutex_lock(&macsec->lock);
 
-	macsec = priv->macsec;
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");

@@ -581,13 +580,12 @@ static int mlx5e_macsec_upd_txsa(struct macsec_context *ctx)
 	struct mlx5e_macsec_device *macsec_device;
 	u8 assoc_num = ctx->sa.assoc_num;
 	struct mlx5e_macsec_sa *tx_sa;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	struct net_device *netdev;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
+	mutex_lock(&macsec->lock);
 
-	macsec = priv->macsec;
 	netdev = ctx->netdev;
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {

@@ -641,11 +639,10 @@ static int mlx5e_macsec_del_txsa(struct macsec_context *ctx)
 	struct mlx5e_macsec_device *macsec_device;
 	u8 assoc_num = ctx->sa.assoc_num;
 	struct mlx5e_macsec_sa *tx_sa;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
-	macsec = priv->macsec;
+	mutex_lock(&macsec->lock);
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");

@@ -679,11 +676,10 @@ static int mlx5e_macsec_add_rxsc(struct macsec_context *ctx)
 	struct mlx5e_macsec_device *macsec_device;
 	struct mlx5e_macsec_rx_sc *rx_sc;
 	struct list_head *rx_sc_list;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
-	macsec = priv->macsec;
+	mutex_lock(&macsec->lock);
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");

@@ -759,14 +755,12 @@ static int mlx5e_macsec_upd_rxsc(struct macsec_context *ctx)
 	struct mlx5e_macsec_device *macsec_device;
 	struct mlx5e_macsec_rx_sc *rx_sc;
 	struct mlx5e_macsec_sa *rx_sa;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	struct list_head *list;
 	int i;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
-
-	macsec = priv->macsec;
+	mutex_lock(&macsec->lock);
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");

@@ -838,13 +832,11 @@ static int mlx5e_macsec_del_rxsc(struct macsec_context *ctx)
 	struct mlx5e_priv *priv = macsec_netdev_priv(ctx->netdev);
 	struct mlx5e_macsec_device *macsec_device;
 	struct mlx5e_macsec_rx_sc *rx_sc;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	struct list_head *list;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
-
-	macsec = priv->macsec;
+	mutex_lock(&macsec->lock);
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");

@@ -879,13 +871,11 @@ static int mlx5e_macsec_add_rxsa(struct macsec_context *ctx)
 	struct mlx5e_macsec_rx_sc *rx_sc;
 	sci_t sci = ctx_rx_sa->sc->sci;
 	struct mlx5e_macsec_sa *rx_sa;
-	struct mlx5e_macsec *macsec;
+	struct mlx5e_macsec *macsec = priv->macsec;
 	struct list_head *list;
 	int err = 0;
 
-	mutex_lock(&priv->macsec->lock);
-
-	macsec = priv->macsec;
+	mutex_lock(&macsec->lock);
 	macsec_device = mlx5e_macsec_get_macsec_device_context(macsec, ctx);
 	if (!macsec_device) {
 		netdev_err(ctx->netdev, "MACsec offload: Failed to find device context\n");