2 * eCryptfs: Linux filesystem encryption layer
3 * This is where eCryptfs coordinates the symmetric encryption and
4 * decryption of the file data as it passes between the lower
5 * encrypted file and the upper decrypted file.
7 * Copyright (C) 1997-2003 Erez Zadok
8 * Copyright (C) 2001-2003 Stony Brook University
9 * Copyright (C) 2004-2007 International Business Machines Corp.
10 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
28 #include <linux/pagemap.h>
29 #include <linux/writeback.h>
30 #include <linux/page-flags.h>
31 #include <linux/mount.h>
32 #include <linux/file.h>
33 #include <linux/crypto.h>
34 #include <linux/scatterlist.h>
35 #include "ecryptfs_kernel.h"
37 struct kmem_cache
*ecryptfs_lower_page_cache
;
42 * Get one page from cache or lower f/s, return error otherwise.
44 * Returns unlocked and up-to-date page (if ok), with increased
47 static struct page
*ecryptfs_get1page(struct file
*file
, int index
)
50 struct dentry
*dentry
;
52 struct address_space
*mapping
;
54 dentry
= file
->f_path
.dentry
;
55 inode
= dentry
->d_inode
;
56 mapping
= inode
->i_mapping
;
57 page
= read_cache_page(mapping
, index
,
58 (filler_t
*)mapping
->a_ops
->readpage
,
62 wait_on_page_locked(page
);
68 int write_zeros(struct file
*file
, pgoff_t index
, int start
, int num_zeros
);
72 * @file: The ecryptfs file
73 * @new_length: The new length of the data in the underlying file;
74 * everything between the prior end of the file and the
75 * new end of the file will be filled with zero's.
76 * new_length must be greater than current length
78 * Function for handling lseek-ing past the end of the file.
80 * This function does not support shrinking, only growing a file.
82 * Returns zero on success; non-zero otherwise.
84 int ecryptfs_fill_zeros(struct file
*file
, loff_t new_length
)
87 struct dentry
*dentry
= file
->f_path
.dentry
;
88 struct inode
*inode
= dentry
->d_inode
;
89 pgoff_t old_end_page_index
= 0;
90 pgoff_t index
= old_end_page_index
;
91 int old_end_pos_in_page
= -1;
92 pgoff_t new_end_page_index
;
93 int new_end_pos_in_page
;
94 loff_t cur_length
= i_size_read(inode
);
96 if (cur_length
!= 0) {
97 index
= old_end_page_index
=
98 ((cur_length
- 1) >> PAGE_CACHE_SHIFT
);
99 old_end_pos_in_page
= ((cur_length
- 1) & ~PAGE_CACHE_MASK
);
101 new_end_page_index
= ((new_length
- 1) >> PAGE_CACHE_SHIFT
);
102 new_end_pos_in_page
= ((new_length
- 1) & ~PAGE_CACHE_MASK
);
103 ecryptfs_printk(KERN_DEBUG
, "old_end_page_index = [0x%.16x]; "
104 "old_end_pos_in_page = [%d]; "
105 "new_end_page_index = [0x%.16x]; "
106 "new_end_pos_in_page = [%d]\n",
107 old_end_page_index
, old_end_pos_in_page
,
108 new_end_page_index
, new_end_pos_in_page
);
109 if (old_end_page_index
== new_end_page_index
) {
110 /* Start and end are in the same page; we just need to
111 * set a portion of the existing page to zero's */
112 rc
= write_zeros(file
, index
, (old_end_pos_in_page
+ 1),
113 (new_end_pos_in_page
- old_end_pos_in_page
));
115 ecryptfs_printk(KERN_ERR
, "write_zeros(file=[%p], "
117 "old_end_pos_in_page=[d], "
118 "(PAGE_CACHE_SIZE - new_end_pos_in_page"
120 ")=[d]) returned [%d]\n", file
, index
,
123 (PAGE_CACHE_SIZE
- new_end_pos_in_page
),
127 /* Fill the remainder of the previous last page with zeros */
128 rc
= write_zeros(file
, index
, (old_end_pos_in_page
+ 1),
129 ((PAGE_CACHE_SIZE
- 1) - old_end_pos_in_page
));
131 ecryptfs_printk(KERN_ERR
, "write_zeros(file=[%p], "
132 "index=[0x%.16x], old_end_pos_in_page=[d], "
133 "(PAGE_CACHE_SIZE - old_end_pos_in_page)=[d]) "
134 "returned [%d]\n", file
, index
,
136 (PAGE_CACHE_SIZE
- old_end_pos_in_page
), rc
);
140 while (index
< new_end_page_index
) {
141 /* Fill all intermediate pages with zeros */
142 rc
= write_zeros(file
, index
, 0, PAGE_CACHE_SIZE
);
144 ecryptfs_printk(KERN_ERR
, "write_zeros(file=[%p], "
146 "old_end_pos_in_page=[d], "
147 "(PAGE_CACHE_SIZE - new_end_pos_in_page"
149 ")=[d]) returned [%d]\n", file
, index
,
152 (PAGE_CACHE_SIZE
- new_end_pos_in_page
),
158 /* Fill the portion at the beginning of the last new page with
160 rc
= write_zeros(file
, index
, 0, (new_end_pos_in_page
+ 1));
162 ecryptfs_printk(KERN_ERR
, "write_zeros(file="
163 "[%p], index=[0x%.16x], 0, "
164 "new_end_pos_in_page=[%d]"
165 "returned [%d]\n", file
, index
,
166 new_end_pos_in_page
, rc
);
175 * @page: Page that is locked before this call is made
177 * Returns zero on success; non-zero otherwise
179 static int ecryptfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
181 struct ecryptfs_page_crypt_context ctx
;
185 ctx
.mode
= ECRYPTFS_WRITEPAGE_MODE
;
187 rc
= ecryptfs_encrypt_page(&ctx
);
189 ecryptfs_printk(KERN_WARNING
, "Error encrypting "
190 "page (upper index [0x%.16x])\n", page
->index
);
191 ClearPageUptodate(page
);
194 SetPageUptodate(page
);
201 * Reads the data from the lower file file at index lower_page_index
202 * and copies that data into page.
204 * @param page Page to fill
205 * @param lower_page_index Index of the page in the lower file to get
207 int ecryptfs_do_readpage(struct file
*file
, struct page
*page
,
208 pgoff_t lower_page_index
)
211 struct dentry
*dentry
;
212 struct file
*lower_file
;
213 struct dentry
*lower_dentry
;
215 struct inode
*lower_inode
;
217 struct page
*lower_page
= NULL
;
218 char *lower_page_data
;
219 const struct address_space_operations
*lower_a_ops
;
221 dentry
= file
->f_path
.dentry
;
222 lower_file
= ecryptfs_file_to_lower(file
);
223 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
224 inode
= dentry
->d_inode
;
225 lower_inode
= ecryptfs_inode_to_lower(inode
);
226 lower_a_ops
= lower_inode
->i_mapping
->a_ops
;
227 lower_page
= read_cache_page(lower_inode
->i_mapping
, lower_page_index
,
228 (filler_t
*)lower_a_ops
->readpage
,
230 if (IS_ERR(lower_page
)) {
231 rc
= PTR_ERR(lower_page
);
233 ecryptfs_printk(KERN_ERR
, "Error reading from page cache\n");
236 wait_on_page_locked(lower_page
);
237 page_data
= kmap_atomic(page
, KM_USER0
);
238 lower_page_data
= kmap_atomic(lower_page
, KM_USER1
);
239 memcpy(page_data
, lower_page_data
, PAGE_CACHE_SIZE
);
240 kunmap_atomic(lower_page_data
, KM_USER1
);
241 kunmap_atomic(page_data
, KM_USER0
);
242 flush_dcache_page(page
);
245 if (likely(lower_page
))
246 page_cache_release(lower_page
);
248 SetPageUptodate(page
);
250 ClearPageUptodate(page
);
255 * Octets 0-7: Unencrypted file size (big-endian)
256 * Octets 8-15: eCryptfs special marker
257 * Octets 16-19: Flags
258 * Octet 16: File format version number (between 0 and 255)
259 * Octets 17-18: Reserved
260 * Octet 19: Bit 1 (lsb): Reserved
263 * Octets 20-23: Header extent size (big-endian)
264 * Octets 24-25: Number of header extents at front of file
266 * Octet 26: Begin RFC 2440 authentication token packet set
268 static void set_header_info(char *page_virt
,
269 struct ecryptfs_crypt_stat
*crypt_stat
)
272 int save_num_header_extents_at_front
=
273 crypt_stat
->num_header_extents_at_front
;
275 crypt_stat
->num_header_extents_at_front
= 1;
276 ecryptfs_write_header_metadata(page_virt
+ 20, crypt_stat
, &written
);
277 crypt_stat
->num_header_extents_at_front
=
278 save_num_header_extents_at_front
;
283 * @file: This is an ecryptfs file
284 * @page: ecryptfs associated page to stick the read data into
286 * Read in a page, decrypting if necessary.
288 * Returns zero on success; non-zero on error.
290 static int ecryptfs_readpage(struct file
*file
, struct page
*page
)
293 struct ecryptfs_crypt_stat
*crypt_stat
;
295 BUG_ON(!(file
&& file
->f_path
.dentry
&& file
->f_path
.dentry
->d_inode
));
296 crypt_stat
= &ecryptfs_inode_to_private(file
->f_path
.dentry
->d_inode
)
299 || !(crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
)
300 || (crypt_stat
->flags
& ECRYPTFS_NEW_FILE
)) {
301 ecryptfs_printk(KERN_DEBUG
,
302 "Passing through unencrypted page\n");
303 rc
= ecryptfs_do_readpage(file
, page
, page
->index
);
305 ecryptfs_printk(KERN_ERR
, "Error reading page; rc = "
309 } else if (crypt_stat
->flags
& ECRYPTFS_VIEW_AS_ENCRYPTED
) {
310 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
) {
311 int num_pages_in_header_region
=
312 (crypt_stat
->header_extent_size
315 if (page
->index
< num_pages_in_header_region
) {
318 page_virt
= kmap_atomic(page
, KM_USER0
);
319 memset(page_virt
, 0, PAGE_CACHE_SIZE
);
320 if (page
->index
== 0) {
321 rc
= ecryptfs_read_xattr_region(
322 page_virt
, file
->f_path
.dentry
);
323 set_header_info(page_virt
, crypt_stat
);
325 kunmap_atomic(page_virt
, KM_USER0
);
326 flush_dcache_page(page
);
328 printk(KERN_ERR
"Error reading xattr "
333 rc
= ecryptfs_do_readpage(
336 - num_pages_in_header_region
));
338 printk(KERN_ERR
"Error reading page; "
344 rc
= ecryptfs_do_readpage(file
, page
, page
->index
);
346 printk(KERN_ERR
"Error reading page; rc = "
352 rc
= ecryptfs_decrypt_page(file
, page
);
354 ecryptfs_printk(KERN_ERR
, "Error decrypting page; "
359 SetPageUptodate(page
);
362 ClearPageUptodate(page
);
363 ecryptfs_printk(KERN_DEBUG
, "Unlocking page with index = [0x%.16x]\n",
370 * Called with lower inode mutex held.
372 static int fill_zeros_to_end_of_page(struct page
*page
, unsigned int to
)
374 struct inode
*inode
= page
->mapping
->host
;
375 int end_byte_in_page
;
378 if ((i_size_read(inode
) / PAGE_CACHE_SIZE
) != page
->index
)
380 end_byte_in_page
= i_size_read(inode
) % PAGE_CACHE_SIZE
;
381 if (to
> end_byte_in_page
)
382 end_byte_in_page
= to
;
383 page_virt
= kmap_atomic(page
, KM_USER0
);
384 memset((page_virt
+ end_byte_in_page
), 0,
385 (PAGE_CACHE_SIZE
- end_byte_in_page
));
386 kunmap_atomic(page_virt
, KM_USER0
);
387 flush_dcache_page(page
);
392 static int ecryptfs_prepare_write(struct file
*file
, struct page
*page
,
393 unsigned from
, unsigned to
)
397 if (from
== 0 && to
== PAGE_CACHE_SIZE
)
398 goto out
; /* If we are writing a full page, it will be
400 if (!PageUptodate(page
))
401 rc
= ecryptfs_do_readpage(file
, page
, page
->index
);
406 int ecryptfs_writepage_and_release_lower_page(struct page
*lower_page
,
407 struct inode
*lower_inode
,
408 struct writeback_control
*wbc
)
412 rc
= lower_inode
->i_mapping
->a_ops
->writepage(lower_page
, wbc
);
414 ecryptfs_printk(KERN_ERR
, "Error calling lower writepage(); "
418 lower_inode
->i_mtime
= lower_inode
->i_ctime
= CURRENT_TIME
;
419 page_cache_release(lower_page
);
425 void ecryptfs_release_lower_page(struct page
*lower_page
, int page_locked
)
428 unlock_page(lower_page
);
429 page_cache_release(lower_page
);
433 * ecryptfs_write_inode_size_to_header
435 * Writes the lower file size to the first 8 bytes of the header.
437 * Returns zero on success; non-zero on error.
439 static int ecryptfs_write_inode_size_to_header(struct file
*lower_file
,
440 struct inode
*lower_inode
,
444 struct page
*header_page
;
446 const struct address_space_operations
*lower_a_ops
;
449 header_page
= grab_cache_page(lower_inode
->i_mapping
, 0);
451 ecryptfs_printk(KERN_ERR
, "grab_cache_page for "
452 "lower_page_index 0 failed\n");
456 lower_a_ops
= lower_inode
->i_mapping
->a_ops
;
457 rc
= lower_a_ops
->prepare_write(lower_file
, header_page
, 0, 8);
459 if (rc
== AOP_TRUNCATED_PAGE
)
460 ecryptfs_release_lower_page(header_page
, 0);
462 ecryptfs_release_lower_page(header_page
, 1);
465 file_size
= (u64
)i_size_read(inode
);
466 ecryptfs_printk(KERN_DEBUG
, "Writing size: [0x%.16x]\n", file_size
);
467 file_size
= cpu_to_be64(file_size
);
468 header_virt
= kmap_atomic(header_page
, KM_USER0
);
469 memcpy(header_virt
, &file_size
, sizeof(u64
));
470 kunmap_atomic(header_virt
, KM_USER0
);
471 flush_dcache_page(header_page
);
472 rc
= lower_a_ops
->commit_write(lower_file
, header_page
, 0, 8);
474 ecryptfs_printk(KERN_ERR
, "Error commiting header page "
476 if (rc
== AOP_TRUNCATED_PAGE
)
477 ecryptfs_release_lower_page(header_page
, 0);
479 ecryptfs_release_lower_page(header_page
, 1);
480 lower_inode
->i_mtime
= lower_inode
->i_ctime
= CURRENT_TIME
;
481 mark_inode_dirty_sync(inode
);
486 static int ecryptfs_write_inode_size_to_xattr(struct inode
*lower_inode
,
488 struct dentry
*ecryptfs_dentry
,
489 int lower_i_mutex_held
)
493 struct dentry
*lower_dentry
;
497 xattr_virt
= kmem_cache_alloc(ecryptfs_xattr_cache
, GFP_KERNEL
);
499 printk(KERN_ERR
"Out of memory whilst attempting to write "
500 "inode size to xattr\n");
504 lower_dentry
= ecryptfs_dentry_to_lower(ecryptfs_dentry
);
505 if (!lower_dentry
->d_inode
->i_op
->getxattr
) {
507 "No support for setting xattr in lower filesystem\n");
509 kmem_cache_free(ecryptfs_xattr_cache
, xattr_virt
);
512 if (!lower_i_mutex_held
)
513 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
514 size
= lower_dentry
->d_inode
->i_op
->getxattr(lower_dentry
,
518 if (!lower_i_mutex_held
)
519 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
522 file_size
= (u64
)i_size_read(inode
);
523 file_size
= cpu_to_be64(file_size
);
524 memcpy(xattr_virt
, &file_size
, sizeof(u64
));
525 if (!lower_i_mutex_held
)
526 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
527 rc
= lower_dentry
->d_inode
->i_op
->setxattr(lower_dentry
,
529 xattr_virt
, size
, 0);
530 if (!lower_i_mutex_held
)
531 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
533 printk(KERN_ERR
"Error whilst attempting to write inode size "
534 "to lower file xattr; rc = [%d]\n", rc
);
535 kmem_cache_free(ecryptfs_xattr_cache
, xattr_virt
);
541 ecryptfs_write_inode_size_to_metadata(struct file
*lower_file
,
542 struct inode
*lower_inode
,
544 struct dentry
*ecryptfs_dentry
,
545 int lower_i_mutex_held
)
547 struct ecryptfs_crypt_stat
*crypt_stat
;
549 crypt_stat
= &ecryptfs_inode_to_private(inode
)->crypt_stat
;
550 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
)
551 return ecryptfs_write_inode_size_to_xattr(lower_inode
, inode
,
555 return ecryptfs_write_inode_size_to_header(lower_file
,
560 int ecryptfs_get_lower_page(struct page
**lower_page
, struct inode
*lower_inode
,
561 struct file
*lower_file
,
562 unsigned long lower_page_index
, int byte_offset
,
567 *lower_page
= grab_cache_page(lower_inode
->i_mapping
, lower_page_index
);
568 if (!(*lower_page
)) {
570 ecryptfs_printk(KERN_ERR
, "Error attempting to grab "
571 "lower page with index [0x%.16x]\n",
575 rc
= lower_inode
->i_mapping
->a_ops
->prepare_write(lower_file
,
580 ecryptfs_printk(KERN_ERR
, "prepare_write for "
581 "lower_page_index = [0x%.16x] failed; rc = "
582 "[%d]\n", lower_page_index
, rc
);
585 if (rc
&& (*lower_page
)) {
586 if (rc
== AOP_TRUNCATED_PAGE
)
587 ecryptfs_release_lower_page(*lower_page
, 0);
589 ecryptfs_release_lower_page(*lower_page
, 1);
590 (*lower_page
) = NULL
;
596 * ecryptfs_commit_lower_page
598 * Returns zero on success; non-zero on error
601 ecryptfs_commit_lower_page(struct page
*lower_page
, struct inode
*lower_inode
,
602 struct file
*lower_file
, int byte_offset
,
608 rc
= lower_inode
->i_mapping
->a_ops
->commit_write(
609 lower_file
, lower_page
, byte_offset
, region_size
);
610 if (rc
== AOP_TRUNCATED_PAGE
)
613 ecryptfs_printk(KERN_ERR
,
614 "Error committing write; rc = [%d]\n", rc
);
617 ecryptfs_release_lower_page(lower_page
, page_locked
);
622 * ecryptfs_copy_page_to_lower
624 * Used for plaintext pass-through; no page index interpolation
627 int ecryptfs_copy_page_to_lower(struct page
*page
, struct inode
*lower_inode
,
628 struct file
*lower_file
)
631 struct page
*lower_page
;
633 rc
= ecryptfs_get_lower_page(&lower_page
, lower_inode
, lower_file
,
634 page
->index
, 0, PAGE_CACHE_SIZE
);
636 ecryptfs_printk(KERN_ERR
, "Error attempting to get page "
637 "at index [0x%.16x]\n", page
->index
);
641 memcpy((char *)page_address(lower_page
), page_address(page
),
643 rc
= ecryptfs_commit_lower_page(lower_page
, lower_inode
, lower_file
,
646 ecryptfs_printk(KERN_ERR
, "Error attempting to commit page "
647 "at index [0x%.16x]\n", page
->index
);
652 struct kmem_cache
*ecryptfs_xattr_cache
;
655 * ecryptfs_commit_write
656 * @file: The eCryptfs file object
657 * @page: The eCryptfs page
658 * @from: Ignored (we rotate the page IV on each write)
661 * This is where we encrypt the data and pass the encrypted data to
662 * the lower filesystem. In OpenPGP-compatible mode, we operate on
663 * entire underlying packets.
665 static int ecryptfs_commit_write(struct file
*file
, struct page
*page
,
666 unsigned from
, unsigned to
)
668 struct ecryptfs_page_crypt_context ctx
;
671 struct inode
*lower_inode
;
672 struct file
*lower_file
;
673 struct ecryptfs_crypt_stat
*crypt_stat
;
676 inode
= page
->mapping
->host
;
677 lower_inode
= ecryptfs_inode_to_lower(inode
);
678 lower_file
= ecryptfs_file_to_lower(file
);
679 mutex_lock(&lower_inode
->i_mutex
);
680 crypt_stat
= &ecryptfs_inode_to_private(file
->f_path
.dentry
->d_inode
)
682 if (crypt_stat
->flags
& ECRYPTFS_NEW_FILE
) {
683 ecryptfs_printk(KERN_DEBUG
, "ECRYPTFS_NEW_FILE flag set in "
684 "crypt_stat at memory location [%p]\n", crypt_stat
);
685 crypt_stat
->flags
&= ~(ECRYPTFS_NEW_FILE
);
687 ecryptfs_printk(KERN_DEBUG
, "Not a new file\n");
688 ecryptfs_printk(KERN_DEBUG
, "Calling fill_zeros_to_end_of_page"
689 "(page w/ index = [0x%.16x], to = [%d])\n", page
->index
,
691 rc
= fill_zeros_to_end_of_page(page
, to
);
693 ecryptfs_printk(KERN_WARNING
, "Error attempting to fill "
694 "zeros in page with index = [0x%.16x]\n",
699 ctx
.mode
= ECRYPTFS_PREPARE_COMMIT_MODE
;
700 ctx
.param
.lower_file
= lower_file
;
701 rc
= ecryptfs_encrypt_page(&ctx
);
703 ecryptfs_printk(KERN_WARNING
, "Error encrypting page (upper "
704 "index [0x%.16x])\n", page
->index
);
707 inode
->i_blocks
= lower_inode
->i_blocks
;
708 pos
= (page
->index
<< PAGE_CACHE_SHIFT
) + to
;
709 if (pos
> i_size_read(inode
)) {
710 i_size_write(inode
, pos
);
711 ecryptfs_printk(KERN_DEBUG
, "Expanded file size to "
712 "[0x%.16x]\n", i_size_read(inode
));
714 rc
= ecryptfs_write_inode_size_to_metadata(lower_file
, lower_inode
,
715 inode
, file
->f_dentry
,
716 ECRYPTFS_LOWER_I_MUTEX_HELD
);
718 printk(KERN_ERR
"Error writing inode size to metadata; "
720 lower_inode
->i_mtime
= lower_inode
->i_ctime
= CURRENT_TIME
;
721 mark_inode_dirty_sync(inode
);
724 ClearPageUptodate(page
);
726 SetPageUptodate(page
);
727 mutex_unlock(&lower_inode
->i_mutex
);
733 * @file: The ecryptfs file
734 * @index: The index in which we are writing
735 * @start: The position after the last block of data
736 * @num_zeros: The number of zeros to write
738 * Write a specified number of zero's to a page.
740 * (start + num_zeros) must be less than or equal to PAGE_CACHE_SIZE
743 int write_zeros(struct file
*file
, pgoff_t index
, int start
, int num_zeros
)
746 struct page
*tmp_page
;
749 tmp_page
= ecryptfs_get1page(file
, index
);
750 if (IS_ERR(tmp_page
)) {
751 ecryptfs_printk(KERN_ERR
, "Error getting page at index "
752 "[0x%.16x]\n", index
);
753 rc
= PTR_ERR(tmp_page
);
756 rc
= ecryptfs_prepare_write(file
, tmp_page
, start
, start
+ num_zeros
);
758 ecryptfs_printk(KERN_ERR
, "Error preparing to write zero's "
759 "to remainder of page at index [0x%.16x]\n",
761 page_cache_release(tmp_page
);
764 tmp_page_virt
= kmap_atomic(tmp_page
, KM_USER0
);
765 memset(((char *)tmp_page_virt
+ start
), 0, num_zeros
);
766 kunmap_atomic(tmp_page_virt
, KM_USER0
);
767 flush_dcache_page(tmp_page
);
768 rc
= ecryptfs_commit_write(file
, tmp_page
, start
, start
+ num_zeros
);
770 ecryptfs_printk(KERN_ERR
, "Error attempting to write zero's "
771 "to remainder of page at index [0x%.16x]\n",
773 page_cache_release(tmp_page
);
777 page_cache_release(tmp_page
);
782 static sector_t
ecryptfs_bmap(struct address_space
*mapping
, sector_t block
)
786 struct inode
*lower_inode
;
788 inode
= (struct inode
*)mapping
->host
;
789 lower_inode
= ecryptfs_inode_to_lower(inode
);
790 if (lower_inode
->i_mapping
->a_ops
->bmap
)
791 rc
= lower_inode
->i_mapping
->a_ops
->bmap(lower_inode
->i_mapping
,
796 static void ecryptfs_sync_page(struct page
*page
)
799 struct inode
*lower_inode
;
800 struct page
*lower_page
;
802 inode
= page
->mapping
->host
;
803 lower_inode
= ecryptfs_inode_to_lower(inode
);
804 /* NOTE: Recently swapped with grab_cache_page(), since
805 * sync_page() just makes sure that pending I/O gets done. */
806 lower_page
= find_lock_page(lower_inode
->i_mapping
, page
->index
);
808 ecryptfs_printk(KERN_DEBUG
, "find_lock_page failed\n");
811 lower_page
->mapping
->a_ops
->sync_page(lower_page
);
812 ecryptfs_printk(KERN_DEBUG
, "Unlocking page with index = [0x%.16x]\n",
814 unlock_page(lower_page
);
815 page_cache_release(lower_page
);
818 struct address_space_operations ecryptfs_aops
= {
819 .writepage
= ecryptfs_writepage
,
820 .readpage
= ecryptfs_readpage
,
821 .prepare_write
= ecryptfs_prepare_write
,
822 .commit_write
= ecryptfs_commit_write
,
823 .bmap
= ecryptfs_bmap
,
824 .sync_page
= ecryptfs_sync_page
,