Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770/* * Copyright © 2008 Intel Corporation * * 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 * THE AUTHORS OR COPYRIGHT HOLDERS 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. * * Authors: * Eric Anholt <eric@anholt.net> * */
#include <linux/dma-buf.h>#include <linux/export.h>#include <linux/file.h>#include <linux/fs.h>#ifdef CONFIG_TRANSPARENT_HUGEPAGE#include <linux/fs_context.h>#endif#include <linux/iosys-map.h>#include <linux/mem_encrypt.h>#include <linux/mm.h>#include <linux/mman.h>#include <linux/module.h>#include <linux/pagemap.h>#include <linux/folio_batch.h>#include <linux/sched/mm.h>#include <linux/shmem_fs.h>#include <linux/slab.h>#include <linux/string_helpers.h>#include <linux/types.h>#include <linux/uaccess.h>
#include <drm/drm.h>#include <drm/drm_device.h>#include <drm/drm_drv.h>#include <drm/drm_file.h>#include <drm/drm_gem.h>#include <drm/drm_managed.h>#include <drm/drm_print.h>#include <drm/drm_vma_manager.h>
#include "drm_internal.h"
/** @file drm_gem.c * * This file provides some of the base ioctls and library routines for * the graphics memory manager implemented by each device driver. * * Because various devices have different requirements in terms of * synchronization and migration strategies, implementing that is left up to * the driver, and all that the general API provides should be generic -- * allocating objects, reading/writing data with the cpu, freeing objects. * Even there, platform-dependent optimizations for reading/writing data with * the CPU mean we'll likely hook those out to driver-specific calls. However, * the DRI2 implementation wants to have at least allocate/mmap be generic. * * The goal was to have swap-backed object allocation managed through * struct file. However, file descriptors as handles to a struct file have * two major failings: * - Process limits prevent more than 1024 or so being used at a time by * default. * - Inability to allocate high fds will aggravate the X Server's select() * handling, and likely that of many GL client applications as well. * * This led to a plan of using our own integer IDs (called handles, following * DRM terminology) to mimic fds, and implement the fd syscalls we need as * ioctls. The objects themselves will still include the struct file so * that we can transition to fds if the required kernel infrastructure shows * up at a later date, and as our interface with shmfs for memory allocation. */
#ifdef CONFIG_TRANSPARENT_HUGEPAGEstatic void drm_gem_huge_mnt_free(struct drm_device *dev, void *data){ kern_unmount(dev->huge_mnt);}
/** * drm_gem_huge_mnt_create - Create, mount and use a huge tmpfs mountpoint * @dev: DRM device that will use the huge tmpfs mountpoint * @value: huge tmpfs mount option value * * This function creates and mounts a dedicated huge tmpfs mountpoint for the * lifetime of the DRM device @dev which is used at GEM object initialization * with drm_gem_object_init(). * * The most common option for @value is "within_size" which only allocates huge * pages if the page will be fully within the GEM object size. "always", * "advise" and "never" are supported too but the latter would just create a * mountpoint similar to the default one (`shm_mnt`). See shmemfs and * Transparent Hugepage for more information. * * Returns: * 0 on success or a negative error code on failure. */int drm_gem_huge_mnt_create(struct drm_device *dev, const char *value){ struct file_system_type *type; struct fs_context *fc; int ret;
if (unlikely(drm_gem_get_huge_mnt(dev))) return 0;
type = get_fs_type("tmpfs"); if (unlikely(!type)) return -EOPNOTSUPP; fc = fs_context_for_mount(type, SB_KERNMOUNT); if (IS_ERR(fc)) return PTR_ERR(fc); ret = vfs_parse_fs_string(fc, "source", "tmpfs"); if (unlikely(ret)) return -ENOPARAM; ret = vfs_parse_fs_string(fc, "huge", value); if (unlikely(ret)) return -ENOPARAM;
dev->huge_mnt = fc_mount_longterm(fc); put_fs_context(fc);
return drmm_add_action_or_reset(dev, drm_gem_huge_mnt_free, NULL);}EXPORT_SYMBOL_GPL(drm_gem_huge_mnt_create);#endif
static voiddrm_gem_init_release(struct drm_device *dev, void *ptr){ drm_vma_offset_manager_destroy(dev->vma_offset_manager);}
/** * drm_gem_init - Initialize the GEM device fields * @dev: drm_devic structure to initialize */intdrm_gem_init(struct drm_device *dev){ struct drm_vma_offset_manager *vma_offset_manager;
mutex_init(&dev->object_name_lock); idr_init_base(&dev->object_name_idr, 1);
vma_offset_manager = drmm_kzalloc(dev, sizeof(*vma_offset_manager), GFP_KERNEL); if (!vma_offset_manager) return -ENOMEM;
dev->vma_offset_manager = vma_offset_manager; drm_vma_offset_manager_init(vma_offset_manager, DRM_FILE_PAGE_OFFSET_START, DRM_FILE_PAGE_OFFSET_SIZE);
return drmm_add_action(dev, drm_gem_init_release, NULL);}
/** * drm_gem_object_init - initialize an allocated shmem-backed GEM object * * @dev: drm_device the object should be initialized for * @obj: drm_gem_object to initialize * @size: object size * * Initialize an already allocated GEM object of the specified size with * shmfs backing store. A huge mountpoint can be used by calling * drm_gem_huge_mnt_create() beforehand. */int drm_gem_object_init(struct drm_device *dev, struct drm_gem_object *obj, size_t size){ struct vfsmount *huge_mnt; struct file *filp; const vma_flags_t flags = mk_vma_flags(VMA_NORESERVE_BIT);
drm_gem_private_object_init(dev, obj, size);
huge_mnt = drm_gem_get_huge_mnt(dev); if (huge_mnt) filp = shmem_file_setup_with_mnt(huge_mnt, "drm mm object", size, flags); else filp = shmem_file_setup("drm mm object", size, flags);
if (IS_ERR(filp)) return PTR_ERR(filp);
obj->filp = filp;
return 0;}EXPORT_SYMBOL(drm_gem_object_init);
/** * drm_gem_private_object_init - initialize an allocated private GEM object * @dev: drm_device the object should be initialized for * @obj: drm_gem_object to initialize * @size: object size * * Initialize an already allocated GEM object of the specified size with * no GEM provided backing store. Instead the caller is responsible for * backing the object and handling it. */void drm_gem_private_object_init(struct drm_device *dev, struct drm_gem_object *obj, size_t size){ BUG_ON((size & (PAGE_SIZE - 1)) != 0);
obj->dev = dev; obj->filp = NULL;
kref_init(&obj->refcount); obj->handle_count = 0; obj->size = size; mutex_init(&obj->gpuva.lock); dma_resv_init(&obj->_resv); if (!obj->resv) obj->resv = &obj->_resv;
if (drm_core_check_feature(dev, DRIVER_GEM_GPUVA)) drm_gem_gpuva_init(obj);
drm_vma_node_reset(&obj->vma_node); INIT_LIST_HEAD(&obj->lru_node);}EXPORT_SYMBOL(drm_gem_private_object_init);
/** * drm_gem_private_object_fini - Finalize a failed drm_gem_object * @obj: drm_gem_object * * Uninitialize an already allocated GEM object when it initialized failed */void drm_gem_private_object_fini(struct drm_gem_object *obj){ WARN_ON(obj->dma_buf);
dma_resv_fini(&obj->_resv); mutex_destroy(&obj->gpuva.lock);}EXPORT_SYMBOL(drm_gem_private_object_fini);
static void drm_gem_object_handle_get(struct drm_gem_object *obj){ struct drm_device *dev = obj->dev;
drm_WARN_ON(dev, !mutex_is_locked(&dev->object_name_lock));
if (obj->handle_count++ == 0) drm_gem_object_get(obj);}
/** * drm_gem_object_handle_get_if_exists_unlocked - acquire reference on user-space handle, if any * @obj: GEM object * * Acquires a reference on the GEM buffer object's handle. Required to keep * the GEM object alive. Call drm_gem_object_handle_put_if_exists_unlocked() * to release the reference. Does nothing if the buffer object has no handle. * * Returns: * True if a handle exists, or false otherwise */bool drm_gem_object_handle_get_if_exists_unlocked(struct drm_gem_object *obj){ struct drm_device *dev = obj->dev;
guard(mutex)(&dev->object_name_lock);
/* * First ref taken during GEM object creation, if any. Some * drivers set up internal framebuffers with GEM objects that * do not have a GEM handle. Hence, this counter can be zero. */ if (!obj->handle_count) return false;
drm_gem_object_handle_get(obj);
return true;}
/** * drm_gem_object_handle_free - release resources bound to userspace handles * @obj: GEM object to clean up. * * Called after the last handle to the object has been closed * * Removes any name for the object. Note that this must be * called before drm_gem_object_free or we'll be touching * freed memory */static void drm_gem_object_handle_free(struct drm_gem_object *obj){ struct drm_device *dev = obj->dev;
/* Remove any name for this object */ if (obj->name) { idr_remove(&dev->object_name_idr, obj->name); obj->name = 0; }}
static void drm_gem_object_exported_dma_buf_free(struct drm_gem_object *obj){ /* Unbreak the reference cycle if we have an exported dma_buf. */ if (obj->dma_buf) { dma_buf_put(obj->dma_buf); obj->dma_buf = NULL; }}
/** * drm_gem_object_handle_put_unlocked - releases reference on user-space handle * @obj: GEM object * * Releases a reference on the GEM buffer object's handle. Possibly releases * the GEM buffer object and associated dma-buf objects. */void drm_gem_object_handle_put_unlocked(struct drm_gem_object *obj){ struct drm_device *dev = obj->dev; bool final = false;
if (drm_WARN_ON(dev, READ_ONCE(obj->handle_count) == 0)) return;
/* * Must bump handle count first as this may be the last * ref, in which case the object would disappear before * we checked for a name. */
mutex_lock(&dev->object_name_lock); if (--obj->handle_count == 0) { drm_gem_object_handle_free(obj); drm_gem_object_exported_dma_buf_free(obj); final = true; } mutex_unlock(&dev->object_name_lock);
if (final) drm_gem_object_put(obj);}
/* * Called at device or object close to release the file's * handle references on objects. */static intdrm_gem_object_release_handle(int id, void *ptr, void *data){ struct drm_file *file_priv = data; struct drm_gem_object *obj = ptr;
if (drm_WARN_ON(obj->dev, !data)) return 0;
if (obj->funcs->close) obj->funcs->close(obj, file_priv);
mutex_lock(&file_priv->prime.lock);
drm_prime_remove_buf_handle(&file_priv->prime, id);
mutex_unlock(&file_priv->prime.lock);
drm_vma_node_revoke(&obj->vma_node, file_priv);
drm_gem_object_handle_put_unlocked(obj);
return 0;}
/** * drm_gem_handle_delete - deletes the given file-private handle * @filp: drm file-private structure to use for the handle look up * @handle: userspace handle to delete * * Removes the GEM handle from the @filp lookup table which has been added with * drm_gem_handle_create(). If this is the last handle also cleans up linked * resources like GEM names. */intdrm_gem_handle_delete(struct drm_file *filp, u32 handle){ struct drm_gem_object *obj;
spin_lock(&filp->table_lock);
/* Check if we currently have a reference on the object */ obj = idr_replace(&filp->object_idr, NULL, handle); spin_unlock(&filp->table_lock); if (IS_ERR_OR_NULL(obj)) return -EINVAL;
/* Release driver's reference and decrement refcount. */ drm_gem_object_release_handle(handle, obj, filp);
/* And finally make the handle available for future allocations. */ spin_lock(&filp->table_lock); idr_remove(&filp->object_idr, handle); spin_unlock(&filp->table_lock);
return 0;}EXPORT_SYMBOL(drm_gem_handle_delete);
/** * drm_gem_dumb_map_offset - return the fake mmap offset for a gem object * @file: drm file-private structure containing the gem object * @dev: corresponding drm_device * @handle: gem object handle * @offset: return location for the fake mmap offset * * This implements the &drm_driver.dumb_map_offset kms driver callback for * drivers which use gem to manage their backing storage. * * Returns: * 0 on success or a negative error code on failure. */int drm_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev, u32 handle, u64 *offset){ struct drm_gem_object *obj; int ret;
obj = drm_gem_object_lookup(file, handle); if (!obj) return -ENOENT;
/* Don't allow imported objects to be mapped */ if (drm_gem_is_imported(obj)) { ret = -EINVAL; goto out; }
ret = drm_gem_create_mmap_offset(obj); if (ret) goto out;
*offset = drm_vma_node_offset_addr(&obj->vma_node);out: drm_gem_object_put(obj);
return ret;}EXPORT_SYMBOL_GPL(drm_gem_dumb_map_offset);
/** * drm_gem_handle_create_tail - internal functions to create a handle * @file_priv: drm file-private structure to register the handle for * @obj: object to register * @handlep: pointer to return the created handle to the caller * * This expects the &drm_device.object_name_lock to be held already and will * drop it before returning. Used to avoid races in establishing new handles * when importing an object from either an flink name or a dma-buf. * * Handles must be release again through drm_gem_handle_delete(). This is done * when userspace closes @file_priv for all attached handles, or through the * GEM_CLOSE ioctl for individual handles. */intdrm_gem_handle_create_tail(struct drm_file *file_priv, struct drm_gem_object *obj, u32 *handlep){ struct drm_device *dev = obj->dev; u32 handle; int ret;
WARN_ON(!mutex_is_locked(&dev->object_name_lock));
drm_gem_object_handle_get(obj);
/* * Get the user-visible handle using idr. Preload and perform * allocation under our spinlock. */ idr_preload(GFP_KERNEL); spin_lock(&file_priv->table_lock);
ret = idr_alloc(&file_priv->object_idr, NULL, 1, 0, GFP_NOWAIT);
spin_unlock(&file_priv->table_lock); idr_preload_end();
mutex_unlock(&dev->object_name_lock); if (ret < 0) goto err_unref;
handle = ret;
ret = drm_vma_node_allow(&obj->vma_node, file_priv); if (ret) goto err_remove;
if (obj->funcs->open) { ret = obj->funcs->open(obj, file_priv); if (ret) goto err_revoke; }
/* mirrors drm_gem_handle_delete to avoid races */ spin_lock(&file_priv->table_lock); obj = idr_replace(&file_priv->object_idr, obj, handle); WARN_ON(obj != NULL); spin_unlock(&file_priv->table_lock); *handlep = handle; return 0;
err_revoke: drm_vma_node_revoke(&obj->vma_node, file_priv);err_remove: spin_lock(&file_priv->table_lock); idr_remove(&file_priv->object_idr, handle); spin_unlock(&file_priv->table_lock);err_unref: drm_gem_object_handle_put_unlocked(obj); return ret;}
/** * drm_gem_handle_create - create a gem handle for an object * @file_priv: drm file-private structure to register the handle for * @obj: object to register * @handlep: pointer to return the created handle to the caller * * Create a handle for this object. This adds a handle reference to the object, * which includes a regular reference count. Callers will likely want to * dereference the object afterwards. * * Since this publishes @obj to userspace it must be fully set up by this point, * drivers must call this last in their buffer object creation callbacks. */int drm_gem_handle_create(struct drm_file *file_priv, struct drm_gem_object *obj, u32 *handlep){ mutex_lock(&obj->dev->object_name_lock);
return drm_gem_handle_create_tail(file_priv, obj, handlep);}EXPORT_SYMBOL(drm_gem_handle_create);
/** * drm_gem_free_mmap_offset - release a fake mmap offset for an object * @obj: obj in question * * This routine frees fake offsets allocated by drm_gem_create_mmap_offset(). * * Note that drm_gem_object_release() already calls this function, so drivers * don't have to take care of releasing the mmap offset themselves when freeing * the GEM object. */voiddrm_gem_free_mmap_offset(struct drm_gem_object *obj){ struct drm_device *dev = obj->dev;
drm_vma_offset_remove(dev->vma_offset_manager, &obj->vma_node);}EXPORT_SYMBOL(drm_gem_free_mmap_offset);
/** * drm_gem_create_mmap_offset_size - create a fake mmap offset for an object * @obj: obj in question * @size: the virtual size * * GEM memory mapping works by handing back to userspace a fake mmap offset * it can use in a subsequent mmap(2) call. The DRM core code then looks * up the object based on the offset and sets up the various memory mapping * structures. * * This routine allocates and attaches a fake offset for @obj, in cases where * the virtual size differs from the physical size (ie. &drm_gem_object.size). * Otherwise just use drm_gem_create_mmap_offset(). * * This function is idempotent and handles an already allocated mmap offset * transparently. Drivers do not need to check for this case. */intdrm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size){ struct drm_device *dev = obj->dev;
return drm_vma_offset_add(dev->vma_offset_manager, &obj->vma_node, size / PAGE_SIZE);}EXPORT_SYMBOL(drm_gem_create_mmap_offset_size);
/** * drm_gem_create_mmap_offset - create a fake mmap offset for an object * @obj: obj in question * * GEM memory mapping works by handing back to userspace a fake mmap offset * it can use in a subsequent mmap(2) call. The DRM core code then looks * up the object based on the offset and sets up the various memory mapping * structures. * * This routine allocates and attaches a fake offset for @obj. * * Drivers can call drm_gem_free_mmap_offset() before freeing @obj to release * the fake offset again. */int drm_gem_create_mmap_offset(struct drm_gem_object *obj){ return drm_gem_create_mmap_offset_size(obj, obj->size);}EXPORT_SYMBOL(drm_gem_create_mmap_offset);
/* * Move folios to appropriate lru and release the folios, decrementing the * ref count of those folios. */static void drm_gem_check_release_batch(struct folio_batch *fbatch){ check_move_unevictable_folios(fbatch); __folio_batch_release(fbatch); cond_resched();}
/** * drm_gem_get_pages - helper to allocate backing pages for a GEM object * from shmem * @obj: obj in question * * This reads the page-array of the shmem-backing storage of the given gem * object. An array of pages is returned. If a page is not allocated or * swapped-out, this will allocate/swap-in the required pages. Note that the * whole object is covered by the page-array and pinned in memory. * * Use drm_gem_put_pages() to release the array and unpin all pages. * * This uses the GFP-mask set on the shmem-mapping (see mapping_set_gfp_mask()). * If you require other GFP-masks, you have to do those allocations yourself. * * Note that you are not allowed to change gfp-zones during runtime. That is, * shmem_read_mapping_page_gfp() must be called with the same gfp_zone(gfp) as * set during initialization. If you have special zone constraints, set them * after drm_gem_object_init() via mapping_set_gfp_mask(). shmem-core takes care * to keep pages in the required zone during swap-in. * * This function is only valid on objects initialized with * drm_gem_object_init(), but not for those initialized with * drm_gem_private_object_init() only. */struct page **drm_gem_get_pages(struct drm_gem_object *obj){ struct address_space *mapping; struct page **pages; struct folio *folio; struct folio_batch fbatch; unsigned long i, j, npages;
if (WARN_ON(!obj->filp)) return ERR_PTR(-EINVAL);
/* This is the shared memory object that backs the GEM resource */ mapping = obj->filp->f_mapping;
/* We already BUG_ON() for non-page-aligned sizes in * drm_gem_object_init(), so we should never hit this unless * driver author is doing something really wrong: */ WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
npages = obj->size >> PAGE_SHIFT;
pages = kvmalloc_objs(struct page *, npages); if (pages == NULL) return ERR_PTR(-ENOMEM);
mapping_set_unevictable(mapping);
i = 0; while (i < npages) { unsigned long nr; folio = shmem_read_folio_gfp(mapping, i, mapping_gfp_mask(mapping)); if (IS_ERR(folio)) goto fail; nr = min(npages - i, folio_nr_pages(folio)); for (j = 0; j < nr; j++, i++) pages[i] = folio_file_page(folio, i);
/* Make sure shmem keeps __GFP_DMA32 allocated pages in the * correct region during swapin. Note that this requires * __GFP_DMA32 to be set in mapping_gfp_mask(inode->i_mapping) * so shmem can relocate pages during swapin if required. */ BUG_ON(mapping_gfp_constraint(mapping, __GFP_DMA32) && (folio_pfn(folio) >= 0x00100000UL)); }
return pages;
fail: mapping_clear_unevictable(mapping); folio_batch_init(&fbatch); j = 0; while (j < i) { struct folio *f = page_folio(pages[j]); if (!folio_batch_add(&fbatch, f)) drm_gem_check_release_batch(&fbatch); j += folio_nr_pages(f); } if (fbatch.nr) drm_gem_check_release_batch(&fbatch);
kvfree(pages); return ERR_CAST(folio);}EXPORT_SYMBOL(drm_gem_get_pages);
/** * drm_gem_put_pages - helper to free backing pages for a GEM object * @obj: obj in question * @pages: pages to free * @dirty: if true, pages will be marked as dirty * @accessed: if true, the pages will be marked as accessed */void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages, bool dirty, bool accessed){ int i, npages; struct address_space *mapping; struct folio_batch fbatch;
mapping = file_inode(obj->filp)->i_mapping; mapping_clear_unevictable(mapping);
/* We already BUG_ON() for non-page-aligned sizes in * drm_gem_object_init(), so we should never hit this unless * driver author is doing something really wrong: */ WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
npages = obj->size >> PAGE_SHIFT;
folio_batch_init(&fbatch); for (i = 0; i < npages; i++) { struct folio *folio;
if (!pages[i]) continue; folio = page_folio(pages[i]);
if (dirty) folio_mark_dirty(folio);
if (accessed) folio_mark_accessed(folio);
/* Undo the reference we took when populating the table */ if (!folio_batch_add(&fbatch, folio)) drm_gem_check_release_batch(&fbatch); i += folio_nr_pages(folio) - 1; } if (folio_batch_count(&fbatch)) drm_gem_check_release_batch(&fbatch);
kvfree(pages);}EXPORT_SYMBOL(drm_gem_put_pages);
static int objects_lookup(struct drm_file *filp, u32 *handle, int count, struct drm_gem_object **objs){ int i; struct drm_gem_object *obj;
spin_lock(&filp->table_lock);
for (i = 0; i < count; i++) { /* Check if we currently have a reference on the object */ obj = idr_find(&filp->object_idr, handle[i]); if (!obj) goto err;
drm_gem_object_get(obj); objs[i] = obj; }
spin_unlock(&filp->table_lock); return 0;
err: spin_unlock(&filp->table_lock);
while (i--) drm_gem_object_put(objs[i]);
return -ENOENT;}
/** * drm_gem_objects_lookup - look up GEM objects from an array of handles * @filp: DRM file private date * @bo_handles: user pointer to array of userspace handle * @count: size of handle array * @objs_out: returned pointer to array of drm_gem_object pointers * * Takes an array of userspace handles and returns a newly allocated array of * GEM objects. * * After a successful lookup GEM objects need to be released using * drm_gem_object_put() and the array returned in @objs_out must be freed using * kvfree(). * * For a single handle lookup, use drm_gem_object_lookup(). * * Return: * Zero on success or a negative error code. */int drm_gem_objects_lookup(struct drm_file *filp, void __user *bo_handles, int count, struct drm_gem_object ***objs_out){ struct drm_gem_object **objs; u32 *handles; int ret;
*objs_out = NULL;
if (!count) return 0;
objs = kvmalloc_objs(*objs, count); if (!objs) return -ENOMEM;
handles = vmemdup_array_user(bo_handles, count, sizeof(u32)); if (IS_ERR(handles)) { ret = PTR_ERR(handles); goto err_free_objs; }
ret = objects_lookup(filp, handles, count, objs); if (ret) goto err_free_handles;
kvfree(handles); *objs_out = objs; return 0;
err_free_handles: kvfree(handles);err_free_objs: kvfree(objs); return ret;}EXPORT_SYMBOL(drm_gem_objects_lookup);
/** * drm_gem_object_lookup - look up a GEM object from its handle * @filp: DRM file private date * @handle: userspace handle * * If looking up an array of handles, use drm_gem_objects_lookup(). * * Returns: * A reference to the object named by the handle if such exists on @filp, NULL * otherwise. */struct drm_gem_object *drm_gem_object_lookup(struct drm_file *filp, u32 handle){ struct drm_gem_object *obj = NULL;
objects_lookup(filp, &handle, 1, &obj); return obj;}EXPORT_SYMBOL(drm_gem_object_lookup);
/** * drm_gem_dma_resv_wait - Wait on GEM object's reservation's objects * shared and/or exclusive fences. * @filep: DRM file private date * @handle: userspace handle * @wait_all: if true, wait on all fences, else wait on just exclusive fence * @timeout: timeout value in jiffies or zero to return immediately * * Returns: * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or * greater than 0 on success. */long drm_gem_dma_resv_wait(struct drm_file *filep, u32 handle, bool wait_all, unsigned long timeout){ struct drm_device *dev = filep->minor->dev; struct drm_gem_object *obj; long ret;
obj = drm_gem_object_lookup(filep, handle); if (!obj) { drm_dbg_core(dev, "Failed to look up GEM BO %d\n", handle); return -EINVAL; }
ret = dma_resv_wait_timeout(obj->resv, dma_resv_usage_rw(wait_all), true, timeout); if (ret == 0) ret = -ETIME; else if (ret > 0) ret = 0;
drm_gem_object_put(obj);
return ret;}EXPORT_SYMBOL(drm_gem_dma_resv_wait);
intdrm_gem_close_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv){ struct drm_gem_close *args = data; int ret;
if (!drm_core_check_feature(dev, DRIVER_GEM)) return -EOPNOTSUPP;
ret = drm_gem_handle_delete(file_priv, args->handle);
return ret;}
intdrm_gem_flink_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv){ struct drm_gem_flink *args = data; struct drm_gem_object *obj; int ret;
if (!drm_core_check_feature(dev, DRIVER_GEM)) return -EOPNOTSUPP;
obj = drm_gem_object_lookup(file_priv, args->handle); if (obj == NULL) return -ENOENT;
mutex_lock(&dev->object_name_lock); /* prevent races with concurrent gem_close. */ if (obj->handle_count == 0) { ret = -ENOENT; goto err; }
if (!obj->name) { ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_KERNEL); if (ret < 0) goto err;
obj->name = ret; }
args->name = (uint64_t) obj->name; ret = 0;
err: mutex_unlock(&dev->object_name_lock); drm_gem_object_put(obj); return ret;}
intdrm_gem_open_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv){ struct drm_gem_open *args = data; struct drm_gem_object *obj; int ret; u32 handle;
if (!drm_core_check_feature(dev, DRIVER_GEM)) return -EOPNOTSUPP;
mutex_lock(&dev->object_name_lock); obj = idr_find(&dev->object_name_idr, (int) args->name); if (obj) { drm_gem_object_get(obj); } else { mutex_unlock(&dev->object_name_lock); return -ENOENT; }
/* drm_gem_handle_create_tail unlocks dev->object_name_lock. */ ret = drm_gem_handle_create_tail(file_priv, obj, &handle); if (ret) goto err;
args->handle = handle; args->size = obj->size;
err: drm_gem_object_put(obj); return ret;}
/* * This ioctl is disabled for security reasons but also it failed * to follow process in terms of adding testing in igt and verifying * all the corner cases which made fixing security bugs in it even * harder than necessary. * * To re-enable this ioctl * 1. land working IGT tests in igt-gpu-tools that cover * all corner cases and race conditions. * 2. handle idr_preload * 3. handle == 0 * 4. handle == new_handle semantics definition. */int drm_gem_change_handle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv){ struct drm_gem_change_handle *args = data; struct drm_gem_object *obj; int new_handle, ret;
if (!drm_core_check_feature(dev, DRIVER_GEM)) return -EOPNOTSUPP;
/* idr_alloc() limitation. */ if (args->new_handle > INT_MAX) return -EINVAL; new_handle = args->new_handle;
if (args->handle == new_handle) return 0;
mutex_lock(&file_priv->prime.lock); spin_lock(&file_priv->table_lock); ret = idr_alloc(&file_priv->object_idr, NULL, new_handle, new_handle + 1, GFP_NOWAIT);
if (ret < 0) { spin_unlock(&file_priv->table_lock); goto out_unlock; }
obj = idr_replace(&file_priv->object_idr, NULL, args->handle); if (IS_ERR_OR_NULL(obj)) { idr_remove(&file_priv->object_idr, new_handle); spin_unlock(&file_priv->table_lock); ret = -ENOENT; goto out_unlock; } spin_unlock(&file_priv->table_lock);
if (obj->dma_buf) { ret = drm_prime_add_buf_handle(&file_priv->prime, obj->dma_buf, new_handle); if (ret < 0) { spin_lock(&file_priv->table_lock); idr_remove(&file_priv->object_idr, new_handle); idr_replace(&file_priv->object_idr, obj, args->handle); spin_unlock(&file_priv->table_lock); goto out_unlock; }
drm_prime_remove_buf_handle(&file_priv->prime, args->handle); }
ret = 0;
spin_lock(&file_priv->table_lock); idr_remove(&file_priv->object_idr, args->handle); obj = idr_replace(&file_priv->object_idr, obj, new_handle); spin_unlock(&file_priv->table_lock); WARN_ON(obj != NULL);
out_unlock: mutex_unlock(&file_priv->prime.lock);
return ret;}
/** * drm_gem_open - initializes GEM file-private structures at devnode open time * @dev: drm_device which is being opened by userspace * @file_private: drm file-private structure to set up * * Called at device open time, sets up the structure for handling refcounting * of mm objects. */voiddrm_gem_open(struct drm_device *dev, struct drm_file *file_private){ idr_init_base(&file_private->object_idr, 1); spin_lock_init(&file_private->table_lock);}
/** * drm_gem_release - release file-private GEM resources * @dev: drm_device which is being closed by userspace * @file_private: drm file-private structure to clean up * * Called at close time when the filp is going away. * * Releases any remaining references on objects by this filp. */voiddrm_gem_release(struct drm_device *dev, struct drm_file *file_private){ idr_for_each(&file_private->object_idr, &drm_gem_object_release_handle, file_private); idr_destroy(&file_private->object_idr);}
/** * drm_gem_object_release - release GEM buffer object resources * @obj: GEM buffer object * * This releases any structures and resources used by @obj and is the inverse of * drm_gem_object_init(). */voiddrm_gem_object_release(struct drm_gem_object *obj){ if (obj->filp) fput(obj->filp);
drm_gem_private_object_fini(obj);
drm_gem_free_mmap_offset(obj); drm_gem_lru_remove(obj);}EXPORT_SYMBOL(drm_gem_object_release);
/** * drm_gem_object_free - free a GEM object * @kref: kref of the object to free * * Called after the last reference to the object has been lost. * * Frees the object */voiddrm_gem_object_free(struct kref *kref){ struct drm_gem_object *obj = container_of(kref, struct drm_gem_object, refcount);
if (WARN_ON(!obj->funcs->free)) return;
obj->funcs->free(obj);}EXPORT_SYMBOL(drm_gem_object_free);
/** * drm_gem_vm_open - vma->ops->open implementation for GEM * @vma: VM area structure * * This function implements the #vm_operations_struct open() callback for GEM * drivers. This must be used together with drm_gem_vm_close(). */void drm_gem_vm_open(struct vm_area_struct *vma){ struct drm_gem_object *obj = vma->vm_private_data;
drm_gem_object_get(obj);}EXPORT_SYMBOL(drm_gem_vm_open);
/** * drm_gem_vm_close - vma->ops->close implementation for GEM * @vma: VM area structure * * This function implements the #vm_operations_struct close() callback for GEM * drivers. This must be used together with drm_gem_vm_open(). */void drm_gem_vm_close(struct vm_area_struct *vma){ struct drm_gem_object *obj = vma->vm_private_data;
drm_gem_object_put(obj);}EXPORT_SYMBOL(drm_gem_vm_close);
/** * drm_gem_mmap_obj - memory map a GEM object * @obj: the GEM object to map * @obj_size: the object size to be mapped, in bytes * @vma: VMA for the area to be mapped * * Set up the VMA to prepare mapping of the GEM object using the GEM object's * vm_ops. Depending on their requirements, GEM objects can either * provide a fault handler in their vm_ops (in which case any accesses to * the object will be trapped, to perform migration, GTT binding, surface * register allocation, or performance monitoring), or mmap the buffer memory * synchronously after calling drm_gem_mmap_obj. * * This function is mainly intended to implement the DMABUF mmap operation, when * the GEM object is not looked up based on its fake offset. To implement the * DRM mmap operation, drivers should use the drm_gem_mmap() function. * * drm_gem_mmap_obj() assumes the user is granted access to the buffer while * drm_gem_mmap() prevents unprivileged users from mapping random objects. So * callers must verify access restrictions before calling this helper. * * Return 0 or success or -EINVAL if the object size is smaller than the VMA * size, or if no vm_ops are provided. */int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size, struct vm_area_struct *vma){ int ret;
/* Check for valid size. */ if (obj_size < vma->vm_end - vma->vm_start) return -EINVAL;
/* Take a ref for this mapping of the object, so that the fault * handler can dereference the mmap offset's pointer to the object. * This reference is cleaned up by the corresponding vm_close * (which should happen whether the vma was created by this call, or * by a vm_open due to mremap or partial unmap or whatever). */ drm_gem_object_get(obj);
vma->vm_private_data = obj; vma->vm_ops = obj->funcs->vm_ops;
if (obj->funcs->mmap) { ret = obj->funcs->mmap(obj, vma); if (ret) goto err_drm_gem_object_put; WARN_ON(!(vma->vm_flags & VM_DONTEXPAND)); } else { if (!vma->vm_ops) { ret = -EINVAL; goto err_drm_gem_object_put; }
vm_flags_set(vma, VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP); vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags)); vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot); }
return 0;
err_drm_gem_object_put: drm_gem_object_put(obj); return ret;}EXPORT_SYMBOL(drm_gem_mmap_obj);
/* * Look up a GEM object in offset space based on the exact start address. The * caller must be granted access to the object. Returns a GEM object on success * or a negative error code on failure. The returned GEM object needs to be * released with drm_gem_object_put(). */static struct drm_gem_object *drm_gem_object_lookup_at_offset(struct file *filp, unsigned long start, unsigned long pages){ struct drm_file *priv = filp->private_data; struct drm_device *dev = priv->minor->dev; struct drm_gem_object *obj = NULL; struct drm_vma_offset_node *node;
if (drm_dev_is_unplugged(dev)) return ERR_PTR(-ENODEV);
drm_vma_offset_lock_lookup(dev->vma_offset_manager); node = drm_vma_offset_exact_lookup_locked(dev->vma_offset_manager, start, pages); if (likely(node)) { obj = container_of(node, struct drm_gem_object, vma_node); /* * When the object is being freed, after it hits 0-refcnt it * proceeds to tear down the object. In the process it will * attempt to remove the VMA offset and so acquire this * mgr->vm_lock. Therefore if we find an object with a 0-refcnt * that matches our range, we know it is in the process of being * destroyed and will be freed as soon as we release the lock - * so we have to check for the 0-refcnted object and treat it as * invalid. */ if (!kref_get_unless_zero(&obj->refcount)) obj = NULL; } drm_vma_offset_unlock_lookup(dev->vma_offset_manager);
if (!obj) return ERR_PTR(-EINVAL);
if (!drm_vma_node_is_allowed(node, priv)) { drm_gem_object_put(obj); return ERR_PTR(-EACCES); }
return obj;}
#ifdef CONFIG_MMU/** * drm_gem_get_unmapped_area - get memory mapping region routine for GEM objects * @filp: DRM file pointer * @uaddr: User address hint * @len: Mapping length * @pgoff: Offset (in pages) * @flags: Mapping flags * * If a driver supports GEM object mapping, before ending up in drm_gem_mmap(), * mmap calls on the DRM file descriptor will first try to find a free linear * address space large enough for a mapping. Since GEM objects are backed by * shmem buffers, this should preferably be handled by the shmem virtual memory * filesystem which can appropriately align addresses to huge page sizes when * needed. * * Look up the GEM object based on the offset passed in (vma->vm_pgoff will * contain the fake offset we created) and call shmem_get_unmapped_area() with * the right file pointer. * * If a GEM object is not available at the given offset or if the caller is not * granted access to it, fall back to mm_get_unmapped_area(). */unsigned long drm_gem_get_unmapped_area(struct file *filp, unsigned long uaddr, unsigned long len, unsigned long pgoff, unsigned long flags){ struct drm_gem_object *obj; unsigned long ret;
obj = drm_gem_object_lookup_at_offset(filp, pgoff, len >> PAGE_SHIFT); if (IS_ERR(obj)) obj = NULL;
if (!obj || !obj->filp || !obj->filp->f_op->get_unmapped_area) ret = mm_get_unmapped_area(filp, uaddr, len, 0, flags); else ret = obj->filp->f_op->get_unmapped_area(obj->filp, uaddr, len, 0, flags);
drm_gem_object_put(obj);
return ret;}EXPORT_SYMBOL_GPL(drm_gem_get_unmapped_area);#endif
/** * drm_gem_mmap - memory map routine for GEM objects * @filp: DRM file pointer * @vma: VMA for the area to be mapped * * If a driver supports GEM object mapping, mmap calls on the DRM file * descriptor will end up here. * * Look up the GEM object based on the offset passed in (vma->vm_pgoff will * contain the fake offset we created) and map it with a call to * drm_gem_mmap_obj(). * * If the caller is not granted access to the buffer object, the mmap will fail * with EACCES. Please see the vma manager for more information. */int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma){ struct drm_gem_object *obj; int ret;
obj = drm_gem_object_lookup_at_offset(filp, vma->vm_pgoff, vma_pages(vma)); if (IS_ERR(obj)) return PTR_ERR(obj);
ret = drm_gem_mmap_obj(obj, drm_vma_node_size(&obj->vma_node) << PAGE_SHIFT, vma);
drm_gem_object_put(obj);
return ret;}EXPORT_SYMBOL(drm_gem_mmap);
void drm_gem_print_info(struct drm_printer *p, unsigned int indent, const struct drm_gem_object *obj){ drm_printf_indent(p, indent, "name=%d\n", obj->name); drm_printf_indent(p, indent, "refcount=%u\n", kref_read(&obj->refcount)); drm_printf_indent(p, indent, "start=%08lx\n", drm_vma_node_start(&obj->vma_node)); drm_printf_indent(p, indent, "size=%zu\n", obj->size); drm_printf_indent(p, indent, "imported=%s\n", str_yes_no(drm_gem_is_imported(obj)));
if (obj->funcs->print_info) obj->funcs->print_info(p, indent, obj);}
int drm_gem_vmap_locked(struct drm_gem_object *obj, struct iosys_map *map){ int ret;
dma_resv_assert_held(obj->resv);
if (!obj->funcs->vmap) return -EOPNOTSUPP;
ret = obj->funcs->vmap(obj, map); if (ret) return ret; else if (iosys_map_is_null(map)) return -ENOMEM;
return 0;}EXPORT_SYMBOL(drm_gem_vmap_locked);
void drm_gem_vunmap_locked(struct drm_gem_object *obj, struct iosys_map *map){ dma_resv_assert_held(obj->resv);
if (iosys_map_is_null(map)) return;
if (obj->funcs->vunmap) obj->funcs->vunmap(obj, map);
/* Always set the mapping to NULL. Callers may rely on this. */ iosys_map_clear(map);}EXPORT_SYMBOL(drm_gem_vunmap_locked);
void drm_gem_lock(struct drm_gem_object *obj){ dma_resv_lock(obj->resv, NULL);}EXPORT_SYMBOL(drm_gem_lock);
void drm_gem_unlock(struct drm_gem_object *obj){ dma_resv_unlock(obj->resv);}EXPORT_SYMBOL(drm_gem_unlock);
int drm_gem_vmap(struct drm_gem_object *obj, struct iosys_map *map){ int ret;
dma_resv_lock(obj->resv, NULL); ret = drm_gem_vmap_locked(obj, map); dma_resv_unlock(obj->resv);
return ret;}EXPORT_SYMBOL(drm_gem_vmap);
void drm_gem_vunmap(struct drm_gem_object *obj, struct iosys_map *map){ dma_resv_lock(obj->resv, NULL); drm_gem_vunmap_locked(obj, map); dma_resv_unlock(obj->resv);}EXPORT_SYMBOL(drm_gem_vunmap);
/** * drm_gem_lock_reservations - Sets up the ww context and acquires * the lock on an array of GEM objects. * * Once you've locked your reservations, you'll want to set up space * for your shared fences (if applicable), submit your job, then * drm_gem_unlock_reservations(). * * @objs: drm_gem_objects to lock * @count: Number of objects in @objs * @acquire_ctx: struct ww_acquire_ctx that will be initialized as * part of tracking this set of locked reservations. */intdrm_gem_lock_reservations(struct drm_gem_object **objs, int count, struct ww_acquire_ctx *acquire_ctx){ int contended = -1; int i, ret;
ww_acquire_init(acquire_ctx, &reservation_ww_class);
retry: if (contended != -1) { struct drm_gem_object *obj = objs[contended];
ret = dma_resv_lock_slow_interruptible(obj->resv, acquire_ctx); if (ret) { ww_acquire_fini(acquire_ctx); return ret; } }
for (i = 0; i < count; i++) { if (i == contended) continue;
ret = dma_resv_lock_interruptible(objs[i]->resv, acquire_ctx); if (ret) { int j;
for (j = 0; j < i; j++) dma_resv_unlock(objs[j]->resv);
if (contended != -1 && contended >= i) dma_resv_unlock(objs[contended]->resv);
if (ret == -EDEADLK) { contended = i; goto retry; }
ww_acquire_fini(acquire_ctx); return ret; } }
ww_acquire_done(acquire_ctx);
return 0;}EXPORT_SYMBOL(drm_gem_lock_reservations);
voiddrm_gem_unlock_reservations(struct drm_gem_object **objs, int count, struct ww_acquire_ctx *acquire_ctx){ int i;
for (i = 0; i < count; i++) dma_resv_unlock(objs[i]->resv);
ww_acquire_fini(acquire_ctx);}EXPORT_SYMBOL(drm_gem_unlock_reservations);
/** * drm_gem_lru_init - initialize a LRU * * @lru: The LRU to initialize */voiddrm_gem_lru_init(struct drm_gem_lru *lru){ lru->count = 0; INIT_LIST_HEAD(&lru->list);}EXPORT_SYMBOL(drm_gem_lru_init);
static voiddrm_gem_lru_remove_locked(struct drm_gem_object *obj){ obj->lru->count -= obj->size >> PAGE_SHIFT; WARN_ON(obj->lru->count < 0); list_del(&obj->lru_node); obj->lru = NULL;}
/** * drm_gem_lru_remove - remove object from whatever LRU it is in * * If the object is currently in any LRU, remove it. * * @obj: The GEM object to remove from current LRU */voiddrm_gem_lru_remove(struct drm_gem_object *obj){ mutex_lock(&obj->dev->gem_lru_mutex); if (obj->lru) drm_gem_lru_remove_locked(obj); mutex_unlock(&obj->dev->gem_lru_mutex);}EXPORT_SYMBOL(drm_gem_lru_remove);
/** * drm_gem_lru_move_tail_locked - move the object to the tail of the LRU * * Like &drm_gem_lru_move_tail but lru lock must be held * * @lru: The LRU to move the object into. * @obj: The GEM object to move into this LRU */voiddrm_gem_lru_move_tail_locked(struct drm_gem_lru *lru, struct drm_gem_object *obj){ lockdep_assert_held_once(&obj->dev->gem_lru_mutex);
if (obj->lru) drm_gem_lru_remove_locked(obj);
lru->count += obj->size >> PAGE_SHIFT; list_add_tail(&obj->lru_node, &lru->list); obj->lru = lru;}EXPORT_SYMBOL(drm_gem_lru_move_tail_locked);
/** * drm_gem_lru_move_tail - move the object to the tail of the LRU * * If the object is already in this LRU it will be moved to the * tail. Otherwise it will be removed from whichever other LRU * it is in (if any) and moved into this LRU. * * @lru: The LRU to move the object into. * @obj: The GEM object to move into this LRU */voiddrm_gem_lru_move_tail(struct drm_gem_lru *lru, struct drm_gem_object *obj){ mutex_lock(&obj->dev->gem_lru_mutex); drm_gem_lru_move_tail_locked(lru, obj); mutex_unlock(&obj->dev->gem_lru_mutex);}EXPORT_SYMBOL(drm_gem_lru_move_tail);
/** * drm_gem_lru_scan - helper to implement shrinker.scan_objects * * If the shrink callback succeeds, it is expected that the driver * move the object out of this LRU. * * If the LRU possibly contain active buffers, it is the responsibility * of the shrink callback to check for this (ie. dma_resv_test_signaled()) * or if necessary block until the buffer becomes idle. * * @dev: DRM device the LRU belongs to * @lru: The LRU to scan * @nr_to_scan: The number of pages to try to reclaim * @remaining: The number of pages left to reclaim, should be initialized by caller * @shrink: Callback to try to shrink/reclaim the object. * @ticket: Optional ww_acquire_ctx context to use for locking */unsigned longdrm_gem_lru_scan(struct drm_device *dev, struct drm_gem_lru *lru, unsigned int nr_to_scan, unsigned long *remaining, bool (*shrink)(struct drm_gem_object *obj, struct ww_acquire_ctx *ticket), struct ww_acquire_ctx *ticket){ struct drm_gem_lru still_in_lru; struct drm_gem_object *obj; unsigned freed = 0;
drm_gem_lru_init(&still_in_lru);
mutex_lock(&dev->gem_lru_mutex);
while (freed < nr_to_scan) { obj = list_first_entry_or_null(&lru->list, typeof(*obj), lru_node);
if (!obj) break;
drm_gem_lru_move_tail_locked(&still_in_lru, obj);
/* * If it's in the process of being freed, gem_object->free() * may be blocked on lock waiting to remove it. So just * skip it. */ if (!kref_get_unless_zero(&obj->refcount)) continue;
/* * Now that we own a reference, we can drop the lock for the * rest of the loop body, to reduce contention with other * code paths that need the LRU lock */ mutex_unlock(&dev->gem_lru_mutex);
if (ticket) ww_acquire_init(ticket, &reservation_ww_class);
/* * Note that this still needs to be trylock, since we can * hit shrinker in response to trying to get backing pages * for this obj (ie. while it's lock is already held) */ if (!ww_mutex_trylock(&obj->resv->lock, ticket)) { *remaining += obj->size >> PAGE_SHIFT; goto tail; }
if (shrink(obj, ticket)) { freed += obj->size >> PAGE_SHIFT;
/* * If we succeeded in releasing the object's backing * pages, we expect the driver to have moved the object * out of this LRU */ WARN_ON(obj->lru == &still_in_lru); WARN_ON(obj->lru == lru); } else if (obj->lru == &still_in_lru) { /* * If the object wasn't moved and wasn't shrunk either, * it's still remaining as reclaimable. Note that * obj->lru is supposed to be checked with the LRU lock * held for an accurate result, but we don't care about * accuracy here. Worst thing that could happen is an * extra scan. */ *remaining += obj->size >> PAGE_SHIFT; }
dma_resv_unlock(obj->resv);
if (ticket) ww_acquire_fini(ticket);
tail: drm_gem_object_put(obj); mutex_lock(&dev->gem_lru_mutex); }
/* * Move objects we've skipped over out of the temporary still_in_lru * back into this LRU */ list_for_each_entry (obj, &still_in_lru.list, lru_node) obj->lru = lru; list_splice_tail(&still_in_lru.list, &lru->list); lru->count += still_in_lru.count;
mutex_unlock(&dev->gem_lru_mutex);
return freed;}EXPORT_SYMBOL(drm_gem_lru_scan);
/** * drm_gem_evict_locked - helper to evict backing pages for a GEM object * @obj: obj in question */int drm_gem_evict_locked(struct drm_gem_object *obj){ dma_resv_assert_held(obj->resv);
if (!dma_resv_test_signaled(obj->resv, DMA_RESV_USAGE_READ)) return -EBUSY;
if (obj->funcs->evict) return obj->funcs->evict(obj);
return 0;}EXPORT_SYMBOL(drm_gem_evict_locked);