7:52 p.m.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/jlayton/linux.git
ceph-fscrypt-content
head: a7bdf8275eeb05b44be3426ce23ac0e99791ab80
commit: 81588e00b89cb14beb905a04b84198f99f5db059 [50/51] ceph: add read/modify/write to
ceph_sync_write
config: arm64-buildonly-randconfig-r003-20211210
(https://download.01.org/0day-ci/archive/20211210/202112101601.2Bb6e4oM-lk...)
compiler: aarch64-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O
~/bin/make.cross
chmod +x ~/bin/make.cross
#
https://git.kernel.org/pub/scm/linux/kernel/git/jlayton/linux.git/commit/...
git remote add jlayton
https://git.kernel.org/pub/scm/linux/kernel/git/jlayton/linux.git
git fetch --no-tags jlayton ceph-fscrypt-content
git checkout 81588e00b89cb14beb905a04b84198f99f5db059
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir
ARCH=arm64 SHELL=/bin/bash fs/ceph/
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp(a)intel.com>
All errors (new ones prefixed by >>):
fs/ceph/file.c: In function 'ceph_sync_write':
> fs/ceph/file.c:1710:31: error: too many arguments to function
'ceph_fscrypt_encrypt_pages'
1710 | ret =
ceph_fscrypt_encrypt_pages(inode, pages,
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from fs/ceph/super.h:29,
from fs/ceph/file.c:16:
fs/ceph/crypto.h:213:19: note: declared here
213 | static inline int ceph_fscrypt_encrypt_pages(struct inode *inode, struct page
**page,
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
At top level:
fs/ceph/file.c:1283:1: warning: 'ceph_direct_read_write' defined but not used
[-Wunused-function]
1283 | ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,
| ^~~~~~~~~~~~~~~~~~~~~~
vim +/ceph_fscrypt_encrypt_pages +1710 fs/ceph/file.c
1485
1486 /*
1487 * Synchronous write, straight from __user pointer or user pages.
1488 *
1489 * If write spans object boundary, just do multiple writes. (For a
1490 * correct atomic write, we should e.g. take write locks on all
1491 * objects, rollback on failure, etc.)
1492 */
1493 static ssize_t
1494 ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
1495 struct ceph_snap_context *snapc)
1496 {
1497 struct file *file = iocb->ki_filp;
1498 struct inode *inode = file_inode(file);
1499 struct ceph_inode_info *ci = ceph_inode(inode);
1500 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
1501 struct ceph_osd_client *osdc = &fsc->client->osdc;
1502 struct ceph_osd_request *req;
1503 struct page **pages;
1504 u64 len;
1505 int num_pages;
1506 int written = 0;
1507 int ret;
1508 bool check_caps = false;
1509 struct timespec64 mtime = current_time(inode);
1510 size_t count = iov_iter_count(from);
1511
1512 if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
1513 return -EROFS;
1514
1515 dout("sync_write on file %p %lld~%u snapc %p seq %lld\n",
1516 file, pos, (unsigned)count, snapc, snapc->seq);
1517
1518 ret = filemap_write_and_wait_range(inode->i_mapping,
1519 pos, pos + count - 1);
1520 if (ret < 0)
1521 return ret;
1522
1523 ret = invalidate_inode_pages2_range(inode->i_mapping,
1524 pos >> PAGE_SHIFT,
1525 (pos + count - 1) >> PAGE_SHIFT);
1526 if (ret < 0)
1527 dout("invalidate_inode_pages2_range returned %d\n", ret);
1528
1529 while ((len = iov_iter_count(from)) > 0) {
1530 size_t left;
1531 int n;
1532 u64 write_pos = pos;
1533 u64 write_len;
1534 u64 objnum, objoff;
1535 u32 objlen;
1536 u64 assert_ver;
1537 bool rmw;
1538 struct iov_iter saved_iter = *from;
1539 size_t off;
1540
1541 /* clamp the length to the end of first object */
1542 ceph_calc_file_object_mapping(&ci->i_layout, pos, len,
1543 &objnum, &objoff, &objlen);
1544 if (objlen < len)
1545 len = objlen;
1546
1547 write_len = len;
1548 fscrypt_adjust_off_and_len(inode, &write_pos, &write_len);
1549
1550 /*
1551 * If we had to adjust the length or position to align with a
1552 * crypto block, then we must do a read/modify/write cycle. We
1553 * use a version assertion to redrive the thing if something
1554 * changes in between.
1555 */
1556 rmw = (pos != write_pos || len != write_len);
1557
1558 /*
1559 * The data is emplaced into the page as it would be if it were in
1560 * an array of pagecache pages.
1561 */
1562 num_pages = calc_pages_for(write_pos, write_len);
1563 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
1564 if (IS_ERR(pages)) {
1565 ret = PTR_ERR(pages);
1566 break;
1567 }
1568
1569 /* Do we need to preload the pages? */
1570 if (rmw) {
1571 u64 first_pos = write_pos;
1572 u64 last_pos = (write_pos + write_len) - CEPH_FSCRYPT_BLOCK_SIZE;
1573 u64 read_len = CEPH_FSCRYPT_BLOCK_SIZE;
1574 bool first = (pos != write_pos);
1575 bool last = (len != write_len && first_pos != last_pos);
1576
1577 /* We should only need to do this for encrypted inodes */
1578 WARN_ON_ONCE(!IS_ENCRYPTED(inode));
1579
1580 /*
1581 * Allocate a read request for one or two extents, depending
1582 * on how the request was aligned.
1583 */
1584 req = ceph_osdc_new_request(osdc, &ci->i_layout,
1585 ci->i_vino, first ? first_pos : last_pos,
1586 &read_len, 0, (first && last) ? 2 : 1,
1587 CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
1588 NULL, ci->i_truncate_seq,
1589 ci->i_truncate_size, false);
1590 if (IS_ERR(req)) {
1591 ceph_release_page_vector(pages, num_pages);
1592 ret = PTR_ERR(req);
1593 break;
1594 }
1595
1596 /* Something is misaligned! */
1597 if (read_len != CEPH_FSCRYPT_BLOCK_SIZE) {
1598 ret = -EIO;
1599 break;
1600 }
1601
1602 /* Add extent for first block? */
1603 if (first)
1604 osd_req_op_extent_osd_data_pages(req, 0, pages,
1605 CEPH_FSCRYPT_BLOCK_SIZE,
1606 offset_in_page(first_pos),
1607 false, false);
1608
1609 /* Add extent for last block */
1610 if (last) {
1611 /* Init the other extent if first extent has been used */
1612 if (first) {
1613 osd_req_op_extent_init(req, 1, CEPH_OSD_OP_READ,
1614 last_pos, read_len,
1615 ci->i_truncate_size,
1616 ci->i_truncate_seq);
1617 }
1618
1619 osd_req_op_extent_osd_data_pages(req, first ? 1 : 0,
1620 &pages[num_pages - 1],
1621 CEPH_FSCRYPT_BLOCK_SIZE,
1622 offset_in_page(last_pos),
1623 false, false);
1624 }
1625
1626 ret = ceph_osdc_start_request(osdc, req, false);
1627 if (!ret)
1628 ret = ceph_osdc_wait_request(osdc, req);
1629
1630 /* FIXME: length field is wrong if there are 2 extents */
1631 ceph_update_read_metrics(&fsc->mdsc->metric,
1632 req->r_start_latency,
1633 req->r_end_latency,
1634 read_len, ret);
1635
1636 /* Ok if object is not already present */
1637 if (ret == -ENOENT) {
1638 /*
1639 * If there is no object, then we can't assert
1640 * on its version. Clear rmw so that we don't try.
1641 */
1642 ceph_osdc_put_request(req);
1643 rmw = false;
1644 ret = 0;
1645
1646 /*
1647 * zero out the soon-to-be uncopied parts of the
1648 * first and last pages.
1649 */
1650 if (first)
1651 zero_user_segment(pages[0], 0,
1652 offset_in_page(first_pos));
1653 if (last)
1654 zero_user_segment(pages[num_pages - 1],
1655 offset_in_page(last_pos),
1656 PAGE_SIZE);
1657 } else {
1658 /* Grab assert version. It must be non-zero. */
1659 assert_ver = req->r_version;
1660 WARN_ON_ONCE(assert_ver == 0);
1661
1662 ceph_osdc_put_request(req);
1663 if (ret < 0) {
1664 ceph_release_page_vector(pages, num_pages);
1665 break;
1666 }
1667
1668 if (first) {
1669 ret = ceph_fscrypt_decrypt_block_inplace(inode,
1670 pages[0],
1671 CEPH_FSCRYPT_BLOCK_SIZE,
1672 offset_in_page(first_pos),
1673 first_pos >> CEPH_FSCRYPT_BLOCK_SHIFT);
1674 if (ret)
1675 break;
1676 }
1677 if (last) {
1678 ret = ceph_fscrypt_decrypt_block_inplace(inode,
1679 pages[num_pages - 1],
1680 CEPH_FSCRYPT_BLOCK_SIZE,
1681 offset_in_page(last_pos),
1682 last_pos >> CEPH_FSCRYPT_BLOCK_SHIFT);
1683 if (ret)
1684 break;
1685 }
1686 }
1687 }
1688
1689 left = len;
1690 off = offset_in_page(pos);
1691 for (n = 0; n < num_pages; n++) {
1692 size_t plen = min_t(size_t, left, PAGE_SIZE - off);
1693
1694 /* copy the data */
1695 ret = copy_page_from_iter(pages[n], off, plen, from);
1696 if (ret != plen) {
1697 ret = -EFAULT;
1698 break;
1699 }
1700 off = 0;
1701 left -= ret;
1702 }
1703 if (ret < 0) {
1704 dout("sync_write write failed with %d\n", ret);
1705 ceph_release_page_vector(pages, num_pages);
1706 break;
1707 }
1708
1709 if (IS_ENCRYPTED(inode)) {
1710 ret = ceph_fscrypt_encrypt_pages(inode, pages,
1711 offset_in_page(write_pos),
1712 write_len, GFP_KERNEL);
1713 if (ret < 0) {
1714 dout("encryption failed with %d\n", ret);
1715 break;
1716 }
1717 }
1718
1719 req = ceph_osdc_new_request(osdc, &ci->i_layout,
1720 ci->i_vino, write_pos, &write_len,
1721 rmw ? 1 : 0, rmw ? 2 : 1,
1722 CEPH_OSD_OP_WRITE,
1723 CEPH_OSD_FLAG_WRITE,
1724 snapc, ci->i_truncate_seq,
1725 ci->i_truncate_size, false);
1726 if (IS_ERR(req)) {
1727 ret = PTR_ERR(req);
1728 ceph_release_page_vector(pages, num_pages);
1729 break;
1730 }
1731
1732 osd_req_op_extent_osd_data_pages(req, rmw ? 1 : 0, pages, write_len,
1733 write_pos & ~CEPH_FSCRYPT_BLOCK_MASK,
1734 false, true);
1735 req->r_inode = inode;
1736 req->r_mtime = mtime;
1737
1738 /* Set up the assertion */
1739 if (rmw) {
1740 /* Set up the assertion */
1741 osd_req_op_init(req, 0, CEPH_OSD_OP_ASSERT_VER, 0);
1742 req->r_ops[0].assert_ver.ver = assert_ver;
1743 }
1744
1745 ret = ceph_osdc_start_request(osdc, req, false);
1746 if (!ret)
1747 ret = ceph_osdc_wait_request(osdc, req);
1748
1749 ceph_update_write_metrics(&fsc->mdsc->metric, req->r_start_latency,
1750 req->r_end_latency, len, ret);
1751 ceph_osdc_put_request(req);
1752 if (ret != 0) {
1753 dout("sync_write osd write returned %d\n", ret);
1754 /* Version changed! Must re-do the rmw cycle */
1755 if (ret == -ERANGE || ret == -EOVERFLOW) {
1756 /* We should only ever see this on a rmw */
1757 WARN_ON_ONCE(!rmw);
1758
1759 /* The version should never go backward */
1760 WARN_ON_ONCE(ret == -EOVERFLOW);
1761
1762 *from = saved_iter;
1763
1764 /* FIXME: limit number of times we loop? */
1765 continue;
1766 }
1767 ceph_set_error_write(ci);
1768 break;
1769 }
1770 ceph_clear_error_write(ci);
1771 pos += len;
1772 written += len;
1773 if (pos > i_size_read(inode)) {
1774 check_caps = ceph_inode_set_size(inode, pos);
1775 if (check_caps)
1776 ceph_check_caps(ceph_inode(inode),
1777 CHECK_CAPS_AUTHONLY,
1778 NULL);
1779 }
1780
1781 }
1782
1783 if (ret != -EOLDSNAPC && written > 0) {
1784 ret = written;
1785 iocb->ki_pos = pos;
1786 }
1787 dout("sync_write returning %d\n", ret);
1788 return ret;
1789 }
1790
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org