1 /* AFS filesystem file handling 2 * 3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/slab.h> 16 #include <linux/fs.h> 17 #include <linux/pagemap.h> 18 #include <linux/writeback.h> 19 #include "internal.h" 20 21 static int afs_readpage(struct file *file, struct page *page); 22 static void afs_invalidatepage(struct page *page, unsigned long offset); 23 static int afs_releasepage(struct page *page, gfp_t gfp_flags); 24 static int afs_launder_page(struct page *page); 25 26 static int afs_readpages(struct file *filp, struct address_space *mapping, 27 struct list_head *pages, unsigned nr_pages); 28 29 const struct file_operations afs_file_operations = { 30 .open = afs_open, 31 .release = afs_release, 32 .llseek = generic_file_llseek, 33 .read = do_sync_read, 34 .write = do_sync_write, 35 .aio_read = generic_file_aio_read, 36 .aio_write = afs_file_write, 37 .mmap = generic_file_readonly_mmap, 38 .splice_read = generic_file_splice_read, 39 .fsync = afs_fsync, 40 .lock = afs_lock, 41 .flock = afs_flock, 42 }; 43 44 const struct inode_operations afs_file_inode_operations = { 45 .getattr = afs_getattr, 46 .setattr = afs_setattr, 47 .permission = afs_permission, 48 }; 49 50 const struct address_space_operations afs_fs_aops = { 51 .readpage = afs_readpage, 52 .readpages = afs_readpages, 53 .set_page_dirty = afs_set_page_dirty, 54 .launder_page = afs_launder_page, 55 .releasepage = afs_releasepage, 56 .invalidatepage = afs_invalidatepage, 57 .write_begin = afs_write_begin, 58 .write_end = afs_write_end, 59 .writepage = afs_writepage, 60 .writepages = afs_writepages, 61 }; 62 63 /* 64 * open an AFS file or directory and attach a key to it 65 */ 66 int afs_open(struct inode *inode, struct file *file) 67 { 68 struct afs_vnode *vnode = AFS_FS_I(inode); 69 struct key *key; 70 int ret; 71 72 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); 73 74 key = afs_request_key(vnode->volume->cell); 75 if (IS_ERR(key)) { 76 _leave(" = %ld [key]", PTR_ERR(key)); 77 return PTR_ERR(key); 78 } 79 80 ret = afs_validate(vnode, key); 81 if (ret < 0) { 82 _leave(" = %d [val]", ret); 83 return ret; 84 } 85 86 file->private_data = key; 87 _leave(" = 0"); 88 return 0; 89 } 90 91 /* 92 * release an AFS file or directory and discard its key 93 */ 94 int afs_release(struct inode *inode, struct file *file) 95 { 96 struct afs_vnode *vnode = AFS_FS_I(inode); 97 98 _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode); 99 100 key_put(file->private_data); 101 _leave(" = 0"); 102 return 0; 103 } 104 105 #ifdef CONFIG_AFS_FSCACHE 106 /* 107 * deal with notification that a page was read from the cache 108 */ 109 static void afs_file_readpage_read_complete(struct page *page, 110 void *data, 111 int error) 112 { 113 _enter("%p,%p,%d", page, data, error); 114 115 /* if the read completes with an error, we just unlock the page and let 116 * the VM reissue the readpage */ 117 if (!error) 118 SetPageUptodate(page); 119 unlock_page(page); 120 } 121 #endif 122 123 /* 124 * AFS read page from file, directory or symlink 125 */ 126 static int afs_readpage(struct file *file, struct page *page) 127 { 128 struct afs_vnode *vnode; 129 struct inode *inode; 130 struct key *key; 131 size_t len; 132 off_t offset; 133 int ret; 134 135 inode = page->mapping->host; 136 137 if (file) { 138 key = file->private_data; 139 ASSERT(key != NULL); 140 } else { 141 key = afs_request_key(AFS_FS_S(inode->i_sb)->volume->cell); 142 if (IS_ERR(key)) { 143 ret = PTR_ERR(key); 144 goto error_nokey; 145 } 146 } 147 148 _enter("{%x},{%lu},{%lu}", key_serial(key), inode->i_ino, page->index); 149 150 vnode = AFS_FS_I(inode); 151 152 BUG_ON(!PageLocked(page)); 153 154 ret = -ESTALE; 155 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 156 goto error; 157 158 /* is it cached? */ 159 #ifdef CONFIG_AFS_FSCACHE 160 ret = fscache_read_or_alloc_page(vnode->cache, 161 page, 162 afs_file_readpage_read_complete, 163 NULL, 164 GFP_KERNEL); 165 #else 166 ret = -ENOBUFS; 167 #endif 168 switch (ret) { 169 /* read BIO submitted (page in cache) */ 170 case 0: 171 break; 172 173 /* page not yet cached */ 174 case -ENODATA: 175 _debug("cache said ENODATA"); 176 goto go_on; 177 178 /* page will not be cached */ 179 case -ENOBUFS: 180 _debug("cache said ENOBUFS"); 181 default: 182 go_on: 183 offset = page->index << PAGE_CACHE_SHIFT; 184 len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE); 185 186 /* read the contents of the file from the server into the 187 * page */ 188 ret = afs_vnode_fetch_data(vnode, key, offset, len, page); 189 if (ret < 0) { 190 if (ret == -ENOENT) { 191 _debug("got NOENT from server" 192 " - marking file deleted and stale"); 193 set_bit(AFS_VNODE_DELETED, &vnode->flags); 194 ret = -ESTALE; 195 } 196 197 #ifdef CONFIG_AFS_FSCACHE 198 fscache_uncache_page(vnode->cache, page); 199 #endif 200 BUG_ON(PageFsCache(page)); 201 goto error; 202 } 203 204 SetPageUptodate(page); 205 206 /* send the page to the cache */ 207 #ifdef CONFIG_AFS_FSCACHE 208 if (PageFsCache(page) && 209 fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) { 210 fscache_uncache_page(vnode->cache, page); 211 BUG_ON(PageFsCache(page)); 212 } 213 #endif 214 unlock_page(page); 215 } 216 217 if (!file) 218 key_put(key); 219 _leave(" = 0"); 220 return 0; 221 222 error: 223 SetPageError(page); 224 unlock_page(page); 225 if (!file) 226 key_put(key); 227 error_nokey: 228 _leave(" = %d", ret); 229 return ret; 230 } 231 232 /* 233 * read a set of pages 234 */ 235 static int afs_readpages(struct file *file, struct address_space *mapping, 236 struct list_head *pages, unsigned nr_pages) 237 { 238 struct afs_vnode *vnode; 239 int ret = 0; 240 241 _enter(",{%lu},,%d", mapping->host->i_ino, nr_pages); 242 243 vnode = AFS_FS_I(mapping->host); 244 if (vnode->flags & AFS_VNODE_DELETED) { 245 _leave(" = -ESTALE"); 246 return -ESTALE; 247 } 248 249 /* attempt to read as many of the pages as possible */ 250 #ifdef CONFIG_AFS_FSCACHE 251 ret = fscache_read_or_alloc_pages(vnode->cache, 252 mapping, 253 pages, 254 &nr_pages, 255 afs_file_readpage_read_complete, 256 NULL, 257 mapping_gfp_mask(mapping)); 258 #else 259 ret = -ENOBUFS; 260 #endif 261 262 switch (ret) { 263 /* all pages are being read from the cache */ 264 case 0: 265 BUG_ON(!list_empty(pages)); 266 BUG_ON(nr_pages != 0); 267 _leave(" = 0 [reading all]"); 268 return 0; 269 270 /* there were pages that couldn't be read from the cache */ 271 case -ENODATA: 272 case -ENOBUFS: 273 break; 274 275 /* other error */ 276 default: 277 _leave(" = %d", ret); 278 return ret; 279 } 280 281 /* load the missing pages from the network */ 282 ret = read_cache_pages(mapping, pages, (void *) afs_readpage, file); 283 284 _leave(" = %d [netting]", ret); 285 return ret; 286 } 287 288 /* 289 * write back a dirty page 290 */ 291 static int afs_launder_page(struct page *page) 292 { 293 _enter("{%lu}", page->index); 294 295 return 0; 296 } 297 298 /* 299 * invalidate part or all of a page 300 * - release a page and clean up its private data if offset is 0 (indicating 301 * the entire page) 302 */ 303 static void afs_invalidatepage(struct page *page, unsigned long offset) 304 { 305 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 306 307 _enter("{%lu},%lu", page->index, offset); 308 309 BUG_ON(!PageLocked(page)); 310 311 /* we clean up only if the entire page is being invalidated */ 312 if (offset == 0) { 313 #ifdef CONFIG_AFS_FSCACHE 314 if (PageFsCache(page)) { 315 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); 316 fscache_wait_on_page_write(vnode->cache, page); 317 fscache_uncache_page(vnode->cache, page); 318 } 319 #endif 320 321 if (PagePrivate(page)) { 322 if (wb && !PageWriteback(page)) { 323 set_page_private(page, 0); 324 afs_put_writeback(wb); 325 } 326 327 if (!page_private(page)) 328 ClearPagePrivate(page); 329 } 330 } 331 332 _leave(""); 333 } 334 335 /* 336 * release a page and clean up its private state if it's not busy 337 * - return true if the page can now be released, false if not 338 */ 339 static int afs_releasepage(struct page *page, gfp_t gfp_flags) 340 { 341 struct afs_writeback *wb = (struct afs_writeback *) page_private(page); 342 struct afs_vnode *vnode = AFS_FS_I(page->mapping->host); 343 344 _enter("{{%x:%u}[%lu],%lx},%x", 345 vnode->fid.vid, vnode->fid.vnode, page->index, page->flags, 346 gfp_flags); 347 348 /* deny if page is being written to the cache and the caller hasn't 349 * elected to wait */ 350 #ifdef CONFIG_AFS_FSCACHE 351 if (!fscache_maybe_release_page(vnode->cache, page, gfp_flags)) { 352 _leave(" = F [cache busy]"); 353 return 0; 354 } 355 #endif 356 357 if (PagePrivate(page)) { 358 if (wb) { 359 set_page_private(page, 0); 360 afs_put_writeback(wb); 361 } 362 ClearPagePrivate(page); 363 } 364 365 /* indicate that the page can be released */ 366 _leave(" = T"); 367 return 1; 368 } 369