1 /** 2 * eCryptfs: Linux filesystem encryption layer 3 * 4 * Copyright (C) 2007 International Business Machines Corp. 5 * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com> 6 * 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. 11 * 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. 16 * 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 20 * 02111-1307, USA. 21 */ 22 23 #include <linux/fs.h> 24 #include <linux/pagemap.h> 25 #include <linux/sched/signal.h> 26 27 #include "ecryptfs_kernel.h" 28 29 /** 30 * ecryptfs_write_lower 31 * @ecryptfs_inode: The eCryptfs inode 32 * @data: Data to write 33 * @offset: Byte offset in the lower file to which to write the data 34 * @size: Number of bytes from @data to write at @offset in the lower 35 * file 36 * 37 * Write data to the lower file. 38 * 39 * Returns bytes written on success; less than zero on error 40 */ 41 int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data, 42 loff_t offset, size_t size) 43 { 44 struct file *lower_file; 45 ssize_t rc; 46 47 lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file; 48 if (!lower_file) 49 return -EIO; 50 rc = kernel_write(lower_file, data, size, &offset); 51 mark_inode_dirty_sync(ecryptfs_inode); 52 return rc; 53 } 54 55 /** 56 * ecryptfs_write_lower_page_segment 57 * @ecryptfs_inode: The eCryptfs inode 58 * @page_for_lower: The page containing the data to be written to the 59 * lower file 60 * @offset_in_page: The offset in the @page_for_lower from which to 61 * start writing the data 62 * @size: The amount of data from @page_for_lower to write to the 63 * lower file 64 * 65 * Determines the byte offset in the file for the given page and 66 * offset within the page, maps the page, and makes the call to write 67 * the contents of @page_for_lower to the lower inode. 68 * 69 * Returns zero on success; non-zero otherwise 70 */ 71 int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode, 72 struct page *page_for_lower, 73 size_t offset_in_page, size_t size) 74 { 75 char *virt; 76 loff_t offset; 77 int rc; 78 79 offset = ((((loff_t)page_for_lower->index) << PAGE_SHIFT) 80 + offset_in_page); 81 virt = kmap(page_for_lower); 82 rc = ecryptfs_write_lower(ecryptfs_inode, virt, offset, size); 83 if (rc > 0) 84 rc = 0; 85 kunmap(page_for_lower); 86 return rc; 87 } 88 89 /** 90 * ecryptfs_write 91 * @ecryptfs_inode: The eCryptfs file into which to write 92 * @data: Virtual address where data to write is located 93 * @offset: Offset in the eCryptfs file at which to begin writing the 94 * data from @data 95 * @size: The number of bytes to write from @data 96 * 97 * Write an arbitrary amount of data to an arbitrary location in the 98 * eCryptfs inode page cache. This is done on a page-by-page, and then 99 * by an extent-by-extent, basis; individual extents are encrypted and 100 * written to the lower page cache (via VFS writes). This function 101 * takes care of all the address translation to locations in the lower 102 * filesystem; it also handles truncate events, writing out zeros 103 * where necessary. 104 * 105 * Returns zero on success; non-zero otherwise 106 */ 107 int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset, 108 size_t size) 109 { 110 struct page *ecryptfs_page; 111 struct ecryptfs_crypt_stat *crypt_stat; 112 char *ecryptfs_page_virt; 113 loff_t ecryptfs_file_size = i_size_read(ecryptfs_inode); 114 loff_t data_offset = 0; 115 loff_t pos; 116 int rc = 0; 117 118 crypt_stat = &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat; 119 /* 120 * if we are writing beyond current size, then start pos 121 * at the current size - we'll fill in zeros from there. 122 */ 123 if (offset > ecryptfs_file_size) 124 pos = ecryptfs_file_size; 125 else 126 pos = offset; 127 while (pos < (offset + size)) { 128 pgoff_t ecryptfs_page_idx = (pos >> PAGE_SHIFT); 129 size_t start_offset_in_page = (pos & ~PAGE_MASK); 130 size_t num_bytes = (PAGE_SIZE - start_offset_in_page); 131 loff_t total_remaining_bytes = ((offset + size) - pos); 132 133 if (fatal_signal_pending(current)) { 134 rc = -EINTR; 135 break; 136 } 137 138 if (num_bytes > total_remaining_bytes) 139 num_bytes = total_remaining_bytes; 140 if (pos < offset) { 141 /* remaining zeros to write, up to destination offset */ 142 loff_t total_remaining_zeros = (offset - pos); 143 144 if (num_bytes > total_remaining_zeros) 145 num_bytes = total_remaining_zeros; 146 } 147 ecryptfs_page = ecryptfs_get_locked_page(ecryptfs_inode, 148 ecryptfs_page_idx); 149 if (IS_ERR(ecryptfs_page)) { 150 rc = PTR_ERR(ecryptfs_page); 151 printk(KERN_ERR "%s: Error getting page at " 152 "index [%ld] from eCryptfs inode " 153 "mapping; rc = [%d]\n", __func__, 154 ecryptfs_page_idx, rc); 155 goto out; 156 } 157 ecryptfs_page_virt = kmap_atomic(ecryptfs_page); 158 159 /* 160 * pos: where we're now writing, offset: where the request was 161 * If current pos is before request, we are filling zeros 162 * If we are at or beyond request, we are writing the *data* 163 * If we're in a fresh page beyond eof, zero it in either case 164 */ 165 if (pos < offset || !start_offset_in_page) { 166 /* We are extending past the previous end of the file. 167 * Fill in zero values to the end of the page */ 168 memset(((char *)ecryptfs_page_virt 169 + start_offset_in_page), 0, 170 PAGE_SIZE - start_offset_in_page); 171 } 172 173 /* pos >= offset, we are now writing the data request */ 174 if (pos >= offset) { 175 memcpy(((char *)ecryptfs_page_virt 176 + start_offset_in_page), 177 (data + data_offset), num_bytes); 178 data_offset += num_bytes; 179 } 180 kunmap_atomic(ecryptfs_page_virt); 181 flush_dcache_page(ecryptfs_page); 182 SetPageUptodate(ecryptfs_page); 183 unlock_page(ecryptfs_page); 184 if (crypt_stat->flags & ECRYPTFS_ENCRYPTED) 185 rc = ecryptfs_encrypt_page(ecryptfs_page); 186 else 187 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, 188 ecryptfs_page, 189 start_offset_in_page, 190 data_offset); 191 put_page(ecryptfs_page); 192 if (rc) { 193 printk(KERN_ERR "%s: Error encrypting " 194 "page; rc = [%d]\n", __func__, rc); 195 goto out; 196 } 197 pos += num_bytes; 198 } 199 if (pos > ecryptfs_file_size) { 200 i_size_write(ecryptfs_inode, pos); 201 if (crypt_stat->flags & ECRYPTFS_ENCRYPTED) { 202 int rc2; 203 204 rc2 = ecryptfs_write_inode_size_to_metadata( 205 ecryptfs_inode); 206 if (rc2) { 207 printk(KERN_ERR "Problem with " 208 "ecryptfs_write_inode_size_to_metadata; " 209 "rc = [%d]\n", rc2); 210 if (!rc) 211 rc = rc2; 212 goto out; 213 } 214 } 215 } 216 out: 217 return rc; 218 } 219 220 /** 221 * ecryptfs_read_lower 222 * @data: The read data is stored here by this function 223 * @offset: Byte offset in the lower file from which to read the data 224 * @size: Number of bytes to read from @offset of the lower file and 225 * store into @data 226 * @ecryptfs_inode: The eCryptfs inode 227 * 228 * Read @size bytes of data at byte offset @offset from the lower 229 * inode into memory location @data. 230 * 231 * Returns bytes read on success; 0 on EOF; less than zero on error 232 */ 233 int ecryptfs_read_lower(char *data, loff_t offset, size_t size, 234 struct inode *ecryptfs_inode) 235 { 236 struct file *lower_file; 237 lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file; 238 if (!lower_file) 239 return -EIO; 240 return kernel_read(lower_file, data, size, &offset); 241 } 242 243 /** 244 * ecryptfs_read_lower_page_segment 245 * @page_for_ecryptfs: The page into which data for eCryptfs will be 246 * written 247 * @offset_in_page: Offset in @page_for_ecryptfs from which to start 248 * writing 249 * @size: The number of bytes to write into @page_for_ecryptfs 250 * @ecryptfs_inode: The eCryptfs inode 251 * 252 * Determines the byte offset in the file for the given page and 253 * offset within the page, maps the page, and makes the call to read 254 * the contents of @page_for_ecryptfs from the lower inode. 255 * 256 * Returns zero on success; non-zero otherwise 257 */ 258 int ecryptfs_read_lower_page_segment(struct page *page_for_ecryptfs, 259 pgoff_t page_index, 260 size_t offset_in_page, size_t size, 261 struct inode *ecryptfs_inode) 262 { 263 char *virt; 264 loff_t offset; 265 int rc; 266 267 offset = ((((loff_t)page_index) << PAGE_SHIFT) + offset_in_page); 268 virt = kmap(page_for_ecryptfs); 269 rc = ecryptfs_read_lower(virt, offset, size, ecryptfs_inode); 270 if (rc > 0) 271 rc = 0; 272 kunmap(page_for_ecryptfs); 273 flush_dcache_page(page_for_ecryptfs); 274 return rc; 275 } 276