linux/fs/read_write.c

12 #include <linux/file.h>
37 static inline bool unsigned_offsets(struct file *file)
39 	return file->f_op->fop_flags & FOP_UNSIGNED_OFFSET;
43  * vfs_setpos_cookie - update the file offset for lseek and reset cookie
44  * @file:	file structure in question
45  * @offset:	file offset to seek to
46  * @maxsize:	maximum file size
49  * Update the file offset to the value specified by @offset if the given
50  * offset is valid and it is not equal to the current file offset and
55 static loff_t vfs_setpos_cookie(struct file *file, loff_t offset,
58 	if (offset < 0 && !unsigned_offsets(file))
63 	if (offset != file->f_pos) {
64 		file->f_pos = offset;
72  * vfs_setpos - update the file offset for lseek
73  * @file:	file structure in question
74  * @offset:	file offset to seek to
75  * @maxsize:	maximum file size
77  * This is a low-level filesystem helper for updating the file offset to
79  * not equal to the current file offset.
83 loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize)
85 	return vfs_setpos_cookie(file, offset, maxsize, NULL);
91  * @file: file to seek on
94  * @eof: end of file
102 static int must_set_pos(struct file *file, loff_t *offset, int whence, loff_t eof)
112 		 * f_pos value back to the file because a concurrent read(),
116 			*offset = file->f_pos;
122 		 * In the generic case the entire file is data, so as long as
123 		 * offset isn't at the end of the file then the offset is data.
130 		 * There is a virtual hole at the end of the file, so as long as
144  * @file:	file structure to seek on
145  * @offset:	file offset to seek to
147  * @maxsize:	max size of this file in file system
151  * maximum file size and a custom EOF position, for e.g. hashed directories
159 generic_file_llseek_size(struct file *file, loff_t offset, int whence,
164 	ret = must_set_pos(file, &offset, whence, eof);
172 		 * If the file requires locking via f_pos_lock we know
173 		 * that mutual exclusion for SEEK_CUR on the same file
174 		 * is guaranteed. If the file isn't locked, we take
178 		if (file_seek_cur_needs_f_lock(file)) {
179 			guard(spinlock)(&file->f_lock);
180 			return vfs_setpos(file, file->f_pos + offset, maxsize);
182 		return vfs_setpos(file, file->f_pos + offset, maxsize);
185 	return vfs_setpos(file, offset, maxsize);
191  * @file:	file structure to seek on
192  * @offset:	file offset to seek to
201 loff_t generic_llseek_cookie(struct file *file, loff_t offset, int whence,
204 	struct inode *inode = file->f_mapping->host;
217 	if (WARN_ON_ONCE(!(file->f_mode & FMODE_ATOMIC_POS)))
220 	ret = must_set_pos(file, &offset, whence, eof);
228 		return vfs_setpos_cookie(file, file->f_pos + offset, maxsize, cookie);
230 	return vfs_setpos_cookie(file, offset, maxsize, cookie);
236  * @file:	file structure to seek on
237  * @offset:	file offset to seek to
241  * filesystems.  It just updates the file offset to the value specified by
244 loff_t generic_file_llseek(struct file *file, loff_t offset, int whence)
246 	struct inode *inode = file->f_mapping->host;
248 	return generic_file_llseek_size(file, offset, whence,
256  * @file:	file structure to seek on
257  * @offset:	file offset to seek to
259  * @size:	size of the file
262 loff_t fixed_size_llseek(struct file *file, loff_t offset, int whence, loff_t size)
266 		return generic_file_llseek_size(file, offset, whence,
276  * @file:	file structure to seek on
277  * @offset:	file offset to seek to
281 loff_t no_seek_end_llseek(struct file *file, loff_t offset, int whence)
285 		return generic_file_llseek_size(file, offset, whence,
295  * @file:	file structure to seek on
296  * @offset:	file offset to seek to
301 loff_t no_seek_end_llseek_size(struct file *file, loff_t offset, int whence, loff_t size)
305 		return generic_file_llseek_size(file, offset, whence,
315  * @file:	file structure to seek on
316  * @offset:	file offset to seek to
320  * userspace expects the seek to succeed but the (device) file is actually not
324 loff_t noop_llseek(struct file *file, loff_t offset, int whence)
326 	return file->f_pos;
330 loff_t default_llseek(struct file *file, loff_t offset, int whence)
332 	struct inode *inode = file_inode(file);
344 				retval = file->f_pos;
347 			offset += file->f_pos;
351 			 * In the generic case the entire file is data, so as
352 			 * long as offset isn't at the end of the file then the
362 			 * There is a virtual hole at the end of the file, so
374 	if (offset >= 0 || unsigned_offsets(file)) {
375 		if (offset != file->f_pos)
376 			file->f_pos = offset;
385 loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
387 	if (!(file->f_mode & FMODE_LSEEK))
389 	return file->f_op->llseek(file, offset, whence);
451 int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
463 			if (!unsigned_offsets(file))
468 			if (!unsigned_offsets(file))
473 	ret = security_file_permission(file, mask);
477 	return fsnotify_file_area_perm(file, mask, ppos, count);
481 static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
498 static int warn_unsupported(struct file *file, const char *op)
501 		"kernel %s not supported for file %pD4 (pid: %d comm: %.20s)\n",
502 		op, file, current->pid, current->comm);
506 ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
516 	if (WARN_ON_ONCE(!(file->f_mode & FMODE_READ)))
518 	if (!(file->f_mode & FMODE_CAN_READ))
524 	if (unlikely(!file->f_op->read_iter || file->f_op->read))
525 		return warn_unsupported(file, "read");
527 	init_sync_kiocb(&kiocb, file);
530 	ret = file->f_op->read_iter(&kiocb, &iter);
534 		fsnotify_access(file);
541 ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
545 	ret = rw_verify_area(READ, file, pos, count);
548 	return __kernel_read(file, buf, count, pos);
552 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
556 	if (!(file->f_mode & FMODE_READ))
558 	if (!(file->f_mode & FMODE_CAN_READ))
563 	ret = rw_verify_area(READ, file, pos, count);
569 	if (file->f_op->read)
570 		ret = file->f_op->read(file, buf, count, pos);
571 	else if (file->f_op->read_iter)
572 		ret = new_sync_read(file, buf, count, pos);
576 		fsnotify_access(file);
583 static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
601 ssize_t __kernel_write_iter(struct file *file, struct iov_iter *from, loff_t *pos)
606 	if (WARN_ON_ONCE(!(file->f_mode & FMODE_WRITE)))
608 	if (!(file->f_mode & FMODE_CAN_WRITE))
614 	if (unlikely(!file->f_op->write_iter || file->f_op->write))
615 		return warn_unsupported(file, "write");
617 	init_sync_kiocb(&kiocb, file);
619 	ret = file->f_op->write_iter(&kiocb, from);
623 		fsnotify_modify(file);
631 ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
639 	return __kernel_write_iter(file, &iter, pos);
650 ssize_t kernel_write(struct file *file, const void *buf, size_t count,
655 	ret = rw_verify_area(WRITE, file, pos, count);
659 	file_start_write(file);
660 	ret =  __kernel_write(file, buf, count, pos);
661 	file_end_write(file);
666 ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
670 	if (!(file->f_mode & FMODE_WRITE))
672 	if (!(file->f_mode & FMODE_CAN_WRITE))
677 	ret = rw_verify_area(WRITE, file, pos, count);
682 	file_start_write(file);
683 	if (file->f_op->write)
684 		ret = file->f_op->write(file, buf, count, pos);
685 	else if (file->f_op->write_iter)
686 		ret = new_sync_write(file, buf, count, pos);
690 		fsnotify_modify(file);
694 	file_end_write(file);
698 /* file_ppos returns &file->f_pos or NULL if file is stream */
699 static inline loff_t *file_ppos(struct file *file)
701 	return file->f_mode & FMODE_STREAM ? NULL : &file->f_pos;
812 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
834 /* Do it by hand, with file-ops */
835 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
868 ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
874 	if (!file->f_op->read_iter)
876 	if (!(file->f_mode & FMODE_READ))
878 	if (!(file->f_mode & FMODE_CAN_READ))
884 	ret = rw_verify_area(READ, file, &iocb->ki_pos, tot_len);
888 	ret = file->f_op->read_iter(iocb, iter);
891 		fsnotify_access(file);
896 ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
902 	if (!file->f_op->read_iter)
904 	if (!(file->f_mode & FMODE_READ))
906 	if (!(file->f_mode & FMODE_CAN_READ))
912 	ret = rw_verify_area(READ, file, ppos, tot_len);
916 	ret = do_iter_readv_writev(file, iter, ppos, READ, flags);
919 		fsnotify_access(file);
928 ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
934 	if (!file->f_op->write_iter)
936 	if (!(file->f_mode & FMODE_WRITE))
938 	if (!(file->f_mode & FMODE_CAN_WRITE))
944 	ret = rw_verify_area(WRITE, file, &iocb->ki_pos, tot_len);
949 	ret = file->f_op->write_iter(iocb, iter);
953 		fsnotify_modify(file);
959 ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
965 	if (!(file->f_mode & FMODE_WRITE))
967 	if (!(file->f_mode & FMODE_CAN_WRITE))
969 	if (!file->f_op->write_iter)
976 	ret = rw_verify_area(WRITE, file, ppos, tot_len);
980 	file_start_write(file);
981 	ret = do_iter_readv_writev(file, iter, ppos, WRITE, flags);
983 		fsnotify_modify(file);
984 	file_end_write(file);
990 static ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
999 	if (!(file->f_mode & FMODE_READ))
1001 	if (!(file->f_mode & FMODE_CAN_READ))
1013 	ret = rw_verify_area(READ, file, pos, tot_len);
1017 	if (file->f_op->read_iter)
1018 		ret = do_iter_readv_writev(file, &iter, pos, READ, flags);
1020 		ret = do_loop_readv_writev(file, &iter, pos, READ, flags);
1023 		fsnotify_access(file);
1028 static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
1037 	if (!(file->f_mode & FMODE_WRITE))
1039 	if (!(file->f_mode & FMODE_CAN_WRITE))
1051 	ret = rw_verify_area(WRITE, file, pos, tot_len);
1055 	file_start_write(file);
1056 	if (file->f_op->write_iter)
1057 		ret = do_iter_readv_writev(file, &iter, pos, WRITE, flags);
1059 		ret = do_loop_readv_writev(file, &iter, pos, WRITE, flags);
1061 		fsnotify_modify(file);
1062 	file_end_write(file);
1313 	 * Get input file, and verify that it is ok..
1334 	 * Get output file, and verify that it is ok..
1360 	 * EAGAIN on a non-blocking file descriptor.
1475  * Performs necessary checks before doing a file copy
1481 static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,
1482 				    struct file *file_out, loff_t pos_out,
1497 	 * a file of the wrong filesystem type to filesystem driver can result
1537 	/* Don't allow overlapped copying within the same file. */
1548  * copy_file_range() differs from regular file read and write in that it
1552 ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
1553 			    struct file *file_out, loff_t pos_out,
1582 	 * Cloning is supported by more file systems, so we implement copy on
1624 	 * to splicing from input file, while file_start_write() is held on
1625 	 * the output file on a different sb.
1705 int generic_write_check_limits(struct file *file, loff_t pos, loff_t *count)
1707 	struct inode *inode = file->f_mapping->host;
1719 	if (!(file->f_flags & O_LARGEFILE))
1734 	struct file *file = iocb->ki_filp;
1735 	struct inode *inode = file->f_mapping->host;
1748 	      (file->f_op->fop_flags & FOP_BUFFER_WASYNC)))
1777  * Performs common checks before doing a file copy/clone
1780 int generic_file_rw_checks(struct file *file_in, struct file *file_out)