Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
dma-buf/dma-fence: Add dma_fence_test_signaled_flag()
The dma_fence framework checks at many places whether the signaled flag
of a fence is already set. The code can be simplified and made more
readable by providing a helper function for that.
Add dma_fence_test_signaled_flag(), which only checks whether a fence is
signaled. Use it internally.
Suggested-by: Tvrtko Ursulin <tvrtko.ursulin@igalia.com>
Reviewed-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Philipp Stanner <phasta@kernel.org>
Link: https://patch.msgid.link/20251201105011.19386-3-phasta@kernel.org
+30
-10
+8
-8
drivers/dma-buf/dma-fence.c
+8
-8
drivers/dma-buf/dma-fence.c
···
543
543
trace_dma_fence_destroy(fence);
544
544
545
545
if (!list_empty(&fence->cb_list) &&
546
-
!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) {
546
+
!dma_fence_test_signaled_flag(fence)) {
547
547
const char __rcu *timeline;
548
548
const char __rcu *driver;
549
549
unsigned long flags;
···
600
600
was_set = test_and_set_bit(DMA_FENCE_FLAG_ENABLE_SIGNAL_BIT,
601
601
&fence->flags);
602
602
603
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
603
+
if (dma_fence_test_signaled_flag(fence))
604
604
return false;
605
605
606
606
if (!was_set && fence->ops->enable_signaling) {
···
664
664
if (WARN_ON(!fence || !func))
665
665
return -EINVAL;
666
666
667
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) {
667
+
if (dma_fence_test_signaled_flag(fence)) {
668
668
INIT_LIST_HEAD(&cb->node);
669
669
return -ENOENT;
670
670
}
···
781
781
782
782
spin_lock_irqsave(fence->lock, flags);
783
783
784
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
784
+
if (dma_fence_test_signaled_flag(fence))
785
785
goto out;
786
786
787
787
if (intr && signal_pending(current)) {
···
798
798
cb.task = current;
799
799
list_add(&cb.base.node, &fence->cb_list);
800
800
801
-
while (!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags) && ret > 0) {
801
+
while (!dma_fence_test_signaled_flag(fence) && ret > 0) {
802
802
if (intr)
803
803
__set_current_state(TASK_INTERRUPTIBLE);
804
804
else
···
830
830
831
831
for (i = 0; i < count; ++i) {
832
832
struct dma_fence *fence = fences[i];
833
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) {
833
+
if (dma_fence_test_signaled_flag(fence)) {
834
834
if (idx)
835
835
*idx = i;
836
836
return true;
···
1108
1108
RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
1109
1109
"RCU protection is required for safe access to returned string");
1110
1110
1111
-
if (!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
1111
+
if (!dma_fence_test_signaled_flag(fence))
1112
1112
return fence->ops->get_driver_name(fence);
1113
1113
else
1114
1114
return "detached-driver";
···
1140
1140
RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
1141
1141
"RCU protection is required for safe access to returned string");
1142
1142
1143
-
if (!test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
1143
+
if (!dma_fence_test_signaled_flag(fence))
1144
1144
return fence->ops->get_driver_name(fence);
1145
1145
else
1146
1146
return "signaled-timeline";
+22
-2
include/linux/dma-fence.h
+22
-2
include/linux/dma-fence.h
···
401
401
const char __rcu *dma_fence_driver_name(struct dma_fence *fence);
402
402
const char __rcu *dma_fence_timeline_name(struct dma_fence *fence);
403
403
404
+
/*
405
+
* dma_fence_test_signaled_flag - Only check whether a fence is signaled yet.
406
+
* @fence: the fence to check
407
+
*
408
+
* This function just checks whether @fence is signaled, without interacting
409
+
* with the fence in any way. The user must, therefore, ensure through other
410
+
* means that fences get signaled eventually.
411
+
*
412
+
* This function uses test_bit(), which is thread-safe. Naturally, this function
413
+
* should be used opportunistically; a fence could get signaled at any moment
414
+
* after the check is done.
415
+
*
416
+
* Return: true if signaled, false otherwise.
417
+
*/
418
+
static inline bool
419
+
dma_fence_test_signaled_flag(struct dma_fence *fence)
420
+
{
421
+
return test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags);
422
+
}
423
+
404
424
/**
405
425
* dma_fence_is_signaled_locked - Return an indication if the fence
406
426
* is signaled yet.
···
438
418
static inline bool
439
419
dma_fence_is_signaled_locked(struct dma_fence *fence)
440
420
{
441
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
421
+
if (dma_fence_test_signaled_flag(fence))
442
422
return true;
443
423
444
424
if (fence->ops->signaled && fence->ops->signaled(fence)) {
···
468
448
static inline bool
469
449
dma_fence_is_signaled(struct dma_fence *fence)
470
450
{
471
-
if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
451
+
if (dma_fence_test_signaled_flag(fence))
472
452
return true;
473
453
474
454
if (fence->ops->signaled && fence->ops->signaled(fence)) {