1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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 <asm/unaligned.h>
36#include "ecryptfs_kernel.h"
37
38
39
40
41
42
43
44
45
46struct page *ecryptfs_get_locked_page(struct file *file, loff_t index)
47{
48 struct dentry *dentry;
49 struct inode *inode;
50 struct address_space *mapping;
51 struct page *page;
52
53 dentry = file->f_path.dentry;
54 inode = dentry->d_inode;
55 mapping = inode->i_mapping;
56 page = read_mapping_page(mapping, index, (void *)file);
57 if (!IS_ERR(page))
58 lock_page(page);
59 return page;
60}
61
62
63
64
65
66
67
68static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
69{
70 int rc;
71
72 rc = ecryptfs_encrypt_page(page);
73 if (rc) {
74 ecryptfs_printk(KERN_WARNING, "Error encrypting "
75 "page (upper index [0x%.16x])\n", page->index);
76 ClearPageUptodate(page);
77 goto out;
78 }
79 SetPageUptodate(page);
80 unlock_page(page);
81out:
82 return rc;
83}
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100static void set_header_info(char *page_virt,
101 struct ecryptfs_crypt_stat *crypt_stat)
102{
103 size_t written;
104 size_t save_num_header_bytes_at_front =
105 crypt_stat->num_header_bytes_at_front;
106
107 crypt_stat->num_header_bytes_at_front =
108 ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
109 ecryptfs_write_header_metadata(page_virt + 20, crypt_stat, &written);
110 crypt_stat->num_header_bytes_at_front =
111 save_num_header_bytes_at_front;
112}
113
114
115
116
117
118
119
120
121
122
123
124static int
125ecryptfs_copy_up_encrypted_with_header(struct page *page,
126 struct ecryptfs_crypt_stat *crypt_stat)
127{
128 loff_t extent_num_in_page = 0;
129 loff_t num_extents_per_page = (PAGE_CACHE_SIZE
130 / crypt_stat->extent_size);
131 int rc = 0;
132
133 while (extent_num_in_page < num_extents_per_page) {
134 loff_t view_extent_num = ((((loff_t)page->index)
135 * num_extents_per_page)
136 + extent_num_in_page);
137 size_t num_header_extents_at_front =
138 (crypt_stat->num_header_bytes_at_front
139 / crypt_stat->extent_size);
140
141 if (view_extent_num < num_header_extents_at_front) {
142
143 char *page_virt;
144
145 page_virt = kmap_atomic(page, KM_USER0);
146 memset(page_virt, 0, PAGE_CACHE_SIZE);
147
148 if (view_extent_num == 0) {
149 rc = ecryptfs_read_xattr_region(
150 page_virt, page->mapping->host);
151 set_header_info(page_virt, crypt_stat);
152 }
153 kunmap_atomic(page_virt, KM_USER0);
154 flush_dcache_page(page);
155 if (rc) {
156 printk(KERN_ERR "%s: Error reading xattr "
157 "region; rc = [%d]\n", __func__, rc);
158 goto out;
159 }
160 } else {
161
162 loff_t lower_offset =
163 ((view_extent_num * crypt_stat->extent_size)
164 - crypt_stat->num_header_bytes_at_front);
165
166 rc = ecryptfs_read_lower_page_segment(
167 page, (lower_offset >> PAGE_CACHE_SHIFT),
168 (lower_offset & ~PAGE_CACHE_MASK),
169 crypt_stat->extent_size, page->mapping->host);
170 if (rc) {
171 printk(KERN_ERR "%s: Error attempting to read "
172 "extent at offset [%lld] in the lower "
173 "file; rc = [%d]\n", __func__,
174 lower_offset, rc);
175 goto out;
176 }
177 }
178 extent_num_in_page++;
179 }
180out:
181 return rc;
182}
183
184
185
186
187
188
189
190
191
192
193static int ecryptfs_readpage(struct file *file, struct page *page)
194{
195 struct ecryptfs_crypt_stat *crypt_stat =
196 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
197 int rc = 0;
198
199 if (!crypt_stat
200 || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
201 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
202 ecryptfs_printk(KERN_DEBUG,
203 "Passing through unencrypted page\n");
204 rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
205 PAGE_CACHE_SIZE,
206 page->mapping->host);
207 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
208 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
209 rc = ecryptfs_copy_up_encrypted_with_header(page,
210 crypt_stat);
211 if (rc) {
212 printk(KERN_ERR "%s: Error attempting to copy "
213 "the encrypted content from the lower "
214 "file whilst inserting the metadata "
215 "from the xattr into the header; rc = "
216 "[%d]\n", __func__, rc);
217 goto out;
218 }
219
220 } else {
221 rc = ecryptfs_read_lower_page_segment(
222 page, page->index, 0, PAGE_CACHE_SIZE,
223 page->mapping->host);
224 if (rc) {
225 printk(KERN_ERR "Error reading page; rc = "
226 "[%d]\n", rc);
227 goto out;
228 }
229 }
230 } else {
231 rc = ecryptfs_decrypt_page(page);
232 if (rc) {
233 ecryptfs_printk(KERN_ERR, "Error decrypting page; "
234 "rc = [%d]\n", rc);
235 goto out;
236 }
237 }
238out:
239 if (rc)
240 ClearPageUptodate(page);
241 else
242 SetPageUptodate(page);
243 ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n",
244 page->index);
245 unlock_page(page);
246 return rc;
247}
248
249
250
251
252static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
253{
254 struct inode *inode = page->mapping->host;
255 int end_byte_in_page;
256
257 if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index)
258 goto out;
259 end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
260 if (to > end_byte_in_page)
261 end_byte_in_page = to;
262 zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
263out:
264 return 0;
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281static int ecryptfs_write_begin(struct file *file,
282 struct address_space *mapping,
283 loff_t pos, unsigned len, unsigned flags,
284 struct page **pagep, void **fsdata)
285{
286 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
287 struct page *page;
288 loff_t prev_page_end_size;
289 int rc = 0;
290
291 page = grab_cache_page_write_begin(mapping, index, flags);
292 if (!page)
293 return -ENOMEM;
294 *pagep = page;
295
296 if (!PageUptodate(page)) {
297 struct ecryptfs_crypt_stat *crypt_stat =
298 &ecryptfs_inode_to_private(
299 file->f_path.dentry->d_inode)->crypt_stat;
300
301 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
302 || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
303 rc = ecryptfs_read_lower_page_segment(
304 page, index, 0, PAGE_CACHE_SIZE, mapping->host);
305 if (rc) {
306 printk(KERN_ERR "%s: Error attemping to read "
307 "lower page segment; rc = [%d]\n",
308 __func__, rc);
309 ClearPageUptodate(page);
310 goto out;
311 } else
312 SetPageUptodate(page);
313 } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
314 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
315 rc = ecryptfs_copy_up_encrypted_with_header(
316 page, crypt_stat);
317 if (rc) {
318 printk(KERN_ERR "%s: Error attempting "
319 "to copy the encrypted content "
320 "from the lower file whilst "
321 "inserting the metadata from "
322 "the xattr into the header; rc "
323 "= [%d]\n", __func__, rc);
324 ClearPageUptodate(page);
325 goto out;
326 }
327 SetPageUptodate(page);
328 } else {
329 rc = ecryptfs_read_lower_page_segment(
330 page, index, 0, PAGE_CACHE_SIZE,
331 mapping->host);
332 if (rc) {
333 printk(KERN_ERR "%s: Error reading "
334 "page; rc = [%d]\n",
335 __func__, rc);
336 ClearPageUptodate(page);
337 goto out;
338 }
339 SetPageUptodate(page);
340 }
341 } else {
342 rc = ecryptfs_decrypt_page(page);
343 if (rc) {
344 printk(KERN_ERR "%s: Error decrypting page "
345 "at index [%ld]; rc = [%d]\n",
346 __func__, page->index, rc);
347 ClearPageUptodate(page);
348 goto out;
349 }
350 SetPageUptodate(page);
351 }
352 }
353 prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);
354
355
356 if (index != 0) {
357 if (prev_page_end_size > i_size_read(page->mapping->host)) {
358 rc = ecryptfs_truncate(file->f_path.dentry,
359 prev_page_end_size);
360 if (rc) {
361 printk(KERN_ERR "%s: Error on attempt to "
362 "truncate to (higher) offset [%lld];"
363 " rc = [%d]\n", __func__,
364 prev_page_end_size, rc);
365 goto out;
366 }
367 }
368 }
369
370
371 if ((i_size_read(mapping->host) == prev_page_end_size)
372 && (pos != 0))
373 zero_user(page, 0, PAGE_CACHE_SIZE);
374out:
375 return rc;
376}
377
378
379
380
381
382
383
384
385static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
386{
387 char *file_size_virt;
388 int rc;
389
390 file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL);
391 if (!file_size_virt) {
392 rc = -ENOMEM;
393 goto out;
394 }
395 put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);
396 rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0,
397 sizeof(u64));
398 kfree(file_size_virt);
399 if (rc < 0)
400 printk(KERN_ERR "%s: Error writing file size to header; "
401 "rc = [%d]\n", __func__, rc);
402 else
403 rc = 0;
404out:
405 return rc;
406}
407
408struct kmem_cache *ecryptfs_xattr_cache;
409
410static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
411{
412 ssize_t size;
413 void *xattr_virt;
414 struct dentry *lower_dentry =
415 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry;
416 struct inode *lower_inode = lower_dentry->d_inode;
417 int rc;
418
419 if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
420 printk(KERN_WARNING
421 "No support for setting xattr in lower filesystem\n");
422 rc = -ENOSYS;
423 goto out;
424 }
425 xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
426 if (!xattr_virt) {
427 printk(KERN_ERR "Out of memory whilst attempting to write "
428 "inode size to xattr\n");
429 rc = -ENOMEM;
430 goto out;
431 }
432 mutex_lock(&lower_inode->i_mutex);
433 size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
434 xattr_virt, PAGE_CACHE_SIZE);
435 if (size < 0)
436 size = 8;
437 put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
438 rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
439 xattr_virt, size, 0);
440 mutex_unlock(&lower_inode->i_mutex);
441 if (rc)
442 printk(KERN_ERR "Error whilst attempting to write inode size "
443 "to lower file xattr; rc = [%d]\n", rc);
444 kmem_cache_free(ecryptfs_xattr_cache, xattr_virt);
445out:
446 return rc;
447}
448
449int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
450{
451 struct ecryptfs_crypt_stat *crypt_stat;
452
453 crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
454 BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
455 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
456 return ecryptfs_write_inode_size_to_xattr(ecryptfs_inode);
457 else
458 return ecryptfs_write_inode_size_to_header(ecryptfs_inode);
459}
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475static int ecryptfs_write_end(struct file *file,
476 struct address_space *mapping,
477 loff_t pos, unsigned len, unsigned copied,
478 struct page *page, void *fsdata)
479{
480 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
481 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
482 unsigned to = from + copied;
483 struct inode *ecryptfs_inode = mapping->host;
484 struct ecryptfs_crypt_stat *crypt_stat =
485 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
486 int rc;
487
488 if (crypt_stat->flags & ECRYPTFS_NEW_FILE) {
489 ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in "
490 "crypt_stat at memory location [%p]\n", crypt_stat);
491 crypt_stat->flags &= ~(ECRYPTFS_NEW_FILE);
492 } else
493 ecryptfs_printk(KERN_DEBUG, "Not a new file\n");
494 ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
495 "(page w/ index = [0x%.16x], to = [%d])\n", index, to);
496 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
497 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
498 to);
499 if (!rc) {
500 rc = copied;
501 fsstack_copy_inode_size(ecryptfs_inode,
502 ecryptfs_inode_to_lower(ecryptfs_inode));
503 }
504 goto out;
505 }
506
507 rc = fill_zeros_to_end_of_page(page, to);
508 if (rc) {
509 ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
510 "zeros in page with index = [0x%.16x]\n", index);
511 goto out;
512 }
513 rc = ecryptfs_encrypt_page(page);
514 if (rc) {
515 ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
516 "index [0x%.16x])\n", index);
517 goto out;
518 }
519 if (pos + copied > i_size_read(ecryptfs_inode)) {
520 i_size_write(ecryptfs_inode, pos + copied);
521 ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
522 "[0x%.16x]\n", i_size_read(ecryptfs_inode));
523 }
524 rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
525 if (rc)
526 printk(KERN_ERR "Error writing inode size to metadata; "
527 "rc = [%d]\n", rc);
528 else
529 rc = copied;
530out:
531 unlock_page(page);
532 page_cache_release(page);
533 return rc;
534}
535
536static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
537{
538 int rc = 0;
539 struct inode *inode;
540 struct inode *lower_inode;
541
542 inode = (struct inode *)mapping->host;
543 lower_inode = ecryptfs_inode_to_lower(inode);
544 if (lower_inode->i_mapping->a_ops->bmap)
545 rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping,
546 block);
547 return rc;
548}
549
550const struct address_space_operations ecryptfs_aops = {
551 .writepage = ecryptfs_writepage,
552 .readpage = ecryptfs_readpage,
553 .write_begin = ecryptfs_write_begin,
554 .write_end = ecryptfs_write_end,
555 .bmap = ecryptfs_bmap,
556};
557