2 * eCryptfs: Linux filesystem encryption layer
4 * Copyright (C) 2007 International Business Machines Corp.
5 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 #include <linux/pagemap.h>
25 #include "ecryptfs_kernel.h"
28 * ecryptfs_write_lower
29 * @ecryptfs_inode: The eCryptfs inode
30 * @data: Data to write
31 * @offset: Byte offset in the lower file to which to write the data
32 * @size: Number of bytes from @data to write at @offset in the lower
35 * Write data to the lower file.
37 * Returns bytes written on success; less than zero on error
39 int ecryptfs_write_lower(struct inode
*ecryptfs_inode
, char *data
,
40 loff_t offset
, size_t size
)
42 struct ecryptfs_inode_info
*inode_info
;
46 inode_info
= ecryptfs_inode_to_private(ecryptfs_inode
);
47 mutex_lock(&inode_info
->lower_file_mutex
);
48 BUG_ON(!inode_info
->lower_file
);
49 inode_info
->lower_file
->f_pos
= offset
;
52 rc
= vfs_write(inode_info
->lower_file
, data
, size
,
53 &inode_info
->lower_file
->f_pos
);
55 mutex_unlock(&inode_info
->lower_file_mutex
);
56 mark_inode_dirty_sync(ecryptfs_inode
);
61 * ecryptfs_write_lower_page_segment
62 * @ecryptfs_inode: The eCryptfs inode
63 * @page_for_lower: The page containing the data to be written to the
65 * @offset_in_page: The offset in the @page_for_lower from which to
66 * start writing the data
67 * @size: The amount of data from @page_for_lower to write to the
70 * Determines the byte offset in the file for the given page and
71 * offset within the page, maps the page, and makes the call to write
72 * the contents of @page_for_lower to the lower inode.
74 * Returns zero on success; non-zero otherwise
76 int ecryptfs_write_lower_page_segment(struct inode
*ecryptfs_inode
,
77 struct page
*page_for_lower
,
78 size_t offset_in_page
, size_t size
)
84 offset
= ((((loff_t
)page_for_lower
->index
) << PAGE_CACHE_SHIFT
)
86 virt
= kmap(page_for_lower
);
87 rc
= ecryptfs_write_lower(ecryptfs_inode
, virt
, offset
, size
);
90 kunmap(page_for_lower
);
96 * @ecryptfs_file: The eCryptfs file into which to write
97 * @data: Virtual address where data to write is located
98 * @offset: Offset in the eCryptfs file at which to begin writing the
100 * @size: The number of bytes to write from @data
102 * Write an arbitrary amount of data to an arbitrary location in the
103 * eCryptfs inode page cache. This is done on a page-by-page, and then
104 * by an extent-by-extent, basis; individual extents are encrypted and
105 * written to the lower page cache (via VFS writes). This function
106 * takes care of all the address translation to locations in the lower
107 * filesystem; it also handles truncate events, writing out zeros
110 * Returns zero on success; non-zero otherwise
112 int ecryptfs_write(struct file
*ecryptfs_file
, char *data
, loff_t offset
,
115 struct page
*ecryptfs_page
;
116 struct ecryptfs_crypt_stat
*crypt_stat
;
117 struct inode
*ecryptfs_inode
= ecryptfs_file
->f_dentry
->d_inode
;
118 char *ecryptfs_page_virt
;
119 loff_t ecryptfs_file_size
= i_size_read(ecryptfs_inode
);
120 loff_t data_offset
= 0;
124 crypt_stat
= &ecryptfs_inode_to_private(ecryptfs_inode
)->crypt_stat
;
126 * if we are writing beyond current size, then start pos
127 * at the current size - we'll fill in zeros from there.
129 if (offset
> ecryptfs_file_size
)
130 pos
= ecryptfs_file_size
;
133 while (pos
< (offset
+ size
)) {
134 pgoff_t ecryptfs_page_idx
= (pos
>> PAGE_CACHE_SHIFT
);
135 size_t start_offset_in_page
= (pos
& ~PAGE_CACHE_MASK
);
136 size_t num_bytes
= (PAGE_CACHE_SIZE
- start_offset_in_page
);
137 size_t total_remaining_bytes
= ((offset
+ size
) - pos
);
139 if (fatal_signal_pending(current
)) {
144 if (num_bytes
> total_remaining_bytes
)
145 num_bytes
= total_remaining_bytes
;
147 /* remaining zeros to write, up to destination offset */
148 size_t total_remaining_zeros
= (offset
- pos
);
150 if (num_bytes
> total_remaining_zeros
)
151 num_bytes
= total_remaining_zeros
;
153 ecryptfs_page
= ecryptfs_get_locked_page(ecryptfs_file
,
155 if (IS_ERR(ecryptfs_page
)) {
156 rc
= PTR_ERR(ecryptfs_page
);
157 printk(KERN_ERR
"%s: Error getting page at "
158 "index [%ld] from eCryptfs inode "
159 "mapping; rc = [%d]\n", __func__
,
160 ecryptfs_page_idx
, rc
);
163 ecryptfs_page_virt
= kmap_atomic(ecryptfs_page
, KM_USER0
);
166 * pos: where we're now writing, offset: where the request was
167 * If current pos is before request, we are filling zeros
168 * If we are at or beyond request, we are writing the *data*
169 * If we're in a fresh page beyond eof, zero it in either case
171 if (pos
< offset
|| !start_offset_in_page
) {
172 /* We are extending past the previous end of the file.
173 * Fill in zero values to the end of the page */
174 memset(((char *)ecryptfs_page_virt
175 + start_offset_in_page
), 0,
176 PAGE_CACHE_SIZE
- start_offset_in_page
);
179 /* pos >= offset, we are now writing the data request */
181 memcpy(((char *)ecryptfs_page_virt
182 + start_offset_in_page
),
183 (data
+ data_offset
), num_bytes
);
184 data_offset
+= num_bytes
;
186 kunmap_atomic(ecryptfs_page_virt
, KM_USER0
);
187 flush_dcache_page(ecryptfs_page
);
188 SetPageUptodate(ecryptfs_page
);
189 unlock_page(ecryptfs_page
);
190 if (crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
)
191 rc
= ecryptfs_encrypt_page(ecryptfs_page
);
193 rc
= ecryptfs_write_lower_page_segment(ecryptfs_inode
,
195 start_offset_in_page
,
197 page_cache_release(ecryptfs_page
);
199 printk(KERN_ERR
"%s: Error encrypting "
200 "page; rc = [%d]\n", __func__
, rc
);
205 if (pos
> ecryptfs_file_size
) {
206 i_size_write(ecryptfs_inode
, pos
);
207 if (crypt_stat
->flags
& ECRYPTFS_ENCRYPTED
) {
210 rc2
= ecryptfs_write_inode_size_to_metadata(
213 printk(KERN_ERR
"Problem with "
214 "ecryptfs_write_inode_size_to_metadata; "
227 * ecryptfs_read_lower
228 * @data: The read data is stored here by this function
229 * @offset: Byte offset in the lower file from which to read the data
230 * @size: Number of bytes to read from @offset of the lower file and
232 * @ecryptfs_inode: The eCryptfs inode
234 * Read @size bytes of data at byte offset @offset from the lower
235 * inode into memory location @data.
237 * Returns bytes read on success; 0 on EOF; less than zero on error
239 int ecryptfs_read_lower(char *data
, loff_t offset
, size_t size
,
240 struct inode
*ecryptfs_inode
)
242 struct ecryptfs_inode_info
*inode_info
=
243 ecryptfs_inode_to_private(ecryptfs_inode
);
244 mm_segment_t fs_save
;
247 mutex_lock(&inode_info
->lower_file_mutex
);
248 BUG_ON(!inode_info
->lower_file
);
249 inode_info
->lower_file
->f_pos
= offset
;
252 rc
= vfs_read(inode_info
->lower_file
, data
, size
,
253 &inode_info
->lower_file
->f_pos
);
255 mutex_unlock(&inode_info
->lower_file_mutex
);
260 * ecryptfs_read_lower_page_segment
261 * @page_for_ecryptfs: The page into which data for eCryptfs will be
263 * @offset_in_page: Offset in @page_for_ecryptfs from which to start
265 * @size: The number of bytes to write into @page_for_ecryptfs
266 * @ecryptfs_inode: The eCryptfs inode
268 * Determines the byte offset in the file for the given page and
269 * offset within the page, maps the page, and makes the call to read
270 * the contents of @page_for_ecryptfs from the lower inode.
272 * Returns zero on success; non-zero otherwise
274 int ecryptfs_read_lower_page_segment(struct page
*page_for_ecryptfs
,
276 size_t offset_in_page
, size_t size
,
277 struct inode
*ecryptfs_inode
)
283 offset
= ((((loff_t
)page_index
) << PAGE_CACHE_SHIFT
) + offset_in_page
);
284 virt
= kmap(page_for_ecryptfs
);
285 rc
= ecryptfs_read_lower(virt
, offset
, size
, ecryptfs_inode
);
288 kunmap(page_for_ecryptfs
);
289 flush_dcache_page(page_for_ecryptfs
);
296 * @data: The virtual address into which to write the data read (and
297 * possibly decrypted) from the lower file
298 * @offset: The offset in the decrypted view of the file from which to
300 * @size: The number of bytes to read into @data
301 * @ecryptfs_file: The eCryptfs file from which to read
303 * Read an arbitrary amount of data from an arbitrary location in the
304 * eCryptfs page cache. This is done on an extent-by-extent basis;
305 * individual extents are decrypted and read from the lower page
306 * cache (via VFS reads). This function takes care of all the
307 * address translation to locations in the lower filesystem.
309 * Returns zero on success; non-zero otherwise
311 int ecryptfs_read(char *data
, loff_t offset
, size_t size
,
312 struct file
*ecryptfs_file
)
314 struct page
*ecryptfs_page
;
315 char *ecryptfs_page_virt
;
316 loff_t ecryptfs_file_size
=
317 i_size_read(ecryptfs_file
->f_dentry
->d_inode
);
318 loff_t data_offset
= 0;
322 if ((offset
+ size
) > ecryptfs_file_size
) {
324 printk(KERN_ERR
"%s: Attempt to read data past the end of the "
325 "file; offset = [%lld]; size = [%td]; "
326 "ecryptfs_file_size = [%lld]\n",
327 __func__
, offset
, size
, ecryptfs_file_size
);
331 while (pos
< (offset
+ size
)) {
332 pgoff_t ecryptfs_page_idx
= (pos
>> PAGE_CACHE_SHIFT
);
333 size_t start_offset_in_page
= (pos
& ~PAGE_CACHE_MASK
);
334 size_t num_bytes
= (PAGE_CACHE_SIZE
- start_offset_in_page
);
335 size_t total_remaining_bytes
= ((offset
+ size
) - pos
);
337 if (num_bytes
> total_remaining_bytes
)
338 num_bytes
= total_remaining_bytes
;
339 ecryptfs_page
= ecryptfs_get_locked_page(ecryptfs_file
,
341 if (IS_ERR(ecryptfs_page
)) {
342 rc
= PTR_ERR(ecryptfs_page
);
343 printk(KERN_ERR
"%s: Error getting page at "
344 "index [%ld] from eCryptfs inode "
345 "mapping; rc = [%d]\n", __func__
,
346 ecryptfs_page_idx
, rc
);
349 ecryptfs_page_virt
= kmap_atomic(ecryptfs_page
, KM_USER0
);
350 memcpy((data
+ data_offset
),
351 ((char *)ecryptfs_page_virt
+ start_offset_in_page
),
353 kunmap_atomic(ecryptfs_page_virt
, KM_USER0
);
354 flush_dcache_page(ecryptfs_page
);
355 SetPageUptodate(ecryptfs_page
);
356 unlock_page(ecryptfs_page
);
357 page_cache_release(ecryptfs_page
);
359 data_offset
+= num_bytes
;