| Message ID | 20240826170144.2492062-2-matthew.brost@intel.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | Split out dma fence array and invalidate media_gt TLBs in PT code | expand |
Am 26.08.24 um 19:01 schrieb Matthew Brost: > Useful to preallocate dma fence array and then arm in path of reclaim or > a dma fence. > > v2: > - s/arm/init (Christian) > - Drop !array warn (Christian) > > Cc: Sumit Semwal <sumit.semwal@linaro.org> > Cc: Christian König <christian.koenig@amd.com> > Signed-off-by: Matthew Brost <matthew.brost@intel.com> Reviewed-by: Christian König <christian.koenig@amd.com> > --- > drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- > include/linux/dma-fence-array.h | 6 +++ > 2 files changed, 63 insertions(+), 21 deletions(-) > > diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c > index c74ac197d5fe..0659e6b29b3c 100644 > --- a/drivers/dma-buf/dma-fence-array.c > +++ b/drivers/dma-buf/dma-fence-array.c > @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { > EXPORT_SYMBOL(dma_fence_array_ops); > > /** > - * dma_fence_array_create - Create a custom fence array > + * dma_fence_array_alloc - Allocate a custom fence array > + * @num_fences: [in] number of fences to add in the array > + * > + * Return dma fence array on success, NULL on failure > + */ > +struct dma_fence_array *dma_fence_array_alloc(int num_fences) > +{ > + struct dma_fence_array *array; > + > + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > +} > +EXPORT_SYMBOL(dma_fence_array_alloc); > + > +/** > + * dma_fence_array_init - Arm a custom fence array > + * @array: [in] dma fence array to arm > * @num_fences: [in] number of fences to add in the array > * @fences: [in] array containing the fences > * @context: [in] fence context to use > * @seqno: [in] sequence number to use > * @signal_on_any: [in] signal on any fence in the array > * > - * Allocate a dma_fence_array object and initialize the base fence with > - * dma_fence_init(). > - * In case of error it returns NULL. > - * > - * The caller should allocate the fences array with num_fences size > - * and fill it with the fences it wants to add to the object. Ownership of this > - * array is taken and dma_fence_put() is used on each fence on release. > - * > - * If @signal_on_any is true the fence array signals if any fence in the array > - * signals, otherwise it signals when all fences in the array signal. > + * Implementation of @dma_fence_array_create without allocation. Useful to arm a > + * preallocated dma fence fence in the path of reclaim or dma fence signaling. > */ > -struct dma_fence_array *dma_fence_array_create(int num_fences, > - struct dma_fence **fences, > - u64 context, unsigned seqno, > - bool signal_on_any) > +void dma_fence_array_init(struct dma_fence_array *array, > + int num_fences, struct dma_fence **fences, > + u64 context, unsigned seqno, > + bool signal_on_any) > { > - struct dma_fence_array *array; > - > WARN_ON(!num_fences || !fences); > > - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > - if (!array) > - return NULL; > - > array->num_fences = num_fences; > > spin_lock_init(&array->lock); > @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, > */ > while (num_fences--) > WARN_ON(dma_fence_is_container(fences[num_fences])); > +} > +EXPORT_SYMBOL(dma_fence_array_init); > + > +/** > + * dma_fence_array_create - Create a custom fence array > + * @num_fences: [in] number of fences to add in the array > + * @fences: [in] array containing the fences > + * @context: [in] fence context to use > + * @seqno: [in] sequence number to use > + * @signal_on_any: [in] signal on any fence in the array > + * > + * Allocate a dma_fence_array object and initialize the base fence with > + * dma_fence_init(). > + * In case of error it returns NULL. > + * > + * The caller should allocate the fences array with num_fences size > + * and fill it with the fences it wants to add to the object. Ownership of this > + * array is taken and dma_fence_put() is used on each fence on release. > + * > + * If @signal_on_any is true the fence array signals if any fence in the array > + * signals, otherwise it signals when all fences in the array signal. > + */ > +struct dma_fence_array *dma_fence_array_create(int num_fences, > + struct dma_fence **fences, > + u64 context, unsigned seqno, > + bool signal_on_any) > +{ > + struct dma_fence_array *array; > + > + array = dma_fence_array_alloc(num_fences); > + if (!array) > + return NULL; > + > + dma_fence_array_init(array, num_fences, fences, > + context, seqno, signal_on_any); > > return array; > } > diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h > index 29c5650c1038..079b3dec0a16 100644 > --- a/include/linux/dma-fence-array.h > +++ b/include/linux/dma-fence-array.h > @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) > for (index = 0, fence = dma_fence_array_first(head); fence; \ > ++(index), fence = dma_fence_array_next(head, index)) > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences); > +void dma_fence_array_init(struct dma_fence_array *array, > + int num_fences, struct dma_fence **fences, > + u64 context, unsigned seqno, > + bool signal_on_any); > + > struct dma_fence_array *dma_fence_array_create(int num_fences, > struct dma_fence **fences, > u64 context, unsigned seqno,
On Mon, Aug 26, 2024 at 07:57:07PM +0200, Christian König wrote: > Am 26.08.24 um 19:01 schrieb Matthew Brost: > > Useful to preallocate dma fence array and then arm in path of reclaim or > > a dma fence. > > > > v2: > > - s/arm/init (Christian) > > - Drop !array warn (Christian) > > > > Cc: Sumit Semwal <sumit.semwal@linaro.org> > > Cc: Christian König <christian.koenig@amd.com> > > Signed-off-by: Matthew Brost <matthew.brost@intel.com> > > Reviewed-by: Christian König <christian.koenig@amd.com> Thanks for the review. Unfamilar with the merge flows to dma-buf subsystem. Do you merge this into a dma-buf branch that we can then pick up in 6.12? Matt > > > --- > > drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- > > include/linux/dma-fence-array.h | 6 +++ > > 2 files changed, 63 insertions(+), 21 deletions(-) > > > > diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c > > index c74ac197d5fe..0659e6b29b3c 100644 > > --- a/drivers/dma-buf/dma-fence-array.c > > +++ b/drivers/dma-buf/dma-fence-array.c > > @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { > > EXPORT_SYMBOL(dma_fence_array_ops); > > /** > > - * dma_fence_array_create - Create a custom fence array > > + * dma_fence_array_alloc - Allocate a custom fence array > > + * @num_fences: [in] number of fences to add in the array > > + * > > + * Return dma fence array on success, NULL on failure > > + */ > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences) > > +{ > > + struct dma_fence_array *array; > > + > > + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > +} > > +EXPORT_SYMBOL(dma_fence_array_alloc); > > + > > +/** > > + * dma_fence_array_init - Arm a custom fence array > > + * @array: [in] dma fence array to arm > > * @num_fences: [in] number of fences to add in the array > > * @fences: [in] array containing the fences > > * @context: [in] fence context to use > > * @seqno: [in] sequence number to use > > * @signal_on_any: [in] signal on any fence in the array > > * > > - * Allocate a dma_fence_array object and initialize the base fence with > > - * dma_fence_init(). > > - * In case of error it returns NULL. > > - * > > - * The caller should allocate the fences array with num_fences size > > - * and fill it with the fences it wants to add to the object. Ownership of this > > - * array is taken and dma_fence_put() is used on each fence on release. > > - * > > - * If @signal_on_any is true the fence array signals if any fence in the array > > - * signals, otherwise it signals when all fences in the array signal. > > + * Implementation of @dma_fence_array_create without allocation. Useful to arm a > > + * preallocated dma fence fence in the path of reclaim or dma fence signaling. > > */ > > -struct dma_fence_array *dma_fence_array_create(int num_fences, > > - struct dma_fence **fences, > > - u64 context, unsigned seqno, > > - bool signal_on_any) > > +void dma_fence_array_init(struct dma_fence_array *array, > > + int num_fences, struct dma_fence **fences, > > + u64 context, unsigned seqno, > > + bool signal_on_any) > > { > > - struct dma_fence_array *array; > > - > > WARN_ON(!num_fences || !fences); > > - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > - if (!array) > > - return NULL; > > - > > array->num_fences = num_fences; > > spin_lock_init(&array->lock); > > @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, > > */ > > while (num_fences--) > > WARN_ON(dma_fence_is_container(fences[num_fences])); > > +} > > +EXPORT_SYMBOL(dma_fence_array_init); > > + > > +/** > > + * dma_fence_array_create - Create a custom fence array > > + * @num_fences: [in] number of fences to add in the array > > + * @fences: [in] array containing the fences > > + * @context: [in] fence context to use > > + * @seqno: [in] sequence number to use > > + * @signal_on_any: [in] signal on any fence in the array > > + * > > + * Allocate a dma_fence_array object and initialize the base fence with > > + * dma_fence_init(). > > + * In case of error it returns NULL. > > + * > > + * The caller should allocate the fences array with num_fences size > > + * and fill it with the fences it wants to add to the object. Ownership of this > > + * array is taken and dma_fence_put() is used on each fence on release. > > + * > > + * If @signal_on_any is true the fence array signals if any fence in the array > > + * signals, otherwise it signals when all fences in the array signal. > > + */ > > +struct dma_fence_array *dma_fence_array_create(int num_fences, > > + struct dma_fence **fences, > > + u64 context, unsigned seqno, > > + bool signal_on_any) > > +{ > > + struct dma_fence_array *array; > > + > > + array = dma_fence_array_alloc(num_fences); > > + if (!array) > > + return NULL; > > + > > + dma_fence_array_init(array, num_fences, fences, > > + context, seqno, signal_on_any); > > return array; > > } > > diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h > > index 29c5650c1038..079b3dec0a16 100644 > > --- a/include/linux/dma-fence-array.h > > +++ b/include/linux/dma-fence-array.h > > @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) > > for (index = 0, fence = dma_fence_array_first(head); fence; \ > > ++(index), fence = dma_fence_array_next(head, index)) > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences); > > +void dma_fence_array_init(struct dma_fence_array *array, > > + int num_fences, struct dma_fence **fences, > > + u64 context, unsigned seqno, > > + bool signal_on_any); > > + > > struct dma_fence_array *dma_fence_array_create(int num_fences, > > struct dma_fence **fences, > > u64 context, unsigned seqno, >
Am 26.08.24 um 21:23 schrieb Matthew Brost: > On Mon, Aug 26, 2024 at 07:57:07PM +0200, Christian König wrote: >> Am 26.08.24 um 19:01 schrieb Matthew Brost: >>> Useful to preallocate dma fence array and then arm in path of reclaim or >>> a dma fence. >>> >>> v2: >>> - s/arm/init (Christian) >>> - Drop !array warn (Christian) >>> >>> Cc: Sumit Semwal <sumit.semwal@linaro.org> >>> Cc: Christian König <christian.koenig@amd.com> >>> Signed-off-by: Matthew Brost <matthew.brost@intel.com> >> Reviewed-by: Christian König <christian.koenig@amd.com> > Thanks for the review. > > Unfamilar with the merge flows to dma-buf subsystem. Do you merge this > into a dma-buf branch that we can then pick up in 6.12? I can push the patches into drm-misc-next or alternatively you pick them up through an XE branch. The change to the dma_fence_array is small enough that it probably won't cause any conflict, so both approaches works for me. Christian. > > Matt > >>> --- >>> drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- >>> include/linux/dma-fence-array.h | 6 +++ >>> 2 files changed, 63 insertions(+), 21 deletions(-) >>> >>> diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c >>> index c74ac197d5fe..0659e6b29b3c 100644 >>> --- a/drivers/dma-buf/dma-fence-array.c >>> +++ b/drivers/dma-buf/dma-fence-array.c >>> @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { >>> EXPORT_SYMBOL(dma_fence_array_ops); >>> /** >>> - * dma_fence_array_create - Create a custom fence array >>> + * dma_fence_array_alloc - Allocate a custom fence array >>> + * @num_fences: [in] number of fences to add in the array >>> + * >>> + * Return dma fence array on success, NULL on failure >>> + */ >>> +struct dma_fence_array *dma_fence_array_alloc(int num_fences) >>> +{ >>> + struct dma_fence_array *array; >>> + >>> + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); >>> +} >>> +EXPORT_SYMBOL(dma_fence_array_alloc); >>> + >>> +/** >>> + * dma_fence_array_init - Arm a custom fence array >>> + * @array: [in] dma fence array to arm >>> * @num_fences: [in] number of fences to add in the array >>> * @fences: [in] array containing the fences >>> * @context: [in] fence context to use >>> * @seqno: [in] sequence number to use >>> * @signal_on_any: [in] signal on any fence in the array >>> * >>> - * Allocate a dma_fence_array object and initialize the base fence with >>> - * dma_fence_init(). >>> - * In case of error it returns NULL. >>> - * >>> - * The caller should allocate the fences array with num_fences size >>> - * and fill it with the fences it wants to add to the object. Ownership of this >>> - * array is taken and dma_fence_put() is used on each fence on release. >>> - * >>> - * If @signal_on_any is true the fence array signals if any fence in the array >>> - * signals, otherwise it signals when all fences in the array signal. >>> + * Implementation of @dma_fence_array_create without allocation. Useful to arm a >>> + * preallocated dma fence fence in the path of reclaim or dma fence signaling. >>> */ >>> -struct dma_fence_array *dma_fence_array_create(int num_fences, >>> - struct dma_fence **fences, >>> - u64 context, unsigned seqno, >>> - bool signal_on_any) >>> +void dma_fence_array_init(struct dma_fence_array *array, >>> + int num_fences, struct dma_fence **fences, >>> + u64 context, unsigned seqno, >>> + bool signal_on_any) >>> { >>> - struct dma_fence_array *array; >>> - >>> WARN_ON(!num_fences || !fences); >>> - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); >>> - if (!array) >>> - return NULL; >>> - >>> array->num_fences = num_fences; >>> spin_lock_init(&array->lock); >>> @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, >>> */ >>> while (num_fences--) >>> WARN_ON(dma_fence_is_container(fences[num_fences])); >>> +} >>> +EXPORT_SYMBOL(dma_fence_array_init); >>> + >>> +/** >>> + * dma_fence_array_create - Create a custom fence array >>> + * @num_fences: [in] number of fences to add in the array >>> + * @fences: [in] array containing the fences >>> + * @context: [in] fence context to use >>> + * @seqno: [in] sequence number to use >>> + * @signal_on_any: [in] signal on any fence in the array >>> + * >>> + * Allocate a dma_fence_array object and initialize the base fence with >>> + * dma_fence_init(). >>> + * In case of error it returns NULL. >>> + * >>> + * The caller should allocate the fences array with num_fences size >>> + * and fill it with the fences it wants to add to the object. Ownership of this >>> + * array is taken and dma_fence_put() is used on each fence on release. >>> + * >>> + * If @signal_on_any is true the fence array signals if any fence in the array >>> + * signals, otherwise it signals when all fences in the array signal. >>> + */ >>> +struct dma_fence_array *dma_fence_array_create(int num_fences, >>> + struct dma_fence **fences, >>> + u64 context, unsigned seqno, >>> + bool signal_on_any) >>> +{ >>> + struct dma_fence_array *array; >>> + >>> + array = dma_fence_array_alloc(num_fences); >>> + if (!array) >>> + return NULL; >>> + >>> + dma_fence_array_init(array, num_fences, fences, >>> + context, seqno, signal_on_any); >>> return array; >>> } >>> diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h >>> index 29c5650c1038..079b3dec0a16 100644 >>> --- a/include/linux/dma-fence-array.h >>> +++ b/include/linux/dma-fence-array.h >>> @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) >>> for (index = 0, fence = dma_fence_array_first(head); fence; \ >>> ++(index), fence = dma_fence_array_next(head, index)) >>> +struct dma_fence_array *dma_fence_array_alloc(int num_fences); >>> +void dma_fence_array_init(struct dma_fence_array *array, >>> + int num_fences, struct dma_fence **fences, >>> + u64 context, unsigned seqno, >>> + bool signal_on_any); >>> + >>> struct dma_fence_array *dma_fence_array_create(int num_fences, >>> struct dma_fence **fences, >>> u64 context, unsigned seqno,
On Tue, Aug 27, 2024 at 08:37:56AM +0200, Christian König wrote: > Am 26.08.24 um 21:23 schrieb Matthew Brost: > > On Mon, Aug 26, 2024 at 07:57:07PM +0200, Christian König wrote: > > > Am 26.08.24 um 19:01 schrieb Matthew Brost: > > > > Useful to preallocate dma fence array and then arm in path of reclaim or > > > > a dma fence. > > > > > > > > v2: > > > > - s/arm/init (Christian) > > > > - Drop !array warn (Christian) > > > > > > > > Cc: Sumit Semwal <sumit.semwal@linaro.org> > > > > Cc: Christian König <christian.koenig@amd.com> > > > > Signed-off-by: Matthew Brost <matthew.brost@intel.com> > > > Reviewed-by: Christian König <christian.koenig@amd.com> > > Thanks for the review. > > > > Unfamilar with the merge flows to dma-buf subsystem. Do you merge this > > into a dma-buf branch that we can then pick up in 6.12? > > I can push the patches into drm-misc-next or alternatively you pick them up > through an XE branch. > > The change to the dma_fence_array is small enough that it probably won't > cause any conflict, so both approaches works for me. > Once I have a review on patch number 2, I'll go ahead and merge to drm-xe-next. Will also reply here once that has happened. Matt > Christian. > > > > > Matt > > > > > > --- > > > > drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- > > > > include/linux/dma-fence-array.h | 6 +++ > > > > 2 files changed, 63 insertions(+), 21 deletions(-) > > > > > > > > diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c > > > > index c74ac197d5fe..0659e6b29b3c 100644 > > > > --- a/drivers/dma-buf/dma-fence-array.c > > > > +++ b/drivers/dma-buf/dma-fence-array.c > > > > @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { > > > > EXPORT_SYMBOL(dma_fence_array_ops); > > > > /** > > > > - * dma_fence_array_create - Create a custom fence array > > > > + * dma_fence_array_alloc - Allocate a custom fence array > > > > + * @num_fences: [in] number of fences to add in the array > > > > + * > > > > + * Return dma fence array on success, NULL on failure > > > > + */ > > > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences) > > > > +{ > > > > + struct dma_fence_array *array; > > > > + > > > > + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > > > +} > > > > +EXPORT_SYMBOL(dma_fence_array_alloc); > > > > + > > > > +/** > > > > + * dma_fence_array_init - Arm a custom fence array > > > > + * @array: [in] dma fence array to arm > > > > * @num_fences: [in] number of fences to add in the array > > > > * @fences: [in] array containing the fences > > > > * @context: [in] fence context to use > > > > * @seqno: [in] sequence number to use > > > > * @signal_on_any: [in] signal on any fence in the array > > > > * > > > > - * Allocate a dma_fence_array object and initialize the base fence with > > > > - * dma_fence_init(). > > > > - * In case of error it returns NULL. > > > > - * > > > > - * The caller should allocate the fences array with num_fences size > > > > - * and fill it with the fences it wants to add to the object. Ownership of this > > > > - * array is taken and dma_fence_put() is used on each fence on release. > > > > - * > > > > - * If @signal_on_any is true the fence array signals if any fence in the array > > > > - * signals, otherwise it signals when all fences in the array signal. > > > > + * Implementation of @dma_fence_array_create without allocation. Useful to arm a > > > > + * preallocated dma fence fence in the path of reclaim or dma fence signaling. > > > > */ > > > > -struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > - struct dma_fence **fences, > > > > - u64 context, unsigned seqno, > > > > - bool signal_on_any) > > > > +void dma_fence_array_init(struct dma_fence_array *array, > > > > + int num_fences, struct dma_fence **fences, > > > > + u64 context, unsigned seqno, > > > > + bool signal_on_any) > > > > { > > > > - struct dma_fence_array *array; > > > > - > > > > WARN_ON(!num_fences || !fences); > > > > - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > > > - if (!array) > > > > - return NULL; > > > > - > > > > array->num_fences = num_fences; > > > > spin_lock_init(&array->lock); > > > > @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > */ > > > > while (num_fences--) > > > > WARN_ON(dma_fence_is_container(fences[num_fences])); > > > > +} > > > > +EXPORT_SYMBOL(dma_fence_array_init); > > > > + > > > > +/** > > > > + * dma_fence_array_create - Create a custom fence array > > > > + * @num_fences: [in] number of fences to add in the array > > > > + * @fences: [in] array containing the fences > > > > + * @context: [in] fence context to use > > > > + * @seqno: [in] sequence number to use > > > > + * @signal_on_any: [in] signal on any fence in the array > > > > + * > > > > + * Allocate a dma_fence_array object and initialize the base fence with > > > > + * dma_fence_init(). > > > > + * In case of error it returns NULL. > > > > + * > > > > + * The caller should allocate the fences array with num_fences size > > > > + * and fill it with the fences it wants to add to the object. Ownership of this > > > > + * array is taken and dma_fence_put() is used on each fence on release. > > > > + * > > > > + * If @signal_on_any is true the fence array signals if any fence in the array > > > > + * signals, otherwise it signals when all fences in the array signal. > > > > + */ > > > > +struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > + struct dma_fence **fences, > > > > + u64 context, unsigned seqno, > > > > + bool signal_on_any) > > > > +{ > > > > + struct dma_fence_array *array; > > > > + > > > > + array = dma_fence_array_alloc(num_fences); > > > > + if (!array) > > > > + return NULL; > > > > + > > > > + dma_fence_array_init(array, num_fences, fences, > > > > + context, seqno, signal_on_any); > > > > return array; > > > > } > > > > diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h > > > > index 29c5650c1038..079b3dec0a16 100644 > > > > --- a/include/linux/dma-fence-array.h > > > > +++ b/include/linux/dma-fence-array.h > > > > @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) > > > > for (index = 0, fence = dma_fence_array_first(head); fence; \ > > > > ++(index), fence = dma_fence_array_next(head, index)) > > > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences); > > > > +void dma_fence_array_init(struct dma_fence_array *array, > > > > + int num_fences, struct dma_fence **fences, > > > > + u64 context, unsigned seqno, > > > > + bool signal_on_any); > > > > + > > > > struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > struct dma_fence **fences, > > > > u64 context, unsigned seqno, >
On Tue, Aug 27, 2024 at 04:10:31PM +0000, Matthew Brost wrote: > On Tue, Aug 27, 2024 at 08:37:56AM +0200, Christian König wrote: > > Am 26.08.24 um 21:23 schrieb Matthew Brost: > > > On Mon, Aug 26, 2024 at 07:57:07PM +0200, Christian König wrote: > > > > Am 26.08.24 um 19:01 schrieb Matthew Brost: > > > > > Useful to preallocate dma fence array and then arm in path of reclaim or > > > > > a dma fence. > > > > > > > > > > v2: > > > > > - s/arm/init (Christian) > > > > > - Drop !array warn (Christian) > > > > > > > > > > Cc: Sumit Semwal <sumit.semwal@linaro.org> > > > > > Cc: Christian König <christian.koenig@amd.com> > > > > > Signed-off-by: Matthew Brost <matthew.brost@intel.com> > > > > Reviewed-by: Christian König <christian.koenig@amd.com> > > > Thanks for the review. > > > > > > Unfamilar with the merge flows to dma-buf subsystem. Do you merge this > > > into a dma-buf branch that we can then pick up in 6.12? > > > > I can push the patches into drm-misc-next or alternatively you pick them up > > through an XE branch. > > > > The change to the dma_fence_array is small enough that it probably won't > > cause any conflict, so both approaches works for me. > > > > Once I have a review on patch number 2, I'll go ahead and merge to > drm-xe-next. Will also reply here once that has happened. > Merged to drm-xe-next. Matt > Matt > > > Christian. > > > > > > > > Matt > > > > > > > > --- > > > > > drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- > > > > > include/linux/dma-fence-array.h | 6 +++ > > > > > 2 files changed, 63 insertions(+), 21 deletions(-) > > > > > > > > > > diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c > > > > > index c74ac197d5fe..0659e6b29b3c 100644 > > > > > --- a/drivers/dma-buf/dma-fence-array.c > > > > > +++ b/drivers/dma-buf/dma-fence-array.c > > > > > @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { > > > > > EXPORT_SYMBOL(dma_fence_array_ops); > > > > > /** > > > > > - * dma_fence_array_create - Create a custom fence array > > > > > + * dma_fence_array_alloc - Allocate a custom fence array > > > > > + * @num_fences: [in] number of fences to add in the array > > > > > + * > > > > > + * Return dma fence array on success, NULL on failure > > > > > + */ > > > > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences) > > > > > +{ > > > > > + struct dma_fence_array *array; > > > > > + > > > > > + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > > > > +} > > > > > +EXPORT_SYMBOL(dma_fence_array_alloc); > > > > > + > > > > > +/** > > > > > + * dma_fence_array_init - Arm a custom fence array > > > > > + * @array: [in] dma fence array to arm > > > > > * @num_fences: [in] number of fences to add in the array > > > > > * @fences: [in] array containing the fences > > > > > * @context: [in] fence context to use > > > > > * @seqno: [in] sequence number to use > > > > > * @signal_on_any: [in] signal on any fence in the array > > > > > * > > > > > - * Allocate a dma_fence_array object and initialize the base fence with > > > > > - * dma_fence_init(). > > > > > - * In case of error it returns NULL. > > > > > - * > > > > > - * The caller should allocate the fences array with num_fences size > > > > > - * and fill it with the fences it wants to add to the object. Ownership of this > > > > > - * array is taken and dma_fence_put() is used on each fence on release. > > > > > - * > > > > > - * If @signal_on_any is true the fence array signals if any fence in the array > > > > > - * signals, otherwise it signals when all fences in the array signal. > > > > > + * Implementation of @dma_fence_array_create without allocation. Useful to arm a > > > > > + * preallocated dma fence fence in the path of reclaim or dma fence signaling. > > > > > */ > > > > > -struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > > - struct dma_fence **fences, > > > > > - u64 context, unsigned seqno, > > > > > - bool signal_on_any) > > > > > +void dma_fence_array_init(struct dma_fence_array *array, > > > > > + int num_fences, struct dma_fence **fences, > > > > > + u64 context, unsigned seqno, > > > > > + bool signal_on_any) > > > > > { > > > > > - struct dma_fence_array *array; > > > > > - > > > > > WARN_ON(!num_fences || !fences); > > > > > - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); > > > > > - if (!array) > > > > > - return NULL; > > > > > - > > > > > array->num_fences = num_fences; > > > > > spin_lock_init(&array->lock); > > > > > @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > > */ > > > > > while (num_fences--) > > > > > WARN_ON(dma_fence_is_container(fences[num_fences])); > > > > > +} > > > > > +EXPORT_SYMBOL(dma_fence_array_init); > > > > > + > > > > > +/** > > > > > + * dma_fence_array_create - Create a custom fence array > > > > > + * @num_fences: [in] number of fences to add in the array > > > > > + * @fences: [in] array containing the fences > > > > > + * @context: [in] fence context to use > > > > > + * @seqno: [in] sequence number to use > > > > > + * @signal_on_any: [in] signal on any fence in the array > > > > > + * > > > > > + * Allocate a dma_fence_array object and initialize the base fence with > > > > > + * dma_fence_init(). > > > > > + * In case of error it returns NULL. > > > > > + * > > > > > + * The caller should allocate the fences array with num_fences size > > > > > + * and fill it with the fences it wants to add to the object. Ownership of this > > > > > + * array is taken and dma_fence_put() is used on each fence on release. > > > > > + * > > > > > + * If @signal_on_any is true the fence array signals if any fence in the array > > > > > + * signals, otherwise it signals when all fences in the array signal. > > > > > + */ > > > > > +struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > > + struct dma_fence **fences, > > > > > + u64 context, unsigned seqno, > > > > > + bool signal_on_any) > > > > > +{ > > > > > + struct dma_fence_array *array; > > > > > + > > > > > + array = dma_fence_array_alloc(num_fences); > > > > > + if (!array) > > > > > + return NULL; > > > > > + > > > > > + dma_fence_array_init(array, num_fences, fences, > > > > > + context, seqno, signal_on_any); > > > > > return array; > > > > > } > > > > > diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h > > > > > index 29c5650c1038..079b3dec0a16 100644 > > > > > --- a/include/linux/dma-fence-array.h > > > > > +++ b/include/linux/dma-fence-array.h > > > > > @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) > > > > > for (index = 0, fence = dma_fence_array_first(head); fence; \ > > > > > ++(index), fence = dma_fence_array_next(head, index)) > > > > > +struct dma_fence_array *dma_fence_array_alloc(int num_fences); > > > > > +void dma_fence_array_init(struct dma_fence_array *array, > > > > > + int num_fences, struct dma_fence **fences, > > > > > + u64 context, unsigned seqno, > > > > > + bool signal_on_any); > > > > > + > > > > > struct dma_fence_array *dma_fence_array_create(int num_fences, > > > > > struct dma_fence **fences, > > > > > u64 context, unsigned seqno, > >
diff --git a/drivers/dma-buf/dma-fence-array.c b/drivers/dma-buf/dma-fence-array.c index c74ac197d5fe..0659e6b29b3c 100644 --- a/drivers/dma-buf/dma-fence-array.c +++ b/drivers/dma-buf/dma-fence-array.c @@ -144,37 +144,38 @@ const struct dma_fence_ops dma_fence_array_ops = { EXPORT_SYMBOL(dma_fence_array_ops); /** - * dma_fence_array_create - Create a custom fence array + * dma_fence_array_alloc - Allocate a custom fence array + * @num_fences: [in] number of fences to add in the array + * + * Return dma fence array on success, NULL on failure + */ +struct dma_fence_array *dma_fence_array_alloc(int num_fences) +{ + struct dma_fence_array *array; + + return kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); +} +EXPORT_SYMBOL(dma_fence_array_alloc); + +/** + * dma_fence_array_init - Arm a custom fence array + * @array: [in] dma fence array to arm * @num_fences: [in] number of fences to add in the array * @fences: [in] array containing the fences * @context: [in] fence context to use * @seqno: [in] sequence number to use * @signal_on_any: [in] signal on any fence in the array * - * Allocate a dma_fence_array object and initialize the base fence with - * dma_fence_init(). - * In case of error it returns NULL. - * - * The caller should allocate the fences array with num_fences size - * and fill it with the fences it wants to add to the object. Ownership of this - * array is taken and dma_fence_put() is used on each fence on release. - * - * If @signal_on_any is true the fence array signals if any fence in the array - * signals, otherwise it signals when all fences in the array signal. + * Implementation of @dma_fence_array_create without allocation. Useful to arm a + * preallocated dma fence fence in the path of reclaim or dma fence signaling. */ -struct dma_fence_array *dma_fence_array_create(int num_fences, - struct dma_fence **fences, - u64 context, unsigned seqno, - bool signal_on_any) +void dma_fence_array_init(struct dma_fence_array *array, + int num_fences, struct dma_fence **fences, + u64 context, unsigned seqno, + bool signal_on_any) { - struct dma_fence_array *array; - WARN_ON(!num_fences || !fences); - array = kzalloc(struct_size(array, callbacks, num_fences), GFP_KERNEL); - if (!array) - return NULL; - array->num_fences = num_fences; spin_lock_init(&array->lock); @@ -200,6 +201,41 @@ struct dma_fence_array *dma_fence_array_create(int num_fences, */ while (num_fences--) WARN_ON(dma_fence_is_container(fences[num_fences])); +} +EXPORT_SYMBOL(dma_fence_array_init); + +/** + * dma_fence_array_create - Create a custom fence array + * @num_fences: [in] number of fences to add in the array + * @fences: [in] array containing the fences + * @context: [in] fence context to use + * @seqno: [in] sequence number to use + * @signal_on_any: [in] signal on any fence in the array + * + * Allocate a dma_fence_array object and initialize the base fence with + * dma_fence_init(). + * In case of error it returns NULL. + * + * The caller should allocate the fences array with num_fences size + * and fill it with the fences it wants to add to the object. Ownership of this + * array is taken and dma_fence_put() is used on each fence on release. + * + * If @signal_on_any is true the fence array signals if any fence in the array + * signals, otherwise it signals when all fences in the array signal. + */ +struct dma_fence_array *dma_fence_array_create(int num_fences, + struct dma_fence **fences, + u64 context, unsigned seqno, + bool signal_on_any) +{ + struct dma_fence_array *array; + + array = dma_fence_array_alloc(num_fences); + if (!array) + return NULL; + + dma_fence_array_init(array, num_fences, fences, + context, seqno, signal_on_any); return array; } diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h index 29c5650c1038..079b3dec0a16 100644 --- a/include/linux/dma-fence-array.h +++ b/include/linux/dma-fence-array.h @@ -79,6 +79,12 @@ to_dma_fence_array(struct dma_fence *fence) for (index = 0, fence = dma_fence_array_first(head); fence; \ ++(index), fence = dma_fence_array_next(head, index)) +struct dma_fence_array *dma_fence_array_alloc(int num_fences); +void dma_fence_array_init(struct dma_fence_array *array, + int num_fences, struct dma_fence **fences, + u64 context, unsigned seqno, + bool signal_on_any); + struct dma_fence_array *dma_fence_array_create(int num_fences, struct dma_fence **fences, u64 context, unsigned seqno,
Useful to preallocate dma fence array and then arm in path of reclaim or a dma fence. v2: - s/arm/init (Christian) - Drop !array warn (Christian) Cc: Sumit Semwal <sumit.semwal@linaro.org> Cc: Christian König <christian.koenig@amd.com> Signed-off-by: Matthew Brost <matthew.brost@intel.com> --- drivers/dma-buf/dma-fence-array.c | 78 ++++++++++++++++++++++--------- include/linux/dma-fence-array.h | 6 +++ 2 files changed, 63 insertions(+), 21 deletions(-)