tree 0c5728cdd5ad4bcc8fb770a78d1521f1113f2d8a
parent 1ffd57c1da2a73b0a0e5cd7a6dd52cc49e36bef9
author Ryan Mallon <rmallon@gmail.com> 1327701100 +1100
committer Dave Airlie <airlied@redhat.com> 1327915959 +0000

vmwgfx: Fix assignment in vmw_framebuffer_create_handle

The assignment of handle in vmw_framebuffer_create_handle doesn't actually do anything useful and is incorrectly assigning an integer value to a pointer argument. It appears that this is a typo and should be dereferencing handle rather than assigning to it directly. This fixes a bug where an undefined handle value is potentially returned to user-space.

Signed-off-by: Ryan Mallon <rmallon@gmail.com>
Reviewed-by: Jakob Bornecrantz<jakob@vmware.com>
Cc: stable@vger.kernel.org
Signed-off-by: Dave Airlie <airlied@redhat.com>
