drm2/ttm/ttm_page_alloc.c

35 /* simple list based uncached page pool
58  * @lock: Protects the shared pool from concurrnet access. Must be used with
59  * irqsave/irqrestore variants because pool allocator maybe called from
64  * @npages: Number of pages in pool.
79  * Limits for the pool. They are handled without locks because only place where
95  * Manager is read only object for pool code so it doesn't need locking.
97  * @free_interval: minimum number of jiffies between freeing pages from pool.
98  * @page_alloc_inited: reference counting for pool allocation.
99  * @work: Work that is used to shrink the pool. Work is only run when there is
103  * @pools: All pool objects in use.
308  * Select the right pool or requested caching state and ttm flags. */
340 static void ttm_pool_update_free_locked(struct ttm_page_pool *pool,
343 	pool->npages -= freed_pages;
344 	pool->nfrees += freed_pages;
348  * Free pages from pool.
353  * @pool: to free the pages from
354  * @free_all: If set to true will free all pages in pool
356 static int ttm_page_pool_free(struct ttm_page_pool *pool, unsigned nr_free)
371 	mtx_lock(&pool->lock);
373 	TAILQ_FOREACH_REVERSE_SAFE(p, &pool->list, pglist, plinks.q, p1) {
380 			/* remove range of pages from the pool */
382 				TAILQ_REMOVE(&pool->list, pages_to_free[i], plinks.q);
384 			ttm_pool_update_free_locked(pool, freed_pages);
387 			 * we unlock the pool to prevent stalling.
389 			mtx_unlock(&pool->lock);
415 	/* remove range of pages from the pool */
418 			TAILQ_REMOVE(&pool->list, pages_to_free[i], plinks.q);
420 		ttm_pool_update_free_locked(pool, freed_pages);
424 	mtx_unlock(&pool->lock);
445  * Callback for mm to request pool to reduce number of page held.
452 	struct ttm_page_pool *pool;
456 	/* select start pool in round robin fashion */
461 		pool = &_manager->pools[(i + pool_offset)%NUM_POOLS];
462 		shrink_pages = ttm_page_pool_free(pool, nr_free);
464 	/* return estimated number of unused pages in pool */
506  * pool.
545 			/* store already allocated pages in the pool after
598  * Fill the given pool if there aren't enough pages and the requested number of
601 static void ttm_page_pool_fill_locked(struct ttm_page_pool *pool,
608 	 * Only allow one pool fill operation at a time.
609 	 * If pool doesn't have enough pages for the allocation new pages are
610 	 * allocated from outside of pool.
612 	if (pool->fill_lock)
615 	pool->fill_lock = true;
618 	 * pages in a pool we fill the pool up first. */
620 		&& count > pool->npages) {
626 		 * drop the pool->lock.
628 		mtx_unlock(&pool->lock);
631 		r = ttm_alloc_new_pages(&new_pages, pool->ttm_page_alloc_flags,
633 		mtx_lock(&pool->lock);
636 			TAILQ_CONCAT(&pool->list, &new_pages, plinks.q);
637 			++pool->nrefills;
638 			pool->npages += alloc_size;
640 			printf("[TTM] Failed to fill pool (%p)\n", pool);
641 			/* If we have any pages left put them to the pool. */
642 			TAILQ_FOREACH(p, &pool->list, plinks.q) {
645 			TAILQ_CONCAT(&pool->list, &new_pages, plinks.q);
646 			pool->npages += cpages;
650 	pool->fill_lock = false;
654  * Cut 'count' number of pages from the pool and put them on the return list.
658 static unsigned ttm_page_pool_get_pages(struct ttm_page_pool *pool,
667 	mtx_lock(&pool->lock);
668 	ttm_page_pool_fill_locked(pool, ttm_flags, cstate, count);
670 	if (count >= pool->npages) {
671 		/* take all pages from the pool */
672 		TAILQ_CONCAT(pages, &pool->list, plinks.q);
673 		count -= pool->npages;
674 		pool->npages = 0;
678 		p = TAILQ_FIRST(&pool->list);
679 		TAILQ_REMOVE(&pool->list, p, plinks.q);
682 	pool->npages -= count;
685 	mtx_unlock(&pool->lock);
689 /* Put all pages in pages list to correct pool to wait for reuse */
693 	struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
696 	if (pool == NULL) {
697 		/* No pool for this memory type so free the pages */
707 	mtx_lock(&pool->lock);
710 			TAILQ_INSERT_TAIL(&pool->list, pages[i], plinks.q);
712 			pool->npages++;
715 	/* Check that we don't go over the pool limit */
717 	if (pool->npages > _manager->options.max_size) {
718 		npages = pool->npages - _manager->options.max_size;
724 	mtx_unlock(&pool->lock);
726 		ttm_page_pool_free(pool, npages);
736 	struct ttm_page_pool *pool = ttm_get_pool(flags, cstate);
743 	/* No pool for cached pages */
744 	if (pool == NULL) {
756 	/* combine zero flag to pool flags */
757 	gfp_flags = flags | pool->ttm_page_alloc_flags;
759 	/* First we take pages from the pool */
761 	npages = ttm_page_pool_get_pages(pool, &plist, flags, cstate, npages);
767 	/* clear the pages coming from the pool if requested */
774 	/* If pool didn't have enough pages allocate new one. */
776 		/* ttm_alloc_new_pages doesn't reference pool so we can run
787 			 * the pool. */
797 static void ttm_page_pool_init_locked(struct ttm_page_pool *pool, int flags,
800 	mtx_init(&pool->lock, "ttmpool", NULL, MTX_DEF);
801 	pool->fill_lock = false;
802 	TAILQ_INIT(&pool->list);
803 	pool->npages = pool->nfrees = 0;
804 	pool->ttm_page_alloc_flags = flags;
805 	pool->name = name;
813 	printf("[TTM] Initializing pool allocator\n");
838 	printf("[TTM] Finalizing pool allocator\n");
909 	char *h[] = {"pool", "refills", "pages freed", "size"};
911 		seq_printf(m, "No pool allocator running.\n");