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&gt; All errors (new ones prefixed by >>): fs/ceph/file.c: In function 'ceph_sync_write': 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)) { 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