static int __ocfs2_page_mkwrite(struct file *file, struct buffer_head *di_bh, struct page *page) { int ret = VM_FAULT_NOPAGE; struct inode *inode = file_inode(file); struct address_space *mapping = inode->i_mapping; loff_t pos = page_offset(page); unsigned int len = PAGE_CACHE_SIZE; pgoff_t last_index; struct page *locked_page = NULL; void *fsdata; loff_t size = i_size_read(inode); last_index = (size - 1) >> PAGE_CACHE_SHIFT; /* * There are cases that lead to the page no longer bebongs to the * mapping. * 1) pagecache truncates locally due to memory pressure. * 2) pagecache truncates when another is taking EX lock against * inode lock. see ocfs2_data_convert_worker. * * The i_size check doesn't catch the case where nodes truncated and * then re-extended the file. We'll re-check the page mapping after * taking the page lock inside of ocfs2_write_begin_nolock(). * * Let VM retry with these cases. */ if ((page->mapping != inode->i_mapping) || (!PageUptodate(page)) || (page_offset(page) >= size)) goto out; /* * Call ocfs2_write_begin() and ocfs2_write_end() to take * advantage of the allocation code there. We pass a write * length of the whole page (chopped to i_size) to make sure * the whole thing is allocated. * * Since we know the page is up to date, we don't have to * worry about ocfs2_write_begin() skipping some buffer reads * because the "write" would invalidate their data. */ if (page->index == last_index) len = ((size - 1) & ~PAGE_CACHE_MASK) + 1; ret = ocfs2_write_begin_nolock(file, mapping, pos, len, 0, &locked_page, &fsdata, di_bh, page); if (ret) { if (ret != -ENOSPC) mlog_errno(ret); if (ret == -ENOMEM) ret = VM_FAULT_OOM; else ret = VM_FAULT_SIGBUS; goto out; } if (!locked_page) { ret = VM_FAULT_NOPAGE; goto out; } ret = ocfs2_write_end_nolock(mapping, pos, len, len, locked_page, fsdata); BUG_ON(ret != len); ret = VM_FAULT_LOCKED; out: return ret; }
static int __ocfs2_page_mkwrite(struct inode *inode, struct buffer_head *di_bh, struct page *page) { int ret; struct address_space *mapping = inode->i_mapping; loff_t pos = page_offset(page); unsigned int len = PAGE_CACHE_SIZE; pgoff_t last_index; struct page *locked_page = NULL; void *fsdata; loff_t size = i_size_read(inode); /* * Another node might have truncated while we were waiting on * cluster locks. */ last_index = size >> PAGE_CACHE_SHIFT; if (page->index > last_index) { ret = -EINVAL; goto out; } /* * The i_size check above doesn't catch the case where nodes * truncated and then re-extended the file. We'll re-check the * page mapping after taking the page lock inside of * ocfs2_write_begin_nolock(). */ if (!PageUptodate(page) || page->mapping != inode->i_mapping) { /* * the page has been umapped in ocfs2_data_downconvert_worker. * So return 0 here and let VFS retry. */ ret = 0; goto out; } /* * Call ocfs2_write_begin() and ocfs2_write_end() to take * advantage of the allocation code there. We pass a write * length of the whole page (chopped to i_size) to make sure * the whole thing is allocated. * * Since we know the page is up to date, we don't have to * worry about ocfs2_write_begin() skipping some buffer reads * because the "write" would invalidate their data. */ if (page->index == last_index) len = size & ~PAGE_CACHE_MASK; ret = ocfs2_write_begin_nolock(mapping, pos, len, 0, &locked_page, &fsdata, di_bh, page); if (ret) { if (ret != -ENOSPC) mlog_errno(ret); goto out; } ret = ocfs2_write_end_nolock(mapping, pos, len, len, locked_page, fsdata); if (ret < 0) { mlog_errno(ret); goto out; } BUG_ON(ret != len); ret = 0; out: return ret; }