The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/drm2/ttm/ttm_bo_api.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /**************************************************************************
    2  *
    3  * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
    4  * All Rights Reserved.
    5  *
    6  * Permission is hereby granted, free of charge, to any person obtaining a
    7  * copy of this software and associated documentation files (the
    8  * "Software"), to deal in the Software without restriction, including
    9  * without limitation the rights to use, copy, modify, merge, publish,
   10  * distribute, sub license, and/or sell copies of the Software, and to
   11  * permit persons to whom the Software is furnished to do so, subject to
   12  * the following conditions:
   13  *
   14  * The above copyright notice and this permission notice (including the
   15  * next paragraph) shall be included in all copies or substantial portions
   16  * of the Software.
   17  *
   18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
   21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
   22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
   23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
   24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
   25  *
   26  **************************************************************************/
   27 /*
   28  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
   29  */
   30 /* $FreeBSD$ */
   31 
   32 #ifndef _TTM_BO_API_H_
   33 #define _TTM_BO_API_H_
   34 
   35 #include <dev/drm2/drmP.h>
   36 
   37 struct ttm_bo_device;
   38 
   39 struct drm_mm_node;
   40 
   41 
   42 /**
   43  * struct ttm_placement
   44  *
   45  * @fpfn:               first valid page frame number to put the object
   46  * @lpfn:               last valid page frame number to put the object
   47  * @num_placement:      number of preferred placements
   48  * @placement:          preferred placements
   49  * @num_busy_placement: number of preferred placements when need to evict buffer
   50  * @busy_placement:     preferred placements when need to evict buffer
   51  *
   52  * Structure indicating the placement you request for an object.
   53  */
   54 struct ttm_placement {
   55         unsigned        fpfn;
   56         unsigned        lpfn;
   57         unsigned        num_placement;
   58         const uint32_t  *placement;
   59         unsigned        num_busy_placement;
   60         const uint32_t  *busy_placement;
   61 };
   62 
   63 /**
   64  * struct ttm_bus_placement
   65  *
   66  * @addr:               mapped virtual address
   67  * @base:               bus base address
   68  * @is_iomem:           is this io memory ?
   69  * @size:               size in byte
   70  * @offset:             offset from the base address
   71  * @io_reserved_vm:     The VM system has a refcount in @io_reserved_count
   72  * @io_reserved_count:  Refcounting the numbers of callers to ttm_mem_io_reserve
   73  *
   74  * Structure indicating the bus placement of an object.
   75  */
   76 struct ttm_bus_placement {
   77         void            *addr;
   78         unsigned long   base;
   79         unsigned long   size;
   80         unsigned long   offset;
   81         bool            is_iomem;
   82         bool            io_reserved_vm;
   83         uint64_t        io_reserved_count;
   84 };
   85 
   86 
   87 /**
   88  * struct ttm_mem_reg
   89  *
   90  * @mm_node: Memory manager node.
   91  * @size: Requested size of memory region.
   92  * @num_pages: Actual size of memory region in pages.
   93  * @page_alignment: Page alignment.
   94  * @placement: Placement flags.
   95  * @bus: Placement on io bus accessible to the CPU
   96  *
   97  * Structure indicating the placement and space resources used by a
   98  * buffer object.
   99  */
  100 
  101 struct ttm_mem_reg {
  102         void *mm_node;
  103         unsigned long start;
  104         unsigned long size;
  105         unsigned long num_pages;
  106         uint32_t page_alignment;
  107         uint32_t mem_type;
  108         uint32_t placement;
  109         struct ttm_bus_placement bus;
  110 };
  111 
  112 /**
  113  * enum ttm_bo_type
  114  *
  115  * @ttm_bo_type_device: These are 'normal' buffers that can
  116  * be mmapped by user space. Each of these bos occupy a slot in the
  117  * device address space, that can be used for normal vm operations.
  118  *
  119  * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
  120  * but they cannot be accessed from user-space. For kernel-only use.
  121  *
  122  * @ttm_bo_type_sg: Buffer made from dmabuf sg table shared with another
  123  * driver.
  124  */
  125 
  126 enum ttm_bo_type {
  127         ttm_bo_type_device,
  128         ttm_bo_type_kernel,
  129         ttm_bo_type_sg
  130 };
  131 
  132 struct ttm_tt;
  133 
  134 /**
  135  * struct ttm_buffer_object
  136  *
  137  * @bdev: Pointer to the buffer object device structure.
  138  * @type: The bo type.
  139  * @destroy: Destruction function. If NULL, kfree is used.
  140  * @num_pages: Actual number of pages.
  141  * @addr_space_offset: Address space offset.
  142  * @acc_size: Accounted size for this object.
  143  * @kref: Reference count of this buffer object. When this refcount reaches
  144  * zero, the object is put on the delayed delete list.
  145  * @list_kref: List reference count of this buffer object. This member is
  146  * used to avoid destruction while the buffer object is still on a list.
  147  * Lru lists may keep one refcount, the delayed delete list, and kref != 0
  148  * keeps one refcount. When this refcount reaches zero,
  149  * the object is destroyed.
  150  * @event_queue: Queue for processes waiting on buffer object status change.
  151  * @mem: structure describing current placement.
  152  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  153  * pinned in physical memory. If this behaviour is not desired, this member
  154  * holds a pointer to a persistent shmem object.
  155  * @ttm: TTM structure holding system pages.
  156  * @evicted: Whether the object was evicted without user-space knowing.
  157  * @cpu_writes: For synchronization. Number of cpu writers.
  158  * @lru: List head for the lru list.
  159  * @ddestroy: List head for the delayed destroy list.
  160  * @swap: List head for swap LRU list.
  161  * @val_seq: Sequence of the validation holding the @reserved lock.
  162  * Used to avoid starvation when many processes compete to validate the
  163  * buffer. This member is protected by the bo_device::lru_lock.
  164  * @seq_valid: The value of @val_seq is valid. This value is protected by
  165  * the bo_device::lru_lock.
  166  * @reserved: Deadlock-free lock used for synchronization state transitions.
  167  * @sync_obj: Pointer to a synchronization object.
  168  * @priv_flags: Flags describing buffer object internal state.
  169  * @vm_rb: Rb node for the vm rb tree.
  170  * @vm_node: Address space manager node.
  171  * @offset: The current GPU offset, which can have different meanings
  172  * depending on the memory type. For SYSTEM type memory, it should be 0.
  173  * @cur_placement: Hint of current placement.
  174  *
  175  * Base class for TTM buffer object, that deals with data placement and CPU
  176  * mappings. GPU mappings are really up to the driver, but for simpler GPUs
  177  * the driver can usually use the placement offset @offset directly as the
  178  * GPU virtual address. For drivers implementing multiple
  179  * GPU memory manager contexts, the driver should manage the address space
  180  * in these contexts separately and use these objects to get the correct
  181  * placement and caching for these GPU maps. This makes it possible to use
  182  * these objects for even quite elaborate memory management schemes.
  183  * The destroy member, the API visibility of this object makes it possible
  184  * to derive driver specific types.
  185  */
  186 
  187 struct ttm_buffer_object {
  188         /**
  189          * Members constant at init.
  190          */
  191 
  192         struct ttm_bo_global *glob;
  193         struct ttm_bo_device *bdev;
  194         enum ttm_bo_type type;
  195         void (*destroy) (struct ttm_buffer_object *);
  196         unsigned long num_pages;
  197         uint64_t addr_space_offset;
  198         size_t acc_size;
  199 
  200         /**
  201         * Members not needing protection.
  202         */
  203 
  204         u_int kref;
  205         u_int list_kref;
  206         /* wait_queue_head_t event_queue; */
  207 
  208         /**
  209          * Members protected by the bo::reserved lock.
  210          */
  211 
  212         struct ttm_mem_reg mem;
  213         struct vm_object *persistent_swap_storage;
  214         struct ttm_tt *ttm;
  215         bool evicted;
  216 
  217         /**
  218          * Members protected by the bo::reserved lock only when written to.
  219          */
  220 
  221         atomic_t cpu_writers;
  222 
  223         /**
  224          * Members protected by the bdev::lru_lock.
  225          */
  226 
  227         struct list_head lru;
  228         struct list_head ddestroy;
  229         struct list_head swap;
  230         struct list_head io_reserve_lru;
  231         uint32_t val_seq;
  232         bool seq_valid;
  233 
  234         /**
  235          * Members protected by the bdev::lru_lock
  236          * only when written to.
  237          */
  238 
  239         atomic_t reserved;
  240 
  241         /**
  242          * Members protected by struct buffer_object_device::fence_lock
  243          * In addition, setting sync_obj to anything else
  244          * than NULL requires bo::reserved to be held. This allows for
  245          * checking NULL while reserved but not holding the mentioned lock.
  246          */
  247 
  248         void *sync_obj;
  249         unsigned long priv_flags;
  250 
  251         /**
  252          * Members protected by the bdev::vm_lock
  253          */
  254 
  255         RB_ENTRY(ttm_buffer_object) vm_rb;
  256         struct drm_mm_node *vm_node;
  257 
  258 
  259         /**
  260          * Special members that are protected by the reserve lock
  261          * and the bo::lock when written to. Can be read with
  262          * either of these locks held.
  263          */
  264 
  265         unsigned long offset;
  266         uint32_t cur_placement;
  267 
  268         struct sg_table *sg;
  269 };
  270 
  271 /**
  272  * struct ttm_bo_kmap_obj
  273  *
  274  * @virtual: The current kernel virtual address.
  275  * @page: The page when kmap'ing a single page.
  276  * @bo_kmap_type: Type of bo_kmap.
  277  *
  278  * Object describing a kernel mapping. Since a TTM bo may be located
  279  * in various memory types with various caching policies, the
  280  * mapping can either be an ioremap, a vmap, a kmap or part of a
  281  * premapped region.
  282  */
  283 
  284 #define TTM_BO_MAP_IOMEM_MASK 0x80
  285 struct ttm_bo_kmap_obj {
  286         void *virtual;
  287         struct vm_page *page;
  288         struct sf_buf *sf;
  289         int num_pages;
  290         unsigned long size;
  291         enum {
  292                 ttm_bo_map_iomap        = 1 | TTM_BO_MAP_IOMEM_MASK,
  293                 ttm_bo_map_vmap         = 2,
  294                 ttm_bo_map_kmap         = 3,
  295                 ttm_bo_map_premapped    = 4 | TTM_BO_MAP_IOMEM_MASK,
  296         } bo_kmap_type;
  297         struct ttm_buffer_object *bo;
  298 };
  299 
  300 /**
  301  * ttm_bo_reference - reference a struct ttm_buffer_object
  302  *
  303  * @bo: The buffer object.
  304  *
  305  * Returns a refcounted pointer to a buffer object.
  306  */
  307 
  308 static inline struct ttm_buffer_object *
  309 ttm_bo_reference(struct ttm_buffer_object *bo)
  310 {
  311         refcount_acquire(&bo->kref);
  312         return bo;
  313 }
  314 
  315 /**
  316  * ttm_bo_wait - wait for buffer idle.
  317  *
  318  * @bo:  The buffer object.
  319  * @interruptible:  Use interruptible wait.
  320  * @no_wait:  Return immediately if buffer is busy.
  321  *
  322  * This function must be called with the bo::mutex held, and makes
  323  * sure any previous rendering to the buffer is completed.
  324  * Note: It might be necessary to block validations before the
  325  * wait by reserving the buffer.
  326  * Returns -EBUSY if no_wait is true and the buffer is busy.
  327  * Returns -ERESTARTSYS if interrupted by a signal.
  328  */
  329 extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
  330                        bool interruptible, bool no_wait);
  331 /**
  332  * ttm_bo_validate
  333  *
  334  * @bo: The buffer object.
  335  * @placement: Proposed placement for the buffer object.
  336  * @interruptible: Sleep interruptible if sleeping.
  337  * @no_wait_gpu: Return immediately if the GPU is busy.
  338  *
  339  * Changes placement and caching policy of the buffer object
  340  * according proposed placement.
  341  * Returns
  342  * -EINVAL on invalid proposed placement.
  343  * -ENOMEM on out-of-memory condition.
  344  * -EBUSY if no_wait is true and buffer busy.
  345  * -ERESTARTSYS if interrupted by a signal.
  346  */
  347 extern int ttm_bo_validate(struct ttm_buffer_object *bo,
  348                                 struct ttm_placement *placement,
  349                                 bool interruptible,
  350                                 bool no_wait_gpu);
  351 
  352 /**
  353  * ttm_bo_unref
  354  *
  355  * @bo: The buffer object.
  356  *
  357  * Unreference and clear a pointer to a buffer object.
  358  */
  359 extern void ttm_bo_unref(struct ttm_buffer_object **bo);
  360 
  361 
  362 /**
  363  * ttm_bo_list_ref_sub
  364  *
  365  * @bo: The buffer object.
  366  * @count: The number of references with which to decrease @bo::list_kref;
  367  * @never_free: The refcount should not reach zero with this operation.
  368  *
  369  * Release @count lru list references to this buffer object.
  370  */
  371 extern void ttm_bo_list_ref_sub(struct ttm_buffer_object *bo, int count,
  372                                 bool never_free);
  373 
  374 /**
  375  * ttm_bo_add_to_lru
  376  *
  377  * @bo: The buffer object.
  378  *
  379  * Add this bo to the relevant mem type lru and, if it's backed by
  380  * system pages (ttms) to the swap list.
  381  * This function must be called with struct ttm_bo_global::lru_lock held, and
  382  * is typically called immediately prior to unreserving a bo.
  383  */
  384 extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo);
  385 
  386 /**
  387  * ttm_bo_del_from_lru
  388  *
  389  * @bo: The buffer object.
  390  *
  391  * Remove this bo from all lru lists used to lookup and reserve an object.
  392  * This function must be called with struct ttm_bo_global::lru_lock held,
  393  * and is usually called just immediately after the bo has been reserved to
  394  * avoid recursive reservation from lru lists.
  395  */
  396 extern int ttm_bo_del_from_lru(struct ttm_buffer_object *bo);
  397 
  398 
  399 /**
  400  * ttm_bo_lock_delayed_workqueue
  401  *
  402  * Prevent the delayed workqueue from running.
  403  * Returns
  404  * True if the workqueue was queued at the time
  405  */
  406 extern int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev);
  407 
  408 /**
  409  * ttm_bo_unlock_delayed_workqueue
  410  *
  411  * Allows the delayed workqueue to run.
  412  */
  413 extern void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev,
  414                                             int resched);
  415 
  416 /**
  417  * ttm_bo_synccpu_write_grab
  418  *
  419  * @bo: The buffer object:
  420  * @no_wait: Return immediately if buffer is busy.
  421  *
  422  * Synchronizes a buffer object for CPU RW access. This means
  423  * command submission that affects the buffer will return -EBUSY
  424  * until ttm_bo_synccpu_write_release is called.
  425  *
  426  * Returns
  427  * -EBUSY if the buffer is busy and no_wait is true.
  428  * -ERESTARTSYS if interrupted by a signal.
  429  */
  430 extern int
  431 ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
  432 
  433 /**
  434  * ttm_bo_synccpu_write_release:
  435  *
  436  * @bo : The buffer object.
  437  *
  438  * Releases a synccpu lock.
  439  */
  440 extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
  441 
  442 /**
  443  * ttm_bo_acc_size
  444  *
  445  * @bdev: Pointer to a ttm_bo_device struct.
  446  * @bo_size: size of the buffer object in byte.
  447  * @struct_size: size of the structure holding buffer object datas
  448  *
  449  * Returns size to account for a buffer object
  450  */
  451 size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
  452                        unsigned long bo_size,
  453                        unsigned struct_size);
  454 size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
  455                            unsigned long bo_size,
  456                            unsigned struct_size);
  457 
  458 /**
  459  * ttm_bo_init
  460  *
  461  * @bdev: Pointer to a ttm_bo_device struct.
  462  * @bo: Pointer to a ttm_buffer_object to be initialized.
  463  * @size: Requested size of buffer object.
  464  * @type: Requested type of buffer object.
  465  * @flags: Initial placement flags.
  466  * @page_alignment: Data alignment in pages.
  467  * @interruptible: If needing to sleep to wait for GPU resources,
  468  * sleep interruptible.
  469  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  470  * pinned in physical memory. If this behaviour is not desired, this member
  471  * holds a pointer to a persistent shmem object. Typically, this would
  472  * point to the shmem object backing a GEM object if TTM is used to back a
  473  * GEM user interface.
  474  * @acc_size: Accounted size for this object.
  475  * @destroy: Destroy function. Use NULL for kfree().
  476  *
  477  * This function initializes a pre-allocated struct ttm_buffer_object.
  478  * As this object may be part of a larger structure, this function,
  479  * together with the @destroy function,
  480  * enables driver-specific objects derived from a ttm_buffer_object.
  481  * On successful return, the object kref and list_kref are set to 1.
  482  * If a failure occurs, the function will call the @destroy function, or
  483  * kfree() if @destroy is NULL. Thus, after a failure, dereferencing @bo is
  484  * illegal and will likely cause memory corruption.
  485  *
  486  * Returns
  487  * -ENOMEM: Out of memory.
  488  * -EINVAL: Invalid placement flags.
  489  * -ERESTARTSYS: Interrupted by signal while sleeping waiting for resources.
  490  */
  491 
  492 extern int ttm_bo_init(struct ttm_bo_device *bdev,
  493                         struct ttm_buffer_object *bo,
  494                         unsigned long size,
  495                         enum ttm_bo_type type,
  496                         struct ttm_placement *placement,
  497                         uint32_t page_alignment,
  498                         bool interrubtible,
  499                         struct vm_object *persistent_swap_storage,
  500                         size_t acc_size,
  501                         struct sg_table *sg,
  502                         void (*destroy) (struct ttm_buffer_object *));
  503 
  504 /**
  505  * ttm_bo_synccpu_object_init
  506  *
  507  * @bdev: Pointer to a ttm_bo_device struct.
  508  * @bo: Pointer to a ttm_buffer_object to be initialized.
  509  * @size: Requested size of buffer object.
  510  * @type: Requested type of buffer object.
  511  * @flags: Initial placement flags.
  512  * @page_alignment: Data alignment in pages.
  513  * @interruptible: If needing to sleep while waiting for GPU resources,
  514  * sleep interruptible.
  515  * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  516  * pinned in physical memory. If this behaviour is not desired, this member
  517  * holds a pointer to a persistent shmem object. Typically, this would
  518  * point to the shmem object backing a GEM object if TTM is used to back a
  519  * GEM user interface.
  520  * @p_bo: On successful completion *p_bo points to the created object.
  521  *
  522  * This function allocates a ttm_buffer_object, and then calls ttm_bo_init
  523  * on that object. The destroy function is set to kfree().
  524  * Returns
  525  * -ENOMEM: Out of memory.
  526  * -EINVAL: Invalid placement flags.
  527  * -ERESTARTSYS: Interrupted by signal while waiting for resources.
  528  */
  529 
  530 extern int ttm_bo_create(struct ttm_bo_device *bdev,
  531                                 unsigned long size,
  532                                 enum ttm_bo_type type,
  533                                 struct ttm_placement *placement,
  534                                 uint32_t page_alignment,
  535                                 bool interruptible,
  536                                 struct vm_object *persistent_swap_storage,
  537                                 struct ttm_buffer_object **p_bo);
  538 
  539 /**
  540  * ttm_bo_check_placement
  541  *
  542  * @bo:         the buffer object.
  543  * @placement:  placements
  544  *
  545  * Performs minimal validity checking on an intended change of
  546  * placement flags.
  547  * Returns
  548  * -EINVAL: Intended change is invalid or not allowed.
  549  */
  550 extern int ttm_bo_check_placement(struct ttm_buffer_object *bo,
  551                                         struct ttm_placement *placement);
  552 
  553 /**
  554  * ttm_bo_init_mm
  555  *
  556  * @bdev: Pointer to a ttm_bo_device struct.
  557  * @mem_type: The memory type.
  558  * @p_size: size managed area in pages.
  559  *
  560  * Initialize a manager for a given memory type.
  561  * Note: if part of driver firstopen, it must be protected from a
  562  * potentially racing lastclose.
  563  * Returns:
  564  * -EINVAL: invalid size or memory type.
  565  * -ENOMEM: Not enough memory.
  566  * May also return driver-specified errors.
  567  */
  568 
  569 extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
  570                                 unsigned long p_size);
  571 /**
  572  * ttm_bo_clean_mm
  573  *
  574  * @bdev: Pointer to a ttm_bo_device struct.
  575  * @mem_type: The memory type.
  576  *
  577  * Take down a manager for a given memory type after first walking
  578  * the LRU list to evict any buffers left alive.
  579  *
  580  * Normally, this function is part of lastclose() or unload(), and at that
  581  * point there shouldn't be any buffers left created by user-space, since
  582  * there should've been removed by the file descriptor release() method.
  583  * However, before this function is run, make sure to signal all sync objects,
  584  * and verify that the delayed delete queue is empty. The driver must also
  585  * make sure that there are no NO_EVICT buffers present in this memory type
  586  * when the call is made.
  587  *
  588  * If this function is part of a VT switch, the caller must make sure that
  589  * there are no appications currently validating buffers before this
  590  * function is called. The caller can do that by first taking the
  591  * struct ttm_bo_device::ttm_lock in write mode.
  592  *
  593  * Returns:
  594  * -EINVAL: invalid or uninitialized memory type.
  595  * -EBUSY: There are still buffers left in this memory type.
  596  */
  597 
  598 extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  599 
  600 /**
  601  * ttm_bo_evict_mm
  602  *
  603  * @bdev: Pointer to a ttm_bo_device struct.
  604  * @mem_type: The memory type.
  605  *
  606  * Evicts all buffers on the lru list of the memory type.
  607  * This is normally part of a VT switch or an
  608  * out-of-memory-space-due-to-fragmentation handler.
  609  * The caller must make sure that there are no other processes
  610  * currently validating buffers, and can do that by taking the
  611  * struct ttm_bo_device::ttm_lock in write mode.
  612  *
  613  * Returns:
  614  * -EINVAL: Invalid or uninitialized memory type.
  615  * -ERESTARTSYS: The call was interrupted by a signal while waiting to
  616  * evict a buffer.
  617  */
  618 
  619 extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
  620 
  621 /**
  622  * ttm_kmap_obj_virtual
  623  *
  624  * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap.
  625  * @is_iomem: Pointer to an integer that on return indicates 1 if the
  626  * virtual map is io memory, 0 if normal memory.
  627  *
  628  * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap.
  629  * If *is_iomem is 1 on return, the virtual address points to an io memory area,
  630  * that should strictly be accessed by the iowriteXX() and similar functions.
  631  */
  632 
  633 static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map,
  634                                          bool *is_iomem)
  635 {
  636         *is_iomem = !!(map->bo_kmap_type & TTM_BO_MAP_IOMEM_MASK);
  637         return map->virtual;
  638 }
  639 
  640 /**
  641  * ttm_bo_kmap
  642  *
  643  * @bo: The buffer object.
  644  * @start_page: The first page to map.
  645  * @num_pages: Number of pages to map.
  646  * @map: pointer to a struct ttm_bo_kmap_obj representing the map.
  647  *
  648  * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the
  649  * data in the buffer object. The ttm_kmap_obj_virtual function can then be
  650  * used to obtain a virtual address to the data.
  651  *
  652  * Returns
  653  * -ENOMEM: Out of memory.
  654  * -EINVAL: Invalid range.
  655  */
  656 
  657 extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
  658                        unsigned long num_pages, struct ttm_bo_kmap_obj *map);
  659 
  660 /**
  661  * ttm_bo_kunmap
  662  *
  663  * @map: Object describing the map to unmap.
  664  *
  665  * Unmaps a kernel map set up by ttm_bo_kmap.
  666  */
  667 
  668 extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
  669 
  670 /**
  671  * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
  672  *
  673  * @vma:       vma as input from the fbdev mmap method.
  674  * @bo:        The bo backing the address space. The address space will
  675  * have the same size as the bo, and start at offset 0.
  676  *
  677  * This function is intended to be called by the fbdev mmap method
  678  * if the fbdev address space is to be backed by a bo.
  679  */
  680 
  681 /* XXXKIB
  682 extern int ttm_fbdev_mmap(struct vm_area_struct *vma,
  683                           struct ttm_buffer_object *bo);
  684 */
  685 /**
  686  * ttm_bo_mmap - mmap out of the ttm device address space.
  687  *
  688  * @filp:      filp as input from the mmap method.
  689  * @vma:       vma as input from the mmap method.
  690  * @bdev:      Pointer to the ttm_bo_device with the address space manager.
  691  *
  692  * This function is intended to be called by the device mmap method.
  693  * if the device address space is to be backed by the bo manager.
  694  */
  695 /* XXXKIB
  696 extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
  697                        struct ttm_bo_device *bdev);
  698 */
  699 /**
  700  * ttm_bo_io
  701  *
  702  * @bdev:      Pointer to the struct ttm_bo_device.
  703  * @filp:      Pointer to the struct file attempting to read / write.
  704  * @wbuf:      User-space pointer to address of buffer to write. NULL on read.
  705  * @rbuf:      User-space pointer to address of buffer to read into.
  706  * Null on write.
  707  * @count:     Number of bytes to read / write.
  708  * @f_pos:     Pointer to current file position.
  709  * @write:     1 for read, 0 for write.
  710  *
  711  * This function implements read / write into ttm buffer objects, and is
  712  * intended to
  713  * be called from the fops::read and fops::write method.
  714  * Returns:
  715  * See man (2) write, man(2) read. In particular,
  716  * the function may return -ERESTARTSYS if
  717  * interrupted by a signal.
  718  */
  719 
  720 extern ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp,
  721                          const char *wbuf, char *rbuf,
  722                          size_t count, off_t *f_pos, bool write);
  723 
  724 extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev);
  725 
  726 /**
  727  * ttm_bo_is_reserved - return an indication if a ttm buffer object is reserved
  728  *
  729  * @bo:     The buffer object to check.
  730  *
  731  * This function returns an indication if a bo is reserved or not, and should
  732  * only be used to print an error when it is not from incorrect api usage, since
  733  * there's no guarantee that it is the caller that is holding the reservation.
  734  */
  735 static inline bool ttm_bo_is_reserved(struct ttm_buffer_object *bo)
  736 {
  737         return atomic_read(&bo->reserved);
  738 }
  739 
  740 #endif

Cache object: 43354a6aeca4773ecf37600c1fc3ed9c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.