1 /* 2 * linux/fs/9p/vfs_addr.c 3 * 4 * This file contians vfs address (mmap) ops for 9P2000. 5 * 6 * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com> 7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 11 * as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to: 20 * Free Software Foundation 21 * 51 Franklin Street, Fifth Floor 22 * Boston, MA 02111-1301 USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/fs.h> 29 #include <linux/file.h> 30 #include <linux/stat.h> 31 #include <linux/string.h> 32 #include <linux/inet.h> 33 #include <linux/pagemap.h> 34 #include <linux/idr.h> 35 #include <linux/sched.h> 36 #include <linux/aio.h> 37 #include <net/9p/9p.h> 38 #include <net/9p/client.h> 39 40 #include "v9fs.h" 41 #include "v9fs_vfs.h" 42 #include "cache.h" 43 #include "fid.h" 44 45 /** 46 * v9fs_fid_readpage - read an entire page in from 9P 47 * 48 * @fid: fid being read 49 * @page: structure to page 50 * 51 */ 52 static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page) 53 { 54 int retval; 55 loff_t offset; 56 char *buffer; 57 struct inode *inode; 58 59 inode = page->mapping->host; 60 p9_debug(P9_DEBUG_VFS, "\n"); 61 62 BUG_ON(!PageLocked(page)); 63 64 retval = v9fs_readpage_from_fscache(inode, page); 65 if (retval == 0) 66 return retval; 67 68 buffer = kmap(page); 69 offset = page_offset(page); 70 71 retval = v9fs_fid_readn(fid, buffer, NULL, PAGE_CACHE_SIZE, offset); 72 if (retval < 0) { 73 v9fs_uncache_page(inode, page); 74 goto done; 75 } 76 77 memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval); 78 flush_dcache_page(page); 79 SetPageUptodate(page); 80 81 v9fs_readpage_to_fscache(inode, page); 82 retval = 0; 83 84 done: 85 kunmap(page); 86 unlock_page(page); 87 return retval; 88 } 89 90 /** 91 * v9fs_vfs_readpage - read an entire page in from 9P 92 * 93 * @filp: file being read 94 * @page: structure to page 95 * 96 */ 97 98 static int v9fs_vfs_readpage(struct file *filp, struct page *page) 99 { 100 return v9fs_fid_readpage(filp->private_data, page); 101 } 102 103 /** 104 * v9fs_vfs_readpages - read a set of pages from 9P 105 * 106 * @filp: file being read 107 * @mapping: the address space 108 * @pages: list of pages to read 109 * @nr_pages: count of pages to read 110 * 111 */ 112 113 static int v9fs_vfs_readpages(struct file *filp, struct address_space *mapping, 114 struct list_head *pages, unsigned nr_pages) 115 { 116 int ret = 0; 117 struct inode *inode; 118 119 inode = mapping->host; 120 p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, filp); 121 122 ret = v9fs_readpages_from_fscache(inode, mapping, pages, &nr_pages); 123 if (ret == 0) 124 return ret; 125 126 ret = read_cache_pages(mapping, pages, (void *)v9fs_vfs_readpage, filp); 127 p9_debug(P9_DEBUG_VFS, " = %d\n", ret); 128 return ret; 129 } 130 131 /** 132 * v9fs_release_page - release the private state associated with a page 133 * 134 * Returns 1 if the page can be released, false otherwise. 135 */ 136 137 static int v9fs_release_page(struct page *page, gfp_t gfp) 138 { 139 if (PagePrivate(page)) 140 return 0; 141 return v9fs_fscache_release_page(page, gfp); 142 } 143 144 /** 145 * v9fs_invalidate_page - Invalidate a page completely or partially 146 * 147 * @page: structure to page 148 * @offset: offset in the page 149 */ 150 151 static void v9fs_invalidate_page(struct page *page, unsigned long offset) 152 { 153 /* 154 * If called with zero offset, we should release 155 * the private state assocated with the page 156 */ 157 if (offset == 0) 158 v9fs_fscache_invalidate_page(page); 159 } 160 161 static int v9fs_vfs_writepage_locked(struct page *page) 162 { 163 char *buffer; 164 int retval, len; 165 loff_t offset, size; 166 mm_segment_t old_fs; 167 struct v9fs_inode *v9inode; 168 struct inode *inode = page->mapping->host; 169 170 v9inode = V9FS_I(inode); 171 size = i_size_read(inode); 172 if (page->index == size >> PAGE_CACHE_SHIFT) 173 len = size & ~PAGE_CACHE_MASK; 174 else 175 len = PAGE_CACHE_SIZE; 176 177 set_page_writeback(page); 178 179 buffer = kmap(page); 180 offset = page_offset(page); 181 182 old_fs = get_fs(); 183 set_fs(get_ds()); 184 /* We should have writeback_fid always set */ 185 BUG_ON(!v9inode->writeback_fid); 186 187 retval = v9fs_file_write_internal(inode, 188 v9inode->writeback_fid, 189 (__force const char __user *)buffer, 190 len, &offset, 0); 191 if (retval > 0) 192 retval = 0; 193 194 set_fs(old_fs); 195 kunmap(page); 196 end_page_writeback(page); 197 return retval; 198 } 199 200 static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc) 201 { 202 int retval; 203 204 retval = v9fs_vfs_writepage_locked(page); 205 if (retval < 0) { 206 if (retval == -EAGAIN) { 207 redirty_page_for_writepage(wbc, page); 208 retval = 0; 209 } else { 210 SetPageError(page); 211 mapping_set_error(page->mapping, retval); 212 } 213 } else 214 retval = 0; 215 216 unlock_page(page); 217 return retval; 218 } 219 220 /** 221 * v9fs_launder_page - Writeback a dirty page 222 * Returns 0 on success. 223 */ 224 225 static int v9fs_launder_page(struct page *page) 226 { 227 int retval; 228 struct inode *inode = page->mapping->host; 229 230 v9fs_fscache_wait_on_page_write(inode, page); 231 if (clear_page_dirty_for_io(page)) { 232 retval = v9fs_vfs_writepage_locked(page); 233 if (retval) 234 return retval; 235 } 236 return 0; 237 } 238 239 /** 240 * v9fs_direct_IO - 9P address space operation for direct I/O 241 * @rw: direction (read or write) 242 * @iocb: target I/O control block 243 * @iov: array of vectors that define I/O buffer 244 * @pos: offset in file to begin the operation 245 * @nr_segs: size of iovec array 246 * 247 * The presence of v9fs_direct_IO() in the address space ops vector 248 * allowes open() O_DIRECT flags which would have failed otherwise. 249 * 250 * In the non-cached mode, we shunt off direct read and write requests before 251 * the VFS gets them, so this method should never be called. 252 * 253 * Direct IO is not 'yet' supported in the cached mode. Hence when 254 * this routine is called through generic_file_aio_read(), the read/write fails 255 * with an error. 256 * 257 */ 258 static ssize_t 259 v9fs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, 260 loff_t pos, unsigned long nr_segs) 261 { 262 /* 263 * FIXME 264 * Now that we do caching with cache mode enabled, We need 265 * to support direct IO 266 */ 267 p9_debug(P9_DEBUG_VFS, "v9fs_direct_IO: v9fs_direct_IO (%s) off/no(%lld/%lu) EINVAL\n", 268 iocb->ki_filp->f_path.dentry->d_name.name, 269 (long long)pos, nr_segs); 270 271 return -EINVAL; 272 } 273 274 static int v9fs_write_begin(struct file *filp, struct address_space *mapping, 275 loff_t pos, unsigned len, unsigned flags, 276 struct page **pagep, void **fsdata) 277 { 278 int retval = 0; 279 struct page *page; 280 struct v9fs_inode *v9inode; 281 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 282 struct inode *inode = mapping->host; 283 284 v9inode = V9FS_I(inode); 285 start: 286 page = grab_cache_page_write_begin(mapping, index, flags); 287 if (!page) { 288 retval = -ENOMEM; 289 goto out; 290 } 291 BUG_ON(!v9inode->writeback_fid); 292 if (PageUptodate(page)) 293 goto out; 294 295 if (len == PAGE_CACHE_SIZE) 296 goto out; 297 298 retval = v9fs_fid_readpage(v9inode->writeback_fid, page); 299 page_cache_release(page); 300 if (!retval) 301 goto start; 302 out: 303 *pagep = page; 304 return retval; 305 } 306 307 static int v9fs_write_end(struct file *filp, struct address_space *mapping, 308 loff_t pos, unsigned len, unsigned copied, 309 struct page *page, void *fsdata) 310 { 311 loff_t last_pos = pos + copied; 312 struct inode *inode = page->mapping->host; 313 314 if (unlikely(copied < len)) { 315 /* 316 * zero out the rest of the area 317 */ 318 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 319 320 zero_user(page, from + copied, len - copied); 321 flush_dcache_page(page); 322 } 323 324 if (!PageUptodate(page)) 325 SetPageUptodate(page); 326 /* 327 * No need to use i_size_read() here, the i_size 328 * cannot change under us because we hold the i_mutex. 329 */ 330 if (last_pos > inode->i_size) { 331 inode_add_bytes(inode, last_pos - inode->i_size); 332 i_size_write(inode, last_pos); 333 } 334 set_page_dirty(page); 335 unlock_page(page); 336 page_cache_release(page); 337 338 return copied; 339 } 340 341 342 const struct address_space_operations v9fs_addr_operations = { 343 .readpage = v9fs_vfs_readpage, 344 .readpages = v9fs_vfs_readpages, 345 .set_page_dirty = __set_page_dirty_nobuffers, 346 .writepage = v9fs_vfs_writepage, 347 .write_begin = v9fs_write_begin, 348 .write_end = v9fs_write_end, 349 .releasepage = v9fs_release_page, 350 .invalidatepage = v9fs_invalidate_page, 351 .launder_page = v9fs_launder_page, 352 .direct_IO = v9fs_direct_IO, 353 }; 354