/*
   * fs/logfs/gc.c	- garbage collection code
   *
   * As should be obvious for Linux kernel code, license is GPLv2
   *
   * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
   */
  #include "logfs.h"
  #include <linux/sched.h>
  #include <linux/slab.h>
  
  /*
   * Wear leveling needs to kick in when the difference between low erase
   * counts and high erase counts gets too big.  A good value for "too big"
   * may be somewhat below 10% of maximum erase count for the device.
   * Why not 397, to pick a nice round number with no specific meaning? :)
   *
   * WL_RATELIMIT is the minimum time between two wear level events.  A huge
   * number of segments may fulfil the requirements for wear leveling at the
   * same time.  If that happens we don't want to cause a latency from hell,
   * but just gently pick one segment every so often and minimize overhead.
   */
  #define WL_DELTA 397
  #define WL_RATELIMIT 100
  #define MAX_OBJ_ALIASES	2600
  #define SCAN_RATIO 512	/* number of scanned segments per gc'd segment */
  #define LIST_SIZE 64	/* base size of candidate lists */
  #define SCAN_ROUNDS 128	/* maximum number of complete medium scans */
  #define SCAN_ROUNDS_HIGH 4 /* maximum number of higher-level scans */
  
  static int no_free_segments(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  
  	return super->s_free_list.count;
  }
  
  /* journal has distance -1, top-most ifile layer distance 0 */
  static u8 root_distance(struct super_block *sb, gc_level_t __gc_level)
  {
  	struct logfs_super *super = logfs_super(sb);
  	u8 gc_level = (__force u8)__gc_level;
  
  	switch (gc_level) {
  	case 0: /* fall through */
  	case 1: /* fall through */
  	case 2: /* fall through */
  	case 3:
  		/* file data or indirect blocks */
  		return super->s_ifile_levels + super->s_iblock_levels - gc_level;
  	case 6: /* fall through */
  	case 7: /* fall through */
  	case 8: /* fall through */
  	case 9:
  		/* inode file data or indirect blocks */
  		return super->s_ifile_levels - (gc_level - 6);
  	default:
  		printk(KERN_ERR"LOGFS: segment of unknown level %x found
  ",
  				gc_level);
  		WARN_ON(1);
  		return super->s_ifile_levels + super->s_iblock_levels;
  	}
  }
  
  static int segment_is_reserved(struct super_block *sb, u32 segno)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct logfs_area *area;
  	void *reserved;
  	int i;
  
  	/* Some segments are reserved.  Just pretend they were all valid */
  	reserved = btree_lookup32(&super->s_reserved_segments, segno);
  	if (reserved)
  		return 1;
  
  	/* Currently open segments */
  	for_each_area(i) {
  		area = super->s_area[i];
  		if (area->a_is_open && area->a_segno == segno)
  			return 1;
  	}
  
  	return 0;
  }
  
  static void logfs_mark_segment_bad(struct super_block *sb, u32 segno)
  {
  	BUG();
  }
  
  /*
   * Returns the bytes consumed by valid objects in this segment.  Object headers
   * are counted, the segment header is not.
   */
  static u32 logfs_valid_bytes(struct super_block *sb, u32 segno, u32 *ec,
  		gc_level_t *gc_level)
  {
  	struct logfs_segment_entry se;
  	u32 ec_level;
  
  	logfs_get_segment_entry(sb, segno, &se);
  	if (se.ec_level == cpu_to_be32(BADSEG) ||
  			se.valid == cpu_to_be32(RESERVED))
  		return RESERVED;
  
  	ec_level = be32_to_cpu(se.ec_level);
  	*ec = ec_level >> 4;
  	*gc_level = GC_LEVEL(ec_level & 0xf);
  	return be32_to_cpu(se.valid);
  }
  
  static void logfs_cleanse_block(struct super_block *sb, u64 ofs, u64 ino,
  		u64 bix, gc_level_t gc_level)
  {
  	struct inode *inode;
  	int err, cookie;
  
  	inode = logfs_safe_iget(sb, ino, &cookie);
  	err = logfs_rewrite_block(inode, bix, ofs, gc_level, 0);
  	BUG_ON(err);
  	logfs_safe_iput(inode, cookie);
  }
  
  static u32 logfs_gc_segment(struct super_block *sb, u32 segno)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct logfs_segment_header sh;
  	struct logfs_object_header oh;
  	u64 ofs, ino, bix;
  	u32 seg_ofs, logical_segno, cleaned = 0;
  	int err, len, valid;
  	gc_level_t gc_level;
  
  	LOGFS_BUG_ON(segment_is_reserved(sb, segno), sb);
  
  	btree_insert32(&super->s_reserved_segments, segno, (void *)1, GFP_NOFS);
  	err = wbuf_read(sb, dev_ofs(sb, segno, 0), sizeof(sh), &sh);
  	BUG_ON(err);
  	gc_level = GC_LEVEL(sh.level);
  	logical_segno = be32_to_cpu(sh.segno);
  	if (sh.crc != logfs_crc32(&sh, sizeof(sh), 4)) {
  		logfs_mark_segment_bad(sb, segno);
  		cleaned = -1;
  		goto out;
  	}
  
  	for (seg_ofs = LOGFS_SEGMENT_HEADERSIZE;
  			seg_ofs + sizeof(oh) < super->s_segsize; ) {
  		ofs = dev_ofs(sb, logical_segno, seg_ofs);
  		err = wbuf_read(sb, dev_ofs(sb, segno, seg_ofs), sizeof(oh),
  				&oh);
  		BUG_ON(err);
  
  		if (!memchr_inv(&oh, 0xff, sizeof(oh)))
  			break;
  
  		if (oh.crc != logfs_crc32(&oh, sizeof(oh) - 4, 4)) {
  			logfs_mark_segment_bad(sb, segno);
  			cleaned = super->s_segsize - 1;
  			goto out;
  		}
  
  		ino = be64_to_cpu(oh.ino);
  		bix = be64_to_cpu(oh.bix);
  		len = sizeof(oh) + be16_to_cpu(oh.len);
  		valid = logfs_is_valid_block(sb, ofs, ino, bix, gc_level);
  		if (valid == 1) {
  			logfs_cleanse_block(sb, ofs, ino, bix, gc_level);
  			cleaned += len;
  		} else if (valid == 2) {
  			/* Will be invalid upon journal commit */
  			cleaned += len;
  		}
  		seg_ofs += len;
  	}
  out:
  	btree_remove32(&super->s_reserved_segments, segno);
  	return cleaned;
  }
  
  static struct gc_candidate *add_list(struct gc_candidate *cand,
  		struct candidate_list *list)
  {
  	struct rb_node **p = &list->rb_tree.rb_node;
  	struct rb_node *parent = NULL;
  	struct gc_candidate *cur;
  	int comp;
  
  	cand->list = list;
  	while (*p) {
  		parent = *p;
  		cur = rb_entry(parent, struct gc_candidate, rb_node);
  
  		if (list->sort_by_ec)
  			comp = cand->erase_count < cur->erase_count;
  		else
  			comp = cand->valid < cur->valid;
  
  		if (comp)
  			p = &parent->rb_left;
  		else
  			p = &parent->rb_right;
  	}
  	rb_link_node(&cand->rb_node, parent, p);
  	rb_insert_color(&cand->rb_node, &list->rb_tree);
  
  	if (list->count <= list->maxcount) {
  		list->count++;
  		return NULL;
  	}
  	cand = rb_entry(rb_last(&list->rb_tree), struct gc_candidate, rb_node);
  	rb_erase(&cand->rb_node, &list->rb_tree);
  	cand->list = NULL;
  	return cand;
  }
  
  static void remove_from_list(struct gc_candidate *cand)
  {
  	struct candidate_list *list = cand->list;
  
  	rb_erase(&cand->rb_node, &list->rb_tree);
  	list->count--;
  }
  
  static void free_candidate(struct super_block *sb, struct gc_candidate *cand)
  {
  	struct logfs_super *super = logfs_super(sb);
  
  	btree_remove32(&super->s_cand_tree, cand->segno);
  	kfree(cand);
  }
  
  u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec)
  {
  	struct gc_candidate *cand;
  	u32 segno;
  
  	BUG_ON(list->count == 0);
  
  	cand = rb_entry(rb_first(&list->rb_tree), struct gc_candidate, rb_node);
  	remove_from_list(cand);
  	segno = cand->segno;
  	if (ec)
  		*ec = cand->erase_count;
  	free_candidate(sb, cand);
  	return segno;
  }
  
  /*
   * We have several lists to manage segments with.  The reserve_list is used to
   * deal with bad blocks.  We try to keep the best (lowest ec) segments on this
   * list.
   * The free_list contains free segments for normal usage.  It usually gets the
   * second pick after the reserve_list.  But when the free_list is running short
   * it is more important to keep the free_list full than to keep a reserve.
   *
   * Segments that are not free are put onto a per-level low_list.  If we have
   * to run garbage collection, we pick a candidate from there.  All segments on
   * those lists should have at least some free space so GC will make progress.
   *
   * And last we have the ec_list, which is used to pick segments for wear
   * leveling.
   *
   * If all appropriate lists are full, we simply free the candidate and forget
   * about that segment for a while.  We have better candidates for each purpose.
   */
  static void __add_candidate(struct super_block *sb, struct gc_candidate *cand)
  {
  	struct logfs_super *super = logfs_super(sb);
  	u32 full = super->s_segsize - LOGFS_SEGMENT_RESERVE;
  
  	if (cand->valid == 0) {
  		/* 100% free segments */
  		log_gc_noisy("add reserve segment %x (ec %x) at %llx
  ",
  				cand->segno, cand->erase_count,
  				dev_ofs(sb, cand->segno, 0));
  		cand = add_list(cand, &super->s_reserve_list);
  		if (cand) {
  			log_gc_noisy("add free segment %x (ec %x) at %llx
  ",
  					cand->segno, cand->erase_count,
  					dev_ofs(sb, cand->segno, 0));
  			cand = add_list(cand, &super->s_free_list);
  		}
  	} else {
  		/* good candidates for Garbage Collection */
  		if (cand->valid < full)
  			cand = add_list(cand, &super->s_low_list[cand->dist]);
  		/* good candidates for wear leveling,
  		 * segments that were recently written get ignored */
  		if (cand)
  			cand = add_list(cand, &super->s_ec_list);
  	}
  	if (cand)
  		free_candidate(sb, cand);
  }
  
  static int add_candidate(struct super_block *sb, u32 segno, u32 valid, u32 ec,
  		u8 dist)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct gc_candidate *cand;
  
  	cand = kmalloc(sizeof(*cand), GFP_NOFS);
  	if (!cand)
  		return -ENOMEM;
  
  	cand->segno = segno;
  	cand->valid = valid;
  	cand->erase_count = ec;
  	cand->dist = dist;
  
  	btree_insert32(&super->s_cand_tree, segno, cand, GFP_NOFS);
  	__add_candidate(sb, cand);
  	return 0;
  }
  
  static void remove_segment_from_lists(struct super_block *sb, u32 segno)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct gc_candidate *cand;
  
  	cand = btree_lookup32(&super->s_cand_tree, segno);
  	if (cand) {
  		remove_from_list(cand);
  		free_candidate(sb, cand);
  	}
  }
  
  static void scan_segment(struct super_block *sb, u32 segno)
  {
  	u32 valid, ec = 0;
  	gc_level_t gc_level = 0;
  	u8 dist;
  
  	if (segment_is_reserved(sb, segno))
  		return;
  
  	remove_segment_from_lists(sb, segno);
  	valid = logfs_valid_bytes(sb, segno, &ec, &gc_level);
  	if (valid == RESERVED)
  		return;
  
  	dist = root_distance(sb, gc_level);
  	add_candidate(sb, segno, valid, ec, dist);
  }
  
  static struct gc_candidate *first_in_list(struct candidate_list *list)
  {
  	if (list->count == 0)
  		return NULL;
  	return rb_entry(rb_first(&list->rb_tree), struct gc_candidate, rb_node);
  }
  
  /*
   * Find the best segment for garbage collection.  Main criterion is
   * the segment requiring the least effort to clean.  Secondary
   * criterion is to GC on the lowest level available.
   *
   * So we search the least effort segment on the lowest level first,
   * then move up and pick another segment iff is requires significantly
   * less effort.  Hence the LOGFS_MAX_OBJECTSIZE in the comparison.
   */
  static struct gc_candidate *get_candidate(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	int i, max_dist;
  	struct gc_candidate *cand = NULL, *this;
  
  	max_dist = min(no_free_segments(sb), LOGFS_NO_AREAS - 1);
  
  	for (i = max_dist; i >= 0; i--) {
  		this = first_in_list(&super->s_low_list[i]);
  		if (!this)
  			continue;
  		if (!cand)
  			cand = this;
  		if (this->valid + LOGFS_MAX_OBJECTSIZE <= cand->valid)
  			cand = this;
  	}
  	return cand;
  }
  
  static int __logfs_gc_once(struct super_block *sb, struct gc_candidate *cand)
  {
  	struct logfs_super *super = logfs_super(sb);
  	gc_level_t gc_level;
  	u32 cleaned, valid, segno, ec;
  	u8 dist;
  
  	if (!cand) {
  		log_gc("GC attempted, but no candidate found
  ");
  		return 0;
  	}
  
  	segno = cand->segno;
  	dist = cand->dist;
  	valid = logfs_valid_bytes(sb, segno, &ec, &gc_level);
  	free_candidate(sb, cand);
  	log_gc("GC segment #%02x at %llx, %x required, %x free, %x valid, %llx free
  ",
  			segno, (u64)segno << super->s_segshift,
  			dist, no_free_segments(sb), valid,
  			super->s_free_bytes);
  	cleaned = logfs_gc_segment(sb, segno);
  	log_gc("GC segment #%02x complete - now %x valid
  ", segno,
  			valid - cleaned);
  	BUG_ON(cleaned != valid);
  	return 1;
  }
  
  static int logfs_gc_once(struct super_block *sb)
  {
  	struct gc_candidate *cand;
  
  	cand = get_candidate(sb);
  	if (cand)
  		remove_from_list(cand);
  	return __logfs_gc_once(sb, cand);
  }
  
  /* returns 1 if a wrap occurs, 0 otherwise */
  static int logfs_scan_some(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	u32 segno;
  	int i, ret = 0;
  
  	segno = super->s_sweeper;
  	for (i = SCAN_RATIO; i > 0; i--) {
  		segno++;
  		if (segno >= super->s_no_segs) {
  			segno = 0;
  			ret = 1;
  			/* Break out of the loop.  We want to read a single
  			 * block from the segment size on next invocation if
  			 * SCAN_RATIO is set to match block size
  			 */
  			break;
  		}
  
  		scan_segment(sb, segno);
  	}
  	super->s_sweeper = segno;
  	return ret;
  }
  
  /*
   * In principle, this function should loop forever, looking for GC candidates
   * and moving data.  LogFS is designed in such a way that this loop is
   * guaranteed to terminate.
   *
   * Limiting the loop to some iterations serves purely to catch cases when
   * these guarantees have failed.  An actual endless loop is an obvious bug
   * and should be reported as such.
   */
  static void __logfs_gc_pass(struct super_block *sb, int target)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct logfs_block *block;
  	int round, progress, last_progress = 0;
  
  	/*
  	 * Doing too many changes to the segfile at once would result
  	 * in a large number of aliases.  Write the journal before
  	 * things get out of hand.
  	 */
  	if (super->s_shadow_tree.no_shadowed_segments >= MAX_OBJ_ALIASES)
  		logfs_write_anchor(sb);
  
  	if (no_free_segments(sb) >= target &&
  			super->s_no_object_aliases < MAX_OBJ_ALIASES)
  		return;
  
  	log_gc("__logfs_gc_pass(%x)
  ", target);
  	for (round = 0; round < SCAN_ROUNDS; ) {
  		if (no_free_segments(sb) >= target)
  			goto write_alias;
  
  		/* Sync in-memory state with on-medium state in case they
  		 * diverged */
  		logfs_write_anchor(sb);
  		round += logfs_scan_some(sb);
  		if (no_free_segments(sb) >= target)
  			goto write_alias;
  		progress = logfs_gc_once(sb);
  		if (progress)
  			last_progress = round;
  		else if (round - last_progress > 2)
  			break;
  		continue;
  
  		/*
  		 * The goto logic is nasty, I just don't know a better way to
  		 * code it.  GC is supposed to ensure two things:
  		 * 1. Enough free segments are available.
  		 * 2. The number of aliases is bounded.
  		 * When 1. is achieved, we take a look at 2. and write back
  		 * some alias-containing blocks, if necessary.  However, after
  		 * each such write we need to go back to 1., as writes can
  		 * consume free segments.
  		 */
  write_alias:
  		if (super->s_no_object_aliases < MAX_OBJ_ALIASES)
  			return;
  		if (list_empty(&super->s_object_alias)) {
  			/* All aliases are still in btree */
  			return;
  		}
  		log_gc("Write back one alias
  ");
  		block = list_entry(super->s_object_alias.next,
  				struct logfs_block, alias_list);
  		block->ops->write_block(block);
  		/*
  		 * To round off the nasty goto logic, we reset round here.  It
  		 * is a safety-net for GC not making any progress and limited
  		 * to something reasonably small.  If incremented it for every
  		 * single alias, the loop could terminate rather quickly.
  		 */
  		round = 0;
  	}
  	LOGFS_BUG(sb);
  }
  
  static int wl_ratelimit(struct super_block *sb, u64 *next_event)
  {
  	struct logfs_super *super = logfs_super(sb);
  
  	if (*next_event < super->s_gec) {
  		*next_event = super->s_gec + WL_RATELIMIT;
  		return 0;
  	}
  	return 1;
  }
  
  static void logfs_wl_pass(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct gc_candidate *wl_cand, *free_cand;
  
  	if (wl_ratelimit(sb, &super->s_wl_gec_ostore))
  		return;
  
  	wl_cand = first_in_list(&super->s_ec_list);
  	if (!wl_cand)
  		return;
  	free_cand = first_in_list(&super->s_free_list);
  	if (!free_cand)
  		return;
  
  	if (wl_cand->erase_count < free_cand->erase_count + WL_DELTA) {
  		remove_from_list(wl_cand);
  		__logfs_gc_once(sb, wl_cand);
  	}
  }
  
  /*
   * The journal needs wear leveling as well.  But moving the journal is an
   * expensive operation so we try to avoid it as much as possible.  And if we
   * have to do it, we move the whole journal, not individual segments.
   *
   * Ratelimiting is not strictly necessary here, it mainly serves to avoid the
   * calculations.  First we check whether moving the journal would be a
   * significant improvement.  That means that a) the current journal segments
   * have more wear than the future journal segments and b) the current journal
   * segments have more wear than normal ostore segments.
   * Rationale for b) is that we don't have to move the journal if it is aging
   * less than the ostore, even if the reserve segments age even less (they are
   * excluded from wear leveling, after all).
   * Next we check that the superblocks have less wear than the journal.  Since
   * moving the journal requires writing the superblocks, we have to protect the
   * superblocks even more than the journal.
   *
   * Also we double the acceptable wear difference, compared to ostore wear
   * leveling.  Journal data is read and rewritten rapidly, comparatively.  So
   * soft errors have much less time to accumulate and we allow the journal to
   * be a bit worse than the ostore.
   */
  static void logfs_journal_wl_pass(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct gc_candidate *cand;
  	u32 min_journal_ec = -1, max_reserve_ec = 0;
  	int i;
  
  	if (wl_ratelimit(sb, &super->s_wl_gec_journal))
  		return;
  
  	if (super->s_reserve_list.count < super->s_no_journal_segs) {
  		/* Reserve is not full enough to move complete journal */
  		return;
  	}
  
  	journal_for_each(i)
  		if (super->s_journal_seg[i])
  			min_journal_ec = min(min_journal_ec,
  					super->s_journal_ec[i]);
  	cand = rb_entry(rb_first(&super->s_free_list.rb_tree),
  			struct gc_candidate, rb_node);
  	max_reserve_ec = cand->erase_count;
  	for (i = 0; i < 2; i++) {
  		struct logfs_segment_entry se;
  		u32 segno = seg_no(sb, super->s_sb_ofs[i]);
  		u32 ec;
  
  		logfs_get_segment_entry(sb, segno, &se);
  		ec = be32_to_cpu(se.ec_level) >> 4;
  		max_reserve_ec = max(max_reserve_ec, ec);
  	}
  
  	if (min_journal_ec > max_reserve_ec + 2 * WL_DELTA) {
  		do_logfs_journal_wl_pass(sb);
  	}
  }
  
  void logfs_gc_pass(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  
  	//BUG_ON(mutex_trylock(&logfs_super(sb)->s_w_mutex));
  	/* Write journal before free space is getting saturated with dirty
  	 * objects.
  	 */
  	if (super->s_dirty_used_bytes + super->s_dirty_free_bytes
  			+ LOGFS_MAX_OBJECTSIZE >= super->s_free_bytes)
  		logfs_write_anchor(sb);
  	__logfs_gc_pass(sb, super->s_total_levels);
  	logfs_wl_pass(sb);
  	logfs_journal_wl_pass(sb);
  }
  
  static int check_area(struct super_block *sb, int i)
  {
  	struct logfs_super *super = logfs_super(sb);
  	struct logfs_area *area = super->s_area[i];
  	gc_level_t gc_level;
  	u32 cleaned, valid, ec;
  	u32 segno = area->a_segno;
  	u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
  
  	if (!area->a_is_open)
  		return 0;
  
  	if (super->s_devops->can_write_buf(sb, ofs) == 0)
  		return 0;
  
  	printk(KERN_INFO"LogFS: Possibly incomplete write at %llx
  ", ofs);
  	/*
  	 * The device cannot write back the write buffer.  Most likely the
  	 * wbuf was already written out and the system crashed at some point
  	 * before the journal commit happened.  In that case we wouldn't have
  	 * to do anything.  But if the crash happened before the wbuf was
  	 * written out correctly, we must GC this segment.  So assume the
  	 * worst and always do the GC run.
  	 */
  	area->a_is_open = 0;
  	valid = logfs_valid_bytes(sb, segno, &ec, &gc_level);
  	cleaned = logfs_gc_segment(sb, segno);
  	if (cleaned != valid)
  		return -EIO;
  	return 0;
  }
  
  int logfs_check_areas(struct super_block *sb)
  {
  	int i, err;
  
  	for_each_area(i) {
  		err = check_area(sb, i);
  		if (err)
  			return err;
  	}
  	return 0;
  }
  
  static void logfs_init_candlist(struct candidate_list *list, int maxcount,
  		int sort_by_ec)
  {
  	list->count = 0;
  	list->maxcount = maxcount;
  	list->sort_by_ec = sort_by_ec;
  	list->rb_tree = RB_ROOT;
  }
  
  int logfs_init_gc(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	int i;
  
  	btree_init_mempool32(&super->s_cand_tree, super->s_btree_pool);
  	logfs_init_candlist(&super->s_free_list, LIST_SIZE + SCAN_RATIO, 1);
  	logfs_init_candlist(&super->s_reserve_list,
  			super->s_bad_seg_reserve, 1);
  	for_each_area(i)
  		logfs_init_candlist(&super->s_low_list[i], LIST_SIZE, 0);
  	logfs_init_candlist(&super->s_ec_list, LIST_SIZE, 1);
  	return 0;
  }
  
  static void logfs_cleanup_list(struct super_block *sb,
  		struct candidate_list *list)
  {
  	struct gc_candidate *cand;
  
  	while (list->count) {
  		cand = rb_entry(list->rb_tree.rb_node, struct gc_candidate,
  				rb_node);
  		remove_from_list(cand);
  		free_candidate(sb, cand);
  	}
  	BUG_ON(list->rb_tree.rb_node);
  }
  
  void logfs_cleanup_gc(struct super_block *sb)
  {
  	struct logfs_super *super = logfs_super(sb);
  	int i;
  
  	if (!super->s_free_list.count)
  		return;
  
  	/*
  	 * FIXME: The btree may still contain a single empty node.  So we
  	 * call the grim visitor to clean up that mess.  Btree code should
  	 * do it for us, really.
  	 */
  	btree_grim_visitor32(&super->s_cand_tree, 0, NULL);
  	logfs_cleanup_list(sb, &super->s_free_list);
  	logfs_cleanup_list(sb, &super->s_reserve_list);
  	for_each_area(i)
  		logfs_cleanup_list(sb, &super->s_low_list[i]);
  	logfs_cleanup_list(sb, &super->s_ec_list);
  }