On 11/9/26 02:48, Yu, Fei wrote: > From: Fei Yu <[email protected]> > > The syncobj ioctls allocate several temporary arrays whose size is taken > directly from the u32 count_handles provided by userspace: > > - handles and syncobjs in drm_syncobj_array_find() > - points and entries in drm_syncobj_array_wait_timeout() > - points and chains in drm_syncobj_timeline_signal_ioctl() > > These are kmalloc() allocations, so a count above KMALLOC_MAX_SIZE / > element size trips the WARN_ON_ONCE_GFP() in ___kmalloc_large_node(): > > WARNING: mm/slub.c:5459 at ___kmalloc_large_node+0x10c/0x170 mm/slub.c:5459 > Call Trace: > __kmalloc_large_node_noprof+0x18/0x90 mm/slub.c:5502 > __do_kmalloc_node mm/slub.c:5519 [inline] > __kmalloc_noprof+0x3f6/0x710 mm/slub.c:5556 > _kmalloc_noprof include/linux/slab.h:995 [inline] > _kmalloc_array_noprof include/linux/slab.h:1211 [inline] > drm_syncobj_array_find+0x3a/0x440 drivers/gpu/drm/drm_syncobj.c:1241 > drm_syncobj_timeline_wait_ioctl+0x18a/0x640 > drivers/gpu/drm/drm_syncobj.c:1356 > drm_ioctl_kernel+0x2df/0x3b0 drivers/gpu/drm/drm_ioctl.c:817 > drm_ioctl+0x70e/0xba0 drivers/gpu/drm/drm_ioctl.c:914 > > The wait entries are 64 bytes each on 64-bit, so with a 4 MiB > KMALLOC_MAX_SIZE a wait on more than about 64K handles already fails > today, with a warning. > > Fix this in two parts: > > - Reject more than DRM_SYNCOBJ_MAX_HANDLES (1M) handles with -EINVAL in > drm_syncobj_array_find(), which every ioctl taking a handle array goes > through. The limit is a fixed number, so it is the same on all > architectures. It is above what these ioctls can handle today: with a > 4 MiB KMALLOC_MAX_SIZE the 8-byte arrays already fail above 512K > handles on 64-bit, so no request that succeeds now is rejected. A > static_assert() makes sure that the largest per-handle allocation, the > wait entries, stays below the INT_MAX size limit of kvmalloc(). > > - Switch the six allocations to kvmalloc(), so that handle counts up to > the limit (64 MiB of wait entries for 1M handles) no longer depend on > physically contiguous memory. > > Using kvmalloc() alone is not enough: the reproducer asks for more than > INT_MAX bytes, which hits the WARN_ON_ONCE() in __kvmalloc_node_noprof() > instead. > > Fixes: 3e6fb72d6cef ("drm/syncobj: Add a syncobj_array_find helper") > Reported-by: [email protected] > Closes: https://syzkaller.appspot.com/bug?extid=95416f957d84e858b377 > Suggested-by: Christian König <[email protected]> > Cc: [email protected] > Signed-off-by: Fei Yu <[email protected]>
Reviewed-by: Christian König <[email protected]> Let me know if you need somebody to push this to drm-misc-next. Regards, Christian. > --- > v3: > - Use a fixed DRM_SYNCOBJ_MAX_HANDLES of SZ_1M instead of deriving it from > sizeof(struct syncobj_wait_entry), so the limit is the same on 32-bit > and 64-bit, and add a static_assert() against the kvmalloc() INT_MAX > limit (Christian). > - 1M rather than 64K: with a 4 MiB KMALLOC_MAX_SIZE, reset, signal, query > and timeline_signal currently work up to 512K handles on 64-bit, so a > 64K limit would turn requests that work today into -EINVAL. > - Keep the define kernel internal for -fixes; documenting the limit in > the uAPI struct comments will be a separate patch for -next. > - Add Cc: stable. > - v2: https://lore.kernel.org/all/[email protected]/ > > v2: > - Drop __GFP_NOWARN (Christian). > - Add DRM_SYNCOBJ_MAX_HANDLES, return -EINVAL above it, and switch all six > arrays to kvmalloc() (Christian). > - v1: https://lore.kernel.org/all/[email protected]/ > > The vmemdup_array_user() conversion and the points array cleanup Christian > pointed out are left to Tvrtko's series, which he will rebase on top of > this fix for -next. > > Testing on v7.4-rc1 (x86_64, KASAN, virtio-gpu in QEMU): > - syzbot C reproducer: base warns in ___kmalloc_large_node(), patched is > clean, the ioctl returns -EINVAL. > - 1048576 signaled syncobjs; wait, timeline_wait, timeline_signal, query, > reset and signal with count 200000, 1M and 1M + 1: > base: 200000: wait and timeline_wait fail with -ENOMEM and the > warning, the others succeed. 1M: all six fail with -ENOMEM. > patched: 200000 and 1M: all succeed. 1M + 1: all return -EINVAL. > - drm_syncobj.o builds for i386 with W=1 (static_assert holds). > - checkpatch --strict clean, W=1 clean, kmemleak clean, > DRM KUnit 667/667 passed. > - IGT syncobj_basic, syncobj_wait, syncobj_timeline on virtio-gpu: > 202/202 subtests pass, same as base. > > drivers/gpu/drm/drm_syncobj.c | 44 +++++++++++++++++++++++------------ > 1 file changed, 29 insertions(+), 15 deletions(-) > > diff --git a/drivers/gpu/drm/drm_syncobj.c b/drivers/gpu/drm/drm_syncobj.c > index f1d4da168545..c8a8c49d12fb 100644 > --- a/drivers/gpu/drm/drm_syncobj.c > +++ b/drivers/gpu/drm/drm_syncobj.c > @@ -199,6 +199,7 @@ > #include <linux/file.h> > #include <linux/fs.h> > #include <linux/sched/signal.h> > +#include <linux/sizes.h> > #include <linux/sync_file.h> > #include <linux/uaccess.h> > > @@ -220,6 +221,16 @@ struct syncobj_wait_entry { > u64 point; > }; > > +/* > + * Upper limit for the number of handles passed to a single ioctl. This is a > + * fixed number so that the limit is the same on all architectures. The > + * largest per-handle allocation is the wait entry array, which must stay > + * below the INT_MAX size limit of kvmalloc(). > + */ > +#define DRM_SYNCOBJ_MAX_HANDLES SZ_1M > +static_assert(DRM_SYNCOBJ_MAX_HANDLES <= > + INT_MAX / sizeof(struct syncobj_wait_entry)); > + > static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj, > struct syncobj_wait_entry *wait); > > @@ -1051,7 +1062,7 @@ static signed long > drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, > lockdep_assert_none_held_once(); > } > > - points = kmalloc_array(count, sizeof(*points), GFP_KERNEL); > + points = kvmalloc_array(count, sizeof(*points), GFP_KERNEL); > if (points == NULL) > return -ENOMEM; > > @@ -1064,7 +1075,7 @@ static signed long > drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, > goto err_free_points; > } > > - entries = kzalloc_objs(*entries, count); > + entries = kvzalloc_objs(*entries, count); > if (!entries) { > timeout = -ENOMEM; > goto err_free_points; > @@ -1185,10 +1196,10 @@ static signed long > drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, > &entries[i].fence_cb); > dma_fence_put(entries[i].fence); > } > - kfree(entries); > + kvfree(entries); > > err_free_points: > - kfree(points); > + kvfree(points); > > return timeout; > } > @@ -1238,7 +1249,10 @@ static int drm_syncobj_array_find(struct drm_file > *file_private, > struct drm_syncobj **syncobjs; > int ret; > > - handles = kmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL); > + if (count_handles > DRM_SYNCOBJ_MAX_HANDLES) > + return -EINVAL; > + > + handles = kvmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL); > if (handles == NULL) > return -ENOMEM; > > @@ -1248,7 +1262,7 @@ static int drm_syncobj_array_find(struct drm_file > *file_private, > goto err_free_handles; > } > > - syncobjs = kmalloc_objs(*syncobjs, count_handles); > + syncobjs = kvmalloc_objs(*syncobjs, count_handles); > if (syncobjs == NULL) { > ret = -ENOMEM; > goto err_free_handles; > @@ -1262,16 +1276,16 @@ static int drm_syncobj_array_find(struct drm_file > *file_private, > } > } > > - kfree(handles); > + kvfree(handles); > *syncobjs_out = syncobjs; > return 0; > > err_put_syncobjs: > while (i-- > 0) > drm_syncobj_put(syncobjs[i]); > - kfree(syncobjs); > + kvfree(syncobjs); > err_free_handles: > - kfree(handles); > + kvfree(handles); > > return ret; > } > @@ -1283,7 +1297,7 @@ static void drm_syncobj_array_free(struct drm_syncobj > **syncobjs, > > for (i = 0; i < count; i++) > drm_syncobj_put(syncobjs[i]); > - kfree(syncobjs); > + kvfree(syncobjs); > } > > int > @@ -1572,8 +1586,8 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device > *dev, void *data, > if (ret < 0) > return ret; > > - points = kmalloc_array(args->count_handles, sizeof(*points), > - GFP_KERNEL); > + points = kvmalloc_array(args->count_handles, sizeof(*points), > + GFP_KERNEL); > if (!points) { > ret = -ENOMEM; > goto out; > @@ -1586,7 +1600,7 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device > *dev, void *data, > goto err_points; > } > > - chains = kmalloc_objs(*chains, args->count_handles); > + chains = kvmalloc_objs(*chains, args->count_handles); > if (!chains) { > ret = -ENOMEM; > goto err_points; > @@ -1609,9 +1623,9 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device > *dev, void *data, > dma_fence_put(fence); > } > err_chains: > - kfree(chains); > + kvfree(chains); > err_points: > - kfree(points); > + kvfree(points); > out: > drm_syncobj_array_free(syncobjs, args->count_handles); > > > base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4 > -- > 2.53.0
