1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * eCryptfs: Linux filesystem encryption layer 4 * 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_lower 17 * @ecryptfs_inode: The eCryptfs inode 18 * @data: Data to write 19 * @offset: Byte offset in the lower file to which to write the data 20 * @size: Number of bytes from @data to write at @offset in the lower 21 * file 22 * 23 * Write data to the lower file. 24 * 25 * Returns bytes written on success; less than zero on error 26 */ 27 int 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_segment 43 * @ecryptfs_inode: The eCryptfs inode 44 * @page_for_lower: The page containing the data to be written to the 45 * lower file 46 * @offset_in_page: The offset in the @page_for_lower from which to 47 * start writing the data 48 * @size: The amount of data from @page_for_lower to write to the 49 * lower file 50 * 51 * Determines the byte offset in the file for the given page and 52 * offset within the page, maps the page, and makes the call to write 53 * the contents of @page_for_lower to the lower inode. 54 * 55 * Returns zero on success; non-zero otherwise 56 */ 57 int 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_write 77 * @ecryptfs_inode: The eCryptfs file into which to write 78 * @data: Virtual address where data to write is located 79 * @offset: Offset in the eCryptfs file at which to begin writing the 80 * data from @data 81 * @size: The number of bytes to write from @data 82 * 83 * Write an arbitrary amount of data to an arbitrary location in the 84 * eCryptfs inode page cache. This is done on a page-by-page, and then 85 * by an extent-by-extent, basis; individual extents are encrypted and 86 * written to the lower page cache (via VFS writes). This function 87 * takes care of all the address translation to locations in the lower 88 * filesystem; it also handles truncate events, writing out zeros 89 * where necessary. 90 * 91 * Returns zero on success; non-zero otherwise 92 */ 93 int 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 pos 107 * at the current size - we'll fill in zeros from there. 108 */ 109 if (offset > ecryptfs_file_size) 110 pos = ecryptfs_file_size; 111 else 112 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 was 147 * If current pos is before request, we are filling zeros 148 * 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 case 150 */ 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_virt 155 + 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_virt 162 + 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 else 173 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 } 202 out: 203 return rc; 204 } 205 206 /** 207 * ecryptfs_read_lower 208 * @data: The read data is stored here by this function 209 * @offset: Byte offset in the lower file from which to read the data 210 * @size: Number of bytes to read from @offset of the lower file and 211 * store into @data 212 * @ecryptfs_inode: The eCryptfs inode 213 * 214 * Read @size bytes of data at byte offset @offset from the lower 215 * inode into memory location @data. 216 * 217 * Returns bytes read on success; 0 on EOF; less than zero on error 218 */ 219 int 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_segment 231 * @page_for_ecryptfs: The page into which data for eCryptfs will be 232 * written 233 * @page_index: Page index in @page_for_ecryptfs from which to start 234 * writing 235 * @offset_in_page: Offset in @page_for_ecryptfs from which to start 236 * writing 237 * @size: The number of bytes to write into @page_for_ecryptfs 238 * @ecryptfs_inode: The eCryptfs inode 239 * 240 * Determines the byte offset in the file for the given page and 241 * offset within the page, maps the page, and makes the call to read 242 * the contents of @page_for_ecryptfs from the lower inode. 243 * 244 * Returns zero on success; non-zero otherwise 245 */ 246 int 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