drm/i915: timeout parameter for seqno wait
Subsystems (2)
PATCH v5 1/4 drm/i915: timeout parameter for seqno wait
Insert a wait parameter in the code so we can possibly timeout on a seqno wait if need be. The code should be functionally the same as before because all the callers will continue to retry if an arbitrary timeout elapses.
We'd like to have nanosecond granularity, but the only way to do this is with hrtimer, and that doesn't fit well with the needs of this code.
v2: Fix rebase error (Chris)
Return proper time even in wedged + signal case (Chris + Ben) Use timespec constructs (Ben)
Didn't take Daniel's advice regarding the Frankenstein-ness of the
function. I did try his advice, but in the end I liked the way the original code looked, better.
v3: Make wakeups far less frequent for infinite waits (Chris)
v4: Remove dummy_wait variable (Daniel)
Use raw monotonic time instead of jiffies (made the code a bit cleaner) (Ben) Added a couple of warnings (Ben)
v5: Remove warnings (Daniel)
Use more accurate time diff for default case (Daniel) Bikeshed for setting the return timespec in timeout case (Daniel) s/jiffies/time in one of the comments
--- drivers/gpu/drm/i915/i915_gem.c | 70 ++++++++++++++++++++++++++++++++------- 1 file changed, 58 insertions(+), 12 deletions(-)
drivers/gpu/drm/i915/i915_gem.c +58 -12
@@ -1868,34 +1868,82 @@ i915_gem_check_olr(struct intel_ring_buffer *ring, u32 seqno)return ret; } +/** +* __wait_seqno - wait until execution of seqno has finished +* @ring: the ring expected to report seqno +* @seqno: duh! +* @interruptible: do an interruptible wait (normally yes) +* @timeout: in - how long to wait (NULL forever); out - how much time remaining +* +* Returns 0 if the seqno was found within the alloted time. Else returns the +* errno with remaining time filled in timeout argument. +*/ static int __wait_seqno (struct intel_ring_buffer *ring,u32 seqno, -bool interruptible) +bool interruptible,struct timespec *timeout) {drm_i915_private_t *dev_priv = ring->dev->dev_private; -int ret =0 ; +struct timespec before, now, wait_time={1 ,0 }; +unsigned long timeout_jiffies; +long end; +bool wait_forever = true;if (i915_seqno_passed (ring->get_seqno (ring), seqno))return 0 ;trace_i915_gem_request_wait_begin (ring, seqno); + +if (timeout !=NULL ) { + wait_time = *timeout; + wait_forever = false; + } + + timeout_jiffies =timespec_to_jiffies (&wait_time); +if (WARN_ON (!ring->irq_get (ring)))return -ENODEV ; +/* Record current time in case interrupted by signal, or wedged * */ +getrawmonotonic (&before); +#define EXIT_COND \ (i915_seqno_passed(ring->get_seqno(ring), seqno) || \ atomic_read(&dev_priv->mm.wedged)) +do { +if (interruptible) + end =wait_event_interruptible_timeout (ring->irq_queue, +EXIT_COND , + timeout_jiffies); +else + end =wait_event_timeout (ring->irq_queue,EXIT_COND , + timeout_jiffies); -if (interruptible) - ret =wait_event_interruptible (ring->irq_queue, -EXIT_COND ); -else -wait_event (ring->irq_queue,EXIT_COND ); +if (atomic_read (&dev_priv->mm.wedged)) + end = -EAGAIN ; + }while (end ==0 && wait_forever); + +getrawmonotonic (&now); ring->irq_put (ring);trace_i915_gem_request_wait_end (ring, seqno);#undef EXIT_COND -return ret; +if (timeout) { +struct timespec sleep_time =timespec_sub (now, before); + *timeout =timespec_sub (*timeout, sleep_time); + } + +switch (end) { +case -EAGAIN :/* Wedged */ +case -ERESTARTSYS :/* Signal */ +return (int )end; +case 0 :/* Timeout */ +if (timeout) +set_normalized_timespec (timeout,0 ,0 ); +return -ETIME ; +default :/* Completed */ +WARN_ON (end <0 );/* We're not aware of other errors */ +return 0 ; + } }/**
@@ -1919,9 +1967,7 @@ i915_wait_request(struct intel_ring_buffer *ring,if (ret)return ret; - ret =__wait_seqno (ring, seqno, dev_priv->mm.interruptible); -if (atomic_read (&dev_priv->mm.wedged)) - ret = -EAGAIN ; + ret =__wait_seqno (ring, seqno, dev_priv->mm.interruptible,NULL );return ret; }
@@ -2996,7 +3042,7 @@ i915_gem_ring_throttle(struct drm_device *dev, struct drm_file *file)if (seqno ==0 )return 0 ; - ret =__wait_seqno (ring, seqno, true); + ret =__wait_seqno (ring, seqno, true,NULL );if (ret ==0 )queue_delayed_work (dev_priv->wq, &dev_priv->mm.retire_work,0 );
Signature · 1 line
1.7.10.2
PATCH RESEND v3 2/4 drm/i915: improve i915_wait_request_begin trace
The trace events adds whether or not the wait was blocking. Blocking in this case means to hold struct_mutex (ie. no new work can be submitted during the wait). The information is inherently racy.
The blocking information is racy since mutex_is_locked doesn't check that the current thread holds the lock. The only other option would be to pass the boolean information of whether or not the class was blocking down through the stack which is less desirable.
v2: Don't do a trace event per loop. (Chris)
Only get blocking/non-blocking info (Chris)
v3: updated comment in code as well as commit msg (Daniel) Add "(NB)" to trace information to remind us in 6 months (Ben)
--- drivers/gpu/drm/i915/i915_trace.h | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_trace.h +26 -2
@@ -311,9 +311,33 @@ DEFINE_EVENT(i915_gem_request, i915_gem_request_retire,TP_ARGS (ring, seqno) ); -DEFINE_EVENT (i915_gem_request, i915_gem_request_wait_begin, +TRACE_EVENT (i915_gem_request_wait_begin, TP_PROTO(struct intel_ring_buffer *ring, u32 seqno), -TP_ARGS (ring, seqno) +TP_ARGS (ring, seqno), + +TP_STRUCT__entry ( + __field(u32, dev) + __field(u32, ring) + __field(u32, seqno) +__field (bool, blocking) + ), + +/* NB: the blocking information is racy since mutex_is_locked +* doesn't check that the current thread holds the lock. The only +* other option would be to pass the boolean information of whether +* or not the class was blocking down through the stack which is +* less desirable. +*/ +TP_fast_assign ( + __entry->dev = ring->dev->primary->index; + __entry->ring = ring->id; + __entry->seqno = seqno; + __entry->blocking = mutex_is_locked(&ring->dev->struct_mutex); + ), + +TP_printk ("dev=%u, ring=%u, seqno=%u, blocking=%s" , + __entry->dev, __entry->ring, __entry->seqno, + __entry->blocking ?"yes (NB)" :"no" ) ); DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end,
Signature · 1 line
1.7.10.2
PATCH v7 3/4 drm/i915: wait render timeout ioctl
In reply to Ben WidawskyThis helps implement GL_ARB_sync but stops short of allowing full blown sync objects. Finally we can use the new timed seqno waiting function to allow userspace to wait on a buffer object with a timeout. This implements that interface.
The IOCTL will take as input a buffer object handle, and a timeout in nanoseconds (flags is currently optional but will likely be used for permutations of flush operations). Users may specify 0 nanoseconds to instantly check.
The wait ioctl with a timeout of 0 reimplements the busy ioctl. With any non-zero timeout parameter the wait ioctl will wait for the given number of nanoseconds on an object becoming unbusy. Since the wait itself does so holding struct_mutex the object may become re-busied before this completes. A similar but shorter race condition exists in the busy ioctl.
v2: ETIME/ERESTARTSYS instead of changing to EBUSY, and EGAIN (Chris) Flush the object from the gpu write domain (Chris + Daniel) Fix leaked refcount in good case (Chris)
Naturally align ioctl struct (Chris)
v3: Drop lock after getting seqno to avoid ugly dance (Chris)
v4: check for 0 timeout after olr check to allow polling (Chris)
v5: Updated the comment. (Chris)
v6: Return -ETIME instead of -EBUSY when timeout_ns is 0 (Daniel) Fix the commit message comment to be less ugly (Ben) Add a warning to check the return timespec (Ben)
v7: Use DRM_AUTH for the ioctl. (Eugeni)
--- drivers/gpu/drm/i915/i915_dma.c | 1 + drivers/gpu/drm/i915/i915_drv.h | 2 + drivers/gpu/drm/i915/i915_gem.c | 86 +++++++++++++++++++++++++++++++++++++++ include/drm/i915_drm.h | 10 +++++ 4 files changed, 99 insertions(+)
drivers/gpu/drm/i915/i915_dma.c +1 -0
@@ -1800,6 +1800,7 @@ struct drm_ioctl_desc i915_ioctls[] = {DRM_IOCTL_DEF_DRV (I915_OVERLAY_ATTRS , intel_overlay_attrs,DRM_MASTER |DRM_CONTROL_ALLOW |DRM_UNLOCKED ),DRM_IOCTL_DEF_DRV (I915_SET_SPRITE_COLORKEY , intel_sprite_set_colorkey,DRM_MASTER |DRM_CONTROL_ALLOW |DRM_UNLOCKED ),DRM_IOCTL_DEF_DRV (I915_GET_SPRITE_COLORKEY , intel_sprite_get_colorkey,DRM_MASTER |DRM_CONTROL_ALLOW |DRM_UNLOCKED ), + DRM_IOCTL_DEF_DRV(I915_GEM_WAIT, i915_gem_wait_ioctl, DRM_AUTH|DRM_UNLOCKED), };int i915_max_ioctl =DRM_ARRAY_SIZE (i915_ioctls);
drivers/gpu/drm/i915/i915_drv.h +2 -0
@@ -1226,6 +1226,8 @@ int i915_gem_get_tiling(struct drm_device *dev, void *data, struct drm_file *file_priv);int i915_gem_get_aperture_ioctl (struct drm_device *dev,void *data,struct drm_file *file_priv); +int i915_gem_wait_ioctl (struct drm_device *dev,void *data, +struct drm_file *file_priv);void i915_gem_load (struct drm_device *dev);int i915_gem_init_object (struct drm_gem_object *obj); int __must_check i915_gem_flush_ring(struct intel_ring_buffer *ring,
drivers/gpu/drm/i915/i915_gem.c +86 -0
92 lines not on this page · raw message
include/drm/i915_drm.h +10 -0
@@ -200,6 +200,7 @@ typedef struct _drm_i915_sarea {#define DRM_I915_GEM_EXECBUFFER2 0x29#define DRM_I915_GET_SPRITE_COLORKEY 0x2a#define DRM_I915_SET_SPRITE_COLORKEY 0x2b +#define DRM_I915_GEM_WAIT 0x2c#define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)#define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -243,6 +244,7 @@ typedef struct _drm_i915_sarea {#define DRM_IOCTL_I915_OVERLAY_ATTRS DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_OVERLAY_ATTRS, struct drm_intel_overlay_attrs)#define DRM_IOCTL_I915_SET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_SET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey)#define DRM_IOCTL_I915_GET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_SET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey) +#define DRM_IOCTL_I915_GEM_WAIT DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_WAIT, struct drm_i915_gem_wait)/* Allow drivers to submit batchbuffers directly to hardware, relying * on the security mechanisms provided by hardware.
@@ -886,4 +888,12 @@ struct drm_intel_sprite_colorkey { __u32 flags; }; +struct drm_i915_gem_wait { +/** Handle of BO we shall wait on */ +__u32 bo_handle; +__u32 flags; +/** Number of nanoseconds to wait, Returns time remaining. */ +__u64 timeout_ns; +}; +#endif /* _I915_DRM_H_ */
Signature · 1 line
1.7.10.2
Re: [PATCH 3/4 v7] drm/i915: wait render timeout ioctl
Quoted 26 lines · On Thu, 24 May 2012 15:03:10 -0700 Ben Widawsky <[email protected]> wrote:
This helps implement
GL_ARB_syncbut stops short of allowing full blown sync objects. Finally we can use the new timed seqno waiting function to allow userspace to wait on a buffer object with a timeout. This implements that interface.The IOCTL will take as input a buffer object handle, and a timeout in nanoseconds (flags is currently optional but will likely be used for permutations of flush operations). Users may specify 0 nanoseconds to instantly check.
The wait ioctl with a timeout of 0 reimplements the busy ioctl. With any non-zero timeout parameter the wait ioctl will wait for the given number of nanoseconds on an object becoming unbusy. Since the wait itself does so holding
struct_mutexthe object may become re-busied before this completes. A similar but shorter race condition exists in the busy ioctl.v2: ETIME/ERESTARTSYS instead of changing to EBUSY, and EGAIN (Chris) Flush the object from the gpu write domain (Chris + Daniel) Fix leaked refcount in good case (Chris)
Naturally align ioctl struct (Chris)v3: Drop lock after getting seqno to avoid ugly dance (Chris)
v4: check for 0 timeout after olr check to allow polling (Chris)
Quoted 7 lines
v5: Updated the comment. (Chris)
v6: Return
-ETIMEinstead of-EBUSYwhentimeout_nsis 0 (Daniel) Fix the commit message comment to be less ugly (Ben) Add a warning to check the return timespec (Ben)v7: Use
DRM_AUTHfor the ioctl. (Eugeni)
Please take v6 if you don't want the DRM_AUTH change.
Thanks.
Ben
Re: [PATCH 3/4 v7] drm/i915: wait render timeout ioctl
Quoted 29 lines · Ben Widawsky
Quoted 26 lines · On Thu, 24 May 2012 15:03:10 -0700 Ben Widawsky <[email protected]> wrote:
This helps implement
GL_ARB_syncbut stops short of allowing full blown sync objects. Finally we can use the new timed seqno waiting function to allow userspace to wait on a buffer object with a timeout. This implements that interface.The IOCTL will take as input a buffer object handle, and a timeout in nanoseconds (flags is currently optional but will likely be used for permutations of flush operations). Users may specify 0 nanoseconds to instantly check.
The wait ioctl with a timeout of 0 reimplements the busy ioctl. With any non-zero timeout parameter the wait ioctl will wait for the given number of nanoseconds on an object becoming unbusy. Since the wait itself does so holding
struct_mutexthe object may become re-busied before this completes. A similar but shorter race condition exists in the busy ioctl.v2: ETIME/ERESTARTSYS instead of changing to EBUSY, and EGAIN (Chris) Flush the object from the gpu write domain (Chris + Daniel) Fix leaked refcount in good case (Chris)
Naturally align ioctl struct (Chris)v3: Drop lock after getting seqno to avoid ugly dance (Chris)
v4: check for 0 timeout after olr check to allow polling (Chris)
Quoted 7 lines
Quoted 7 lines
v5: Updated the comment. (Chris)
v6: Return
-ETIMEinstead of-EBUSYwhentimeout_nsis 0 (Daniel) Fix the commit message comment to be less ugly (Ben) Add a warning to check the return timespec (Ben)v7: Use
DRM_AUTHfor the ioctl. (Eugeni)
So what Ben just reminded me was that we hadn't considered enabling an infinite non-blocking wait through this ioctl. That seems like a gross oversight to me...
-Chris
Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
PATCH RESEND 4/4 drm/i915: s/i915_wait_request/i915_wait_seqno/g
In reply to Ben WidawskyWait request is poorly named IMO. After working with these functions for some time, I feel it's much clearer to name the functions more appropriately.
Of course we must update the callers to use the new name as well.
This leaves room within our namespace for a *real* wait request function at some point.
Note to maintainer: this patch is optional.
--- drivers/gpu/drm/i915/i915_drv.h | 4 ++-- drivers/gpu/drm/i915/i915_gem.c | 9 ++++----- drivers/gpu/drm/i915/intel_overlay.c | 4 ++-- drivers/gpu/drm/i915/intel_ringbuffer.c | 2 +- 4 files changed, 9 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +2 -2
@@ -1312,8 +1312,8 @@ int __must_check i915_gem_idle(struct drm_device *dev);int __must_check i915_add_request (struct intel_ring_buffer *ring,struct drm_file *file,struct drm_i915_gem_request *request); -int __must_check i915_wait_request (struct intel_ring_buffer *ring, -uint32_t seqno); +int __must_check i915_wait_seqno (struct intel_ring_buffer *ring, +uint32_t seqno);int i915_gem_fault (struct vm_area_struct *vma,struct vm_fault *vmf); int __must_check i915_gem_object_set_to_gtt_domain(struct drm_i915_gem_object *obj,
drivers/gpu/drm/i915/i915_gem.c +4 -5
@@ -1951,8 +1951,7 @@ static int __wait_seqno(struct intel_ring_buffer *ring, u32 seqno,* request and object lists appropriately for that event. */ int -i915_wait_request (struct intel_ring_buffer *ring, -uint32_t seqno) +i915_wait_seqno (struct intel_ring_buffer *ring,uint32_t seqno) {drm_i915_private_t *dev_priv = ring->dev->dev_private;int ret =0 ;
@@ -1990,7 +1989,7 @@ i915_gem_object_wait_rendering(struct drm_i915_gem_object *obj)* it. */ if (obj->active) { - ret =i915_wait_request (obj->ring, obj->last_rendering_seqno); + ret =i915_wait_seqno (obj->ring, obj->last_rendering_seqno);if (ret)return ret;i915_gem_retire_requests_ring (obj->ring);
@@ -2263,7 +2262,7 @@ static int i915_ring_idle(struct intel_ring_buffer *ring)return ret; } -return i915_wait_request (ring,i915_gem_next_request_seqno (ring)); +return i915_wait_seqno (ring,i915_gem_next_request_seqno (ring)); }int i915_gpu_idle (struct drm_device *dev)
@@ -2462,7 +2461,7 @@ i915_gem_object_flush_fence(struct drm_i915_gem_object *obj) }if (obj->last_fenced_seqno) { - ret =i915_wait_request (obj->ring, obj->last_fenced_seqno); + ret =i915_wait_seqno (obj->ring, obj->last_fenced_seqno);if (ret)return ret;
drivers/gpu/drm/i915/intel_overlay.c +2 -2
@@ -226,7 +226,7 @@ static int intel_overlay_do_wait_request(struct intel_overlay *overlay, } overlay->last_flip_req = request->seqno; overlay->flip_tail = tail; - ret =i915_wait_request (ring, overlay->last_flip_req); + ret =i915_wait_seqno (ring, overlay->last_flip_req);if (ret)return ret;i915_gem_retire_requests (dev);
@@ -452,7 +452,7 @@ static int intel_overlay_recover_from_interrupt(struct intel_overlay *overlay)if (overlay->last_flip_req ==0 )return 0 ; - ret =i915_wait_request (ring, overlay->last_flip_req); + ret =i915_wait_seqno (ring, overlay->last_flip_req);if (ret)return ret;i915_gem_retire_requests (dev);
drivers/gpu/drm/i915/intel_ringbuffer.c +1 -1
@@ -1085,7 +1085,7 @@ static int intel_ring_wait_seqno(struct intel_ring_buffer *ring, u32 seqno) was_interruptible = dev_priv->mm.interruptible; dev_priv->mm.interruptible = false; - ret =i915_wait_request (ring, seqno); + ret =i915_wait_seqno (ring, seqno); dev_priv->mm.interruptible = was_interruptible;if (!ret)
Signature · 1 line
1.7.10.2
Re: [PATCH 4/4] [RESEND] drm/i915: s/i915_wait_request/i915_wait_seqno/g
Quoted 6 lines · Ben Widawsky
Wait request is poorly named IMO. After working with these functions for some time, I feel it's much clearer to name the functions more appropriately.
Of course we must update the callers to use the new name as well.
Quoted 7 lines
This leaves room within our namespace for a *real* wait request function at some point.
Note to maintainer: this patch is optional.
Signed-off-by Ben Widawsky <[email protected]>Reviewed-by Eugeni Dodonov <[email protected]>
I've slurped in the entire series for -next, thanks for the patches. I'll look at the testcase some more over the w/e (I'll be a bit offline), I think we should pimp it with a few more cases.
Cheers, Daniel
Signature · 3 lines
Daniel Vetter Mail: [email protected] Mobile: +41 (0)79 365 57 48