Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

-1

Documentation/filesystems/Locking

··· 447 447 int (*flush) (struct file *); 448 448 int (*release) (struct inode *, struct file *); 449 449 int (*fsync) (struct file *, loff_t start, loff_t end, int datasync); 450 - int (*aio_fsync) (struct kiocb *, int datasync); 451 450 int (*fasync) (int, struct file *, int); 452 451 int (*lock) (struct file *, int, struct file_lock *); 453 452 ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,

-1

Documentation/filesystems/vfs.txt

··· 828 828 int (*flush) (struct file *, fl_owner_t id); 829 829 int (*release) (struct inode *, struct file *); 830 830 int (*fsync) (struct file *, loff_t, loff_t, int datasync); 831 - int (*aio_fsync) (struct kiocb *, int datasync); 832 831 int (*fasync) (int, struct file *, int); 833 832 int (*lock) (struct file *, int, struct file_lock *); 834 833 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);

+114 -103

fs/aio.c

··· 1078 1078 unsigned tail, pos, head; 1079 1079 unsigned long flags; 1080 1080 1081 + if (kiocb->ki_flags & IOCB_WRITE) { 1082 + struct file *file = kiocb->ki_filp; 1083 + 1084 + /* 1085 + * Tell lockdep we inherited freeze protection from submission 1086 + * thread. 1087 + */ 1088 + __sb_writers_acquired(file_inode(file)->i_sb, SB_FREEZE_WRITE); 1089 + file_end_write(file); 1090 + } 1091 + 1081 1092 /* 1082 1093 * Special case handling for sync iocbs: 1083 1094 * - events go directly into the iocb for fast handling ··· 1403 1392 return -EINVAL; 1404 1393 } 1405 1394 1406 - typedef ssize_t (rw_iter_op)(struct kiocb *, struct iov_iter *); 1407 - 1408 - static int aio_setup_vectored_rw(int rw, char __user *buf, size_t len, 1409 - struct iovec **iovec, 1410 - bool compat, 1411 - struct iov_iter *iter) 1395 + static int aio_setup_rw(int rw, struct iocb *iocb, struct iovec **iovec, 1396 + bool vectored, bool compat, struct iov_iter *iter) 1412 1397 { 1398 + void __user *buf = (void __user *)(uintptr_t)iocb->aio_buf; 1399 + size_t len = iocb->aio_nbytes; 1400 + 1401 + if (!vectored) { 1402 + ssize_t ret = import_single_range(rw, buf, len, *iovec, iter); 1403 + *iovec = NULL; 1404 + return ret; 1405 + } 1413 1406 #ifdef CONFIG_COMPAT 1414 1407 if (compat) 1415 - return compat_import_iovec(rw, 1416 - (struct compat_iovec __user *)buf, 1417 - len, UIO_FASTIOV, iovec, iter); 1408 + return compat_import_iovec(rw, buf, len, UIO_FASTIOV, iovec, 1409 + iter); 1418 1410 #endif 1419 - return import_iovec(rw, (struct iovec __user *)buf, 1420 - len, UIO_FASTIOV, iovec, iter); 1411 + return import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter); 1421 1412 } 1422 1413 1423 - /* 1424 - * aio_run_iocb: 1425 - * Performs the initial checks and io submission. 1426 - */ 1427 - static ssize_t aio_run_iocb(struct kiocb *req, unsigned opcode, 1428 - char __user *buf, size_t len, bool compat) 1414 + static inline ssize_t aio_ret(struct kiocb *req, ssize_t ret) 1429 1415 { 1430 - struct file *file = req->ki_filp; 1431 - ssize_t ret; 1432 - int rw; 1433 - fmode_t mode; 1434 - rw_iter_op *iter_op; 1435 - struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1436 - struct iov_iter iter; 1437 - 1438 - switch (opcode) { 1439 - case IOCB_CMD_PREAD: 1440 - case IOCB_CMD_PREADV: 1441 - mode = FMODE_READ; 1442 - rw = READ; 1443 - iter_op = file->f_op->read_iter; 1444 - goto rw_common; 1445 - 1446 - case IOCB_CMD_PWRITE: 1447 - case IOCB_CMD_PWRITEV: 1448 - mode = FMODE_WRITE; 1449 - rw = WRITE; 1450 - iter_op = file->f_op->write_iter; 1451 - goto rw_common; 1452 - rw_common: 1453 - if (unlikely(!(file->f_mode & mode))) 1454 - return -EBADF; 1455 - 1456 - if (!iter_op) 1457 - return -EINVAL; 1458 - 1459 - if (opcode == IOCB_CMD_PREADV || opcode == IOCB_CMD_PWRITEV) 1460 - ret = aio_setup_vectored_rw(rw, buf, len, 1461 - &iovec, compat, &iter); 1462 - else { 1463 - ret = import_single_range(rw, buf, len, iovec, &iter); 1464 - iovec = NULL; 1465 - } 1466 - if (!ret) 1467 - ret = rw_verify_area(rw, file, &req->ki_pos, 1468 - iov_iter_count(&iter)); 1469 - if (ret < 0) { 1470 - kfree(iovec); 1471 - return ret; 1472 - } 1473 - 1474 - if (rw == WRITE) 1475 - file_start_write(file); 1476 - 1477 - ret = iter_op(req, &iter); 1478 - 1479 - if (rw == WRITE) 1480 - file_end_write(file); 1481 - kfree(iovec); 1482 - break; 1483 - 1484 - case IOCB_CMD_FDSYNC: 1485 - if (!file->f_op->aio_fsync) 1486 - return -EINVAL; 1487 - 1488 - ret = file->f_op->aio_fsync(req, 1); 1489 - break; 1490 - 1491 - case IOCB_CMD_FSYNC: 1492 - if (!file->f_op->aio_fsync) 1493 - return -EINVAL; 1494 - 1495 - ret = file->f_op->aio_fsync(req, 0); 1496 - break; 1497 - 1498 - default: 1499 - pr_debug("EINVAL: no operation provided\n"); 1500 - return -EINVAL; 1501 - } 1502 - 1503 - if (ret != -EIOCBQUEUED) { 1416 + switch (ret) { 1417 + case -EIOCBQUEUED: 1418 + return ret; 1419 + case -ERESTARTSYS: 1420 + case -ERESTARTNOINTR: 1421 + case -ERESTARTNOHAND: 1422 + case -ERESTART_RESTARTBLOCK: 1504 1423 /* 1505 1424 * There's no easy way to restart the syscall since other AIO's 1506 1425 * may be already running. Just fail this IO with EINTR. 1507 1426 */ 1508 - if (unlikely(ret == -ERESTARTSYS || ret == -ERESTARTNOINTR || 1509 - ret == -ERESTARTNOHAND || 1510 - ret == -ERESTART_RESTARTBLOCK)) 1511 - ret = -EINTR; 1427 + ret = -EINTR; 1428 + /*FALLTHRU*/ 1429 + default: 1512 1430 aio_complete(req, ret, 0); 1431 + return 0; 1513 1432 } 1433 + } 1514 1434 1515 - return 0; 1435 + static ssize_t aio_read(struct kiocb *req, struct iocb *iocb, bool vectored, 1436 + bool compat) 1437 + { 1438 + struct file *file = req->ki_filp; 1439 + struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1440 + struct iov_iter iter; 1441 + ssize_t ret; 1442 + 1443 + if (unlikely(!(file->f_mode & FMODE_READ))) 1444 + return -EBADF; 1445 + if (unlikely(!file->f_op->read_iter)) 1446 + return -EINVAL; 1447 + 1448 + ret = aio_setup_rw(READ, iocb, &iovec, vectored, compat, &iter); 1449 + if (ret) 1450 + return ret; 1451 + ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter)); 1452 + if (!ret) 1453 + ret = aio_ret(req, file->f_op->read_iter(req, &iter)); 1454 + kfree(iovec); 1455 + return ret; 1456 + } 1457 + 1458 + static ssize_t aio_write(struct kiocb *req, struct iocb *iocb, bool vectored, 1459 + bool compat) 1460 + { 1461 + struct file *file = req->ki_filp; 1462 + struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1463 + struct iov_iter iter; 1464 + ssize_t ret; 1465 + 1466 + if (unlikely(!(file->f_mode & FMODE_WRITE))) 1467 + return -EBADF; 1468 + if (unlikely(!file->f_op->write_iter)) 1469 + return -EINVAL; 1470 + 1471 + ret = aio_setup_rw(WRITE, iocb, &iovec, vectored, compat, &iter); 1472 + if (ret) 1473 + return ret; 1474 + ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter)); 1475 + if (!ret) { 1476 + req->ki_flags |= IOCB_WRITE; 1477 + file_start_write(file); 1478 + ret = aio_ret(req, file->f_op->write_iter(req, &iter)); 1479 + /* 1480 + * We release freeze protection in aio_complete(). Fool lockdep 1481 + * by telling it the lock got released so that it doesn't 1482 + * complain about held lock when we return to userspace. 1483 + */ 1484 + __sb_writers_release(file_inode(file)->i_sb, SB_FREEZE_WRITE); 1485 + } 1486 + kfree(iovec); 1487 + return ret; 1516 1488 } 1517 1489 1518 1490 static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb, 1519 1491 struct iocb *iocb, bool compat) 1520 1492 { 1521 1493 struct aio_kiocb *req; 1494 + struct file *file; 1522 1495 ssize_t ret; 1523 1496 1524 1497 /* enforce forwards compatibility on users */ ··· 1525 1530 if (unlikely(!req)) 1526 1531 return -EAGAIN; 1527 1532 1528 - req->common.ki_filp = fget(iocb->aio_fildes); 1533 + req->common.ki_filp = file = fget(iocb->aio_fildes); 1529 1534 if (unlikely(!req->common.ki_filp)) { 1530 1535 ret = -EBADF; 1531 1536 goto out_put_req; ··· 1560 1565 req->ki_user_iocb = user_iocb; 1561 1566 req->ki_user_data = iocb->aio_data; 1562 1567 1563 - ret = aio_run_iocb(&req->common, iocb->aio_lio_opcode, 1564 - (char __user *)(unsigned long)iocb->aio_buf, 1565 - iocb->aio_nbytes, 1566 - compat); 1567 - if (ret) 1568 - goto out_put_req; 1568 + get_file(file); 1569 + switch (iocb->aio_lio_opcode) { 1570 + case IOCB_CMD_PREAD: 1571 + ret = aio_read(&req->common, iocb, false, compat); 1572 + break; 1573 + case IOCB_CMD_PWRITE: 1574 + ret = aio_write(&req->common, iocb, false, compat); 1575 + break; 1576 + case IOCB_CMD_PREADV: 1577 + ret = aio_read(&req->common, iocb, true, compat); 1578 + break; 1579 + case IOCB_CMD_PWRITEV: 1580 + ret = aio_write(&req->common, iocb, true, compat); 1581 + break; 1582 + default: 1583 + pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode); 1584 + ret = -EINVAL; 1585 + break; 1586 + } 1587 + fput(file); 1569 1588 1589 + if (ret && ret != -EIOCBQUEUED) 1590 + goto out_put_req; 1570 1591 return 0; 1571 1592 out_put_req: 1572 1593 put_reqs_available(ctx, 1);

-2

fs/ntfs/dir.c

··· 1544 1544 .iterate = ntfs_readdir, /* Read directory contents. */ 1545 1545 #ifdef NTFS_RW 1546 1546 .fsync = ntfs_dir_fsync, /* Sync a directory to disk. */ 1547 - /*.aio_fsync = ,*/ /* Sync all outstanding async 1548 - i/o operations on a kiocb. */ 1549 1547 #endif /* NTFS_RW */ 1550 1548 /*.ioctl = ,*/ /* Perform function on the 1551 1549 mounted filesystem. */

-5

fs/splice.c

··· 299 299 { 300 300 struct iov_iter to; 301 301 struct kiocb kiocb; 302 - loff_t isize; 303 302 int idx, ret; 304 - 305 - isize = i_size_read(in->f_mapping->host); 306 - if (unlikely(*ppos >= isize)) 307 - return 0; 308 303 309 304 iov_iter_pipe(&to, ITER_PIPE | READ, pipe, len); 310 305 idx = to.idx;

+1 -1

include/linux/fs.h

··· 321 321 #define IOCB_HIPRI (1 << 3) 322 322 #define IOCB_DSYNC (1 << 4) 323 323 #define IOCB_SYNC (1 << 5) 324 + #define IOCB_WRITE (1 << 6) 324 325 325 326 struct kiocb { 326 327 struct file *ki_filp; ··· 1710 1709 int (*flush) (struct file *, fl_owner_t id); 1711 1710 int (*release) (struct inode *, struct file *); 1712 1711 int (*fsync) (struct file *, loff_t, loff_t, int datasync); 1713 - int (*aio_fsync) (struct kiocb *, int datasync); 1714 1712 int (*fasync) (int, struct file *, int); 1715 1713 int (*lock) (struct file *, int, struct file_lock *); 1716 1714 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);

+3

mm/filemap.c

··· 1732 1732 if (inode->i_blkbits == PAGE_SHIFT || 1733 1733 !mapping->a_ops->is_partially_uptodate) 1734 1734 goto page_not_up_to_date; 1735 + /* pipes can't handle partially uptodate pages */ 1736 + if (unlikely(iter->type & ITER_PIPE)) 1737 + goto page_not_up_to_date; 1735 1738 if (!trylock_page(page)) 1736 1739 goto page_not_up_to_date; 1737 1740 /* Did it get truncated before we got the lock? */

Configure Feed

Configure Feed