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

Commit eee2a817 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable: (25 commits)
  Btrfs: forced readonly mounts on errors
  btrfs: Require CAP_SYS_ADMIN for filesystem rebalance
  Btrfs: don't warn if we get ENOSPC in btrfs_block_rsv_check
  btrfs: Fix memory leak in btrfs_read_fs_root_no_radix()
  btrfs: check NULL or not
  btrfs: Don't pass NULL ptr to func that may deref it.
  btrfs: mount failure return value fix
  btrfs: Mem leak in btrfs_get_acl()
  btrfs: fix wrong free space information of btrfs
  btrfs: make the chunk allocator utilize the devices better
  btrfs: restructure find_free_dev_extent()
  btrfs: fix wrong calculation of stripe size
  btrfs: try to reclaim some space when chunk allocation fails
  btrfs: fix wrong data space statistics
  fs/btrfs: Fix build of ctree
  Btrfs: fix off by one while setting block groups readonly
  Btrfs: Add BTRFS_IOC_SUBVOL_GETFLAGS/SETFLAGS ioctls
  Btrfs: Add readonly snapshots support
  Btrfs: Refactor btrfs_ioctl_snap_create()
  btrfs: Extract duplicate decompress code
  ...
parents 83896fb5 acce952b

fs/btrfs/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -4,6 +4,8 @@ config BTRFS_FS 
	select LIBCRC32C

	select ZLIB_INFLATE

	select ZLIB_DEFLATE

	select LZO_COMPRESS

	select LZO_DECOMPRESS

	help

	  Btrfs is a new filesystem with extents, writable snapshotting,

	  support for multiple devices and many more features.

fs/btrfs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -6,5 +6,5 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.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 \

	   export.o tree-log.o acl.o free-space-cache.o zlib.o \

	   export.o tree-log.o acl.o free-space-cache.o zlib.o lzo.o \

	   compression.o delayed-ref.o relocation.o

fs/btrfs/acl.c

+3 −1
Original line number Diff line number Diff line
@@ -60,8 +60,10 @@ static struct posix_acl *btrfs_get_acl(struct inode *inode, int type) 
		size = __btrfs_getxattr(inode, name, value, size);

		if (size > 0) {

			acl = posix_acl_from_xattr(value, size);

			if (IS_ERR(acl))

			if (IS_ERR(acl)) {

				kfree(value);

				return acl;

			}

			set_cached_acl(inode, type, acl);

		}

		kfree(value);

fs/btrfs/btrfs_inode.h

+1 −1
Original line number Diff line number Diff line
@@ -157,7 +157,7 @@ struct btrfs_inode { 
	/*

	 * always compress this one file

	 */

	unsigned force_compress:1;

	unsigned force_compress:4;



	struct inode vfs_inode;

};

fs/btrfs/compression.c

