13d14c5d2SYehuda Sadeh #include <linux/ceph/ceph_debug.h> 21d3576fdSSage Weil 31d3576fdSSage Weil #include <linux/backing-dev.h> 41d3576fdSSage Weil #include <linux/fs.h> 51d3576fdSSage Weil #include <linux/mm.h> 61d3576fdSSage Weil #include <linux/pagemap.h> 71d3576fdSSage Weil #include <linux/writeback.h> /* generic_writepages */ 85a0e3ad6STejun Heo #include <linux/slab.h> 91d3576fdSSage Weil #include <linux/pagevec.h> 101d3576fdSSage Weil #include <linux/task_io_accounting_ops.h> 11f361bf4aSIngo Molnar #include <linux/signal.h> 121d3576fdSSage Weil 131d3576fdSSage Weil #include "super.h" 143d14c5d2SYehuda Sadeh #include "mds_client.h" 1599ccbd22SMilosz Tanski #include "cache.h" 163d14c5d2SYehuda Sadeh #include <linux/ceph/osd_client.h> 171d3576fdSSage Weil 181d3576fdSSage Weil /* 191d3576fdSSage Weil * Ceph address space ops. 201d3576fdSSage Weil * 211d3576fdSSage Weil * There are a few funny things going on here. 221d3576fdSSage Weil * 231d3576fdSSage Weil * The page->private field is used to reference a struct 241d3576fdSSage Weil * ceph_snap_context for _every_ dirty page. This indicates which 251d3576fdSSage Weil * snapshot the page was logically dirtied in, and thus which snap 261d3576fdSSage Weil * context needs to be associated with the osd write during writeback. 271d3576fdSSage Weil * 281d3576fdSSage Weil * Similarly, struct ceph_inode_info maintains a set of counters to 2925985edcSLucas De Marchi * count dirty pages on the inode. In the absence of snapshots, 301d3576fdSSage Weil * i_wrbuffer_ref == i_wrbuffer_ref_head == the dirty page count. 311d3576fdSSage Weil * 321d3576fdSSage Weil * When a snapshot is taken (that is, when the client receives 331d3576fdSSage Weil * notification that a snapshot was taken), each inode with caps and 341d3576fdSSage Weil * with dirty pages (dirty pages implies there is a cap) gets a new 351d3576fdSSage Weil * ceph_cap_snap in the i_cap_snaps list (which is sorted in ascending 361d3576fdSSage Weil * order, new snaps go to the tail). The i_wrbuffer_ref_head count is 371d3576fdSSage Weil * moved to capsnap->dirty. (Unless a sync write is currently in 381d3576fdSSage Weil * progress. In that case, the capsnap is said to be "pending", new 391d3576fdSSage Weil * writes cannot start, and the capsnap isn't "finalized" until the 401d3576fdSSage Weil * write completes (or fails) and a final size/mtime for the inode for 411d3576fdSSage Weil * that snap can be settled upon.) i_wrbuffer_ref_head is reset to 0. 421d3576fdSSage Weil * 431d3576fdSSage Weil * On writeback, we must submit writes to the osd IN SNAP ORDER. So, 441d3576fdSSage Weil * we look for the first capsnap in i_cap_snaps and write out pages in 451d3576fdSSage Weil * that snap context _only_. Then we move on to the next capsnap, 461d3576fdSSage Weil * eventually reaching the "live" or "head" context (i.e., pages that 471d3576fdSSage Weil * are not yet snapped) and are writing the most recently dirtied 481d3576fdSSage Weil * pages. 491d3576fdSSage Weil * 501d3576fdSSage Weil * Invalidate and so forth must take care to ensure the dirty page 511d3576fdSSage Weil * accounting is preserved. 521d3576fdSSage Weil */ 531d3576fdSSage Weil 542baba250SYehuda Sadeh #define CONGESTION_ON_THRESH(congestion_kb) (congestion_kb >> (PAGE_SHIFT-10)) 552baba250SYehuda Sadeh #define CONGESTION_OFF_THRESH(congestion_kb) \ 562baba250SYehuda Sadeh (CONGESTION_ON_THRESH(congestion_kb) - \ 572baba250SYehuda Sadeh (CONGESTION_ON_THRESH(congestion_kb) >> 2)) 582baba250SYehuda Sadeh 5961600ef8SYan, Zheng static inline struct ceph_snap_context *page_snap_context(struct page *page) 6061600ef8SYan, Zheng { 6161600ef8SYan, Zheng if (PagePrivate(page)) 6261600ef8SYan, Zheng return (void *)page->private; 6361600ef8SYan, Zheng return NULL; 6461600ef8SYan, Zheng } 651d3576fdSSage Weil 661d3576fdSSage Weil /* 671d3576fdSSage Weil * Dirty a page. Optimistically adjust accounting, on the assumption 681d3576fdSSage Weil * that we won't race with invalidate. If we do, readjust. 691d3576fdSSage Weil */ 701d3576fdSSage Weil static int ceph_set_page_dirty(struct page *page) 711d3576fdSSage Weil { 721d3576fdSSage Weil struct address_space *mapping = page->mapping; 731d3576fdSSage Weil struct inode *inode; 741d3576fdSSage Weil struct ceph_inode_info *ci; 751d3576fdSSage Weil struct ceph_snap_context *snapc; 767d6e1f54SSha Zhengju int ret; 771d3576fdSSage Weil 781d3576fdSSage Weil if (unlikely(!mapping)) 791d3576fdSSage Weil return !TestSetPageDirty(page); 801d3576fdSSage Weil 817d6e1f54SSha Zhengju if (PageDirty(page)) { 821d3576fdSSage Weil dout("%p set_page_dirty %p idx %lu -- already dirty\n", 831d3576fdSSage Weil mapping->host, page, page->index); 847d6e1f54SSha Zhengju BUG_ON(!PagePrivate(page)); 851d3576fdSSage Weil return 0; 861d3576fdSSage Weil } 871d3576fdSSage Weil 881d3576fdSSage Weil inode = mapping->host; 891d3576fdSSage Weil ci = ceph_inode(inode); 901d3576fdSSage Weil 911d3576fdSSage Weil /* dirty the head */ 92be655596SSage Weil spin_lock(&ci->i_ceph_lock); 935dda377cSYan, Zheng BUG_ON(ci->i_wr_ref == 0); // caller should hold Fw reference 945dda377cSYan, Zheng if (__ceph_have_pending_cap_snap(ci)) { 955dda377cSYan, Zheng struct ceph_cap_snap *capsnap = 965dda377cSYan, Zheng list_last_entry(&ci->i_cap_snaps, 975dda377cSYan, Zheng struct ceph_cap_snap, 985dda377cSYan, Zheng ci_item); 995dda377cSYan, Zheng snapc = ceph_get_snap_context(capsnap->context); 1005dda377cSYan, Zheng capsnap->dirty_pages++; 1015dda377cSYan, Zheng } else { 1025dda377cSYan, Zheng BUG_ON(!ci->i_head_snapc); 1035dda377cSYan, Zheng snapc = ceph_get_snap_context(ci->i_head_snapc); 1041d3576fdSSage Weil ++ci->i_wrbuffer_ref_head; 1055dda377cSYan, Zheng } 1061d3576fdSSage Weil if (ci->i_wrbuffer_ref == 0) 1070444d76aSDave Chinner ihold(inode); 1081d3576fdSSage Weil ++ci->i_wrbuffer_ref; 1091d3576fdSSage Weil dout("%p set_page_dirty %p idx %lu head %d/%d -> %d/%d " 1101d3576fdSSage Weil "snapc %p seq %lld (%d snaps)\n", 1111d3576fdSSage Weil mapping->host, page, page->index, 1121d3576fdSSage Weil ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1, 1131d3576fdSSage Weil ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head, 1141d3576fdSSage Weil snapc, snapc->seq, snapc->num_snaps); 115be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 1161d3576fdSSage Weil 1171d3576fdSSage Weil /* 1181d3576fdSSage Weil * Reference snap context in page->private. Also set 1191d3576fdSSage Weil * PagePrivate so that we get invalidatepage callback. 1201d3576fdSSage Weil */ 1217d6e1f54SSha Zhengju BUG_ON(PagePrivate(page)); 1221d3576fdSSage Weil page->private = (unsigned long)snapc; 1231d3576fdSSage Weil SetPagePrivate(page); 1241d3576fdSSage Weil 1257d6e1f54SSha Zhengju ret = __set_page_dirty_nobuffers(page); 1267d6e1f54SSha Zhengju WARN_ON(!PageLocked(page)); 1277d6e1f54SSha Zhengju WARN_ON(!page->mapping); 1281d3576fdSSage Weil 1297d6e1f54SSha Zhengju return ret; 1301d3576fdSSage Weil } 1311d3576fdSSage Weil 1321d3576fdSSage Weil /* 1331d3576fdSSage Weil * If we are truncating the full page (i.e. offset == 0), adjust the 1341d3576fdSSage Weil * dirty page counters appropriately. Only called if there is private 1351d3576fdSSage Weil * data on the page. 1361d3576fdSSage Weil */ 137d47992f8SLukas Czerner static void ceph_invalidatepage(struct page *page, unsigned int offset, 138d47992f8SLukas Czerner unsigned int length) 1391d3576fdSSage Weil { 1404ce1e9adSAlexander Beregalov struct inode *inode; 1411d3576fdSSage Weil struct ceph_inode_info *ci; 14261600ef8SYan, Zheng struct ceph_snap_context *snapc = page_snap_context(page); 1431d3576fdSSage Weil 1444ce1e9adSAlexander Beregalov inode = page->mapping->host; 145b150f5c1SMilosz Tanski ci = ceph_inode(inode); 146b150f5c1SMilosz Tanski 14709cbfeafSKirill A. Shutemov if (offset != 0 || length != PAGE_SIZE) { 148b150f5c1SMilosz Tanski dout("%p invalidatepage %p idx %lu partial dirty page %u~%u\n", 149b150f5c1SMilosz Tanski inode, page, page->index, offset, length); 150b150f5c1SMilosz Tanski return; 151b150f5c1SMilosz Tanski } 1524ce1e9adSAlexander Beregalov 15399ccbd22SMilosz Tanski ceph_invalidate_fscache_page(inode, page); 15499ccbd22SMilosz Tanski 15599ccbd22SMilosz Tanski if (!PagePrivate(page)) 15699ccbd22SMilosz Tanski return; 15799ccbd22SMilosz Tanski 1581d3576fdSSage Weil /* 1591d3576fdSSage Weil * We can get non-dirty pages here due to races between 1601d3576fdSSage Weil * set_page_dirty and truncate_complete_page; just spit out a 1611d3576fdSSage Weil * warning, in case we end up with accounting problems later. 1621d3576fdSSage Weil */ 1631d3576fdSSage Weil if (!PageDirty(page)) 1641d3576fdSSage Weil pr_err("%p invalidatepage %p page not dirty\n", inode, page); 1651d3576fdSSage Weil 1661d3576fdSSage Weil ClearPageChecked(page); 1671d3576fdSSage Weil 168569d39fcSLukas Czerner dout("%p invalidatepage %p idx %lu full dirty page\n", 169569d39fcSLukas Czerner inode, page, page->index); 170b150f5c1SMilosz Tanski 1711d3576fdSSage Weil ceph_put_wrbuffer_cap_refs(ci, 1, snapc); 1721d3576fdSSage Weil ceph_put_snap_context(snapc); 1731d3576fdSSage Weil page->private = 0; 1741d3576fdSSage Weil ClearPagePrivate(page); 1751d3576fdSSage Weil } 1761d3576fdSSage Weil 1771d3576fdSSage Weil static int ceph_releasepage(struct page *page, gfp_t g) 1781d3576fdSSage Weil { 179e55f1a18SNeilBrown dout("%p releasepage %p idx %lu (%sdirty)\n", page->mapping->host, 180e55f1a18SNeilBrown page, page->index, PageDirty(page) ? "" : "not "); 18199ccbd22SMilosz Tanski 18299ccbd22SMilosz Tanski /* Can we release the page from the cache? */ 18399ccbd22SMilosz Tanski if (!ceph_release_fscache_page(page, g)) 1841d3576fdSSage Weil return 0; 18599ccbd22SMilosz Tanski 18699ccbd22SMilosz Tanski return !PagePrivate(page); 1871d3576fdSSage Weil } 1881d3576fdSSage Weil 1891d3576fdSSage Weil /* 1901d3576fdSSage Weil * read a single page, without unlocking it. 1911d3576fdSSage Weil */ 192dd2bc473SYan, Zheng static int ceph_do_readpage(struct file *filp, struct page *page) 1931d3576fdSSage Weil { 194496ad9aaSAl Viro struct inode *inode = file_inode(filp); 1951d3576fdSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 1963d14c5d2SYehuda Sadeh struct ceph_osd_client *osdc = 1973d14c5d2SYehuda Sadeh &ceph_inode_to_client(inode)->client->osdc; 1981d3576fdSSage Weil int err = 0; 19983701246SYan, Zheng u64 off = page_offset(page); 20009cbfeafSKirill A. Shutemov u64 len = PAGE_SIZE; 2011d3576fdSSage Weil 20283701246SYan, Zheng if (off >= i_size_read(inode)) { 20309cbfeafSKirill A. Shutemov zero_user_segment(page, 0, PAGE_SIZE); 20483701246SYan, Zheng SetPageUptodate(page); 20583701246SYan, Zheng return 0; 20683701246SYan, Zheng } 20799ccbd22SMilosz Tanski 208fcc02d2aSYan, Zheng if (ci->i_inline_version != CEPH_INLINE_NONE) { 20983701246SYan, Zheng /* 210fcc02d2aSYan, Zheng * Uptodate inline data should have been added 211fcc02d2aSYan, Zheng * into page cache while getting Fcr caps. 21283701246SYan, Zheng */ 213fcc02d2aSYan, Zheng if (off == 0) 21483701246SYan, Zheng return -EINVAL; 21509cbfeafSKirill A. Shutemov zero_user_segment(page, 0, PAGE_SIZE); 216fcc02d2aSYan, Zheng SetPageUptodate(page); 217fcc02d2aSYan, Zheng return 0; 218fcc02d2aSYan, Zheng } 21983701246SYan, Zheng 22083701246SYan, Zheng err = ceph_readpage_from_fscache(inode, page); 22199ccbd22SMilosz Tanski if (err == 0) 222dd2bc473SYan, Zheng return -EINPROGRESS; 22399ccbd22SMilosz Tanski 2241d3576fdSSage Weil dout("readpage inode %p file %p page %p index %lu\n", 2251d3576fdSSage Weil inode, filp, page, page->index); 2261d3576fdSSage Weil err = ceph_osdc_readpages(osdc, ceph_vino(inode), &ci->i_layout, 22783701246SYan, Zheng off, &len, 2281d3576fdSSage Weil ci->i_truncate_seq, ci->i_truncate_size, 229b7495fc2SSage Weil &page, 1, 0); 2301d3576fdSSage Weil if (err == -ENOENT) 2311d3576fdSSage Weil err = 0; 2321d3576fdSSage Weil if (err < 0) { 2331d3576fdSSage Weil SetPageError(page); 23418302805SLi Wang ceph_fscache_readpage_cancel(inode, page); 2351d3576fdSSage Weil goto out; 23623cd573bSZhang Zhen } 23709cbfeafSKirill A. Shutemov if (err < PAGE_SIZE) 2381d3576fdSSage Weil /* zero fill remainder of page */ 23909cbfeafSKirill A. Shutemov zero_user_segment(page, err, PAGE_SIZE); 24023cd573bSZhang Zhen else 24156f91aadSLi Wang flush_dcache_page(page); 2421d3576fdSSage Weil 24323cd573bSZhang Zhen SetPageUptodate(page); 24499ccbd22SMilosz Tanski ceph_readpage_to_fscache(inode, page); 24599ccbd22SMilosz Tanski 2461d3576fdSSage Weil out: 2471d3576fdSSage Weil return err < 0 ? err : 0; 2481d3576fdSSage Weil } 2491d3576fdSSage Weil 2501d3576fdSSage Weil static int ceph_readpage(struct file *filp, struct page *page) 2511d3576fdSSage Weil { 252dd2bc473SYan, Zheng int r = ceph_do_readpage(filp, page); 253dd2bc473SYan, Zheng if (r != -EINPROGRESS) 2541d3576fdSSage Weil unlock_page(page); 255dd2bc473SYan, Zheng else 256dd2bc473SYan, Zheng r = 0; 2571d3576fdSSage Weil return r; 2581d3576fdSSage Weil } 2591d3576fdSSage Weil 2601d3576fdSSage Weil /* 2617c272194SSage Weil * Finish an async read(ahead) op. 2621d3576fdSSage Weil */ 26385e084feSIlya Dryomov static void finish_read(struct ceph_osd_request *req) 2641d3576fdSSage Weil { 2657c272194SSage Weil struct inode *inode = req->r_inode; 26687060c10SAlex Elder struct ceph_osd_data *osd_data; 26785e084feSIlya Dryomov int rc = req->r_result <= 0 ? req->r_result : 0; 26885e084feSIlya Dryomov int bytes = req->r_result >= 0 ? req->r_result : 0; 269e0c59487SAlex Elder int num_pages; 2707c272194SSage Weil int i; 2717c272194SSage Weil 2727c272194SSage Weil dout("finish_read %p req %p rc %d bytes %d\n", inode, req, rc, bytes); 2737c272194SSage Weil 2747c272194SSage Weil /* unlock all pages, zeroing any data we didn't read */ 275406e2c9fSAlex Elder osd_data = osd_req_op_extent_osd_data(req, 0); 27687060c10SAlex Elder BUG_ON(osd_data->type != CEPH_OSD_DATA_TYPE_PAGES); 27787060c10SAlex Elder num_pages = calc_pages_for((u64)osd_data->alignment, 27887060c10SAlex Elder (u64)osd_data->length); 279e0c59487SAlex Elder for (i = 0; i < num_pages; i++) { 28087060c10SAlex Elder struct page *page = osd_data->pages[i]; 2817c272194SSage Weil 282368e3585SYan, Zheng if (rc < 0 && rc != -ENOENT) { 283368e3585SYan, Zheng ceph_fscache_readpage_cancel(inode, page); 284f36132a7SLi Wang goto unlock; 285368e3585SYan, Zheng } 28609cbfeafSKirill A. Shutemov if (bytes < (int)PAGE_SIZE) { 2877c272194SSage Weil /* zero (remainder of) page */ 2887c272194SSage Weil int s = bytes < 0 ? 0 : bytes; 28909cbfeafSKirill A. Shutemov zero_user_segment(page, s, PAGE_SIZE); 2907c272194SSage Weil } 2917c272194SSage Weil dout("finish_read %p uptodate %p idx %lu\n", inode, page, 2927c272194SSage Weil page->index); 2937c272194SSage Weil flush_dcache_page(page); 2947c272194SSage Weil SetPageUptodate(page); 29599ccbd22SMilosz Tanski ceph_readpage_to_fscache(inode, page); 296f36132a7SLi Wang unlock: 2977c272194SSage Weil unlock_page(page); 29809cbfeafSKirill A. Shutemov put_page(page); 29909cbfeafSKirill A. Shutemov bytes -= PAGE_SIZE; 3007c272194SSage Weil } 30187060c10SAlex Elder kfree(osd_data->pages); 3027c272194SSage Weil } 3037c272194SSage Weil 3047c272194SSage Weil /* 3057c272194SSage Weil * start an async read(ahead) operation. return nr_pages we submitted 3067c272194SSage Weil * a read for on success, or negative error code. 3077c272194SSage Weil */ 3080d66a487SSage Weil static int start_read(struct inode *inode, struct list_head *page_list, int max) 3097c272194SSage Weil { 3107c272194SSage Weil struct ceph_osd_client *osdc = 3117c272194SSage Weil &ceph_inode_to_client(inode)->client->osdc; 3127c272194SSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 3137c272194SSage Weil struct page *page = list_entry(page_list->prev, struct page, lru); 314acead002SAlex Elder struct ceph_vino vino; 3157c272194SSage Weil struct ceph_osd_request *req; 3167c272194SSage Weil u64 off; 3177c272194SSage Weil u64 len; 3187c272194SSage Weil int i; 3191d3576fdSSage Weil struct page **pages; 3207c272194SSage Weil pgoff_t next_index; 3217c272194SSage Weil int nr_pages = 0; 3222b1ac852SYan, Zheng int got = 0; 3232b1ac852SYan, Zheng int ret = 0; 3242b1ac852SYan, Zheng 3252b1ac852SYan, Zheng if (!current->journal_info) { 3262b1ac852SYan, Zheng /* caller of readpages does not hold buffer and read caps 3272b1ac852SYan, Zheng * (fadvise, madvise and readahead cases) */ 3282b1ac852SYan, Zheng int want = CEPH_CAP_FILE_CACHE; 3292b1ac852SYan, Zheng ret = ceph_try_get_caps(ci, CEPH_CAP_FILE_RD, want, &got); 3302b1ac852SYan, Zheng if (ret < 0) { 3312b1ac852SYan, Zheng dout("start_read %p, error getting cap\n", inode); 3322b1ac852SYan, Zheng } else if (!(got & want)) { 3332b1ac852SYan, Zheng dout("start_read %p, no cache cap\n", inode); 3342b1ac852SYan, Zheng ret = 0; 3352b1ac852SYan, Zheng } 3362b1ac852SYan, Zheng if (ret <= 0) { 3372b1ac852SYan, Zheng if (got) 3382b1ac852SYan, Zheng ceph_put_cap_refs(ci, got); 3392b1ac852SYan, Zheng while (!list_empty(page_list)) { 3402b1ac852SYan, Zheng page = list_entry(page_list->prev, 3412b1ac852SYan, Zheng struct page, lru); 3422b1ac852SYan, Zheng list_del(&page->lru); 3432b1ac852SYan, Zheng put_page(page); 3442b1ac852SYan, Zheng } 3452b1ac852SYan, Zheng return ret; 3462b1ac852SYan, Zheng } 3472b1ac852SYan, Zheng } 3487c272194SSage Weil 3496285bc23SAlex Elder off = (u64) page_offset(page); 3507c272194SSage Weil 3517c272194SSage Weil /* count pages */ 3527c272194SSage Weil next_index = page->index; 3537c272194SSage Weil list_for_each_entry_reverse(page, page_list, lru) { 3547c272194SSage Weil if (page->index != next_index) 3557c272194SSage Weil break; 3567c272194SSage Weil nr_pages++; 3577c272194SSage Weil next_index++; 3580d66a487SSage Weil if (max && nr_pages == max) 3590d66a487SSage Weil break; 3607c272194SSage Weil } 36109cbfeafSKirill A. Shutemov len = nr_pages << PAGE_SHIFT; 3627c272194SSage Weil dout("start_read %p nr_pages %d is %lld~%lld\n", inode, nr_pages, 3637c272194SSage Weil off, len); 364acead002SAlex Elder vino = ceph_vino(inode); 365acead002SAlex Elder req = ceph_osdc_new_request(osdc, &ci->i_layout, vino, off, &len, 366715e4cd4SYan, Zheng 0, 1, CEPH_OSD_OP_READ, 367acead002SAlex Elder CEPH_OSD_FLAG_READ, NULL, 3687c272194SSage Weil ci->i_truncate_seq, ci->i_truncate_size, 369acead002SAlex Elder false); 3702b1ac852SYan, Zheng if (IS_ERR(req)) { 3712b1ac852SYan, Zheng ret = PTR_ERR(req); 3722b1ac852SYan, Zheng goto out; 3732b1ac852SYan, Zheng } 3741d3576fdSSage Weil 3751d3576fdSSage Weil /* build page vector */ 376cf7b7e14SAlex Elder nr_pages = calc_pages_for(0, len); 377687265e5SYan, Zheng pages = kmalloc(sizeof(*pages) * nr_pages, GFP_KERNEL); 3782b1ac852SYan, Zheng if (!pages) { 3797c272194SSage Weil ret = -ENOMEM; 3802b1ac852SYan, Zheng goto out_put; 3812b1ac852SYan, Zheng } 3827c272194SSage Weil for (i = 0; i < nr_pages; ++i) { 3837c272194SSage Weil page = list_entry(page_list->prev, struct page, lru); 3847c272194SSage Weil BUG_ON(PageLocked(page)); 3857c272194SSage Weil list_del(&page->lru); 3861d3576fdSSage Weil 3877c272194SSage Weil dout("start_read %p adding %p idx %lu\n", inode, page, 3887c272194SSage Weil page->index); 3897c272194SSage Weil if (add_to_page_cache_lru(page, &inode->i_data, page->index, 390687265e5SYan, Zheng GFP_KERNEL)) { 391d4d3aa38SMilosz Tanski ceph_fscache_uncache_page(inode, page); 39209cbfeafSKirill A. Shutemov put_page(page); 3937c272194SSage Weil dout("start_read %p add_to_page_cache failed %p\n", 3947c272194SSage Weil inode, page); 3957c272194SSage Weil nr_pages = i; 3961afe4785SYan, Zheng if (nr_pages > 0) { 3971afe4785SYan, Zheng len = nr_pages << PAGE_SHIFT; 398d641df81SYan, Zheng osd_req_op_extent_update(req, 0, len); 3991afe4785SYan, Zheng break; 4001afe4785SYan, Zheng } 4017c272194SSage Weil goto out_pages; 4021d3576fdSSage Weil } 4037c272194SSage Weil pages[i] = page; 4041d3576fdSSage Weil } 405406e2c9fSAlex Elder osd_req_op_extent_osd_data_pages(req, 0, pages, len, 0, false, false); 4067c272194SSage Weil req->r_callback = finish_read; 4077c272194SSage Weil req->r_inode = inode; 4087c272194SSage Weil 4097c272194SSage Weil dout("start_read %p starting %p %lld~%lld\n", inode, req, off, len); 4107c272194SSage Weil ret = ceph_osdc_start_request(osdc, req, false); 4117c272194SSage Weil if (ret < 0) 4127c272194SSage Weil goto out_pages; 4137c272194SSage Weil ceph_osdc_put_request(req); 4142b1ac852SYan, Zheng 4152b1ac852SYan, Zheng /* After adding locked pages to page cache, the inode holds cache cap. 4162b1ac852SYan, Zheng * So we can drop our cap refs. */ 4172b1ac852SYan, Zheng if (got) 4182b1ac852SYan, Zheng ceph_put_cap_refs(ci, got); 4192b1ac852SYan, Zheng 4207c272194SSage Weil return nr_pages; 4217c272194SSage Weil 4227c272194SSage Weil out_pages: 4231afe4785SYan, Zheng for (i = 0; i < nr_pages; ++i) { 4241afe4785SYan, Zheng ceph_fscache_readpage_cancel(inode, pages[i]); 4251afe4785SYan, Zheng unlock_page(pages[i]); 4261afe4785SYan, Zheng } 4271afe4785SYan, Zheng ceph_put_page_vector(pages, nr_pages, false); 4282b1ac852SYan, Zheng out_put: 4297c272194SSage Weil ceph_osdc_put_request(req); 4302b1ac852SYan, Zheng out: 4312b1ac852SYan, Zheng if (got) 4322b1ac852SYan, Zheng ceph_put_cap_refs(ci, got); 4337c272194SSage Weil return ret; 4341d3576fdSSage Weil } 4351d3576fdSSage Weil 4367c272194SSage Weil 4371d3576fdSSage Weil /* 4381d3576fdSSage Weil * Read multiple pages. Leave pages we don't read + unlock in page_list; 4391d3576fdSSage Weil * the caller (VM) cleans them up. 4401d3576fdSSage Weil */ 4411d3576fdSSage Weil static int ceph_readpages(struct file *file, struct address_space *mapping, 4421d3576fdSSage Weil struct list_head *page_list, unsigned nr_pages) 4431d3576fdSSage Weil { 444496ad9aaSAl Viro struct inode *inode = file_inode(file); 4450d66a487SSage Weil struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 4461d3576fdSSage Weil int rc = 0; 4470d66a487SSage Weil int max = 0; 4481d3576fdSSage Weil 44983701246SYan, Zheng if (ceph_inode(inode)->i_inline_version != CEPH_INLINE_NONE) 45083701246SYan, Zheng return -EINVAL; 45183701246SYan, Zheng 45299ccbd22SMilosz Tanski rc = ceph_readpages_from_fscache(mapping->host, mapping, page_list, 45399ccbd22SMilosz Tanski &nr_pages); 45499ccbd22SMilosz Tanski 45599ccbd22SMilosz Tanski if (rc == 0) 45699ccbd22SMilosz Tanski goto out; 45799ccbd22SMilosz Tanski 458aa187926SYan, Zheng max = fsc->mount_options->rsize >> PAGE_SHIFT; 459aa187926SYan, Zheng dout("readpages %p file %p nr_pages %d max %d\n", 460aa187926SYan, Zheng inode, file, nr_pages, max); 4617c272194SSage Weil while (!list_empty(page_list)) { 4620d66a487SSage Weil rc = start_read(inode, page_list, max); 4631d3576fdSSage Weil if (rc < 0) 4641d3576fdSSage Weil goto out; 4651d3576fdSSage Weil } 4661d3576fdSSage Weil out: 46776be778bSMilosz Tanski ceph_fscache_readpages_cancel(inode, page_list); 46876be778bSMilosz Tanski 4697c272194SSage Weil dout("readpages %p file %p ret %d\n", inode, file, rc); 4701d3576fdSSage Weil return rc; 4711d3576fdSSage Weil } 4721d3576fdSSage Weil 4731d3576fdSSage Weil /* 4741d3576fdSSage Weil * Get ref for the oldest snapc for an inode with dirty data... that is, the 4751d3576fdSSage Weil * only snap context we are allowed to write back. 4761d3576fdSSage Weil */ 4776298a337SSage Weil static struct ceph_snap_context *get_oldest_context(struct inode *inode, 4785f743e45SYan, Zheng loff_t *snap_size, 4795f743e45SYan, Zheng u64 *truncate_size, 4805f743e45SYan, Zheng u32 *truncate_seq) 4811d3576fdSSage Weil { 4821d3576fdSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 4831d3576fdSSage Weil struct ceph_snap_context *snapc = NULL; 4841d3576fdSSage Weil struct ceph_cap_snap *capsnap = NULL; 4851d3576fdSSage Weil 486be655596SSage Weil spin_lock(&ci->i_ceph_lock); 4871d3576fdSSage Weil list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) { 4881d3576fdSSage Weil dout(" cap_snap %p snapc %p has %d dirty pages\n", capsnap, 4891d3576fdSSage Weil capsnap->context, capsnap->dirty_pages); 4901d3576fdSSage Weil if (capsnap->dirty_pages) { 4911d3576fdSSage Weil snapc = ceph_get_snap_context(capsnap->context); 4921d3576fdSSage Weil if (snap_size) 4931d3576fdSSage Weil *snap_size = capsnap->size; 4945f743e45SYan, Zheng if (truncate_size) 4955f743e45SYan, Zheng *truncate_size = capsnap->truncate_size; 4965f743e45SYan, Zheng if (truncate_seq) 4975f743e45SYan, Zheng *truncate_seq = capsnap->truncate_seq; 4981d3576fdSSage Weil break; 4991d3576fdSSage Weil } 5001d3576fdSSage Weil } 5017d8cb26dSSage Weil if (!snapc && ci->i_wrbuffer_ref_head) { 50280e755feSSage Weil snapc = ceph_get_snap_context(ci->i_head_snapc); 5031d3576fdSSage Weil dout(" head snapc %p has %d dirty pages\n", 5041d3576fdSSage Weil snapc, ci->i_wrbuffer_ref_head); 5055f743e45SYan, Zheng if (truncate_size) 50684fcc2d2SGeng, Jichao *truncate_size = ci->i_truncate_size; 5075f743e45SYan, Zheng if (truncate_seq) 50884fcc2d2SGeng, Jichao *truncate_seq = ci->i_truncate_seq; 5091d3576fdSSage Weil } 510be655596SSage Weil spin_unlock(&ci->i_ceph_lock); 5111d3576fdSSage Weil return snapc; 5121d3576fdSSage Weil } 5131d3576fdSSage Weil 5141d3576fdSSage Weil /* 5151d3576fdSSage Weil * Write a single page, but leave the page locked. 5161d3576fdSSage Weil * 5171d3576fdSSage Weil * If we get a write error, set the page error bit, but still adjust the 5181d3576fdSSage Weil * dirty page accounting (i.e., page is no longer dirty). 5191d3576fdSSage Weil */ 5201d3576fdSSage Weil static int writepage_nounlock(struct page *page, struct writeback_control *wbc) 5211d3576fdSSage Weil { 5221d3576fdSSage Weil struct inode *inode; 5231d3576fdSSage Weil struct ceph_inode_info *ci; 5243d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc; 5251d3576fdSSage Weil struct ceph_osd_client *osdc; 5266298a337SSage Weil struct ceph_snap_context *snapc, *oldest; 527fc2744aaSYan, Zheng loff_t page_off = page_offset(page); 528e1966b49SYan, Zheng loff_t snap_size = -1; 5292baba250SYehuda Sadeh long writeback_stat; 530e1966b49SYan, Zheng u64 truncate_size; 531fc2744aaSYan, Zheng u32 truncate_seq; 53243986881SYan, Zheng int err, len = PAGE_SIZE; 5331d3576fdSSage Weil 5341d3576fdSSage Weil dout("writepage %p idx %lu\n", page, page->index); 5351d3576fdSSage Weil 5361d3576fdSSage Weil inode = page->mapping->host; 5371d3576fdSSage Weil ci = ceph_inode(inode); 5383d14c5d2SYehuda Sadeh fsc = ceph_inode_to_client(inode); 5393d14c5d2SYehuda Sadeh osdc = &fsc->client->osdc; 5401d3576fdSSage Weil 5411d3576fdSSage Weil /* verify this is a writeable snap context */ 54261600ef8SYan, Zheng snapc = page_snap_context(page); 5431d3576fdSSage Weil if (snapc == NULL) { 5441d3576fdSSage Weil dout("writepage %p page %p not dirty?\n", inode, page); 54543986881SYan, Zheng return 0; 5461d3576fdSSage Weil } 5475f743e45SYan, Zheng oldest = get_oldest_context(inode, &snap_size, 5485f743e45SYan, Zheng &truncate_size, &truncate_seq); 5496298a337SSage Weil if (snapc->seq > oldest->seq) { 5501d3576fdSSage Weil dout("writepage %p page %p snapc %p not writeable - noop\n", 55161600ef8SYan, Zheng inode, page, snapc); 5521d3576fdSSage Weil /* we should only noop if called by kswapd */ 553fa71fefbSYan, Zheng WARN_ON(!(current->flags & PF_MEMALLOC)); 5546298a337SSage Weil ceph_put_snap_context(oldest); 555fa71fefbSYan, Zheng redirty_page_for_writepage(wbc, page); 55643986881SYan, Zheng return 0; 5571d3576fdSSage Weil } 5586298a337SSage Weil ceph_put_snap_context(oldest); 5591d3576fdSSage Weil 560e1966b49SYan, Zheng if (snap_size == -1) 561fc2744aaSYan, Zheng snap_size = i_size_read(inode); 562fc2744aaSYan, Zheng 5631d3576fdSSage Weil /* is this a partial page at end of file? */ 564fc2744aaSYan, Zheng if (page_off >= snap_size) { 565fc2744aaSYan, Zheng dout("%p page eof %llu\n", page, snap_size); 56643986881SYan, Zheng return 0; 567fc2744aaSYan, Zheng } 56843986881SYan, Zheng 569fc2744aaSYan, Zheng if (snap_size < page_off + len) 570fc2744aaSYan, Zheng len = snap_size - page_off; 5711d3576fdSSage Weil 572ae00d4f3SSage Weil dout("writepage %p page %p index %lu on %llu~%u snapc %p\n", 573ae00d4f3SSage Weil inode, page, page->index, page_off, len, snapc); 5741d3576fdSSage Weil 5753d14c5d2SYehuda Sadeh writeback_stat = atomic_long_inc_return(&fsc->writeback_count); 5762baba250SYehuda Sadeh if (writeback_stat > 5773d14c5d2SYehuda Sadeh CONGESTION_ON_THRESH(fsc->mount_options->congestion_kb)) 57809dc9fc2SJan Kara set_bdi_congested(inode_to_bdi(inode), BLK_RW_ASYNC); 5792baba250SYehuda Sadeh 5801d3576fdSSage Weil set_page_writeback(page); 5811d3576fdSSage Weil err = ceph_osdc_writepages(osdc, ceph_vino(inode), 5821d3576fdSSage Weil &ci->i_layout, snapc, 5831d3576fdSSage Weil page_off, len, 584fc2744aaSYan, Zheng truncate_seq, truncate_size, 58524808826SAlex Elder &inode->i_mtime, &page, 1); 5861d3576fdSSage Weil if (err < 0) { 587ad15ec06SYan, Zheng struct writeback_control tmp_wbc; 588ad15ec06SYan, Zheng if (!wbc) 589ad15ec06SYan, Zheng wbc = &tmp_wbc; 590ad15ec06SYan, Zheng if (err == -ERESTARTSYS) { 591ad15ec06SYan, Zheng /* killed by SIGKILL */ 592ad15ec06SYan, Zheng dout("writepage interrupted page %p\n", page); 593ad15ec06SYan, Zheng redirty_page_for_writepage(wbc, page); 594ad15ec06SYan, Zheng end_page_writeback(page); 59543986881SYan, Zheng return err; 596ad15ec06SYan, Zheng } 597ad15ec06SYan, Zheng dout("writepage setting page/mapping error %d %p\n", 598ad15ec06SYan, Zheng err, page); 5991d3576fdSSage Weil SetPageError(page); 6001d3576fdSSage Weil mapping_set_error(&inode->i_data, err); 6011d3576fdSSage Weil wbc->pages_skipped++; 6021d3576fdSSage Weil } else { 6031d3576fdSSage Weil dout("writepage cleaned page %p\n", page); 6041d3576fdSSage Weil err = 0; /* vfs expects us to return 0 */ 6051d3576fdSSage Weil } 6061d3576fdSSage Weil page->private = 0; 6071d3576fdSSage Weil ClearPagePrivate(page); 6081d3576fdSSage Weil end_page_writeback(page); 6091d3576fdSSage Weil ceph_put_wrbuffer_cap_refs(ci, 1, snapc); 6106298a337SSage Weil ceph_put_snap_context(snapc); /* page's reference */ 6111d3576fdSSage Weil return err; 6121d3576fdSSage Weil } 6131d3576fdSSage Weil 6141d3576fdSSage Weil static int ceph_writepage(struct page *page, struct writeback_control *wbc) 6151d3576fdSSage Weil { 616dbd646a8SYehuda Sadeh int err; 617dbd646a8SYehuda Sadeh struct inode *inode = page->mapping->host; 618dbd646a8SYehuda Sadeh BUG_ON(!inode); 61970b666c3SSage Weil ihold(inode); 620dbd646a8SYehuda Sadeh err = writepage_nounlock(page, wbc); 621ad15ec06SYan, Zheng if (err == -ERESTARTSYS) { 622ad15ec06SYan, Zheng /* direct memory reclaimer was killed by SIGKILL. return 0 623ad15ec06SYan, Zheng * to prevent caller from setting mapping/page error */ 624ad15ec06SYan, Zheng err = 0; 625ad15ec06SYan, Zheng } 6261d3576fdSSage Weil unlock_page(page); 627dbd646a8SYehuda Sadeh iput(inode); 6281d3576fdSSage Weil return err; 6291d3576fdSSage Weil } 6301d3576fdSSage Weil 6311d3576fdSSage Weil /* 6321d3576fdSSage Weil * lame release_pages helper. release_pages() isn't exported to 6331d3576fdSSage Weil * modules. 6341d3576fdSSage Weil */ 6351d3576fdSSage Weil static void ceph_release_pages(struct page **pages, int num) 6361d3576fdSSage Weil { 6371d3576fdSSage Weil struct pagevec pvec; 6381d3576fdSSage Weil int i; 6391d3576fdSSage Weil 6401d3576fdSSage Weil pagevec_init(&pvec, 0); 6411d3576fdSSage Weil for (i = 0; i < num; i++) { 6421d3576fdSSage Weil if (pagevec_add(&pvec, pages[i]) == 0) 6431d3576fdSSage Weil pagevec_release(&pvec); 6441d3576fdSSage Weil } 6451d3576fdSSage Weil pagevec_release(&pvec); 6461d3576fdSSage Weil } 6471d3576fdSSage Weil 6481d3576fdSSage Weil /* 6491d3576fdSSage Weil * async writeback completion handler. 6501d3576fdSSage Weil * 6511d3576fdSSage Weil * If we get an error, set the mapping error bit, but not the individual 6521d3576fdSSage Weil * page error bits. 6531d3576fdSSage Weil */ 65485e084feSIlya Dryomov static void writepages_finish(struct ceph_osd_request *req) 6551d3576fdSSage Weil { 6561d3576fdSSage Weil struct inode *inode = req->r_inode; 6571d3576fdSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 65887060c10SAlex Elder struct ceph_osd_data *osd_data; 6591d3576fdSSage Weil struct page *page; 6605b64640cSYan, Zheng int num_pages, total_pages = 0; 6615b64640cSYan, Zheng int i, j; 6625b64640cSYan, Zheng int rc = req->r_result; 6631d3576fdSSage Weil struct ceph_snap_context *snapc = req->r_snapc; 6641d3576fdSSage Weil struct address_space *mapping = inode->i_mapping; 6653d14c5d2SYehuda Sadeh struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 6665b64640cSYan, Zheng bool remove_page; 6671d3576fdSSage Weil 6685b64640cSYan, Zheng dout("writepages_finish %p rc %d\n", inode, rc); 66926544c62SJeff Layton if (rc < 0) { 6701d3576fdSSage Weil mapping_set_error(mapping, rc); 67126544c62SJeff Layton ceph_set_error_write(ci); 67226544c62SJeff Layton } else { 67326544c62SJeff Layton ceph_clear_error_write(ci); 67426544c62SJeff Layton } 675e63dc5c7SYehuda Sadeh 676e63dc5c7SYehuda Sadeh /* 677e63dc5c7SYehuda Sadeh * We lost the cache cap, need to truncate the page before 678e63dc5c7SYehuda Sadeh * it is unlocked, otherwise we'd truncate it later in the 679e63dc5c7SYehuda Sadeh * page truncation thread, possibly losing some data that 680e63dc5c7SYehuda Sadeh * raced its way in 681e63dc5c7SYehuda Sadeh */ 6825b64640cSYan, Zheng remove_page = !(ceph_caps_issued(ci) & 6835b64640cSYan, Zheng (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)); 6845b64640cSYan, Zheng 6855b64640cSYan, Zheng /* clean all pages */ 6865b64640cSYan, Zheng for (i = 0; i < req->r_num_ops; i++) { 6875b64640cSYan, Zheng if (req->r_ops[i].op != CEPH_OSD_OP_WRITE) 6885b64640cSYan, Zheng break; 6895b64640cSYan, Zheng 6905b64640cSYan, Zheng osd_data = osd_req_op_extent_osd_data(req, i); 6915b64640cSYan, Zheng BUG_ON(osd_data->type != CEPH_OSD_DATA_TYPE_PAGES); 6925b64640cSYan, Zheng num_pages = calc_pages_for((u64)osd_data->alignment, 6935b64640cSYan, Zheng (u64)osd_data->length); 6945b64640cSYan, Zheng total_pages += num_pages; 6955b64640cSYan, Zheng for (j = 0; j < num_pages; j++) { 6965b64640cSYan, Zheng page = osd_data->pages[j]; 6975b64640cSYan, Zheng BUG_ON(!page); 6985b64640cSYan, Zheng WARN_ON(!PageUptodate(page)); 6995b64640cSYan, Zheng 7005b64640cSYan, Zheng if (atomic_long_dec_return(&fsc->writeback_count) < 7015b64640cSYan, Zheng CONGESTION_OFF_THRESH( 7025b64640cSYan, Zheng fsc->mount_options->congestion_kb)) 70309dc9fc2SJan Kara clear_bdi_congested(inode_to_bdi(inode), 7045b64640cSYan, Zheng BLK_RW_ASYNC); 7055b64640cSYan, Zheng 7065b64640cSYan, Zheng ceph_put_snap_context(page_snap_context(page)); 7075b64640cSYan, Zheng page->private = 0; 7085b64640cSYan, Zheng ClearPagePrivate(page); 7095b64640cSYan, Zheng dout("unlocking %p\n", page); 7105b64640cSYan, Zheng end_page_writeback(page); 7115b64640cSYan, Zheng 7125b64640cSYan, Zheng if (remove_page) 7135b64640cSYan, Zheng generic_error_remove_page(inode->i_mapping, 7145b64640cSYan, Zheng page); 715e63dc5c7SYehuda Sadeh 7161d3576fdSSage Weil unlock_page(page); 7171d3576fdSSage Weil } 7185b64640cSYan, Zheng dout("writepages_finish %p wrote %llu bytes cleaned %d pages\n", 7195b64640cSYan, Zheng inode, osd_data->length, rc >= 0 ? num_pages : 0); 7201d3576fdSSage Weil 72187060c10SAlex Elder ceph_release_pages(osd_data->pages, num_pages); 7225b64640cSYan, Zheng } 7235b64640cSYan, Zheng 7245b64640cSYan, Zheng ceph_put_wrbuffer_cap_refs(ci, total_pages, snapc); 7255b64640cSYan, Zheng 7265b64640cSYan, Zheng osd_data = osd_req_op_extent_osd_data(req, 0); 72787060c10SAlex Elder if (osd_data->pages_from_pool) 72887060c10SAlex Elder mempool_free(osd_data->pages, 729640ef79dSCheng Renquan ceph_sb_to_client(inode->i_sb)->wb_pagevec_pool); 7301d3576fdSSage Weil else 73187060c10SAlex Elder kfree(osd_data->pages); 7321d3576fdSSage Weil ceph_osdc_put_request(req); 7331d3576fdSSage Weil } 7341d3576fdSSage Weil 7351d3576fdSSage Weil /* 7361d3576fdSSage Weil * initiate async writeback 7371d3576fdSSage Weil */ 7381d3576fdSSage Weil static int ceph_writepages_start(struct address_space *mapping, 7391d3576fdSSage Weil struct writeback_control *wbc) 7401d3576fdSSage Weil { 7411d3576fdSSage Weil struct inode *inode = mapping->host; 7421d3576fdSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 743fc2744aaSYan, Zheng struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 744fc2744aaSYan, Zheng struct ceph_vino vino = ceph_vino(inode); 7451d3576fdSSage Weil pgoff_t index, start, end; 7461d3576fdSSage Weil int range_whole = 0; 7471d3576fdSSage Weil int should_loop = 1; 7481d3576fdSSage Weil pgoff_t max_pages = 0, max_pages_ever = 0; 74980e755feSSage Weil struct ceph_snap_context *snapc = NULL, *last_snapc = NULL, *pgsnapc; 7501d3576fdSSage Weil struct pagevec pvec; 7511d3576fdSSage Weil int done = 0; 7521d3576fdSSage Weil int rc = 0; 75393407472SFabian Frederick unsigned int wsize = i_blocksize(inode); 7541d3576fdSSage Weil struct ceph_osd_request *req = NULL; 755e1966b49SYan, Zheng loff_t snap_size, i_size; 756e1966b49SYan, Zheng u64 truncate_size; 757fc2744aaSYan, Zheng u32 truncate_seq; 7581d3576fdSSage Weil 7593fb99d48SYanhu Cao dout("writepages_start %p (mode=%s)\n", inode, 7601d3576fdSSage Weil wbc->sync_mode == WB_SYNC_NONE ? "NONE" : 7611d3576fdSSage Weil (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD")); 7621d3576fdSSage Weil 76352953d55SSeraphime Kirkovski if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) { 7646c93df5dSYan, Zheng if (ci->i_wrbuffer_ref > 0) { 7656c93df5dSYan, Zheng pr_warn_ratelimited( 7666c93df5dSYan, Zheng "writepage_start %p %lld forced umount\n", 7676c93df5dSYan, Zheng inode, ceph_ino(inode)); 7686c93df5dSYan, Zheng } 769a341d4dfSYan, Zheng mapping_set_error(mapping, -EIO); 7701d3576fdSSage Weil return -EIO; /* we're in a forced umount, don't write! */ 7711d3576fdSSage Weil } 77295cca2b4SYan, Zheng if (fsc->mount_options->wsize < wsize) 7733d14c5d2SYehuda Sadeh wsize = fsc->mount_options->wsize; 77409cbfeafSKirill A. Shutemov max_pages_ever = wsize >> PAGE_SHIFT; 7751d3576fdSSage Weil 7761d3576fdSSage Weil pagevec_init(&pvec, 0); 7771d3576fdSSage Weil 7781d3576fdSSage Weil /* where to start/end? */ 7791d3576fdSSage Weil if (wbc->range_cyclic) { 7801d3576fdSSage Weil start = mapping->writeback_index; /* Start from prev offset */ 7811d3576fdSSage Weil end = -1; 7821d3576fdSSage Weil dout(" cyclic, start at %lu\n", start); 7831d3576fdSSage Weil } else { 78409cbfeafSKirill A. Shutemov start = wbc->range_start >> PAGE_SHIFT; 78509cbfeafSKirill A. Shutemov end = wbc->range_end >> PAGE_SHIFT; 7861d3576fdSSage Weil if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) 7871d3576fdSSage Weil range_whole = 1; 7881d3576fdSSage Weil should_loop = 0; 7891d3576fdSSage Weil dout(" not cyclic, %lu to %lu\n", start, end); 7901d3576fdSSage Weil } 7911d3576fdSSage Weil index = start; 7921d3576fdSSage Weil 7931d3576fdSSage Weil retry: 7941d3576fdSSage Weil /* find oldest snap context with dirty data */ 7951d3576fdSSage Weil ceph_put_snap_context(snapc); 796e1966b49SYan, Zheng snap_size = -1; 7975f743e45SYan, Zheng snapc = get_oldest_context(inode, &snap_size, 7985f743e45SYan, Zheng &truncate_size, &truncate_seq); 7991d3576fdSSage Weil if (!snapc) { 8001d3576fdSSage Weil /* hmm, why does writepages get called when there 8011d3576fdSSage Weil is no dirty data? */ 8021d3576fdSSage Weil dout(" no snap context with dirty data?\n"); 8031d3576fdSSage Weil goto out; 8041d3576fdSSage Weil } 8051d3576fdSSage Weil dout(" oldest snapc is %p seq %lld (%d snaps)\n", 8061d3576fdSSage Weil snapc, snapc->seq, snapc->num_snaps); 807fc2744aaSYan, Zheng 808e1966b49SYan, Zheng i_size = i_size_read(inode); 809fc2744aaSYan, Zheng 8101d3576fdSSage Weil if (last_snapc && snapc != last_snapc) { 8111d3576fdSSage Weil /* if we switched to a newer snapc, restart our scan at the 8121d3576fdSSage Weil * start of the original file range. */ 8131d3576fdSSage Weil dout(" snapc differs from last pass, restarting at %lu\n", 8141d3576fdSSage Weil index); 8151d3576fdSSage Weil index = start; 8161d3576fdSSage Weil } 8171d3576fdSSage Weil last_snapc = snapc; 8181d3576fdSSage Weil 8191d3576fdSSage Weil while (!done && index <= end) { 8201d3576fdSSage Weil unsigned i; 8211d3576fdSSage Weil int first; 8225b64640cSYan, Zheng pgoff_t strip_unit_end = 0; 8235b64640cSYan, Zheng int num_ops = 0, op_idx; 8245b64640cSYan, Zheng int pvec_pages, locked_pages = 0; 8255b64640cSYan, Zheng struct page **pages = NULL, **data_pages; 826e5975c7cSAlex Elder mempool_t *pool = NULL; /* Becomes non-null if mempool used */ 8271d3576fdSSage Weil struct page *page; 8281d3576fdSSage Weil int want; 8295b64640cSYan, Zheng u64 offset = 0, len = 0; 8301d3576fdSSage Weil 8311d3576fdSSage Weil max_pages = max_pages_ever; 8321d3576fdSSage Weil 8331d3576fdSSage Weil get_more_pages: 8341d3576fdSSage Weil first = -1; 8351d3576fdSSage Weil want = min(end - index, 8361d3576fdSSage Weil min((pgoff_t)PAGEVEC_SIZE, 8371d3576fdSSage Weil max_pages - (pgoff_t)locked_pages) - 1) 8381d3576fdSSage Weil + 1; 8391d3576fdSSage Weil pvec_pages = pagevec_lookup_tag(&pvec, mapping, &index, 8401d3576fdSSage Weil PAGECACHE_TAG_DIRTY, 8411d3576fdSSage Weil want); 8421d3576fdSSage Weil dout("pagevec_lookup_tag got %d\n", pvec_pages); 8431d3576fdSSage Weil if (!pvec_pages && !locked_pages) 8441d3576fdSSage Weil break; 8451d3576fdSSage Weil for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) { 8461d3576fdSSage Weil page = pvec.pages[i]; 8471d3576fdSSage Weil dout("? %p idx %lu\n", page, page->index); 8481d3576fdSSage Weil if (locked_pages == 0) 8491d3576fdSSage Weil lock_page(page); /* first page */ 8501d3576fdSSage Weil else if (!trylock_page(page)) 8511d3576fdSSage Weil break; 8521d3576fdSSage Weil 8531d3576fdSSage Weil /* only dirty pages, or our accounting breaks */ 8541d3576fdSSage Weil if (unlikely(!PageDirty(page)) || 8551d3576fdSSage Weil unlikely(page->mapping != mapping)) { 8561d3576fdSSage Weil dout("!dirty or !mapping %p\n", page); 8571d3576fdSSage Weil unlock_page(page); 8581d3576fdSSage Weil break; 8591d3576fdSSage Weil } 8601d3576fdSSage Weil if (!wbc->range_cyclic && page->index > end) { 8611d3576fdSSage Weil dout("end of range %p\n", page); 8621d3576fdSSage Weil done = 1; 8631d3576fdSSage Weil unlock_page(page); 8641d3576fdSSage Weil break; 8651d3576fdSSage Weil } 8665b64640cSYan, Zheng if (strip_unit_end && (page->index > strip_unit_end)) { 8675b64640cSYan, Zheng dout("end of strip unit %p\n", page); 8681d3576fdSSage Weil unlock_page(page); 8691d3576fdSSage Weil break; 8701d3576fdSSage Weil } 8711d3576fdSSage Weil if (wbc->sync_mode != WB_SYNC_NONE) { 8721d3576fdSSage Weil dout("waiting on writeback %p\n", page); 8731d3576fdSSage Weil wait_on_page_writeback(page); 8741d3576fdSSage Weil } 875e1966b49SYan, Zheng if (page_offset(page) >= 876e1966b49SYan, Zheng (snap_size == -1 ? i_size : snap_size)) { 877e1966b49SYan, Zheng dout("%p page eof %llu\n", page, 878e1966b49SYan, Zheng (snap_size == -1 ? i_size : snap_size)); 8791d3576fdSSage Weil done = 1; 8801d3576fdSSage Weil unlock_page(page); 8811d3576fdSSage Weil break; 8821d3576fdSSage Weil } 8831d3576fdSSage Weil if (PageWriteback(page)) { 8841d3576fdSSage Weil dout("%p under writeback\n", page); 8851d3576fdSSage Weil unlock_page(page); 8861d3576fdSSage Weil break; 8871d3576fdSSage Weil } 8881d3576fdSSage Weil 8891d3576fdSSage Weil /* only if matching snap context */ 89061600ef8SYan, Zheng pgsnapc = page_snap_context(page); 89180e755feSSage Weil if (pgsnapc->seq > snapc->seq) { 89280e755feSSage Weil dout("page snapc %p %lld > oldest %p %lld\n", 89380e755feSSage Weil pgsnapc, pgsnapc->seq, snapc, snapc->seq); 8941d3576fdSSage Weil unlock_page(page); 8951d3576fdSSage Weil if (!locked_pages) 8961d3576fdSSage Weil continue; /* keep looking for snap */ 8971d3576fdSSage Weil break; 8981d3576fdSSage Weil } 8991d3576fdSSage Weil 9001d3576fdSSage Weil if (!clear_page_dirty_for_io(page)) { 9011d3576fdSSage Weil dout("%p !clear_page_dirty_for_io\n", page); 9021d3576fdSSage Weil unlock_page(page); 9031d3576fdSSage Weil break; 9041d3576fdSSage Weil } 9051d3576fdSSage Weil 906e5975c7cSAlex Elder /* 907e5975c7cSAlex Elder * We have something to write. If this is 908e5975c7cSAlex Elder * the first locked page this time through, 9095b64640cSYan, Zheng * calculate max possinle write size and 9105b64640cSYan, Zheng * allocate a page array 911e5975c7cSAlex Elder */ 9121d3576fdSSage Weil if (locked_pages == 0) { 9135b64640cSYan, Zheng u64 objnum; 9145b64640cSYan, Zheng u64 objoff; 9155b64640cSYan, Zheng 9161d3576fdSSage Weil /* prepare async write request */ 9176285bc23SAlex Elder offset = (u64)page_offset(page); 9181d3576fdSSage Weil len = wsize; 9195b64640cSYan, Zheng 9205b64640cSYan, Zheng rc = ceph_calc_file_object_mapping(&ci->i_layout, 9215b64640cSYan, Zheng offset, len, 9225b64640cSYan, Zheng &objnum, &objoff, 9235b64640cSYan, Zheng &len); 9245b64640cSYan, Zheng if (rc < 0) { 9258c71897bSHenry C Chang unlock_page(page); 9268c71897bSHenry C Chang break; 9278c71897bSHenry C Chang } 9288c71897bSHenry C Chang 9293fb99d48SYanhu Cao num_ops = 1; 9305b64640cSYan, Zheng strip_unit_end = page->index + 93109cbfeafSKirill A. Shutemov ((len - 1) >> PAGE_SHIFT); 932715e4cd4SYan, Zheng 9335b64640cSYan, Zheng BUG_ON(pages); 93488486957SAlex Elder max_pages = calc_pages_for(0, (u64)len); 935fc2744aaSYan, Zheng pages = kmalloc(max_pages * sizeof (*pages), 936fc2744aaSYan, Zheng GFP_NOFS); 93788486957SAlex Elder if (!pages) { 93888486957SAlex Elder pool = fsc->wb_pagevec_pool; 93988486957SAlex Elder pages = mempool_alloc(pool, GFP_NOFS); 940e5975c7cSAlex Elder BUG_ON(!pages); 94188486957SAlex Elder } 9425b64640cSYan, Zheng 9435b64640cSYan, Zheng len = 0; 9445b64640cSYan, Zheng } else if (page->index != 94509cbfeafSKirill A. Shutemov (offset + len) >> PAGE_SHIFT) { 9465b64640cSYan, Zheng if (num_ops >= (pool ? CEPH_OSD_SLAB_OPS : 9475b64640cSYan, Zheng CEPH_OSD_MAX_OPS)) { 9485b64640cSYan, Zheng redirty_page_for_writepage(wbc, page); 9495b64640cSYan, Zheng unlock_page(page); 9505b64640cSYan, Zheng break; 9515b64640cSYan, Zheng } 9525b64640cSYan, Zheng 9535b64640cSYan, Zheng num_ops++; 9545b64640cSYan, Zheng offset = (u64)page_offset(page); 9555b64640cSYan, Zheng len = 0; 9561d3576fdSSage Weil } 9571d3576fdSSage Weil 9581d3576fdSSage Weil /* note position of first page in pvec */ 9591d3576fdSSage Weil if (first < 0) 9601d3576fdSSage Weil first = i; 9611d3576fdSSage Weil dout("%p will write page %p idx %lu\n", 9621d3576fdSSage Weil inode, page, page->index); 9632baba250SYehuda Sadeh 9645b64640cSYan, Zheng if (atomic_long_inc_return(&fsc->writeback_count) > 9655b64640cSYan, Zheng CONGESTION_ON_THRESH( 9663d14c5d2SYehuda Sadeh fsc->mount_options->congestion_kb)) { 96709dc9fc2SJan Kara set_bdi_congested(inode_to_bdi(inode), 968213c99eeSSage Weil BLK_RW_ASYNC); 9692baba250SYehuda Sadeh } 9702baba250SYehuda Sadeh 971e5975c7cSAlex Elder pages[locked_pages] = page; 9721d3576fdSSage Weil locked_pages++; 97309cbfeafSKirill A. Shutemov len += PAGE_SIZE; 9741d3576fdSSage Weil } 9751d3576fdSSage Weil 9761d3576fdSSage Weil /* did we get anything? */ 9771d3576fdSSage Weil if (!locked_pages) 9781d3576fdSSage Weil goto release_pvec_pages; 9791d3576fdSSage Weil if (i) { 9801d3576fdSSage Weil int j; 9811d3576fdSSage Weil BUG_ON(!locked_pages || first < 0); 9821d3576fdSSage Weil 9831d3576fdSSage Weil if (pvec_pages && i == pvec_pages && 9841d3576fdSSage Weil locked_pages < max_pages) { 9851d3576fdSSage Weil dout("reached end pvec, trying for more\n"); 9861d3576fdSSage Weil pagevec_reinit(&pvec); 9871d3576fdSSage Weil goto get_more_pages; 9881d3576fdSSage Weil } 9891d3576fdSSage Weil 9901d3576fdSSage Weil /* shift unused pages over in the pvec... we 9911d3576fdSSage Weil * will need to release them below. */ 9921d3576fdSSage Weil for (j = i; j < pvec_pages; j++) { 9935b64640cSYan, Zheng dout(" pvec leftover page %p\n", pvec.pages[j]); 9941d3576fdSSage Weil pvec.pages[j-i+first] = pvec.pages[j]; 9951d3576fdSSage Weil } 9961d3576fdSSage Weil pvec.nr -= i-first; 9971d3576fdSSage Weil } 9981d3576fdSSage Weil 9995b64640cSYan, Zheng new_request: 1000e5975c7cSAlex Elder offset = page_offset(pages[0]); 10015b64640cSYan, Zheng len = wsize; 10025b64640cSYan, Zheng 10035b64640cSYan, Zheng req = ceph_osdc_new_request(&fsc->client->osdc, 10045b64640cSYan, Zheng &ci->i_layout, vino, 10055b64640cSYan, Zheng offset, &len, 0, num_ops, 10065b64640cSYan, Zheng CEPH_OSD_OP_WRITE, 100754ea0046SIlya Dryomov CEPH_OSD_FLAG_WRITE, 10085b64640cSYan, Zheng snapc, truncate_seq, 10095b64640cSYan, Zheng truncate_size, false); 10105b64640cSYan, Zheng if (IS_ERR(req)) { 10115b64640cSYan, Zheng req = ceph_osdc_new_request(&fsc->client->osdc, 10125b64640cSYan, Zheng &ci->i_layout, vino, 10135b64640cSYan, Zheng offset, &len, 0, 10145b64640cSYan, Zheng min(num_ops, 10155b64640cSYan, Zheng CEPH_OSD_SLAB_OPS), 10165b64640cSYan, Zheng CEPH_OSD_OP_WRITE, 101754ea0046SIlya Dryomov CEPH_OSD_FLAG_WRITE, 10185b64640cSYan, Zheng snapc, truncate_seq, 10195b64640cSYan, Zheng truncate_size, true); 10205b64640cSYan, Zheng BUG_ON(IS_ERR(req)); 10215b64640cSYan, Zheng } 10225b64640cSYan, Zheng BUG_ON(len < page_offset(pages[locked_pages - 1]) + 102309cbfeafSKirill A. Shutemov PAGE_SIZE - offset); 10245b64640cSYan, Zheng 10255b64640cSYan, Zheng req->r_callback = writepages_finish; 10265b64640cSYan, Zheng req->r_inode = inode; 10275b64640cSYan, Zheng 10285b64640cSYan, Zheng /* Format the osd request message and submit the write */ 10295b64640cSYan, Zheng len = 0; 10305b64640cSYan, Zheng data_pages = pages; 10315b64640cSYan, Zheng op_idx = 0; 10325b64640cSYan, Zheng for (i = 0; i < locked_pages; i++) { 10335b64640cSYan, Zheng u64 cur_offset = page_offset(pages[i]); 10345b64640cSYan, Zheng if (offset + len != cur_offset) { 10353fb99d48SYanhu Cao if (op_idx + 1 == req->r_num_ops) 10365b64640cSYan, Zheng break; 10375b64640cSYan, Zheng osd_req_op_extent_dup_last(req, op_idx, 10385b64640cSYan, Zheng cur_offset - offset); 10395b64640cSYan, Zheng dout("writepages got pages at %llu~%llu\n", 10405b64640cSYan, Zheng offset, len); 10415b64640cSYan, Zheng osd_req_op_extent_osd_data_pages(req, op_idx, 10425b64640cSYan, Zheng data_pages, len, 0, 10435b64640cSYan, Zheng !!pool, false); 10445b64640cSYan, Zheng osd_req_op_extent_update(req, op_idx, len); 10455b64640cSYan, Zheng 10465b64640cSYan, Zheng len = 0; 10475b64640cSYan, Zheng offset = cur_offset; 10485b64640cSYan, Zheng data_pages = pages + i; 10495b64640cSYan, Zheng op_idx++; 10505b64640cSYan, Zheng } 10515b64640cSYan, Zheng 10525b64640cSYan, Zheng set_page_writeback(pages[i]); 105309cbfeafSKirill A. Shutemov len += PAGE_SIZE; 10545b64640cSYan, Zheng } 10555b64640cSYan, Zheng 10565b64640cSYan, Zheng if (snap_size != -1) { 10575b64640cSYan, Zheng len = min(len, snap_size - offset); 10585b64640cSYan, Zheng } else if (i == locked_pages) { 1059e1966b49SYan, Zheng /* writepages_finish() clears writeback pages 1060e1966b49SYan, Zheng * according to the data length, so make sure 1061e1966b49SYan, Zheng * data length covers all locked pages */ 106209cbfeafSKirill A. Shutemov u64 min_len = len + 1 - PAGE_SIZE; 10635b64640cSYan, Zheng len = min(len, (u64)i_size_read(inode) - offset); 10645b64640cSYan, Zheng len = max(len, min_len); 1065e1966b49SYan, Zheng } 10665b64640cSYan, Zheng dout("writepages got pages at %llu~%llu\n", offset, len); 10671d3576fdSSage Weil 10685b64640cSYan, Zheng osd_req_op_extent_osd_data_pages(req, op_idx, data_pages, len, 10695b64640cSYan, Zheng 0, !!pool, false); 10705b64640cSYan, Zheng osd_req_op_extent_update(req, op_idx, len); 1071e5975c7cSAlex Elder 10725b64640cSYan, Zheng BUG_ON(op_idx + 1 != req->r_num_ops); 10735b64640cSYan, Zheng 1074e5975c7cSAlex Elder pool = NULL; 10755b64640cSYan, Zheng if (i < locked_pages) { 10765b64640cSYan, Zheng BUG_ON(num_ops <= req->r_num_ops); 10775b64640cSYan, Zheng num_ops -= req->r_num_ops; 10785b64640cSYan, Zheng locked_pages -= i; 1079e5975c7cSAlex Elder 10805b64640cSYan, Zheng /* allocate new pages array for next request */ 10815b64640cSYan, Zheng data_pages = pages; 10825b64640cSYan, Zheng pages = kmalloc(locked_pages * sizeof (*pages), 10835b64640cSYan, Zheng GFP_NOFS); 10845b64640cSYan, Zheng if (!pages) { 10855b64640cSYan, Zheng pool = fsc->wb_pagevec_pool; 10865b64640cSYan, Zheng pages = mempool_alloc(pool, GFP_NOFS); 10875b64640cSYan, Zheng BUG_ON(!pages); 10885b64640cSYan, Zheng } 10895b64640cSYan, Zheng memcpy(pages, data_pages + i, 10905b64640cSYan, Zheng locked_pages * sizeof(*pages)); 10915b64640cSYan, Zheng memset(data_pages + i, 0, 10925b64640cSYan, Zheng locked_pages * sizeof(*pages)); 10935b64640cSYan, Zheng } else { 10945b64640cSYan, Zheng BUG_ON(num_ops != req->r_num_ops); 10955b64640cSYan, Zheng index = pages[i - 1]->index + 1; 10965b64640cSYan, Zheng /* request message now owns the pages array */ 10975b64640cSYan, Zheng pages = NULL; 10985b64640cSYan, Zheng } 1099e5975c7cSAlex Elder 1100bb873b53SIlya Dryomov req->r_mtime = inode->i_mtime; 11019d6fcb08SSage Weil rc = ceph_osdc_start_request(&fsc->client->osdc, req, true); 11029d6fcb08SSage Weil BUG_ON(rc); 11031d3576fdSSage Weil req = NULL; 11041d3576fdSSage Weil 11055b64640cSYan, Zheng wbc->nr_to_write -= i; 11065b64640cSYan, Zheng if (pages) 11075b64640cSYan, Zheng goto new_request; 11085b64640cSYan, Zheng 11091d3576fdSSage Weil if (wbc->nr_to_write <= 0) 11101d3576fdSSage Weil done = 1; 11111d3576fdSSage Weil 11121d3576fdSSage Weil release_pvec_pages: 11131d3576fdSSage Weil dout("pagevec_release on %d pages (%p)\n", (int)pvec.nr, 11141d3576fdSSage Weil pvec.nr ? pvec.pages[0] : NULL); 11151d3576fdSSage Weil pagevec_release(&pvec); 11161d3576fdSSage Weil 11171d3576fdSSage Weil if (locked_pages && !done) 11181d3576fdSSage Weil goto retry; 11191d3576fdSSage Weil } 11201d3576fdSSage Weil 11211d3576fdSSage Weil if (should_loop && !done) { 11221d3576fdSSage Weil /* more to do; loop back to beginning of file */ 11231d3576fdSSage Weil dout("writepages looping back to beginning of file\n"); 11241d3576fdSSage Weil should_loop = 0; 11251d3576fdSSage Weil index = 0; 11261d3576fdSSage Weil goto retry; 11271d3576fdSSage Weil } 11281d3576fdSSage Weil 11291d3576fdSSage Weil if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) 11301d3576fdSSage Weil mapping->writeback_index = index; 11311d3576fdSSage Weil 11321d3576fdSSage Weil out: 11331d3576fdSSage Weil ceph_osdc_put_request(req); 11341d3576fdSSage Weil ceph_put_snap_context(snapc); 11351d3576fdSSage Weil dout("writepages done, rc = %d\n", rc); 11361d3576fdSSage Weil return rc; 11371d3576fdSSage Weil } 11381d3576fdSSage Weil 11391d3576fdSSage Weil 11401d3576fdSSage Weil 11411d3576fdSSage Weil /* 11421d3576fdSSage Weil * See if a given @snapc is either writeable, or already written. 11431d3576fdSSage Weil */ 11441d3576fdSSage Weil static int context_is_writeable_or_written(struct inode *inode, 11451d3576fdSSage Weil struct ceph_snap_context *snapc) 11461d3576fdSSage Weil { 11475f743e45SYan, Zheng struct ceph_snap_context *oldest = get_oldest_context(inode, NULL, 11485f743e45SYan, Zheng NULL, NULL); 11496298a337SSage Weil int ret = !oldest || snapc->seq <= oldest->seq; 11506298a337SSage Weil 11516298a337SSage Weil ceph_put_snap_context(oldest); 11526298a337SSage Weil return ret; 11531d3576fdSSage Weil } 11541d3576fdSSage Weil 11551d3576fdSSage Weil /* 11561d3576fdSSage Weil * We are only allowed to write into/dirty the page if the page is 11571d3576fdSSage Weil * clean, or already dirty within the same snap context. 11588f883c24SSage Weil * 11598f883c24SSage Weil * called with page locked. 11608f883c24SSage Weil * return success with page locked, 11618f883c24SSage Weil * or any failure (incl -EAGAIN) with page unlocked. 11621d3576fdSSage Weil */ 11634af6b225SYehuda Sadeh static int ceph_update_writeable_page(struct file *file, 11644af6b225SYehuda Sadeh loff_t pos, unsigned len, 11654af6b225SYehuda Sadeh struct page *page) 11661d3576fdSSage Weil { 1167496ad9aaSAl Viro struct inode *inode = file_inode(file); 11686c93df5dSYan, Zheng struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 11691d3576fdSSage Weil struct ceph_inode_info *ci = ceph_inode(inode); 117009cbfeafSKirill A. Shutemov loff_t page_off = pos & PAGE_MASK; 117109cbfeafSKirill A. Shutemov int pos_in_page = pos & ~PAGE_MASK; 11721d3576fdSSage Weil int end_in_page = pos_in_page + len; 11731d3576fdSSage Weil loff_t i_size; 11741d3576fdSSage Weil int r; 117580e755feSSage Weil struct ceph_snap_context *snapc, *oldest; 11761d3576fdSSage Weil 117752953d55SSeraphime Kirkovski if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) { 11786c93df5dSYan, Zheng dout(" page %p forced umount\n", page); 11796c93df5dSYan, Zheng unlock_page(page); 11806c93df5dSYan, Zheng return -EIO; 11816c93df5dSYan, Zheng } 11826c93df5dSYan, Zheng 11831d3576fdSSage Weil retry_locked: 11841d3576fdSSage Weil /* writepages currently holds page lock, but if we change that later, */ 11851d3576fdSSage Weil wait_on_page_writeback(page); 11861d3576fdSSage Weil 118761600ef8SYan, Zheng snapc = page_snap_context(page); 118880e755feSSage Weil if (snapc && snapc != ci->i_head_snapc) { 11891d3576fdSSage Weil /* 11901d3576fdSSage Weil * this page is already dirty in another (older) snap 11911d3576fdSSage Weil * context! is it writeable now? 11921d3576fdSSage Weil */ 11935f743e45SYan, Zheng oldest = get_oldest_context(inode, NULL, NULL, NULL); 11941d3576fdSSage Weil 119580e755feSSage Weil if (snapc->seq > oldest->seq) { 11966298a337SSage Weil ceph_put_snap_context(oldest); 11971d3576fdSSage Weil dout(" page %p snapc %p not current or oldest\n", 11986298a337SSage Weil page, snapc); 11991d3576fdSSage Weil /* 12001d3576fdSSage Weil * queue for writeback, and wait for snapc to 12011d3576fdSSage Weil * be writeable or written 12021d3576fdSSage Weil */ 12036298a337SSage Weil snapc = ceph_get_snap_context(snapc); 12041d3576fdSSage Weil unlock_page(page); 12053c6f6b79SSage Weil ceph_queue_writeback(inode); 1206a78bbd4bSYan, Zheng r = wait_event_killable(ci->i_cap_wq, 12071d3576fdSSage Weil context_is_writeable_or_written(inode, snapc)); 12081d3576fdSSage Weil ceph_put_snap_context(snapc); 12098f883c24SSage Weil if (r == -ERESTARTSYS) 12108f883c24SSage Weil return r; 12114af6b225SYehuda Sadeh return -EAGAIN; 12121d3576fdSSage Weil } 12136298a337SSage Weil ceph_put_snap_context(oldest); 12141d3576fdSSage Weil 12151d3576fdSSage Weil /* yay, writeable, do it now (without dropping page lock) */ 12161d3576fdSSage Weil dout(" page %p snapc %p not current, but oldest\n", 12171d3576fdSSage Weil page, snapc); 12181d3576fdSSage Weil if (!clear_page_dirty_for_io(page)) 12191d3576fdSSage Weil goto retry_locked; 12201d3576fdSSage Weil r = writepage_nounlock(page, NULL); 12211d3576fdSSage Weil if (r < 0) 1222dd2bc473SYan, Zheng goto fail_unlock; 12231d3576fdSSage Weil goto retry_locked; 12241d3576fdSSage Weil } 12251d3576fdSSage Weil 12261d3576fdSSage Weil if (PageUptodate(page)) { 12271d3576fdSSage Weil dout(" page %p already uptodate\n", page); 12281d3576fdSSage Weil return 0; 12291d3576fdSSage Weil } 12301d3576fdSSage Weil 12311d3576fdSSage Weil /* full page? */ 123209cbfeafSKirill A. Shutemov if (pos_in_page == 0 && len == PAGE_SIZE) 12331d3576fdSSage Weil return 0; 12341d3576fdSSage Weil 12351d3576fdSSage Weil /* past end of file? */ 123699c88e69SYan, Zheng i_size = i_size_read(inode); 12371d3576fdSSage Weil 12381d3576fdSSage Weil if (page_off >= i_size || 12391d3576fdSSage Weil (pos_in_page == 0 && (pos+len) >= i_size && 124009cbfeafSKirill A. Shutemov end_in_page - pos_in_page != PAGE_SIZE)) { 12411d3576fdSSage Weil dout(" zeroing %p 0 - %d and %d - %d\n", 124209cbfeafSKirill A. Shutemov page, pos_in_page, end_in_page, (int)PAGE_SIZE); 12431d3576fdSSage Weil zero_user_segments(page, 12441d3576fdSSage Weil 0, pos_in_page, 124509cbfeafSKirill A. Shutemov end_in_page, PAGE_SIZE); 12461d3576fdSSage Weil return 0; 12471d3576fdSSage Weil } 12481d3576fdSSage Weil 12491d3576fdSSage Weil /* we need to read it. */ 1250dd2bc473SYan, Zheng r = ceph_do_readpage(file, page); 1251dd2bc473SYan, Zheng if (r < 0) { 1252dd2bc473SYan, Zheng if (r == -EINPROGRESS) 1253dd2bc473SYan, Zheng return -EAGAIN; 1254dd2bc473SYan, Zheng goto fail_unlock; 1255dd2bc473SYan, Zheng } 12561d3576fdSSage Weil goto retry_locked; 1257dd2bc473SYan, Zheng fail_unlock: 12581d3576fdSSage Weil unlock_page(page); 12591d3576fdSSage Weil return r; 12601d3576fdSSage Weil } 12611d3576fdSSage Weil 12621d3576fdSSage Weil /* 12634af6b225SYehuda Sadeh * We are only allowed to write into/dirty the page if the page is 12644af6b225SYehuda Sadeh * clean, or already dirty within the same snap context. 12654af6b225SYehuda Sadeh */ 12664af6b225SYehuda Sadeh static int ceph_write_begin(struct file *file, struct address_space *mapping, 12674af6b225SYehuda Sadeh loff_t pos, unsigned len, unsigned flags, 12684af6b225SYehuda Sadeh struct page **pagep, void **fsdata) 12694af6b225SYehuda Sadeh { 1270496ad9aaSAl Viro struct inode *inode = file_inode(file); 12714af6b225SYehuda Sadeh struct page *page; 127209cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT; 12737971bd92SSage Weil int r; 12744af6b225SYehuda Sadeh 12754af6b225SYehuda Sadeh do { 12764af6b225SYehuda Sadeh /* get a page */ 12774af6b225SYehuda Sadeh page = grab_cache_page_write_begin(mapping, index, 0); 12787971bd92SSage Weil if (!page) 12797971bd92SSage Weil return -ENOMEM; 12804af6b225SYehuda Sadeh 12814af6b225SYehuda Sadeh dout("write_begin file %p inode %p page %p %d~%d\n", file, 12824af6b225SYehuda Sadeh inode, page, (int)pos, (int)len); 12834af6b225SYehuda Sadeh 12844af6b225SYehuda Sadeh r = ceph_update_writeable_page(file, pos, len, page); 1285c1d00b2dSTaesoo Kim if (r < 0) 128609cbfeafSKirill A. Shutemov put_page(page); 1287c1d00b2dSTaesoo Kim else 1288c1d00b2dSTaesoo Kim *pagep = page; 12894af6b225SYehuda Sadeh } while (r == -EAGAIN); 12904af6b225SYehuda Sadeh 12914af6b225SYehuda Sadeh return r; 12924af6b225SYehuda Sadeh } 12934af6b225SYehuda Sadeh 12944af6b225SYehuda Sadeh /* 12951d3576fdSSage Weil * we don't do anything in here that simple_write_end doesn't do 12965dda377cSYan, Zheng * except adjust dirty page accounting 12971d3576fdSSage Weil */ 12981d3576fdSSage Weil static int ceph_write_end(struct file *file, struct address_space *mapping, 12991d3576fdSSage Weil loff_t pos, unsigned len, unsigned copied, 13001d3576fdSSage Weil struct page *page, void *fsdata) 13011d3576fdSSage Weil { 1302496ad9aaSAl Viro struct inode *inode = file_inode(file); 1303efb0ca76SYan, Zheng bool check_cap = false; 13041d3576fdSSage Weil 13051d3576fdSSage Weil dout("write_end file %p inode %p page %p %d~%d (%d)\n", file, 13061d3576fdSSage Weil inode, page, (int)pos, (int)copied, (int)len); 13071d3576fdSSage Weil 13081d3576fdSSage Weil /* zero the stale part of the page if we did a short copy */ 1309b9de313cSAl Viro if (!PageUptodate(page)) { 1310b9de313cSAl Viro if (copied < len) { 1311b9de313cSAl Viro copied = 0; 1312b9de313cSAl Viro goto out; 1313b9de313cSAl Viro } 1314b9de313cSAl Viro SetPageUptodate(page); 1315b9de313cSAl Viro } 13161d3576fdSSage Weil 13171d3576fdSSage Weil /* did file size increase? */ 131899c88e69SYan, Zheng if (pos+copied > i_size_read(inode)) 13191d3576fdSSage Weil check_cap = ceph_inode_set_size(inode, pos+copied); 13201d3576fdSSage Weil 13211d3576fdSSage Weil set_page_dirty(page); 13221d3576fdSSage Weil 1323b9de313cSAl Viro out: 13241d3576fdSSage Weil unlock_page(page); 132509cbfeafSKirill A. Shutemov put_page(page); 13261d3576fdSSage Weil 13271d3576fdSSage Weil if (check_cap) 13281d3576fdSSage Weil ceph_check_caps(ceph_inode(inode), CHECK_CAPS_AUTHONLY, NULL); 13291d3576fdSSage Weil 13301d3576fdSSage Weil return copied; 13311d3576fdSSage Weil } 13321d3576fdSSage Weil 13331d3576fdSSage Weil /* 13341d3576fdSSage Weil * we set .direct_IO to indicate direct io is supported, but since we 13351d3576fdSSage Weil * intercept O_DIRECT reads and writes early, this function should 13361d3576fdSSage Weil * never get called. 13371d3576fdSSage Weil */ 1338c8b8e32dSChristoph Hellwig static ssize_t ceph_direct_io(struct kiocb *iocb, struct iov_iter *iter) 13391d3576fdSSage Weil { 13401d3576fdSSage Weil WARN_ON(1); 13411d3576fdSSage Weil return -EINVAL; 13421d3576fdSSage Weil } 13431d3576fdSSage Weil 13441d3576fdSSage Weil const struct address_space_operations ceph_aops = { 13451d3576fdSSage Weil .readpage = ceph_readpage, 13461d3576fdSSage Weil .readpages = ceph_readpages, 13471d3576fdSSage Weil .writepage = ceph_writepage, 13481d3576fdSSage Weil .writepages = ceph_writepages_start, 13491d3576fdSSage Weil .write_begin = ceph_write_begin, 13501d3576fdSSage Weil .write_end = ceph_write_end, 13511d3576fdSSage Weil .set_page_dirty = ceph_set_page_dirty, 13521d3576fdSSage Weil .invalidatepage = ceph_invalidatepage, 13531d3576fdSSage Weil .releasepage = ceph_releasepage, 13541d3576fdSSage Weil .direct_IO = ceph_direct_io, 13551d3576fdSSage Weil }; 13561d3576fdSSage Weil 13574f7e89f6SYan, Zheng static void ceph_block_sigs(sigset_t *oldset) 13584f7e89f6SYan, Zheng { 13594f7e89f6SYan, Zheng sigset_t mask; 13604f7e89f6SYan, Zheng siginitsetinv(&mask, sigmask(SIGKILL)); 13614f7e89f6SYan, Zheng sigprocmask(SIG_BLOCK, &mask, oldset); 13624f7e89f6SYan, Zheng } 13634f7e89f6SYan, Zheng 13644f7e89f6SYan, Zheng static void ceph_restore_sigs(sigset_t *oldset) 13654f7e89f6SYan, Zheng { 13664f7e89f6SYan, Zheng sigprocmask(SIG_SETMASK, oldset, NULL); 13674f7e89f6SYan, Zheng } 13681d3576fdSSage Weil 13691d3576fdSSage Weil /* 13701d3576fdSSage Weil * vm ops 13711d3576fdSSage Weil */ 137211bac800SDave Jiang static int ceph_filemap_fault(struct vm_fault *vmf) 137361f68816SYan, Zheng { 137411bac800SDave Jiang struct vm_area_struct *vma = vmf->vma; 137561f68816SYan, Zheng struct inode *inode = file_inode(vma->vm_file); 137661f68816SYan, Zheng struct ceph_inode_info *ci = ceph_inode(inode); 137761f68816SYan, Zheng struct ceph_file_info *fi = vma->vm_file->private_data; 13783738daa6SYan, Zheng struct page *pinned_page = NULL; 137909cbfeafSKirill A. Shutemov loff_t off = vmf->pgoff << PAGE_SHIFT; 138061f68816SYan, Zheng int want, got, ret; 13814f7e89f6SYan, Zheng sigset_t oldset; 13824f7e89f6SYan, Zheng 13834f7e89f6SYan, Zheng ceph_block_sigs(&oldset); 138461f68816SYan, Zheng 138561f68816SYan, Zheng dout("filemap_fault %p %llx.%llx %llu~%zd trying to get caps\n", 138609cbfeafSKirill A. Shutemov inode, ceph_vinop(inode), off, (size_t)PAGE_SIZE); 138761f68816SYan, Zheng if (fi->fmode & CEPH_FILE_MODE_LAZY) 138861f68816SYan, Zheng want = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO; 138961f68816SYan, Zheng else 139061f68816SYan, Zheng want = CEPH_CAP_FILE_CACHE; 13914f7e89f6SYan, Zheng 139261f68816SYan, Zheng got = 0; 13934f7e89f6SYan, Zheng ret = ceph_get_caps(ci, CEPH_CAP_FILE_RD, want, -1, &got, &pinned_page); 13946ce026e4SYan, Zheng if (ret < 0) 13954f7e89f6SYan, Zheng goto out_restore; 13966ce026e4SYan, Zheng 139761f68816SYan, Zheng dout("filemap_fault %p %llu~%zd got cap refs on %s\n", 139809cbfeafSKirill A. Shutemov inode, off, (size_t)PAGE_SIZE, ceph_cap_string(got)); 139961f68816SYan, Zheng 140083701246SYan, Zheng if ((got & (CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO)) || 14012b1ac852SYan, Zheng ci->i_inline_version == CEPH_INLINE_NONE) { 14022b1ac852SYan, Zheng current->journal_info = vma->vm_file; 140311bac800SDave Jiang ret = filemap_fault(vmf); 14042b1ac852SYan, Zheng current->journal_info = NULL; 14052b1ac852SYan, Zheng } else 140683701246SYan, Zheng ret = -EAGAIN; 140761f68816SYan, Zheng 140861f68816SYan, Zheng dout("filemap_fault %p %llu~%zd dropping cap refs on %s ret %d\n", 140909cbfeafSKirill A. Shutemov inode, off, (size_t)PAGE_SIZE, ceph_cap_string(got), ret); 14103738daa6SYan, Zheng if (pinned_page) 141109cbfeafSKirill A. Shutemov put_page(pinned_page); 141261f68816SYan, Zheng ceph_put_cap_refs(ci, got); 141361f68816SYan, Zheng 141483701246SYan, Zheng if (ret != -EAGAIN) 14154f7e89f6SYan, Zheng goto out_restore; 141683701246SYan, Zheng 141783701246SYan, Zheng /* read inline data */ 141809cbfeafSKirill A. Shutemov if (off >= PAGE_SIZE) { 141983701246SYan, Zheng /* does not support inline data > PAGE_SIZE */ 142083701246SYan, Zheng ret = VM_FAULT_SIGBUS; 142183701246SYan, Zheng } else { 142283701246SYan, Zheng int ret1; 142383701246SYan, Zheng struct address_space *mapping = inode->i_mapping; 142483701246SYan, Zheng struct page *page = find_or_create_page(mapping, 0, 1425c62d2555SMichal Hocko mapping_gfp_constraint(mapping, 1426c62d2555SMichal Hocko ~__GFP_FS)); 142783701246SYan, Zheng if (!page) { 142883701246SYan, Zheng ret = VM_FAULT_OOM; 14294f7e89f6SYan, Zheng goto out_inline; 143083701246SYan, Zheng } 143183701246SYan, Zheng ret1 = __ceph_do_getattr(inode, page, 143283701246SYan, Zheng CEPH_STAT_CAP_INLINE_DATA, true); 143383701246SYan, Zheng if (ret1 < 0 || off >= i_size_read(inode)) { 143483701246SYan, Zheng unlock_page(page); 143509cbfeafSKirill A. Shutemov put_page(page); 14366ce026e4SYan, Zheng if (ret1 < 0) 14376ce026e4SYan, Zheng ret = ret1; 14386ce026e4SYan, Zheng else 143983701246SYan, Zheng ret = VM_FAULT_SIGBUS; 14404f7e89f6SYan, Zheng goto out_inline; 144183701246SYan, Zheng } 144209cbfeafSKirill A. Shutemov if (ret1 < PAGE_SIZE) 144309cbfeafSKirill A. Shutemov zero_user_segment(page, ret1, PAGE_SIZE); 144483701246SYan, Zheng else 144583701246SYan, Zheng flush_dcache_page(page); 144683701246SYan, Zheng SetPageUptodate(page); 144783701246SYan, Zheng vmf->page = page; 144883701246SYan, Zheng ret = VM_FAULT_MAJOR | VM_FAULT_LOCKED; 14494f7e89f6SYan, Zheng out_inline: 145083701246SYan, Zheng dout("filemap_fault %p %llu~%zd read inline data ret %d\n", 145109cbfeafSKirill A. Shutemov inode, off, (size_t)PAGE_SIZE, ret); 14524f7e89f6SYan, Zheng } 14534f7e89f6SYan, Zheng out_restore: 14544f7e89f6SYan, Zheng ceph_restore_sigs(&oldset); 14556ce026e4SYan, Zheng if (ret < 0) 14566ce026e4SYan, Zheng ret = (ret == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS; 14576ce026e4SYan, Zheng 145861f68816SYan, Zheng return ret; 145961f68816SYan, Zheng } 14601d3576fdSSage Weil 14611d3576fdSSage Weil /* 14621d3576fdSSage Weil * Reuse write_begin here for simplicity. 14631d3576fdSSage Weil */ 146411bac800SDave Jiang static int ceph_page_mkwrite(struct vm_fault *vmf) 14651d3576fdSSage Weil { 146611bac800SDave Jiang struct vm_area_struct *vma = vmf->vma; 1467496ad9aaSAl Viro struct inode *inode = file_inode(vma->vm_file); 146861f68816SYan, Zheng struct ceph_inode_info *ci = ceph_inode(inode); 146961f68816SYan, Zheng struct ceph_file_info *fi = vma->vm_file->private_data; 1470f66fd9f0SYan, Zheng struct ceph_cap_flush *prealloc_cf; 147161f68816SYan, Zheng struct page *page = vmf->page; 14726285bc23SAlex Elder loff_t off = page_offset(page); 147361f68816SYan, Zheng loff_t size = i_size_read(inode); 147461f68816SYan, Zheng size_t len; 147561f68816SYan, Zheng int want, got, ret; 14764f7e89f6SYan, Zheng sigset_t oldset; 14771d3576fdSSage Weil 1478f66fd9f0SYan, Zheng prealloc_cf = ceph_alloc_cap_flush(); 1479f66fd9f0SYan, Zheng if (!prealloc_cf) 14806ce026e4SYan, Zheng return VM_FAULT_OOM; 1481f66fd9f0SYan, Zheng 14824f7e89f6SYan, Zheng ceph_block_sigs(&oldset); 14831d3576fdSSage Weil 148428127bddSYan, Zheng if (ci->i_inline_version != CEPH_INLINE_NONE) { 148528127bddSYan, Zheng struct page *locked_page = NULL; 148628127bddSYan, Zheng if (off == 0) { 148728127bddSYan, Zheng lock_page(page); 148828127bddSYan, Zheng locked_page = page; 148928127bddSYan, Zheng } 149028127bddSYan, Zheng ret = ceph_uninline_data(vma->vm_file, locked_page); 149128127bddSYan, Zheng if (locked_page) 149228127bddSYan, Zheng unlock_page(locked_page); 14936ce026e4SYan, Zheng if (ret < 0) 1494f66fd9f0SYan, Zheng goto out_free; 1495f66fd9f0SYan, Zheng } 149628127bddSYan, Zheng 149709cbfeafSKirill A. Shutemov if (off + PAGE_SIZE <= size) 149809cbfeafSKirill A. Shutemov len = PAGE_SIZE; 14991d3576fdSSage Weil else 150009cbfeafSKirill A. Shutemov len = size & ~PAGE_MASK; 15011d3576fdSSage Weil 150261f68816SYan, Zheng dout("page_mkwrite %p %llx.%llx %llu~%zd getting caps i_size %llu\n", 150361f68816SYan, Zheng inode, ceph_vinop(inode), off, len, size); 150461f68816SYan, Zheng if (fi->fmode & CEPH_FILE_MODE_LAZY) 150561f68816SYan, Zheng want = CEPH_CAP_FILE_BUFFER | CEPH_CAP_FILE_LAZYIO; 150661f68816SYan, Zheng else 150761f68816SYan, Zheng want = CEPH_CAP_FILE_BUFFER; 15084f7e89f6SYan, Zheng 150961f68816SYan, Zheng got = 0; 15103738daa6SYan, Zheng ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, off + len, 15113738daa6SYan, Zheng &got, NULL); 15126ce026e4SYan, Zheng if (ret < 0) 1513f66fd9f0SYan, Zheng goto out_free; 15146ce026e4SYan, Zheng 151561f68816SYan, Zheng dout("page_mkwrite %p %llu~%zd got cap refs on %s\n", 151661f68816SYan, Zheng inode, off, len, ceph_cap_string(got)); 151761f68816SYan, Zheng 151861f68816SYan, Zheng /* Update time before taking page lock */ 151961f68816SYan, Zheng file_update_time(vma->vm_file); 15204af6b225SYehuda Sadeh 1521f0b33df5SYan, Zheng do { 15224af6b225SYehuda Sadeh lock_page(page); 15234af6b225SYehuda Sadeh 15246ce026e4SYan, Zheng if ((off > size) || (page->mapping != inode->i_mapping)) { 1525f9cac5acSYan, Zheng unlock_page(page); 15266ce026e4SYan, Zheng ret = VM_FAULT_NOPAGE; 1527f0b33df5SYan, Zheng break; 1528f9cac5acSYan, Zheng } 15294af6b225SYehuda Sadeh 15304af6b225SYehuda Sadeh ret = ceph_update_writeable_page(vma->vm_file, off, len, page); 1531f9cac5acSYan, Zheng if (ret >= 0) { 15324af6b225SYehuda Sadeh /* success. we'll keep the page locked. */ 15331d3576fdSSage Weil set_page_dirty(page); 15341d3576fdSSage Weil ret = VM_FAULT_LOCKED; 15351d3576fdSSage Weil } 1536f0b33df5SYan, Zheng } while (ret == -EAGAIN); 1537f0b33df5SYan, Zheng 153828127bddSYan, Zheng if (ret == VM_FAULT_LOCKED || 153928127bddSYan, Zheng ci->i_inline_version != CEPH_INLINE_NONE) { 154061f68816SYan, Zheng int dirty; 154161f68816SYan, Zheng spin_lock(&ci->i_ceph_lock); 154228127bddSYan, Zheng ci->i_inline_version = CEPH_INLINE_NONE; 1543f66fd9f0SYan, Zheng dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR, 1544f66fd9f0SYan, Zheng &prealloc_cf); 154561f68816SYan, Zheng spin_unlock(&ci->i_ceph_lock); 154661f68816SYan, Zheng if (dirty) 154761f68816SYan, Zheng __mark_inode_dirty(inode, dirty); 154861f68816SYan, Zheng } 154961f68816SYan, Zheng 155061f68816SYan, Zheng dout("page_mkwrite %p %llu~%zd dropping cap refs on %s ret %d\n", 155161f68816SYan, Zheng inode, off, len, ceph_cap_string(got), ret); 155261f68816SYan, Zheng ceph_put_cap_refs(ci, got); 1553f66fd9f0SYan, Zheng out_free: 15544f7e89f6SYan, Zheng ceph_restore_sigs(&oldset); 1555f66fd9f0SYan, Zheng ceph_free_cap_flush(prealloc_cf); 15566ce026e4SYan, Zheng if (ret < 0) 15576ce026e4SYan, Zheng ret = (ret == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS; 15581d3576fdSSage Weil return ret; 15591d3576fdSSage Weil } 15601d3576fdSSage Weil 156131c542a1SYan, Zheng void ceph_fill_inline_data(struct inode *inode, struct page *locked_page, 156231c542a1SYan, Zheng char *data, size_t len) 156331c542a1SYan, Zheng { 156431c542a1SYan, Zheng struct address_space *mapping = inode->i_mapping; 156531c542a1SYan, Zheng struct page *page; 156631c542a1SYan, Zheng 156731c542a1SYan, Zheng if (locked_page) { 156831c542a1SYan, Zheng page = locked_page; 156931c542a1SYan, Zheng } else { 157031c542a1SYan, Zheng if (i_size_read(inode) == 0) 157131c542a1SYan, Zheng return; 157231c542a1SYan, Zheng page = find_or_create_page(mapping, 0, 1573c62d2555SMichal Hocko mapping_gfp_constraint(mapping, 1574c62d2555SMichal Hocko ~__GFP_FS)); 157531c542a1SYan, Zheng if (!page) 157631c542a1SYan, Zheng return; 157731c542a1SYan, Zheng if (PageUptodate(page)) { 157831c542a1SYan, Zheng unlock_page(page); 157909cbfeafSKirill A. Shutemov put_page(page); 158031c542a1SYan, Zheng return; 158131c542a1SYan, Zheng } 158231c542a1SYan, Zheng } 158331c542a1SYan, Zheng 15840668ff52SIlya Dryomov dout("fill_inline_data %p %llx.%llx len %zu locked_page %p\n", 158531c542a1SYan, Zheng inode, ceph_vinop(inode), len, locked_page); 158631c542a1SYan, Zheng 158731c542a1SYan, Zheng if (len > 0) { 158831c542a1SYan, Zheng void *kaddr = kmap_atomic(page); 158931c542a1SYan, Zheng memcpy(kaddr, data, len); 159031c542a1SYan, Zheng kunmap_atomic(kaddr); 159131c542a1SYan, Zheng } 159231c542a1SYan, Zheng 159331c542a1SYan, Zheng if (page != locked_page) { 159409cbfeafSKirill A. Shutemov if (len < PAGE_SIZE) 159509cbfeafSKirill A. Shutemov zero_user_segment(page, len, PAGE_SIZE); 159631c542a1SYan, Zheng else 159731c542a1SYan, Zheng flush_dcache_page(page); 159831c542a1SYan, Zheng 159931c542a1SYan, Zheng SetPageUptodate(page); 160031c542a1SYan, Zheng unlock_page(page); 160109cbfeafSKirill A. Shutemov put_page(page); 160231c542a1SYan, Zheng } 160331c542a1SYan, Zheng } 160431c542a1SYan, Zheng 160528127bddSYan, Zheng int ceph_uninline_data(struct file *filp, struct page *locked_page) 160628127bddSYan, Zheng { 160728127bddSYan, Zheng struct inode *inode = file_inode(filp); 160828127bddSYan, Zheng struct ceph_inode_info *ci = ceph_inode(inode); 160928127bddSYan, Zheng struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 161028127bddSYan, Zheng struct ceph_osd_request *req; 161128127bddSYan, Zheng struct page *page = NULL; 161228127bddSYan, Zheng u64 len, inline_version; 161328127bddSYan, Zheng int err = 0; 161428127bddSYan, Zheng bool from_pagecache = false; 161528127bddSYan, Zheng 161628127bddSYan, Zheng spin_lock(&ci->i_ceph_lock); 161728127bddSYan, Zheng inline_version = ci->i_inline_version; 161828127bddSYan, Zheng spin_unlock(&ci->i_ceph_lock); 161928127bddSYan, Zheng 162028127bddSYan, Zheng dout("uninline_data %p %llx.%llx inline_version %llu\n", 162128127bddSYan, Zheng inode, ceph_vinop(inode), inline_version); 162228127bddSYan, Zheng 162328127bddSYan, Zheng if (inline_version == 1 || /* initial version, no data */ 162428127bddSYan, Zheng inline_version == CEPH_INLINE_NONE) 162528127bddSYan, Zheng goto out; 162628127bddSYan, Zheng 162728127bddSYan, Zheng if (locked_page) { 162828127bddSYan, Zheng page = locked_page; 162928127bddSYan, Zheng WARN_ON(!PageUptodate(page)); 163028127bddSYan, Zheng } else if (ceph_caps_issued(ci) & 163128127bddSYan, Zheng (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) { 163228127bddSYan, Zheng page = find_get_page(inode->i_mapping, 0); 163328127bddSYan, Zheng if (page) { 163428127bddSYan, Zheng if (PageUptodate(page)) { 163528127bddSYan, Zheng from_pagecache = true; 163628127bddSYan, Zheng lock_page(page); 163728127bddSYan, Zheng } else { 163809cbfeafSKirill A. Shutemov put_page(page); 163928127bddSYan, Zheng page = NULL; 164028127bddSYan, Zheng } 164128127bddSYan, Zheng } 164228127bddSYan, Zheng } 164328127bddSYan, Zheng 164428127bddSYan, Zheng if (page) { 164528127bddSYan, Zheng len = i_size_read(inode); 164609cbfeafSKirill A. Shutemov if (len > PAGE_SIZE) 164709cbfeafSKirill A. Shutemov len = PAGE_SIZE; 164828127bddSYan, Zheng } else { 164928127bddSYan, Zheng page = __page_cache_alloc(GFP_NOFS); 165028127bddSYan, Zheng if (!page) { 165128127bddSYan, Zheng err = -ENOMEM; 165228127bddSYan, Zheng goto out; 165328127bddSYan, Zheng } 165428127bddSYan, Zheng err = __ceph_do_getattr(inode, page, 165528127bddSYan, Zheng CEPH_STAT_CAP_INLINE_DATA, true); 165628127bddSYan, Zheng if (err < 0) { 165728127bddSYan, Zheng /* no inline data */ 165828127bddSYan, Zheng if (err == -ENODATA) 165928127bddSYan, Zheng err = 0; 166028127bddSYan, Zheng goto out; 166128127bddSYan, Zheng } 166228127bddSYan, Zheng len = err; 166328127bddSYan, Zheng } 166428127bddSYan, Zheng 166528127bddSYan, Zheng req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout, 166628127bddSYan, Zheng ceph_vino(inode), 0, &len, 0, 1, 166754ea0046SIlya Dryomov CEPH_OSD_OP_CREATE, CEPH_OSD_FLAG_WRITE, 166834b759b4SIlya Dryomov NULL, 0, 0, false); 166928127bddSYan, Zheng if (IS_ERR(req)) { 167028127bddSYan, Zheng err = PTR_ERR(req); 167128127bddSYan, Zheng goto out; 167228127bddSYan, Zheng } 167328127bddSYan, Zheng 1674bb873b53SIlya Dryomov req->r_mtime = inode->i_mtime; 167528127bddSYan, Zheng err = ceph_osdc_start_request(&fsc->client->osdc, req, false); 167628127bddSYan, Zheng if (!err) 167728127bddSYan, Zheng err = ceph_osdc_wait_request(&fsc->client->osdc, req); 167828127bddSYan, Zheng ceph_osdc_put_request(req); 167928127bddSYan, Zheng if (err < 0) 168028127bddSYan, Zheng goto out; 168128127bddSYan, Zheng 168228127bddSYan, Zheng req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout, 168328127bddSYan, Zheng ceph_vino(inode), 0, &len, 1, 3, 168454ea0046SIlya Dryomov CEPH_OSD_OP_WRITE, CEPH_OSD_FLAG_WRITE, 168534b759b4SIlya Dryomov NULL, ci->i_truncate_seq, 168634b759b4SIlya Dryomov ci->i_truncate_size, false); 168728127bddSYan, Zheng if (IS_ERR(req)) { 168828127bddSYan, Zheng err = PTR_ERR(req); 168928127bddSYan, Zheng goto out; 169028127bddSYan, Zheng } 169128127bddSYan, Zheng 169228127bddSYan, Zheng osd_req_op_extent_osd_data_pages(req, 1, &page, len, 0, false, false); 169328127bddSYan, Zheng 1694ec137c10SYan, Zheng { 1695ec137c10SYan, Zheng __le64 xattr_buf = cpu_to_le64(inline_version); 169628127bddSYan, Zheng err = osd_req_op_xattr_init(req, 0, CEPH_OSD_OP_CMPXATTR, 1697ec137c10SYan, Zheng "inline_version", &xattr_buf, 1698ec137c10SYan, Zheng sizeof(xattr_buf), 169928127bddSYan, Zheng CEPH_OSD_CMPXATTR_OP_GT, 170028127bddSYan, Zheng CEPH_OSD_CMPXATTR_MODE_U64); 170128127bddSYan, Zheng if (err) 170228127bddSYan, Zheng goto out_put; 1703ec137c10SYan, Zheng } 170428127bddSYan, Zheng 1705ec137c10SYan, Zheng { 1706ec137c10SYan, Zheng char xattr_buf[32]; 1707ec137c10SYan, Zheng int xattr_len = snprintf(xattr_buf, sizeof(xattr_buf), 1708ec137c10SYan, Zheng "%llu", inline_version); 170928127bddSYan, Zheng err = osd_req_op_xattr_init(req, 2, CEPH_OSD_OP_SETXATTR, 1710ec137c10SYan, Zheng "inline_version", 1711ec137c10SYan, Zheng xattr_buf, xattr_len, 0, 0); 171228127bddSYan, Zheng if (err) 171328127bddSYan, Zheng goto out_put; 1714ec137c10SYan, Zheng } 171528127bddSYan, Zheng 1716bb873b53SIlya Dryomov req->r_mtime = inode->i_mtime; 171728127bddSYan, Zheng err = ceph_osdc_start_request(&fsc->client->osdc, req, false); 171828127bddSYan, Zheng if (!err) 171928127bddSYan, Zheng err = ceph_osdc_wait_request(&fsc->client->osdc, req); 172028127bddSYan, Zheng out_put: 172128127bddSYan, Zheng ceph_osdc_put_request(req); 172228127bddSYan, Zheng if (err == -ECANCELED) 172328127bddSYan, Zheng err = 0; 172428127bddSYan, Zheng out: 172528127bddSYan, Zheng if (page && page != locked_page) { 172628127bddSYan, Zheng if (from_pagecache) { 172728127bddSYan, Zheng unlock_page(page); 172809cbfeafSKirill A. Shutemov put_page(page); 172928127bddSYan, Zheng } else 173028127bddSYan, Zheng __free_pages(page, 0); 173128127bddSYan, Zheng } 173228127bddSYan, Zheng 173328127bddSYan, Zheng dout("uninline_data %p %llx.%llx inline_version %llu = %d\n", 173428127bddSYan, Zheng inode, ceph_vinop(inode), inline_version, err); 173528127bddSYan, Zheng return err; 173628127bddSYan, Zheng } 173728127bddSYan, Zheng 17387cbea8dcSKirill A. Shutemov static const struct vm_operations_struct ceph_vmops = { 173961f68816SYan, Zheng .fault = ceph_filemap_fault, 17401d3576fdSSage Weil .page_mkwrite = ceph_page_mkwrite, 17411d3576fdSSage Weil }; 17421d3576fdSSage Weil 17431d3576fdSSage Weil int ceph_mmap(struct file *file, struct vm_area_struct *vma) 17441d3576fdSSage Weil { 17451d3576fdSSage Weil struct address_space *mapping = file->f_mapping; 17461d3576fdSSage Weil 17471d3576fdSSage Weil if (!mapping->a_ops->readpage) 17481d3576fdSSage Weil return -ENOEXEC; 17491d3576fdSSage Weil file_accessed(file); 17501d3576fdSSage Weil vma->vm_ops = &ceph_vmops; 17511d3576fdSSage Weil return 0; 17521d3576fdSSage Weil } 175310183a69SYan, Zheng 175410183a69SYan, Zheng enum { 175510183a69SYan, Zheng POOL_READ = 1, 175610183a69SYan, Zheng POOL_WRITE = 2, 175710183a69SYan, Zheng }; 175810183a69SYan, Zheng 1759779fe0fbSYan, Zheng static int __ceph_pool_perm_get(struct ceph_inode_info *ci, 1760779fe0fbSYan, Zheng s64 pool, struct ceph_string *pool_ns) 176110183a69SYan, Zheng { 176210183a69SYan, Zheng struct ceph_fs_client *fsc = ceph_inode_to_client(&ci->vfs_inode); 176310183a69SYan, Zheng struct ceph_mds_client *mdsc = fsc->mdsc; 176410183a69SYan, Zheng struct ceph_osd_request *rd_req = NULL, *wr_req = NULL; 176510183a69SYan, Zheng struct rb_node **p, *parent; 176610183a69SYan, Zheng struct ceph_pool_perm *perm; 176710183a69SYan, Zheng struct page **pages; 1768779fe0fbSYan, Zheng size_t pool_ns_len; 176910183a69SYan, Zheng int err = 0, err2 = 0, have = 0; 177010183a69SYan, Zheng 177110183a69SYan, Zheng down_read(&mdsc->pool_perm_rwsem); 177210183a69SYan, Zheng p = &mdsc->pool_perm_tree.rb_node; 177310183a69SYan, Zheng while (*p) { 177410183a69SYan, Zheng perm = rb_entry(*p, struct ceph_pool_perm, node); 177510183a69SYan, Zheng if (pool < perm->pool) 177610183a69SYan, Zheng p = &(*p)->rb_left; 177710183a69SYan, Zheng else if (pool > perm->pool) 177810183a69SYan, Zheng p = &(*p)->rb_right; 177910183a69SYan, Zheng else { 1780779fe0fbSYan, Zheng int ret = ceph_compare_string(pool_ns, 1781779fe0fbSYan, Zheng perm->pool_ns, 1782779fe0fbSYan, Zheng perm->pool_ns_len); 1783779fe0fbSYan, Zheng if (ret < 0) 1784779fe0fbSYan, Zheng p = &(*p)->rb_left; 1785779fe0fbSYan, Zheng else if (ret > 0) 1786779fe0fbSYan, Zheng p = &(*p)->rb_right; 1787779fe0fbSYan, Zheng else { 178810183a69SYan, Zheng have = perm->perm; 178910183a69SYan, Zheng break; 179010183a69SYan, Zheng } 179110183a69SYan, Zheng } 1792779fe0fbSYan, Zheng } 179310183a69SYan, Zheng up_read(&mdsc->pool_perm_rwsem); 179410183a69SYan, Zheng if (*p) 179510183a69SYan, Zheng goto out; 179610183a69SYan, Zheng 1797779fe0fbSYan, Zheng if (pool_ns) 1798779fe0fbSYan, Zheng dout("__ceph_pool_perm_get pool %lld ns %.*s no perm cached\n", 1799779fe0fbSYan, Zheng pool, (int)pool_ns->len, pool_ns->str); 1800779fe0fbSYan, Zheng else 18017627151eSYan, Zheng dout("__ceph_pool_perm_get pool %lld no perm cached\n", pool); 180210183a69SYan, Zheng 180310183a69SYan, Zheng down_write(&mdsc->pool_perm_rwsem); 1804779fe0fbSYan, Zheng p = &mdsc->pool_perm_tree.rb_node; 180510183a69SYan, Zheng parent = NULL; 180610183a69SYan, Zheng while (*p) { 180710183a69SYan, Zheng parent = *p; 180810183a69SYan, Zheng perm = rb_entry(parent, struct ceph_pool_perm, node); 180910183a69SYan, Zheng if (pool < perm->pool) 181010183a69SYan, Zheng p = &(*p)->rb_left; 181110183a69SYan, Zheng else if (pool > perm->pool) 181210183a69SYan, Zheng p = &(*p)->rb_right; 181310183a69SYan, Zheng else { 1814779fe0fbSYan, Zheng int ret = ceph_compare_string(pool_ns, 1815779fe0fbSYan, Zheng perm->pool_ns, 1816779fe0fbSYan, Zheng perm->pool_ns_len); 1817779fe0fbSYan, Zheng if (ret < 0) 1818779fe0fbSYan, Zheng p = &(*p)->rb_left; 1819779fe0fbSYan, Zheng else if (ret > 0) 1820779fe0fbSYan, Zheng p = &(*p)->rb_right; 1821779fe0fbSYan, Zheng else { 182210183a69SYan, Zheng have = perm->perm; 182310183a69SYan, Zheng break; 182410183a69SYan, Zheng } 182510183a69SYan, Zheng } 1826779fe0fbSYan, Zheng } 182710183a69SYan, Zheng if (*p) { 182810183a69SYan, Zheng up_write(&mdsc->pool_perm_rwsem); 182910183a69SYan, Zheng goto out; 183010183a69SYan, Zheng } 183110183a69SYan, Zheng 183234b759b4SIlya Dryomov rd_req = ceph_osdc_alloc_request(&fsc->client->osdc, NULL, 183310183a69SYan, Zheng 1, false, GFP_NOFS); 183410183a69SYan, Zheng if (!rd_req) { 183510183a69SYan, Zheng err = -ENOMEM; 183610183a69SYan, Zheng goto out_unlock; 183710183a69SYan, Zheng } 183810183a69SYan, Zheng 183910183a69SYan, Zheng rd_req->r_flags = CEPH_OSD_FLAG_READ; 184010183a69SYan, Zheng osd_req_op_init(rd_req, 0, CEPH_OSD_OP_STAT, 0); 184110183a69SYan, Zheng rd_req->r_base_oloc.pool = pool; 1842779fe0fbSYan, Zheng if (pool_ns) 1843779fe0fbSYan, Zheng rd_req->r_base_oloc.pool_ns = ceph_get_string(pool_ns); 1844d30291b9SIlya Dryomov ceph_oid_printf(&rd_req->r_base_oid, "%llx.00000000", ci->i_vino.ino); 184510183a69SYan, Zheng 184613d1ad16SIlya Dryomov err = ceph_osdc_alloc_messages(rd_req, GFP_NOFS); 184713d1ad16SIlya Dryomov if (err) 184813d1ad16SIlya Dryomov goto out_unlock; 184910183a69SYan, Zheng 185034b759b4SIlya Dryomov wr_req = ceph_osdc_alloc_request(&fsc->client->osdc, NULL, 185110183a69SYan, Zheng 1, false, GFP_NOFS); 185210183a69SYan, Zheng if (!wr_req) { 185310183a69SYan, Zheng err = -ENOMEM; 185410183a69SYan, Zheng goto out_unlock; 185510183a69SYan, Zheng } 185610183a69SYan, Zheng 185754ea0046SIlya Dryomov wr_req->r_flags = CEPH_OSD_FLAG_WRITE; 185810183a69SYan, Zheng osd_req_op_init(wr_req, 0, CEPH_OSD_OP_CREATE, CEPH_OSD_OP_FLAG_EXCL); 185963244fa1SIlya Dryomov ceph_oloc_copy(&wr_req->r_base_oloc, &rd_req->r_base_oloc); 1860d30291b9SIlya Dryomov ceph_oid_copy(&wr_req->r_base_oid, &rd_req->r_base_oid); 186110183a69SYan, Zheng 186213d1ad16SIlya Dryomov err = ceph_osdc_alloc_messages(wr_req, GFP_NOFS); 186313d1ad16SIlya Dryomov if (err) 186413d1ad16SIlya Dryomov goto out_unlock; 186510183a69SYan, Zheng 186610183a69SYan, Zheng /* one page should be large enough for STAT data */ 186710183a69SYan, Zheng pages = ceph_alloc_page_vector(1, GFP_KERNEL); 186810183a69SYan, Zheng if (IS_ERR(pages)) { 186910183a69SYan, Zheng err = PTR_ERR(pages); 187010183a69SYan, Zheng goto out_unlock; 187110183a69SYan, Zheng } 187210183a69SYan, Zheng 187310183a69SYan, Zheng osd_req_op_raw_data_in_pages(rd_req, 0, pages, PAGE_SIZE, 187410183a69SYan, Zheng 0, false, true); 187510183a69SYan, Zheng err = ceph_osdc_start_request(&fsc->client->osdc, rd_req, false); 187610183a69SYan, Zheng 1877bb873b53SIlya Dryomov wr_req->r_mtime = ci->vfs_inode.i_mtime; 1878a1f4020aSJeff Layton wr_req->r_abort_on_full = true; 187910183a69SYan, Zheng err2 = ceph_osdc_start_request(&fsc->client->osdc, wr_req, false); 188010183a69SYan, Zheng 188110183a69SYan, Zheng if (!err) 188210183a69SYan, Zheng err = ceph_osdc_wait_request(&fsc->client->osdc, rd_req); 188310183a69SYan, Zheng if (!err2) 188410183a69SYan, Zheng err2 = ceph_osdc_wait_request(&fsc->client->osdc, wr_req); 188510183a69SYan, Zheng 188610183a69SYan, Zheng if (err >= 0 || err == -ENOENT) 188710183a69SYan, Zheng have |= POOL_READ; 188810183a69SYan, Zheng else if (err != -EPERM) 188910183a69SYan, Zheng goto out_unlock; 189010183a69SYan, Zheng 189110183a69SYan, Zheng if (err2 == 0 || err2 == -EEXIST) 189210183a69SYan, Zheng have |= POOL_WRITE; 189310183a69SYan, Zheng else if (err2 != -EPERM) { 189410183a69SYan, Zheng err = err2; 189510183a69SYan, Zheng goto out_unlock; 189610183a69SYan, Zheng } 189710183a69SYan, Zheng 1898779fe0fbSYan, Zheng pool_ns_len = pool_ns ? pool_ns->len : 0; 1899779fe0fbSYan, Zheng perm = kmalloc(sizeof(*perm) + pool_ns_len + 1, GFP_NOFS); 190010183a69SYan, Zheng if (!perm) { 190110183a69SYan, Zheng err = -ENOMEM; 190210183a69SYan, Zheng goto out_unlock; 190310183a69SYan, Zheng } 190410183a69SYan, Zheng 190510183a69SYan, Zheng perm->pool = pool; 190610183a69SYan, Zheng perm->perm = have; 1907779fe0fbSYan, Zheng perm->pool_ns_len = pool_ns_len; 1908779fe0fbSYan, Zheng if (pool_ns_len > 0) 1909779fe0fbSYan, Zheng memcpy(perm->pool_ns, pool_ns->str, pool_ns_len); 1910779fe0fbSYan, Zheng perm->pool_ns[pool_ns_len] = 0; 1911779fe0fbSYan, Zheng 191210183a69SYan, Zheng rb_link_node(&perm->node, parent, p); 191310183a69SYan, Zheng rb_insert_color(&perm->node, &mdsc->pool_perm_tree); 191410183a69SYan, Zheng err = 0; 191510183a69SYan, Zheng out_unlock: 191610183a69SYan, Zheng up_write(&mdsc->pool_perm_rwsem); 191710183a69SYan, Zheng 191810183a69SYan, Zheng ceph_osdc_put_request(rd_req); 191910183a69SYan, Zheng ceph_osdc_put_request(wr_req); 192010183a69SYan, Zheng out: 192110183a69SYan, Zheng if (!err) 192210183a69SYan, Zheng err = have; 1923779fe0fbSYan, Zheng if (pool_ns) 1924779fe0fbSYan, Zheng dout("__ceph_pool_perm_get pool %lld ns %.*s result = %d\n", 1925779fe0fbSYan, Zheng pool, (int)pool_ns->len, pool_ns->str, err); 1926779fe0fbSYan, Zheng else 19277627151eSYan, Zheng dout("__ceph_pool_perm_get pool %lld result = %d\n", pool, err); 192810183a69SYan, Zheng return err; 192910183a69SYan, Zheng } 193010183a69SYan, Zheng 193110183a69SYan, Zheng int ceph_pool_perm_check(struct ceph_inode_info *ci, int need) 193210183a69SYan, Zheng { 19337627151eSYan, Zheng s64 pool; 1934779fe0fbSYan, Zheng struct ceph_string *pool_ns; 193510183a69SYan, Zheng int ret, flags; 193610183a69SYan, Zheng 193780e80fbbSYan, Zheng if (ci->i_vino.snap != CEPH_NOSNAP) { 193880e80fbbSYan, Zheng /* 193980e80fbbSYan, Zheng * Pool permission check needs to write to the first object. 194080e80fbbSYan, Zheng * But for snapshot, head of the first object may have alread 194180e80fbbSYan, Zheng * been deleted. Skip check to avoid creating orphan object. 194280e80fbbSYan, Zheng */ 194380e80fbbSYan, Zheng return 0; 194480e80fbbSYan, Zheng } 194580e80fbbSYan, Zheng 194610183a69SYan, Zheng if (ceph_test_mount_opt(ceph_inode_to_client(&ci->vfs_inode), 194710183a69SYan, Zheng NOPOOLPERM)) 194810183a69SYan, Zheng return 0; 194910183a69SYan, Zheng 195010183a69SYan, Zheng spin_lock(&ci->i_ceph_lock); 195110183a69SYan, Zheng flags = ci->i_ceph_flags; 19527627151eSYan, Zheng pool = ci->i_layout.pool_id; 195310183a69SYan, Zheng spin_unlock(&ci->i_ceph_lock); 195410183a69SYan, Zheng check: 195510183a69SYan, Zheng if (flags & CEPH_I_POOL_PERM) { 195610183a69SYan, Zheng if ((need & CEPH_CAP_FILE_RD) && !(flags & CEPH_I_POOL_RD)) { 19577627151eSYan, Zheng dout("ceph_pool_perm_check pool %lld no read perm\n", 195810183a69SYan, Zheng pool); 195910183a69SYan, Zheng return -EPERM; 196010183a69SYan, Zheng } 196110183a69SYan, Zheng if ((need & CEPH_CAP_FILE_WR) && !(flags & CEPH_I_POOL_WR)) { 19627627151eSYan, Zheng dout("ceph_pool_perm_check pool %lld no write perm\n", 196310183a69SYan, Zheng pool); 196410183a69SYan, Zheng return -EPERM; 196510183a69SYan, Zheng } 196610183a69SYan, Zheng return 0; 196710183a69SYan, Zheng } 196810183a69SYan, Zheng 1969779fe0fbSYan, Zheng pool_ns = ceph_try_get_string(ci->i_layout.pool_ns); 1970779fe0fbSYan, Zheng ret = __ceph_pool_perm_get(ci, pool, pool_ns); 1971779fe0fbSYan, Zheng ceph_put_string(pool_ns); 197210183a69SYan, Zheng if (ret < 0) 197310183a69SYan, Zheng return ret; 197410183a69SYan, Zheng 197510183a69SYan, Zheng flags = CEPH_I_POOL_PERM; 197610183a69SYan, Zheng if (ret & POOL_READ) 197710183a69SYan, Zheng flags |= CEPH_I_POOL_RD; 197810183a69SYan, Zheng if (ret & POOL_WRITE) 197910183a69SYan, Zheng flags |= CEPH_I_POOL_WR; 198010183a69SYan, Zheng 198110183a69SYan, Zheng spin_lock(&ci->i_ceph_lock); 1982779fe0fbSYan, Zheng if (pool == ci->i_layout.pool_id && 1983779fe0fbSYan, Zheng pool_ns == rcu_dereference_raw(ci->i_layout.pool_ns)) { 1984779fe0fbSYan, Zheng ci->i_ceph_flags |= flags; 198510183a69SYan, Zheng } else { 19867627151eSYan, Zheng pool = ci->i_layout.pool_id; 198710183a69SYan, Zheng flags = ci->i_ceph_flags; 198810183a69SYan, Zheng } 198910183a69SYan, Zheng spin_unlock(&ci->i_ceph_lock); 199010183a69SYan, Zheng goto check; 199110183a69SYan, Zheng } 199210183a69SYan, Zheng 199310183a69SYan, Zheng void ceph_pool_perm_destroy(struct ceph_mds_client *mdsc) 199410183a69SYan, Zheng { 199510183a69SYan, Zheng struct ceph_pool_perm *perm; 199610183a69SYan, Zheng struct rb_node *n; 199710183a69SYan, Zheng 199810183a69SYan, Zheng while (!RB_EMPTY_ROOT(&mdsc->pool_perm_tree)) { 199910183a69SYan, Zheng n = rb_first(&mdsc->pool_perm_tree); 200010183a69SYan, Zheng perm = rb_entry(n, struct ceph_pool_perm, node); 200110183a69SYan, Zheng rb_erase(n, &mdsc->pool_perm_tree); 200210183a69SYan, Zheng kfree(perm); 200310183a69SYan, Zheng } 200410183a69SYan, Zheng } 2005