1038 lines · 26.7 KB · C
RawDownload
/* * Copyright (C) 2008 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 <linux/kernel.h>#include <linux/bio.h>#include <linux/buffer_head.h>#include <linux/file.h>#include <linux/fs.h>#include <linux/pagemap.h>#include <linux/highmem.h>#include <linux/time.h>#include <linux/init.h>#include <linux/string.h>#include <linux/backing-dev.h>#include <linux/mpage.h>#include <linux/swap.h>#include <linux/writeback.h>#include <linux/bit_spinlock.h>#include <linux/slab.h>#include "compat.h"#include "ctree.h"#include "disk-io.h"#include "transaction.h"#include "btrfs_inode.h"#include "volumes.h"#include "ordered-data.h"#include "compression.h"#include "extent_io.h"#include "extent_map.h" struct compressed_bio {	/* number of bios pending for this compressed extent */	atomic_t pending_bios; 	/* the pages with the compressed data on them */	struct page **compressed_pages; 	/* inode that owns this data */	struct inode *inode; 	/* starting offset in the inode for our pages */	u64 start; 	/* number of bytes in the inode we're working on */	unsigned long len; 	/* 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; 	/* IO errors */	int errors;	int mirror_num; 	/* for reads, this is the bio we are copying the data into */	struct bio *orig_bio; 	/*	 * the start of a variable length array of checksums only	 * used by reads	 */	u32 sums;}; static inline int compressed_bio_size(struct btrfs_root *root,				      unsigned long disk_size){	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); 	return sizeof(struct compressed_bio) +		((disk_size + root->sectorsize - 1) / root->sectorsize) *		csum_size;} static struct bio *compressed_bio_alloc(struct block_device *bdev,					u64 first_byte, gfp_t gfp_flags){	int nr_vecs; 	nr_vecs = bio_get_nr_vecs(bdev);	return btrfs_bio_alloc(bdev, first_byte >> 9, nr_vecs, gfp_flags);} static int check_compressed_csum(struct inode *inode,				 struct compressed_bio *cb,				 u64 disk_start){	int ret;	struct btrfs_root *root = BTRFS_I(inode)->root;	struct page *page;	unsigned long i;	char *kaddr;	u32 csum;	u32 *cb_sum = &cb->sums; 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)		return 0; 	for (i = 0; i < cb->nr_pages; i++) {		page = cb->compressed_pages[i];		csum = ~(u32)0; 		kaddr = kmap_atomic(page);		csum = btrfs_csum_data(root, kaddr, csum, PAGE_CACHE_SIZE);		btrfs_csum_final(csum, (char *)&csum);		kunmap_atomic(kaddr); 		if (csum != *cb_sum) {			printk(KERN_INFO "btrfs csum failed ino %llu "			       "extent %llu csum %u "			       "wanted %u mirror %d\n",			       (unsigned long long)btrfs_ino(inode),			       (unsigned long long)disk_start,			       csum, *cb_sum, cb->mirror_num);			ret = -EIO;			goto fail;		}		cb_sum++; 	}	ret = 0;fail:	return ret;} /* when we finish reading compressed pages from the disk, we * decompress them and then run the bio end_io routines on the * decompressed pages (in the inode address space). * * This allows the checksumming and other IO error handling routines * to work normally * * The compressed pages are freed here, and it must be run * in process context */static void end_compressed_bio_read(struct bio *bio, int err){	struct compressed_bio *cb = bio->bi_private;	struct inode *inode;	struct page *page;	unsigned long index;	int ret; 	if (err)		cb->errors = 1; 	/* if there are more bios still pending for this compressed	 * extent, just exit	 */	if (!atomic_dec_and_test(&cb->pending_bios))		goto out; 	inode = cb->inode;	ret = check_compressed_csum(inode, cb, (u64)bio->bi_sector << 9);	if (ret)		goto csum_failed; 	/* ok, we're the last bio for this extent, lets start	 * the decompression.	 */	ret = btrfs_decompress_biovec(cb->compress_type,				      cb->compressed_pages,				      cb->start,				      cb->orig_bio->bi_io_vec,				      cb->orig_bio->bi_vcnt,				      cb->compressed_len);csum_failed:	if (ret)		cb->errors = 1; 	/* release the compressed pages */	index = 0;	for (index = 0; index < cb->nr_pages; index++) {		page = cb->compressed_pages[index];		page->mapping = NULL;		page_cache_release(page);	} 	/* do io completion on the original bio */	if (cb->errors) {		bio_io_error(cb->orig_bio);	} else {		int bio_index = 0;		struct bio_vec *bvec = cb->orig_bio->bi_io_vec; 		/*		 * we have verified the checksum already, set page		 * checked so the end_io handlers know about it		 */		while (bio_index < cb->orig_bio->bi_vcnt) {			SetPageChecked(bvec->bv_page);			bvec++;			bio_index++;		}		bio_endio(cb->orig_bio, 0);	} 	/* finally free the cb struct */	kfree(cb->compressed_pages);	kfree(cb);out:	bio_put(bio);} /* * Clear the writeback bits on all of the file * pages for a compressed write */static noinline void end_compressed_writeback(struct inode *inode, u64 start,					      unsigned long ram_size){	unsigned long index = start >> PAGE_CACHE_SHIFT;	unsigned long end_index = (start + ram_size - 1) >> PAGE_CACHE_SHIFT;	struct page *pages[16];	unsigned long nr_pages = end_index - index + 1;	int i;	int ret; 	while (nr_pages > 0) {		ret = find_get_pages_contig(inode->i_mapping, index,				     min_t(unsigned long,				     nr_pages, ARRAY_SIZE(pages)), pages);		if (ret == 0) {			nr_pages -= 1;			index += 1;			continue;		}		for (i = 0; i < ret; i++) {			end_page_writeback(pages[i]);			page_cache_release(pages[i]);		}		nr_pages -= ret;		index += ret;	}	/* the inode may be gone now */} /* * do the cleanup once all the compressed pages hit the disk. * This will clear writeback on the file pages and free the compressed * pages. * * This also calls the writeback end hooks for the file pages so that * metadata and checksums can be updated in the file. */static void end_compressed_bio_write(struct bio *bio, int err){	struct extent_io_tree *tree;	struct compressed_bio *cb = bio->bi_private;	struct inode *inode;	struct page *page;	unsigned long index; 	if (err)		cb->errors = 1; 	/* if there are more bios still pending for this compressed	 * extent, just exit	 */	if (!atomic_dec_and_test(&cb->pending_bios))		goto out; 	/* ok, we're the last bio for this extent, step one is to	 * call back into the FS and do all the end_io operations	 */	inode = cb->inode;	tree = &BTRFS_I(inode)->io_tree;	cb->compressed_pages[0]->mapping = cb->inode->i_mapping;	tree->ops->writepage_end_io_hook(cb->compressed_pages[0],					 cb->start,					 cb->start + cb->len - 1,					 NULL, 1);	cb->compressed_pages[0]->mapping = NULL; 	end_compressed_writeback(inode, cb->start, cb->len);	/* note, our inode could be gone now */ 	/*	 * release the compressed pages, these came from alloc_page and	 * are not attached to the inode at all	 */	index = 0;	for (index = 0; index < cb->nr_pages; index++) {		page = cb->compressed_pages[index];		page->mapping = NULL;		page_cache_release(page);	} 	/* finally free the cb struct */	kfree(cb->compressed_pages);	kfree(cb);out:	bio_put(bio);} /* * worker function to build and submit bios for previously compressed pages. * The corresponding pages in the inode should be marked for writeback * and the compressed pages should have a reference on them for dropping * when the IO is complete. * * This also checksums the file bytes and gets things ready for * the end io hooks. */int btrfs_submit_compressed_write(struct inode *inode, u64 start,				 unsigned long len, u64 disk_start,				 unsigned long compressed_len,				 struct page **compressed_pages,				 unsigned long nr_pages){	struct bio *bio = NULL;	struct btrfs_root *root = BTRFS_I(inode)->root;	struct compressed_bio *cb;	unsigned long bytes_left;	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;	int pg_index = 0;	struct page *page;	u64 first_byte = disk_start;	struct block_device *bdev;	int ret;	int skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; 	WARN_ON(start & ((u64)PAGE_CACHE_SIZE - 1));	cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);	if (!cb)		return -ENOMEM;	atomic_set(&cb->pending_bios, 0);	cb->errors = 0;	cb->inode = inode;	cb->start = start;	cb->len = len;	cb->mirror_num = 0;	cb->compressed_pages = compressed_pages;	cb->compressed_len = compressed_len;	cb->orig_bio = NULL;	cb->nr_pages = nr_pages; 	bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev; 	bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);	if(!bio) {		kfree(cb);		return -ENOMEM;	}	bio->bi_private = cb;	bio->bi_end_io = end_compressed_bio_write;	atomic_inc(&cb->pending_bios); 	/* create and submit bios for the compressed pages */	bytes_left = compressed_len;	for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {		page = compressed_pages[pg_index];		page->mapping = inode->i_mapping;		if (bio->bi_size)			ret = io_tree->ops->merge_bio_hook(page, 0,							   PAGE_CACHE_SIZE,							   bio, 0);		else			ret = 0; 		page->mapping = NULL;		if (ret || bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) <		    PAGE_CACHE_SIZE) {			bio_get(bio); 			/*			 * inc the count before we submit the bio so			 * we know the end IO handler won't happen before			 * we inc the count.  Otherwise, the cb might get			 * freed before we're done setting it up			 */			atomic_inc(&cb->pending_bios);			ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);			BUG_ON(ret); /* -ENOMEM */ 			if (!skip_sum) {				ret = btrfs_csum_one_bio(root, inode, bio,							 start, 1);				BUG_ON(ret); /* -ENOMEM */			} 			ret = btrfs_map_bio(root, WRITE, bio, 0, 1);			BUG_ON(ret); /* -ENOMEM */ 			bio_put(bio); 			bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);			BUG_ON(!bio);			bio->bi_private = cb;			bio->bi_end_io = end_compressed_bio_write;			bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);		}		if (bytes_left < PAGE_CACHE_SIZE) {			printk("bytes left %lu compress len %lu nr %lu\n",			       bytes_left, cb->compressed_len, cb->nr_pages);		}		bytes_left -= PAGE_CACHE_SIZE;		first_byte += PAGE_CACHE_SIZE;		cond_resched();	}	bio_get(bio); 	ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);	BUG_ON(ret); /* -ENOMEM */ 	if (!skip_sum) {		ret = btrfs_csum_one_bio(root, inode, bio, start, 1);		BUG_ON(ret); /* -ENOMEM */	} 	ret = btrfs_map_bio(root, WRITE, bio, 0, 1);	BUG_ON(ret); /* -ENOMEM */ 	bio_put(bio);	return 0;} static noinline int add_ra_bio_pages(struct inode *inode,				     u64 compressed_end,				     struct compressed_bio *cb){	unsigned long end_index;	unsigned long pg_index;	u64 last_offset;	u64 isize = i_size_read(inode);	int ret;	struct page *page;	unsigned long nr_pages = 0;	struct extent_map *em;	struct address_space *mapping = inode->i_mapping;	struct extent_map_tree *em_tree;	struct extent_io_tree *tree;	u64 end;	int misses = 0; 	page = cb->orig_bio->bi_io_vec[cb->orig_bio->bi_vcnt - 1].bv_page;	last_offset = (page_offset(page) + PAGE_CACHE_SIZE);	em_tree = &BTRFS_I(inode)->extent_tree;	tree = &BTRFS_I(inode)->io_tree; 	if (isize == 0)		return 0; 	end_index = (i_size_read(inode) - 1) >> PAGE_CACHE_SHIFT; 	while (last_offset < compressed_end) {		pg_index = last_offset >> PAGE_CACHE_SHIFT; 		if (pg_index > end_index)			break; 		rcu_read_lock();		page = radix_tree_lookup(&mapping->page_tree, pg_index);		rcu_read_unlock();		if (page) {			misses++;			if (misses > 4)				break;			goto next;		} 		page = __page_cache_alloc(mapping_gfp_mask(mapping) &								~__GFP_FS);		if (!page)			break; 		if (add_to_page_cache_lru(page, mapping, pg_index,								GFP_NOFS)) {			page_cache_release(page);			goto next;		} 		end = last_offset + PAGE_CACHE_SIZE - 1;		/*		 * at this point, we have a locked page in the page cache		 * for these bytes in the file.  But, we have to make		 * sure they map to this compressed extent on disk.		 */		set_page_extent_mapped(page);		lock_extent(tree, last_offset, end);

Lines 1–500 of 1038.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t