splice: return type ssize_t from all helpers

+4 -4

fs/internal.h

··· 243 243 /* 244 244 * fs/splice.c: 245 245 */ 246 - long splice_file_to_pipe(struct file *in, 247 - struct pipe_inode_info *opipe, 248 - loff_t *offset, 249 - size_t len, unsigned int flags); 246 + ssize_t splice_file_to_pipe(struct file *in, 247 + struct pipe_inode_info *opipe, 248 + loff_t *offset, 249 + size_t len, unsigned int flags); 250 250 251 251 /* 252 252 * fs/xattr.c:

+1 -1

fs/overlayfs/copy_up.c

··· 285 285 286 286 while (len) { 287 287 size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 288 - long bytes; 288 + ssize_t bytes; 289 289 290 290 if (len < this_len) 291 291 this_len = len;

+1 -1

fs/read_write.c

··· 1214 1214 #endif /* CONFIG_COMPAT */ 1215 1215 1216 1216 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos, 1217 - size_t count, loff_t max) 1217 + size_t count, loff_t max) 1218 1218 { 1219 1219 struct fd in, out; 1220 1220 struct inode *in_inode, *out_inode;

+53 -51

fs/splice.c

··· 201 201 unsigned int tail = pipe->tail; 202 202 unsigned int head = pipe->head; 203 203 unsigned int mask = pipe->ring_size - 1; 204 - int ret = 0, page_nr = 0; 204 + ssize_t ret = 0; 205 + int page_nr = 0; 205 206 206 207 if (!spd_pages) 207 208 return 0; ··· 933 932 /* 934 933 * Attempt to initiate a splice from pipe to file. 935 934 */ 936 - static long do_splice_from(struct pipe_inode_info *pipe, struct file *out, 937 - loff_t *ppos, size_t len, unsigned int flags) 935 + static ssize_t do_splice_from(struct pipe_inode_info *pipe, struct file *out, 936 + loff_t *ppos, size_t len, unsigned int flags) 938 937 { 939 938 if (unlikely(!out->f_op->splice_write)) 940 939 return warn_unsupported(out, "write"); ··· 956 955 * Callers already called rw_verify_area() on the entire range. 957 956 * No need to call it for sub ranges. 958 957 */ 959 - static long do_splice_read(struct file *in, loff_t *ppos, 960 - struct pipe_inode_info *pipe, size_t len, 961 - unsigned int flags) 958 + static ssize_t do_splice_read(struct file *in, loff_t *ppos, 959 + struct pipe_inode_info *pipe, size_t len, 960 + unsigned int flags) 962 961 { 963 962 unsigned int p_space; 964 963 ··· 1000 999 * If successful, it returns the amount of data spliced, 0 if it hit the EOF or 1001 1000 * a hole and a negative error code otherwise. 1002 1001 */ 1003 - long vfs_splice_read(struct file *in, loff_t *ppos, 1004 - struct pipe_inode_info *pipe, size_t len, 1005 - unsigned int flags) 1002 + ssize_t vfs_splice_read(struct file *in, loff_t *ppos, 1003 + struct pipe_inode_info *pipe, size_t len, 1004 + unsigned int flags) 1006 1005 { 1007 - int ret; 1006 + ssize_t ret; 1008 1007 1009 1008 ret = rw_verify_area(READ, in, ppos, len); 1010 1009 if (unlikely(ret < 0)) ··· 1031 1030 splice_direct_actor *actor) 1032 1031 { 1033 1032 struct pipe_inode_info *pipe; 1034 - long ret, bytes; 1033 + ssize_t ret, bytes; 1035 1034 size_t len; 1036 1035 int i, flags, more; 1037 1036 ··· 1182 1181 file->f_op->splice_eof(file); 1183 1182 } 1184 1183 1185 - static long do_splice_direct_actor(struct file *in, loff_t *ppos, 1186 - struct file *out, loff_t *opos, 1187 - size_t len, unsigned int flags, 1188 - splice_direct_actor *actor) 1184 + static ssize_t do_splice_direct_actor(struct file *in, loff_t *ppos, 1185 + struct file *out, loff_t *opos, 1186 + size_t len, unsigned int flags, 1187 + splice_direct_actor *actor) 1189 1188 { 1190 1189 struct splice_desc sd = { 1191 1190 .len = len, ··· 1196 1195 .splice_eof = direct_file_splice_eof, 1197 1196 .opos = opos, 1198 1197 }; 1199 - long ret; 1198 + ssize_t ret; 1200 1199 1201 1200 if (unlikely(!(out->f_mode & FMODE_WRITE))) 1202 1201 return -EBADF; ··· 1227 1226 * 1228 1227 * Callers already called rw_verify_area() on the entire range. 1229 1228 */ 1230 - long do_splice_direct(struct file *in, loff_t *ppos, struct file *out, 1231 - loff_t *opos, size_t len, unsigned int flags) 1229 + ssize_t do_splice_direct(struct file *in, loff_t *ppos, struct file *out, 1230 + loff_t *opos, size_t len, unsigned int flags) 1232 1231 { 1233 1232 return do_splice_direct_actor(in, ppos, out, opos, len, flags, 1234 1233 direct_splice_actor); ··· 1250 1249 * 1251 1250 * Callers already called rw_verify_area() on the entire range. 1252 1251 */ 1253 - long splice_file_range(struct file *in, loff_t *ppos, struct file *out, 1254 - loff_t *opos, size_t len) 1252 + ssize_t splice_file_range(struct file *in, loff_t *ppos, struct file *out, 1253 + loff_t *opos, size_t len) 1255 1254 { 1256 1255 lockdep_assert(file_write_started(out)); 1257 1256 ··· 1281 1280 struct pipe_inode_info *opipe, 1282 1281 size_t len, unsigned int flags); 1283 1282 1284 - long splice_file_to_pipe(struct file *in, 1285 - struct pipe_inode_info *opipe, 1286 - loff_t *offset, 1287 - size_t len, unsigned int flags) 1283 + ssize_t splice_file_to_pipe(struct file *in, 1284 + struct pipe_inode_info *opipe, 1285 + loff_t *offset, 1286 + size_t len, unsigned int flags) 1288 1287 { 1289 - long ret; 1288 + ssize_t ret; 1290 1289 1291 1290 pipe_lock(opipe); 1292 1291 ret = wait_for_space(opipe, flags); ··· 1301 1300 /* 1302 1301 * Determine where to splice to/from. 1303 1302 */ 1304 - long do_splice(struct file *in, loff_t *off_in, struct file *out, 1305 - loff_t *off_out, size_t len, unsigned int flags) 1303 + ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out, 1304 + loff_t *off_out, size_t len, unsigned int flags) 1306 1305 { 1307 1306 struct pipe_inode_info *ipipe; 1308 1307 struct pipe_inode_info *opipe; 1309 1308 loff_t offset; 1310 - long ret; 1309 + ssize_t ret; 1311 1310 1312 1311 if (unlikely(!(in->f_mode & FMODE_READ) || 1313 1312 !(out->f_mode & FMODE_WRITE))) ··· 1398 1397 return ret; 1399 1398 } 1400 1399 1401 - static long __do_splice(struct file *in, loff_t __user *off_in, 1402 - struct file *out, loff_t __user *off_out, 1403 - size_t len, unsigned int flags) 1400 + static ssize_t __do_splice(struct file *in, loff_t __user *off_in, 1401 + struct file *out, loff_t __user *off_out, 1402 + size_t len, unsigned int flags) 1404 1403 { 1405 1404 struct pipe_inode_info *ipipe; 1406 1405 struct pipe_inode_info *opipe; 1407 1406 loff_t offset, *__off_in = NULL, *__off_out = NULL; 1408 - long ret; 1407 + ssize_t ret; 1409 1408 1410 1409 ipipe = get_pipe_info(in, true); 1411 1410 opipe = get_pipe_info(out, true); ··· 1444 1443 return ret; 1445 1444 } 1446 1445 1447 - static int iter_to_pipe(struct iov_iter *from, 1448 - struct pipe_inode_info *pipe, 1449 - unsigned flags) 1446 + static ssize_t iter_to_pipe(struct iov_iter *from, 1447 + struct pipe_inode_info *pipe, 1448 + unsigned int flags) 1450 1449 { 1451 1450 struct pipe_buffer buf = { 1452 1451 .ops = &user_page_pipe_buf_ops, 1453 1452 .flags = flags 1454 1453 }; 1455 1454 size_t total = 0; 1456 - int ret = 0; 1455 + ssize_t ret = 0; 1457 1456 1458 1457 while (iov_iter_count(from)) { 1459 1458 struct page *pages[16]; ··· 1502 1501 * For lack of a better implementation, implement vmsplice() to userspace 1503 1502 * as a simple copy of the pipes pages to the user iov. 1504 1503 */ 1505 - static long vmsplice_to_user(struct file *file, struct iov_iter *iter, 1506 - unsigned int flags) 1504 + static ssize_t vmsplice_to_user(struct file *file, struct iov_iter *iter, 1505 + unsigned int flags) 1507 1506 { 1508 1507 struct pipe_inode_info *pipe = get_pipe_info(file, true); 1509 1508 struct splice_desc sd = { ··· 1511 1510 .flags = flags, 1512 1511 .u.data = iter 1513 1512 }; 1514 - long ret = 0; 1513 + ssize_t ret = 0; 1515 1514 1516 1515 if (!pipe) 1517 1516 return -EBADF; ··· 1535 1534 * as splice-from-memory, where the regular splice is splice-from-file (or 1536 1535 * to file). In both cases the output is a pipe, naturally. 1537 1536 */ 1538 - static long vmsplice_to_pipe(struct file *file, struct iov_iter *iter, 1539 - unsigned int flags) 1537 + static ssize_t vmsplice_to_pipe(struct file *file, struct iov_iter *iter, 1538 + unsigned int flags) 1540 1539 { 1541 1540 struct pipe_inode_info *pipe; 1542 - long ret = 0; 1541 + ssize_t ret = 0; 1543 1542 unsigned buf_flag = 0; 1544 1543 1545 1544 if (flags & SPLICE_F_GIFT) ··· 1635 1634 size_t, len, unsigned int, flags) 1636 1635 { 1637 1636 struct fd in, out; 1638 - long error; 1637 + ssize_t error; 1639 1638 1640 1639 if (unlikely(!len)) 1641 1640 return 0; ··· 1649 1648 out = fdget(fd_out); 1650 1649 if (out.file) { 1651 1650 error = __do_splice(in.file, off_in, out.file, off_out, 1652 - len, flags); 1651 + len, flags); 1653 1652 fdput(out); 1654 1653 } 1655 1654 fdput(in); ··· 1872 1871 /* 1873 1872 * Link contents of ipipe to opipe. 1874 1873 */ 1875 - static int link_pipe(struct pipe_inode_info *ipipe, 1876 - struct pipe_inode_info *opipe, 1877 - size_t len, unsigned int flags) 1874 + static ssize_t link_pipe(struct pipe_inode_info *ipipe, 1875 + struct pipe_inode_info *opipe, 1876 + size_t len, unsigned int flags) 1878 1877 { 1879 1878 struct pipe_buffer *ibuf, *obuf; 1880 1879 unsigned int i_head, o_head; 1881 1880 unsigned int i_tail, o_tail; 1882 1881 unsigned int i_mask, o_mask; 1883 - int ret = 0; 1882 + ssize_t ret = 0; 1884 1883 1885 1884 /* 1886 1885 * Potential ABBA deadlock, work around it by ordering lock ··· 1963 1962 * The 'flags' used are the SPLICE_F_* variants, currently the only 1964 1963 * applicable one is SPLICE_F_NONBLOCK. 1965 1964 */ 1966 - long do_tee(struct file *in, struct file *out, size_t len, unsigned int flags) 1965 + ssize_t do_tee(struct file *in, struct file *out, size_t len, 1966 + unsigned int flags) 1967 1967 { 1968 1968 struct pipe_inode_info *ipipe = get_pipe_info(in, true); 1969 1969 struct pipe_inode_info *opipe = get_pipe_info(out, true); 1970 - int ret = -EINVAL; 1970 + ssize_t ret = -EINVAL; 1971 1971 1972 1972 if (unlikely(!(in->f_mode & FMODE_READ) || 1973 1973 !(out->f_mode & FMODE_WRITE))) ··· 2005 2003 SYSCALL_DEFINE4(tee, int, fdin, int, fdout, size_t, len, unsigned int, flags) 2006 2004 { 2007 2005 struct fd in, out; 2008 - int error; 2006 + ssize_t error; 2009 2007 2010 2008 if (unlikely(flags & ~SPLICE_F_ALL)) 2011 2009 return -EINVAL;

+21 -22

include/linux/splice.h

··· 68 68 typedef int (splice_direct_actor)(struct pipe_inode_info *, 69 69 struct splice_desc *); 70 70 71 - extern ssize_t splice_from_pipe(struct pipe_inode_info *, struct file *, 72 - loff_t *, size_t, unsigned int, 73 - splice_actor *); 74 - extern ssize_t __splice_from_pipe(struct pipe_inode_info *, 75 - struct splice_desc *, splice_actor *); 76 - extern ssize_t splice_to_pipe(struct pipe_inode_info *, 77 - struct splice_pipe_desc *); 78 - extern ssize_t add_to_pipe(struct pipe_inode_info *, 79 - struct pipe_buffer *); 80 - long vfs_splice_read(struct file *in, loff_t *ppos, 81 - struct pipe_inode_info *pipe, size_t len, 82 - unsigned int flags); 71 + ssize_t splice_from_pipe(struct pipe_inode_info *pipe, struct file *out, 72 + loff_t *ppos, size_t len, unsigned int flags, 73 + splice_actor *actor); 74 + ssize_t __splice_from_pipe(struct pipe_inode_info *pipe, 75 + struct splice_desc *sd, splice_actor *actor); 76 + ssize_t splice_to_pipe(struct pipe_inode_info *pipe, 77 + struct splice_pipe_desc *spd); 78 + ssize_t add_to_pipe(struct pipe_inode_info *pipe, struct pipe_buffer *buf); 79 + ssize_t vfs_splice_read(struct file *in, loff_t *ppos, 80 + struct pipe_inode_info *pipe, size_t len, 81 + unsigned int flags); 83 82 ssize_t splice_direct_to_actor(struct file *file, struct splice_desc *sd, 84 83 splice_direct_actor *actor); 85 - long do_splice(struct file *in, loff_t *off_in, struct file *out, 86 - loff_t *off_out, size_t len, unsigned int flags); 87 - long do_splice_direct(struct file *in, loff_t *ppos, struct file *out, 88 - loff_t *opos, size_t len, unsigned int flags); 89 - long splice_file_range(struct file *in, loff_t *ppos, struct file *out, 90 - loff_t *opos, size_t len); 84 + ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out, 85 + loff_t *off_out, size_t len, unsigned int flags); 86 + ssize_t do_splice_direct(struct file *in, loff_t *ppos, struct file *out, 87 + loff_t *opos, size_t len, unsigned int flags); 88 + ssize_t splice_file_range(struct file *in, loff_t *ppos, struct file *out, 89 + loff_t *opos, size_t len); 91 90 92 - extern long do_tee(struct file *in, struct file *out, size_t len, 93 - unsigned int flags); 94 - extern ssize_t splice_to_socket(struct pipe_inode_info *pipe, struct file *out, 95 - loff_t *ppos, size_t len, unsigned int flags); 91 + ssize_t do_tee(struct file *in, struct file *out, size_t len, 92 + unsigned int flags); 93 + ssize_t splice_to_socket(struct pipe_inode_info *pipe, struct file *out, 94 + loff_t *ppos, size_t len, unsigned int flags); 96 95 97 96 /* 98 97 * for dynamic pipe sizing

+2 -2

io_uring/splice.c

··· 51 51 struct file *out = sp->file_out; 52 52 unsigned int flags = sp->flags & ~SPLICE_F_FD_IN_FIXED; 53 53 struct file *in; 54 - long ret = 0; 54 + ssize_t ret = 0; 55 55 56 56 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 57 57 ··· 92 92 unsigned int flags = sp->flags & ~SPLICE_F_FD_IN_FIXED; 93 93 loff_t *poff_in, *poff_out; 94 94 struct file *in; 95 - long ret = 0; 95 + ssize_t ret = 0; 96 96 97 97 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 98 98

Configure Feed

Configure Feed