Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d352ac68 authored by Chris Mason's avatar Chris Mason
Browse files

Btrfs: add and improve comments 



This improves the comments at the top of many functions.  It didn't
dive into the guts of functions because I was trying to
avoid merging problems with the new allocator and back reference work.

extent-tree.c and volumes.c were both skipped, and there is definitely
more work todo in cleaning and commenting the code.

Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent 9a5e1ea1

fs/btrfs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ ifneq ($(KERNELRELEASE),) 
obj-m  := btrfs.o

btrfs-y := super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \

	   file-item.o inode-item.o inode-map.o disk-io.o \

	   transaction.o bit-radix.o inode.o file.o tree-defrag.o \

	   transaction.o inode.o file.o tree-defrag.o \

	   extent_map.o sysfs.o struct-funcs.o xattr.o ordered-data.o \

	   extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \

	   ref-cache.o export.o tree-log.o acl.o free-space-cache.o

fs/btrfs/TODO

deleted100644 → 0
+0 −20
Original line number Diff line number Diff line 
* cleanup, add more error checking, get rid of BUG_ONs

* Fix ENOSPC handling

* Make allocator smarter

* add a block group to struct inode

* Do actual block accounting

* Check compat and incompat flags on the inode

* Get rid of struct ctree_path, limiting tree levels held at one time

* Add generation number to key pointer in nodes

* Add generation number to inode

* forbid cross subvolume renames and hardlinks

* Release

* Do real tree locking

* Add extent mirroring (backup copies of blocks)

* Add fancy interface to get access to incremental backups

* Add fancy striped extents to make big reads faster

* Use relocation to try and fix write errors

* Make allocator much smarter

* xattrs (directory streams for regular files)

* Scrub & defrag

fs/btrfs/async-thread.c

+9 −1
Original line number Diff line number Diff line
@@ -231,17 +231,25 @@ static struct btrfs_worker_thread *next_worker(struct btrfs_workers *workers) 


	/*

	 * if we pick a busy task, move the task to the end of the list.

	 * hopefully this will keep things somewhat evenly balanced

	 * hopefully this will keep things somewhat evenly balanced.

	 * Do the move in batches based on the sequence number.  This groups

	 * requests submitted at roughly the same time onto the same worker.

	 */

	next = workers->worker_list.next;

	worker = list_entry(next, struct btrfs_worker_thread, worker_list);

	atomic_inc(&worker->num_pending);

	worker->sequence++;



	if (worker->sequence % workers->idle_thresh == 0)

		list_move_tail(next, &workers->worker_list);

	return worker;

}



/*

 * selects a worker thread to take the next job.  This will either find

 * an idle worker, start a new worker up to the max count, or just return

 * one of the existing busy workers.

 */

static struct btrfs_worker_thread *find_worker(struct btrfs_workers *workers)

{

	struct btrfs_worker_thread *worker;

fs/btrfs/async-thread.h

+5 −2
Original line number Diff line number Diff line
@@ -63,14 +63,17 @@ struct btrfs_workers { 
	/* once a worker has this many requests or fewer, it is idle */

	int idle_thresh;



	/* list with all the work threads */

	/* list with all the work threads.  The workers on the idle thread

	 * may be actively servicing jobs, but they haven't yet hit the

	 * idle thresh limit above.

	 */

	struct list_head worker_list;

	struct list_head idle_list;



	/* lock for finding the next worker thread to queue on */

	spinlock_t lock;



	/* extra name for this worker */

	/* extra name for this worker, used for current->name */

	char *name;

};

fs/btrfs/bit-radix.c

deleted100644 → 0
+0 −130
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2007 Oracle.  All rights reserved.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public

 * License v2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public

 * License along with this program; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 021110-1307, USA.

 */



#include "bit-radix.h"



#define BIT_ARRAY_BYTES 256

#define BIT_RADIX_BITS_PER_ARRAY ((BIT_ARRAY_BYTES - sizeof(unsigned long)) * 8)



extern struct kmem_cache *btrfs_bit_radix_cachep;

int set_radix_bit(struct radix_tree_root *radix, unsigned long bit)

{

	unsigned long *bits;

	unsigned long slot;

	int bit_slot;

	int ret;



	slot = bit / BIT_RADIX_BITS_PER_ARRAY;

	bit_slot = bit % BIT_RADIX_BITS_PER_ARRAY;



	bits = radix_tree_lookup(radix, slot);

	if (!bits) {

		bits = kmem_cache_alloc(btrfs_bit_radix_cachep, GFP_NOFS);

		if (!bits)

			return -ENOMEM;

		memset(bits + 1, 0, BIT_ARRAY_BYTES - sizeof(unsigned long));

		bits[0] = slot;

		ret = radix_tree_insert(radix, slot, bits);

		if (ret)

			return ret;

	}

	ret = test_and_set_bit(bit_slot, bits + 1);

	if (ret < 0)

		ret = 1;

	return ret;

}



int test_radix_bit(struct radix_tree_root *radix, unsigned long bit)

{

	unsigned long *bits;

	unsigned long slot;

	int bit_slot;



	slot = bit / BIT_RADIX_BITS_PER_ARRAY;

	bit_slot = bit % BIT_RADIX_BITS_PER_ARRAY;



	bits = radix_tree_lookup(radix, slot);

	if (!bits)

		return 0;

	return test_bit(bit_slot, bits + 1);

}



int clear_radix_bit(struct radix_tree_root *radix, unsigned long bit)

{

	unsigned long *bits;

	unsigned long slot;

	int bit_slot;

	int i;

	int empty = 1;



	slot = bit / BIT_RADIX_BITS_PER_ARRAY;

	bit_slot = bit % BIT_RADIX_BITS_PER_ARRAY;



	bits = radix_tree_lookup(radix, slot);

	if (!bits)

		return 0;

	clear_bit(bit_slot, bits + 1);

	for (i = 1; i < BIT_ARRAY_BYTES / sizeof(unsigned long); i++) {

		if (bits[i]) {

			empty = 0;

			break;

		}

	}

	if (empty) {

		bits = radix_tree_delete(radix, slot);

		BUG_ON(!bits);

		kmem_cache_free(btrfs_bit_radix_cachep, bits);

	}

	return 0;

}



int find_first_radix_bit(struct radix_tree_root *radix, unsigned long *retbits,

			 unsigned long start, int nr)

{

	unsigned long *bits;

	unsigned long *gang[4];

	int found;

	int ret;

	int i;

	int total_found = 0;

	unsigned long slot;



	slot = start / BIT_RADIX_BITS_PER_ARRAY;

	ret = radix_tree_gang_lookup(radix, (void **)gang, slot,

				     ARRAY_SIZE(gang));

	found = start % BIT_RADIX_BITS_PER_ARRAY;

	for (i = 0; i < ret && nr > 0; i++) {

		bits = gang[i];

		while(nr > 0) {

			found = find_next_bit(bits + 1,

					      BIT_RADIX_BITS_PER_ARRAY,

					      found);

			if (found < BIT_RADIX_BITS_PER_ARRAY) {

				*retbits = bits[0] *

					BIT_RADIX_BITS_PER_ARRAY + found;

				retbits++;

				nr--;

				total_found++;

				found++;

			} else

				break;

		}

		found = 0;

	}

	return total_found;

}