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

Commit 807b7ebe authored by Badari Pulavarty's avatar Badari Pulavarty Committed by Linus Torvalds
Browse files

ecryptfs: convert to use new aops 



Convert ecryptfs to use write_begin/write_end

Signed-off-by: default avatarNick Piggin <npiggin@suse.de>
Signed-off-by: default avatarBadari Pulavarty <pbadari@us.ibm.com>
Acked-by: default avatarMichael Halcrow <mhalcrow@us.ibm.com>
Cc: Dave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 7d6c7045

fs/ecryptfs/mmap.c

+50 −31
Original line number Diff line number Diff line
@@ -265,22 +265,34 @@ static int fill_zeros_to_end_of_page(struct page *page, unsigned int to) 
}



/**

 * ecryptfs_prepare_write

 * ecryptfs_write_begin

 * @file: The eCryptfs file

 * @page: The eCryptfs page

 * @from: The start byte from which we will write

 * @to: The end byte to which we will write

 * @mapping: The eCryptfs object

 * @pos: The file offset at which to start writing

 * @len: Length of the write

 * @flags: Various flags

 * @pagep: Pointer to return the page

 * @fsdata: Pointer to return fs data (unused)

 *

 * This function must zero any hole we create

 *

 * Returns zero on success; non-zero otherwise

 */

static int ecryptfs_prepare_write(struct file *file, struct page *page,

				  unsigned from, unsigned to)

static int ecryptfs_write_begin(struct file *file,

			struct address_space *mapping,

			loff_t pos, unsigned len, unsigned flags,

			struct page **pagep, void **fsdata)

{

	pgoff_t index = pos >> PAGE_CACHE_SHIFT;

	struct page *page;

	loff_t prev_page_end_size;

	int rc = 0;



	page = __grab_cache_page(mapping, index);

	if (!page)

		return -ENOMEM;

	*pagep = page;



	if (!PageUptodate(page)) {

		struct ecryptfs_crypt_stat *crypt_stat =

			&ecryptfs_inode_to_private(
@@ -289,8 +301,7 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page, 
		if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)

		    || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {

			rc = ecryptfs_read_lower_page_segment(

				page, page->index, 0, PAGE_CACHE_SIZE,

				page->mapping->host);

				page, index, 0, PAGE_CACHE_SIZE, mapping->host);

			if (rc) {

				printk(KERN_ERR "%s: Error attemping to read "

				       "lower page segment; rc = [%d]\n",
@@ -316,8 +327,8 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page, 
				SetPageUptodate(page);

			} else {

				rc = ecryptfs_read_lower_page_segment(

					page, page->index, 0, PAGE_CACHE_SIZE,

					page->mapping->host);

					page, index, 0, PAGE_CACHE_SIZE,

					mapping->host);

				if (rc) {

					printk(KERN_ERR "%s: Error reading "

					       "page; rc = [%d]\n",
@@ -339,10 +350,10 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page, 
			SetPageUptodate(page);

		}

	}

	prev_page_end_size = ((loff_t)page->index << PAGE_CACHE_SHIFT);

	prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);

	/* If creating a page or more of holes, zero them out via truncate.

	 * Note, this will increase i_size. */

	if (page->index != 0) {

	if (index != 0) {

		if (prev_page_end_size > i_size_read(page->mapping->host)) {

			rc = ecryptfs_truncate(file->f_path.dentry,

					       prev_page_end_size);
@@ -357,8 +368,8 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page, 
	}

	/* Writing to a new page, and creating a small hole from start

	 * of page?  Zero it out. */

	if ((i_size_read(page->mapping->host) == prev_page_end_size)

	    && (from != 0))

	if ((i_size_read(mapping->host) == prev_page_end_size)

	    && (pos != 0))

		zero_user(page, 0, PAGE_CACHE_SIZE);

out:

	return rc;
@@ -445,21 +456,28 @@ int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode) 
}



/**

 * ecryptfs_commit_write

 * ecryptfs_write_end

 * @file: The eCryptfs file object

 * @mapping: The eCryptfs object

 * @pos: The file position

 * @len: The length of the data (unused)

 * @copied: The amount of data copied

 * @page: The eCryptfs page

 * @from: Ignored (we rotate the page IV on each write)

 * @to: Ignored

 * @fsdata: The fsdata (unused)

 *

 * This is where we encrypt the data and pass the encrypted data to

 * the lower filesystem.  In OpenPGP-compatible mode, we operate on

 * entire underlying packets.

 */

static int ecryptfs_commit_write(struct file *file, struct page *page,

				 unsigned from, unsigned to)

static int ecryptfs_write_end(struct file *file,

			struct address_space *mapping,

			loff_t pos, unsigned len, unsigned copied,

			struct page *page, void *fsdata)

{

	loff_t pos;

	struct inode *ecryptfs_inode = page->mapping->host;

	pgoff_t index = pos >> PAGE_CACHE_SHIFT;

	unsigned from = pos & (PAGE_CACHE_SIZE - 1);

	unsigned to = from + copied;

	struct inode *ecryptfs_inode = mapping->host;

	struct ecryptfs_crypt_stat *crypt_stat =

		&ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;

	int rc;
@@ -471,25 +489,22 @@ static int ecryptfs_commit_write(struct file *file, struct page *page, 
	} else

		ecryptfs_printk(KERN_DEBUG, "Not a new file\n");

	ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"

			"(page w/ index = [0x%.16x], to = [%d])\n", page->index,

			to);

			"(page w/ index = [0x%.16x], to = [%d])\n", index, to);

	/* Fills in zeros if 'to' goes beyond inode size */

	rc = fill_zeros_to_end_of_page(page, to);

	if (rc) {

		ecryptfs_printk(KERN_WARNING, "Error attempting to fill "

				"zeros in page with index = [0x%.16x]\n",

				page->index);

			"zeros in page with index = [0x%.16x]\n", index);

		goto out;

	}

	rc = ecryptfs_encrypt_page(page);

	if (rc) {

		ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "

				"index [0x%.16x])\n", page->index);

				"index [0x%.16x])\n", index);

		goto out;

	}

	pos = (((loff_t)page->index) << PAGE_CACHE_SHIFT) + to;

	if (pos > i_size_read(ecryptfs_inode)) {

		i_size_write(ecryptfs_inode, pos);

	if (pos + copied > i_size_read(ecryptfs_inode)) {

		i_size_write(ecryptfs_inode, pos + copied);

		ecryptfs_printk(KERN_DEBUG, "Expanded file size to "

				"[0x%.16x]\n", i_size_read(ecryptfs_inode));

	}
@@ -497,7 +512,11 @@ static int ecryptfs_commit_write(struct file *file, struct page *page, 
	if (rc)

		printk(KERN_ERR "Error writing inode size to metadata; "

		       "rc = [%d]\n", rc);

	else

		rc = copied;

out:

	unlock_page(page);

	page_cache_release(page);

	return rc;

}
@@ -518,7 +537,7 @@ static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block) 
struct address_space_operations ecryptfs_aops = {

	.writepage = ecryptfs_writepage,

	.readpage = ecryptfs_readpage,

	.prepare_write = ecryptfs_prepare_write,

	.commit_write = ecryptfs_commit_write,

	.write_begin = ecryptfs_write_begin,

	.write_end = ecryptfs_write_end,

	.bmap = ecryptfs_bmap,

};