Convert ecryptfs to new aops. Signed-off-by: Nick Piggin Index: linux-2.6/fs/ecryptfs/mmap.c =================================================================== --- linux-2.6.orig/fs/ecryptfs/mmap.c +++ linux-2.6/fs/ecryptfs/mmap.c @@ -36,34 +36,6 @@ struct kmem_cache *ecryptfs_lower_page_cache; -/** - * ecryptfs_get1page - * - * Get one page from cache or lower f/s, return error otherwise. - * - * Returns unlocked and up-to-date page (if ok), with increased - * refcnt. - */ -static struct page *ecryptfs_get1page(struct file *file, int index) -{ - struct page *page; - struct dentry *dentry; - struct inode *inode; - struct address_space *mapping; - - dentry = file->f_path.dentry; - inode = dentry->d_inode; - mapping = inode->i_mapping; - page = read_cache_page(mapping, index, - (filler_t *)mapping->a_ops->readpage, - (void *)file); - if (IS_ERR(page)) - goto out; - wait_on_page_locked(page); -out: - return page; -} - static int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros); @@ -369,17 +341,14 @@ out: /** * Called with lower inode mutex held. */ -static int fill_zeros_to_end_of_page(struct page *page, unsigned int to) +static int fill_zeros_to_end_of_page(struct page *page, loff_t new_isize) { - struct inode *inode = page->mapping->host; int end_byte_in_page; char *page_virt; - if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index) + if ((new_isize >> PAGE_CACHE_SHIFT) != page->index) goto out; - end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE; - if (to > end_byte_in_page) - end_byte_in_page = to; + end_byte_in_page = new_isize % PAGE_CACHE_SIZE; page_virt = kmap_atomic(page, KM_USER0); memset((page_virt + end_byte_in_page), 0, (PAGE_CACHE_SIZE - end_byte_in_page)); @@ -389,16 +358,35 @@ out: return 0; } -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) { + struct page *page; + pgoff_t index; int rc = 0; - if (from == 0 && to == PAGE_CACHE_SIZE) - goto out; /* If we are writing a full page, it will be - up to date. */ - if (!PageUptodate(page)) - rc = ecryptfs_do_readpage(file, page, page->index); + index = pos >> PAGE_CACHE_SHIFT; + page = __grab_cache_page(mapping, index); + if (!page) { + rc = -ENOMEM; + goto out; + } + + /* + * If we are writing a full page (with no possibility of a short + * write), it will be guaranteed to end up being uptodate at + * write_end-time + */ + if (flags & AOP_FLAG_UNINTERRUPTIBLE && len == PAGE_CACHE_SIZE) + goto out; + if (!PageUptodate(page)) { + rc = ecryptfs_do_readpage(file, page, index); + if (rc) { + unlock_page(page); + page_cache_release(page); + } + } out: return rc; } @@ -421,12 +409,6 @@ out: return rc; } -static void ecryptfs_release_lower_page(struct page *lower_page) -{ - unlock_page(lower_page); - page_cache_release(lower_page); -} - /** * ecryptfs_write_inode_size_to_header * @@ -440,23 +422,17 @@ static int ecryptfs_write_inode_size_to_ { int rc = 0; struct page *header_page; + void *fsdata; char *header_virt; - const struct address_space_operations *lower_a_ops; + struct address_space *lower_mapping = lower_inode->i_mapping; u64 file_size; - header_page = grab_cache_page(lower_inode->i_mapping, 0); - if (!header_page) { - ecryptfs_printk(KERN_ERR, "grab_cache_page for " - "lower_page_index 0 failed\n"); - rc = -EINVAL; - goto out; - } - lower_a_ops = lower_inode->i_mapping->a_ops; - rc = lower_a_ops->prepare_write(lower_file, header_page, 0, 8); - if (rc) { - ecryptfs_release_lower_page(header_page); + rc = pagecache_write_begin(lower_file, lower_mapping, 0, sizeof(u64), + AOP_FLAG_UNINTERRUPTIBLE, + &header_page, &fsdata); + if (rc) goto out; - } + file_size = (u64)i_size_read(inode); ecryptfs_printk(KERN_DEBUG, "Writing size: [0x%.16x]\n", file_size); file_size = cpu_to_be64(file_size); @@ -464,13 +440,17 @@ static int ecryptfs_write_inode_size_to_ memcpy(header_virt, &file_size, sizeof(u64)); kunmap_atomic(header_virt, KM_USER0); flush_dcache_page(header_page); - rc = lower_a_ops->commit_write(lower_file, header_page, 0, 8); - if (rc < 0) + + rc = pagecache_write_end(lower_file, lower_mapping, 0, sizeof(u64), + sizeof(u64), header_page, fsdata); + if (rc != sizeof(u64)) { ecryptfs_printk(KERN_ERR, "Error commiting header page " "write\n"); - ecryptfs_release_lower_page(header_page); + if (rc > 0) + rc = -EINVAL; /* XXX: can we do better? */ + } lower_inode->i_mtime = lower_inode->i_ctime = CURRENT_TIME; - mark_inode_dirty_sync(inode); + mark_inode_dirty_sync(inode); /* XXX: lower_inode? */ out: return rc; } @@ -553,31 +533,21 @@ ecryptfs_write_inode_size_to_metadata(st int ecryptfs_get_lower_page(struct page **lower_page, struct inode *lower_inode, struct file *lower_file, unsigned long lower_page_index, int byte_offset, - int region_bytes) + int region_bytes, void **fsdata) { - int rc = 0; + int rc; + struct address_space *lower_mapping = lower_inode->i_mapping; + loff_t pos = (lower_page_index << PAGE_CACHE_SHIFT) + byte_offset; -retry: - *lower_page = grab_cache_page(lower_inode->i_mapping, lower_page_index); - if (!(*lower_page)) { - rc = -EINVAL; - ecryptfs_printk(KERN_ERR, "Error attempting to grab " - "lower page with index [0x%.16x]\n", - lower_page_index); - goto out; - } - rc = lower_inode->i_mapping->a_ops->prepare_write(lower_file, - (*lower_page), - byte_offset, - region_bytes); + rc = pagecache_write_begin(lower_file, lower_mapping, pos, region_bytes, + AOP_FLAG_UNINTERRUPTIBLE, /* XXX: ok? */ + lower_page, fsdata); if (rc) { - ecryptfs_printk(KERN_ERR, "prepare_write for " + ecryptfs_printk(KERN_ERR, "pagecache_write_begin for " "lower_page_index = [0x%.16x] failed; rc = " "[%d]\n", lower_page_index, rc); - ecryptfs_release_lower_page(*lower_page); (*lower_page) = NULL; } -out: return rc; } @@ -589,18 +559,21 @@ out: int ecryptfs_commit_lower_page(struct page *lower_page, struct inode *lower_inode, struct file *lower_file, int byte_offset, - int region_size) + int region_size, void *fsdata) { - int rc = 0; + int rc; + struct address_space *lower_mapping = lower_inode->i_mapping; + loff_t pos = (lower_page->index << PAGE_CACHE_SHIFT) + byte_offset; - rc = lower_inode->i_mapping->a_ops->commit_write( - lower_file, lower_page, byte_offset, region_size); - if (rc < 0) { + rc = pagecache_write_end(lower_file, lower_mapping, pos, region_size, + region_size, lower_page, fsdata); + if (rc != region_size) { ecryptfs_printk(KERN_ERR, "Error committing write; rc = [%d]\n", rc); + if (rc > 0) + rc = -EINVAL; } else rc = 0; - ecryptfs_release_lower_page(lower_page); return rc; } @@ -615,9 +588,10 @@ int ecryptfs_copy_page_to_lower(struct p { int rc = 0; struct page *lower_page; + void *fsdata; rc = ecryptfs_get_lower_page(&lower_page, lower_inode, lower_file, - page->index, 0, PAGE_CACHE_SIZE); + page->index, 0, PAGE_CACHE_SIZE, &fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error attempting to get page " "at index [0x%.16x]\n", page->index); @@ -627,7 +601,7 @@ int ecryptfs_copy_page_to_lower(struct p memcpy((char *)page_address(lower_page), page_address(page), PAGE_CACHE_SIZE); rc = ecryptfs_commit_lower_page(lower_page, lower_inode, lower_file, - 0, PAGE_CACHE_SIZE); + 0, PAGE_CACHE_SIZE, fsdata); if (rc) ecryptfs_printk(KERN_ERR, "Error attempting to commit page " "at index [0x%.16x]\n", page->index); @@ -638,31 +612,37 @@ out: struct kmem_cache *ecryptfs_xattr_cache; /** - * ecryptfs_commit_write + * ecryptfs_write_end * @file: The eCryptfs file object - * @page: The eCryptfs page - * @from: Ignored (we rotate the page IV on each write) - * @to: Ignored + * @mapping: The eCryptfs address_space + * @pos: The start of the write + * @len: The length passed to write_begin (unused) + * @copied: The actual amount copied + * @page: The eCryptfs page returned by write_begin + * @fsdata: Filesystem private data (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) { struct ecryptfs_page_crypt_context ctx; - loff_t pos; + loff_t isize; struct inode *inode; struct inode *lower_inode; struct file *lower_file; struct ecryptfs_crypt_stat *crypt_stat; int rc; - inode = page->mapping->host; + inode = mapping->host; + isize = inode->i_size; /* i_mutex is held */ lower_inode = ecryptfs_inode_to_lower(inode); lower_file = ecryptfs_file_to_lower(file); - mutex_lock(&lower_inode->i_mutex); + mutex_lock(&lower_inode->i_mutex); /* XXX: put this in write_begin? */ crypt_stat = &ecryptfs_inode_to_private(file->f_path.dentry->d_inode) ->crypt_stat; if (crypt_stat->flags & ECRYPTFS_NEW_FILE) { @@ -673,8 +653,8 @@ static int ecryptfs_commit_write(struct 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); - rc = fill_zeros_to_end_of_page(page, to); + max(isize, pos+copied)); + rc = fill_zeros_to_end_of_page(page, max(isize, pos+copied)); if (rc) { ecryptfs_printk(KERN_WARNING, "Error attempting to fill " "zeros in page with index = [0x%.16x]\n", @@ -691,11 +671,10 @@ static int ecryptfs_commit_write(struct goto out; } inode->i_blocks = lower_inode->i_blocks; - pos = (page->index << PAGE_CACHE_SHIFT) + to; - if (pos > i_size_read(inode)) { - i_size_write(inode, pos); + if (pos + copied > isize) { + i_size_write(inode, pos + copied); ecryptfs_printk(KERN_DEBUG, "Expanded file size to " - "[0x%.16x]\n", i_size_read(inode)); + "[0x%.16x]\n", pos + copied); } rc = ecryptfs_write_inode_size_to_metadata(lower_file, lower_inode, inode, file->f_dentry, @@ -711,6 +690,9 @@ out: else SetPageUptodate(page); mutex_unlock(&lower_inode->i_mutex); + unlock_page(page); + page_cache_release(page); + return rc; } @@ -731,32 +713,31 @@ int write_zeros(struct file *file, pgoff int rc = 0; struct page *tmp_page; char *tmp_page_virt; - - tmp_page = ecryptfs_get1page(file, index); - if (IS_ERR(tmp_page)) { - ecryptfs_printk(KERN_ERR, "Error getting page at index " - "[0x%.16x]\n", index); - rc = PTR_ERR(tmp_page); - goto out; - } - rc = ecryptfs_prepare_write(file, tmp_page, start, start + num_zeros); + void *fsdata; + struct address_space *mapping = file->f_path.dentry->d_inode->i_mapping; + loff_t pos = (index << PAGE_CACHE_SHIFT) + start; + + rc = pagecache_write_begin(file, mapping, pos, num_zeros, + AOP_FLAG_UNINTERRUPTIBLE, + &tmp_page, &fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error preparing to write zero's " "to remainder of page at index [0x%.16x]\n", index); - page_cache_release(tmp_page); goto out; } tmp_page_virt = kmap_atomic(tmp_page, KM_USER0); memset(((char *)tmp_page_virt + start), 0, num_zeros); kunmap_atomic(tmp_page_virt, KM_USER0); flush_dcache_page(tmp_page); - rc = ecryptfs_commit_write(file, tmp_page, start, start + num_zeros); - if (rc < 0) { + rc = pagecache_write_end(file, mapping, pos, num_zeros, num_zeros, + tmp_page, fsdata); + if (rc != num_zeros) { ecryptfs_printk(KERN_ERR, "Error attempting to write zero's " "to remainder of page at index [0x%.16x]\n", index); - page_cache_release(tmp_page); + if (rc > 0) + rc = -EINVAL; goto out; } rc = 0; @@ -804,8 +785,8 @@ static void ecryptfs_sync_page(struct pa 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, .sync_page = ecryptfs_sync_page, }; Index: linux-2.6/fs/ecryptfs/crypto.c =================================================================== --- linux-2.6.orig/fs/ecryptfs/crypto.c +++ linux-2.6/fs/ecryptfs/crypto.c @@ -375,7 +375,8 @@ ecryptfs_extent_to_lwr_pg_idx_and_offset static int ecryptfs_write_out_page(struct ecryptfs_page_crypt_context *ctx, struct page *lower_page, struct inode *lower_inode, - int byte_offset_in_page, int bytes_to_write) + int byte_offset_in_page, int bytes_to_write, + void *fsdata) { int rc = 0; @@ -383,7 +384,7 @@ static int ecryptfs_write_out_page(struc rc = ecryptfs_commit_lower_page(lower_page, lower_inode, ctx->param.lower_file, byte_offset_in_page, - bytes_to_write); + bytes_to_write, fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error calling lower " "commit; rc = [%d]\n", rc); @@ -407,7 +408,7 @@ static int ecryptfs_read_in_page(struct struct page **lower_page, struct inode *lower_inode, unsigned long lower_page_idx, - int byte_offset_in_page) + int byte_offset_in_page, void **fsdata) { int rc = 0; @@ -419,13 +420,12 @@ static int ecryptfs_read_in_page(struct lower_page_idx, byte_offset_in_page, (PAGE_CACHE_SIZE - - byte_offset_in_page)); + - byte_offset_in_page), fsdata); if (rc) { ecryptfs_printk( - KERN_ERR, "Error attempting to grab, map, " - "and prepare_write lower page with index " + KERN_ERR, "Error in ecryptfs_get_lower_page " + "lower page with index " "[0x%.16x]; rc = [%d]\n", lower_page_idx, rc); - goto out; } } else { *lower_page = grab_cache_page(lower_inode->i_mapping, @@ -436,10 +436,9 @@ static int ecryptfs_read_in_page(struct KERN_ERR, "Error attempting to grab and map " "lower page with index [0x%.16x]; rc = [%d]\n", lower_page_idx, rc); - goto out; } } -out: + return rc; } @@ -475,6 +474,8 @@ int ecryptfs_encrypt_page(struct ecryptf int lower_byte_offset = 0; int orig_byte_offset = 0; int num_extents_per_page; + void *fsdata; + #define ECRYPTFS_PAGE_STATE_UNREAD 0 #define ECRYPTFS_PAGE_STATE_READ 1 #define ECRYPTFS_PAGE_STATE_MODIFIED 2 @@ -503,10 +504,9 @@ int ecryptfs_encrypt_page(struct ecryptf if (prior_lower_page_idx != lower_page_idx && page_state == ECRYPTFS_PAGE_STATE_MODIFIED) { rc = ecryptfs_write_out_page(ctx, lower_page, - lower_inode, - orig_byte_offset, - (PAGE_CACHE_SIZE - - orig_byte_offset)); + lower_inode, orig_byte_offset, + (PAGE_CACHE_SIZE - orig_byte_offset), + fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error attempting " "to write out page; rc = [%d]" @@ -519,7 +519,7 @@ int ecryptfs_encrypt_page(struct ecryptf || page_state == ECRYPTFS_PAGE_STATE_WRITTEN) { rc = ecryptfs_read_in_page(ctx, &lower_page, lower_inode, lower_page_idx, - lower_byte_offset); + lower_byte_offset, &fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error attempting " "to read in lower page with " @@ -571,8 +571,8 @@ int ecryptfs_encrypt_page(struct ecryptf } BUG_ON(orig_byte_offset != 0); rc = ecryptfs_write_out_page(ctx, lower_page, lower_inode, 0, - (lower_byte_offset - + crypt_stat->extent_size)); + (lower_byte_offset + crypt_stat->extent_size), + fsdata); if (rc) { ecryptfs_printk(KERN_ERR, "Error attempting to write out " "page; rc = [%d]\n", rc); Index: linux-2.6/fs/ecryptfs/ecryptfs_kernel.h =================================================================== --- linux-2.6.orig/fs/ecryptfs/ecryptfs_kernel.h +++ linux-2.6/fs/ecryptfs/ecryptfs_kernel.h @@ -503,11 +503,11 @@ int ecryptfs_write_inode_size_to_metadat int ecryptfs_get_lower_page(struct page **lower_page, struct inode *lower_inode, struct file *lower_file, unsigned long lower_page_index, int byte_offset, - int region_bytes); + int region_bytes, void **fsdata); int ecryptfs_commit_lower_page(struct page *lower_page, struct inode *lower_inode, struct file *lower_file, int byte_offset, - int region_size); + int region_size, void *fsdata); int ecryptfs_copy_page_to_lower(struct page *page, struct inode *lower_inode, struct file *lower_file); int ecryptfs_do_readpage(struct file *file, struct page *page,