+324 −5
Original line number Diff line number Diff line
@@ -62,6 +62,9 @@ struct compressed_bio { 
	/* number of bytes on disk */

	unsigned long compressed_len;



	/* the compression algorithm for this bio */

	int compress_type;



	/* number of compressed pages in the array */

	unsigned long nr_pages;
@@ -173,7 +176,8 @@ static void end_compressed_bio_read(struct bio *bio, int err) 
	/* ok, we're the last bio for this extent, lets start

	 * the decompression.

	 */

	ret = btrfs_zlib_decompress_biovec(cb->compressed_pages,

	ret = btrfs_decompress_biovec(cb->compress_type,

				      cb->compressed_pages,

				      cb->start,

				      cb->orig_bio->bi_io_vec,

				      cb->orig_bio->bi_vcnt,
@@ -588,6 +592,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 


	cb->len = uncompressed_len;

	cb->compressed_len = compressed_len;

	cb->compress_type = extent_compress_type(bio_flags);

	cb->orig_bio = bio;



	nr_pages = (compressed_len + PAGE_CACHE_SIZE - 1) /
@@ -677,3 +682,317 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	bio_put(comp_bio);

	return 0;

}



static struct list_head comp_idle_workspace[BTRFS_COMPRESS_TYPES];

static spinlock_t comp_workspace_lock[BTRFS_COMPRESS_TYPES];

static int comp_num_workspace[BTRFS_COMPRESS_TYPES];

static atomic_t comp_alloc_workspace[BTRFS_COMPRESS_TYPES];

static wait_queue_head_t comp_workspace_wait[BTRFS_COMPRESS_TYPES];



struct btrfs_compress_op *btrfs_compress_op[] = {

	&btrfs_zlib_compress,

	&btrfs_lzo_compress,

};



int __init btrfs_init_compress(void)

{

	int i;



	for (i = 0; i < BTRFS_COMPRESS_TYPES; i++) {

		INIT_LIST_HEAD(&comp_idle_workspace[i]);

		spin_lock_init(&comp_workspace_lock[i]);

		atomic_set(&comp_alloc_workspace[i], 0);

		init_waitqueue_head(&comp_workspace_wait[i]);

	}

	return 0;

}



/*

 * this finds an available workspace or allocates a new one

 * ERR_PTR is returned if things go bad.

 */

static struct list_head *find_workspace(int type)

{

	struct list_head *workspace;

	int cpus = num_online_cpus();

	int idx = type - 1;



	struct list_head *idle_workspace	= &comp_idle_workspace[idx];

	spinlock_t *workspace_lock		= &comp_workspace_lock[idx];

	atomic_t *alloc_workspace		= &comp_alloc_workspace[idx];

	wait_queue_head_t *workspace_wait	= &comp_workspace_wait[idx];

	int *num_workspace			= &comp_num_workspace[idx];

again:

	spin_lock(workspace_lock);

	if (!list_empty(idle_workspace)) {

		workspace = idle_workspace->next;

		list_del(workspace);

		(*num_workspace)--;

		spin_unlock(workspace_lock);

		return workspace;



	}

	if (atomic_read(alloc_workspace) > cpus) {

		DEFINE_WAIT(wait);



		spin_unlock(workspace_lock);

		prepare_to_wait(workspace_wait, &wait, TASK_UNINTERRUPTIBLE);

		if (atomic_read(alloc_workspace) > cpus && !*num_workspace)

			schedule();

		finish_wait(workspace_wait, &wait);

		goto again;

	}

	atomic_inc(alloc_workspace);

	spin_unlock(workspace_lock);



	workspace = btrfs_compress_op[idx]->alloc_workspace();

	if (IS_ERR(workspace)) {

		atomic_dec(alloc_workspace);

		wake_up(workspace_wait);

	}

	return workspace;

}



/*

 * put a workspace struct back on the list or free it if we have enough

 * idle ones sitting around

 */

static void free_workspace(int type, struct list_head *workspace)

{

	int idx = type - 1;

	struct list_head *idle_workspace	= &comp_idle_workspace[idx];

	spinlock_t *workspace_lock		= &comp_workspace_lock[idx];

	atomic_t *alloc_workspace		= &comp_alloc_workspace[idx];

	wait_queue_head_t *workspace_wait	= &comp_workspace_wait[idx];

	int *num_workspace			= &comp_num_workspace[idx];



	spin_lock(workspace_lock);

	if (*num_workspace < num_online_cpus()) {

		list_add_tail(workspace, idle_workspace);

		(*num_workspace)++;

		spin_unlock(workspace_lock);

		goto wake;

	}

	spin_unlock(workspace_lock);



	btrfs_compress_op[idx]->free_workspace(workspace);

	atomic_dec(alloc_workspace);

wake:

	if (waitqueue_active(workspace_wait))

		wake_up(workspace_wait);

}



/*

 * cleanup function for module exit

 */

static void free_workspaces(void)

{

	struct list_head *workspace;

	int i;



	for (i = 0; i < BTRFS_COMPRESS_TYPES; i++) {

		while (!list_empty(&comp_idle_workspace[i])) {

			workspace = comp_idle_workspace[i].next;

			list_del(workspace);

			btrfs_compress_op[i]->free_workspace(workspace);

			atomic_dec(&comp_alloc_workspace[i]);

		}

	}

}



/*

 * given an address space and start/len, compress the bytes.

 *

 * pages are allocated to hold the compressed result and stored

 * in 'pages'

 *

 * out_pages is used to return the number of pages allocated.  There

 * may be pages allocated even if we return an error

 *

 * total_in is used to return the number of bytes actually read.  It

 * may be smaller then len if we had to exit early because we

 * ran out of room in the pages array or because we cross the

 * max_out threshold.

 *

 * total_out is used to return the total number of compressed bytes

 *

 * max_out tells us the max number of bytes that we're allowed to

 * stuff into pages

 */

int btrfs_compress_pages(int type, struct address_space *mapping,

			 u64 start, unsigned long len,

			 struct page **pages,

			 unsigned long nr_dest_pages,

			 unsigned long *out_pages,

			 unsigned long *total_in,

			 unsigned long *total_out,

			 unsigned long max_out)

{

	struct list_head *workspace;

	int ret;



	workspace = find_workspace(type);

	if (IS_ERR(workspace))

		return -1;



	ret = btrfs_compress_op[type-1]->compress_pages(workspace, mapping,

						      start, len, pages,

						      nr_dest_pages, out_pages,

						      total_in, total_out,

						      max_out);

	free_workspace(type, workspace);

	return ret;

}



/*

 * pages_in is an array of pages with compressed data.

 *

 * disk_start is the starting logical offset of this array in the file

 *

 * bvec is a bio_vec of pages from the file that we want to decompress into

 *

 * vcnt is the count of pages in the biovec

 *

 * srclen is the number of bytes in pages_in

 *

 * The basic idea is that we have a bio that was created by readpages.

 * The pages in the bio are for the uncompressed data, and they may not

 * be contiguous.  They all correspond to the range of bytes covered by

 * the compressed extent.

 */

int btrfs_decompress_biovec(int type, struct page **pages_in, u64 disk_start,

			    struct bio_vec *bvec, int vcnt, size_t srclen)

{

	struct list_head *workspace;

	int ret;



	workspace = find_workspace(type);

	if (IS_ERR(workspace))

		return -ENOMEM;



	ret = btrfs_compress_op[type-1]->decompress_biovec(workspace, pages_in,

							 disk_start,

							 bvec, vcnt, srclen);

	free_workspace(type, workspace);

	return ret;

}



/*

 * a less complex decompression routine.  Our compressed data fits in a

 * single page, and we want to read a single page out of it.

 * start_byte tells us the offset into the compressed data we're interested in

 */

int btrfs_decompress(int type, unsigned char *data_in, struct page *dest_page,

		     unsigned long start_byte, size_t srclen, size_t destlen)

{

	struct list_head *workspace;

	int ret;



	workspace = find_workspace(type);

	if (IS_ERR(workspace))

		return -ENOMEM;



	ret = btrfs_compress_op[type-1]->decompress(workspace, data_in,

						  dest_page, start_byte,

						  srclen, destlen);



	free_workspace(type, workspace);

	return ret;

}



void __exit btrfs_exit_compress(void)

{

	free_workspaces();

}



/*

 * Copy uncompressed data from working buffer to pages.

 *

 * buf_start is the byte offset we're of the start of our workspace buffer.

 *

 * total_out is the last byte of the buffer

 */

int btrfs_decompress_buf2page(char *buf, unsigned long buf_start,

			      unsigned long total_out, u64 disk_start,

			      struct bio_vec *bvec, int vcnt,

			      unsigned long *page_index,

			      unsigned long *pg_offset)

{

	unsigned long buf_offset;

	unsigned long current_buf_start;

	unsigned long start_byte;

	unsigned long working_bytes = total_out - buf_start;

	unsigned long bytes;

	char *kaddr;

	struct page *page_out = bvec[*page_index].bv_page;



	/*

	 * start byte is the first byte of the page we're currently

	 * copying into relative to the start of the compressed data.

	 */

	start_byte = page_offset(page_out) - disk_start;



	/* we haven't yet hit data corresponding to this page */

	if (total_out <= start_byte)

		return 1;



	/*

	 * the start of the data we care about is offset into

	 * the middle of our working buffer

	 */

	if (total_out > start_byte && buf_start < start_byte) {

		buf_offset = start_byte - buf_start;

		working_bytes -= buf_offset;

	} else {

		buf_offset = 0;

	}

	current_buf_start = buf_start;



	/* copy bytes from the working buffer into the pages */

	while (working_bytes > 0) {

		bytes = min(PAGE_CACHE_SIZE - *pg_offset,

			    PAGE_CACHE_SIZE - buf_offset);

		bytes = min(bytes, working_bytes);

		kaddr = kmap_atomic(page_out, KM_USER0);

		memcpy(kaddr + *pg_offset, buf + buf_offset, bytes);

		kunmap_atomic(kaddr, KM_USER0);

		flush_dcache_page(page_out);



		*pg_offset += bytes;

		buf_offset += bytes;

		working_bytes -= bytes;

		current_buf_start += bytes;



		/* check if we need to pick another page */

		if (*pg_offset == PAGE_CACHE_SIZE) {

			(*page_index)++;

			if (*page_index >= vcnt)

				return 0;



			page_out = bvec[*page_index].bv_page;

			*pg_offset = 0;

			start_byte = page_offset(page_out) - disk_start;



			/*

			 * make sure our new page is covered by this

			 * working buffer

			 */

			if (total_out <= start_byte)

				return 1;



			/*

			 * the next page in the biovec might not be adjacent

			 * to the last page, but it might still be found

			 * inside this working buffer. bump our offset pointer

			 */

			if (total_out > start_byte &&

			    current_buf_start < start_byte) {

				buf_offset = start_byte - buf_start;

				working_bytes = total_out - start_byte;

				current_buf_start = buf_start + buf_offset;

			}

		}

	}



	return 1;

}