lru - Linux

Symbol: lru

arch/mips/mm/cerr-sb1.c

arch/mips/mm/cerr-sb1.c

lru = (taghi >> 14) & 0xff;

arch/mips/mm/cerr-sb1.c

arch/mips/mm/cerr-sb1.c

((lru >> 2) & 0x3),

arch/mips/mm/cerr-sb1.c

((lru >> 4) & 0x3),

arch/mips/mm/cerr-sb1.c

((lru >> 6) & 0x3));

arch/mips/mm/cerr-sb1.c

uint8_t ecc, lru;

arch/mips/mm/cerr-sb1.c

lru = (taghi >> 14) & 0xff;

arch/mips/mm/cerr-sb1.c

arch/mips/mm/cerr-sb1.c

((lru >> 2) & 0x3),

arch/mips/mm/cerr-sb1.c

((lru >> 4) & 0x3),

arch/mips/mm/cerr-sb1.c

((lru >> 6) & 0x3));

arch/x86/mm/fault.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/mm/init_64.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/mm/init_64.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/mm/pat/set_memory.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/mm/pat/set_memory.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/xen/mmu_pv.c

list_for_each_entry(page, &pgd_list, lru) {

arch/x86/xen/mmu_pv.c

list_for_each_entry(page, &pgd_list, lru) {

block/blk-mq-tag.c

page = list_first_entry(&tags->page_list, struct page, lru);

block/blk-mq-tag.c

list_del_init(&page->lru);

block/blk-mq.c

list_for_each_entry(page, &tags->page_list, lru) {

block/blk-mq.c

list_add_tail(&page->lru, &tags->page_list);

drivers/android/binder_alloc.c

drivers/android/binder_alloc.c

drivers/android/binder_alloc.c

seq_printf(m, " pages: %d:%d:%d\n", active, lru, free);

drivers/android/binder_alloc.c

struct list_lru_one *lru,

drivers/android/binder_alloc.c

__must_hold(&lru->lock)

drivers/android/binder_alloc.c

struct binder_shrinker_mdata *mdata = container_of(item, typeof(*mdata), lru);

drivers/android/binder_alloc.c

list_lru_isolate(lru, item);

drivers/android/binder_alloc.c

spin_unlock(&lru->lock);

drivers/android/binder_alloc.c

INIT_LIST_HEAD(&mdata->lru);

drivers/android/binder_alloc.h

struct list_lru_one *lru,

drivers/android/binder_alloc.h

struct list_head lru;

drivers/android/binder_alloc.h

return &mdata->lru;

drivers/block/xen-blkfront.c

list_for_each_entry_safe(indirect_page, n, &rinfo->indirect_pages, lru) {

drivers/block/xen-blkfront.c

list_del(&indirect_page->lru);

drivers/block/xen-blkfront.c

list_add(&indirect_page->lru, &rinfo->indirect_pages);

drivers/block/xen-blkfront.c

list_add(&indirect_page->lru, &rinfo->indirect_pages);

drivers/block/xen-blkfront.c

list_for_each_entry_safe(indirect_page, n, &rinfo->indirect_pages, lru) {

drivers/block/xen-blkfront.c

list_del(&indirect_page->lru);

drivers/block/xen-blkfront.c

struct page, lru);

drivers/block/xen-blkfront.c

list_del(&indirect_page->lru);

drivers/dma-buf/heaps/system_heap.c

list_add_tail(&page->lru, &pages);

drivers/dma-buf/heaps/system_heap.c

list_for_each_entry_safe(page, tmp_page, &pages, lru) {

drivers/dma-buf/heaps/system_heap.c

list_del(&page->lru);

drivers/dma-buf/heaps/system_heap.c

list_for_each_entry_safe(page, tmp_page, &pages, lru)

drivers/gpu/drm/drm_gem.c

drm_gem_lru_init(struct drm_gem_lru *lru)

drivers/gpu/drm/drm_gem.c

lru->count = 0;

drivers/gpu/drm/drm_gem.c

INIT_LIST_HEAD(&lru->list);

drivers/gpu/drm/drm_gem.c

obj->lru->count -= obj->size >> PAGE_SHIFT;

drivers/gpu/drm/drm_gem.c

WARN_ON(obj->lru->count < 0);

drivers/gpu/drm/drm_gem.c

obj->lru = NULL;

drivers/gpu/drm/drm_gem.c

if (obj->lru)

drivers/gpu/drm/drm_gem.c

drm_gem_lru_move_tail_locked(struct drm_gem_lru *lru, struct drm_gem_object *obj)

drivers/gpu/drm/drm_gem.c

if (obj->lru)

drivers/gpu/drm/drm_gem.c

lru->count += obj->size >> PAGE_SHIFT;

drivers/gpu/drm/drm_gem.c

list_add_tail(&obj->lru_node, &lru->list);

drivers/gpu/drm/drm_gem.c

obj->lru = lru;

drivers/gpu/drm/drm_gem.c

drm_gem_lru_move_tail(struct drm_gem_lru *lru, struct drm_gem_object *obj)

drivers/gpu/drm/drm_gem.c

drm_gem_lru_move_tail_locked(lru, obj);

drivers/gpu/drm/drm_gem.c

struct drm_gem_lru *lru,

drivers/gpu/drm/drm_gem.c

obj = list_first_entry_or_null(&lru->list, typeof(*obj), lru_node);

drivers/gpu/drm/drm_gem.c

WARN_ON(obj->lru == &still_in_lru);

drivers/gpu/drm/drm_gem.c

WARN_ON(obj->lru == lru);

drivers/gpu/drm/drm_gem.c

} else if (obj->lru == &still_in_lru) {

drivers/gpu/drm/drm_gem.c

obj->lru = lru;

drivers/gpu/drm/drm_gem.c

list_splice_tail(&still_in_lru.list, &lru->list);

drivers/gpu/drm/drm_gem.c

lru->count += still_in_lru.count;

drivers/gpu/drm/i915/i915_gpu_error.c

list_for_each_entry_safe(page, n, &vma->page_list, lru) {

drivers/gpu/drm/i915/i915_gpu_error.c

list_del_init(&page->lru);

drivers/gpu/drm/i915/i915_gpu_error.c

list_for_each_entry_safe_reverse(page, n, &dst->page_list, lru) {

drivers/gpu/drm/i915/i915_gpu_error.c

list_del_init(&page->lru);

drivers/gpu/drm/i915/i915_gpu_error.c

list_add_tail(&page->lru, &dst->page_list);

drivers/gpu/drm/i915/i915_gpu_error.c

list_add_tail(&virt_to_page(ptr)->lru, &dst->page_list);

drivers/gpu/drm/i915/i915_gpu_error.c

list_for_each_entry(page, &vma->page_list, lru) {

drivers/gpu/drm/i915/i915_gpu_error.c

if (page == list_last_entry(&vma->page_list, typeof(*page), lru))

drivers/gpu/drm/msm/msm_drv.c

drm_gem_lru_init(&priv->lru.unbacked);

drivers/gpu/drm/msm/msm_drv.c

drm_gem_lru_init(&priv->lru.pinned);

drivers/gpu/drm/msm/msm_drv.c

drm_gem_lru_init(&priv->lru.willneed);

drivers/gpu/drm/msm/msm_drv.c

drm_gem_lru_init(&priv->lru.dontneed);

drivers/gpu/drm/msm/msm_drv.h

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail(&priv->lru.unbacked, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail(&priv->lru.pinned, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail_locked(&priv->lru.pinned, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail_locked(&priv->lru.willneed, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail_locked(&priv->lru.dontneed, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail_locked(&priv->lru.unbacked, obj);

drivers/gpu/drm/msm/msm_gem.c

drm_gem_lru_move_tail_locked(&priv->lru.pinned, obj);

drivers/gpu/drm/msm/msm_gem_shrinker.c

struct drm_gem_lru *lru;

drivers/gpu/drm/msm/msm_gem_shrinker.c

{ &priv->lru.dontneed, purge, true },

drivers/gpu/drm/msm/msm_gem_shrinker.c

{ &priv->lru.willneed, evict, can_swap() },

drivers/gpu/drm/msm/msm_gem_shrinker.c

{ &priv->lru.dontneed, active_purge, can_block(sc) },

drivers/gpu/drm/msm/msm_gem_shrinker.c

{ &priv->lru.willneed, active_evict, can_swap() && can_block(sc) },

drivers/gpu/drm/msm/msm_gem_shrinker.c

drm_gem_lru_scan(priv->dev, stages[i].lru, nr,

drivers/gpu/drm/msm/msm_gem_shrinker.c

&priv->lru.dontneed,

drivers/gpu/drm/msm/msm_gem_shrinker.c

&priv->lru.willneed,

drivers/gpu/drm/msm/msm_gem_shrinker.c

&priv->lru.pinned,

drivers/gpu/drm/msm/msm_gem_shrinker.c

unsigned count = priv->lru.dontneed.count;

drivers/gpu/drm/msm/msm_gem_shrinker.c

count += priv->lru.willneed.count;

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

eobj = list_first_entry_or_null(&imem->lru, typeof(*eobj), lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

list_del_init(&eobj->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

if (likely(iobj->lru.next) && iobj->map) {

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

BUG_ON(!list_empty(&iobj->lru));

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

list_add_tail(&iobj->lru, &imem->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

if (likely(iobj->lru.next))

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

list_del_init(&iobj->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

if (likely(iobj->lru.next)) {

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

list_del_init(&iobj->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

iobj->lru.next = NULL;

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

iobj->lru.next = NULL; /* Exclude from eviction. */

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

if (likely(iobj->lru.next))

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

list_del(&iobj->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

INIT_LIST_HEAD(&iobj->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

struct list_head lru;

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

INIT_LIST_HEAD(&imem->lru);

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c

struct list_head lru;

drivers/gpu/drm/panthor/panthor_mmu.c

drm_gem_lru_move_tail_locked(&vm->reclaim.lru, &bo->base);

drivers/gpu/drm/panthor/panthor_mmu.c

drm_gem_lru_init(&vm->reclaim.lru);

drivers/gpu/drm/panthor/panthor_mmu.c

freed += drm_gem_lru_scan(&ptdev->base, &vm->reclaim.lru,

drivers/gpu/drm/panthor/panthor_mmu.c

if (vm->reclaim.lru.count > 0)

drivers/gpu/drm/panthor/panthor_mmu.c

struct drm_gem_lru lru;

drivers/gpu/drm/panthor/panthor_mmu.c

if (vm->reclaim.lru.count)

drivers/gpu/drm/ttm/tests/ttm_bo_test.c

list_is_last(&res1->lru.link, &man->lru[bo->priority]), 1);

drivers/gpu/drm/ttm/tests/ttm_bo_test.c

list_is_last(&res2->lru.link, &priv->ttm_dev->unevictable), 1);

drivers/gpu/drm/ttm/tests/ttm_bo_test.c

list_is_last(&res1->lru.link, &priv->ttm_dev->unevictable), 1);

drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c

KUNIT_ASSERT_TRUE(test, list_is_singular(&man->lru[bo->priority]));

drivers/gpu/drm/ttm/tests/ttm_device_test.c

KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[0]));

drivers/gpu/drm/ttm/tests/ttm_resource_test.c

KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[bo->priority]));

drivers/gpu/drm/ttm/tests/ttm_resource_test.c

KUNIT_ASSERT_TRUE(test, list_is_singular(&man->lru[bo->priority]));

drivers/gpu/drm/ttm/tests/ttm_resource_test.c

KUNIT_ASSERT_TRUE(test, list_empty(&res->lru.link));

drivers/gpu/drm/ttm/tests/ttm_resource_test.c

KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[i]));

drivers/gpu/drm/ttm/tests/ttm_resource_test.c

KUNIT_ASSERT_TRUE(test, list_empty(&man->lru[bo->priority]));

drivers/gpu/drm/ttm/ttm_device.c

if (list_empty(&man->lru[0]))

drivers/gpu/drm/ttm/ttm_device.c

list_del_init(&bo->resource->lru.link);

drivers/gpu/drm/ttm/ttm_device.c

ttm_device_clear_lru_dma_mappings(bdev, &man->lru[j]);

drivers/gpu/drm/ttm/ttm_pool.c

INIT_LIST_HEAD(&p->lru);

drivers/gpu/drm/ttm/ttm_pool.c

list_lru_add(&pt->pages, &p->lru, nid, NULL);

drivers/gpu/drm/ttm/ttm_pool.c

struct page *p = container_of(item, struct page, lru);

drivers/gpu/drm/ttm/ttm_pool.c

p = list_first_entry(dispose, struct page, lru);

drivers/gpu/drm/ttm/ttm_pool.c

list_del_init(&p->lru);

drivers/gpu/drm/ttm/ttm_resource.c

list_bulk_move_tail(&man->lru[j], &pos->first->lru.link,

drivers/gpu/drm/ttm/ttm_resource.c

&pos->last->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

struct ttm_lru_item *lru = &cur->lru;

drivers/gpu/drm/ttm/ttm_resource.c

lru = list_prev_entry(lru, link);

drivers/gpu/drm/ttm/ttm_resource.c

} while (!ttm_lru_item_is_res(lru));

drivers/gpu/drm/ttm/ttm_resource.c

return ttm_lru_item_to_res(lru);

drivers/gpu/drm/ttm/ttm_resource.c

struct ttm_lru_item *lru = &cur->lru;

drivers/gpu/drm/ttm/ttm_resource.c

lru = list_next_entry(lru, link);

drivers/gpu/drm/ttm/ttm_resource.c

} while (!ttm_lru_item_is_res(lru));

drivers/gpu/drm/ttm/ttm_resource.c

return ttm_lru_item_to_res(lru);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&res->lru.link, &pos->last->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&res->lru.link, &pos->last->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

list_move_tail(&res->lru.link, &bdev->unevictable);

drivers/gpu/drm/ttm/ttm_resource.c

list_move_tail(&res->lru.link, &man->lru[bo->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

list_add_tail(&res->lru.link, &bo->bdev->unevictable);

drivers/gpu/drm/ttm/ttm_resource.c

list_add_tail(&res->lru.link, &man->lru[bo->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

list_del_init(&res->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

INIT_LIST_HEAD(&man->lru[i]);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&cursor->hitch.link, &pos->last->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&cursor->hitch.link, &man->lru[cursor->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

struct ttm_lru_item *lru;

drivers/gpu/drm/ttm/ttm_resource.c

lru = &cursor->hitch;

drivers/gpu/drm/ttm/ttm_resource.c

list_for_each_entry_continue(lru, &man->lru[cursor->priority], link) {

drivers/gpu/drm/ttm/ttm_resource.c

if (ttm_lru_item_is_res(lru)) {

drivers/gpu/drm/ttm/ttm_resource.c

ttm_resource_cursor_check_bulk(cursor, lru);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&cursor->hitch.link, &lru->link);

drivers/gpu/drm/ttm/ttm_resource.c

return ttm_lru_item_to_res(lru);

drivers/gpu/drm/ttm/ttm_resource.c

list_move(&cursor->hitch.link, &man->lru[cursor->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

struct ttm_lru_item *lru;

drivers/gpu/drm/ttm/ttm_resource.c

list_for_each_entry(lru, head, link) {

drivers/gpu/drm/ttm/ttm_resource.c

if (ttm_lru_item_is_res(lru))

drivers/gpu/drm/ttm/ttm_resource.c

return ttm_lru_item_to_res(lru);

drivers/gpu/drm/vmwgfx/vmwgfx_validation.c

list_add_tail(&page->lru, &ctx->page_list);

drivers/gpu/drm/vmwgfx/vmwgfx_validation.c

list_for_each_entry_safe(entry, next, &ctx->page_list, lru) {

drivers/gpu/drm/vmwgfx/vmwgfx_validation.c

list_del_init(&entry->lru);

drivers/iommu/iommu-pages.c

IOPTDESC_MATCH(lru, iopt_freelist_elm); /* Ensure bit 0 is clear */

drivers/md/bcache/bcache.h

struct list_head lru;

drivers/md/bcache/request.c

i = list_first_entry(&dc->io_lru, struct io, lru);

drivers/md/bcache/request.c

list_move_tail(&i->lru, &dc->io_lru);

drivers/md/bcache/super.c

list_add(&io->lru, &dc->io_lru);

drivers/md/dm-bufio.c

static void lru_destroy(struct lru *lru)

drivers/md/dm-bufio.c

WARN_ON_ONCE(lru->cursor);

drivers/md/dm-bufio.c

WARN_ON_ONCE(!list_empty(&lru->iterators));

drivers/md/dm-bufio.c

static void lru_insert(struct lru *lru, struct lru_entry *le)

drivers/md/dm-bufio.c

if (lru->cursor) {

drivers/md/dm-bufio.c

list_add_tail(&le->list, lru->cursor);

drivers/md/dm-bufio.c

lru->cursor = &le->list;

drivers/md/dm-bufio.c

lru->count++;

drivers/md/dm-bufio.c

static void lru_iter_begin(struct lru *lru, struct lru_iter *it)

drivers/md/dm-bufio.c

it->lru = lru;

drivers/md/dm-bufio.c

it->stop = lru->cursor ? to_le(lru->cursor->prev) : NULL;

drivers/md/dm-bufio.c

it->e = lru->cursor ? to_le(lru->cursor) : NULL;

drivers/md/dm-bufio.c

list_add(&it->list, &lru->iterators);

drivers/md/dm-bufio.c

list_del(&b->lru.list);

drivers/md/dm-bufio.c

list_add(&b->lru.list, &c->reserved_buffers);

drivers/md/dm-bufio.c

static void lru_iter_invalidate(struct lru *lru, struct lru_entry *e)

drivers/md/dm-bufio.c

list_for_each_entry(it, &lru->iterators, list) {

drivers/md/dm-bufio.c

static void lru_remove(struct lru *lru, struct lru_entry *le)

drivers/md/dm-bufio.c

lru_iter_invalidate(lru, le);

drivers/md/dm-bufio.c

lru_iter_begin(&c->cache.lru[LIST_DIRTY], &it);

drivers/md/dm-bufio.c

if (lru->count == 1) {

drivers/md/dm-bufio.c

lru->cursor = NULL;

drivers/md/dm-bufio.c

if (lru->cursor == &le->list)

drivers/md/dm-bufio.c

lru->cursor = lru->cursor->next;

drivers/md/dm-bufio.c

lru->count--;

drivers/md/dm-bufio.c

static struct lru_entry *lru_evict(struct lru *lru, le_predicate pred, void *context, bool no_sleep)

drivers/md/dm-bufio.c

struct list_head *h = lru->cursor;

drivers/md/dm-bufio.c

list_del(&b->lru.list);

drivers/md/dm-bufio.c

while (tested < lru->count) {

drivers/md/dm-bufio.c

list_del(&b->lru.list);

drivers/md/dm-bufio.c

lru->cursor = le->list.next;

drivers/md/dm-bufio.c

lru->cursor = le->list.next;

drivers/md/dm-bufio.c

struct lru lru[LIST_SIZE];

drivers/md/dm-bufio.c

lru_init(&bc->lru[LIST_CLEAN]);

drivers/md/dm-bufio.c

lru_init(&bc->lru[LIST_DIRTY]);

drivers/md/dm-bufio.c

lru_destroy(&bc->lru[LIST_CLEAN]);

drivers/md/dm-bufio.c

lru_destroy(&bc->lru[LIST_DIRTY]);

drivers/md/dm-bufio.c

return bc->lru[list_mode].count;

drivers/md/dm-bufio.c

lru_reference(&b->lru);

drivers/md/dm-bufio.c

le = lru_evict(&bc->lru[list_mode], __evict_pred, &w, bc->no_sleep);

drivers/md/dm-bufio.c

lru_remove(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

lru_insert(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

le = lru_evict(&bc->lru[old_mode], __evict_pred, &w, bc->no_sleep);

drivers/md/dm-bufio.c

lru_insert(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

struct lru *lru = &bc->lru[list_mode];

drivers/md/dm-bufio.c

if (!lru->cursor)

drivers/md/dm-bufio.c

struct lru *lru;

drivers/md/dm-bufio.c

first = le = to_le(lru->cursor);

drivers/md/dm-bufio.c

lru_insert(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

lru_remove(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

static void lru_init(struct lru *lru)

drivers/md/dm-bufio.c

lru_remove(&bc->lru[b->list_mode], &b->lru);

drivers/md/dm-bufio.c

lru->cursor = NULL;

drivers/md/dm-bufio.c

lru->count = 0;

drivers/md/dm-bufio.c

INIT_LIST_HEAD(&lru->iterators);

drivers/md/dm-writecache.c

INIT_LIST_HEAD(&wc->lru);

drivers/md/dm-writecache.c

struct list_head lru;

drivers/md/dm-writecache.c

INIT_LIST_HEAD(&e->lru);

drivers/md/dm-writecache.c

INIT_LIST_HEAD(&e->lru);

drivers/md/dm-writecache.c

e = container_of(wbl->list.prev, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_del(&e->lru);

drivers/md/dm-writecache.c

f = container_of(wbl->list.prev, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_del(&f->lru);

drivers/md/dm-writecache.c

e = container_of(wbl->list.prev, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_del(&e->lru);

drivers/md/dm-writecache.c

f = container_of(wbl->list.prev, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_del(&f->lru);

drivers/md/dm-writecache.c

while (!list_empty(&wc->lru) &&

drivers/md/dm-writecache.c

(jiffies - container_of(wc->lru.prev, struct wc_entry, lru)->age >=

drivers/md/dm-writecache.c

e = container_of(wc->lru.prev, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_move(&e->lru, &skipped);

drivers/md/dm-writecache.c

list_move(&e->lru, &wbl.list);

drivers/md/dm-writecache.c

list_move(&g->lru, &wbl.list);

drivers/md/dm-writecache.c

list_splice_tail(&skipped, &wc->lru);

drivers/md/dm-writecache.c

list_add(&ins->lru, &wc->lru);

drivers/md/dm-writecache.c

list_del(&e->lru);

drivers/md/dm-writecache.c

list_add_tail(&e->lru, &wc->freelist);

drivers/md/dm-writecache.c

e = container_of(wc->freelist.next, struct wc_entry, lru);

drivers/md/dm-writecache.c

list_del(&e->lru);

drivers/md/dm-writecache.c

wc->lru.next = LIST_POISON1;

drivers/md/dm-writecache.c

wc->lru.prev = LIST_POISON2;

drivers/md/dm-writecache.c

if (list_empty(&wc->lru))

drivers/md/dm-writecache.c

e = container_of(wc->lru.next, struct wc_entry, lru);

drivers/md/dm-writecache.c

if (unlikely(e->lru.next == &wc->lru))

drivers/md/dm-writecache.c

e2 = container_of(e->lru.next, struct wc_entry, lru);

drivers/md/dm-writecache.c

struct list_head lru;

drivers/md/dm-writecache.c

if (unlikely(e->lru.prev == &wc->lru))

drivers/md/dm-writecache.c

e = container_of(e->lru.prev, struct wc_entry, lru);

drivers/md/raid5-cache.c

BUG_ON(list_empty(&sh->lru));

drivers/md/raid5-cache.c

list_del_init(&sh->lru);

drivers/md/raid5-cache.c

list_for_each_entry_safe(sh, next, &conf->r5c_full_stripe_list, lru) {

drivers/md/raid5-cache.c

&conf->r5c_partial_stripe_list, lru) {

drivers/md/raid5-cache.c

if (!list_empty(&sh->lru) &&

drivers/md/raid5-cache.c

list_for_each_entry(sh, list, lru)

drivers/md/raid5-cache.c

list_for_each_entry_safe(sh, next, cached_stripe_list, lru) {

drivers/md/raid5-cache.c

list_del_init(&sh->lru);

drivers/md/raid5-cache.c

list_for_each_entry_safe(sh, next, cached_stripe_list, lru)

drivers/md/raid5-cache.c

list_del_init(&sh->lru);

drivers/md/raid5-cache.c

list_del_init(&sh->lru);

drivers/md/raid5-cache.c

list_add_tail(&sh->lru, cached_stripe_list);

drivers/md/raid5-cache.c

list_move_tail(&sh->lru, cached_stripe_list);

drivers/md/raid5-cache.c

list_for_each_entry(sh, &ctx->cached_list, lru) {

drivers/md/raid5-cache.c

list_for_each_entry(sh, &ctx->cached_list, lru) {

drivers/md/raid5-cache.c

list_for_each_entry_safe(sh, next, &ctx->cached_list, lru) {

drivers/md/raid5-cache.c

list_del_init(&sh->lru);

drivers/md/raid5.c

if (list_empty(&sh->lru)) {

drivers/md/raid5.c

list_add_tail(&sh->lru, &group->loprio_list);

drivers/md/raid5.c

list_add_tail(&sh->lru, &group->handle_list);

drivers/md/raid5.c

BUG_ON(!list_empty(&sh->lru));

drivers/md/raid5.c

INIT_LIST_HEAD(&sh->lru);

drivers/md/raid5.c

list_add_tail(&sh->lru, &conf->delayed_list);

drivers/md/raid5.c

list_add(&nsh->lru, &newstripes);

drivers/md/raid5.c

nsh = list_entry(newstripes.next, struct stripe_head, lru);

drivers/md/raid5.c

list_del(&nsh->lru);

drivers/md/raid5.c

list_for_each_entry(nsh, &newstripes, lru) {

drivers/md/raid5.c

list_add_tail(&sh->lru, &conf->bitmap_list);

drivers/md/raid5.c

nsh = list_entry(newstripes.next, struct stripe_head, lru);

drivers/md/raid5.c

list_del_init(&nsh->lru);

drivers/md/raid5.c

list_add_tail(&sh->lru,

drivers/md/raid5.c

list_add_tail(&sh->lru,

drivers/md/raid5.c

list_add_tail(&sh->lru, temp_inactive_list);

drivers/md/raid5.c

list_add_tail(&sh->lru, temp_inactive_list);

drivers/md/raid5.c

list_add_tail(&sh->lru, &conf->r5c_full_stripe_list);

drivers/md/raid5.c

list_add_tail(&sh->lru, &conf->r5c_partial_stripe_list);

drivers/md/raid5.c

sh = list_entry(first, struct stripe_head, lru);

drivers/md/raid5.c

sh = list_entry(l, struct stripe_head, lru);

drivers/md/raid5.c

list_add_tail(&sh->lru, &conf->hold_list);

drivers/md/raid5.c

struct stripe_head *sh = list_entry(head.next, struct stripe_head, lru);

drivers/md/raid5.c

list_del_init(&sh->lru);

drivers/md/raid5.c

sh = list_entry(handle_list->next, typeof(*sh), lru);

drivers/md/raid5.c

list_for_each_entry(tmp, &conf->hold_list, lru) {

drivers/md/raid5.c

list_del_init(&sh->lru);

drivers/md/raid5.c

sh = list_first_entry(&cb->list, struct stripe_head, lru);

drivers/md/raid5.c

list_del_init(&sh->lru);

drivers/md/raid5.c

list_add_tail(&sh->lru, &cb->list);

drivers/md/raid5.c

list_add(&sh->lru, &stripes);

drivers/md/raid5.c

sh = list_entry(stripes.next, struct stripe_head, lru);

drivers/md/raid5.c

list_del_init(&sh->lru);

drivers/md/raid5.c

BUG_ON(list_empty(&sh->lru) &&

drivers/md/raid5.c

list_del_init(&sh->lru);

drivers/md/raid5.h

struct list_head lru; /* inactive_list or handle_list */

drivers/misc/vmw_balloon.c

list_for_each_entry(page, pages, lru) {

drivers/misc/vmw_balloon.c

list_for_each_entry_safe(page, tmp, &b->huge_pages, lru) {

drivers/misc/vmw_balloon.c

list_move(&page->lru, pages);

drivers/misc/vmw_balloon.c

list_for_each_entry_safe(page, tmp, &ctl->refused_pages, lru) {

drivers/misc/vmw_balloon.c

list_del(&page->lru);

drivers/misc/vmw_balloon.c

list_add(&page[i].lru, &ctl->prealloc_pages);

drivers/misc/vmw_balloon.c

struct page, lru);

drivers/misc/vmw_balloon.c

list_del(&page->lru);

drivers/misc/vmw_balloon.c

list_add(&page->lru, &ctl->pages);

drivers/misc/vmw_balloon.c

list_for_each_entry(page, &ctl->pages, lru)

drivers/misc/vmw_balloon.c

list_move(&page->lru, &ctl->refused_pages);

drivers/misc/vmw_balloon.c

list_for_each_entry_safe(page, tmp, page_list, lru) {

drivers/misc/vmw_balloon.c

list_del(&page->lru);

drivers/virtio/virtio_balloon.c

list_add(&page->lru, &pages);

drivers/virtio/virtio_balloon.c

list_for_each_entry_safe(page, next, &pages, lru) {

drivers/virtio/virtio_balloon.c

list_del(&page->lru);

drivers/virtio/virtio_balloon.c

list_for_each_entry_safe(page, next, pages, lru) {

drivers/virtio/virtio_balloon.c

list_del(&page->lru);

drivers/virtio/virtio_balloon.c

list_add(&page->lru, &pages);

drivers/virtio/virtio_balloon.c

list_for_each_entry_safe(page, next, &vb->free_page_list, lru) {

drivers/virtio/virtio_balloon.c

list_del(&page->lru);

drivers/virtio/virtio_balloon.c

list_add(&page->lru, &vb->free_page_list);

drivers/xen/balloon.c

list_add_tail(&page->lru, &ballooned_pages);

drivers/xen/balloon.c

list_add(&page->lru, &ballooned_pages);

drivers/xen/balloon.c

page = list_entry(ballooned_pages.next, struct page, lru);

drivers/xen/balloon.c

list_del(&page->lru);

drivers/xen/balloon.c

struct list_head *next = page->lru.next;

drivers/xen/balloon.c

return list_entry(next, struct page, lru);

drivers/xen/balloon.c

page = list_first_entry_or_null(&ballooned_pages, struct page, lru);

drivers/xen/balloon.c

list_add(&page->lru, &pages);

drivers/xen/balloon.c

list_for_each_entry_safe(page, tmp, &pages, lru) {

drivers/xen/balloon.c

list_del(&page->lru);

drivers/xen/grant-table.c

page = list_first_entry(&cache->pages, struct page, lru);

drivers/xen/grant-table.c

list_del(&page->lru);

drivers/xen/grant-table.c

list_add(&page->lru, &cache->pages);

drivers/xen/privcmd.c

list_for_each_entry_safe(p, n, pages, lru)

drivers/xen/privcmd.c

list_add_tail(&page->lru, pagelist);

drivers/xen/privcmd.c

page = list_entry(pos, struct page, lru);

drivers/xen/privcmd.c

page = list_entry(pos, struct page, lru);

drivers/xen/privcmd.c

struct page, lru);

fs/btrfs/compression.c

struct page *page = list_entry(tmp, struct page, lru);

fs/btrfs/compression.c

folio = list_first_entry(&compr_pool.list, struct folio, lru);

fs/btrfs/compression.c

list_del_init(&folio->lru);

fs/btrfs/compression.c

list_add(&folio->lru, &compr_pool.list);

fs/btrfs/send.c

struct btrfs_lru_cache_entry *lru;

fs/btrfs/send.c

lru = btrfs_lru_cache_lru_entry(&sctx->dir_utimes_cache);

fs/btrfs/send.c

ASSERT(lru != NULL);

fs/btrfs/send.c

ret = send_utimes(sctx, lru->key, lru->gen);

fs/btrfs/send.c

btrfs_lru_cache_remove(&sctx->dir_utimes_cache, lru);

fs/ceph/mds_client.c

page = list_first_entry(&recon_state->pagelist->head, struct page, lru);

fs/ceph/mds_client.c

struct page, lru);

fs/ceph/mds_client.h

struct list_head lru;

fs/ceph/snap.c

list_del_init(&exist->lru);

fs/ceph/snap.c

INIT_LIST_HEAD(&sm->lru);

fs/ceph/snap.c

list_del_init(&exist->lru);

fs/ceph/snap.c

list_add_tail(&sm->lru, &mdsc->snapid_map_lru);

fs/ceph/snap.c

struct ceph_snapid_map, lru);

fs/ceph/snap.c

list_move(&sm->lru, &to_free);

fs/ceph/snap.c

sm = list_first_entry(&to_free, struct ceph_snapid_map, lru);

fs/ceph/snap.c

list_del(&sm->lru);

fs/ceph/snap.c

list_move(&sm->lru, &to_free);

fs/ceph/snap.c

sm = list_first_entry(&to_free, struct ceph_snapid_map, lru);

fs/ceph/snap.c

list_del(&sm->lru);

fs/ceph/xattr.c

struct page, lru);

fs/dcache.c

struct list_lru_one *lru, void *arg)

fs/dcache.c

d_lru_isolate(lru, dentry);

fs/dcache.c

d_lru_shrink_move(lru, dentry, freeable);

fs/dcache.c

struct list_lru_one *lru, void *arg)

fs/dcache.c

d_lru_shrink_move(lru, dentry, freeable);

fs/dcache.c

static void d_lru_isolate(struct list_lru_one *lru, struct dentry *dentry)

fs/dcache.c

list_lru_isolate(lru, &dentry->d_lru);

fs/dcache.c

static void d_lru_shrink_move(struct list_lru_one *lru, struct dentry *dentry,

fs/dcache.c

list_lru_isolate_move(lru, &dentry->d_lru, list);

fs/gfs2/quota.c

struct list_lru_one *lru, void *arg)

fs/gfs2/quota.c

list_lru_isolate_move(lru, &qd->qd_lru, dispose);

fs/inode.c

struct list_lru_one *lru, void *arg)

fs/inode.c

list_lru_isolate(lru, &inode->i_lru);

fs/inode.c

spin_unlock(&lru->lock);

fs/inode.c

list_lru_isolate_move(lru, &inode->i_lru, freeable);

fs/nfs/dir.c

cache = list_entry(head->next, struct nfs_access_entry, lru);

fs/nfs/dir.c

list_del(&cache->lru);

fs/nfs/dir.c

struct nfs_access_entry, lru);

fs/nfs/dir.c

list_move(&cache->lru, &head);

fs/nfs/dir.c

list_move(&entry->lru, head);

fs/nfs/dir.c

list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);

fs/nfs/dir.c

cache = list_entry(lh, struct nfs_access_entry, lru);

fs/nfs/dir.c

list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);

fs/nfs/dir.c

list_add_tail(&set->lru, &nfsi->access_cache_entry_lru);

fs/nfs/dir.c

list_del(&entry->lru);

fs/nfs/nfs42xattr.c

struct list_lru *lru)

fs/nfs/nfs42xattr.c

list_lru_destroy(lru);

fs/nfs/nfs42xattr.c

struct list_lru *lru;

fs/nfs/nfs42xattr.c

lru = (entry->flags & NFS4_XATTR_ENTRY_EXTVAL) ?

fs/nfs/nfs42xattr.c

return list_lru_add_obj(lru, &entry->lru);

fs/nfs/nfs42xattr.c

struct list_lru *lru;

fs/nfs/nfs42xattr.c

lru = (entry->flags & NFS4_XATTR_ENTRY_EXTVAL) ?

fs/nfs/nfs42xattr.c

return list_lru_del_obj(lru, &entry->lru);

fs/nfs/nfs42xattr.c

INIT_LIST_HEAD(&entry->lru);

fs/nfs/nfs42xattr.c

if (WARN_ON(!list_empty(&entry->lru)))

fs/nfs/nfs42xattr.c

list_lru_del_obj(&nfs4_xattr_cache_lru, &oldcache->lru);

fs/nfs/nfs42xattr.c

list_lru_add_obj(&nfs4_xattr_cache_lru, &cache->lru);

fs/nfs/nfs42xattr.c

struct list_head lru;

fs/nfs/nfs42xattr.c

struct list_lru_one *lru, void *arg)

fs/nfs/nfs42xattr.c

struct nfs4_xattr_cache, lru);

fs/nfs/nfs42xattr.c

struct list_head lru;

fs/nfs/nfs42xattr.c

list_lru_isolate(lru, &cache->lru);

fs/nfs/nfs42xattr.c

struct list_lru_one *lru, void *arg)

fs/nfs/nfs42xattr.c

struct nfs4_xattr_entry, lru);

fs/nfs/nfs42xattr.c

list_lru_isolate(lru, &entry->lru);

fs/nfs/nfs42xattr.c

list_lru_isolate(lru, &entry->lru);

fs/nfs/nfs42xattr.c

struct list_lru *lru;

fs/nfs/nfs42xattr.c

lru = (shrink == nfs4_xattr_large_entry_shrinker) ?

fs/nfs/nfs42xattr.c

freed = list_lru_shrink_walk(lru, sc, entry_lru_isolate, &dispose);

fs/nfs/nfs42xattr.c

struct list_lru *lru;

fs/nfs/nfs42xattr.c

lru = (shrink == nfs4_xattr_large_entry_shrinker) ?

fs/nfs/nfs42xattr.c

count = list_lru_shrink_count(lru, sc);

fs/nfs/nfs42xattr.c

INIT_LIST_HEAD(&cache->lru);

fs/nfs/nfs42xattr.c

struct list_lru *lru, const char *name,

fs/nfs/nfs42xattr.c

ret = list_lru_init_memcg(lru, *shrinker);

fs/nfsd/filecache.c

unsigned long lru = 0, total_age = 0;

fs/nfsd/filecache.c

lru = list_lru_count(&nfsd_file_lru);

fs/nfsd/filecache.c

seq_printf(m, "lru entries: %lu\n", lru);

fs/nfsd/filecache.c

nfsd_file_lru_cb(struct list_head *item, struct list_lru_one *lru,

fs/nfsd/filecache.c

list_lru_isolate(lru, &nf->nf_lru);

fs/nfsd/filecache.c

nfsd_file_gc_cb(struct list_head *item, struct list_lru_one *lru,

fs/nfsd/filecache.c

return nfsd_file_lru_cb(item, lru, arg);

fs/proc/meminfo.c

fs/proc/meminfo.c

for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)

fs/proc/meminfo.c

pages[lru] = global_node_page_state(NR_LRU_BASE + lru);

fs/xfs/xfs_buf.c

struct list_lru_one *lru,

fs/xfs/xfs_buf.c

list_lru_isolate_move(lru, item, dispose);

fs/xfs/xfs_buf.c

struct list_lru_one *lru,

fs/xfs/xfs_buf.c

list_lru_isolate(lru, &bp->b_lru);

fs/xfs/xfs_buf.c

list_lru_isolate_move(lru, item, dispose);

fs/xfs/xfs_qm.c

struct list_lru_one *lru,

fs/xfs/xfs_qm.c

__releases(&lru->lock) __acquires(&lru->lock)

fs/xfs/xfs_qm.c

list_lru_isolate(lru, &dqp->q_lru);

fs/xfs/xfs_qm.c

list_lru_isolate_move(lru, &dqp->q_lru, &isol->dispose);

include/drm/drm_gem.h

struct drm_gem_lru *lru;

include/drm/drm_gem.h

void drm_gem_lru_init(struct drm_gem_lru *lru);

include/drm/drm_gem.h

void drm_gem_lru_move_tail_locked(struct drm_gem_lru *lru, struct drm_gem_object *obj);

include/drm/drm_gem.h

void drm_gem_lru_move_tail(struct drm_gem_lru *lru, struct drm_gem_object *obj);

include/drm/drm_gem.h

struct drm_gem_lru *lru,

include/drm/ttm/ttm_resource.h

struct list_head lru[TTM_MAX_BO_PRIORITY];

include/drm/ttm/ttm_resource.h

struct ttm_lru_item lru;

include/drm/ttm/ttm_resource.h

return container_of(item, struct ttm_resource, lru);

include/drm/ttm/ttm_resource.h

WARN_ON(!list_empty(&man->lru[i]));

include/linux/list_lru.h

int folio_memcg_list_lru_alloc(struct folio *folio, struct list_lru *lru,

include/linux/list_lru.h

struct list_lru *lru, gfp_t gfp)

include/linux/list_lru.h

struct list_lru_one *list_lru_lock(struct list_lru *lru, int nid,

include/linux/list_lru.h

struct list_lru_one *list_lru_lock_irq(struct list_lru *lru, int nid,

include/linux/list_lru.h

struct list_lru_one *list_lru_lock_irqsave(struct list_lru *lru, int nid,

include/linux/list_lru.h

bool __list_lru_add(struct list_lru *lru, struct list_lru_one *l,

include/linux/list_lru.h

bool __list_lru_del(struct list_lru *lru, struct list_lru_one *l,

include/linux/list_lru.h

bool list_lru_add(struct list_lru *lru, struct list_head *item, int nid,

include/linux/list_lru.h

bool list_lru_add_irq(struct list_lru *lru, struct list_head *item, int nid,

include/linux/list_lru.h

bool list_lru_add_obj(struct list_lru *lru, struct list_head *item);

include/linux/list_lru.h

bool list_lru_del(struct list_lru *lru, struct list_head *item, int nid,

include/linux/list_lru.h

bool list_lru_del_obj(struct list_lru *lru, struct list_head *item);

include/linux/list_lru.h

unsigned long list_lru_count_one(struct list_lru *lru,

include/linux/list_lru.h

unsigned long list_lru_count_node(struct list_lru *lru, int nid);

include/linux/list_lru.h

static inline unsigned long list_lru_shrink_count(struct list_lru *lru,

include/linux/list_lru.h

return list_lru_count_one(lru, sc->nid, sc->memcg);

include/linux/list_lru.h

static inline unsigned long list_lru_count(struct list_lru *lru)

include/linux/list_lru.h

count += list_lru_count_node(lru, nid);

include/linux/list_lru.h

struct list_lru_one lru;

include/linux/list_lru.h

void list_lru_destroy(struct list_lru *lru);

include/linux/list_lru.h

int __list_lru_init(struct list_lru *lru, bool memcg_aware,

include/linux/list_lru.h

#define list_lru_init(lru) \

include/linux/list_lru.h

__list_lru_init((lru), false, NULL)

include/linux/list_lru.h

#define list_lru_init_memcg(lru, shrinker) \

include/linux/list_lru.h

__list_lru_init((lru), true, shrinker)

include/linux/list_lru.h

static inline int list_lru_init_memcg_key(struct list_lru *lru, struct shrinker *shrinker,

include/linux/list_lru.h

lru->key = key;

include/linux/list_lru.h

return list_lru_init_memcg(lru, shrinker);

include/linux/list_lru.h

int memcg_list_lru_alloc(struct mem_cgroup *memcg, struct list_lru *lru,

include/linux/lru_cache.h

struct list_head lru;

include/linux/memcontrol.h

enum lru_list lru, int zone_idx)

include/linux/memcontrol.h

void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,

include/linux/memcontrol.h

enum lru_list lru, int zone_idx)

include/linux/memcontrol.h

return READ_ONCE(mz->lru_zone_size[zone_idx][lru]);

include/linux/mm.h

return list_entry((head)->prev, struct folio, lru);

include/linux/mm.h

return (uintptr_t)page->lru.next & BIT(1);

include/linux/mm.h

return (uintptr_t)folio->lru.next & BIT(1);

include/linux/mm.h

page->lru.next = (void *)BIT(1);

include/linux/mm.h

page->lru.next = NULL;

include/linux/mm_inline.h

enum lru_list lru = type * LRU_INACTIVE_FILE;

include/linux/mm_inline.h

lru += LRU_ACTIVE;

include/linux/mm_inline.h

__update_lru_size(lruvec, lru, zone, delta);

include/linux/mm_inline.h

lru += LRU_ACTIVE;

include/linux/mm_inline.h

__update_lru_size(lruvec, lru, zone, -delta);

include/linux/mm_inline.h

__update_lru_size(lruvec, lru, zone, -delta);

include/linux/mm_inline.h

__update_lru_size(lruvec, lru + LRU_ACTIVE, zone, delta);

include/linux/mm_inline.h

list_add_tail(&folio->lru, &lrugen->folios[gen][type][zone]);

include/linux/mm_inline.h

list_add(&folio->lru, &lrugen->folios[gen][type][zone]);

include/linux/mm_inline.h

list_del(&folio->lru);

include/linux/mm_inline.h

enum lru_list lru, enum zone_type zid,

include/linux/mm_inline.h

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

if (lru != LRU_UNEVICTABLE)

include/linux/mm_inline.h

list_add(&folio->lru, &lruvec->lists[lru]);

include/linux/mm_inline.h

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

list_add_tail(&folio->lru, &lruvec->lists[lru]);

include/linux/mm_inline.h

enum lru_list lru = folio_lru_list(folio);

include/linux/mm_inline.h

if (lru != LRU_UNEVICTABLE)

include/linux/mm_inline.h

list_del(&folio->lru);

include/linux/mm_inline.h

update_lru_size(lruvec, lru, folio_zonenum(folio),

include/linux/mm_inline.h

mod_lruvec_state(lruvec, NR_LRU_BASE + lru, nr_pages);

include/linux/mm_inline.h

NR_ZONE_LRU_BASE + lru, nr_pages);

include/linux/mm_inline.h

enum lru_list lru, enum zone_type zid,

include/linux/mm_inline.h

__update_lru_size(lruvec, lru, zid, nr_pages);

include/linux/mm_inline.h

mem_cgroup_update_lru_size(lruvec, lru, zid, nr_pages);

include/linux/mm_inline.h

enum lru_list lru;

include/linux/mm_inline.h

lru = folio_is_file_lru(folio) ? LRU_INACTIVE_FILE : LRU_INACTIVE_ANON;

include/linux/mm_inline.h

lru += LRU_ACTIVE;

include/linux/mm_inline.h

include/linux/mm_types.h

struct list_head lru;

include/linux/mm_types.h

FOLIO_MATCH(lru, lru);

include/linux/mm_types.h

FOLIO_MATCH(compound_info, lru);

include/linux/mm_types.h

struct list_head lru;

include/linux/mmzone.h

#define for_each_lru(lru) for (lru = 0; lru < NR_LRU_LISTS; lru++)

include/linux/mmzone.h

#define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)

include/linux/mmzone.h

static inline bool is_file_lru(enum lru_list lru)

include/linux/mmzone.h

return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);

include/linux/mmzone.h

static inline bool is_active_lru(enum lru_list lru)

include/linux/mmzone.h

return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);

include/linux/nfs_fs.h

struct list_head lru;

include/linux/page-flags.h

PAGEFLAG(LRU, lru, PF_HEAD) __CLEARPAGEFLAG(LRU, lru, PF_HEAD)

include/linux/page-flags.h

TESTCLEARFLAG(LRU, lru, PF_HEAD)

include/linux/slab.h

void *kmem_cache_alloc_lru_noprof(struct kmem_cache *s, struct list_lru *lru,

include/linux/swap.h

unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx);

include/linux/vmstat.h

static inline const char *lru_list_name(enum lru_list lru)

include/linux/vmstat.h

return node_stat_name(NR_LRU_BASE + lru) + 3; // skip "nr_"

include/linux/xarray.h

static inline void xas_set_lru(struct xa_state *xas, struct list_lru *lru)

include/linux/xarray.h

xas->xa_lru = lru;

include/trace/events/mmflags.h

DEF_PAGEFLAG_NAME(lru), \

include/trace/events/pagemap.h

__field(enum lru_list, lru )

include/trace/events/pagemap.h

__entry->lru = folio_lru_list(folio);

include/trace/events/pagemap.h

__entry->lru,

include/trace/events/vmscan.h

include/trace/events/vmscan.h

TP_ARGS(highest_zoneidx, order, nr_requested, nr_scanned, nr_skipped, nr_taken, lru),

include/trace/events/vmscan.h

__field(int, lru)

include/trace/events/vmscan.h

__entry->lru = lru;

include/trace/events/vmscan.h

__print_symbolic(__entry->lru, LRU_NAMES))

kernel/bpf/bpf_lru_list.c

static void __bpf_lru_list_rotate_active(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

if (++i == lru->nr_scans || node == first_node)

kernel/bpf/bpf_lru_list.c

static void __bpf_lru_list_rotate_inactive(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

while (i < lru->nr_scans) {

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_shrink_inactive(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

lru->del_from_htab(lru->del_arg, node)) {

kernel/bpf/bpf_lru_list.c

if (++i == lru->nr_scans)

kernel/bpf/bpf_lru_list.c

static void __bpf_lru_list_rotate(struct bpf_lru *lru, struct bpf_lru_list *l)

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_rotate_active(lru, l);

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_rotate_inactive(lru, l);

kernel/bpf/bpf_lru_list.c

static unsigned int __bpf_lru_list_shrink(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

nshrinked = __bpf_lru_list_shrink_inactive(lru, l, tgt_nshrink,

kernel/bpf/bpf_lru_list.c

lru->del_from_htab(lru->del_arg, node)) {

kernel/bpf/bpf_lru_list.c

static void bpf_lru_list_pop_free_to_local(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

struct bpf_lru_list *l = &lru->common_lru.lru_list;

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_rotate(lru, l);

kernel/bpf/bpf_lru_list.c

if (++nfree == lru->target_free)

kernel/bpf/bpf_lru_list.c

if (nfree < lru->target_free)

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_shrink(lru, l, lru->target_free - nfree,

kernel/bpf/bpf_lru_list.c

static void __local_list_add_pending(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

*(u32 *)((void *)node + lru->hash_offset) = hash;

kernel/bpf/bpf_lru_list.c

__local_list_pop_pending(struct bpf_lru *lru, struct bpf_lru_locallist *loc_l)

kernel/bpf/bpf_lru_list.c

lru->del_from_htab(lru->del_arg, node))) {

kernel/bpf/bpf_lru_list.c

static struct bpf_lru_node *bpf_percpu_lru_pop_free(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

l = per_cpu_ptr(lru->percpu_lru, cpu);

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_rotate(lru, l);

kernel/bpf/bpf_lru_list.c

__bpf_lru_list_shrink(lru, l, PERCPU_FREE_TARGET, free_list,

kernel/bpf/bpf_lru_list.c

*(u32 *)((void *)node + lru->hash_offset) = hash;

kernel/bpf/bpf_lru_list.c

static struct bpf_lru_node *bpf_common_lru_pop_free(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

struct bpf_common_lru *clru = &lru->common_lru;

kernel/bpf/bpf_lru_list.c

bpf_lru_list_pop_free_to_local(lru, loc_l);

kernel/bpf/bpf_lru_list.c

__local_list_add_pending(lru, loc_l, cpu, node, hash);

kernel/bpf/bpf_lru_list.c

node = __local_list_pop_pending(lru, steal_loc_l);

kernel/bpf/bpf_lru_list.c

__local_list_add_pending(lru, loc_l, cpu, node, hash);

kernel/bpf/bpf_lru_list.c

struct bpf_lru_node *bpf_lru_pop_free(struct bpf_lru *lru, u32 hash)

kernel/bpf/bpf_lru_list.c

if (lru->percpu)

kernel/bpf/bpf_lru_list.c

return bpf_percpu_lru_pop_free(lru, hash);

kernel/bpf/bpf_lru_list.c

return bpf_common_lru_pop_free(lru, hash);

kernel/bpf/bpf_lru_list.c

static void bpf_common_lru_push_free(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

loc_l = per_cpu_ptr(lru->common_lru.local_list, node->cpu);

kernel/bpf/bpf_lru_list.c

bpf_lru_list_push_free(&lru->common_lru.lru_list, node);

kernel/bpf/bpf_lru_list.c

static void bpf_percpu_lru_push_free(struct bpf_lru *lru,

kernel/bpf/bpf_lru_list.c

l = per_cpu_ptr(lru->percpu_lru, node->cpu);

kernel/bpf/bpf_lru_list.c

void bpf_lru_push_free(struct bpf_lru *lru, struct bpf_lru_node *node)

kernel/bpf/bpf_lru_list.c

if (lru->percpu)

kernel/bpf/bpf_lru_list.c

bpf_percpu_lru_push_free(lru, node);

kernel/bpf/bpf_lru_list.c

bpf_common_lru_push_free(lru, node);

kernel/bpf/bpf_lru_list.c

static void bpf_common_lru_populate(struct bpf_lru *lru, void *buf,

kernel/bpf/bpf_lru_list.c

struct bpf_lru_list *l = &lru->common_lru.lru_list;

kernel/bpf/bpf_lru_list.c

lru->target_free = clamp((nr_elems / num_possible_cpus()) / 2,

kernel/bpf/bpf_lru_list.c

static void bpf_percpu_lru_populate(struct bpf_lru *lru, void *buf,

kernel/bpf/bpf_lru_list.c

l = per_cpu_ptr(lru->percpu_lru, cpu);

kernel/bpf/bpf_lru_list.c

void bpf_lru_populate(struct bpf_lru *lru, void *buf, u32 node_offset,

kernel/bpf/bpf_lru_list.c

if (lru->percpu)

kernel/bpf/bpf_lru_list.c

bpf_percpu_lru_populate(lru, buf, node_offset, elem_size,

kernel/bpf/bpf_lru_list.c

bpf_common_lru_populate(lru, buf, node_offset, elem_size,

kernel/bpf/bpf_lru_list.c

int bpf_lru_init(struct bpf_lru *lru, bool percpu, u32 hash_offset,

kernel/bpf/bpf_lru_list.c

lru->percpu_lru = alloc_percpu(struct bpf_lru_list);

kernel/bpf/bpf_lru_list.c

if (!lru->percpu_lru)

kernel/bpf/bpf_lru_list.c

l = per_cpu_ptr(lru->percpu_lru, cpu);

kernel/bpf/bpf_lru_list.c

lru->nr_scans = PERCPU_NR_SCANS;

kernel/bpf/bpf_lru_list.c

struct bpf_common_lru *clru = &lru->common_lru;

kernel/bpf/bpf_lru_list.c

lru->nr_scans = LOCAL_NR_SCANS;

kernel/bpf/bpf_lru_list.c

lru->percpu = percpu;

kernel/bpf/bpf_lru_list.c

lru->del_from_htab = del_from_htab;

kernel/bpf/bpf_lru_list.c

lru->del_arg = del_arg;

kernel/bpf/bpf_lru_list.c

lru->hash_offset = hash_offset;

kernel/bpf/bpf_lru_list.c

void bpf_lru_destroy(struct bpf_lru *lru)

kernel/bpf/bpf_lru_list.c

if (lru->percpu)

kernel/bpf/bpf_lru_list.c

free_percpu(lru->percpu_lru);

kernel/bpf/bpf_lru_list.c

free_percpu(lru->common_lru.local_list);

kernel/bpf/bpf_lru_list.h

int bpf_lru_init(struct bpf_lru *lru, bool percpu, u32 hash_offset,

kernel/bpf/bpf_lru_list.h

void bpf_lru_populate(struct bpf_lru *lru, void *buf, u32 node_offset,

kernel/bpf/bpf_lru_list.h

void bpf_lru_destroy(struct bpf_lru *lru);

kernel/bpf/bpf_lru_list.h

struct bpf_lru_node *bpf_lru_pop_free(struct bpf_lru *lru, u32 hash);

kernel/bpf/bpf_lru_list.h

void bpf_lru_push_free(struct bpf_lru *lru, struct bpf_lru_node *node);

kernel/bpf/hashtab.c

bpf_lru_push_free(&htab->lru, &elem->lru_node);

kernel/bpf/hashtab.c

bpf_lru_push_free(&htab->lru, &l_new->lru_node);

kernel/bpf/hashtab.c

bool lru = htab_is_lru(htab);

kernel/bpf/hashtab.c

else if (!lru)

kernel/bpf/hashtab.c

struct bpf_lru_node *node = bpf_lru_pop_free(&htab->lru, hash);

kernel/bpf/hashtab.c

err = bpf_lru_init(&htab->lru,

kernel/bpf/hashtab.c

bpf_lru_populate(&htab->lru, htab->elems,

kernel/bpf/hashtab.c

bpf_lru_destroy(&htab->lru);

kernel/bpf/hashtab.c

bool lru = (attr->map_type == BPF_MAP_TYPE_LRU_HASH ||

kernel/bpf/hashtab.c

if (!lru && percpu_lru)

kernel/bpf/hashtab.c

if (lru && !prealloc)

kernel/bpf/hashtab.c

struct bpf_lru lru;

kernel/kexec_core.c

list_for_each_entry_safe(page, next, list, lru) {

kernel/kexec_core.c

list_del(&page->lru);

kernel/kexec_core.c

list_add(&pages->lru, &extra_pages);

kernel/kexec_core.c

list_add(&pages->lru, &image->control_pages);

kernel/kexec_core.c

list_for_each_entry(page, &image->dest_pages, lru) {

kernel/kexec_core.c

list_del(&page->lru);

kernel/kexec_core.c

list_add(&page->lru, &image->unusable_pages);

kernel/kexec_core.c

list_add(&page->lru, &image->dest_pages);

kernel/power/wakelock.c

list_move(&wl->lru, &wakelocks_lru_list);

kernel/power/wakelock.c

list_for_each_entry_safe_reverse(wl, aux, &wakelocks_lru_list, lru) {

kernel/power/wakelock.c

list_del(&wl->lru);

kernel/power/wakelock.c

struct list_head lru;

kernel/power/wakelock.c

list_add(&wl->lru, &wakelocks_lru_list);

kernel/vmcore_info.c

VMCOREINFO_OFFSET(page, lru);

lib/lru_cache.c

INIT_LIST_HEAD(&lc->lru);

lib/lru_cache.c

INIT_LIST_HEAD(&lc->lru);

lib/lru_cache.c

else if (!list_empty(&lc->lru))

lib/lru_cache.c

n = lc->lru.prev;

lib/lru_cache.c

if (!list_empty(&lc->lru))

lib/lru_cache.c

list_move(&e->list, &lc->lru);

lib/test_lockup.c

list_add(&page->lru, pages);

lib/test_lockup.c

list_for_each_entry_safe(page, next, pages, lru)

mm/balloon.c

list_for_each_entry_safe(page, tmp, &b_dev_info->pages, lru) {

mm/balloon.c

list_del(&page->lru);

mm/balloon.c

list_add(&page->lru, pages);

mm/balloon.c

return list_first_entry(&pages, struct page, lru);

mm/balloon.c

list_del(&page->lru);

mm/balloon.c

list_add(&page->lru, &b_dev_info->pages);

mm/balloon.c

list_add(&page->lru, &balloon->pages);

mm/balloon.c

list_for_each_entry_safe(page, tmp, pages, lru) {

mm/balloon.c

list_del(&page->lru);

mm/compaction.c

list_del(&page->lru);

mm/compaction.c

list_add(&folio->lru, &cc->migratepages);

mm/compaction.c

list_add_tail(&page->lru, &cc->freepages[order]);

mm/compaction.c

mm/compaction.c

list_del(&freepage->lru);

mm/compaction.c

list_add(&freepage[size].lru, &cc->freepages[start_order]);

mm/compaction.c

list_add(&dst->lru, &cc->freepages[order]);

mm/compaction.c

list_add_tail(&page->lru, &freelist[order]);

mm/compaction.c

list_for_each_entry_safe(page, next, &freepages[order], lru) {

mm/damon/ops-common.c

list_del(&folio->lru);

mm/damon/ops-common.c

list_add(&folio->lru, &migrate_folios);

mm/damon/ops-common.c

list_add(&folio->lru, &ret_folios);

mm/damon/ops-common.c

list_del(&folio->lru);

mm/damon/ops-common.c

list_move(&folio->lru, &node_folio_list);

mm/damon/paddr.c

list_add(&folio->lru, &folio_list);

mm/damon/paddr.c

list_add(&folio->lru, &folio_list);

mm/damon/vaddr.c

list_add(&folio->lru, &migration_lists[i]);

mm/gup.c

list_add_tail(&folio->lru, movable_folio_list);

mm/huge_memory.c

list_add_tail(&new_folio->lru, list);

mm/huge_memory.c

list_add_tail(&new_folio->lru, &folio->lru);

mm/huge_memory.c

struct list_lru_one *lru;

mm/huge_memory.c

lru = list_lru_lock(&deferred_split_lru,

mm/huge_memory.c

__list_lru_del(&deferred_split_lru, lru,

mm/huge_memory.c

list_lru_unlock(lru);

mm/huge_memory.c

list_lru_unlock(lru);

mm/huge_memory.c

struct list_lru_one *lru;

mm/huge_memory.c

lru = list_lru_lock_irqsave(&deferred_split_lru, nid, &memcg, &flags);

mm/huge_memory.c

if (__list_lru_del(&deferred_split_lru, lru, &folio->_deferred_list, nid)) {

mm/huge_memory.c

list_lru_unlock_irqrestore(lru, &flags);

mm/huge_memory.c

struct list_lru_one *lru;

mm/huge_memory.c

lru = list_lru_lock_irqsave(&deferred_split_lru, nid, &memcg, &flags);

mm/huge_memory.c

__list_lru_add(&deferred_split_lru, lru, &folio->_deferred_list, nid, memcg);

mm/huge_memory.c

list_lru_unlock_irqrestore(lru, &flags);

mm/huge_memory.c

struct list_lru_one *lru,

mm/huge_memory.c

list_lru_isolate_move(lru, item, freeable);

mm/huge_memory.c

list_lru_isolate(lru, item);

mm/hugetlb.c

list_move(&folio->lru, &h->hugepage_freelists[nid]);

mm/hugetlb.c

list_for_each_entry(folio, &h->hugepage_freelists[nid], lru) {

mm/hugetlb.c

list_move(&folio->lru, &h->hugepage_activelist);

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

INIT_LIST_HEAD(&folio->lru);

mm/hugetlb.c

list_for_each_entry_safe(folio, t_folio, non_hvo_folios, lru) {

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

list_for_each_entry_safe(folio, t_folio, folio_list, lru)

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

list_for_each_entry(folio, &non_hvo_folios, lru)

mm/hugetlb.c

list_for_each_entry_safe(folio, t_folio, &non_hvo_folios, lru) {

mm/hugetlb.c

INIT_LIST_HEAD(&folio->lru);

mm/hugetlb.c

list_for_each_entry_safe(folio, tmp_f, folio_list, lru) {

mm/hugetlb.c

struct folio, lru);

mm/hugetlb.c

list_add(&folio->lru, &surplus_list);

mm/hugetlb.c

list_for_each_entry_safe(folio, tmp, &surplus_list, lru) {

mm/hugetlb.c

list_for_each_entry_safe(folio, tmp, &surplus_list, lru)

mm/hugetlb.c

list_add(&folio->lru, &page_list);

mm/hugetlb.c

list_add(&folio->lru, &h->hugepage_activelist);

mm/hugetlb.c

list_for_each_entry_safe(folio, tmp_f, folio_list, lru) {

mm/hugetlb.c

list_add(&folio->lru, &folio_list);

mm/hugetlb.c

list_add(&folio->lru, &folio_list);

mm/hugetlb.c

list_move(&folio->lru, &folio_list);

mm/hugetlb.c

list_for_each_entry_safe(folio, next, freel, lru) {

mm/hugetlb.c

list_add(&folio->lru, &page_list);

mm/hugetlb.c

list_add(&folio->lru, &page_list);

mm/hugetlb.c

list_add(&folio->lru, &page_list);

mm/hugetlb.c

list_for_each_entry_safe(folio, next, src_list, lru) {

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

list_add(&new_folio->lru, &dst_list);

mm/hugetlb.c

list_for_each_entry_safe(folio, next, &src->hugepage_freelists[node], lru) {

mm/hugetlb.c

list_add(&folio->lru, &list);

mm/hugetlb.c

list_for_each_entry_safe(folio, next, &list, lru) {

mm/hugetlb.c

list_del(&folio->lru);

mm/hugetlb.c

list_move_tail(&folio->lru, list);

mm/hugetlb.c

list_move_tail(&folio->lru, &(folio_hstate(folio))->hugepage_activelist);

mm/hugetlb.c

list_move_tail(&new_folio->lru, &(folio_hstate(new_folio))->hugepage_activelist);

mm/hugetlb_cgroup.c

list_for_each_entry(folio, &h->hugepage_activelist, lru)

mm/hugetlb_cgroup.c

list_move(&new_folio->lru, &h->hugepage_activelist);

mm/hugetlb_vmemmap.c

list_for_each_entry_safe(page, next, list, lru)

mm/hugetlb_vmemmap.c

list_del(&walk->vmemmap_head->lru);

mm/hugetlb_vmemmap.c

list_add(&page->lru, walk->vmemmap_pages);

mm/hugetlb_vmemmap.c

dst = list_first_entry(walk->vmemmap_pages, struct page, lru);

mm/hugetlb_vmemmap.c

list_del(&dst->lru);

mm/hugetlb_vmemmap.c

list_add(&page->lru, list);

mm/hugetlb_vmemmap.c

list_for_each_entry_safe(page, next, list, lru)

mm/hugetlb_vmemmap.c

list_for_each_entry_safe(folio, t_folio, folio_list, lru) {

mm/hugetlb_vmemmap.c

list_move(&folio->lru, non_hvo_folios);

mm/hugetlb_vmemmap.c

list_add(&vmemmap_head->lru, vmemmap_pages);

mm/hugetlb_vmemmap.c

list_for_each_entry(folio, folio_list, lru) {

mm/hugetlb_vmemmap.c

list_for_each_entry(folio, folio_list, lru) {

mm/khugepaged.c

list_add_tail(&folio->lru, &pagelist);

mm/khugepaged.c

list_for_each_entry(folio, &pagelist, lru) {

mm/khugepaged.c

list_for_each_entry_safe(folio, tmp, &pagelist, lru) {

mm/khugepaged.c

list_del(&folio->lru);

mm/khugepaged.c

list_for_each_entry_safe(folio, tmp, &pagelist, lru) {

mm/khugepaged.c

list_del(&folio->lru);

mm/khugepaged.c

list_for_each_entry_safe(folio, tmp, compound_pagelist, lru) {

mm/khugepaged.c

list_del(&folio->lru);

mm/khugepaged.c

list_for_each_entry(f, compound_pagelist, lru) {

mm/khugepaged.c

list_add_tail(&folio->lru, compound_pagelist);

mm/khugepaged.c

list_for_each_entry_safe(src, tmp, compound_pagelist, lru) {

mm/khugepaged.c

list_del(&src->lru);

mm/list_lru.c

static void list_lru_register(struct list_lru *lru)

mm/list_lru.c

static void list_lru_unregister(struct list_lru *lru)

mm/list_lru.c

static int lru_shrinker_id(struct list_lru *lru)

mm/list_lru.c

static inline bool list_lru_memcg_aware(struct list_lru *lru)

mm/list_lru.c

list_lru_from_memcg_idx(struct list_lru *lru, int nid, int idx)

mm/list_lru.c

return &lru->node[nid].lru;

mm/list_lru.c

lock_list_lru_of_memcg(struct list_lru *lru, int nid,

mm/list_lru.c

struct list_lru_one *l = &lru->node[nid].lru;

mm/list_lru.c

struct list_lru_one *list_lru_lock(struct list_lru *lru, int nid,

mm/list_lru.c

return lock_list_lru_of_memcg(lru, nid, memcg, /*irq=*/false,

mm/list_lru.c

struct list_lru_one *list_lru_lock_irq(struct list_lru *lru, int nid,

mm/list_lru.c

return lock_list_lru_of_memcg(lru, nid, memcg, /*irq=*/true,

mm/list_lru.c

struct list_lru_one *list_lru_lock_irqsave(struct list_lru *lru, int nid,

mm/list_lru.c

return lock_list_lru_of_memcg(lru, nid, memcg, /*irq=*/true,

mm/list_lru.c

bool __list_lru_add(struct list_lru *lru, struct list_lru_one *l,

mm/list_lru.c

set_shrinker_bit(memcg, nid, lru_shrinker_id(lru));

mm/list_lru.c

atomic_long_inc(&lru->node[nid].nr_items);

mm/list_lru.c

bool __list_lru_del(struct list_lru *lru, struct list_lru_one *l,

mm/list_lru.c

atomic_long_dec(&lru->node[nid].nr_items);

mm/list_lru.c

bool list_lru_add(struct list_lru *lru, struct list_head *item, int nid,

mm/list_lru.c

l = list_lru_lock(lru, nid, &memcg);

mm/list_lru.c

ret = __list_lru_add(lru, l, item, nid, memcg);

mm/list_lru.c

bool list_lru_add_irq(struct list_lru *lru, struct list_head *item,

mm/list_lru.c

l = list_lru_lock_irq(lru, nid, &memcg);

mm/list_lru.c

ret = __list_lru_add(lru, l, item, nid, memcg);

mm/list_lru.c

bool list_lru_add_obj(struct list_lru *lru, struct list_head *item)

mm/list_lru.c

if (list_lru_memcg_aware(lru)) {

mm/list_lru.c

ret = list_lru_add(lru, item, nid, mem_cgroup_from_virt(item));

mm/list_lru.c

ret = list_lru_add(lru, item, nid, NULL);

mm/list_lru.c

bool list_lru_del(struct list_lru *lru, struct list_head *item, int nid,

mm/list_lru.c

l = list_lru_lock(lru, nid, &memcg);

mm/list_lru.c

ret = __list_lru_del(lru, l, item, nid);

mm/list_lru.c

bool list_lru_del_obj(struct list_lru *lru, struct list_head *item)

mm/list_lru.c

if (list_lru_memcg_aware(lru)) {

mm/list_lru.c

ret = list_lru_del(lru, item, nid, mem_cgroup_from_virt(item));

mm/list_lru.c

ret = list_lru_del(lru, item, nid, NULL);

mm/list_lru.c

unsigned long list_lru_count_one(struct list_lru *lru,

mm/list_lru.c

l = list_lru_from_memcg_idx(lru, nid, memcg_kmem_id(memcg));

mm/list_lru.c

unsigned long list_lru_count_node(struct list_lru *lru, int nid)

mm/list_lru.c

nlru = &lru->node[nid];

mm/list_lru.c

__list_lru_walk_one(struct list_lru *lru, int nid, struct mem_cgroup *memcg,

mm/list_lru.c

struct list_lru_node *nlru = &lru->node[nid];

mm/list_lru.c

l = lock_list_lru_of_memcg(lru, nid, &memcg, /*irq=*/irq_off,

mm/list_lru.c

list_lru_walk_one(struct list_lru *lru, int nid, struct mem_cgroup *memcg,

mm/list_lru.c

return __list_lru_walk_one(lru, nid, memcg, isolate,

mm/list_lru.c

list_lru_walk_one_irq(struct list_lru *lru, int nid, struct mem_cgroup *memcg,

mm/list_lru.c

return __list_lru_walk_one(lru, nid, memcg, isolate,

mm/list_lru.c

unsigned long list_lru_walk_node(struct list_lru *lru, int nid,

mm/list_lru.c

isolated += list_lru_walk_one(lru, nid, NULL, isolate, cb_arg,

mm/list_lru.c

if (*nr_to_walk > 0 && list_lru_memcg_aware(lru)) {

mm/list_lru.c

xa_for_each(&lru->xa, index, mlru) {

mm/list_lru.c

isolated += __list_lru_walk_one(lru, nid, memcg,

mm/list_lru.c

static inline bool list_lru_memcg_aware(struct list_lru *lru)

mm/list_lru.c

static void init_one_lru(struct list_lru *lru, struct list_lru_one *l)

mm/list_lru.c

if (lru->key)

mm/list_lru.c

lockdep_set_class(&l->lock, lru->key);

mm/list_lru.c

return lru->memcg_aware;

mm/list_lru.c

static struct list_lru_memcg *memcg_init_list_lru_one(struct list_lru *lru, gfp_t gfp)

mm/list_lru.c

init_one_lru(lru, &mlru->node[nid]);

mm/list_lru.c

static inline void memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)

mm/list_lru.c

xa_init_flags(&lru->xa, XA_FLAGS_LOCK_IRQ);

mm/list_lru.c

lru->memcg_aware = memcg_aware;

mm/list_lru.c

static void memcg_destroy_list_lru(struct list_lru *lru)

mm/list_lru.c

XA_STATE(xas, &lru->xa, 0);

mm/list_lru.c

static void list_lru_register(struct list_lru *lru)

mm/list_lru.c

if (!list_lru_memcg_aware(lru))

mm/list_lru.c

static void memcg_reparent_list_lru_one(struct list_lru *lru, int nid,

mm/list_lru.c

dst = list_lru_from_memcg_idx(lru, nid, dst_idx);

mm/list_lru.c

if (!list_lru_memcg_aware(lru))

mm/list_lru.c

set_shrinker_bit(dst_memcg, nid, lru_shrinker_id(lru));

mm/list_lru.c

struct list_lru *lru;

mm/list_lru.c

list_for_each_entry(lru, &memcg_list_lrus, list) {

mm/list_lru.c

mlru = xa_load(&lru->xa, memcg->kmemcg_id);

mm/list_lru.c

list_add(&lru->list, &memcg_list_lrus);

mm/list_lru.c

memcg_reparent_list_lru_one(lru, i, &mlru->node[i], parent);

mm/list_lru.c

xa_erase_irq(&lru->xa, memcg->kmemcg_id);

mm/list_lru.c

struct list_lru *lru)

mm/list_lru.c

return idx < 0 || xa_load(&lru->xa, idx);

mm/list_lru.c

struct list_lru *lru, gfp_t gfp)

mm/list_lru.c

XA_STATE(xas, &lru->xa, 0);

mm/list_lru.c

static void list_lru_unregister(struct list_lru *lru)

mm/list_lru.c

while (!memcg_list_lru_allocated(parent, lru)) {

mm/list_lru.c

mlru = memcg_init_list_lru_one(lru, gfp);

mm/list_lru.c

if (!list_lru_memcg_aware(lru))

mm/list_lru.c

int memcg_list_lru_alloc(struct mem_cgroup *memcg, struct list_lru *lru,

mm/list_lru.c

if (!list_lru_memcg_aware(lru) || memcg_list_lru_allocated(memcg, lru))

mm/list_lru.c

return __memcg_list_lru_alloc(memcg, lru, gfp);

mm/list_lru.c

int folio_memcg_list_lru_alloc(struct folio *folio, struct list_lru *lru,

mm/list_lru.c

if (!list_lru_memcg_aware(lru))

mm/list_lru.c

res = memcg_list_lru_allocated(memcg, lru);

mm/list_lru.c

list_del(&lru->list);

mm/list_lru.c

res = __memcg_list_lru_alloc(memcg, lru, gfp);

mm/list_lru.c

static inline void memcg_init_list_lru(struct list_lru *lru, bool memcg_aware)

mm/list_lru.c

static void memcg_destroy_list_lru(struct list_lru *lru)

mm/list_lru.c

int __list_lru_init(struct list_lru *lru, bool memcg_aware, struct shrinker *shrinker)

mm/list_lru.c

lru->shrinker_id = shrinker->id;

mm/list_lru.c

lru->shrinker_id = -1;

mm/list_lru.c

lru->node = kzalloc_objs(*lru->node, nr_node_ids);

mm/list_lru.c

if (!lru->node)

mm/list_lru.c

init_one_lru(lru, &lru->node[i].lru);

mm/list_lru.c

memcg_init_list_lru(lru, memcg_aware);

mm/list_lru.c

list_lru_register(lru);

mm/list_lru.c

static int lru_shrinker_id(struct list_lru *lru)

mm/list_lru.c

void list_lru_destroy(struct list_lru *lru)

mm/list_lru.c

if (!lru->node)

mm/list_lru.c

list_lru_unregister(lru);

mm/list_lru.c

memcg_destroy_list_lru(lru);

mm/list_lru.c

kfree(lru->node);

mm/list_lru.c

lru->node = NULL;

mm/list_lru.c

lru->shrinker_id = -1;

mm/list_lru.c

return lru->shrinker_id;

mm/list_lru.c

list_lru_from_memcg_idx(struct list_lru *lru, int nid, int idx)

mm/list_lru.c

if (list_lru_memcg_aware(lru) && idx >= 0) {

mm/list_lru.c

struct list_lru_memcg *mlru = xa_load(&lru->xa, idx);

mm/list_lru.c

return &lru->node[nid].lru;

mm/list_lru.c

lock_list_lru_of_memcg(struct list_lru *lru, int nid,

mm/list_lru.c

l = list_lru_from_memcg_idx(lru, nid, memcg_kmem_id(*memcg));

mm/madvise.c

list_add(&folio->lru, &folio_list);

mm/madvise.c

list_add(&folio->lru, &folio_list);

mm/memcontrol-v1.c

enum lru_list lru;

mm/memcontrol-v1.c

for_each_lru(lru) {

mm/memcontrol-v1.c

if (!(BIT(lru) & lru_mask))

mm/memcontrol-v1.c

nr += lruvec_page_state(lruvec, NR_LRU_BASE + lru);

mm/memcontrol-v1.c

nr += lruvec_page_state_local(lruvec, NR_LRU_BASE + lru);

mm/memcontrol-v1.c

enum lru_list lru;

mm/memcontrol-v1.c

for_each_lru(lru) {

mm/memcontrol-v1.c

if (!(BIT(lru) & lru_mask))

mm/memcontrol-v1.c

nr += memcg_page_state(memcg, NR_LRU_BASE + lru);

mm/memcontrol-v1.c

nr += memcg_page_state_local(memcg, NR_LRU_BASE + lru);

mm/memcontrol.c

void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,

mm/memcontrol.c

lru_size = &mz->lru_zone_size[zid][lru];

mm/memcontrol.c

__func__, lruvec, lru, nr_pages, size)) {

mm/memcontrol.c

bool __memcg_slab_post_alloc_hook(struct kmem_cache *s, struct list_lru *lru,

mm/memcontrol.c

mm/memcontrol.c

ret = memcg_list_lru_alloc(memcg, lru, flags);

mm/memory-failure.c

{ lru|dirty, lru|dirty, MF_MSG_DIRTY_LRU, me_pagecache_dirty },

mm/memory-failure.c

{ lru|dirty, lru, MF_MSG_CLEAN_LRU, me_pagecache_clean },

mm/memory_hotplug.c

mtc.nid = folio_nid(list_first_entry(&source, struct folio, lru));

mm/memory_hotplug.c

list_for_each_entry(folio, &source, lru) {

mm/mempolicy.c

list_add_tail(&folio->lru, foliolist);

mm/mempolicy.c

list_for_each_entry(folio, &pagelist, lru) {

mm/mempolicy.c

if (!list_entry_is_head(folio, &pagelist, lru)) {

mm/migrate.c

list_move_tail(&src->lru, ret);

mm/migrate.c

prev = dst->lru.prev;

mm/migrate.c

list_del(&dst->lru);

mm/migrate.c

list_del(&src->lru);

mm/migrate.c

list_add(&dst->lru, prev);

mm/migrate.c

list_move_tail(&src->lru, ret);

mm/migrate.c

list_move_tail(&folio->lru, split_folios);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

list_move_tail(&folio->lru, ret_folios);

mm/migrate.c

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

dst2 = list_next_entry(dst, lru);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, src_folios, lru) {

mm/migrate.c

dst2 = list_next_entry(dst, lru);

mm/migrate.c

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

dst2 = list_next_entry(dst, lru);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, src_folios, lru) {

mm/migrate.c

list_del(&dst->lru);

mm/migrate.c

dst2 = list_next_entry(dst, lru);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

list_move_tail(&folio->lru, ret_folios);

mm/migrate.c

list_del(&folio->lru);

mm/migrate.c

list_move_tail(&folio->lru, &unmap_folios);

mm/migrate.c

list_add_tail(&dst->lru, &dst_folios);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, from, lru) {

mm/migrate.c

list_move_tail(&folio->lru, &ret_folios);

mm/migrate.c

list_cut_before(&folios, from, &folio2->lru);

mm/migrate.c

list_add_tail(&folio->lru, pagelist);

mm/migrate.c

list_for_each_entry_safe(folio, folio2, l, lru) {

mm/migrate.c

list_del(&folio->lru);

mm/migrate.c

list_add(&folio->lru, &migratepages);

mm/migrate.c

list_add(&folio->lru, list);

mm/mm_init.c

INIT_LIST_HEAD(&page->lru);

mm/mmzone.c

enum lru_list lru;

mm/mmzone.c

for_each_lru(lru)

mm/mmzone.c

INIT_LIST_HEAD(&lruvec->lists[lru]);

mm/page_alloc.c

list_for_each_entry(page, page_list, lru)

mm/page_alloc.c

list_for_each_entry_safe(page, next, &list[order], lru) {

mm/page_alloc.c

list_del(&page->lru);

mm/page_alloc.c

list_add_tail(&page[i].lru, &list[0]);

mm/page_alloc.c

list_del(&page->lru);

mm/page_alloc.c

struct page, lru);

mm/page_alloc.c

list_add_tail(&page->lru, &zone->unaccepted_pages);

mm/page_reporting.c

list_for_each_entry_safe(page, next, list, lru) {

mm/page_reporting.c

if (!list_is_first(&page->lru, list))

mm/page_reporting.c

list_rotate_to_front(&page->lru, list);

mm/page_reporting.c

next = list_first_entry(list, struct page, lru);

mm/page_reporting.c

if (!list_entry_is_head(next, list, lru) && !list_is_first(&next->lru, list))

mm/page_reporting.c

list_rotate_to_front(&next->lru, list);

mm/pgtable-generic.c

INIT_LIST_HEAD(&pgtable->lru);

mm/pgtable-generic.c

list_add(&pgtable->lru, &pmd_huge_pte(mm, pmdp)->lru);

mm/pgtable-generic.c

pmd_huge_pte(mm, pmdp) = list_first_entry_or_null(&pgtable->lru,

mm/pgtable-generic.c

struct page, lru);

mm/pgtable-generic.c

list_del(&pgtable->lru);

mm/shuffle.c

list_swap(&page_i->lru, &page_j->lru);

mm/slab.h

bool __memcg_slab_post_alloc_hook(struct kmem_cache *s, struct list_lru *lru,

mm/slub.c

struct list_lru *lru;

mm/slub.c

if (likely(__memcg_slab_post_alloc_hook(s, ac->lru, flags,

mm/slub.c

void *kmem_cache_alloc_lru_noprof(struct kmem_cache *s, struct list_lru *lru,

mm/slub.c

mm/swap.c

enum lru_list lru, int nid)

mm/swap.c

if (lru != LRU_UNEVICTABLE)

mm/swap.c

list_splice_tail_init(&child_lruvec->lists[lru], &parent_lruvec->lists[lru]);

mm/swap.c

unsigned long size = mem_cgroup_get_zone_lru_size(child_lruvec, lru, zid);

mm/swap.c

mem_cgroup_update_lru_size(parent_lruvec, lru, zid, size);

mm/swap.c

enum lru_list lru;

mm/swap.c

for_each_lru(lru)

mm/swap.c

lruvec_reparent_lru(child_lruvec, parent_lruvec, lru, nid);

mm/vmscan.c

list_del(&folio->lru);

mm/vmscan.c

list_add_tail(&folio->lru, folio_list);

mm/vmscan.c

list_add(&folio->lru, &demote_folios);

mm/vmscan.c

list_add(&folio->lru, &ret_folios);

mm/vmscan.c

list_for_each_entry_safe(folio, next, folio_list, lru) {

mm/vmscan.c

list_move(&folio->lru, &clean_folios);

mm/vmscan.c

enum lru_list lru, unsigned long *nr_zone_taken)

mm/vmscan.c

update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);

mm/vmscan.c

enum lru_list lru)

mm/vmscan.c

struct list_head *src = &lruvec->lists[lru];

mm/vmscan.c

list_move(&folio->lru, move_to);

mm/vmscan.c

total_scan, skipped, nr_taken, lru);

mm/vmscan.c

update_lru_sizes(lruvec, lru, nr_zone_taken);

mm/vmscan.c

if ((_folio)->lru.prev != _base) { \

mm/vmscan.c

prev = lru_to_folio(&(_folio->lru)); \

mm/vmscan.c

list_del(&folio->lru);

mm/vmscan.c

enum lru_list lru)

mm/vmscan.c

bool file = is_file_lru(lru);

mm/vmscan.c

&nr_scanned, sc, lru);

mm/vmscan.c

enum lru_list lru)

mm/vmscan.c

bool file = is_file_lru(lru);

mm/vmscan.c

&nr_scanned, sc, lru);

mm/vmscan.c

list_del(&folio->lru);

mm/vmscan.c

list_add(&folio->lru, &l_active);

mm/vmscan.c

list_add(&folio->lru, &l_inactive);

mm/vmscan.c

list_del(&folio->lru);

mm/vmscan.c

list_move(&folio->lru, &node_folio_list);

mm/vmscan.c

static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,

mm/vmscan.c

if (is_active_lru(lru)) {

mm/vmscan.c

if (sc->may_deactivate & (1 << is_file_lru(lru)))

mm/vmscan.c

shrink_active_list(nr_to_scan, lruvec, sc, lru);

mm/vmscan.c

return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);

mm/vmscan.c

enum lru_list lru;

mm/vmscan.c

for_each_evictable_lru(lru) {

mm/vmscan.c

bool file = is_file_lru(lru);

mm/vmscan.c

lruvec_size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx);

mm/vmscan.c

nr[lru] = scan;

mm/vmscan.c

enum lru_list lru = type * LRU_INACTIVE_FILE;

mm/vmscan.c

lru += LRU_ACTIVE;

mm/vmscan.c

__update_lru_size(lruvec, lru, zone, delta);

mm/vmscan.c

list_move_tail(&folio->lru, &lrugen->folios[new_gen][type][zone]);

mm/vmscan.c

unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx)

mm/vmscan.c

enum lru_list lru = type * LRU_INACTIVE_FILE;

mm/vmscan.c

__update_lru_size(lruvec, lru, zone, delta);

mm/vmscan.c

__update_lru_size(lruvec, lru + LRU_ACTIVE, zone, -delta);

mm/vmscan.c

size += mem_cgroup_get_zone_lru_size(lruvec, lru, zid);

mm/vmscan.c

size += zone_page_state(zone, NR_ZONE_LRU_BASE + lru);

mm/vmscan.c

enum lru_list lru = type * LRU_INACTIVE_FILE;

mm/vmscan.c

__update_lru_size(child_lruvec, lru + child_lru_active, zone, -nr_pages);

mm/vmscan.c

__update_lru_size(parent_lruvec, lru + parent_lru_active, zone, nr_pages);

mm/vmscan.c

enum lru_list lru;

mm/vmscan.c

for_each_lru(lru) {

mm/vmscan.c

unsigned long size = mem_cgroup_get_zone_lru_size(child_lruvec, lru, zid);

mm/vmscan.c

mem_cgroup_update_lru_size(parent_lruvec, lru, zid, size);

mm/vmscan.c

list_move(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

list_move(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

list_move_tail(&folio->lru, &lrugen->folios[gen][type][zone]);

mm/vmscan.c

list_add(&folio->lru, list);

mm/vmscan.c

list_move(&folio->lru, &moved);

mm/vmscan.c

list_for_each_entry_safe_reverse(folio, next, &list, lru) {

mm/vmscan.c

list_del(&folio->lru);

mm/vmscan.c

list_move(&folio->lru, &clean);

mm/vmscan.c

enum lru_list lru;

mm/vmscan.c

for_each_evictable_lru(lru) {

mm/vmscan.c

if (!list_empty(&lruvec->lists[lru]))

mm/vmscan.c

enum lru_list lru;

mm/vmscan.c

for_each_evictable_lru(lru) {

mm/vmscan.c

int type = is_file_lru(lru);

mm/vmscan.c

bool active = is_active_lru(lru);

mm/vmscan.c

struct list_head *head = &lruvec->lists[lru];

mm/vmscan.c

enum lru_list lru;

mm/vmscan.c

for_each_evictable_lru(lru) {

mm/vmscan.c

if (nr[lru]) {

mm/vmscan.c

nr_to_scan = min(nr[lru], SWAP_CLUSTER_MAX);

mm/vmscan.c

nr[lru] -= nr_to_scan;

mm/vmscan.c

nr_reclaimed += shrink_list(lru, nr_to_scan,

mm/vmscan.c

lru = LRU_BASE;

mm/vmscan.c

lru = LRU_FILE;

mm/vmscan.c

mm/vmscan.c

nr[lru + LRU_ACTIVE] = 0;

mm/vmscan.c

lru = (lru == LRU_FILE) ? LRU_BASE : LRU_FILE;

mm/vmscan.c

nr_scanned = targets[lru] - nr[lru];

mm/vmscan.c

nr[lru] = targets[lru] * (100 - percentage) / 100;

mm/vmscan.c

nr[lru] -= min(nr[lru], nr_scanned);

mm/vmscan.c

lru += LRU_ACTIVE;

mm/vmscan.c

nr_scanned = targets[lru] - nr[lru];

mm/vmscan.c

nr[lru] = targets[lru] * (100 - percentage) / 100;

mm/vmscan.c

nr[lru] -= min(nr[lru], nr_scanned);

mm/workingset.c

struct list_lru_one *lru,

mm/workingset.c

void *arg) __must_hold(lru->lock)

mm/workingset.c

spin_unlock_irq(&lru->lock);

mm/workingset.c

spin_unlock_irq(&lru->lock);

mm/workingset.c

list_lru_isolate(lru, item);

mm/workingset.c

spin_unlock(&lru->lock);

mm/zpdesc.h

struct list_head lru;

mm/zpdesc.h

ZPDESC_MATCH(lru, lru);

mm/zswap.c

struct zswap_entry *entry = container_of(item, struct zswap_entry, lru);

mm/zswap.c

INIT_LIST_HEAD(&entry->lru);

mm/zswap.c

struct list_head lru;

mm/zswap.c

list_lru_add(list_lru, &entry->lru, nid, memcg);

mm/zswap.c

list_lru_del(list_lru, &entry->lru, nid, memcg);

net/ceph/messenger.c

page = list_first_entry(&pagelist->head, struct page, lru);

net/ceph/messenger.c

BUG_ON(list_is_last(&cursor->page->lru, &pagelist->head));

net/ceph/messenger.c

cursor->page = list_next_entry(cursor->page, lru);

net/ceph/pagelist.c

list_add_tail(&page->lru, &pl->free_list);

net/ceph/pagelist.c

struct page, lru);

net/ceph/pagelist.c

list_del(&page->lru);

net/ceph/pagelist.c

struct page *page = list_entry(pl->head.prev, struct page, lru);

net/ceph/pagelist.c

net/ceph/pagelist.c

list_del(&page->lru);

net/ceph/pagelist.c

page = list_first_entry(&pl->free_list, struct page, lru);

net/ceph/pagelist.c

list_del(&page->lru);

net/ceph/pagelist.c

list_add_tail(&page->lru, &pl->head);

rust/helpers/binder.c

__rust_helper unsigned long rust_helper_list_lru_count(struct list_lru *lru)

rust/helpers/binder.c

return list_lru_count(lru);

rust/helpers/binder.c

__rust_helper unsigned long rust_helper_list_lru_walk(struct list_lru *lru,

rust/helpers/binder.c

return list_lru_walk(lru, isolate, cb_arg, nr_to_walk);

samples/bpf/test_lru_dist.c

lru->map_fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,

samples/bpf/test_lru_dist.c

assert(lru->map_fd != -1);

samples/bpf/test_lru_dist.c

lru->free_nodes = malloc(lru_size * sizeof(struct pfect_lru_node));

samples/bpf/test_lru_dist.c

assert(lru->free_nodes);

samples/bpf/test_lru_dist.c

INIT_LIST_HEAD(&lru->list);

samples/bpf/test_lru_dist.c

lru->cur_size = 0;

samples/bpf/test_lru_dist.c

lru->lru_size = lru_size;

samples/bpf/test_lru_dist.c

lru->nr_unique = lru->nr_misses = lru->total = 0;

samples/bpf/test_lru_dist.c

static void pfect_lru_destroy(struct pfect_lru *lru)

samples/bpf/test_lru_dist.c

close(lru->map_fd);

samples/bpf/test_lru_dist.c

free(lru->free_nodes);

samples/bpf/test_lru_dist.c

static int pfect_lru_lookup_or_insert(struct pfect_lru *lru,

samples/bpf/test_lru_dist.c

lru->total++;

samples/bpf/test_lru_dist.c

if (!bpf_map_lookup_elem(lru->map_fd, &key, &node)) {

samples/bpf/test_lru_dist.c

list_move(&node->list, &lru->list);

samples/bpf/test_lru_dist.c

if (lru->cur_size < lru->lru_size) {

samples/bpf/test_lru_dist.c

node = &lru->free_nodes[lru->cur_size++];

samples/bpf/test_lru_dist.c

node = list_last_entry(&lru->list,

samples/bpf/test_lru_dist.c

bpf_map_update_elem(lru->map_fd, &node->key, &null_node, BPF_EXIST);

samples/bpf/test_lru_dist.c

list_move(&node->list, &lru->list);

samples/bpf/test_lru_dist.c

lru->nr_misses++;

samples/bpf/test_lru_dist.c

assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_EXIST));

samples/bpf/test_lru_dist.c

lru->nr_unique++;

samples/bpf/test_lru_dist.c

assert(!bpf_map_update_elem(lru->map_fd, &key, &node, BPF_NOEXIST));

samples/bpf/test_lru_dist.c

static void pfect_lru_init(struct pfect_lru *lru, unsigned int lru_size,

tools/testing/selftests/bpf/benchs/bench_xdp_lb.c

struct real_pos_lru lru = { .pos = real_idx };

tools/testing/selftests/bpf/benchs/bench_xdp_lb.c

lru.atime = ktime_get_ns();

tools/testing/selftests/bpf/benchs/bench_xdp_lb.c

err = bpf_map_update_elem(lru_inner_fds[i], &fk, &lru, BPF_ANY);

tools/testing/selftests/bpf/progs/timer.c

bpf_map_update_elem(&lru, &lru_key, &init, 0);

tools/testing/selftests/bpf/progs/timer.c

lru_timer = bpf_map_lookup_elem(&lru, &lru_key);

tools/testing/selftests/bpf/progs/timer.c

bpf_timer_init(lru_timer, &lru, CLOCK_MONOTONIC);

tools/testing/selftests/bpf/progs/timer.c

} lru SEC(".maps");

tools/testing/selftests/bpf/progs/timer.c

lru_timer = bpf_map_lookup_elem(&lru, &lru_key);

tools/testing/selftests/bpf/progs/wq.c

return test_elem_callback(&lru, &key, wq_callback);

tools/testing/selftests/bpf/progs/wq.c

} lru SEC(".maps");

tools/testing/selftests/bpf/progs/wq.c

if (map == &lru &&

tools/testing/selftests/bpf/progs/wq_failures.c

} lru SEC(".maps");

tools/testing/selftests/bpf/progs/wq_failures.c

if (bpf_wq_init(wq, &lru, 0) != 0)

tools/testing/shared/linux.c

void *kmem_cache_alloc_lru(struct kmem_cache *cachep, struct list_lru *lru,