WebSVN – Kolibri OS – Blame – /drivers/include/drm/drm_vma_manager.h

Rev	Author	Line No.	Line
4103	Serge	1	#ifndef __DRM_VMA_MANAGER_H__
		2	#define __DRM_VMA_MANAGER_H__
		3
		4	/*
		5	* Copyright (c) 2013 David Herrmann
		6	*
		7	* Permission is hereby granted, free of charge, to any person obtaining a
		8	* copy of this software and associated documentation files (the "Software"),
		9	* to deal in the Software without restriction, including without limitation
		10	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		11	* and/or sell copies of the Software, and to permit persons to whom the
		12	* Software is furnished to do so, subject to the following conditions:
		13	*
		14	* The above copyright notice and this permission notice shall be included in
		15	* all copies or substantial portions of the Software.
		16	*
		17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		18	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		20	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
		21	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		22	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		23	* OTHER DEALINGS IN THE SOFTWARE.
		24	*/
		25
		26	#include
4559	Serge	27	#include
4103	Serge	28	#include
		29	#include
		30	#include
		31	#include
		32	#include
		33
		34	struct drm_vma_offset_file {
		35	struct rb_node vm_rb;
		36	struct file *vm_filp;
		37	unsigned long vm_count;
		38	};
		39
		40	struct drm_vma_offset_node {
		41	rwlock_t vm_lock;
		42	struct drm_mm_node vm_node;
		43	struct rb_node vm_rb;
		44	struct rb_root vm_files;
		45	};
		46
		47	struct drm_vma_offset_manager {
		48	rwlock_t vm_lock;
		49	struct rb_root vm_addr_space_rb;
		50	struct drm_mm vm_addr_space_mm;
		51	};
		52
		53	void drm_vma_offset_manager_init(struct drm_vma_offset_manager *mgr,
		54	unsigned long page_offset, unsigned long size);
		55	void drm_vma_offset_manager_destroy(struct drm_vma_offset_manager *mgr);
		56
		57	struct drm_vma_offset_node drm_vma_offset_lookup_locked(struct drm_vma_offset_manager mgr,
		58	unsigned long start,
		59	unsigned long pages);
		60	int drm_vma_offset_add(struct drm_vma_offset_manager *mgr,
		61	struct drm_vma_offset_node *node, unsigned long pages);
		62	void drm_vma_offset_remove(struct drm_vma_offset_manager *mgr,
		63	struct drm_vma_offset_node *node);
		64
		65	int drm_vma_node_allow(struct drm_vma_offset_node node, struct file filp);
		66	void drm_vma_node_revoke(struct drm_vma_offset_node node, struct file filp);
		67	bool drm_vma_node_is_allowed(struct drm_vma_offset_node *node,
		68	struct file *filp);
		69
		70	/**
6082	serge	71	* drm_vma_offset_exact_lookup_locked() - Look up node by exact address
4103	Serge	72	* @mgr: Manager object
		73	* @start: Start address (page-based, not byte-based)
		74	* @pages: Size of object (page-based)
		75	*
6082	serge	76	* Same as drm_vma_offset_lookup_locked() but does not allow any offset into the node.
4103	Serge	77	* It only returns the exact object with the given start address.
		78	*
		79	* RETURNS:
		80	* Node at exact start address @start.
		81	*/
		82	static inline struct drm_vma_offset_node *
6082	serge	83	drm_vma_offset_exact_lookup_locked(struct drm_vma_offset_manager *mgr,
		84	unsigned long start,
		85	unsigned long pages)
