dm bufio: add LRU abstraction (be845bab) · Commits · EulixOS / Software / Kernel

drivers/md/dm-bufio.c

+235 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,241 @@
		#define LIST_DIRTY 1
		#define LIST_SIZE 2

		/--------------------------------------------------------------/

		/*
		* Rather than use an LRU list, we use a clock algorithm where entries
		* are held in a circular list. When an entry is 'hit' a reference bit
		* is set. The least recently used entry is approximated by running a
		* cursor around the list selecting unreferenced entries. Referenced
		* entries have their reference bit cleared as the cursor passes them.
		*/
		struct lru_entry {
		struct list_head list;
		atomic_t referenced;
		};

		struct lru_iter {
		struct lru *lru;
		struct list_head list;
		struct lru_entry *stop;
		struct lru_entry *e;
		};

		struct lru {
		struct list_head *cursor;
		unsigned long count;

		struct list_head iterators;
		};

		/--------------/

		static void lru_init(struct lru *lru)
		{
		lru->cursor = NULL;
		lru->count = 0;
		INIT_LIST_HEAD(&lru->iterators);
		}

		static void lru_destroy(struct lru *lru)
		{
		WARN_ON_ONCE(lru->cursor);
		WARN_ON_ONCE(!list_empty(&lru->iterators));
		}

		/*
		* Insert a new entry into the lru.
		*/
		static void lru_insert(struct lru lru, struct lru_entry le)
		{
		/*
		* Don't be tempted to set to 1, makes the lru aspect
		* perform poorly.
		*/
		atomic_set(&le->referenced, 0);

		if (lru->cursor) {
		list_add_tail(&le->list, lru->cursor);
		} else {
		INIT_LIST_HEAD(&le->list);
		lru->cursor = &le->list;
		}
		lru->count++;
		}

		/--------------/

		/*
		* Convert a list_head pointer to an lru_entry pointer.
		*/
		static inline struct lru_entry to_le(struct list_head l)
		{
		return container_of(l, struct lru_entry, list);
		}

		/*
		* Initialize an lru_iter and add it to the list of cursors in the lru.
		*/
		static void lru_iter_begin(struct lru lru, struct lru_iter it)
		{
		it->lru = lru;
		it->stop = lru->cursor ? to_le(lru->cursor->prev) : NULL;
		it->e = lru->cursor ? to_le(lru->cursor) : NULL;
		list_add(&it->list, &lru->iterators);
		}

		/*
		* Remove an lru_iter from the list of cursors in the lru.
		*/
		static inline void lru_iter_end(struct lru_iter *it)
		{
		list_del(&it->list);
		}

		/* Predicate function type to be used with lru_iter_next */
		typedef bool (iter_predicate)(struct lru_entry le, void *context);

		/*
		* Advance the cursor to the next entry that passes the
		* predicate, and return that entry. Returns NULL if the
		* iteration is complete.
		*/
		static struct lru_entry lru_iter_next(struct lru_iter it,
		iter_predicate pred, void *context)
		{
		struct lru_entry *e;

		while (it->e) {
		e = it->e;

		/* advance the cursor */
		if (it->e == it->stop)
		it->e = NULL;
		else
		it->e = to_le(it->e->list.next);

		if (pred(e, context))
		return e;
		}

		return NULL;
		}

		/*
		* Invalidate a specific lru_entry and update all cursors in
		* the lru accordingly.
		*/
		static void lru_iter_invalidate(struct lru lru, struct lru_entry e)
		{
		struct lru_iter *it;

		list_for_each_entry(it, &lru->iterators, list) {
		/* Move c->e forwards if necc. */
		if (it->e == e) {
		it->e = to_le(it->e->list.next);
		if (it->e == e)
		it->e = NULL;
		}

		/* Move it->stop backwards if necc. */
		if (it->stop == e) {
		it->stop = to_le(it->stop->list.prev);
		if (it->stop == e)
		it->stop = NULL;
		}
		}
		}

		/--------------/

		/*
		* Remove a specific entry from the lru.
		*/
		static void lru_remove(struct lru lru, struct lru_entry le)
		{
		lru_iter_invalidate(lru, le);
		if (lru->count == 1) {
		lru->cursor = NULL;
		} else {
		if (lru->cursor == &le->list)
		lru->cursor = lru->cursor->next;
		list_del(&le->list);
		}
		lru->count--;
		}

		/*
		* Mark as referenced.
		*/
		static inline void lru_reference(struct lru_entry *le)
		{
		atomic_set(&le->referenced, 1);
		}

		/--------------/

		/*
		* Remove the least recently used entry (approx), that passes the predicate.
		* Returns NULL on failure.
		*/
		enum evict_result {
		ER_EVICT,
		ER_DONT_EVICT,
		ER_STOP, /* stop looking for something to evict */
		};

		typedef enum evict_result (le_predicate)(struct lru_entry le, void *context);

		static struct lru_entry lru_evict(struct lru lru, le_predicate pred, void *context)
		{
		unsigned long tested = 0;
		struct list_head *h = lru->cursor;
		struct lru_entry *le;

		if (!h)
		return NULL;
		/*
		* In the worst case we have to loop around twice. Once to clear
		* the reference flags, and then again to discover the predicate
		* fails for all entries.
		*/
		while (tested < lru->count) {
		le = container_of(h, struct lru_entry, list);

		if (atomic_read(&le->referenced)) {
		atomic_set(&le->referenced, 0);
		} else {
		tested++;
		switch (pred(le, context)) {
		case ER_EVICT:
		/*
		* Adjust the cursor, so we start the next
		* search from here.
		*/
		lru->cursor = le->list.next;
		lru_remove(lru, le);
		return le;

		case ER_DONT_EVICT:
		break;

		case ER_STOP:
		lru->cursor = le->list.next;
		return NULL;
		}
		}

		h = h->next;

		cond_resched();
		}

		return NULL;
		}

		/--------------------------------------------------------------/

		/*
		* Linking of buffers:
		* All buffers are linked to buffer_tree with their node field.