xref: /openbmc/linux/fs/ecryptfs/mmap.c (revision 92a76f6d)
1 /**
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.
6  *
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>
11  *
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.
16  *
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.
21  *
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
25  * 02111-1307, USA.
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/scatterlist.h>
34 #include <linux/slab.h>
35 #include <asm/unaligned.h>
36 #include "ecryptfs_kernel.h"
37 
38 /**
39  * ecryptfs_get_locked_page
40  *
41  * Get one page from cache or lower f/s, return error otherwise.
42  *
43  * Returns locked and up-to-date page (if ok), with increased
44  * refcnt.
45  */
46 struct page *ecryptfs_get_locked_page(struct inode *inode, loff_t index)
47 {
48 	struct page *page = read_mapping_page(inode->i_mapping, index, NULL);
49 	if (!IS_ERR(page))
50 		lock_page(page);
51 	return page;
52 }
53 
54 /**
55  * ecryptfs_writepage
56  * @page: Page that is locked before this call is made
57  *
58  * Returns zero on success; non-zero otherwise
59  *
60  * This is where we encrypt the data and pass the encrypted data to
61  * the lower filesystem.  In OpenPGP-compatible mode, we operate on
62  * entire underlying packets.
63  */
64 static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
65 {
66 	int rc;
67 
68 	rc = ecryptfs_encrypt_page(page);
69 	if (rc) {
70 		ecryptfs_printk(KERN_WARNING, "Error encrypting "
71 				"page (upper index [0x%.16lx])\n", page->index);
72 		ClearPageUptodate(page);
73 		goto out;
74 	}
75 	SetPageUptodate(page);
76 out:
77 	unlock_page(page);
78 	return rc;
79 }
80 
81 static void strip_xattr_flag(char *page_virt,
82 			     struct ecryptfs_crypt_stat *crypt_stat)
83 {
84 	if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
85 		size_t written;
86 
87 		crypt_stat->flags &= ~ECRYPTFS_METADATA_IN_XATTR;
88 		ecryptfs_write_crypt_stat_flags(page_virt, crypt_stat,
89 						&written);
90 		crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
91 	}
92 }
93 
94 /**
95  *   Header Extent:
96  *     Octets 0-7:        Unencrypted file size (big-endian)
97  *     Octets 8-15:       eCryptfs special marker
98  *     Octets 16-19:      Flags
99  *      Octet 16:         File format version number (between 0 and 255)
100  *      Octets 17-18:     Reserved
101  *      Octet 19:         Bit 1 (lsb): Reserved
102  *                        Bit 2: Encrypted?
103  *                        Bits 3-8: Reserved
104  *     Octets 20-23:      Header extent size (big-endian)
105  *     Octets 24-25:      Number of header extents at front of file
106  *                        (big-endian)
107  *     Octet  26:         Begin RFC 2440 authentication token packet set
108  */
109 
110 /**
111  * ecryptfs_copy_up_encrypted_with_header
112  * @page: Sort of a ``virtual'' representation of the encrypted lower
113  *        file. The actual lower file does not have the metadata in
114  *        the header. This is locked.
115  * @crypt_stat: The eCryptfs inode's cryptographic context
116  *
117  * The ``view'' is the version of the file that userspace winds up
118  * seeing, with the header information inserted.
119  */
120 static int
121 ecryptfs_copy_up_encrypted_with_header(struct page *page,
122 				       struct ecryptfs_crypt_stat *crypt_stat)
123 {
124 	loff_t extent_num_in_page = 0;
125 	loff_t num_extents_per_page = (PAGE_CACHE_SIZE
126 				       / crypt_stat->extent_size);
127 	int rc = 0;
128 
129 	while (extent_num_in_page < num_extents_per_page) {
130 		loff_t view_extent_num = ((((loff_t)page->index)
131 					   * num_extents_per_page)
132 					  + extent_num_in_page);
133 		size_t num_header_extents_at_front =
134 			(crypt_stat->metadata_size / crypt_stat->extent_size);
135 
136 		if (view_extent_num < num_header_extents_at_front) {
137 			/* This is a header extent */
138 			char *page_virt;
139 
140 			page_virt = kmap_atomic(page);
141 			memset(page_virt, 0, PAGE_CACHE_SIZE);
142 			/* TODO: Support more than one header extent */
143 			if (view_extent_num == 0) {
144 				size_t written;
145 
146 				rc = ecryptfs_read_xattr_region(
147 					page_virt, page->mapping->host);
148 				strip_xattr_flag(page_virt + 16, crypt_stat);
149 				ecryptfs_write_header_metadata(page_virt + 20,
150 							       crypt_stat,
151 							       &written);
152 			}
153 			kunmap_atomic(page_virt);
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 			/* This is an encrypted data extent */
162 			loff_t lower_offset =
163 				((view_extent_num * crypt_stat->extent_size)
164 				 - crypt_stat->metadata_size);
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 	}
180 out:
181 	return rc;
182 }
183 
184 /**
185  * ecryptfs_readpage
186  * @file: An eCryptfs file
187  * @page: Page from eCryptfs inode mapping into which to stick the read data
188  *
189  * Read in a page, decrypting if necessary.
190  *
191  * Returns zero on success; non-zero on error.
192  */
193 static int ecryptfs_readpage(struct file *file, struct page *page)
194 {
195 	struct ecryptfs_crypt_stat *crypt_stat =
196 		&ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
197 	int rc = 0;
198 
199 	if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
200 		rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
201 						      PAGE_CACHE_SIZE,
202 						      page->mapping->host);
203 	} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
204 		if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
205 			rc = ecryptfs_copy_up_encrypted_with_header(page,
206 								    crypt_stat);
207 			if (rc) {
208 				printk(KERN_ERR "%s: Error attempting to copy "
209 				       "the encrypted content from the lower "
210 				       "file whilst inserting the metadata "
211 				       "from the xattr into the header; rc = "
212 				       "[%d]\n", __func__, rc);
213 				goto out;
214 			}
215 
216 		} else {
217 			rc = ecryptfs_read_lower_page_segment(
218 				page, page->index, 0, PAGE_CACHE_SIZE,
219 				page->mapping->host);
220 			if (rc) {
221 				printk(KERN_ERR "Error reading page; rc = "
222 				       "[%d]\n", rc);
223 				goto out;
224 			}
225 		}
226 	} else {
227 		rc = ecryptfs_decrypt_page(page);
228 		if (rc) {
229 			ecryptfs_printk(KERN_ERR, "Error decrypting page; "
230 					"rc = [%d]\n", rc);
231 			goto out;
232 		}
233 	}
234 out:
235 	if (rc)
236 		ClearPageUptodate(page);
237 	else
238 		SetPageUptodate(page);
239 	ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16lx]\n",
240 			page->index);
241 	unlock_page(page);
242 	return rc;
243 }
244 
245 /**
246  * Called with lower inode mutex held.
247  */
248 static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
249 {
250 	struct inode *inode = page->mapping->host;
251 	int end_byte_in_page;
252 
253 	if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index)
254 		goto out;
255 	end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
256 	if (to > end_byte_in_page)
257 		end_byte_in_page = to;
258 	zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
259 out:
260 	return 0;
261 }
262 
263 /**
264  * ecryptfs_write_begin
265  * @file: The eCryptfs file
266  * @mapping: The eCryptfs object
267  * @pos: The file offset at which to start writing
268  * @len: Length of the write
269  * @flags: Various flags
270  * @pagep: Pointer to return the page
271  * @fsdata: Pointer to return fs data (unused)
272  *
273  * This function must zero any hole we create
274  *
275  * Returns zero on success; non-zero otherwise
276  */
277 static int ecryptfs_write_begin(struct file *file,
278 			struct address_space *mapping,
279 			loff_t pos, unsigned len, unsigned flags,
280 			struct page **pagep, void **fsdata)
281 {
282 	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
283 	struct page *page;
284 	loff_t prev_page_end_size;
285 	int rc = 0;
286 
287 	page = grab_cache_page_write_begin(mapping, index, flags);
288 	if (!page)
289 		return -ENOMEM;
290 	*pagep = page;
291 
292 	prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);
293 	if (!PageUptodate(page)) {
294 		struct ecryptfs_crypt_stat *crypt_stat =
295 			&ecryptfs_inode_to_private(mapping->host)->crypt_stat;
296 
297 		if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
298 			rc = ecryptfs_read_lower_page_segment(
299 				page, index, 0, PAGE_CACHE_SIZE, mapping->host);
300 			if (rc) {
301 				printk(KERN_ERR "%s: Error attempting to read "
302 				       "lower page segment; rc = [%d]\n",
303 				       __func__, rc);
304 				ClearPageUptodate(page);
305 				goto out;
306 			} else
307 				SetPageUptodate(page);
308 		} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
309 			if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
310 				rc = ecryptfs_copy_up_encrypted_with_header(
311 					page, crypt_stat);
312 				if (rc) {
313 					printk(KERN_ERR "%s: Error attempting "
314 					       "to copy the encrypted content "
315 					       "from the lower file whilst "
316 					       "inserting the metadata from "
317 					       "the xattr into the header; rc "
318 					       "= [%d]\n", __func__, rc);
319 					ClearPageUptodate(page);
320 					goto out;
321 				}
322 				SetPageUptodate(page);
323 			} else {
324 				rc = ecryptfs_read_lower_page_segment(
325 					page, index, 0, PAGE_CACHE_SIZE,
326 					mapping->host);
327 				if (rc) {
328 					printk(KERN_ERR "%s: Error reading "
329 					       "page; rc = [%d]\n",
330 					       __func__, rc);
331 					ClearPageUptodate(page);
332 					goto out;
333 				}
334 				SetPageUptodate(page);
335 			}
336 		} else {
337 			if (prev_page_end_size
338 			    >= i_size_read(page->mapping->host)) {
339 				zero_user(page, 0, PAGE_CACHE_SIZE);
340 				SetPageUptodate(page);
341 			} else if (len < PAGE_CACHE_SIZE) {
342 				rc = ecryptfs_decrypt_page(page);
343 				if (rc) {
344 					printk(KERN_ERR "%s: Error decrypting "
345 					       "page at index [%ld]; "
346 					       "rc = [%d]\n",
347 					       __func__, page->index, rc);
348 					ClearPageUptodate(page);
349 					goto out;
350 				}
351 				SetPageUptodate(page);
352 			}
353 		}
354 	}
355 	/* If creating a page or more of holes, zero them out via truncate.
356 	 * Note, this will increase i_size. */
357 	if (index != 0) {
358 		if (prev_page_end_size > i_size_read(page->mapping->host)) {
359 			rc = ecryptfs_truncate(file->f_path.dentry,
360 					       prev_page_end_size);
361 			if (rc) {
362 				printk(KERN_ERR "%s: Error on attempt to "
363 				       "truncate to (higher) offset [%lld];"
364 				       " rc = [%d]\n", __func__,
365 				       prev_page_end_size, rc);
366 				goto out;
367 			}
368 		}
369 	}
370 	/* Writing to a new page, and creating a small hole from start
371 	 * of page?  Zero it out. */
372 	if ((i_size_read(mapping->host) == prev_page_end_size)
373 	    && (pos != 0))
374 		zero_user(page, 0, PAGE_CACHE_SIZE);
375 out:
376 	if (unlikely(rc)) {
377 		unlock_page(page);
378 		page_cache_release(page);
379 		*pagep = NULL;
380 	}
381 	return rc;
382 }
383 
384 /**
385  * ecryptfs_write_inode_size_to_header
386  *
387  * Writes the lower file size to the first 8 bytes of the header.
388  *
389  * Returns zero on success; non-zero on error.
390  */
391 static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
392 {
393 	char *file_size_virt;
394 	int rc;
395 
396 	file_size_virt = kmalloc(sizeof(u64), GFP_KERNEL);
397 	if (!file_size_virt) {
398 		rc = -ENOMEM;
399 		goto out;
400 	}
401 	put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);
402 	rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0,
403 				  sizeof(u64));
404 	kfree(file_size_virt);
405 	if (rc < 0)
406 		printk(KERN_ERR "%s: Error writing file size to header; "
407 		       "rc = [%d]\n", __func__, rc);
408 	else
409 		rc = 0;
410 out:
411 	return rc;
412 }
413 
414 struct kmem_cache *ecryptfs_xattr_cache;
415 
416 static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
417 {
418 	ssize_t size;
419 	void *xattr_virt;
420 	struct dentry *lower_dentry =
421 		ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
422 	struct inode *lower_inode = d_inode(lower_dentry);
423 	int rc;
424 
425 	if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
426 		printk(KERN_WARNING
427 		       "No support for setting xattr in lower filesystem\n");
428 		rc = -ENOSYS;
429 		goto out;
430 	}
431 	xattr_virt = kmem_cache_alloc(ecryptfs_xattr_cache, GFP_KERNEL);
432 	if (!xattr_virt) {
433 		printk(KERN_ERR "Out of memory whilst attempting to write "
434 		       "inode size to xattr\n");
435 		rc = -ENOMEM;
436 		goto out;
437 	}
438 	inode_lock(lower_inode);
439 	size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
440 					   xattr_virt, PAGE_CACHE_SIZE);
441 	if (size < 0)
442 		size = 8;
443 	put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
444 	rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
445 					 xattr_virt, size, 0);
446 	inode_unlock(lower_inode);
447 	if (rc)
448 		printk(KERN_ERR "Error whilst attempting to write inode size "
449 		       "to lower file xattr; rc = [%d]\n", rc);
450 	kmem_cache_free(ecryptfs_xattr_cache, xattr_virt);
451 out:
452 	return rc;
453 }
454 
455 int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
456 {
457 	struct ecryptfs_crypt_stat *crypt_stat;
458 
459 	crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
460 	BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
461 	if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
462 		return ecryptfs_write_inode_size_to_xattr(ecryptfs_inode);
463 	else
464 		return ecryptfs_write_inode_size_to_header(ecryptfs_inode);
465 }
466 
467 /**
468  * ecryptfs_write_end
469  * @file: The eCryptfs file object
470  * @mapping: The eCryptfs object
471  * @pos: The file position
472  * @len: The length of the data (unused)
473  * @copied: The amount of data copied
474  * @page: The eCryptfs page
475  * @fsdata: The fsdata (unused)
476  */
477 static int ecryptfs_write_end(struct file *file,
478 			struct address_space *mapping,
479 			loff_t pos, unsigned len, unsigned copied,
480 			struct page *page, void *fsdata)
481 {
482 	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
483 	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
484 	unsigned to = from + copied;
485 	struct inode *ecryptfs_inode = mapping->host;
486 	struct ecryptfs_crypt_stat *crypt_stat =
487 		&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
488 	int rc;
489 
490 	ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
491 			"(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
492 	if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
493 		rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
494 						       to);
495 		if (!rc) {
496 			rc = copied;
497 			fsstack_copy_inode_size(ecryptfs_inode,
498 				ecryptfs_inode_to_lower(ecryptfs_inode));
499 		}
500 		goto out;
501 	}
502 	if (!PageUptodate(page)) {
503 		if (copied < PAGE_CACHE_SIZE) {
504 			rc = 0;
505 			goto out;
506 		}
507 		SetPageUptodate(page);
508 	}
509 	/* Fills in zeros if 'to' goes beyond inode size */
510 	rc = fill_zeros_to_end_of_page(page, to);
511 	if (rc) {
512 		ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
513 			"zeros in page with index = [0x%.16lx]\n", index);
514 		goto out;
515 	}
516 	rc = ecryptfs_encrypt_page(page);
517 	if (rc) {
518 		ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
519 				"index [0x%.16lx])\n", index);
520 		goto out;
521 	}
522 	if (pos + copied > i_size_read(ecryptfs_inode)) {
523 		i_size_write(ecryptfs_inode, pos + copied);
524 		ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
525 			"[0x%.16llx]\n",
526 			(unsigned long long)i_size_read(ecryptfs_inode));
527 	}
528 	rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
529 	if (rc)
530 		printk(KERN_ERR "Error writing inode size to metadata; "
531 		       "rc = [%d]\n", rc);
532 	else
533 		rc = copied;
534 out:
535 	unlock_page(page);
536 	page_cache_release(page);
537 	return rc;
538 }
539 
540 static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
541 {
542 	int rc = 0;
543 	struct inode *inode;
544 	struct inode *lower_inode;
545 
546 	inode = (struct inode *)mapping->host;
547 	lower_inode = ecryptfs_inode_to_lower(inode);
548 	if (lower_inode->i_mapping->a_ops->bmap)
549 		rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping,
550 							 block);
551 	return rc;
552 }
553 
554 const struct address_space_operations ecryptfs_aops = {
555 	.writepage = ecryptfs_writepage,
556 	.readpage = ecryptfs_readpage,
557 	.write_begin = ecryptfs_write_begin,
558 	.write_end = ecryptfs_write_end,
559 	.bmap = ecryptfs_bmap,
560 };
561