Skip to content

Commit

Permalink
z3fold: add kref refcounting
Browse files Browse the repository at this point in the history 
With both coming and already present locking optimizations, introducing
kref to reference-count z3fold objects is the right thing to do.
Moreover, it makes buddied list no longer necessary, and allows for a
simpler handling of headless pages.

[[email protected]: coding-style fixes]
Link: http://lkml.kernel.org/r/[email protected]
Signed-off-by: Vitaly Wool <[email protected]>
Reviewed-by: Dan Streetman <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>
  • Loading branch information
@vwool @torvalds
vwool authored and torvalds committed Feb 25, 2017
1 parent 2f1e5e4 commit 5a27aa8
Showing 1 changed file with 69 additions and 86 deletions.
155 changes: 69 additions & 86 deletions mm/z3fold.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,7 @@ enum buddy {
* z3fold page, except for HEADLESS pages
* @buddy: links the z3fold page into the relevant list in the pool
* @page_lock: per-page lock
* @refcount: reference cound for the z3fold page
* @first_chunks: the size of the first buddy in chunks, 0 if free
* @middle_chunks: the size of the middle buddy in chunks, 0 if free
* @last_chunks: the size of the last buddy in chunks, 0 if free
Expand All @@ -60,6 +61,7 @@ enum buddy {
struct z3fold_header {
struct list_head buddy;
spinlock_t page_lock;
struct kref refcount;
unsigned short first_chunks;
unsigned short middle_chunks;
unsigned short last_chunks;
Expand Down Expand Up @@ -95,8 +97,6 @@ struct z3fold_header {
* @unbuddied: array of lists tracking z3fold pages that contain 2- buddies;
* the lists each z3fold page is added to depends on the size of
* its free region.
* @buddied: list tracking the z3fold pages that contain 3 buddies;
* these z3fold pages are full
* @lru: list tracking the z3fold pages in LRU order by most recently
* added buddy.
* @pages_nr: number of z3fold pages in the pool.
Expand All @@ -109,7 +109,6 @@ struct z3fold_header {
struct z3fold_pool {
spinlock_t lock;
struct list_head unbuddied[NCHUNKS];
struct list_head buddied;
struct list_head lru;
atomic64_t pages_nr;
const struct z3fold_ops *ops;
Expand All @@ -121,8 +120,7 @@ struct z3fold_pool {
* Internal z3fold page flags
*/
enum z3fold_page_flags {
UNDER_RECLAIM = 0,
PAGE_HEADLESS,
PAGE_HEADLESS = 0,
MIDDLE_CHUNK_MAPPED,
};

Expand All @@ -146,11 +144,11 @@ static struct z3fold_header *init_z3fold_page(struct page *page)
struct z3fold_header *zhdr = page_address(page);

INIT_LIST_HEAD(&page->lru);
clear_bit(UNDER_RECLAIM, &page->private);
clear_bit(PAGE_HEADLESS, &page->private);
clear_bit(MIDDLE_CHUNK_MAPPED, &page->private);

spin_lock_init(&zhdr->page_lock);
kref_init(&zhdr->refcount);
zhdr->first_chunks = 0;
zhdr->middle_chunks = 0;
zhdr->last_chunks = 0;
Expand All @@ -161,9 +159,24 @@ static struct z3fold_header *init_z3fold_page(struct page *page)
}

/* Resets the struct page fields and frees the page */
static void free_z3fold_page(struct z3fold_header *zhdr)
static void free_z3fold_page(struct page *page)
{
__free_page(virt_to_page(zhdr));
__free_page(page);
}

static void release_z3fold_page(struct kref *ref)
{
struct z3fold_header *zhdr;
struct page *page;

zhdr = container_of(ref, struct z3fold_header, refcount);
page = virt_to_page(zhdr);

if (!list_empty(&zhdr->buddy))
list_del(&zhdr->buddy);
if (!list_empty(&page->lru))
list_del(&page->lru);
free_z3fold_page(page);
}

/* Lock a z3fold page */
Expand All @@ -178,7 +191,6 @@ static inline void z3fold_page_unlock(struct z3fold_header *zhdr)
spin_unlock(&zhdr->page_lock);
}


/*
* Encodes the handle of a particular buddy within a z3fold page
* Pool lock should be held as this function accesses first_num
Expand Down Expand Up @@ -257,7 +269,6 @@ static struct z3fold_pool *z3fold_create_pool(gfp_t gfp,
spin_lock_init(&pool->lock);
for_each_unbuddied_list(i, 0)
INIT_LIST_HEAD(&pool->unbuddied[i]);
INIT_LIST_HEAD(&pool->buddied);
INIT_LIST_HEAD(&pool->lru);
atomic64_set(&pool->pages_nr, 0);
pool->ops = ops;
Expand Down Expand Up @@ -378,6 +389,7 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
spin_unlock(&pool->lock);
continue;
}
kref_get(&zhdr->refcount);
list_del_init(&zhdr->buddy);
spin_unlock(&pool->lock);

Expand All @@ -394,10 +406,12 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
else if (zhdr->middle_chunks == 0)
bud = MIDDLE;
else {
z3fold_page_unlock(zhdr);
spin_lock(&pool->lock);
list_add(&zhdr->buddy, &pool->buddied);
if (kref_put(&zhdr->refcount,
release_z3fold_page))
atomic64_dec(&pool->pages_nr);
spin_unlock(&pool->lock);
z3fold_page_unlock(zhdr);
pr_err("No free chunks in unbuddied\n");
WARN_ON(1);
continue;
Expand Down Expand Up @@ -438,9 +452,6 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
/* Add to unbuddied list */
freechunks = num_free_chunks(zhdr);
list_add(&zhdr->buddy, &pool->unbuddied[freechunks]);
} else {
/* Add to buddied list */
list_add(&zhdr->buddy, &pool->buddied);
}

headless:
Expand Down Expand Up @@ -504,52 +515,29 @@ static void z3fold_free(struct z3fold_pool *pool, unsigned long handle)
}
}

if (test_bit(UNDER_RECLAIM, &page->private)) {
/* z3fold page is under reclaim, reclaim will free */
if (bud != HEADLESS)
z3fold_page_unlock(zhdr);
return;
}

/* Remove from existing buddy list */
if (bud != HEADLESS) {
spin_lock(&pool->lock);
/*
* this object may have been removed from its list by
* z3fold_alloc(). In that case we just do nothing,
* z3fold_alloc() will allocate an object and add the page
* to the relevant list.
*/
if (!list_empty(&zhdr->buddy)) {
list_del(&zhdr->buddy);
} else {
spin_unlock(&pool->lock);
z3fold_page_unlock(zhdr);
return;
}
spin_unlock(&pool->lock);
}

if (bud == HEADLESS ||
(zhdr->first_chunks == 0 && zhdr->middle_chunks == 0 &&
zhdr->last_chunks == 0)) {
/* z3fold page is empty, free */
if (bud == HEADLESS) {
spin_lock(&pool->lock);
list_del(&page->lru);
spin_unlock(&pool->lock);
clear_bit(PAGE_HEADLESS, &page->private);
if (bud != HEADLESS)
z3fold_page_unlock(zhdr);
free_z3fold_page(zhdr);
free_z3fold_page(page);
atomic64_dec(&pool->pages_nr);
} else {
z3fold_compact_page(zhdr);
/* Add to the unbuddied list */
if (zhdr->first_chunks != 0 || zhdr->middle_chunks != 0 ||
zhdr->last_chunks != 0) {
z3fold_compact_page(zhdr);
/* Add to the unbuddied list */
spin_lock(&pool->lock);
if (!list_empty(&zhdr->buddy))
list_del(&zhdr->buddy);
freechunks = num_free_chunks(zhdr);
list_add(&zhdr->buddy, &pool->unbuddied[freechunks]);
spin_unlock(&pool->lock);
}
z3fold_page_unlock(zhdr);
spin_lock(&pool->lock);
freechunks = num_free_chunks(zhdr);
list_add(&zhdr->buddy, &pool->unbuddied[freechunks]);
if (kref_put(&zhdr->refcount, release_z3fold_page))
atomic64_dec(&pool->pages_nr);
spin_unlock(&pool->lock);
z3fold_page_unlock(zhdr);
}

}
Expand Down Expand Up @@ -608,13 +596,13 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries)
return -EINVAL;
}
page = list_last_entry(&pool->lru, struct page, lru);
list_del(&page->lru);
list_del_init(&page->lru);

