virtio: hint if callbacks surprisingly might sleep

cohuck · mstsirkin · commit ab7a2375fb8e · 2019-03-06T11:19:57.000-05:00
A virtio transport is free to implement some of the callbacks in
virtio_config_ops in a matter that they cannot be called from
atomic context (e.g. virtio-ccw, which maps a lot of the callbacks
to channel I/O, which is an inherently asynchronous mechanism).
This can be very surprising for developers using the much more
common virtio-pci transport, just to find out that things break
when used on s390.

The documentation for virtio_config_ops now contains a comment
explaining this, but it makes sense to add a might_sleep() annotation
to various wrapper functions in the virtio core to avoid surprises
later.

Note that annotations are NOT added to two classes of calls:
- direct calls from device drivers (all current callers should be
  fine, however)
- calls which clearly won't be made from atomic context (such as
  those ultimately coming in via the driver core)

Signed-off-by: Cornelia Huck &lt;cohuck@redhat.com&gt;
Signed-off-by: Michael S. Tsirkin &lt;mst@redhat.com&gt;
diff --git a/drivers/virtio/virtio.c b/drivers/virtio/virtio.c
@@ -161,6 +161,7 @@ EXPORT_SYMBOL_GPL(virtio_config_enable);
 
 void virtio_add_status(struct virtio_device *dev, unsigned int status)
 {
+	might_sleep();
 	dev->config->set_status(dev, dev->config->get_status(dev) | status);
 }
 EXPORT_SYMBOL_GPL(virtio_add_status);
@@ -170,6 +171,7 @@ int virtio_finalize_features(struct virtio_device *dev)
 	int ret = dev->config->finalize_features(dev);
 	unsigned status;
 
