adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-29 04:06:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

ecryptfs: convert to use new aops

Browse source 
Convert ecryptfs to use write_begin/write_end

Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Badari Pulavarty <pbadari@us.ibm.com>
Acked-by: Michael Halcrow <mhalcrow@us.ibm.com>
Cc: Dave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Badari Pulavarty 2008-10-15 22:02:50 -07:00 committed by Linus Torvalds
parent 7d6c704558
commit 807b7ebe41
1 changed files with 50 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
fs/ecryptfs/mmap.c
View file

@ -265,22 +265,34 @@ out:
} }
/** /**
* ecryptfs_prepare_write * ecryptfs_write_begin
* @file: The eCryptfs file * @file: The eCryptfs file
* @page: The eCryptfs page * @mapping: The eCryptfs object
* @from: The start byte from which we will write * @pos: The file offset at which to start writing
* @to: The end byte to which we will write * @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 * This function must zero any hole we create
* *
* Returns zero on success; non-zero otherwise * Returns zero on success; non-zero otherwise
*/ */
static int ecryptfs_prepare_write(struct file *file, struct page *page, static int ecryptfs_write_begin(struct file *file,
unsigned from, unsigned to) 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; loff_t prev_page_end_size;
int rc = 0; int rc = 0;
page = __grab_cache_page(mapping, index);
if (!page)
return -ENOMEM;
*pagep = page;
if (!PageUptodate(page)) { if (!PageUptodate(page)) {
struct ecryptfs_crypt_stat *crypt_stat = struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private( &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) if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
|| (crypt_stat->flags & ECRYPTFS_NEW_FILE)) { || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
rc = ecryptfs_read_lower_page_segment( rc = ecryptfs_read_lower_page_segment(
page, page->index, 0, PAGE_CACHE_SIZE, page, index, 0, PAGE_CACHE_SIZE, mapping->host);
page->mapping->host);
if (rc) { if (rc) {
printk(KERN_ERR "%s: Error attemping to read " printk(KERN_ERR "%s: Error attemping to read "
"lower page segment; rc = [%d]\n", "lower page segment; rc = [%d]\n",
@ -316,8 +327,8 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
SetPageUptodate(page); SetPageUptodate(page);
} else { } else {
rc = ecryptfs_read_lower_page_segment( rc = ecryptfs_read_lower_page_segment(
page, page->index, 0, PAGE_CACHE_SIZE, page, index, 0, PAGE_CACHE_SIZE,
page->mapping->host); mapping->host);
if (rc) { if (rc) {
printk(KERN_ERR "%s: Error reading " printk(KERN_ERR "%s: Error reading "
"page; rc = [%d]\n", "page; rc = [%d]\n",
@ -339,10 +350,10 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
SetPageUptodate(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. /* If creating a page or more of holes, zero them out via truncate.
* Note, this will increase i_size. */ * Note, this will increase i_size. */
if (page->index != 0) { if (index != 0) {
if (prev_page_end_size > i_size_read(page->mapping->host)) { if (prev_page_end_size > i_size_read(page->mapping->host)) {
rc = ecryptfs_truncate(file->f_path.dentry, rc = ecryptfs_truncate(file->f_path.dentry,
prev_page_end_size); 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 /* Writing to a new page, and creating a small hole from start
* of page? Zero it out. */ * of page? Zero it out. */
if ((i_size_read(page->mapping->host) == prev_page_end_size) if ((i_size_read(mapping->host) == prev_page_end_size)
&& (from != 0)) && (pos != 0))
zero_user(page, 0, PAGE_CACHE_SIZE); zero_user(page, 0, PAGE_CACHE_SIZE);
out: out:
return rc; 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 * @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 * @page: The eCryptfs page
* @from: Ignored (we rotate the page IV on each write) * @fsdata: The fsdata (unused)
* @to: Ignored
* *
* This is where we encrypt the data and pass the encrypted data to * This is where we encrypt the data and pass the encrypted data to
* the lower filesystem. In OpenPGP-compatible mode, we operate on * the lower filesystem. In OpenPGP-compatible mode, we operate on
* entire underlying packets. * entire underlying packets.
*/ */
static int ecryptfs_commit_write(struct file *file, struct page *page, static int ecryptfs_write_end(struct file *file,
unsigned from, unsigned to) struct address_space *mapping,
loff_t pos, unsigned len, unsigned copied,
struct page *page, void *fsdata)
{ {
loff_t pos; pgoff_t index = pos >> PAGE_CACHE_SHIFT;
struct inode *ecryptfs_inode = page->mapping->host; unsigned from = pos & (PAGE_CACHE_SIZE - 1);
unsigned to = from + copied;
struct inode *ecryptfs_inode = mapping->host;
struct ecryptfs_crypt_stat *crypt_stat = struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat; &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
int rc; int rc;
@ -471,25 +489,22 @@ static int ecryptfs_commit_write(struct file *file, struct page *page,
} else } else
ecryptfs_printk(KERN_DEBUG, "Not a new file\n"); ecryptfs_printk(KERN_DEBUG, "Not a new file\n");
ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page" ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
"(page w/ index = [0x%.16x], to = [%d])\n", page->index, "(page w/ index = [0x%.16x], to = [%d])\n", index, to);
to);
/* Fills in zeros if 'to' goes beyond inode size */ /* Fills in zeros if 'to' goes beyond inode size */
rc = fill_zeros_to_end_of_page(page, to); rc = fill_zeros_to_end_of_page(page, to);
if (rc) { if (rc) {
ecryptfs_printk(KERN_WARNING, "Error attempting to fill " ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
"zeros in page with index = [0x%.16x]\n", "zeros in page with index = [0x%.16x]\n", index);
page->index);
goto out; goto out;
} }
rc = ecryptfs_encrypt_page(page); rc = ecryptfs_encrypt_page(page);
if (rc) { if (rc) {
ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper " ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
"index [0x%.16x])\n", page->index); "index [0x%.16x])\n", index);
goto out; goto out;
} }
pos = (((loff_t)page->index) << PAGE_CACHE_SHIFT) + to; if (pos + copied > i_size_read(ecryptfs_inode)) {
if (pos > i_size_read(ecryptfs_inode)) { i_size_write(ecryptfs_inode, pos + copied);
i_size_write(ecryptfs_inode, pos);
ecryptfs_printk(KERN_DEBUG, "Expanded file size to " ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
"[0x%.16x]\n", i_size_read(ecryptfs_inode)); "[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) if (rc)
printk(KERN_ERR "Error writing inode size to metadata; " printk(KERN_ERR "Error writing inode size to metadata; "
"rc = [%d]\n", rc); "rc = [%d]\n", rc);
else
rc = copied;
out: out:
unlock_page(page);
page_cache_release(page);
return rc; return rc;
} }
@ -518,7 +537,7 @@ static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
struct address_space_operations ecryptfs_aops = { struct address_space_operations ecryptfs_aops = {
.writepage = ecryptfs_writepage, .writepage = ecryptfs_writepage,
.readpage = ecryptfs_readpage, .readpage = ecryptfs_readpage,
.prepare_write = ecryptfs_prepare_write, .write_begin = ecryptfs_write_begin,
.commit_write = ecryptfs_commit_write, .write_end = ecryptfs_write_end,
.bmap = ecryptfs_bmap, .bmap = ecryptfs_bmap,
}; };