/* Protect z3fold page against free */
set_bit(UNDER_RECLAIM, &page->private);
zhdr = page_address(page);
if (!test_bit(PAGE_HEADLESS, &page->private)) {
list_del(&zhdr->buddy);
if (!list_empty(&zhdr->buddy))
list_del_init(&zhdr->buddy);
kref_get(&zhdr->refcount);
spin_unlock(&pool->lock);
z3fold_page_lock(zhdr);
/*
Expand Down Expand Up @@ -655,30 +643,19 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries)
goto next;
}
next:
if (!test_bit(PAGE_HEADLESS, &page->private))
z3fold_page_lock(zhdr);
clear_bit(UNDER_RECLAIM, &page->private);
if ((test_bit(PAGE_HEADLESS, &page->private) && ret == 0) ||
(zhdr->first_chunks == 0 && zhdr->last_chunks == 0 &&
zhdr->middle_chunks == 0)) {
/*
* All buddies are now free, free the z3fold page and
* return success.
*/
if (!test_and_clear_bit(PAGE_HEADLESS, &page->private))
z3fold_page_unlock(zhdr);
free_z3fold_page(zhdr);
atomic64_dec(&pool->pages_nr);
return 0;
} else if (!test_bit(PAGE_HEADLESS, &page->private)) {
if (zhdr->first_chunks != 0 &&
zhdr->last_chunks != 0 &&
zhdr->middle_chunks != 0) {
/* Full, add to buddied list */
spin_lock(&pool->lock);
list_add(&zhdr->buddy, &pool->buddied);
spin_unlock(&pool->lock);
if (test_bit(PAGE_HEADLESS, &page->private)) {
if (ret == 0) {
free_z3fold_page(page);
return 0;
} else {
spin_lock(&pool->lock);
}
} else {
z3fold_page_lock(zhdr);
if ((zhdr->first_chunks || zhdr->last_chunks ||
zhdr->middle_chunks) &&
!(zhdr->first_chunks && zhdr->last_chunks &&
zhdr->middle_chunks)) {
z3fold_compact_page(zhdr);
/* add to unbuddied list */
spin_lock(&pool->lock);
Expand All @@ -687,13 +664,19 @@ static int z3fold_reclaim_page(struct z3fold_pool *pool, unsigned int retries)
&pool->unbuddied[freechunks]);
spin_unlock(&pool->lock);
}
}

if (!test_bit(PAGE_HEADLESS, &page->private))
z3fold_page_unlock(zhdr);
spin_lock(&pool->lock);
if (kref_put(&zhdr->refcount, release_z3fold_page)) {
atomic64_dec(&pool->pages_nr);
return 0;
}
}

spin_lock(&pool->lock);
/* add to beginning of LRU */
/*
* Add to the beginning of LRU.
* Pool lock has to be kept here to ensure the page has
* not already been released
*/
list_add(&page->lru, &pool->lru);
}
spin_unlock(&pool->lock);
Expand Down

0 comments on commit 5a27aa8

Please sign in to comment.