Pull more set_fs removal from Al Viro: "Christoph's 'use kernel_read and friends rather than open-coding set_fs()' series" * 'work.set_fs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: fs: unexport vfs_readv and vfs_writev fs: unexport vfs_read and vfs_write fs: unexport __vfs_read/__vfs_write lustre: switch to kernel_write gadget/f_mass_storage: stop messing with the address limit mconsole: switch to kernel_read btrfs: switch write_buf to kernel_write net/9p: switch p9_fd_read to kernel_write mm/nommu: switch do_mmap_private to kernel_read serial2002: switch serial2002_tty_write to kernel_{read/write} fs: make the buf argument to __kernel_write a void pointer fs: fix kernel_write prototype fs: fix kernel_read prototype fs: move kernel_read to fs/read_write.c fs: move kernel_write to fs/read_write.c autofs4: switch autofs4_write to __kernel_write ashmem: switch to ->read_iter
Unified · Split
| @@ -87,6 +87,7 @@ int arch_elf_pt_proc(void *_ehdr, void *_phdr, struct file *elf, · 86 unmodified lines | ||
| 87 | 87 | bool elf32; |
| 88 | 88 | u32 flags; |
| 89 | 89 | int ret; |
| 90 | + loff_t pos; | |
| 90 | 91 | |
| 91 | 92 | elf32 = ehdr->e32.e_ident[EI_CLASS] == ELFCLASS32; |
| 92 | 93 | flags = elf32 ? ehdr->e32.e_flags : ehdr->e64.e_flags; |
| @@ -108,21 +109,16 @@ int arch_elf_pt_proc(void *_ehdr, void *_phdr, struct file *elf, · 15 unmodified lines | ||
| 108 | 109 | |
| 109 | 110 | if (phdr32->p_filesz < sizeof(abiflags)) |
| 110 | 111 | return -EINVAL; |
| 111 | − | |
| 112 | − ret = kernel_read(elf, phdr32->p_offset, | |
| 113 | − (char *)&abiflags, | |
| 114 | − sizeof(abiflags)); | |
| 112 | + pos = phdr32->p_offset; | |
| 115 | 113 | } else { |
| 116 | 114 | if (phdr64->p_type != PT_MIPS_ABIFLAGS) |
| 117 | 115 | return 0; |
| 118 | 116 | if (phdr64->p_filesz < sizeof(abiflags)) |
| 119 | 117 | return -EINVAL; |
| 120 | − | |
| 121 | − ret = kernel_read(elf, phdr64->p_offset, | |
| 122 | − (char *)&abiflags, | |
| 123 | − sizeof(abiflags)); | |
| 118 | + pos = phdr64->p_offset; | |
| 124 | 119 | } |
| 125 | 120 | |
| 121 | + ret = kernel_read(elf, &abiflags, sizeof(abiflags), &pos); | |
| 126 | 122 | if (ret < 0) |
| 127 | 123 | return ret; |
| 128 | 124 | if (ret != sizeof(abiflags)) |
| @@ -148,12 +148,7 @@ void mconsole_proc(struct mc_request *req) · 147 unmodified lines | ||
| 148 | 148 | } |
| 149 | 149 | |
| 150 | 150 | do { |
| 151 | − loff_t pos = file->f_pos; | |
| 152 | − mm_segment_t old_fs = get_fs(); | |
| 153 | − set_fs(KERNEL_DS); | |
| 154 | − len = vfs_read(file, buf, PAGE_SIZE - 1, &pos); | |
| 155 | − set_fs(old_fs); | |
| 156 | − file->f_pos = pos; | |
| 151 | + len = kernel_read(file, buf, PAGE_SIZE - 1, &file->f_pos); | |
| 157 | 152 | if (len < 0) { |
| 158 | 153 | mconsole_reply(req, "Read of file failed", 1, 0); |
| 159 | 154 | goto out_free; |
| @@ -407,10 +407,10 @@ static int load_aout_library(struct file *file) · 406 unmodified lines | ||
| 407 | 407 | unsigned long bss, start_addr, len, error; |
| 408 | 408 | int retval; |
| 409 | 409 | struct exec ex; |
| 410 | − | |
| 410 | + loff_t pos = 0; | |
| 411 | 411 | |
| 412 | 412 | retval = -ENOEXEC; |
| 413 | − error = kernel_read(file, 0, (char *) &ex, sizeof(ex)); | |
| 413 | + error = kernel_read(file, &ex, sizeof(ex), &pos); | |
| 414 | 414 | if (error != sizeof(ex)) |
| 415 | 415 | goto out; |
| 416 | 416 | |
| @@ -277,7 +277,7 @@ static int cx25821_get_audio_data(struct cx25821_dev *dev, · 276 unmodified lines | ||
| 277 | 277 | p = (char *)dev->_audiodata_buf_virt_addr + frame_offset; |
| 278 | 278 | |
| 279 | 279 | for (i = 0; i < dev->_audio_lines_count; i++) { |
| 280 | − int n = kernel_read(file, file_offset, mybuf, AUDIO_LINE_SIZE); | |
| 280 | + int n = kernel_read(file, mybuf, AUDIO_LINE_SIZE, &file_offset); | |
| 281 | 281 | if (n < AUDIO_LINE_SIZE) { |
| 282 | 282 | pr_info("Done: exit %s() since no more bytes to read from Audio file\n", |
| 283 | 283 | __func__); |
| @@ -290,7 +290,6 @@ static int cx25821_get_audio_data(struct cx25821_dev *dev, · 6 unmodified lines | ||
| 290 | 290 | memcpy(p, mybuf, n); |
| 291 | 291 | p += n; |
| 292 | 292 | } |
| 293 | − file_offset += n; | |
| 294 | 293 | } |
| 295 | 294 | dev->_audioframe_count++; |
| 296 | 295 | fput(file); |
| @@ -318,7 +317,7 @@ static int cx25821_openfile_audio(struct cx25821_dev *dev, · 21 unmodified lines | ||
| 318 | 317 | { |
| 319 | 318 | char *p = (void *)dev->_audiodata_buf_virt_addr; |
| 320 | 319 | struct file *file; |
| 321 | − loff_t offset; | |
| 320 | + loff_t file_offset = 0; | |
| 322 | 321 | int i, j; |
| 323 | 322 | |
| 324 | 323 | file = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0); |
| @@ -328,11 +327,11 @@ static int cx25821_openfile_audio(struct cx25821_dev *dev, · 3 unmodified lines | ||
| 328 | 327 | return PTR_ERR(file); |
| 329 | 328 | } |
| 330 | 329 | |
| 331 | − for (j = 0, offset = 0; j < NUM_AUDIO_FRAMES; j++) { | |
| 330 | + for (j = 0; j < NUM_AUDIO_FRAMES; j++) { | |
| 332 | 331 | for (i = 0; i < dev->_audio_lines_count; i++) { |
| 333 | 332 | char buf[AUDIO_LINE_SIZE]; |
| 334 | − int n = kernel_read(file, offset, buf, | |
| 335 | − AUDIO_LINE_SIZE); | |
| 333 | + loff_t offset = file_offset; | |
| 334 | + int n = kernel_read(file, buf, AUDIO_LINE_SIZE, &file_offset); | |
| 336 | 335 | |
| 337 | 336 | if (n < AUDIO_LINE_SIZE) { |
| 338 | 337 | pr_info("Done: exit %s() since no more bytes to read from Audio file\n", |
| @@ -344,8 +343,6 @@ static int cx25821_openfile_audio(struct cx25821_dev *dev, · 5 unmodified lines | ||
| 344 | 343 | |
| 345 | 344 | if (p) |
| 346 | 345 | memcpy(p + offset, buf, n); |
| 347 | − | |
| 348 | − offset += n; | |
| 349 | 346 | } |
| 350 | 347 | dev->_audioframe_count++; |
| 351 | 348 | } |
| @@ -1356,7 +1356,7 @@ static ssize_t read_file(struct nandsim *ns, struct file *file, void *buf, size_ · 1355 unmodified lines | ||
| 1356 | 1356 | if (err) |
| 1357 | 1357 | return err; |
| 1358 | 1358 | noreclaim_flag = memalloc_noreclaim_save(); |
| 1359 | − tx = kernel_read(file, pos, buf, count); | |
| 1359 | + tx = kernel_read(file, buf, count, &pos); | |
| 1360 | 1360 | memalloc_noreclaim_restore(noreclaim_flag); |
| 1361 | 1361 | put_pages(ns); |
| 1362 | 1362 | return tx; |
| @@ -1372,7 +1372,7 @@ static ssize_t write_file(struct nandsim *ns, struct file *file, void *buf, size · 9 unmodified lines | ||
| 1372 | 1372 | if (err) |
| 1373 | 1373 | return err; |
| 1374 | 1374 | noreclaim_flag = memalloc_noreclaim_save(); |
| 1375 | − tx = kernel_write(file, buf, count, pos); | |
| 1375 | + tx = kernel_write(file, buf, count, &pos); | |
| 1376 | 1376 | memalloc_noreclaim_restore(noreclaim_flag); |
| 1377 | 1377 | put_pages(ns); |
| 1378 | 1378 | return tx; |
| @@ -294,19 +294,9 @@ static int ashmem_release(struct inode *ignored, struct file *file) · 293 unmodified lines | ||
| 294 | 294 | return 0; |
| 295 | 295 | } |
| 296 | 296 | |
| 297 | −/** | |
| 298 | − * ashmem_read() - Reads a set of bytes from an Ashmem-enabled file | |
| 299 | − * @file: The associated backing file. | |
| 300 | − * @buf: The buffer of data being written to | |
| 301 | − * @len: The number of bytes being read | |
| 302 | − * @pos: The position of the first byte to read. | |
| 303 | − * | |
| 304 | − * Return: 0 if successful, or another return code if not. | |
| 305 | − */ | |
| 306 | −static ssize_t ashmem_read(struct file *file, char __user *buf, | |
| 307 | − size_t len, loff_t *pos) | |
| 297 | +static ssize_t ashmem_read_iter(struct kiocb *iocb, struct iov_iter *iter) | |
| 308 | 298 | { |
| 309 | − struct ashmem_area *asma = file->private_data; | |
| 299 | + struct ashmem_area *asma = iocb->ki_filp->private_data; | |
| 310 | 300 | int ret = 0; |
| 311 | 301 | |
| 312 | 302 | mutex_lock(&ashmem_mutex); |
| @@ -320,20 +310,17 @@ static ssize_t ashmem_read(struct file *file, char __user *buf, · 7 unmodified lines | ||
| 320 | 310 | goto out_unlock; |
| 321 | 311 | } |
| 322 | 312 | |
| 323 | − mutex_unlock(&ashmem_mutex); | |
| 324 | − | |
| 325 | 313 | /* |
| 326 | 314 | * asma and asma->file are used outside the lock here. We assume |
| 327 | 315 | * once asma->file is set it will never be changed, and will not |
| 328 | 316 | * be destroyed until all references to the file are dropped and |
| 329 | 317 | * ashmem_release is called. |
| 330 | 318 | */ |
| 331 | − ret = __vfs_read(asma->file, buf, len, pos); | |
| 332 | − if (ret >= 0) | |
| 333 | − /** Update backing file pos, since f_ops->read() doesn't */ | |
| 334 | − asma->file->f_pos = *pos; | |
| 335 | − return ret; | |
| 336 | − | |
| 319 | + mutex_unlock(&ashmem_mutex); | |
| 320 | + ret = vfs_iter_read(asma->file, iter, &iocb->ki_pos, 0); | |
| 321 | + mutex_lock(&ashmem_mutex); | |
| 322 | + if (ret > 0) | |
| 323 | + asma->file->f_pos = iocb->ki_pos; | |
| 337 | 324 | out_unlock: |
| 338 | 325 | mutex_unlock(&ashmem_mutex); |
| 339 | 326 | return ret; |
| @@ -834,7 +821,7 @@ static const struct file_operations ashmem_fops = { · 494 unmodified lines | ||
| 834 | 821 | .owner = THIS_MODULE, |
| 835 | 822 | .open = ashmem_open, |
| 836 | 823 | .release = ashmem_release, |
| 837 | − .read = ashmem_read, | |
| 824 | + .read_iter = ashmem_read_iter, | |
| 838 | 825 | .llseek = ashmem_llseek, |
| 839 | 826 | .mmap = ashmem_mmap, |
| 840 | 827 | .unlocked_ioctl = ashmem_ioctl, |
| @@ -106,16 +106,8 @@ static long serial2002_tty_ioctl(struct file *f, unsigned int op, · 105 unmodified lines | ||
| 106 | 106 | |
| 107 | 107 | static int serial2002_tty_write(struct file *f, unsigned char *buf, int count) |
| 108 | 108 | { |
| 109 | − const char __user *p = (__force const char __user *)buf; | |
| 110 | − int result; | |
| 111 | − loff_t offset = 0; | |
| 112 | − mm_segment_t oldfs; | |
| 113 | − | |
| 114 | − oldfs = get_fs(); | |
| 115 | − set_fs(KERNEL_DS); | |
| 116 | − result = __vfs_write(f, p, count, &offset); | |
| 117 | − set_fs(oldfs); | |
| 118 | − return result; | |
| 109 | + loff_t pos = 0; | |
| 110 | + return kernel_write(f, buf, count, &pos); | |
| 119 | 111 | } |
| 120 | 112 | |
| 121 | 113 | static void serial2002_tty_read_poll_wait(struct file *f, int timeout) |
| @@ -148,19 +140,14 @@ static int serial2002_tty_read(struct file *f, int timeout) · 26 unmodified lines | ||
| 148 | 140 | { |
| 149 | 141 | unsigned char ch; |
| 150 | 142 | int result; |
| 143 | + loff_t pos = 0; | |
| 151 | 144 | |
| 152 | 145 | result = -1; |
| 153 | 146 | if (!IS_ERR(f)) { |
| 154 | − mm_segment_t oldfs; | |
| 155 | − char __user *p = (__force char __user *)&ch; | |
| 156 | − loff_t offset = 0; | |
| 157 | − | |
| 158 | − oldfs = get_fs(); | |
| 159 | − set_fs(KERNEL_DS); | |
| 160 | 147 | if (f->f_op->poll) { |
| 161 | 148 | serial2002_tty_read_poll_wait(f, timeout); |
| 162 | 149 | |
| 163 | − if (__vfs_read(f, p, 1, &offset) == 1) | |
| 150 | + if (kernel_read(f, &ch, 1, &pos) == 1) | |
| 164 | 151 | result = ch; |
| 165 | 152 | } else { |
| 166 | 153 | /* Device does not support poll, busy wait */ |
| @@ -171,14 +158,13 @@ static int serial2002_tty_read(struct file *f, int timeout) · 4 unmodified lines | ||
| 171 | 158 | if (retries >= timeout) |
| 172 | 159 | break; |
| 173 | 160 | |
| 174 | − if (__vfs_read(f, p, 1, &offset) == 1) { | |
| 161 | + if (kernel_read(f, &ch, 1, &pos) == 1) { | |
| 175 | 162 | result = ch; |
| 176 | 163 | break; |
| 177 | 164 | } |
| 178 | 165 | usleep_range(100, 1000); |
| 179 | 166 | } |
| 180 | 167 | } |
| 181 | − set_fs(oldfs); | |
| 182 | 168 | } |
| 183 | 169 | return result; |
| 184 | 170 | } |
| @@ -731,8 +731,7 @@ int cfs_tracefile_dump_all_pages(char *filename) · 730 unmodified lines | ||
| 731 | 731 | __LASSERT_TAGE_INVARIANT(tage); |
| 732 | 732 | |
| 733 | 733 | buf = kmap(tage->page); |
| 734 | − rc = vfs_write(filp, (__force const char __user *)buf, | |
| 735 | − tage->used, &filp->f_pos); | |
| 734 | + rc = kernel_write(filp, buf, tage->used, &filp->f_pos); | |
| 736 | 735 | kunmap(tage->page); |
| 737 | 736 | |
| 738 | 737 | if (rc != (int)tage->used) { |
| @@ -976,7 +975,6 @@ static int tracefiled(void *arg) · 237 unmodified lines | ||
| 976 | 975 | struct tracefiled_ctl *tctl = arg; |
| 977 | 976 | struct cfs_trace_page *tage; |
| 978 | 977 | struct cfs_trace_page *tmp; |
| 979 | − mm_segment_t __oldfs; | |
| 980 | 978 | struct file *filp; |
| 981 | 979 | char *buf; |
| 982 | 980 | int last_loop = 0; |
| @@ -1014,8 +1012,6 @@ static int tracefiled(void *arg) · 31 unmodified lines | ||
| 1014 | 1012 | __LASSERT(list_empty(&pc.pc_pages)); |
| 1015 | 1013 | goto end_loop; |
| 1016 | 1014 | } |
| 1017 | − __oldfs = get_fs(); | |
| 1018 | − set_fs(get_ds()); | |
| 1019 | 1015 | |
| 1020 | 1016 | list_for_each_entry_safe(tage, tmp, &pc.pc_pages, linkage) { |
| 1021 | 1017 | static loff_t f_pos; |
| @@ -1028,8 +1024,7 @@ static int tracefiled(void *arg) · 6 unmodified lines | ||
| 1028 | 1024 | f_pos = i_size_read(file_inode(filp)); |
| 1029 | 1025 | |
| 1030 | 1026 | buf = kmap(tage->page); |
| 1031 | − rc = vfs_write(filp, (__force const char __user *)buf, | |
| 1032 | − tage->used, &f_pos); | |
| 1027 | + rc = kernel_write(filp, buf, tage->used, &f_pos); | |
| 1033 | 1028 | kunmap(tage->page); |
| 1034 | 1029 | |
| 1035 | 1030 | if (rc != (int)tage->used) { |
| @@ -1040,7 +1035,6 @@ static int tracefiled(void *arg) · 4 unmodified lines | ||
| 1040 | 1035 | break; |
| 1041 | 1036 | } |
| 1042 | 1037 | } |
| 1043 | − set_fs(__oldfs); | |
| 1044 | 1038 | |
| 1045 | 1039 | filp_close(filp, NULL); |
| 1046 | 1040 | put_pages_on_daemon_list(&pc); |
| @@ -52,7 +52,6 @@ int libcfs_kkuc_msg_put(struct file *filp, void *payload) · 51 unmodified lines | ||
| 52 | 52 | struct kuc_hdr *kuch = (struct kuc_hdr *)payload; |
| 53 | 53 | ssize_t count = kuch->kuc_msglen; |
| 54 | 54 | loff_t offset = 0; |
| 55 | − mm_segment_t fs; | |
| 56 | 55 | int rc = -ENXIO; |
| 57 | 56 | |
| 58 | 57 | if (IS_ERR_OR_NULL(filp)) |
| @@ -63,18 +62,14 @@ int libcfs_kkuc_msg_put(struct file *filp, void *payload) · 4 unmodified lines | ||
| 63 | 62 | return rc; |
| 64 | 63 | } |
| 65 | 64 | |
| 66 | − fs = get_fs(); | |
| 67 | − set_fs(KERNEL_DS); | |
| 68 | 65 | while (count > 0) { |
| 69 | − rc = vfs_write(filp, (void __force __user *)payload, | |
| 70 | − count, &offset); | |
| 66 | + rc = kernel_write(filp, payload, count, &offset); | |
| 71 | 67 | if (rc < 0) |
| 72 | 68 | break; |
| 73 | 69 | count -= rc; |
| 74 | 70 | payload += rc; |
| 75 | 71 | rc = 0; |
| 76 | 72 | } |
| 77 | − set_fs(fs); | |
| 78 | 73 | |
| 79 | 74 | if (rc < 0) |
| 80 | 75 | CWARN("message send failed (%d)\n", rc); |
| @@ -896,13 +896,14 @@ static int core_alua_write_tpg_metadata( · 895 unmodified lines | ||
| 896 | 896 | u32 md_buf_len) |
| 897 | 897 | { |
| 898 | 898 | struct file *file = filp_open(path, O_RDWR | O_CREAT | O_TRUNC, 0600); |
| 899 | + loff_t pos = 0; | |
| 899 | 900 | int ret; |
| 900 | 901 | |
| 901 | 902 | if (IS_ERR(file)) { |
| 902 | 903 | pr_err("filp_open(%s) for ALUA metadata failed\n", path); |
| 903 | 904 | return -ENODEV; |
| 904 | 905 | } |
| 905 | − ret = kernel_write(file, md_buf, md_buf_len, 0); | |
| 906 | + ret = kernel_write(file, md_buf, md_buf_len, &pos); | |
| 906 | 907 | if (ret < 0) |
| 907 | 908 | pr_err("Error writing ALUA metadata file: %s\n", path); |
| 908 | 909 | fput(file); |
| @@ -443,7 +443,7 @@ fd_do_prot_fill(struct se_device *se_dev, sector_t lba, sector_t nolb, · 442 unmodified lines | ||
| 443 | 443 | |
| 444 | 444 | for (prot = 0; prot < prot_length;) { |
| 445 | 445 | sector_t len = min_t(sector_t, bufsize, prot_length - prot); |
| 446 | − ssize_t ret = kernel_write(prot_fd, buf, len, pos + prot); | |
| 446 | + ssize_t ret = kernel_write(prot_fd, buf, len, &pos); | |
| 447 | 447 | |
| 448 | 448 | if (ret != len) { |
| 449 | 449 | pr_err("vfs_write to prot file failed: %zd\n", ret); |
| @@ -1974,6 +1974,7 @@ static int __core_scsi3_write_aptpl_to_file( · 1973 unmodified lines | ||
| 1974 | 1974 | char path[512]; |
| 1975 | 1975 | u32 pr_aptpl_buf_len; |
| 1976 | 1976 | int ret; |
| 1977 | + loff_t pos = 0; | |
| 1977 | 1978 | |
| 1978 | 1979 | memset(path, 0, 512); |
| 1979 | 1980 | |
| @@ -1993,7 +1994,7 @@ static int __core_scsi3_write_aptpl_to_file( · 13 unmodified lines | ||
| 1993 | 1994 | |
| 1994 | 1995 | pr_aptpl_buf_len = (strlen(buf) + 1); /* Add extra for NULL */ |
| 1995 | 1996 | |
| 1996 | − ret = kernel_write(file, buf, pr_aptpl_buf_len, 0); | |
| 1997 | + ret = kernel_write(file, buf, pr_aptpl_buf_len, &pos); | |
| 1997 | 1998 | |
| 1998 | 1999 | if (ret < 0) |
| 1999 | 2000 | pr_debug("Error writing APTPL metadata file: %s\n", path); |
| @@ -686,9 +686,8 @@ static int do_read(struct fsg_common *common) · 685 unmodified lines | ||
| 686 | 686 | |
| 687 | 687 | /* Perform the read */ |
| 688 | 688 | file_offset_tmp = file_offset; |
| 689 | − nread = vfs_read(curlun->filp, | |
| 690 | − (char __user *)bh->buf, | |
| 691 | − amount, &file_offset_tmp); | |
| 689 | + nread = kernel_read(curlun->filp, bh->buf, amount, | |
| 690 | + &file_offset_tmp); | |
| 692 | 691 | VLDBG(curlun, "file read %u @ %llu -> %d\n", amount, |
| 693 | 692 | (unsigned long long)file_offset, (int)nread); |
| 694 | 693 | if (signal_pending(current)) |
| @@ -883,8 +882,8 @@ static int do_write(struct fsg_common *common) · 188 unmodified lines | ||
| 883 | 882 | |
| 884 | 883 | /* Perform the write */ |
| 885 | 884 | file_offset_tmp = file_offset; |
| 886 | − nwritten = vfs_write(curlun->filp, (char __user *)bh->buf, | |
| 887 | − amount, &file_offset_tmp); | |
| 885 | + nwritten = kernel_write(curlun->filp, bh->buf, amount, | |
| 886 | + &file_offset_tmp); | |
| 888 | 887 | VLDBG(curlun, "file write %u @ %llu -> %d\n", amount, |
| 889 | 888 | (unsigned long long)file_offset, (int)nwritten); |
| 890 | 889 | if (signal_pending(current)) |
| @@ -1021,9 +1020,8 @@ static int do_verify(struct fsg_common *common) · 130 unmodified lines | ||
| 1021 | 1020 | |
| 1022 | 1021 | /* Perform the read */ |
| 1023 | 1022 | file_offset_tmp = file_offset; |
| 1024 | − nread = vfs_read(curlun->filp, | |
| 1025 | − (char __user *) bh->buf, | |
| 1026 | − amount, &file_offset_tmp); | |
| 1023 | + nread = kernel_read(curlun->filp, bh->buf, amount, | |
| 1024 | + &file_offset_tmp); | |
| 1027 | 1025 | VLDBG(curlun, "file read %u @ %llu -> %d\n", amount, |
| 1028 | 1026 | (unsigned long long) file_offset, |
| 1029 | 1027 | (int) nread); |
| @@ -2453,13 +2451,6 @@ static int fsg_main_thread(void *common_) · 1423 unmodified lines | ||
| 2453 | 2451 | /* Allow the thread to be frozen */ |
| 2454 | 2452 | set_freezable(); |
| 2455 | 2453 | |
| 2456 | − /* | |
| 2457 | − * Arrange for userspace references to be interpreted as kernel | |
| 2458 | − * pointers. That way we can pass a kernel pointer to a routine | |
| 2459 | − * that expects a __user pointer and it will work okay. | |
| 2460 | − */ | |
| 2461 | − set_fs(get_ds()); | |
| 2462 | − | |
| 2463 | 2454 | /* The main loop */ |
| 2464 | 2455 | while (common->state != FSG_STATE_TERMINATED) { |
| 2465 | 2456 | if (exception_in_progress(common) || signal_pending(current)) { |
| @@ -56,19 +56,14 @@ static int autofs4_write(struct autofs_sb_info *sbi, · 55 unmodified lines | ||
| 56 | 56 | struct file *file, const void *addr, int bytes) |
| 57 | 57 | { |
| 58 | 58 | unsigned long sigpipe, flags; |
| 59 | − mm_segment_t fs; | |
| 60 | 59 | const char *data = (const char *)addr; |
| 61 | 60 | ssize_t wr = 0; |
| 62 | 61 | |
| 63 | 62 | sigpipe = sigismember(¤t->pending.signal, SIGPIPE); |
| 64 | 63 | |
| 65 | − /* Save pointer to user space and point back to kernel space */ | |
| 66 | − fs = get_fs(); | |
| 67 | − set_fs(KERNEL_DS); | |
| 68 | − | |
| 69 | 64 | mutex_lock(&sbi->pipe_mutex); |
| 70 | 65 | while (bytes) { |
| 71 | − wr = __vfs_write(file, data, bytes, &file->f_pos); | |
| 66 | + wr = __kernel_write(file, data, bytes, &file->f_pos); | |
| 72 | 67 | if (wr <= 0) |
| 73 | 68 | break; |
| 74 | 69 | data += wr; |
| @@ -76,8 +71,6 @@ static int autofs4_write(struct autofs_sb_info *sbi, · 1 unmodified line | ||
| 76 | 71 | } |
| 77 | 72 | mutex_unlock(&sbi->pipe_mutex); |
| 78 | 73 | |
| 79 | − set_fs(fs); | |
| 80 | − | |
| 81 | 74 | /* Keep the currently executing process from receiving a |
| 82 | 75 | * SIGPIPE unless it was already supposed to get one |
| 83 | 76 | */ |
| @@ -341,11 +341,12 @@ static int load_aout_library(struct file *file) · 340 unmodified lines | ||
| 341 | 341 | unsigned long error; |
| 342 | 342 | int retval; |
| 343 | 343 | struct exec ex; |
| 344 | + loff_t pos = 0; | |
| 344 | 345 | |
| 345 | 346 | inode = file_inode(file); |
| 346 | 347 | |
| 347 | 348 | retval = -ENOEXEC; |
| 348 | − error = kernel_read(file, 0, (char *) &ex, sizeof(ex)); | |
| 349 | + error = kernel_read(file, &ex, sizeof(ex), &pos); | |
| 349 | 350 | if (error != sizeof(ex)) |
| 350 | 351 | goto out; |
| 351 | 352 | |
| @@ -409,6 +409,7 @@ static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex, · 408 unmodified lines | ||
| 409 | 409 | { |
| 410 | 410 | struct elf_phdr *elf_phdata = NULL; |
| 411 | 411 | int retval, size, err = -1; |
| 412 | + loff_t pos = elf_ex->e_phoff; | |
| 412 | 413 | |
| 413 | 414 | /* |
| 414 | 415 | * If the size of this structure has changed, then punt, since |
| @@ -432,8 +433,7 @@ static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex, · 17 unmodified lines | ||
| 432 | 433 | goto out; |
| 433 | 434 | |
| 434 | 435 | /* Read in the program headers */ |
| 435 | − retval = kernel_read(elf_file, elf_ex->e_phoff, | |
| 436 | − (char *)elf_phdata, size); | |
| 436 | + retval = kernel_read(elf_file, elf_phdata, size, &pos); | |
| 437 | 437 | if (retval != size) { |
| 438 | 438 | err = (retval < 0) ? retval : -EIO; |
| 439 | 439 | goto out; |
| @@ -698,6 +698,7 @@ static int load_elf_binary(struct linux_binprm *bprm) · 258 unmodified lines | ||
| 698 | 698 | struct elfhdr interp_elf_ex; |
| 699 | 699 | } *loc; |
| 700 | 700 | struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE; |
| 701 | + loff_t pos; | |
| 701 | 702 | |
| 702 | 703 | loc = kmalloc(sizeof(*loc), GFP_KERNEL); |
| 703 | 704 | if (!loc) { |
| @@ -750,9 +751,9 @@ static int load_elf_binary(struct linux_binprm *bprm) · 46 unmodified lines | ||
| 750 | 751 | if (!elf_interpreter) |
| 751 | 752 | goto out_free_ph; |
| 752 | 753 | |
| 753 | − retval = kernel_read(bprm->file, elf_ppnt->p_offset, | |
| 754 | − elf_interpreter, | |
| 755 | − elf_ppnt->p_filesz); | |
| 754 | + pos = elf_ppnt->p_offset; | |
| 755 | + retval = kernel_read(bprm->file, elf_interpreter, | |
| 756 | + elf_ppnt->p_filesz, &pos); | |
| 756 | 757 | if (retval != elf_ppnt->p_filesz) { |
| 757 | 758 | if (retval >= 0) |
| 758 | 759 | retval = -EIO; |
| @@ -776,9 +777,9 @@ static int load_elf_binary(struct linux_binprm *bprm) · 17 unmodified lines | ||
| 776 | 777 | would_dump(bprm, interpreter); |
| 777 | 778 | |
| 778 | 779 | /* Get the exec headers */ |
| 779 | − retval = kernel_read(interpreter, 0, | |
| 780 | − (void *)&loc->interp_elf_ex, | |
| 781 | − sizeof(loc->interp_elf_ex)); | |
| 780 | + pos = 0; | |
| 781 | + retval = kernel_read(interpreter, &loc->interp_elf_ex, | |
| 782 | + sizeof(loc->interp_elf_ex), &pos); | |
| 782 | 783 | if (retval != sizeof(loc->interp_elf_ex)) { |
| 783 | 784 | if (retval >= 0) |
| 784 | 785 | retval = -EIO; |
| @@ -1175,9 +1176,10 @@ static int load_elf_library(struct file *file) · 390 unmodified lines | ||
| 1175 | 1176 | unsigned long elf_bss, bss, len; |
| 1176 | 1177 | int retval, error, i, j; |
| 1177 | 1178 | struct elfhdr elf_ex; |
| 1179 | + loff_t pos = 0; | |
| 1178 | 1180 | |
| 1179 | 1181 | error = -ENOEXEC; |
| 1180 | − retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex)); | |
| 1182 | + retval = kernel_read(file, &elf_ex, sizeof(elf_ex), &pos); | |
| 1181 | 1183 | if (retval != sizeof(elf_ex)) |
| 1182 | 1184 | goto out; |
| 1183 | 1185 | |
| @@ -1201,7 +1203,8 @@ static int load_elf_library(struct file *file) · 17 unmodified lines | ||
| 1201 | 1203 | |
| 1202 | 1204 | eppnt = elf_phdata; |
| 1203 | 1205 | error = -ENOEXEC; |
| 1204 | − retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j); | |
| 1206 | + pos = elf_ex.e_phoff; | |
| 1207 | + retval = kernel_read(file, eppnt, j, &pos); | |
| 1205 | 1208 | if (retval != j) |
| 1206 | 1209 | goto out_free_ph; |
| 1207 | 1210 | |
| @@ -145,6 +145,7 @@ static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *params, · 144 unmodified lines | ||
| 145 | 145 | struct elf32_phdr *phdr; |
| 146 | 146 | unsigned long size; |
| 147 | 147 | int retval, loop; |
| 148 | + loff_t pos = params->hdr.e_phoff; | |
| 148 | 149 | |
| 149 | 150 | if (params->hdr.e_phentsize != sizeof(struct elf_phdr)) |
| 150 | 151 | return -ENOMEM; |
| @@ -156,8 +157,7 @@ static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *params, · 5 unmodified lines | ||
| 156 | 157 | if (!params->phdrs) |
| 157 | 158 | return -ENOMEM; |
| 158 | 159 | |
| 159 | − retval = kernel_read(file, params->hdr.e_phoff, | |
| 160 | − (char *) params->phdrs, size); | |
| 160 | + retval = kernel_read(file, params->phdrs, size, &pos); | |
| 161 | 161 | if (unlikely(retval != size)) |
| 162 | 162 | return retval < 0 ? retval : -ENOEXEC; |
| 163 | 163 | |
| @@ -199,6 +199,7 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm) · 35 unmodified lines | ||
| 199 | 199 | char *interpreter_name = NULL; |
| 200 | 200 | int executable_stack; |
| 201 | 201 | int retval, i; |
| 202 | + loff_t pos; | |
| 202 | 203 | |
| 203 | 204 | kdebug("____ LOAD %d ____", current->pid); |
| 204 | 205 | |
| @@ -246,10 +247,9 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm) · 41 unmodified lines | ||
| 246 | 247 | if (!interpreter_name) |
| 247 | 248 | goto error; |
| 248 | 249 | |
| 249 | − retval = kernel_read(bprm->file, | |
| 250 | − phdr->p_offset, | |
| 251 | − interpreter_name, | |
| 252 | − phdr->p_filesz); | |
| 250 | + pos = phdr->p_offset; | |
| 251 | + retval = kernel_read(bprm->file, interpreter_name, | |
| 252 | + phdr->p_filesz, &pos); | |
| 253 | 253 | if (unlikely(retval != phdr->p_filesz)) { |
| 254 | 254 | if (retval >= 0) |
| 255 | 255 | retval = -ENOEXEC; |
| @@ -277,8 +277,9 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm) · 21 unmodified lines | ||
| 277 | 277 | */ |
| 278 | 278 | would_dump(bprm, interpreter); |
| 279 | 279 | |
| 280 | − retval = kernel_read(interpreter, 0, bprm->buf, | |
| 281 | − BINPRM_BUF_SIZE); | |
| 280 | + pos = 0; | |
| 281 | + retval = kernel_read(interpreter, bprm->buf, | |
| 282 | + BINPRM_BUF_SIZE, &pos); | |
| 282 | 283 | if (unlikely(retval != BINPRM_BUF_SIZE)) { |
| 283 | 284 | if (retval >= 0) |
| 284 | 285 | retval = -ENOEXEC; |
| @@ -176,19 +176,14 @@ static int create_flat_tables(struct linux_binprm *bprm, unsigned long arg_start · 175 unmodified lines | ||
| 176 | 176 | #define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ |
| 177 | 177 | #define RESERVED 0xC0 /* bit 6,7: reserved */ |
| 178 | 178 | |
| 179 | −static int decompress_exec( | |
| 180 | − struct linux_binprm *bprm, | |
| 181 | − unsigned long offset, | |
| 182 | − char *dst, | |
| 183 | − long len, | |
| 184 | − int fd) | |
| 179 | +static int decompress_exec(struct linux_binprm *bprm, loff_t fpos, char *dst, | |
| 180 | + long len, int fd) | |
| 185 | 181 | { |
| 186 | 182 | unsigned char *buf; |
| 187 | 183 | z_stream strm; |
| 188 | − loff_t fpos; | |
| 189 | 184 | int ret, retval; |
| 190 | 185 | |
| 191 | − pr_debug("decompress_exec(offset=%lx,buf=%p,len=%lx)\n", offset, dst, len); | |
| 186 | + pr_debug("decompress_exec(offset=%llx,buf=%p,len=%lx)\n", fpos, dst, len); | |
| 192 | 187 | |
| 193 | 188 | memset(&strm, 0, sizeof(strm)); |
| 194 | 189 | strm.workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL); |
| @@ -202,13 +197,11 @@ static int decompress_exec( · 7 unmodified lines | ||
| 202 | 197 | } |
| 203 | 198 | |
| 204 | 199 | /* Read in first chunk of data and parse gzip header. */ |
| 205 | − fpos = offset; | |
| 206 | − ret = kernel_read(bprm->file, offset, buf, LBUFSIZE); | |
| 200 | + ret = kernel_read(bprm->file, buf, LBUFSIZE, &fpos); | |
| 207 | 201 | |
| 208 | 202 | strm.next_in = buf; |
| 209 | 203 | strm.avail_in = ret; |
| 210 | 204 | strm.total_in = 0; |
| 211 | − fpos += ret; | |
| 212 | 205 | |
| 213 | 206 | retval = -ENOEXEC; |
| 214 | 207 | |
| @@ -274,7 +267,7 @@ static int decompress_exec( · 59 unmodified lines | ||
| 274 | 267 | } |
| 275 | 268 | |
| 276 | 269 | while ((ret = zlib_inflate(&strm, Z_NO_FLUSH)) == Z_OK) { |
| 277 | − ret = kernel_read(bprm->file, fpos, buf, LBUFSIZE); | |
| 270 | + ret = kernel_read(bprm->file, buf, LBUFSIZE, &fpos); | |
| 278 | 271 | if (ret <= 0) |
| 279 | 272 | break; |
| 280 | 273 | len -= ret; |
| @@ -282,7 +275,6 @@ static int decompress_exec( · 1 unmodified line | ||
| 282 | 275 | strm.next_in = buf; |
| 283 | 276 | strm.avail_in = ret; |
| 284 | 277 | strm.total_in = 0; |
| 285 | − fpos += ret; | |
| 286 | 278 | } |
| 287 | 279 | |
| 288 | 280 | if (ret < 0) { |
| @@ -218,12 +218,15 @@ static int load_misc_binary(struct linux_binprm *bprm) · 217 unmodified lines | ||
| 218 | 218 | |
| 219 | 219 | bprm->file = interp_file; |
| 220 | 220 | if (fmt->flags & MISC_FMT_CREDENTIALS) { |
| 221 | + loff_t pos = 0; | |
| 222 | + | |
| 221 | 223 | /* |
| 222 | 224 | * No need to call prepare_binprm(), it's already been |
| 223 | 225 | * done. bprm->buf is stale, update from interp_file. |
| 224 | 226 | */ |
| 225 | 227 | memset(bprm->buf, 0, BINPRM_BUF_SIZE); |
| 226 | − retval = kernel_read(bprm->file, 0, bprm->buf, BINPRM_BUF_SIZE); | |
| 228 | + retval = kernel_read(bprm->file, bprm->buf, BINPRM_BUF_SIZE, | |
| 229 | + &pos); | |
| 227 | 230 | } else |
| 228 | 231 | retval = prepare_binprm(bprm); |
| 229 | 232 | |
| @@ -539,33 +539,23 @@ static struct btrfs_path *alloc_path_for_send(void) · 538 unmodified lines | ||
| 539 | 539 | static int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off) |
| 540 | 540 | { |
| 541 | 541 | int ret; |
| 542 | − mm_segment_t old_fs; | |
| 543 | 542 | u32 pos = 0; |
| 544 | 543 | |
| 545 | − old_fs = get_fs(); | |
| 546 | − set_fs(KERNEL_DS); | |
| 547 | − | |
| 548 | 544 | while (pos < len) { |
| 549 | − ret = vfs_write(filp, (__force const char __user *)buf + pos, | |
| 550 | − len - pos, off); | |
| 545 | + ret = kernel_write(filp, buf + pos, len - pos, off); | |
| 551 | 546 | /* TODO handle that correctly */ |
| 552 | 547 | /*if (ret == -ERESTARTSYS) { |
| 553 | 548 | continue; |
| 554 | 549 | }*/ |
| 555 | 550 | if (ret < 0) |
| 556 | − goto out; | |
| 551 | + return ret; | |
| 557 | 552 | if (ret == 0) { |
| 558 | − ret = -EIO; | |
| 559 | − goto out; | |
| 553 | + return -EIO; | |
| 560 | 554 | } |
| 561 | 555 | pos += ret; |
| 562 | 556 | } |
| 563 | 557 | |
| 564 | − ret = 0; | |
| 565 | − | |
| 566 | −out: | |
| 567 | − set_fs(old_fs); | |
| 568 | − return ret; | |
| 558 | + return 0; | |
| 569 | 559 | } |
| 570 | 560 | |
| 571 | 561 | static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len) |
| @@ -368,9 +368,10 @@ static int coda_venus_readdir(struct file *coda_file, struct dir_context *ctx) · 367 unmodified lines | ||
| 368 | 368 | goto out; |
| 369 | 369 | |
| 370 | 370 | while (1) { |
| 371 | + loff_t pos = ctx->pos - 2; | |
| 372 | + | |
| 371 | 373 | /* read entries from the directory file */ |
| 372 | − ret = kernel_read(host_file, ctx->pos - 2, (char *)vdir, | |
| 373 | − sizeof(*vdir)); | |
| 374 | + ret = kernel_read(host_file, vdir, sizeof(*vdir), &pos); | |
| 374 | 375 | if (ret < 0) { |
| 375 | 376 | pr_err("%s: read dir %s failed %d\n", |
| 376 | 377 | __func__, coda_f2s(&cii->c_fid), ret); |
| @@ -47,7 +47,7 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data, · 46 unmodified lines | ||
| 47 | 47 | lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file; |
| 48 | 48 | if (!lower_file) |
| 49 | 49 | return -EIO; |
| 50 | − rc = kernel_write(lower_file, data, size, offset); | |
| 50 | + rc = kernel_write(lower_file, data, size, &offset); | |
| 51 | 51 | mark_inode_dirty_sync(ecryptfs_inode); |
| 52 | 52 | return rc; |
| 53 | 53 | } |
| @@ -237,7 +237,7 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size, · 183 unmodified lines | ||
| 237 | 237 | lower_file = ecryptfs_inode_to_private(ecryptfs_inode)->lower_file; |
| 238 | 238 | if (!lower_file) |
| 239 | 239 | return -EIO; |
| 240 | − return kernel_read(lower_file, offset, data, size); | |
| 240 | + return kernel_read(lower_file, data, size, &offset); | |
| 241 | 241 | } |
| 242 | 242 | |
| 243 | 243 | /** |
| @@ -885,23 +885,6 @@ struct file *open_exec(const char *name) · 884 unmodified lines | ||
| 885 | 885 | } |
| 886 | 886 | EXPORT_SYMBOL(open_exec); |
| 887 | 887 | |
| 888 | −int kernel_read(struct file *file, loff_t offset, | |
| 889 | − char *addr, unsigned long count) | |
| 890 | −{ | |
| 891 | − mm_segment_t old_fs; | |
| 892 | − loff_t pos = offset; | |
| 893 | − int result; | |
| 894 | − | |
| 895 | − old_fs = get_fs(); | |
| 896 | − set_fs(get_ds()); | |
| 897 | − /* The cast to a user pointer is valid due to the set_fs() */ | |
| 898 | − result = vfs_read(file, (void __user *)addr, count, &pos); | |
| 899 | − set_fs(old_fs); | |
| 900 | − return result; | |
| 901 | −} | |
| 902 | − | |
| 903 | −EXPORT_SYMBOL(kernel_read); | |
| 904 | − | |
| 905 | 888 | int kernel_read_file(struct file *file, void **buf, loff_t *size, |
| 906 | 889 | loff_t max_size, enum kernel_read_file_id id) |
| 907 | 890 | { |
| @@ -939,8 +922,7 @@ int kernel_read_file(struct file *file, void **buf, loff_t *size, · 31 unmodified lines | ||
| 939 | 922 | |
| 940 | 923 | pos = 0; |
| 941 | 924 | while (pos < i_size) { |
| 942 | − bytes = kernel_read(file, pos, (char *)(*buf) + pos, | |
| 943 | − i_size - pos); | |
| 925 | + bytes = kernel_read(file, *buf + pos, i_size - pos, &pos); | |
| 944 | 926 | if (bytes < 0) { |
| 945 | 927 | ret = bytes; |
| 946 | 928 | goto out; |
| @@ -948,7 +930,6 @@ int kernel_read_file(struct file *file, void **buf, loff_t *size, · 1 unmodified line | ||
| 948 | 930 | |
| 949 | 931 | if (bytes == 0) |
| 950 | 932 | break; |
| 951 | − pos += bytes; | |
| 952 | 933 | } |
| 953 | 934 | |
| 954 | 935 | if (pos != i_size) { |
| @@ -1567,6 +1548,7 @@ static void bprm_fill_uid(struct linux_binprm *bprm) · 612 unmodified lines | ||
| 1567 | 1548 | int prepare_binprm(struct linux_binprm *bprm) |
| 1568 | 1549 | { |
| 1569 | 1550 | int retval; |
| 1551 | + loff_t pos = 0; | |
| 1570 | 1552 | |
| 1571 | 1553 | bprm_fill_uid(bprm); |
| 1572 | 1554 | |
| @@ -1577,7 +1559,7 @@ int prepare_binprm(struct linux_binprm *bprm) · 4 unmodified lines | ||
| 1577 | 1559 | bprm->called_set_creds = 1; |
| 1578 | 1560 | |
| 1579 | 1561 | memset(bprm->buf, 0, BINPRM_BUF_SIZE); |
| 1580 | − return kernel_read(bprm->file, 0, bprm->buf, BINPRM_BUF_SIZE); | |
| 1562 | + return kernel_read(bprm->file, bprm->buf, BINPRM_BUF_SIZE, &pos); | |
| 1581 | 1563 | } |
| 1582 | 1564 | |
| 1583 | 1565 | EXPORT_SYMBOL(prepare_binprm); |
| @@ -413,7 +413,20 @@ ssize_t __vfs_read(struct file *file, char __user *buf, size_t count, · 412 unmodified lines | ||
| 413 | 413 | else |
| 414 | 414 | return -EINVAL; |
| 415 | 415 | } |
| 416 | −EXPORT_SYMBOL(__vfs_read); | |
| 416 | + | |
| 417 | +ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos) | |
| 418 | +{ | |
| 419 | + mm_segment_t old_fs; | |
| 420 | + ssize_t result; | |
| 421 | + | |
| 422 | + old_fs = get_fs(); | |
| 423 | + set_fs(get_ds()); | |
| 424 | + /* The cast to a user pointer is valid due to the set_fs() */ | |
| 425 | + result = vfs_read(file, (void __user *)buf, count, pos); | |
| 426 | + set_fs(old_fs); | |
| 427 | + return result; | |
| 428 | +} | |
| 429 | +EXPORT_SYMBOL(kernel_read); | |
| 417 | 430 | |
| 418 | 431 | ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) |
| 419 | 432 | { |
| @@ -441,8 +454,6 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) · 21 unmodified lines | ||
| 441 | 454 | return ret; |
| 442 | 455 | } |
| 443 | 456 | |
| 444 | −EXPORT_SYMBOL(vfs_read); | |
| 445 | − | |
| 446 | 457 | static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) |
| 447 | 458 | { |
| 448 | 459 | struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len }; |
| @@ -471,9 +482,8 @@ ssize_t __vfs_write(struct file *file, const char __user *p, size_t count, · 22 unmodified lines | ||
| 471 | 482 | else |
| 472 | 483 | return -EINVAL; |
| 473 | 484 | } |
| 474 | −EXPORT_SYMBOL(__vfs_write); | |
| 475 | 485 | |
| 476 | −ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos) | |
| 486 | +ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos) | |
| 477 | 487 | { |
| 478 | 488 | mm_segment_t old_fs; |
| 479 | 489 | const char __user *p; |
| @@ -496,9 +506,24 @@ ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t · 16 unmodified lines | ||
| 496 | 506 | inc_syscw(current); |
| 497 | 507 | return ret; |
| 498 | 508 | } |
| 499 | − | |
| 500 | 509 | EXPORT_SYMBOL(__kernel_write); |
| 501 | 510 | |
| 511 | +ssize_t kernel_write(struct file *file, const void *buf, size_t count, | |
| 512 | + loff_t *pos) | |
| 513 | +{ | |
| 514 | + mm_segment_t old_fs; | |
| 515 | + ssize_t res; | |
| 516 | + | |
| 517 | + old_fs = get_fs(); | |
| 518 | + set_fs(get_ds()); | |
| 519 | + /* The cast to a user pointer is valid due to the set_fs() */ | |
| 520 | + res = vfs_write(file, (__force const char __user *)buf, count, pos); | |
| 521 | + set_fs(old_fs); | |
| 522 | + | |
| 523 | + return res; | |
| 524 | +} | |
| 525 | +EXPORT_SYMBOL(kernel_write); | |
| 526 | + | |
| 502 | 527 | ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) |
| 503 | 528 | { |
| 504 | 529 | ssize_t ret; |
| @@ -527,8 +552,6 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_ · 22 unmodified lines | ||
| 527 | 552 | return ret; |
| 528 | 553 | } |
| 529 | 554 | |
| 530 | −EXPORT_SYMBOL(vfs_write); | |
| 531 | − | |
| 532 | 555 | static inline loff_t file_pos_read(struct file *file) |
| 533 | 556 | { |
| 534 | 557 | return file->f_pos; |
| @@ -959,9 +982,8 @@ ssize_t vfs_readv(struct file *file, const struct iovec __user *vec, · 424 unmodified lines | ||
| 959 | 982 | |
| 960 | 983 | return ret; |
| 961 | 984 | } |
| 962 | −EXPORT_SYMBOL(vfs_readv); | |
| 963 | 985 | |
| 964 | −ssize_t vfs_writev(struct file *file, const struct iovec __user *vec, | |
| 986 | +static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec, | |
| 965 | 987 | unsigned long vlen, loff_t *pos, rwf_t flags) |
| 966 | 988 | { |
| 967 | 989 | struct iovec iovstack[UIO_FASTIOV]; |
| @@ -978,7 +1000,6 @@ ssize_t vfs_writev(struct file *file, const struct iovec __user *vec, · 10 unmodified lines | ||
| 978 | 1000 | } |
| 979 | 1001 | return ret; |
| 980 | 1002 | } |
| 981 | −EXPORT_SYMBOL(vfs_writev); | |
| 982 | 1003 | |
| 983 | 1004 | static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec, |
| 984 | 1005 | unsigned long vlen, rwf_t flags) |
| @@ -364,22 +364,6 @@ static ssize_t kernel_readv(struct file *file, const struct kvec *vec, · 363 unmodified lines | ||
| 364 | 364 | return res; |
| 365 | 365 | } |
| 366 | 366 | |
| 367 | −ssize_t kernel_write(struct file *file, const char *buf, size_t count, | |
| 368 | − loff_t pos) | |
| 369 | −{ | |
| 370 | − mm_segment_t old_fs; | |
| 371 | − ssize_t res; | |
| 372 | − | |
| 373 | − old_fs = get_fs(); | |
| 374 | − set_fs(get_ds()); | |
| 375 | − /* The cast to a user pointer is valid due to the set_fs() */ | |
| 376 | − res = vfs_write(file, (__force const char __user *)buf, count, &pos); | |
| 377 | − set_fs(old_fs); | |
| 378 | − | |
| 379 | − return res; | |
| 380 | −} | |
| 381 | −EXPORT_SYMBOL(kernel_write); | |
| 382 | − | |
| 383 | 367 | static ssize_t default_file_splice_read(struct file *in, loff_t *ppos, |
| 384 | 368 | struct pipe_inode_info *pipe, size_t len, |
| 385 | 369 | unsigned int flags) |
| @@ -1754,13 +1754,10 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector, · 1753 unmodified lines | ||
| 1754 | 1754 | struct iovec **ret_pointer); |
| 1755 | 1755 | |
| 1756 | 1756 | extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *); |
| 1757 | −extern ssize_t __vfs_write(struct file *, const char __user *, size_t, loff_t *); | |
| 1758 | 1757 | extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *); |
| 1759 | 1758 | extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *); |
| 1760 | 1759 | extern ssize_t vfs_readv(struct file *, const struct iovec __user *, |
| 1761 | 1760 | unsigned long, loff_t *, rwf_t); |
| 1762 | −extern ssize_t vfs_writev(struct file *, const struct iovec __user *, | |
| 1763 | − unsigned long, loff_t *, rwf_t); | |
| 1764 | 1761 | extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *, |
| 1765 | 1762 | loff_t, size_t, unsigned int); |
| 1766 | 1763 | extern int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in, |
| @@ -2788,15 +2785,15 @@ static inline const char *kernel_read_file_id_str(enum kernel_read_file_id id) · 1021 unmodified lines | ||
| 2788 | 2785 | return kernel_read_file_str[id]; |
| 2789 | 2786 | } |
| 2790 | 2787 | |
| 2791 | −extern int kernel_read(struct file *, loff_t, char *, unsigned long); | |
| 2792 | 2788 | extern int kernel_read_file(struct file *, void **, loff_t *, loff_t, |
| 2793 | 2789 | enum kernel_read_file_id); |
| 2794 | 2790 | extern int kernel_read_file_from_path(char *, void **, loff_t *, loff_t, |
| 2795 | 2791 | enum kernel_read_file_id); |
| 2796 | 2792 | extern int kernel_read_file_from_fd(int, void **, loff_t *, loff_t, |
| 2797 | 2793 | enum kernel_read_file_id); |
| 2798 | −extern ssize_t kernel_write(struct file *, const char *, size_t, loff_t); | |
| 2799 | −extern ssize_t __kernel_write(struct file *, const char *, size_t, loff_t *); | |
| 2794 | +extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *); | |
| 2795 | +extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *); | |
| 2796 | +extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *); | |
| 2800 | 2797 | extern struct file * open_exec(const char *); |
| 2801 | 2798 | |
| 2802 | 2799 | /* fs/dcache.c -- generic fs support functions */ |
| @@ -516,7 +516,7 @@ static void do_acct_process(struct bsd_acct_struct *acct) · 515 unmodified lines | ||
| 516 | 516 | if (file_start_write_trylock(file)) { |
| 517 | 517 | /* it's been opened O_APPEND, so position is irrelevant */ |
| 518 | 518 | loff_t pos = 0; |
| 519 | − __kernel_write(file, (char *)&ac, sizeof(acct_t), &pos); | |
| 519 | + __kernel_write(file, &ac, sizeof(acct_t), &pos); | |
| 520 | 520 | file_end_write(file); |
| 521 | 521 | } |
| 522 | 522 | out: |
| @@ -986,8 +986,9 @@ static ssize_t bin_intvec(struct file *file, · 985 unmodified lines | ||
| 986 | 986 | size_t length = oldlen / sizeof(*vec); |
| 987 | 987 | char *str, *end; |
| 988 | 988 | int i; |
| 989 | + loff_t pos = 0; | |
| 989 | 990 | |
| 990 | − result = kernel_read(file, 0, buffer, BUFSZ - 1); | |
| 991 | + result = kernel_read(file, buffer, BUFSZ - 1, &pos); | |
| 991 | 992 | if (result < 0) |
| 992 | 993 | goto out_kfree; |
| 993 | 994 | |
| @@ -1016,6 +1017,7 @@ static ssize_t bin_intvec(struct file *file, · 22 unmodified lines | ||
| 1016 | 1017 | size_t length = newlen / sizeof(*vec); |
| 1017 | 1018 | char *str, *end; |
| 1018 | 1019 | int i; |
| 1020 | + loff_t pos = 0; | |
| 1019 | 1021 | |
| 1020 | 1022 | str = buffer; |
| 1021 | 1023 | end = str + BUFSZ; |
| @@ -1029,7 +1031,7 @@ static ssize_t bin_intvec(struct file *file, · 7 unmodified lines | ||
| 1029 | 1031 | str += scnprintf(str, end - str, "%lu\t", value); |
| 1030 | 1032 | } |
| 1031 | 1033 | |
| 1032 | − result = kernel_write(file, buffer, str - buffer, 0); | |
| 1034 | + result = kernel_write(file, buffer, str - buffer, &pos); | |
| 1033 | 1035 | if (result < 0) |
| 1034 | 1036 | goto out_kfree; |
| 1035 | 1037 | } |
| @@ -1057,8 +1059,9 @@ static ssize_t bin_ulongvec(struct file *file, · 21 unmodified lines | ||
| 1057 | 1059 | size_t length = oldlen / sizeof(*vec); |
| 1058 | 1060 | char *str, *end; |
| 1059 | 1061 | int i; |
| 1062 | + loff_t pos = 0; | |
| 1060 | 1063 | |
| 1061 | − result = kernel_read(file, 0, buffer, BUFSZ - 1); | |
| 1064 | + result = kernel_read(file, buffer, BUFSZ - 1, &pos); | |
| 1062 | 1065 | if (result < 0) |
| 1063 | 1066 | goto out_kfree; |
| 1064 | 1067 | |
| @@ -1087,6 +1090,7 @@ static ssize_t bin_ulongvec(struct file *file, · 22 unmodified lines | ||
| 1087 | 1090 | size_t length = newlen / sizeof(*vec); |
| 1088 | 1091 | char *str, *end; |
| 1089 | 1092 | int i; |
| 1093 | + loff_t pos = 0; | |
| 1090 | 1094 | |
| 1091 | 1095 | str = buffer; |
| 1092 | 1096 | end = str + BUFSZ; |
| @@ -1100,7 +1104,7 @@ static ssize_t bin_ulongvec(struct file *file, · 7 unmodified lines | ||
| 1100 | 1104 | str += scnprintf(str, end - str, "%lu\t", value); |
| 1101 | 1105 | } |
| 1102 | 1106 | |
| 1103 | − result = kernel_write(file, buffer, str - buffer, 0); | |
| 1107 | + result = kernel_write(file, buffer, str - buffer, &pos); | |
| 1104 | 1108 | if (result < 0) |
| 1105 | 1109 | goto out_kfree; |
| 1106 | 1110 | } |
| @@ -1120,8 +1124,9 @@ static ssize_t bin_uuid(struct file *file, · 13 unmodified lines | ||
| 1120 | 1124 | if (oldval && oldlen) { |
| 1121 | 1125 | char buf[UUID_STRING_LEN + 1]; |
| 1122 | 1126 | uuid_t uuid; |
| 1127 | + loff_t pos = 0; | |
| 1123 | 1128 | |
| 1124 | − result = kernel_read(file, 0, buf, sizeof(buf) - 1); | |
| 1129 | + result = kernel_read(file, buf, sizeof(buf) - 1, &pos); | |
| 1125 | 1130 | if (result < 0) |
| 1126 | 1131 | goto out; |
| 1127 | 1132 | |
| @@ -1154,8 +1159,9 @@ static ssize_t bin_dn_node_address(struct file *file, · 26 unmodified lines | ||
| 1154 | 1159 | char buf[15], *nodep; |
| 1155 | 1160 | unsigned long area, node; |
| 1156 | 1161 | __le16 dnaddr; |
| 1162 | + loff_t pos = 0; | |
| 1157 | 1163 | |
| 1158 | − result = kernel_read(file, 0, buf, sizeof(buf) - 1); | |
| 1164 | + result = kernel_read(file, buf, sizeof(buf) - 1, &pos); | |
| 1159 | 1165 | if (result < 0) |
| 1160 | 1166 | goto out; |
| 1161 | 1167 | |
| @@ -1188,6 +1194,7 @@ static ssize_t bin_dn_node_address(struct file *file, · 26 unmodified lines | ||
| 1188 | 1194 | __le16 dnaddr; |
| 1189 | 1195 | char buf[15]; |
| 1190 | 1196 | int len; |
| 1197 | + loff_t pos = 0; | |
| 1191 | 1198 | |
| 1192 | 1199 | result = -EINVAL; |
| 1193 | 1200 | if (newlen != sizeof(dnaddr)) |
| @@ -1201,7 +1208,7 @@ static ssize_t bin_dn_node_address(struct file *file, · 7 unmodified lines | ||
| 1201 | 1208 | le16_to_cpu(dnaddr) >> 10, |
| 1202 | 1209 | le16_to_cpu(dnaddr) & 0x3ff); |
| 1203 | 1210 | |
| 1204 | − result = kernel_write(file, buf, len, 0); | |
| 1211 | + result = kernel_write(file, buf, len, &pos); | |
| 1205 | 1212 | if (result < 0) |
| 1206 | 1213 | goto out; |
| 1207 | 1214 | } |
| @@ -1164,17 +1164,12 @@ static int do_mmap_private(struct vm_area_struct *vma, · 1163 unmodified lines | ||
| 1164 | 1164 | |
| 1165 | 1165 | if (vma->vm_file) { |
| 1166 | 1166 | /* read the contents of a file into the copy */ |
| 1167 | − mm_segment_t old_fs; | |
| 1168 | 1167 | loff_t fpos; |
| 1169 | 1168 | |
| 1170 | 1169 | fpos = vma->vm_pgoff; |
| 1171 | 1170 | fpos <<= PAGE_SHIFT; |
| 1172 | 1171 | |
| 1173 | − old_fs = get_fs(); | |
| 1174 | − set_fs(KERNEL_DS); | |
| 1175 | − ret = __vfs_read(vma->vm_file, base, len, &fpos); | |
| 1176 | − set_fs(old_fs); | |
| 1177 | − | |
| 1172 | + ret = kernel_read(vma->vm_file, base, len, &fpos); | |
| 1178 | 1173 | if (ret < 0) |
| 1179 | 1174 | goto error_free; |
| 1180 | 1175 | |
| @@ -272,6 +272,7 @@ static int p9_fd_read(struct p9_client *client, void *v, int len) · 271 unmodified lines | ||
| 272 | 272 | { |
| 273 | 273 | int ret; |
| 274 | 274 | struct p9_trans_fd *ts = NULL; |
| 275 | + loff_t pos; | |
| 275 | 276 | |
| 276 | 277 | if (client && client->status != Disconnected) |
| 277 | 278 | ts = client->trans; |
| @@ -282,7 +283,8 @@ static int p9_fd_read(struct p9_client *client, void *v, int len) · 4 unmodified lines | ||
| 282 | 283 | if (!(ts->rd->f_flags & O_NONBLOCK)) |
| 283 | 284 | p9_debug(P9_DEBUG_ERROR, "blocking read ...\n"); |
| 284 | 285 | |
| 285 | − ret = kernel_read(ts->rd, ts->rd->f_pos, v, len); | |
| 286 | + pos = ts->rd->f_pos; | |
| 287 | + ret = kernel_read(ts->rd, v, len, &pos); | |
| 286 | 288 | if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN) |
| 287 | 289 | client->status = Disconnected; |
| 288 | 290 | return ret; |
| @@ -420,8 +422,7 @@ error: · 131 unmodified lines | ||
| 420 | 422 | |
| 421 | 423 | static int p9_fd_write(struct p9_client *client, void *v, int len) |
| 422 | 424 | { |
| 423 | − int ret; | |
| 424 | − mm_segment_t oldfs; | |
| 425 | + ssize_t ret; | |
| 425 | 426 | struct p9_trans_fd *ts = NULL; |
| 426 | 427 | |
| 427 | 428 | if (client && client->status != Disconnected) |
| @@ -433,12 +434,7 @@ static int p9_fd_write(struct p9_client *client, void *v, int len) · 5 unmodified lines | ||
| 433 | 434 | if (!(ts->wr->f_flags & O_NONBLOCK)) |
| 434 | 435 | p9_debug(P9_DEBUG_ERROR, "blocking write ...\n"); |
| 435 | 436 | |
| 436 | − oldfs = get_fs(); | |
| 437 | − set_fs(get_ds()); | |
| 438 | − /* The cast to a user pointer is valid due to the set_fs() */ | |
| 439 | − ret = vfs_write(ts->wr, (__force void __user *)v, len, &ts->wr->f_pos); | |
| 440 | − set_fs(oldfs); | |
| 441 | − | |
| 437 | + ret = kernel_write(ts->wr, v, len, &ts->wr->f_pos); | |
| 442 | 438 | if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN) |
| 443 | 439 | client->status = Disconnected; |
| 444 | 440 | return ret; |
| @@ -147,6 +147,7 @@ int big_key_preparse(struct key_preparsed_payload *prep) · 146 unmodified lines | ||
| 147 | 147 | * File content is stored encrypted with randomly generated key. |
| 148 | 148 | */ |
| 149 | 149 | size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher)); |
| 150 | + loff_t pos = 0; | |
| 150 | 151 | |
| 151 | 152 | /* prepare aligned data to encrypt */ |
| 152 | 153 | data = kmalloc(enclen, GFP_KERNEL); |
| @@ -179,7 +180,7 @@ int big_key_preparse(struct key_preparsed_payload *prep) · 26 unmodified lines | ||
| 179 | 180 | goto err_enckey; |
| 180 | 181 | } |
| 181 | 182 | |
| 182 | − written = kernel_write(file, data, enclen, 0); | |
| 183 | + written = kernel_write(file, data, enclen, &pos); | |
| 183 | 184 | if (written != enclen) { |
| 184 | 185 | ret = written; |
| 185 | 186 | if (written >= 0) |
| @@ -295,6 +296,7 @@ long big_key_read(const struct key *key, char __user *buffer, size_t buflen) · 109 unmodified lines | ||
| 295 | 296 | u8 *data; |
| 296 | 297 | u8 *enckey = (u8 *)key->payload.data[big_key_data]; |
| 297 | 298 | size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher)); |
| 299 | + loff_t pos = 0; | |
| 298 | 300 | |
| 299 | 301 | data = kmalloc(enclen, GFP_KERNEL); |
| 300 | 302 | if (!data) |
| @@ -307,7 +309,7 @@ long big_key_read(const struct key *key, char __user *buffer, size_t buflen) · 6 unmodified lines | ||
| 307 | 309 | } |
| 308 | 310 | |
| 309 | 311 | /* read file to kernel and decrypt */ |
| 310 | − ret = kernel_read(file, 0, data, enclen); | |
| 312 | + ret = kernel_read(file, data, enclen, &pos); | |
| 311 | 313 | if (ret >= 0 && ret != enclen) { |
| 312 | 314 | ret = -EIO; |
| 313 | 315 | goto err_fput; |