2017-03-08 14:12:42 +00:00
|
|
|
/*
|
|
|
|
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
|
|
|
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
|
|
|
* Copyright (c) 2009-2010, Code Aurora Forum.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Author: Rickard E. (Rik) Faith <faith@valinux.com>
|
|
|
|
* Author: Gareth Hughes <gareth@valinux.com>
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _DRM_FILE_H_
|
|
|
|
#define _DRM_FILE_H_
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/completion.h>
|
2018-12-27 12:56:38 +00:00
|
|
|
#include <linux/idr.h>
|
2017-03-08 14:12:42 +00:00
|
|
|
|
|
|
|
#include <uapi/drm/drm.h>
|
|
|
|
|
|
|
|
#include <drm/drm_prime.h>
|
|
|
|
|
|
|
|
struct dma_fence;
|
|
|
|
struct drm_file;
|
|
|
|
struct drm_device;
|
2023-05-24 15:59:35 +00:00
|
|
|
struct drm_printer;
|
2017-05-31 09:21:46 +00:00
|
|
|
struct device;
|
2019-11-07 18:05:58 +00:00
|
|
|
struct file;
|
2017-03-08 14:12:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: Not sure we want to have drm_minor here in the end, but to avoid
|
|
|
|
* header include loops we need it here for now.
|
|
|
|
*/
|
2017-03-08 14:12:44 +00:00
|
|
|
|
2023-07-14 10:46:04 +00:00
|
|
|
/* Note that the values of this enum are ABI (it determines
|
2018-05-09 00:14:25 +00:00
|
|
|
* /dev/dri/renderD* numbers).
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
*
|
|
|
|
* Setting DRM_MINOR_ACCEL to 32 gives enough space for more drm minors to
|
|
|
|
* be implemented before we hit any future
|
2018-05-09 00:14:25 +00:00
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
enum drm_minor_type {
|
2023-07-14 10:46:04 +00:00
|
|
|
DRM_MINOR_PRIMARY = 0,
|
|
|
|
DRM_MINOR_CONTROL = 1,
|
|
|
|
DRM_MINOR_RENDER = 2,
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
DRM_MINOR_ACCEL = 32,
|
2017-03-08 14:12:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2017-03-08 14:12:44 +00:00
|
|
|
* struct drm_minor - DRM device minor structure
|
|
|
|
*
|
|
|
|
* This structure represents a DRM minor number for device nodes in /dev.
|
|
|
|
* Entirely opaque to drivers and should never be inspected directly by drivers.
|
|
|
|
* Drivers instead should only interact with &struct drm_file and of course
|
|
|
|
* &struct drm_device, which is also where driver-private data and resources can
|
|
|
|
* be attached to.
|
2017-03-08 14:12:42 +00:00
|
|
|
*/
|
|
|
|
struct drm_minor {
|
2017-03-08 14:12:44 +00:00
|
|
|
/* private: */
|
|
|
|
int index; /* Minor device number */
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
int type; /* Control or render or accel */
|
2017-03-08 14:12:44 +00:00
|
|
|
struct device *kdev; /* Linux device */
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_device *dev;
|
|
|
|
|
2023-08-29 11:01:13 +00:00
|
|
|
struct dentry *debugfs_symlink;
|
2017-03-08 14:12:42 +00:00
|
|
|
struct dentry *debugfs_root;
|
|
|
|
};
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* struct drm_pending_event - Event queued up for userspace to read
|
|
|
|
*
|
|
|
|
* This represents a DRM event. Drivers can use this as a generic completion
|
|
|
|
* mechanism, which supports kernel-internal &struct completion, &struct dma_fence
|
|
|
|
* and also the DRM-specific &struct drm_event delivery mechanism.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_pending_event {
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @completion:
|
|
|
|
*
|
|
|
|
* Optional pointer to a kernel internal completion signalled when
|
|
|
|
* drm_send_event() is called, useful to internally synchronize with
|
|
|
|
* nonblocking operations.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct completion *completion;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @completion_release:
|
|
|
|
*
|
|
|
|
* Optional callback currently only used by the atomic modeset helpers
|
|
|
|
* to clean up the reference count for the structure @completion is
|
|
|
|
* stored in.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
void (*completion_release)(struct completion *completion);
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @event:
|
|
|
|
*
|
|
|
|
* Pointer to the actual event that should be sent to userspace to be
|
|
|
|
* read using drm_read(). Can be optional, since nowadays events are
|
|
|
|
* also used to signal kernel internal threads with @completion or DMA
|
|
|
|
* transactions using @fence.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_event *event;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @fence:
|
|
|
|
*
|
|
|
|
* Optional DMA fence to unblock other hardware transactions which
|
|
|
|
* depend upon the nonblocking DRM operation this event represents.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct dma_fence *fence;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @file_priv:
|
|
|
|
*
|
|
|
|
* &struct drm_file where @event should be delivered to. Only set when
|
|
|
|
* @event is set.
|
|
|
|
*/
|
|
|
|
struct drm_file *file_priv;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @link:
|
|
|
|
*
|
|
|
|
* Double-linked list to keep track of this event. Can be used by the
|
|
|
|
* driver up to the point when it calls drm_send_event(), after that
|
|
|
|
* this list entry is owned by the core for its own book-keeping.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head link;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @pending_link:
|
|
|
|
*
|
|
|
|
* Entry on &drm_file.pending_event_list, to keep track of all pending
|
|
|
|
* events for @file_priv, to allow correct unwinding of them when
|
|
|
|
* userspace closes the file before the event is delivered.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head pending_link;
|
|
|
|
};
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* struct drm_file - DRM file private data
|
|
|
|
*
|
|
|
|
* This structure tracks DRM state per open file descriptor.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_file {
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @authenticated:
|
|
|
|
*
|
|
|
|
* Whether the client is allowed to submit rendering, which for legacy
|
|
|
|
* nodes means it must be authenticated.
|
|
|
|
*
|
|
|
|
* See also the :ref:`section on primary nodes and authentication
|
|
|
|
* <drm_primary_node>`.
|
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool authenticated;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @stereo_allowed:
|
|
|
|
*
|
|
|
|
* True when the client has asked us to expose stereo 3D mode flags.
|
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool stereo_allowed;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @universal_planes:
|
|
|
|
*
|
|
|
|
* True if client understands CRTC primary planes and cursor planes
|
|
|
|
* in the plane list. Automatically set when @atomic is set.
|
2017-03-08 14:12:42 +00:00
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool universal_planes;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/** @atomic: True if client understands atomic properties. */
|
2018-11-02 13:25:42 +00:00
|
|
|
bool atomic;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
2018-05-08 11:09:41 +00:00
|
|
|
/**
|
|
|
|
* @aspect_ratio_allowed:
|
|
|
|
*
|
|
|
|
* True, if client can handle picture aspect ratios, and has requested
|
|
|
|
* to pass this information along with the mode.
|
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool aspect_ratio_allowed;
|
2018-05-08 11:09:41 +00:00
|
|
|
|
2018-02-28 14:11:23 +00:00
|
|
|
/**
|
|
|
|
* @writeback_connectors:
|
|
|
|
*
|
|
|
|
* True if client understands writeback connectors
|
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool writeback_connectors;
|
2018-02-28 14:11:23 +00:00
|
|
|
|
2020-03-19 17:29:29 +00:00
|
|
|
/**
|
|
|
|
* @was_master:
|
|
|
|
*
|
|
|
|
* This client has or had, master capability. Protected by struct
|
|
|
|
* &drm_device.master_mutex.
|
|
|
|
*
|
|
|
|
* This is used to ensure that CAP_SYS_ADMIN is not enforced, if the
|
|
|
|
* client is or was master in the past.
|
|
|
|
*/
|
|
|
|
bool was_master;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @is_master:
|
|
|
|
*
|
|
|
|
* This client is the creator of @master. Protected by struct
|
|
|
|
* &drm_device.master_mutex.
|
|
|
|
*
|
|
|
|
* See also the :ref:`section on primary nodes and authentication
|
|
|
|
* <drm_primary_node>`.
|
2017-03-08 14:12:42 +00:00
|
|
|
*/
|
2018-11-02 13:25:42 +00:00
|
|
|
bool is_master;
|
2017-03-08 14:12:42 +00:00
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @master:
|
|
|
|
*
|
drm: serialize drm_file.master with a new spinlock
Currently, drm_file.master pointers should be protected by
drm_device.master_mutex when being dereferenced. This is because
drm_file.master is not invariant for the lifetime of drm_file. If
drm_file is not the creator of master, then drm_file.is_master is
false, and a call to drm_setmaster_ioctl will invoke
drm_new_set_master, which then allocates a new master for drm_file and
puts the old master.
Thus, without holding drm_device.master_mutex, the old value of
drm_file.master could be freed while it is being used by another
concurrent process.
However, it is not always possible to lock drm_device.master_mutex to
dereference drm_file.master. Through the fbdev emulation code, this
might occur in a deep nest of other locks. But drm_device.master_mutex
is also the outermost lock in the nesting hierarchy, so this leads to
potential deadlocks.
To address this, we introduce a new spin lock at the bottom of the
lock hierarchy that only serializes drm_file.master. With this change,
the value of drm_file.master changes only when both
drm_device.master_mutex and drm_file.master_lookup_lock are
held. Hence, any process holding either of those locks can ensure that
the value of drm_file.master will not change concurrently.
Since no lock depends on the new drm_file.master_lookup_lock, when
drm_file.master is dereferenced, but drm_device.master_mutex cannot be
held, we can safely protect the master pointer with
drm_file.master_lookup_lock.
Reported-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Desmond Cheong Zhi Xi <desmondcheongzx@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20210712043508.11584-5-desmondcheongzx@gmail.com
2021-07-12 04:35:07 +00:00
|
|
|
* Master this node is currently associated with. Protected by struct
|
|
|
|
* &drm_device.master_mutex, and serialized by @master_lookup_lock.
|
|
|
|
*
|
|
|
|
* Only relevant if drm_is_primary_client() returns true. Note that
|
|
|
|
* this only matches &drm_device.master if the master is the currently
|
|
|
|
* active one.
|
2017-03-08 14:12:44 +00:00
|
|
|
*
|
2021-08-02 10:59:57 +00:00
|
|
|
* To update @master, both &drm_device.master_mutex and
|
|
|
|
* @master_lookup_lock need to be held, therefore holding either of
|
|
|
|
* them is safe and enough for the read side.
|
|
|
|
*
|
2021-07-12 04:35:08 +00:00
|
|
|
* When dereferencing this pointer, either hold struct
|
|
|
|
* &drm_device.master_mutex for the duration of the pointer's use, or
|
|
|
|
* use drm_file_get_master() if struct &drm_device.master_mutex is not
|
|
|
|
* currently held and there is no other need to hold it. This prevents
|
|
|
|
* @master from being freed during use.
|
|
|
|
*
|
2017-03-08 14:12:44 +00:00
|
|
|
* See also @authentication and @is_master and the :ref:`section on
|
|
|
|
* primary nodes and authentication <drm_primary_node>`.
|
|
|
|
*/
|
|
|
|
struct drm_master *master;
|
|
|
|
|
2022-04-03 23:10:40 +00:00
|
|
|
/** @master_lookup_lock: Serializes @master. */
|
drm: serialize drm_file.master with a new spinlock
Currently, drm_file.master pointers should be protected by
drm_device.master_mutex when being dereferenced. This is because
drm_file.master is not invariant for the lifetime of drm_file. If
drm_file is not the creator of master, then drm_file.is_master is
false, and a call to drm_setmaster_ioctl will invoke
drm_new_set_master, which then allocates a new master for drm_file and
puts the old master.
Thus, without holding drm_device.master_mutex, the old value of
drm_file.master could be freed while it is being used by another
concurrent process.
However, it is not always possible to lock drm_device.master_mutex to
dereference drm_file.master. Through the fbdev emulation code, this
might occur in a deep nest of other locks. But drm_device.master_mutex
is also the outermost lock in the nesting hierarchy, so this leads to
potential deadlocks.
To address this, we introduce a new spin lock at the bottom of the
lock hierarchy that only serializes drm_file.master. With this change,
the value of drm_file.master changes only when both
drm_device.master_mutex and drm_file.master_lookup_lock are
held. Hence, any process holding either of those locks can ensure that
the value of drm_file.master will not change concurrently.
Since no lock depends on the new drm_file.master_lookup_lock, when
drm_file.master is dereferenced, but drm_device.master_mutex cannot be
held, we can safely protect the master pointer with
drm_file.master_lookup_lock.
Reported-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Desmond Cheong Zhi Xi <desmondcheongzx@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20210712043508.11584-5-desmondcheongzx@gmail.com
2021-07-12 04:35:07 +00:00
|
|
|
spinlock_t master_lookup_lock;
|
|
|
|
|
drm: Update file owner during use
With the typical model where the display server opens the file descriptor
and then hands it over to the client(*), we were showing stale data in
debugfs.
Fix it by updating the drm_file->pid on ioctl access from a different
process.
The field is also made RCU protected to allow for lockless readers. Update
side is protected with dev->filelist_mutex.
Before:
$ cat /sys/kernel/debug/dri/0/clients
command pid dev master a uid magic
Xorg 2344 0 y y 0 0
Xorg 2344 0 n y 0 2
Xorg 2344 0 n y 0 3
Xorg 2344 0 n y 0 4
After:
$ cat /sys/kernel/debug/dri/0/clients
command tgid dev master a uid magic
Xorg 830 0 y y 0 0
xfce4-session 880 0 n y 0 1
xfwm4 943 0 n y 0 2
neverball 1095 0 n y 0 3
*)
More detailed and historically accurate description of various handover
implementation kindly provided by Emil Velikov:
"""
The traditional model, the server was the orchestrator managing the
primary device node. From the fd, to the master status and
authentication. But looking at the fd alone, this has varied across
the years.
IIRC in the DRI1 days, Xorg (libdrm really) would have a list of open
fd(s) and reuse those whenever needed, DRI2 the client was responsible
for open() themselves and with DRI3 the fd was passed to the client.
Around the inception of DRI3 and systemd-logind, the latter became
another possible orchestrator. Whereby Xorg and Wayland compositors
could ask it for the fd. For various reasons (hysterical and genuine
ones) Xorg has a fallback path going the open(), whereas Wayland
compositors are moving to solely relying on logind... some never had
fallback even.
Over the past few years, more projects have emerged which provide
functionality similar (be that on API level, Dbus, or otherwise) to
systemd-logind.
"""
v2:
* Fixed typo in commit text and added a fine historical explanation
from Emil.
Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Cc: "Christian König" <christian.koenig@amd.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Acked-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Emil Velikov <emil.l.velikov@gmail.com>
Reviewed-by: Rob Clark <robdclark@gmail.com>
Tested-by: Rob Clark <robdclark@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20230621094824.2348732-1-tvrtko.ursulin@linux.intel.com
Signed-off-by: Christian König <christian.koenig@amd.com>
2023-06-21 09:48:24 +00:00
|
|
|
/**
|
|
|
|
* @pid: Process that is using this file.
|
|
|
|
*
|
|
|
|
* Must only be dereferenced under a rcu_read_lock or equivalent.
|
|
|
|
*
|
|
|
|
* Updates are guarded with dev->filelist_mutex and reference must be
|
|
|
|
* dropped after a RCU grace period to accommodate lockless readers.
|
|
|
|
*/
|
|
|
|
struct pid __rcu *pid;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
2023-05-24 15:59:32 +00:00
|
|
|
/** @client_id: A unique id for fdinfo */
|
|
|
|
u64 client_id;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/** @magic: Authentication magic, see @authenticated. */
|
2017-03-08 14:12:42 +00:00
|
|
|
drm_magic_t magic;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @lhead:
|
|
|
|
*
|
|
|
|
* List of all open files of a DRM device, linked into
|
|
|
|
* &drm_device.filelist. Protected by &drm_device.filelist_mutex.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head lhead;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/** @minor: &struct drm_minor for this file. */
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_minor *minor;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @object_idr:
|
|
|
|
*
|
|
|
|
* Mapping of mm object handles to object pointers. Used by the GEM
|
|
|
|
* subsystem. Protected by @table_lock.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct idr object_idr;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/** @table_lock: Protects @object_idr. */
|
2017-03-08 14:12:42 +00:00
|
|
|
spinlock_t table_lock;
|
|
|
|
|
2017-04-04 03:26:24 +00:00
|
|
|
/** @syncobj_idr: Mapping of sync object handles to object pointers. */
|
|
|
|
struct idr syncobj_idr;
|
|
|
|
/** @syncobj_table_lock: Protects @syncobj_idr. */
|
|
|
|
spinlock_t syncobj_table_lock;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/** @filp: Pointer to the core file structure. */
|
2017-03-08 14:12:42 +00:00
|
|
|
struct file *filp;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @driver_priv:
|
|
|
|
*
|
|
|
|
* Optional pointer for driver private data. Can be allocated in
|
|
|
|
* &drm_driver.open and should be freed in &drm_driver.postclose.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
void *driver_priv;
|
|
|
|
|
|
|
|
/**
|
2017-03-08 14:12:44 +00:00
|
|
|
* @fbs:
|
|
|
|
*
|
|
|
|
* List of &struct drm_framebuffer associated with this file, using the
|
|
|
|
* &drm_framebuffer.filp_head entry.
|
2017-03-08 14:12:42 +00:00
|
|
|
*
|
2017-03-08 14:12:44 +00:00
|
|
|
* Protected by @fbs_lock. Note that the @fbs list holds a reference on
|
|
|
|
* the framebuffer object to prevent it from untimely disappearing.
|
2017-03-08 14:12:42 +00:00
|
|
|
*/
|
|
|
|
struct list_head fbs;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/** @fbs_lock: Protects @fbs. */
|
2017-03-08 14:12:42 +00:00
|
|
|
struct mutex fbs_lock;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @blobs:
|
|
|
|
*
|
|
|
|
* User-created blob properties; this retains a reference on the
|
|
|
|
* property.
|
|
|
|
*
|
|
|
|
* Protected by @drm_mode_config.blob_lock;
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head blobs;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/** @event_wait: Waitqueue for new events added to @event_list. */
|
2017-03-08 14:12:42 +00:00
|
|
|
wait_queue_head_t event_wait;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @pending_event_list:
|
|
|
|
*
|
|
|
|
* List of pending &struct drm_pending_event, used to clean up pending
|
|
|
|
* events in case this file gets closed before the event is signalled.
|
|
|
|
* Uses the &drm_pending_event.pending_link entry.
|
|
|
|
*
|
|
|
|
* Protect by &drm_device.event_lock.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head pending_event_list;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @event_list:
|
|
|
|
*
|
|
|
|
* List of &struct drm_pending_event, ready for delivery to userspace
|
|
|
|
* through drm_read(). Uses the &drm_pending_event.link entry.
|
|
|
|
*
|
|
|
|
* Protect by &drm_device.event_lock.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct list_head event_list;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @event_space:
|
|
|
|
*
|
|
|
|
* Available event space to prevent userspace from
|
|
|
|
* exhausting kernel memory. Currently limited to the fairly arbitrary
|
|
|
|
* value of 4KB.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
int event_space;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/** @event_read_lock: Serializes drm_read(). */
|
2017-03-08 14:12:42 +00:00
|
|
|
struct mutex event_read_lock;
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* @prime:
|
|
|
|
*
|
|
|
|
* Per-file buffer caches used by the PRIME buffer sharing code.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
struct drm_prime_file_private prime;
|
2017-03-08 14:12:44 +00:00
|
|
|
|
|
|
|
/* private: */
|
2019-04-23 00:01:50 +00:00
|
|
|
#if IS_ENABLED(CONFIG_DRM_LEGACY)
|
2017-03-08 14:12:44 +00:00
|
|
|
unsigned long lock_count; /* DRI1 legacy lock count */
|
2019-04-23 00:01:50 +00:00
|
|
|
#endif
|
2017-03-08 14:12:42 +00:00
|
|
|
};
|
|
|
|
|
2017-03-08 14:12:44 +00:00
|
|
|
/**
|
|
|
|
* drm_is_primary_client - is this an open file of the primary node
|
|
|
|
* @file_priv: DRM file
|
|
|
|
*
|
|
|
|
* Returns true if this is an open file of the primary node, i.e.
|
|
|
|
* &drm_file.minor of @file_priv is a primary minor.
|
|
|
|
*
|
|
|
|
* See also the :ref:`section on primary nodes and authentication
|
|
|
|
* <drm_primary_node>`.
|
|
|
|
*/
|
|
|
|
static inline bool drm_is_primary_client(const struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
return file_priv->minor->type == DRM_MINOR_PRIMARY;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_is_render_client - is this an open file of the render node
|
|
|
|
* @file_priv: DRM file
|
|
|
|
*
|
|
|
|
* Returns true if this is an open file of the render node, i.e.
|
|
|
|
* &drm_file.minor of @file_priv is a render minor.
|
|
|
|
*
|
|
|
|
* See also the :ref:`section on render nodes <drm_render_node>`.
|
|
|
|
*/
|
2017-03-08 14:12:42 +00:00
|
|
|
static inline bool drm_is_render_client(const struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
return file_priv->minor->type == DRM_MINOR_RENDER;
|
|
|
|
}
|
|
|
|
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
/**
|
|
|
|
* drm_is_accel_client - is this an open file of the compute acceleration node
|
|
|
|
* @file_priv: DRM file
|
|
|
|
*
|
|
|
|
* Returns true if this is an open file of the compute acceleration node, i.e.
|
|
|
|
* &drm_file.minor of @file_priv is a accel minor.
|
|
|
|
*
|
2023-03-07 04:35:26 +00:00
|
|
|
* See also :doc:`Introduction to compute accelerators subsystem
|
|
|
|
* </accel/introduction>`.
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
*/
|
|
|
|
static inline bool drm_is_accel_client(const struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
return file_priv->minor->type == DRM_MINOR_ACCEL;
|
|
|
|
}
|
|
|
|
|
drm: Update file owner during use
With the typical model where the display server opens the file descriptor
and then hands it over to the client(*), we were showing stale data in
debugfs.
Fix it by updating the drm_file->pid on ioctl access from a different
process.
The field is also made RCU protected to allow for lockless readers. Update
side is protected with dev->filelist_mutex.
Before:
$ cat /sys/kernel/debug/dri/0/clients
command pid dev master a uid magic
Xorg 2344 0 y y 0 0
Xorg 2344 0 n y 0 2
Xorg 2344 0 n y 0 3
Xorg 2344 0 n y 0 4
After:
$ cat /sys/kernel/debug/dri/0/clients
command tgid dev master a uid magic
Xorg 830 0 y y 0 0
xfce4-session 880 0 n y 0 1
xfwm4 943 0 n y 0 2
neverball 1095 0 n y 0 3
*)
More detailed and historically accurate description of various handover
implementation kindly provided by Emil Velikov:
"""
The traditional model, the server was the orchestrator managing the
primary device node. From the fd, to the master status and
authentication. But looking at the fd alone, this has varied across
the years.
IIRC in the DRI1 days, Xorg (libdrm really) would have a list of open
fd(s) and reuse those whenever needed, DRI2 the client was responsible
for open() themselves and with DRI3 the fd was passed to the client.
Around the inception of DRI3 and systemd-logind, the latter became
another possible orchestrator. Whereby Xorg and Wayland compositors
could ask it for the fd. For various reasons (hysterical and genuine
ones) Xorg has a fallback path going the open(), whereas Wayland
compositors are moving to solely relying on logind... some never had
fallback even.
Over the past few years, more projects have emerged which provide
functionality similar (be that on API level, Dbus, or otherwise) to
systemd-logind.
"""
v2:
* Fixed typo in commit text and added a fine historical explanation
from Emil.
Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Cc: "Christian König" <christian.koenig@amd.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Acked-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Emil Velikov <emil.l.velikov@gmail.com>
Reviewed-by: Rob Clark <robdclark@gmail.com>
Tested-by: Rob Clark <robdclark@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20230621094824.2348732-1-tvrtko.ursulin@linux.intel.com
Signed-off-by: Christian König <christian.koenig@amd.com>
2023-06-21 09:48:24 +00:00
|
|
|
void drm_file_update_pid(struct drm_file *);
|
|
|
|
|
2017-03-08 14:12:42 +00:00
|
|
|
int drm_open(struct inode *inode, struct file *filp);
|
accel: add dedicated minor for accelerator devices
The accelerator devices are exposed to user-space using a dedicated
major. In addition, they are represented in /dev with new, dedicated
device char names: /dev/accel/accel*. This is done to make sure any
user-space software that tries to open a graphic card won't open
the accelerator device by mistake.
The above implies that the minor numbering should be separated from
the rest of the DRM devices. However, to avoid code duplication, we
want the drm_minor structure to be able to represent the accelerator
device.
To achieve this, we add a new drm_minor* to drm_device that represents
the accelerator device. This pointer is initialized for drivers that
declare they handle compute accelerator, using a new driver feature
flag called DRIVER_COMPUTE_ACCEL. It is important to note that this
driver feature is mutually exclusive with DRIVER_RENDER. Devices that
want to expose both graphics and compute device char files should be
handled by two drivers that are connected using the auxiliary bus
framework.
In addition, we define a different IDR to handle the accelerators
minors. This is done to make the minor's index be identical to the
device index in /dev/. Any access to the IDR is done solely
by functions in accel_drv.c, as the IDR is define as static. The
DRM core functions call those functions in case they detect the minor's
type is DRM_MINOR_ACCEL.
We define a separate accel_open function (from drm_open) that the
accel drivers should set as their open callback function. Both these
functions eventually call the same drm_open_helper(), which had to be
changed to be non-static so it can be called from accel_drv.c.
accel_open() only partially duplicates drm_open as I removed some code
from it that handles legacy devices.
To help new drivers, I defined DEFINE_DRM_ACCEL_FOPS macro to easily
set the required function operations pointers structure.
Signed-off-by: Oded Gabbay <ogabbay@kernel.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jeffrey Hugo <quic_jhugo@quicinc.com>
Reviewed-by: Dave Airlie <airlied@redhat.com>
Acked-by: Thomas Zimmermann <tzimmermann@suse.de>
Acked-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Tested-by: Jacek Lawrynowicz <jacek.lawrynowicz@linux.intel.com>
Reviewed-by: Melissa Wen <mwen@igalia.com>
2022-10-31 13:33:06 +00:00
|
|
|
int drm_open_helper(struct file *filp, struct drm_minor *minor);
|
2017-03-08 14:12:42 +00:00
|
|
|
ssize_t drm_read(struct file *filp, char __user *buffer,
|
|
|
|
size_t count, loff_t *offset);
|
|
|
|
int drm_release(struct inode *inode, struct file *filp);
|
2020-01-24 12:56:26 +00:00
|
|
|
int drm_release_noglobal(struct inode *inode, struct file *filp);
|
2017-07-03 10:39:46 +00:00
|
|
|
__poll_t drm_poll(struct file *filp, struct poll_table_struct *wait);
|
2017-03-08 14:12:42 +00:00
|
|
|
int drm_event_reserve_init_locked(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
struct drm_pending_event *p,
|
|
|
|
struct drm_event *e);
|
|
|
|
int drm_event_reserve_init(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
struct drm_pending_event *p,
|
|
|
|
struct drm_event *e);
|
|
|
|
void drm_event_cancel_free(struct drm_device *dev,
|
|
|
|
struct drm_pending_event *p);
|
|
|
|
void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e);
|
|
|
|
void drm_send_event(struct drm_device *dev, struct drm_pending_event *e);
|
2021-01-16 00:31:47 +00:00
|
|
|
void drm_send_event_timestamp_locked(struct drm_device *dev,
|
|
|
|
struct drm_pending_event *e,
|
|
|
|
ktime_t timestamp);
|
2023-05-24 15:59:35 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* struct drm_memory_stats - GEM object stats associated
|
|
|
|
* @shared: Total size of GEM objects shared between processes
|
|
|
|
* @private: Total size of GEM objects
|
|
|
|
* @resident: Total size of GEM objects backing pages
|
|
|
|
* @purgeable: Total size of GEM objects that can be purged (resident and not active)
|
|
|
|
* @active: Total size of GEM objects active on one or more engines
|
|
|
|
*
|
|
|
|
* Used by drm_print_memory_stats()
|
|
|
|
*/
|
|
|
|
struct drm_memory_stats {
|
|
|
|
u64 shared;
|
|
|
|
u64 private;
|
|
|
|
u64 resident;
|
|
|
|
u64 purgeable;
|
|
|
|
u64 active;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum drm_gem_object_status;
|
|
|
|
|
|
|
|
void drm_print_memory_stats(struct drm_printer *p,
|
|
|
|
const struct drm_memory_stats *stats,
|
|
|
|
enum drm_gem_object_status supported_status,
|
|
|
|
const char *region);
|
|
|
|
|
|
|
|
void drm_show_memory_stats(struct drm_printer *p, struct drm_file *file);
|
2023-05-24 15:59:32 +00:00
|
|
|
void drm_show_fdinfo(struct seq_file *m, struct file *f);
|
2017-03-08 14:12:42 +00:00
|
|
|
|
2019-11-07 18:05:58 +00:00
|
|
|
struct file *mock_drm_getfile(struct drm_minor *minor, unsigned int flags);
|
|
|
|
|
2017-03-08 14:12:42 +00:00
|
|
|
#endif /* _DRM_FILE_H_ */
|