4103	Serge	86	{
		87	struct drm_vma_offset_node *node;
		88
6082	serge	89	node = drm_vma_offset_lookup_locked(mgr, start, pages);
4103	Serge	90	return (node && node->vm_node.start == start) ? node : NULL;
		91	}
		92
		93	/**
		94	* drm_vma_offset_lock_lookup() - Lock lookup for extended private use
		95	* @mgr: Manager object
		96	*
6082	serge	97	* Lock VMA manager for extended lookups. Only locked VMA function calls
4103	Serge	98	* are allowed while holding this lock. All other contexts are blocked from VMA
		99	* until the lock is released via drm_vma_offset_unlock_lookup().
		100	*
		101	* Use this if you need to take a reference to the objects returned by
		102	* drm_vma_offset_lookup_locked() before releasing this lock again.
		103	*
		104	* This lock must not be used for anything else than extended lookups. You must
		105	* not call any other VMA helpers while holding this lock.
		106	*
		107	* Note: You're in atomic-context while holding this lock!
		108	*/
		109	static inline void drm_vma_offset_lock_lookup(struct drm_vma_offset_manager *mgr)
		110	{
		111	read_lock(&mgr->vm_lock);
		112	}
		113
		114	/**
		115	* drm_vma_offset_unlock_lookup() - Unlock lookup for extended private use
		116	* @mgr: Manager object
		117	*
		118	* Release lookup-lock. See drm_vma_offset_lock_lookup() for more information.
		119	*/
		120	static inline void drm_vma_offset_unlock_lookup(struct drm_vma_offset_manager *mgr)
		121	{
		122	read_unlock(&mgr->vm_lock);
		123	}
		124
		125	/**
		126	* drm_vma_node_reset() - Initialize or reset node object
		127	* @node: Node to initialize or reset
		128	*
		129	* Reset a node to its initial state. This must be called before using it with
		130	* any VMA offset manager.
		131	*
		132	* This must not be called on an already allocated node, or you will leak
		133	* memory.
		134	*/
		135	static inline void drm_vma_node_reset(struct drm_vma_offset_node *node)
		136	{
		137	memset(node, 0, sizeof(*node));
		138	node->vm_files = RB_ROOT;
		139	rwlock_init(&node->vm_lock);
		140	}
		141
		142	/**
		143	* drm_vma_node_start() - Return start address for page-based addressing
		144	* @node: Node to inspect
		145	*
		146	* Return the start address of the given node. This can be used as offset into
		147	* the linear VM space that is provided by the VMA offset manager. Note that
		148	* this can only be used for page-based addressing. If you need a proper offset
		149	* for user-space mappings, you must apply "<< PAGE_SHIFT" or use the
		150	* drm_vma_node_offset_addr() helper instead.
		151	*
		152	* RETURNS:
		153	* Start address of @node for page-based addressing. 0 if the node does not
		154	* have an offset allocated.
		155	*/
		156	static inline unsigned long drm_vma_node_start(struct drm_vma_offset_node *node)
		157	{
		158	return node->vm_node.start;
		159	}
		160
		161	/**
		162	* drm_vma_node_size() - Return size (page-based)
		163	* @node: Node to inspect
		164	*
		165	* Return the size as number of pages for the given node. This is the same size
		166	* that was passed to drm_vma_offset_add(). If no offset is allocated for the
		167	* node, this is 0.
		168	*
		169	* RETURNS:
		170	* Size of @node as number of pages. 0 if the node does not have an offset
		171	* allocated.
		172	*/
		173	static inline unsigned long drm_vma_node_size(struct drm_vma_offset_node *node)
		174	{
		175	return node->vm_node.size;
		176	}
		177
		178	/**
		179	* drm_vma_node_has_offset() - Check whether node is added to offset manager
		180	* @node: Node to be checked
		181	*
		182	* RETURNS:
		183	* true iff the node was previously allocated an offset and added to
		184	* an vma offset manager.
		185	*/
		186	static inline bool drm_vma_node_has_offset(struct drm_vma_offset_node *node)
		187	{
		188	return drm_mm_node_allocated(&node->vm_node);
		189	}
		190
		191	/**
		192	* drm_vma_node_offset_addr() - Return sanitized offset for user-space mmaps
		193	* @node: Linked offset node
		194	*
		195	* Same as drm_vma_node_start() but returns the address as a valid offset that
		196	* can be used for user-space mappings during mmap().
		197	* This must not be called on unlinked nodes.
		198	*
		199	* RETURNS:
		200	* Offset of @node for byte-based addressing. 0 if the node does not have an
		201	* object allocated.
		202	*/
		203	static inline __u64 drm_vma_node_offset_addr(struct drm_vma_offset_node *node)
		204	{
		205	return ((__u64)node->vm_node.start) << PAGE_SHIFT;
		206	}
		207
		208	/**
		209	* drm_vma_node_unmap() - Unmap offset node
		210	* @node: Offset node
		211	* @file_mapping: Address space to unmap @node from
		212	*
		213	* Unmap all userspace mappings for a given offset node. The mappings must be
5056	serge	214	* associated with the @file_mapping address-space. If no offset exists
		215	* nothing is done.
4103	Serge	216	*
		217	* This call is unlocked. The caller must guarantee that drm_vma_offset_remove()
		218	* is not called on this node concurrently.
		219	*/
		220	static inline void drm_vma_node_unmap(struct drm_vma_offset_node *node,
		221	struct address_space *file_mapping)
		222	{
5056	serge	223	// if (drm_vma_node_has_offset(node))
		224	// unmap_mapping_range(file_mapping,
		225	// drm_vma_node_offset_addr(node),
		226	// drm_vma_node_size(node) << PAGE_SHIFT, 1);
4103	Serge	227	}
		228
		229	/**
		230	* drm_vma_node_verify_access() - Access verification helper for TTM
		231	* @node: Offset node
		232	* @filp: Open-file
		233	*
		234	* This checks whether @filp is granted access to @node. It is the same as
		235	* drm_vma_node_is_allowed() but suitable as drop-in helper for TTM
		236	* verify_access() callbacks.
		237	*
		238	* RETURNS:
		239	* 0 if access is granted, -EACCES otherwise.
		240	*/
		241	static inline int drm_vma_node_verify_access(struct drm_vma_offset_node *node,
		242	struct file *filp)
		243	{
		244	return drm_vma_node_is_allowed(node, filp) ? 0 : -EACCES;
		245	}
		246
		247	#endif /* __DRM_VMA_MANAGER_H__ */

Subversion Repositories Kolibri OS

(root)/drivers/include/drm/drm_vma_manager.h – Rev 6082