+	might_sleep();
 	if (ret)
 		return ret;
 
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
@@ -290,6 +290,7 @@ static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)
 /* Config space accessors. */
 #define virtio_cread(vdev, structname, member, ptr)			\
 	do {								\
+		might_sleep();						\
 		/* Must match the member's type, and be integer */	\
 		if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \
 			(*ptr) = 1;					\
@@ -319,6 +320,7 @@ static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)
 /* Config space accessors. */
 #define virtio_cwrite(vdev, structname, member, ptr)			\
 	do {								\
+		might_sleep();						\
 		/* Must match the member's type, and be integer */	\
 		if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \
 			BUG_ON((*ptr) == 1);				\
@@ -358,6 +360,7 @@ static inline void __virtio_cread_many(struct virtio_device *vdev,
 		vdev->config->generation(vdev) : 0;
 	int i;
 
+	might_sleep();
 	do {
 		old = gen;
 
@@ -380,27 +383,33 @@ static inline void virtio_cread_bytes(struct virtio_device *vdev,
 static inline u8 virtio_cread8(struct virtio_device *vdev, unsigned int offset)
 {
 	u8 ret;
+
+	might_sleep();
 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
 	return ret;
 }
 
 static inline void virtio_cwrite8(struct virtio_device *vdev,
 				  unsigned int offset, u8 val)
 {
+	might_sleep();
 	vdev->config->set(vdev, offset, &val, sizeof(val));
 }
 
 static inline u16 virtio_cread16(struct virtio_device *vdev,
 				 unsigned int offset)
 {
 	u16 ret;
+
+	might_sleep();
 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
 	return virtio16_to_cpu(vdev, (__force __virtio16)ret);
 }
 
 static inline void virtio_cwrite16(struct virtio_device *vdev,
 				   unsigned int offset, u16 val)
 {
+	might_sleep();
 	val = (__force u16)cpu_to_virtio16(vdev, val);
 	vdev->config->set(vdev, offset, &val, sizeof(val));
 }
@@ -409,13 +418,16 @@ static inline u32 virtio_cread32(struct virtio_device *vdev,
 				 unsigned int offset)
 {
 	u32 ret;
+
+	might_sleep();
 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
 	return virtio32_to_cpu(vdev, (__force __virtio32)ret);
 }
 
 static inline void virtio_cwrite32(struct virtio_device *vdev,
 				   unsigned int offset, u32 val)
 {
+	might_sleep();
 	val = (__force u32)cpu_to_virtio32(vdev, val);
 	vdev->config->set(vdev, offset, &val, sizeof(val));
 }
@@ -431,6 +443,7 @@ static inline u64 virtio_cread64(struct virtio_device *vdev,
 static inline void virtio_cwrite64(struct virtio_device *vdev,
 				   unsigned int offset, u64 val)
 {
+	might_sleep();
 	val = (__force u64)cpu_to_virtio64(vdev, val);
 	vdev->config->set(vdev, offset, &val, sizeof(val));
 }

Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,7 @@ EXPORT_SYMBOL_GPL(virtio_config_enable);`
`161`	`161`
`162`	`162`	`void virtio_add_status(struct virtio_device *dev, unsigned int status)`
`163`	`163`	`{`
	`164`	`+ might_sleep();`
`164`	`165`	`dev->config->set_status(dev, dev->config->get_status(dev) \| status);`
`165`	`166`	`}`
`166`	`167`	`EXPORT_SYMBOL_GPL(virtio_add_status);`
`@@ -170,6 +171,7 @@ int virtio_finalize_features(struct virtio_device *dev)`
`170`	`171`	`int ret = dev->config->finalize_features(dev);`
`171`	`172`	`unsigned status;`
`172`	`173`
	`174`	`+ might_sleep();`
`173`	`175`	`if (ret)`
`174`	`176`	`return ret;`
`175`	`177`
Original file line number	Diff line number	Diff line change
`@@ -290,6 +290,7 @@ static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)`
`290`	`290`	`/* Config space accessors. */`
`291`	`291`	`#define virtio_cread(vdev, structname, member, ptr) \`
`292`	`292`	`do { \`
	`293`	`+ might_sleep(); \`
`293`	`294`	`/* Must match the member's type, and be integer */ \`
`294`	`295`	`if (!typecheck(typeof((((structname)0)->member)), (ptr))) \`
`295`	`296`	`(*ptr) = 1; \`
`@@ -319,6 +320,7 @@ static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)`
`319`	`320`	`/* Config space accessors. */`
`320`	`321`	`#define virtio_cwrite(vdev, structname, member, ptr) \`
`321`	`322`	`do { \`
	`323`	`+ might_sleep(); \`
`322`	`324`	`/* Must match the member's type, and be integer */ \`
`323`	`325`	`if (!typecheck(typeof((((structname)0)->member)), (ptr))) \`
`324`	`326`	`BUG_ON((*ptr) == 1); \`
`@@ -358,6 +360,7 @@ static inline void __virtio_cread_many(struct virtio_device *vdev,`
`358`	`360`	`vdev->config->generation(vdev) : 0;`
`359`	`361`	`int i;`
`360`	`362`
	`363`	`+ might_sleep();`
`361`	`364`	`do {`
`362`	`365`	`old = gen;`
`363`	`366`
`@@ -380,27 +383,33 @@ static inline void virtio_cread_bytes(struct virtio_device *vdev,`
`380`	`383`	`static inline u8 virtio_cread8(struct virtio_device *vdev, unsigned int offset)`
`381`	`384`	`{`
`382`	`385`	`u8 ret;`
	`386`	`+`
	`387`	`+ might_sleep();`
`383`	`388`	`vdev->config->get(vdev, offset, &ret, sizeof(ret));`
`384`	`389`	`return ret;`
`385`	`390`	`}`
`386`	`391`
`387`	`392`	`static inline void virtio_cwrite8(struct virtio_device *vdev,`
`388`	`393`	`unsigned int offset, u8 val)`
`389`	`394`	`{`
	`395`	`+ might_sleep();`
`390`	`396`	`vdev->config->set(vdev, offset, &val, sizeof(val));`
`391`	`397`	`}`
`392`	`398`
`393`	`399`	`static inline u16 virtio_cread16(struct virtio_device *vdev,`
`394`	`400`	`unsigned int offset)`
`395`	`401`	`{`
`396`	`402`	`u16 ret;`
	`403`	`+`
	`404`	`+ might_sleep();`
`397`	`405`	`vdev->config->get(vdev, offset, &ret, sizeof(ret));`
`398`	`406`	`return virtio16_to_cpu(vdev, (__force __virtio16)ret);`
`399`	`407`	`}`
`400`	`408`
`401`	`409`	`static inline void virtio_cwrite16(struct virtio_device *vdev,`
`402`	`410`	`unsigned int offset, u16 val)`
`403`	`411`	`{`
	`412`	`+ might_sleep();`
`404`	`413`	`val = (__force u16)cpu_to_virtio16(vdev, val);`
`405`	`414`	`vdev->config->set(vdev, offset, &val, sizeof(val));`
`406`	`415`	`}`
`@@ -409,13 +418,16 @@ static inline u32 virtio_cread32(struct virtio_device *vdev,`
`409`	`418`	`unsigned int offset)`
`410`	`419`	`{`
`411`	`420`	`u32 ret;`
	`421`	`+`
	`422`	`+ might_sleep();`
`412`	`423`	`vdev->config->get(vdev, offset, &ret, sizeof(ret));`
`413`	`424`	`return virtio32_to_cpu(vdev, (__force __virtio32)ret);`
`414`	`425`	`}`
`415`	`426`
`416`	`427`	`static inline void virtio_cwrite32(struct virtio_device *vdev,`
`417`	`428`	`unsigned int offset, u32 val)`
`418`	`429`	`{`
	`430`	`+ might_sleep();`
`419`	`431`	`val = (__force u32)cpu_to_virtio32(vdev, val);`
`420`	`432`	`vdev->config->set(vdev, offset, &val, sizeof(val));`
`421`	`433`	`}`
`@@ -431,6 +443,7 @@ static inline u64 virtio_cread64(struct virtio_device *vdev,`
`431`	`443`	`static inline void virtio_cwrite64(struct virtio_device *vdev,`
`432`	`444`	`unsigned int offset, u64 val)`
`433`	`445`	`{`
	`446`	`+ might_sleep();`
`434`	`447`	`val = (__force u64)cpu_to_virtio64(vdev, val);`
`435`	`448`	`vdev->config->set(vdev, offset, &val, sizeof(val));`
`436`	`449`	`}`