kpriv/linux-hardened
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ecryptfs/ecryptfs-2.6

Browse source 
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ecryptfs/ecryptfs-2.6:
  ecryptfs: remove unnecessary decrypt when extending a file
  ecryptfs: Fix ecryptfs_printk() size_t warnings
  fs/ecryptfs: Add printf format/argument verification and fix fallout
  ecryptfs: fixed testing of file descriptor flags
  ecryptfs: test lower_file pointer when lower_file_mutex is locked
  ecryptfs: missing initialization of the superblock 'magic' field
  ecryptfs: moved ECRYPTFS_SUPER_MAGIC definition to linux/magic.h
  ecryptfs: fix truncation error in ecryptfs_read_update_atime
This commit is contained in:
Linus Torvalds 2011-01-17 12:39:57 -08:00
commit 9e8a462a01
8 changed files with 83 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
fs/ecryptfs/crypto.c
View file

@ -348,7 +348,7 @@ static int encrypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
BUG_ON(!crypt_stat || !crypt_stat->tfm BUG_ON(!crypt_stat || !crypt_stat->tfm
|| !(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)); || !(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED));
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
ecryptfs_printk(KERN_DEBUG, "Key size [%d]; key:\n", ecryptfs_printk(KERN_DEBUG, "Key size [%zd]; key:\n",
crypt_stat->key_size); crypt_stat->key_size);
ecryptfs_dump_hex(crypt_stat->key, ecryptfs_dump_hex(crypt_stat->key,
crypt_stat->key_size); crypt_stat->key_size);
@ -413,10 +413,9 @@ static int ecryptfs_encrypt_extent(struct page *enc_extent_page,
rc = ecryptfs_derive_iv(extent_iv, crypt_stat, rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
(extent_base + extent_offset)); (extent_base + extent_offset));
if (rc) { if (rc) {
ecryptfs_printk(KERN_ERR, "Error attempting to " ecryptfs_printk(KERN_ERR, "Error attempting to derive IV for "
"derive IV for extent [0x%.16x]; " "extent [0x%.16llx]; rc = [%d]\n",
"rc = [%d]\n", (extent_base + extent_offset), (unsigned long long)(extent_base + extent_offset), rc);
rc);
goto out; goto out;
} }
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
@ -443,9 +442,9 @@ static int ecryptfs_encrypt_extent(struct page *enc_extent_page,
} }
rc = 0; rc = 0;
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
ecryptfs_printk(KERN_DEBUG, "Encrypt extent [0x%.16x]; " ecryptfs_printk(KERN_DEBUG, "Encrypt extent [0x%.16llx]; "
"rc = [%d]\n", (extent_base + extent_offset), "rc = [%d]\n",
rc); (unsigned long long)(extent_base + extent_offset), rc);
ecryptfs_printk(KERN_DEBUG, "First 8 bytes after " ecryptfs_printk(KERN_DEBUG, "First 8 bytes after "
"encryption:\n"); "encryption:\n");
ecryptfs_dump_hex((char *)(page_address(enc_extent_page)), 8); ecryptfs_dump_hex((char *)(page_address(enc_extent_page)), 8);
@ -540,10 +539,9 @@ static int ecryptfs_decrypt_extent(struct page *page,
rc = ecryptfs_derive_iv(extent_iv, crypt_stat, rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
(extent_base + extent_offset)); (extent_base + extent_offset));
if (rc) { if (rc) {
ecryptfs_printk(KERN_ERR, "Error attempting to " ecryptfs_printk(KERN_ERR, "Error attempting to derive IV for "
"derive IV for extent [0x%.16x]; " "extent [0x%.16llx]; rc = [%d]\n",
"rc = [%d]\n", (extent_base + extent_offset), (unsigned long long)(extent_base + extent_offset), rc);
rc);
goto out; goto out;
} }
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
@ -571,9 +569,9 @@ static int ecryptfs_decrypt_extent(struct page *page,
} }
rc = 0; rc = 0;
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
ecryptfs_printk(KERN_DEBUG, "Decrypt extent [0x%.16x]; " ecryptfs_printk(KERN_DEBUG, "Decrypt extent [0x%.16llx]; "
"rc = [%d]\n", (extent_base + extent_offset), "rc = [%d]\n",
rc); (unsigned long long)(extent_base + extent_offset), rc);
ecryptfs_printk(KERN_DEBUG, "First 8 bytes after " ecryptfs_printk(KERN_DEBUG, "First 8 bytes after "
"decryption:\n"); "decryption:\n");
ecryptfs_dump_hex((char *)(page_address(page) ecryptfs_dump_hex((char *)(page_address(page)
@ -780,7 +778,7 @@ int ecryptfs_init_crypt_ctx(struct ecryptfs_crypt_stat *crypt_stat)
} }
ecryptfs_printk(KERN_DEBUG, ecryptfs_printk(KERN_DEBUG,
"Initializing cipher [%s]; strlen = [%d]; " "Initializing cipher [%s]; strlen = [%d]; "
"key_size_bits = [%d]\n", "key_size_bits = [%zd]\n",
crypt_stat->cipher, (int)strlen(crypt_stat->cipher), crypt_stat->cipher, (int)strlen(crypt_stat->cipher),
crypt_stat->key_size << 3); crypt_stat->key_size << 3);
if (crypt_stat->tfm) { if (crypt_stat->tfm) {

2
fs/ecryptfs/ecryptfs_kernel.h
View file

@ -192,7 +192,6 @@ ecryptfs_get_key_payload_data(struct key *key)
(((struct user_key_payload*)key->payload.data)->data); (((struct user_key_payload*)key->payload.data)->data);
} }
#define ECRYPTFS_SUPER_MAGIC 0xf15f
#define ECRYPTFS_MAX_KEYSET_SIZE 1024 #define ECRYPTFS_MAX_KEYSET_SIZE 1024
#define ECRYPTFS_MAX_CIPHER_NAME_SIZE 32 #define ECRYPTFS_MAX_CIPHER_NAME_SIZE 32
#define ECRYPTFS_MAX_NUM_ENC_KEYS 64 #define ECRYPTFS_MAX_NUM_ENC_KEYS 64
@ -584,6 +583,7 @@ ecryptfs_set_dentry_lower_mnt(struct dentry *dentry, struct vfsmount *lower_mnt)
#define ecryptfs_printk(type, fmt, arg...) \ #define ecryptfs_printk(type, fmt, arg...) \
__ecryptfs_printk(type "%s: " fmt, __func__, ## arg); __ecryptfs_printk(type "%s: " fmt, __func__, ## arg);
__attribute__ ((format(printf, 1, 2)))
void __ecryptfs_printk(const char *fmt, ...); void __ecryptfs_printk(const char *fmt, ...);
extern const struct file_operations ecryptfs_main_fops; extern const struct file_operations ecryptfs_main_fops;

28
fs/ecryptfs/file.c
View file

@ -47,7 +47,7 @@ static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
const struct iovec *iov, const struct iovec *iov,
unsigned long nr_segs, loff_t pos) unsigned long nr_segs, loff_t pos)
{ {
int rc; ssize_t rc;
struct dentry *lower_dentry; struct dentry *lower_dentry;
struct vfsmount *lower_vfsmount; struct vfsmount *lower_vfsmount;
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
@ -191,18 +191,16 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
| ECRYPTFS_ENCRYPTED); | ECRYPTFS_ENCRYPTED);
} }
mutex_unlock(&crypt_stat->cs_mutex); mutex_unlock(&crypt_stat->cs_mutex);
if (!ecryptfs_inode_to_private(inode)->lower_file) { rc = ecryptfs_init_persistent_file(ecryptfs_dentry);
rc = ecryptfs_init_persistent_file(ecryptfs_dentry); if (rc) {
if (rc) { printk(KERN_ERR "%s: Error attempting to initialize "
printk(KERN_ERR "%s: Error attempting to initialize " "the persistent file for the dentry with name "
"the persistent file for the dentry with name " "[%s]; rc = [%d]\n", __func__,
"[%s]; rc = [%d]\n", __func__, ecryptfs_dentry->d_name.name, rc);
ecryptfs_dentry->d_name.name, rc); goto out_free;
goto out_free;
}
} }
if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_RDONLY) if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_ACCMODE)
&& !(file->f_flags & O_RDONLY)) { == O_RDONLY && (file->f_flags & O_ACCMODE) != O_RDONLY) {
rc = -EPERM; rc = -EPERM;
printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs " printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs "
"file must hence be opened RO\n", __func__); "file must hence be opened RO\n", __func__);
@ -243,9 +241,9 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
} }
} }
mutex_unlock(&crypt_stat->cs_mutex); mutex_unlock(&crypt_stat->cs_mutex);
ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = [0x%.16x] " ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
"size: [0x%.16x]\n", inode, inode->i_ino, "[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
i_size_read(inode)); (unsigned long long)i_size_read(inode));
goto out; goto out;
out_free: out_free:
kmem_cache_free(ecryptfs_file_info_cache, kmem_cache_free(ecryptfs_file_info_cache,

32
fs/ecryptfs/inode.c
View file

@ -185,15 +185,13 @@ static int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry)
"context; rc = [%d]\n", rc); "context; rc = [%d]\n", rc);
goto out; goto out;
} }
if (!ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->lower_file) { rc = ecryptfs_init_persistent_file(ecryptfs_dentry);
rc = ecryptfs_init_persistent_file(ecryptfs_dentry); if (rc) {
if (rc) { printk(KERN_ERR "%s: Error attempting to initialize "
printk(KERN_ERR "%s: Error attempting to initialize " "the persistent file for the dentry with name "
"the persistent file for the dentry with name " "[%s]; rc = [%d]\n", __func__,
"[%s]; rc = [%d]\n", __func__, ecryptfs_dentry->d_name.name, rc);
ecryptfs_dentry->d_name.name, rc); goto out;
goto out;
}
} }
rc = ecryptfs_write_metadata(ecryptfs_dentry); rc = ecryptfs_write_metadata(ecryptfs_dentry);
if (rc) { if (rc) {
@ -302,15 +300,13 @@ int ecryptfs_lookup_and_interpose_lower(struct dentry *ecryptfs_dentry,
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
} }
if (!ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->lower_file) { rc = ecryptfs_init_persistent_file(ecryptfs_dentry);
rc = ecryptfs_init_persistent_file(ecryptfs_dentry); if (rc) {
if (rc) { printk(KERN_ERR "%s: Error attempting to initialize "
printk(KERN_ERR "%s: Error attempting to initialize " "the persistent file for the dentry with name "
"the persistent file for the dentry with name " "[%s]; rc = [%d]\n", __func__,
"[%s]; rc = [%d]\n", __func__, ecryptfs_dentry->d_name.name, rc);
ecryptfs_dentry->d_name.name, rc); goto out_free_kmem;
goto out_free_kmem;
}
} }
crypt_stat = &ecryptfs_inode_to_private( crypt_stat = &ecryptfs_inode_to_private(
ecryptfs_dentry->d_inode)->crypt_stat; ecryptfs_dentry->d_inode)->crypt_stat;

26
fs/ecryptfs/keystore.c
View file

@ -59,7 +59,7 @@ static int process_request_key_err(long err_code)
break; break;
default: default:
ecryptfs_printk(KERN_WARNING, "Unknown error code: " ecryptfs_printk(KERN_WARNING, "Unknown error code: "
"[0x%.16x]\n", err_code); "[0x%.16lx]\n", err_code);
rc = -EINVAL; rc = -EINVAL;
} }
return rc; return rc;
@ -130,7 +130,7 @@ int ecryptfs_write_packet_length(char *dest, size_t size,
} else { } else {
rc = -EINVAL; rc = -EINVAL;
ecryptfs_printk(KERN_WARNING, ecryptfs_printk(KERN_WARNING,
"Unsupported packet size: [%d]\n", size); "Unsupported packet size: [%zd]\n", size);
} }
return rc; return rc;
} }
@ -1672,7 +1672,7 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
auth_tok->session_key.decrypted_key_size); auth_tok->session_key.decrypted_key_size);
crypt_stat->flags |= ECRYPTFS_KEY_VALID; crypt_stat->flags |= ECRYPTFS_KEY_VALID;
if (unlikely(ecryptfs_verbosity > 0)) { if (unlikely(ecryptfs_verbosity > 0)) {
ecryptfs_printk(KERN_DEBUG, "FEK of size [%d]:\n", ecryptfs_printk(KERN_DEBUG, "FEK of size [%zd]:\n",
crypt_stat->key_size); crypt_stat->key_size);
ecryptfs_dump_hex(crypt_stat->key, ecryptfs_dump_hex(crypt_stat->key,
crypt_stat->key_size); crypt_stat->key_size);
@ -1754,7 +1754,7 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) { if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
ecryptfs_printk(KERN_ERR, "Expected " ecryptfs_printk(KERN_ERR, "Expected "
"signature of size [%d]; " "signature of size [%d]; "
"read size [%d]\n", "read size [%zd]\n",
ECRYPTFS_SIG_SIZE, ECRYPTFS_SIG_SIZE,
tag_11_contents_size); tag_11_contents_size);
rc = -EIO; rc = -EIO;
@ -1787,8 +1787,8 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
goto out_wipe_list; goto out_wipe_list;
break; break;
default: default:
ecryptfs_printk(KERN_DEBUG, "No packet at offset " ecryptfs_printk(KERN_DEBUG, "No packet at offset [%zd] "
"[%d] of the file header; hex value of " "of the file header; hex value of "
"character is [0x%.2x]\n", i, src[i]); "character is [0x%.2x]\n", i, src[i]);
next_packet_is_auth_tok_packet = 0; next_packet_is_auth_tok_packet = 0;
} }
@ -1864,8 +1864,8 @@ found_matching_auth_tok:
"session key for authentication token with sig " "session key for authentication token with sig "
"[%.*s]; rc = [%d]. Removing auth tok " "[%.*s]; rc = [%d]. Removing auth tok "
"candidate from the list and searching for " "candidate from the list and searching for "
"the next match.\n", candidate_auth_tok_sig, "the next match.\n", ECRYPTFS_SIG_SIZE_HEX,
ECRYPTFS_SIG_SIZE_HEX, rc); candidate_auth_tok_sig, rc);
list_for_each_entry_safe(auth_tok_list_item, list_for_each_entry_safe(auth_tok_list_item,
auth_tok_list_item_tmp, auth_tok_list_item_tmp,
&auth_tok_list, list) { &auth_tok_list, list) {
@ -2168,7 +2168,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
if (encrypted_session_key_valid) { if (encrypted_session_key_valid) {
ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; " ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; "
"using auth_tok->session_key.encrypted_key, " "using auth_tok->session_key.encrypted_key, "
"where key_rec->enc_key_size = [%d]\n", "where key_rec->enc_key_size = [%zd]\n",
key_rec->enc_key_size); key_rec->enc_key_size);
memcpy(key_rec->enc_key, memcpy(key_rec->enc_key,
auth_tok->session_key.encrypted_key, auth_tok->session_key.encrypted_key,
@ -2198,7 +2198,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
if (rc < 1 || rc > 2) { if (rc < 1 || rc > 2) {
ecryptfs_printk(KERN_ERR, "Error generating scatterlist " ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
"for crypt_stat session key; expected rc = 1; " "for crypt_stat session key; expected rc = 1; "
"got rc = [%d]. key_rec->enc_key_size = [%d]\n", "got rc = [%d]. key_rec->enc_key_size = [%zd]\n",
rc, key_rec->enc_key_size); rc, key_rec->enc_key_size);
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
@ -2209,7 +2209,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
ecryptfs_printk(KERN_ERR, "Error generating scatterlist " ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
"for crypt_stat encrypted session key; " "for crypt_stat encrypted session key; "
"expected rc = 1; got rc = [%d]. " "expected rc = 1; got rc = [%d]. "
"key_rec->enc_key_size = [%d]\n", rc, "key_rec->enc_key_size = [%zd]\n", rc,
key_rec->enc_key_size); key_rec->enc_key_size);
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
@ -2224,7 +2224,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
goto out; goto out;
} }
rc = 0; rc = 0;
ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n", ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the key\n",
crypt_stat->key_size); crypt_stat->key_size);
rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg, rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,
(*key_rec).enc_key_size); (*key_rec).enc_key_size);
@ -2235,7 +2235,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
} }
ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n"); ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
if (ecryptfs_verbosity > 0) { if (ecryptfs_verbosity > 0) {
ecryptfs_printk(KERN_DEBUG, "EFEK of size [%d]:\n", ecryptfs_printk(KERN_DEBUG, "EFEK of size [%zd]:\n",
key_rec->enc_key_size); key_rec->enc_key_size);
ecryptfs_dump_hex(key_rec->enc_key, ecryptfs_dump_hex(key_rec->enc_key,
key_rec->enc_key_size); key_rec->enc_key_size);

9
fs/ecryptfs/main.c
View file

@ -36,6 +36,7 @@
#include <linux/parser.h> #include <linux/parser.h>
#include <linux/fs_stack.h> #include <linux/fs_stack.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/magic.h>
#include "ecryptfs_kernel.h" #include "ecryptfs_kernel.h"
/** /**
@ -564,6 +565,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
ecryptfs_set_superblock_lower(s, path.dentry->d_sb); ecryptfs_set_superblock_lower(s, path.dentry->d_sb);
s->s_maxbytes = path.dentry->d_sb->s_maxbytes; s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
s->s_blocksize = path.dentry->d_sb->s_blocksize; s->s_blocksize = path.dentry->d_sb->s_blocksize;
s->s_magic = ECRYPTFS_SUPER_MAGIC;
inode = ecryptfs_get_inode(path.dentry->d_inode, s); inode = ecryptfs_get_inode(path.dentry->d_inode, s);
rc = PTR_ERR(inode); rc = PTR_ERR(inode);
@ -808,9 +810,10 @@ static int __init ecryptfs_init(void)
ecryptfs_printk(KERN_ERR, "The eCryptfs extent size is " ecryptfs_printk(KERN_ERR, "The eCryptfs extent size is "
"larger than the host's page size, and so " "larger than the host's page size, and so "
"eCryptfs cannot run on this system. The " "eCryptfs cannot run on this system. The "
"default eCryptfs extent size is [%d] bytes; " "default eCryptfs extent size is [%u] bytes; "
"the page size is [%d] bytes.\n", "the page size is [%lu] bytes.\n",
ECRYPTFS_DEFAULT_EXTENT_SIZE, PAGE_CACHE_SIZE); ECRYPTFS_DEFAULT_EXTENT_SIZE,
(unsigned long)PAGE_CACHE_SIZE);
goto out; goto out;
} }
rc = ecryptfs_init_kmem_caches(); rc = ecryptfs_init_kmem_caches();

35
fs/ecryptfs/mmap.c
View file

@ -65,7 +65,7 @@ static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
rc = ecryptfs_encrypt_page(page); rc = ecryptfs_encrypt_page(page);
if (rc) { if (rc) {
ecryptfs_printk(KERN_WARNING, "Error encrypting " ecryptfs_printk(KERN_WARNING, "Error encrypting "
"page (upper index [0x%.16x])\n", page->index); "page (upper index [0x%.16lx])\n", page->index);
ClearPageUptodate(page); ClearPageUptodate(page);
goto out; goto out;
} }
@ -237,7 +237,7 @@ out:
ClearPageUptodate(page); ClearPageUptodate(page);
else else
SetPageUptodate(page); SetPageUptodate(page);
ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n", ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16lx]\n",
page->index); page->index);
unlock_page(page); unlock_page(page);
return rc; return rc;
@ -290,6 +290,7 @@ static int ecryptfs_write_begin(struct file *file,
return -ENOMEM; return -ENOMEM;
*pagep = page; *pagep = page;
prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);
if (!PageUptodate(page)) { if (!PageUptodate(page)) {
struct ecryptfs_crypt_stat *crypt_stat = struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(mapping->host)->crypt_stat; &ecryptfs_inode_to_private(mapping->host)->crypt_stat;
@ -335,18 +336,23 @@ static int ecryptfs_write_begin(struct file *file,
SetPageUptodate(page); SetPageUptodate(page);
} }
} else { } else {
rc = ecryptfs_decrypt_page(page); if (prev_page_end_size
if (rc) { >= i_size_read(page->mapping->host)) {
printk(KERN_ERR "%s: Error decrypting page " zero_user(page, 0, PAGE_CACHE_SIZE);
"at index [%ld]; rc = [%d]\n", } else {
__func__, page->index, rc); rc = ecryptfs_decrypt_page(page);
ClearPageUptodate(page); if (rc) {
goto out; printk(KERN_ERR "%s: Error decrypting "
"page at index [%ld]; "
"rc = [%d]\n",
__func__, page->index, rc);
ClearPageUptodate(page);
goto out;
}
} }
SetPageUptodate(page); SetPageUptodate(page);
} }
} }
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 (index != 0) { if (index != 0) {
@ -488,7 +494,7 @@ static int ecryptfs_write_end(struct file *file,
} 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", index, to); "(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) { if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0, rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
to); to);
@ -503,19 +509,20 @@ static int ecryptfs_write_end(struct file *file,
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", index); "zeros in page with index = [0x%.16lx]\n", 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", index); "index [0x%.16lx])\n", index);
goto out; goto out;
} }
if (pos + copied > i_size_read(ecryptfs_inode)) { if (pos + copied > i_size_read(ecryptfs_inode)) {
i_size_write(ecryptfs_inode, pos + copied); i_size_write(ecryptfs_inode, pos + copied);
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%.16llx]\n",
(unsigned long long)i_size_read(ecryptfs_inode));
} }
rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode); rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
if (rc) if (rc)

1
include/linux/magic.h
View file

@ -16,6 +16,7 @@
#define TMPFS_MAGIC 0x01021994 #define TMPFS_MAGIC 0x01021994
#define HUGETLBFS_MAGIC 0x958458f6 /* some random number */ #define HUGETLBFS_MAGIC 0x958458f6 /* some random number */
#define SQUASHFS_MAGIC 0x73717368 #define SQUASHFS_MAGIC 0x73717368
#define ECRYPTFS_SUPER_MAGIC 0xf15f
#define EFS_SUPER_MAGIC 0x414A53 #define EFS_SUPER_MAGIC 0x414A53
#define EXT2_SUPER_MAGIC 0xEF53 #define EXT2_SUPER_MAGIC 0xEF53
#define EXT3_SUPER_MAGIC 0xEF53 #define EXT3_SUPER_MAGIC 0xEF53