264 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * eCryptfs: Linux filesystem encryption layer4 *5 * Copyright (C) 2007 International Business Machines Corp.6 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>7 */8 9#include <linux/fs.h>10#include <linux/pagemap.h>11#include <linux/sched/signal.h>12 13#include "ecryptfs_kernel.h"14 15/**16 * ecryptfs_write_lower17 * @ecryptfs_inode: The eCryptfs inode18 * @data: Data to write19 * @offset: Byte offset in the lower file to which to write the data20 * @size: Number of bytes from @data to write at @offset in the lower21 * file22 *23 * Write data to the lower file.24 *25 * Returns bytes written on success; less than zero on error26 */27int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,28 loff_t offset, size_t size)29{30 struct file *lower_file;31 ssize_t rc;32 33 lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file;34 if (!lower_file)35 return -EIO;36 rc = kernel_write(lower_file, data, size, &offset);37 mark_inode_dirty_sync(ecryptfs_inode);38 return rc;39}40 41/**42 * ecryptfs_write_lower_page_segment43 * @ecryptfs_inode: The eCryptfs inode44 * @page_for_lower: The page containing the data to be written to the45 * lower file46 * @offset_in_page: The offset in the @page_for_lower from which to47 * start writing the data48 * @size: The amount of data from @page_for_lower to write to the49 * lower file50 *51 * Determines the byte offset in the file for the given page and52 * offset within the page, maps the page, and makes the call to write53 * the contents of @page_for_lower to the lower inode.54 *55 * Returns zero on success; non-zero otherwise56 */57int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,58 struct page *page_for_lower,59 size_t offset_in_page, size_t size)60{61 char *virt;62 loff_t offset;63 int rc;64 65 offset = ((((loff_t)page_for_lower->index) << PAGE_SHIFT)66 + offset_in_page);67 virt = kmap_local_page(page_for_lower);68 rc = ecryptfs_write_lower(ecryptfs_inode, virt, offset, size);69 if (rc > 0)70 rc = 0;71 kunmap_local(virt);72 return rc;73}74 75/**76 * ecryptfs_write77 * @ecryptfs_inode: The eCryptfs file into which to write78 * @data: Virtual address where data to write is located79 * @offset: Offset in the eCryptfs file at which to begin writing the80 * data from @data81 * @size: The number of bytes to write from @data82 *83 * Write an arbitrary amount of data to an arbitrary location in the84 * eCryptfs inode page cache. This is done on a page-by-page, and then85 * by an extent-by-extent, basis; individual extents are encrypted and86 * written to the lower page cache (via VFS writes). This function87 * takes care of all the address translation to locations in the lower88 * filesystem; it also handles truncate events, writing out zeros89 * where necessary.90 *91 * Returns zero on success; non-zero otherwise92 */93int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,94 size_t size)95{96 struct page *ecryptfs_page;97 struct ecryptfs_crypt_stat *crypt_stat;98 char *ecryptfs_page_virt;99 loff_t ecryptfs_file_size = i_size_read(ecryptfs_inode);100 loff_t data_offset = 0;101 loff_t pos;102 int rc = 0;103 104 crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;105 /*106 * if we are writing beyond current size, then start pos107 * at the current size - we'll fill in zeros from there.108 */109 if (offset > ecryptfs_file_size)110 pos = ecryptfs_file_size;111 else112 pos = offset;113 while (pos < (offset + size)) {114 pgoff_t ecryptfs_page_idx = (pos >> PAGE_SHIFT);115 size_t start_offset_in_page = (pos & ~PAGE_MASK);116 size_t num_bytes = (PAGE_SIZE - start_offset_in_page);117 loff_t total_remaining_bytes = ((offset + size) - pos);118 119 if (fatal_signal_pending(current)) {120 rc = -EINTR;121 break;122 }123 124 if (num_bytes > total_remaining_bytes)125 num_bytes = total_remaining_bytes;126 if (pos < offset) {127 /* remaining zeros to write, up to destination offset */128 loff_t total_remaining_zeros = (offset - pos);129 130 if (num_bytes > total_remaining_zeros)131 num_bytes = total_remaining_zeros;132 }133 ecryptfs_page = ecryptfs_get_locked_page(ecryptfs_inode,134 ecryptfs_page_idx);135 if (IS_ERR(ecryptfs_page)) {136 rc = PTR_ERR(ecryptfs_page);137 printk(KERN_ERR "%s: Error getting page at "138 "index [%ld] from eCryptfs inode "139 "mapping; rc = [%d]\n", __func__,140 ecryptfs_page_idx, rc);141 goto out;142 }143 ecryptfs_page_virt = kmap_local_page(ecryptfs_page);144 145 /*146 * pos: where we're now writing, offset: where the request was147 * If current pos is before request, we are filling zeros148 * If we are at or beyond request, we are writing the *data*149 * If we're in a fresh page beyond eof, zero it in either case150 */151 if (pos < offset || !start_offset_in_page) {152 /* We are extending past the previous end of the file.153 * Fill in zero values to the end of the page */154 memset(((char *)ecryptfs_page_virt155 + start_offset_in_page), 0,156 PAGE_SIZE - start_offset_in_page);157 }158 159 /* pos >= offset, we are now writing the data request */160 if (pos >= offset) {161 memcpy(((char *)ecryptfs_page_virt162 + start_offset_in_page),163 (data + data_offset), num_bytes);164 data_offset += num_bytes;165 }166 kunmap_local(ecryptfs_page_virt);167 flush_dcache_page(ecryptfs_page);168 SetPageUptodate(ecryptfs_page);169 unlock_page(ecryptfs_page);170 if (crypt_stat->flags & ECRYPTFS_ENCRYPTED)171 rc = ecryptfs_encrypt_page(ecryptfs_page);172 else173 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,174 ecryptfs_page,175 start_offset_in_page,176 data_offset);177 put_page(ecryptfs_page);178 if (rc) {179 printk(KERN_ERR "%s: Error encrypting "180 "page; rc = [%d]\n", __func__, rc);181 goto out;182 }183 pos += num_bytes;184 }185 if (pos > ecryptfs_file_size) {186 i_size_write(ecryptfs_inode, pos);187 if (crypt_stat->flags & ECRYPTFS_ENCRYPTED) {188 int rc2;189 190 rc2 = ecryptfs_write_inode_size_to_metadata(191 ecryptfs_inode);192 if (rc2) {193 printk(KERN_ERR "Problem with "194 "ecryptfs_write_inode_size_to_metadata; "195 "rc = [%d]\n", rc2);196 if (!rc)197 rc = rc2;198 goto out;199 }200 }201 }202out:203 return rc;204}205 206/**207 * ecryptfs_read_lower208 * @data: The read data is stored here by this function209 * @offset: Byte offset in the lower file from which to read the data210 * @size: Number of bytes to read from @offset of the lower file and211 * store into @data212 * @ecryptfs_inode: The eCryptfs inode213 *214 * Read @size bytes of data at byte offset @offset from the lower215 * inode into memory location @data.216 *217 * Returns bytes read on success; 0 on EOF; less than zero on error218 */219int ecryptfs_read_lower(char *data, loff_t offset, size_t size,220 struct inode *ecryptfs_inode)221{222 struct file *lower_file;223 lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file;224 if (!lower_file)225 return -EIO;226 return kernel_read(lower_file, data, size, &offset);227}228 229/**230 * ecryptfs_read_lower_page_segment231 * @page_for_ecryptfs: The page into which data for eCryptfs will be232 * written233 * @page_index: Page index in @page_for_ecryptfs from which to start234 * writing235 * @offset_in_page: Offset in @page_for_ecryptfs from which to start236 * writing237 * @size: The number of bytes to write into @page_for_ecryptfs238 * @ecryptfs_inode: The eCryptfs inode239 *240 * Determines the byte offset in the file for the given page and241 * offset within the page, maps the page, and makes the call to read242 * the contents of @page_for_ecryptfs from the lower inode.243 *244 * Returns zero on success; non-zero otherwise245 */246int ecryptfs_read_lower_page_segment(struct page *page_for_ecryptfs,247 pgoff_t page_index,248 size_t offset_in_page, size_t size,249 struct inode *ecryptfs_inode)250{251 char *virt;252 loff_t offset;253 int rc;254 255 offset = ((((loff_t)page_index) << PAGE_SHIFT) + offset_in_page);256 virt = kmap_local_page(page_for_ecryptfs);257 rc = ecryptfs_read_lower(virt, offset, size, ecryptfs_inode);258 if (rc > 0)259 rc = 0;260 kunmap_local(virt);261 flush_dcache_page(page_for_ecryptfs);262 return rc;263}264