mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 00:36:40 +07:00
09cbfeaf1a
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time ago with promise that one day it will be possible to implement page cache with bigger chunks than PAGE_SIZE. This promise never materialized. And unlikely will. We have many places where PAGE_CACHE_SIZE assumed to be equal to PAGE_SIZE. And it's constant source of confusion on whether PAGE_CACHE_* or PAGE_* constant should be used in a particular case, especially on the border between fs and mm. Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much breakage to be doable. Let's stop pretending that pages in page cache are special. They are not. The changes are pretty straight-forward: - <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>; - <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>; - PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN}; - page_cache_get() -> get_page(); - page_cache_release() -> put_page(); This patch contains automated changes generated with coccinelle using script below. For some reason, coccinelle doesn't patch header files. I've called spatch for them manually. The only adjustment after coccinelle is revert of changes to PAGE_CAHCE_ALIGN definition: we are going to drop it later. There are few places in the code where coccinelle didn't reach. I'll fix them manually in a separate patch. Comments and documentation also will be addressed with the separate patch. virtual patch @@ expression E; @@ - E << (PAGE_CACHE_SHIFT - PAGE_SHIFT) + E @@ expression E; @@ - E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) + E @@ @@ - PAGE_CACHE_SHIFT + PAGE_SHIFT @@ @@ - PAGE_CACHE_SIZE + PAGE_SIZE @@ @@ - PAGE_CACHE_MASK + PAGE_MASK @@ expression E; @@ - PAGE_CACHE_ALIGN(E) + PAGE_ALIGN(E) @@ expression E; @@ - page_cache_get(E) + get_page(E) @@ expression E; @@ - page_cache_release(E) + put_page(E) Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> Acked-by: Michal Hocko <mhocko@suse.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
561 lines
16 KiB
C
561 lines
16 KiB
C
/**
|
|
* eCryptfs: Linux filesystem encryption layer
|
|
* This is where eCryptfs coordinates the symmetric encryption and
|
|
* decryption of the file data as it passes between the lower
|
|
* encrypted file and the upper decrypted file.
|
|
*
|
|
* Copyright (C) 1997-2003 Erez Zadok
|
|
* Copyright (C) 2001-2003 Stony Brook University
|
|
* Copyright (C) 2004-2007 International Business Machines Corp.
|
|
* Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* 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
|
|
* 02111-1307, USA.
|
|
*/
|
|
|
|
#include <linux/pagemap.h>
|
|
#include <linux/writeback.h>
|
|
#include <linux/page-flags.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/file.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <linux/slab.h>
|
|
#include <asm/unaligned.h>
|
|
#include "ecryptfs_kernel.h"
|
|
|
|
/**
|
|
* ecryptfs_get_locked_page
|
|
*
|
|
* Get one page from cache or lower f/s, return error otherwise.
|
|
*
|
|
* Returns locked and up-to-date page (if ok), with increased
|
|
* refcnt.
|
|
*/
|
|
struct page *ecryptfs_get_locked_page(struct inode *inode, loff_t index)
|
|
{
|
|
struct page *page = read_mapping_page(inode->i_mapping, index, NULL);
|
|
if (!IS_ERR(page))
|
|
lock_page(page);
|
|
return page;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_writepage
|
|
* @page: Page that is locked before this call is made
|
|
*
|
|
* Returns zero on success; non-zero otherwise
|
|
*
|
|
* 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_writepage(struct page *page, struct writeback_control *wbc)
|
|
{
|
|
int rc;
|
|
|
|
rc = ecryptfs_encrypt_page(page);
|
|
if (rc) {
|
|
ecryptfs_printk(KERN_WARNING, "Error encrypting "
|
|
"page (upper index [0x%.16lx])\n", page->index);
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
}
|
|
SetPageUptodate(page);
|
|
out:
|
|
unlock_page(page);
|
|
return rc;
|
|
}
|
|
|
|
static void strip_xattr_flag(char *page_virt,
|
|
struct ecryptfs_crypt_stat *crypt_stat)
|
|
{
|
|
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
|
|
size_t written;
|
|
|
|
crypt_stat->flags &= ~ECRYPTFS_METADATA_IN_XATTR;
|
|
ecryptfs_write_crypt_stat_flags(page_virt, crypt_stat,
|
|
&written);
|
|
crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Header Extent:
|
|
* Octets 0-7: Unencrypted file size (big-endian)
|
|
* Octets 8-15: eCryptfs special marker
|
|
* Octets 16-19: Flags
|
|
* Octet 16: File format version number (between 0 and 255)
|
|
* Octets 17-18: Reserved
|
|
* Octet 19: Bit 1 (lsb): Reserved
|
|
* Bit 2: Encrypted?
|
|
* Bits 3-8: Reserved
|
|
* Octets 20-23: Header extent size (big-endian)
|
|
* Octets 24-25: Number of header extents at front of file
|
|
* (big-endian)
|
|
* Octet 26: Begin RFC 2440 authentication token packet set
|
|
*/
|
|
|
|
/**
|
|
* ecryptfs_copy_up_encrypted_with_header
|
|
* @page: Sort of a ``virtual'' representation of the encrypted lower
|
|
* file. The actual lower file does not have the metadata in
|
|
* the header. This is locked.
|
|
* @crypt_stat: The eCryptfs inode's cryptographic context
|
|
*
|
|
* The ``view'' is the version of the file that userspace winds up
|
|
* seeing, with the header information inserted.
|
|
*/
|
|
static int
|
|
ecryptfs_copy_up_encrypted_with_header(struct page *page,
|
|
struct ecryptfs_crypt_stat *crypt_stat)
|
|
{
|
|
loff_t extent_num_in_page = 0;
|
|
loff_t num_extents_per_page = (PAGE_SIZE
|
|
/ crypt_stat->extent_size);
|
|
int rc = 0;
|
|
|
|
while (extent_num_in_page < num_extents_per_page) {
|
|
loff_t view_extent_num = ((((loff_t)page->index)
|
|
* num_extents_per_page)
|
|
+ extent_num_in_page);
|
|
size_t num_header_extents_at_front =
|
|
(crypt_stat->metadata_size / crypt_stat->extent_size);
|
|
|
|
if (view_extent_num < num_header_extents_at_front) {
|
|
/* This is a header extent */
|
|
char *page_virt;
|
|
|
|
page_virt = kmap_atomic(page);
|
|
memset(page_virt, 0, PAGE_SIZE);
|
|
/* TODO: Support more than one header extent */
|
|
if (view_extent_num == 0) {
|
|
size_t written;
|
|
|
|
rc = ecryptfs_read_xattr_region(
|
|
page_virt, page->mapping->host);
|
|
strip_xattr_flag(page_virt + 16, crypt_stat);
|
|
ecryptfs_write_header_metadata(page_virt + 20,
|
|
crypt_stat,
|
|
&written);
|
|
}
|
|
kunmap_atomic(page_virt);
|
|
flush_dcache_page(page);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error reading xattr "
|
|
"region; rc = [%d]\n", __func__, rc);
|
|
goto out;
|
|
}
|
|
} else {
|
|
/* This is an encrypted data extent */
|
|
loff_t lower_offset =
|
|
((view_extent_num * crypt_stat->extent_size)
|
|
- crypt_stat->metadata_size);
|
|
|
|
rc = ecryptfs_read_lower_page_segment(
|
|
page, (lower_offset >> PAGE_SHIFT),
|
|
(lower_offset & ~PAGE_MASK),
|
|
crypt_stat->extent_size, page->mapping->host);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error attempting to read "
|
|
"extent at offset [%lld] in the lower "
|
|
"file; rc = [%d]\n", __func__,
|
|
lower_offset, rc);
|
|
goto out;
|
|
}
|
|
}
|
|
extent_num_in_page++;
|
|
}
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_readpage
|
|
* @file: An eCryptfs file
|
|
* @page: Page from eCryptfs inode mapping into which to stick the read data
|
|
*
|
|
* Read in a page, decrypting if necessary.
|
|
*
|
|
* Returns zero on success; non-zero on error.
|
|
*/
|
|
static int ecryptfs_readpage(struct file *file, struct page *page)
|
|
{
|
|
struct ecryptfs_crypt_stat *crypt_stat =
|
|
&ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
|
|
int rc = 0;
|
|
|
|
if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
|
|
rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
|
|
PAGE_SIZE,
|
|
page->mapping->host);
|
|
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
|
|
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
|
|
rc = ecryptfs_copy_up_encrypted_with_header(page,
|
|
crypt_stat);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error attempting to copy "
|
|
"the encrypted content from the lower "
|
|
"file whilst inserting the metadata "
|
|
"from the xattr into the header; rc = "
|
|
"[%d]\n", __func__, rc);
|
|
goto out;
|
|
}
|
|
|
|
} else {
|
|
rc = ecryptfs_read_lower_page_segment(
|
|
page, page->index, 0, PAGE_SIZE,
|
|
page->mapping->host);
|
|
if (rc) {
|
|
printk(KERN_ERR "Error reading page; rc = "
|
|
"[%d]\n", rc);
|
|
goto out;
|
|
}
|
|
}
|
|
} else {
|
|
rc = ecryptfs_decrypt_page(page);
|
|
if (rc) {
|
|
ecryptfs_printk(KERN_ERR, "Error decrypting page; "
|
|
"rc = [%d]\n", rc);
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
if (rc)
|
|
ClearPageUptodate(page);
|
|
else
|
|
SetPageUptodate(page);
|
|
ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16lx]\n",
|
|
page->index);
|
|
unlock_page(page);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Called with lower inode mutex held.
|
|
*/
|
|
static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
|
|
{
|
|
struct inode *inode = page->mapping->host;
|
|
int end_byte_in_page;
|
|
|
|
if ((i_size_read(inode) / PAGE_SIZE) != page->index)
|
|
goto out;
|
|
end_byte_in_page = i_size_read(inode) % PAGE_SIZE;
|
|
if (to > end_byte_in_page)
|
|
end_byte_in_page = to;
|
|
zero_user_segment(page, end_byte_in_page, PAGE_SIZE);
|
|
out:
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_write_begin
|
|
* @file: The eCryptfs file
|
|
* @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_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_SHIFT;
|
|
struct page *page;
|
|
loff_t prev_page_end_size;
|
|
int rc = 0;
|
|
|
|
page = grab_cache_page_write_begin(mapping, index, flags);
|
|
if (!page)
|
|
return -ENOMEM;
|
|
*pagep = page;
|
|
|
|
prev_page_end_size = ((loff_t)index << PAGE_SHIFT);
|
|
if (!PageUptodate(page)) {
|
|
struct ecryptfs_crypt_stat *crypt_stat =
|
|
&ecryptfs_inode_to_private(mapping->host)->crypt_stat;
|
|
|
|
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
|
|
rc = ecryptfs_read_lower_page_segment(
|
|
page, index, 0, PAGE_SIZE, mapping->host);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error attempting to read "
|
|
"lower page segment; rc = [%d]\n",
|
|
__func__, rc);
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
} else
|
|
SetPageUptodate(page);
|
|
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
|
|
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
|
|
rc = ecryptfs_copy_up_encrypted_with_header(
|
|
page, crypt_stat);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error attempting "
|
|
"to copy the encrypted content "
|
|
"from the lower file whilst "
|
|
"inserting the metadata from "
|
|
"the xattr into the header; rc "
|
|
"= [%d]\n", __func__, rc);
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
}
|
|
SetPageUptodate(page);
|
|
} else {
|
|
rc = ecryptfs_read_lower_page_segment(
|
|
page, index, 0, PAGE_SIZE,
|
|
mapping->host);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error reading "
|
|
"page; rc = [%d]\n",
|
|
__func__, rc);
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
}
|
|
SetPageUptodate(page);
|
|
}
|
|
} else {
|
|
if (prev_page_end_size
|
|
>= i_size_read(page->mapping->host)) {
|
|
zero_user(page, 0, PAGE_SIZE);
|
|
SetPageUptodate(page);
|
|
} else if (len < PAGE_SIZE) {
|
|
rc = ecryptfs_decrypt_page(page);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error decrypting "
|
|
"page at index [%ld]; "
|
|
"rc = [%d]\n",
|
|
__func__, page->index, rc);
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
}
|
|
SetPageUptodate(page);
|
|
}
|
|
}
|
|
}
|
|
/* If creating a page or more of holes, zero them out via truncate.
|
|
* Note, this will increase i_size. */
|
|
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);
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: Error on attempt to "
|
|
"truncate to (higher) offset [%lld];"
|
|
" rc = [%d]\n", __func__,
|
|
prev_page_end_size, rc);
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
/* Writing to a new page, and creating a small hole from start
|
|
* of page? Zero it out. */
|
|
if ((i_size_read(mapping->host) == prev_page_end_size)
|
|
&& (pos != 0))
|
|
zero_user(page, 0, PAGE_SIZE);
|
|
out:
|
|
if (unlikely(rc)) {
|
|
unlock_page(page);
|
|
put_page(page);
|
|
*pagep = NULL;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_write_inode_size_to_header
|
|
*
|
|
* Writes the lower file size to the first 8 bytes of the header.
|
|
*
|
|
* Returns zero on success; non-zero on error.
|
|
*/
|
|
static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
|
|
{
|
|
char *file_size_virt;
|
|
int rc;
|
|
|
|
file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL);
|
|
if (!file_size_virt) {
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);
|
|
rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0,
|
|
sizeof(u64));
|
|
kfree(file_size_virt);
|
|
if (rc < 0)
|
|
printk(KERN_ERR "%s: Error writing file size to header; "
|
|
"rc = [%d]\n", __func__, rc);
|
|
else
|
|
rc = 0;
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
struct kmem_cache *ecryptfs_xattr_cache;
|
|
|
|
static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
|
|
{
|
|
ssize_t size;
|
|
void *xattr_virt;
|
|
struct dentry *lower_dentry =
|
|
ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
|
|
struct inode *lower_inode = d_inode(lower_dentry);
|
|
int rc;
|
|
|
|
if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
|
|
printk(KERN_WARNING
|
|
"No support for setting xattr in lower filesystem\n");
|
|
rc = -ENOSYS;
|
|
goto out;
|
|
}
|
|
xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
|
|
if (!xattr_virt) {
|
|
printk(KERN_ERR "Out of memory whilst attempting to write "
|
|
"inode size to xattr\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
inode_lock(lower_inode);
|
|
size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
|
|
xattr_virt, PAGE_SIZE);
|
|
if (size < 0)
|
|
size = 8;
|
|
put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
|
|
rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
|
|
xattr_virt, size, 0);
|
|
inode_unlock(lower_inode);
|
|
if (rc)
|
|
printk(KERN_ERR "Error whilst attempting to write inode size "
|
|
"to lower file xattr; rc = [%d]\n", rc);
|
|
kmem_cache_free(ecryptfs_xattr_cache, xattr_virt);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
|
|
{
|
|
struct ecryptfs_crypt_stat *crypt_stat;
|
|
|
|
crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
|
|
BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
|
|
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
|
|
return ecryptfs_write_inode_size_to_xattr(ecryptfs_inode);
|
|
else
|
|
return ecryptfs_write_inode_size_to_header(ecryptfs_inode);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* @fsdata: The fsdata (unused)
|
|
*/
|
|
static int ecryptfs_write_end(struct file *file,
|
|
struct address_space *mapping,
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
struct page *page, void *fsdata)
|
|
{
|
|
pgoff_t index = pos >> PAGE_SHIFT;
|
|
unsigned from = pos & (PAGE_SIZE - 1);
|
|
unsigned to = from + copied;
|
|
struct inode *ecryptfs_inode = mapping->host;
|
|
struct ecryptfs_crypt_stat *crypt_stat =
|
|
&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
|
|
int rc;
|
|
|
|
ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
|
|
"(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
|
|
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
|
|
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
|
|
to);
|
|
if (!rc) {
|
|
rc = copied;
|
|
fsstack_copy_inode_size(ecryptfs_inode,
|
|
ecryptfs_inode_to_lower(ecryptfs_inode));
|
|
}
|
|
goto out;
|
|
}
|
|
if (!PageUptodate(page)) {
|
|
if (copied < PAGE_SIZE) {
|
|
rc = 0;
|
|
goto out;
|
|
}
|
|
SetPageUptodate(page);
|
|
}
|
|
/* 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%.16lx]\n", index);
|
|
goto out;
|
|
}
|
|
rc = ecryptfs_encrypt_page(page);
|
|
if (rc) {
|
|
ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
|
|
"index [0x%.16lx])\n", index);
|
|
goto out;
|
|
}
|
|
if (pos + copied > i_size_read(ecryptfs_inode)) {
|
|
i_size_write(ecryptfs_inode, pos + copied);
|
|
ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
|
|
"[0x%.16llx]\n",
|
|
(unsigned long long)i_size_read(ecryptfs_inode));
|
|
}
|
|
rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
|
|
if (rc)
|
|
printk(KERN_ERR "Error writing inode size to metadata; "
|
|
"rc = [%d]\n", rc);
|
|
else
|
|
rc = copied;
|
|
out:
|
|
unlock_page(page);
|
|
put_page(page);
|
|
return rc;
|
|
}
|
|
|
|
static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
|
|
{
|
|
int rc = 0;
|
|
struct inode *inode;
|
|
struct inode *lower_inode;
|
|
|
|
inode = (struct inode *)mapping->host;
|
|
lower_inode = ecryptfs_inode_to_lower(inode);
|
|
if (lower_inode->i_mapping->a_ops->bmap)
|
|
rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping,
|
|
block);
|
|
return rc;
|
|
}
|
|
|
|
const struct address_space_operations ecryptfs_aops = {
|
|
.writepage = ecryptfs_writepage,
|
|
.readpage = ecryptfs_readpage,
|
|
.write_begin = ecryptfs_write_begin,
|
|
.write_end = ecryptfs_write_end,
|
|
.bmap = ecryptfs_bmap,
|
|
};
|