linux/fs/cachefiles/rdwr.c
<<
>>
Prefs
   1/* Storage object read/write
   2 *
   3 * Copyright (C) 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 Licence
   8 * as published by the Free Software Foundation; either version
   9 * 2 of the Licence, or (at your option) any later version.
  10 */
  11
  12#include <linux/mount.h>
  13#include <linux/slab.h>
  14#include <linux/file.h>
  15#include "internal.h"
  16
  17/*
  18 * detect wake up events generated by the unlocking of pages in which we're
  19 * interested
  20 * - we use this to detect read completion of backing pages
  21 * - the caller holds the waitqueue lock
  22 */
  23static int cachefiles_read_waiter(wait_queue_t *wait, unsigned mode,
  24                                  int sync, void *_key)
  25{
  26        struct cachefiles_one_read *monitor =
  27                container_of(wait, struct cachefiles_one_read, monitor);
  28        struct cachefiles_object *object;
  29        struct wait_bit_key *key = _key;
  30        struct page *page = wait->private;
  31
  32        ASSERT(key);
  33
  34        _enter("{%lu},%u,%d,{%p,%u}",
  35               monitor->netfs_page->index, mode, sync,
  36               key->flags, key->bit_nr);
  37
  38        if (key->flags != &page->flags ||
  39            key->bit_nr != PG_locked)
  40                return 0;
  41
  42        _debug("--- monitor %p %lx ---", page, page->flags);
  43
  44        if (!PageUptodate(page) && !PageError(page)) {
  45                /* unlocked, not uptodate and not erronous? */
  46                _debug("page probably truncated");
  47        }
  48
  49        /* remove from the waitqueue */
  50        list_del(&wait->task_list);
  51
  52        /* move onto the action list and queue for FS-Cache thread pool */
  53        ASSERT(monitor->op);
  54
  55        object = container_of(monitor->op->op.object,
  56                              struct cachefiles_object, fscache);
  57
  58        spin_lock(&object->work_lock);
  59        list_add_tail(&monitor->op_link, &monitor->op->to_do);
  60        spin_unlock(&object->work_lock);
  61
  62        fscache_enqueue_retrieval(monitor->op);
  63        return 0;
  64}
  65
  66/*
  67 * handle a probably truncated page
  68 * - check to see if the page is still relevant and reissue the read if
  69 *   possible
  70 * - return -EIO on error, -ENODATA if the page is gone, -EINPROGRESS if we
  71 *   must wait again and 0 if successful
  72 */
  73static int cachefiles_read_reissue(struct cachefiles_object *object,
  74                                   struct cachefiles_one_read *monitor)
  75{
  76        struct address_space *bmapping = object->backer->d_inode->i_mapping;
  77        struct page *backpage = monitor->back_page, *backpage2;
  78        int ret;
  79
  80        kenter("{ino=%lx},{%lx,%lx}",
  81               object->backer->d_inode->i_ino,
  82               backpage->index, backpage->flags);
  83
  84        /* skip if the page was truncated away completely */
  85        if (backpage->mapping != bmapping) {
  86                kleave(" = -ENODATA [mapping]");
  87                return -ENODATA;
  88        }
  89
  90        backpage2 = find_get_page(bmapping, backpage->index);
  91        if (!backpage2) {
  92                kleave(" = -ENODATA [gone]");
  93                return -ENODATA;
  94        }
  95
  96        if (backpage != backpage2) {
  97                put_page(backpage2);
  98                kleave(" = -ENODATA [different]");
  99                return -ENODATA;
 100        }
 101
 102        /* the page is still there and we already have a ref on it, so we don't
 103         * need a second */
 104        put_page(backpage2);
 105
 106        INIT_LIST_HEAD(&monitor->op_link);
 107        add_page_wait_queue(backpage, &monitor->monitor);
 108
 109        if (trylock_page(backpage)) {
 110                ret = -EIO;
 111                if (PageError(backpage))
 112                        goto unlock_discard;
 113                ret = 0;
 114                if (PageUptodate(backpage))
 115                        goto unlock_discard;
 116
 117                kdebug("reissue read");
 118                ret = bmapping->a_ops->readpage(NULL, backpage);
 119                if (ret < 0)
 120                        goto unlock_discard;
 121        }
 122
 123        /* but the page may have been read before the monitor was installed, so
 124         * the monitor may miss the event - so we have to ensure that we do get
 125         * one in such a case */
 126        if (trylock_page(backpage)) {
 127                _debug("jumpstart %p {%lx}", backpage, backpage->flags);
 128                unlock_page(backpage);
 129        }
 130
 131        /* it'll reappear on the todo list */
 132        kleave(" = -EINPROGRESS");
 133        return -EINPROGRESS;
 134
 135unlock_discard:
 136        unlock_page(backpage);
 137        spin_lock_irq(&object->work_lock);
 138        list_del(&monitor->op_link);
 139        spin_unlock_irq(&object->work_lock);
 140        kleave(" = %d", ret);
 141        return ret;
 142}
 143
 144/*
 145 * copy data from backing pages to netfs pages to complete a read operation
 146 * - driven by FS-Cache's thread pool
 147 */
 148static void cachefiles_read_copier(struct fscache_operation *_op)
 149{
 150        struct cachefiles_one_read *monitor;
 151        struct cachefiles_object *object;
 152        struct fscache_retrieval *op;
 153        struct pagevec pagevec;
 154        int error, max;
 155
 156        op = container_of(_op, struct fscache_retrieval, op);
 157        object = container_of(op->op.object,
 158                              struct cachefiles_object, fscache);
 159
 160        _enter("{ino=%lu}", object->backer->d_inode->i_ino);
 161
 162        pagevec_init(&pagevec, 0);
 163
 164        max = 8;
 165        spin_lock_irq(&object->work_lock);
 166
 167        while (!list_empty(&op->to_do)) {
 168                monitor = list_entry(op->to_do.next,
 169                                     struct cachefiles_one_read, op_link);
 170                list_del(&monitor->op_link);
 171
 172                spin_unlock_irq(&object->work_lock);
 173
 174                _debug("- copy {%lu}", monitor->back_page->index);
 175
 176        recheck:
 177                if (PageUptodate(monitor->back_page)) {
 178                        copy_highpage(monitor->netfs_page, monitor->back_page);
 179
 180                        pagevec_add(&pagevec, monitor->netfs_page);
 181                        fscache_mark_pages_cached(monitor->op, &pagevec);
 182                        error = 0;
 183                } else if (!PageError(monitor->back_page)) {
 184                        /* the page has probably been truncated */
 185                        error = cachefiles_read_reissue(object, monitor);
 186                        if (error == -EINPROGRESS)
 187                                goto next;
 188                        goto recheck;
 189                } else {
 190                        cachefiles_io_error_obj(
 191                                object,
 192                                "Readpage failed on backing file %lx",
 193                                (unsigned long) monitor->back_page->flags);
 194                        error = -EIO;
 195                }
 196
 197                page_cache_release(monitor->back_page);
 198
 199                fscache_end_io(op, monitor->netfs_page, error);
 200                page_cache_release(monitor->netfs_page);
 201                fscache_put_retrieval(op);
 202                kfree(monitor);
 203
 204        next:
 205                /* let the thread pool have some air occasionally */
 206                max--;
 207                if (max < 0 || need_resched()) {
 208                        if (!list_empty(&op->to_do))
 209                                fscache_enqueue_retrieval(op);
 210                        _leave(" [maxed out]");
 211                        return;
 212                }
 213
 214                spin_lock_irq(&object->work_lock);
 215        }
 216
 217        spin_unlock_irq(&object->work_lock);
 218        _leave("");
 219}
 220
 221/*
 222 * read the corresponding page to the given set from the backing file
 223 * - an uncertain page is simply discarded, to be tried again another time
 224 */
 225static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
 226                                            struct fscache_retrieval *op,
 227                                            struct page *netpage,
 228                                            struct pagevec *pagevec)
 229{
 230        struct cachefiles_one_read *monitor;
 231        struct address_space *bmapping;
 232        struct page *newpage, *backpage;
 233        int ret;
 234
 235        _enter("");
 236
 237        pagevec_reinit(pagevec);
 238
 239        _debug("read back %p{%lu,%d}",
 240               netpage, netpage->index, page_count(netpage));
 241
 242        monitor = kzalloc(sizeof(*monitor), GFP_KERNEL);
 243        if (!monitor)
 244                goto nomem;
 245
 246        monitor->netfs_page = netpage;
 247        monitor->op = fscache_get_retrieval(op);
 248
 249        init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter);
 250
 251        /* attempt to get hold of the backing page */
 252        bmapping = object->backer->d_inode->i_mapping;
 253        newpage = NULL;
 254
 255        for (;;) {
 256                backpage = find_get_page(bmapping, netpage->index);
 257                if (backpage)
 258                        goto backing_page_already_present;
 259
 260                if (!newpage) {
 261                        newpage = page_cache_alloc_cold(bmapping);
 262                        if (!newpage)
 263                                goto nomem_monitor;
 264                }
 265
 266                ret = add_to_page_cache(newpage, bmapping,
 267                                        netpage->index, GFP_KERNEL);
 268                if (ret == 0)
 269                        goto installed_new_backing_page;
 270                if (ret != -EEXIST)
 271                        goto nomem_page;
 272        }
 273
 274        /* we've installed a new backing page, so now we need to add it
 275         * to the LRU list and start it reading */
 276installed_new_backing_page:
 277        _debug("- new %p", newpage);
 278
 279        backpage = newpage;
 280        newpage = NULL;
 281
 282        page_cache_get(backpage);
 283        pagevec_add(pagevec, backpage);
 284        __pagevec_lru_add_file(pagevec);
 285
 286read_backing_page:
 287        ret = bmapping->a_ops->readpage(NULL, backpage);
 288        if (ret < 0)
 289                goto read_error;
 290
 291        /* set the monitor to transfer the data across */
 292monitor_backing_page:
 293        _debug("- monitor add");
 294
 295        /* install the monitor */
 296        page_cache_get(monitor->netfs_page);
 297        page_cache_get(backpage);
 298        monitor->back_page = backpage;
 299        monitor->monitor.private = backpage;
 300        add_page_wait_queue(backpage, &monitor->monitor);
 301        monitor = NULL;
 302
 303        /* but the page may have been read before the monitor was installed, so
 304         * the monitor may miss the event - so we have to ensure that we do get
 305         * one in such a case */
 306        if (trylock_page(backpage)) {
 307                _debug("jumpstart %p {%lx}", backpage, backpage->flags);
 308                unlock_page(backpage);
 309        }
 310        goto success;
 311
 312        /* if the backing page is already present, it can be in one of
 313         * three states: read in progress, read failed or read okay */
 314backing_page_already_present:
 315        _debug("- present");
 316
 317        if (newpage) {
 318                page_cache_release(newpage);
 319                newpage = NULL;
 320        }
 321
 322        if (PageError(backpage))
 323                goto io_error;
 324
 325        if (PageUptodate(backpage))
 326                goto backing_page_already_uptodate;
 327
 328        if (!trylock_page(backpage))
 329                goto monitor_backing_page;
 330        _debug("read %p {%lx}", backpage, backpage->flags);
 331        goto read_backing_page;
 332
 333        /* the backing page is already up to date, attach the netfs
 334         * page to the pagecache and LRU and copy the data across */
 335backing_page_already_uptodate:
 336        _debug("- uptodate");
 337
 338        pagevec_add(pagevec, netpage);
 339        fscache_mark_pages_cached(op, pagevec);
 340
 341        copy_highpage(netpage, backpage);
 342        fscache_end_io(op, netpage, 0);
 343
 344success:
 345        _debug("success");
 346        ret = 0;
 347
 348out:
 349        if (backpage)
 350                page_cache_release(backpage);
 351        if (monitor) {
 352                fscache_put_retrieval(monitor->op);
 353                kfree(monitor);
 354        }
 355        _leave(" = %d", ret);
 356        return ret;
 357
 358read_error:
 359        _debug("read error %d", ret);
 360        if (ret == -ENOMEM)
 361                goto out;
 362io_error:
 363        cachefiles_io_error_obj(object, "Page read error on backing file");
 364        ret = -ENOBUFS;
 365        goto out;
 366
 367nomem_page:
 368        page_cache_release(newpage);
 369nomem_monitor:
 370        fscache_put_retrieval(monitor->op);
 371        kfree(monitor);
 372nomem:
 373        _leave(" = -ENOMEM");
 374        return -ENOMEM;
 375}
 376
 377/*
 378 * read a page from the cache or allocate a block in which to store it
 379 * - cache withdrawal is prevented by the caller
 380 * - returns -EINTR if interrupted
 381 * - returns -ENOMEM if ran out of memory
 382 * - returns -ENOBUFS if no buffers can be made available
 383 * - returns -ENOBUFS if page is beyond EOF
 384 * - if the page is backed by a block in the cache:
 385 *   - a read will be started which will call the callback on completion
 386 *   - 0 will be returned
 387 * - else if the page is unbacked:
 388 *   - the metadata will be retained
 389 *   - -ENODATA will be returned
 390 */
 391int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,
 392                                  struct page *page,
 393                                  gfp_t gfp)
 394{
 395        struct cachefiles_object *object;
 396        struct cachefiles_cache *cache;
 397        struct pagevec pagevec;
 398        struct inode *inode;
 399        sector_t block0, block;
 400        unsigned shift;
 401        int ret;
 402
 403        object = container_of(op->op.object,
 404                              struct cachefiles_object, fscache);
 405        cache = container_of(object->fscache.cache,
 406                             struct cachefiles_cache, cache);
 407
 408        _enter("{%p},{%lx},,,", object, page->index);
 409
 410        if (!object->backer)
 411                return -ENOBUFS;
 412
 413        inode = object->backer->d_inode;
 414        ASSERT(S_ISREG(inode->i_mode));
 415        ASSERT(inode->i_mapping->a_ops->bmap);
 416        ASSERT(inode->i_mapping->a_ops->readpages);
 417
 418        /* calculate the shift required to use bmap */
 419        if (inode->i_sb->s_blocksize > PAGE_SIZE)
 420                return -ENOBUFS;
 421
 422        shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
 423
 424        op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
 425        op->op.flags |= FSCACHE_OP_ASYNC;
 426        op->op.processor = cachefiles_read_copier;
 427
 428        pagevec_init(&pagevec, 0);
 429
 430        /* we assume the absence or presence of the first block is a good
 431         * enough indication for the page as a whole
 432         * - TODO: don't use bmap() for this as it is _not_ actually good
 433         *   enough for this as it doesn't indicate errors, but it's all we've
 434         *   got for the moment
 435         */
 436        block0 = page->index;
 437        block0 <<= shift;
 438
 439        block = inode->i_mapping->a_ops->bmap(inode->i_mapping, block0);
 440        _debug("%llx -> %llx",
 441               (unsigned long long) block0,
 442               (unsigned long long) block);
 443
 444        if (block) {
 445                /* submit the apparently valid page to the backing fs to be
 446                 * read from disk */
 447                ret = cachefiles_read_backing_file_one(object, op, page,
 448                                                       &pagevec);
 449        } else if (cachefiles_has_space(cache, 0, 1) == 0) {
 450                /* there's space in the cache we can use */
 451                pagevec_add(&pagevec, page);
 452                fscache_mark_pages_cached(op, &pagevec);
 453                ret = -ENODATA;
 454        } else {
 455                ret = -ENOBUFS;
 456        }
 457
 458        _leave(" = %d", ret);
 459        return ret;
 460}
 461
 462/*
 463 * read the corresponding pages to the given set from the backing file
 464 * - any uncertain pages are simply discarded, to be tried again another time
 465 */
 466static int cachefiles_read_backing_file(struct cachefiles_object *object,
 467                                        struct fscache_retrieval *op,
 468                                        struct list_head *list,
 469                                        struct pagevec *mark_pvec)
 470{
 471        struct cachefiles_one_read *monitor = NULL;
 472        struct address_space *bmapping = object->backer->d_inode->i_mapping;
 473        struct pagevec lru_pvec;
 474        struct page *newpage = NULL, *netpage, *_n, *backpage = NULL;
 475        int ret = 0;
 476
 477        _enter("");
 478
 479        pagevec_init(&lru_pvec, 0);
 480
 481        list_for_each_entry_safe(netpage, _n, list, lru) {
 482                list_del(&netpage->lru);
 483
 484                _debug("read back %p{%lu,%d}",
 485                       netpage, netpage->index, page_count(netpage));
 486
 487                if (!monitor) {
 488                        monitor = kzalloc(sizeof(*monitor), GFP_KERNEL);
 489                        if (!monitor)
 490                                goto nomem;
 491
 492                        monitor->op = fscache_get_retrieval(op);
 493                        init_waitqueue_func_entry(&monitor->monitor,
 494                                                  cachefiles_read_waiter);
 495                }
 496
 497                for (;;) {
 498                        backpage = find_get_page(bmapping, netpage->index);
 499                        if (backpage)
 500                                goto backing_page_already_present;
 501
 502                        if (!newpage) {
 503                                newpage = page_cache_alloc_cold(bmapping);
 504                                if (!newpage)
 505                                        goto nomem;
 506                        }
 507
 508                        ret = add_to_page_cache(newpage, bmapping,
 509                                                netpage->index, GFP_KERNEL);
 510                        if (ret == 0)
 511                                goto installed_new_backing_page;
 512                        if (ret != -EEXIST)
 513                                goto nomem;
 514                }
 515
 516                /* we've installed a new backing page, so now we need to add it
 517                 * to the LRU list and start it reading */
 518        installed_new_backing_page:
 519                _debug("- new %p", newpage);
 520
 521                backpage = newpage;
 522                newpage = NULL;
 523
 524                page_cache_get(backpage);
 525                if (!pagevec_add(&lru_pvec, backpage))
 526                        __pagevec_lru_add_file(&lru_pvec);
 527
 528        reread_backing_page:
 529                ret = bmapping->a_ops->readpage(NULL, backpage);
 530                if (ret < 0)
 531                        goto read_error;
 532
 533                /* add the netfs page to the pagecache and LRU, and set the
 534                 * monitor to transfer the data across */
 535        monitor_backing_page:
 536                _debug("- monitor add");
 537
 538                ret = add_to_page_cache(netpage, op->mapping, netpage->index,
 539                                        GFP_KERNEL);
 540                if (ret < 0) {
 541                        if (ret == -EEXIST) {
 542                                page_cache_release(netpage);
 543                                continue;
 544                        }
 545                        goto nomem;
 546                }
 547
 548                page_cache_get(netpage);
 549                if (!pagevec_add(&lru_pvec, netpage))
 550                        __pagevec_lru_add_file(&lru_pvec);
 551
 552                /* install a monitor */
 553                page_cache_get(netpage);
 554                monitor->netfs_page = netpage;
 555
 556                page_cache_get(backpage);
 557                monitor->back_page = backpage;
 558                monitor->monitor.private = backpage;
 559                add_page_wait_queue(backpage, &monitor->monitor);
 560                monitor = NULL;
 561
 562                /* but the page may have been read before the monitor was
 563                 * installed, so the monitor may miss the event - so we have to
 564                 * ensure that we do get one in such a case */
 565                if (trylock_page(backpage)) {
 566                        _debug("2unlock %p {%lx}", backpage, backpage->flags);
 567                        unlock_page(backpage);
 568                }
 569
 570                page_cache_release(backpage);
 571                backpage = NULL;
 572
 573                page_cache_release(netpage);
 574                netpage = NULL;
 575                continue;
 576
 577                /* if the backing page is already present, it can be in one of
 578                 * three states: read in progress, read failed or read okay */
 579        backing_page_already_present:
 580                _debug("- present %p", backpage);
 581
 582                if (PageError(backpage))
 583                        goto io_error;
 584
 585                if (PageUptodate(backpage))
 586                        goto backing_page_already_uptodate;
 587
 588                _debug("- not ready %p{%lx}", backpage, backpage->flags);
 589
 590                if (!trylock_page(backpage))
 591                        goto monitor_backing_page;
 592
 593                if (PageError(backpage)) {
 594                        _debug("error %lx", backpage->flags);
 595                        unlock_page(backpage);
 596                        goto io_error;
 597                }
 598
 599                if (PageUptodate(backpage))
 600                        goto backing_page_already_uptodate_unlock;
 601
 602                /* we've locked a page that's neither up to date nor erroneous,
 603                 * so we need to attempt to read it again */
 604                goto reread_backing_page;
 605
 606                /* the backing page is already up to date, attach the netfs
 607                 * page to the pagecache and LRU and copy the data across */
 608        backing_page_already_uptodate_unlock:
 609                _debug("uptodate %lx", backpage->flags);
 610                unlock_page(backpage);
 611        backing_page_already_uptodate:
 612                _debug("- uptodate");
 613
 614                ret = add_to_page_cache(netpage, op->mapping, netpage->index,
 615                                        GFP_KERNEL);
 616                if (ret < 0) {
 617                        if (ret == -EEXIST) {
 618                                page_cache_release(netpage);
 619                                continue;
 620                        }
 621                        goto nomem;
 622                }
 623
 624                copy_highpage(netpage, backpage);
 625
 626                page_cache_release(backpage);
 627                backpage = NULL;
 628
 629                if (!pagevec_add(mark_pvec, netpage))
 630                        fscache_mark_pages_cached(op, mark_pvec);
 631
 632                page_cache_get(netpage);
 633                if (!pagevec_add(&lru_pvec, netpage))
 634                        __pagevec_lru_add_file(&lru_pvec);
 635
 636                fscache_end_io(op, netpage, 0);
 637                page_cache_release(netpage);
 638                netpage = NULL;
 639                continue;
 640        }
 641
 642        netpage = NULL;
 643
 644        _debug("out");
 645
 646out:
 647        /* tidy up */
 648        pagevec_lru_add_file(&lru_pvec);
 649
 650        if (newpage)
 651                page_cache_release(newpage);
 652        if (netpage)
 653                page_cache_release(netpage);
 654        if (backpage)
 655                page_cache_release(backpage);
 656        if (monitor) {
 657                fscache_put_retrieval(op);
 658                kfree(monitor);
 659        }
 660
 661        list_for_each_entry_safe(netpage, _n, list, lru) {
 662                list_del(&netpage->lru);
 663                page_cache_release(netpage);
 664        }
 665
 666        _leave(" = %d", ret);
 667        return ret;
 668
 669nomem:
 670        _debug("nomem");
 671        ret = -ENOMEM;
 672        goto out;
 673
 674read_error:
 675        _debug("read error %d", ret);
 676        if (ret == -ENOMEM)
 677                goto out;
 678io_error:
 679        cachefiles_io_error_obj(object, "Page read error on backing file");
 680        ret = -ENOBUFS;
 681        goto out;
 682}
 683
 684/*
 685 * read a list of pages from the cache or allocate blocks in which to store
 686 * them
 687 */
 688int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
 689                                   struct list_head *pages,
 690                                   unsigned *nr_pages,
 691                                   gfp_t gfp)
 692{
 693        struct cachefiles_object *object;
 694        struct cachefiles_cache *cache;
 695        struct list_head backpages;
 696        struct pagevec pagevec;
 697        struct inode *inode;
 698        struct page *page, *_n;
 699        unsigned shift, nrbackpages;
 700        int ret, ret2, space;
 701
 702        object = container_of(op->op.object,
 703                              struct cachefiles_object, fscache);
 704        cache = container_of(object->fscache.cache,
 705                             struct cachefiles_cache, cache);
 706
 707        _enter("{OBJ%x,%d},,%d,,",
 708               object->fscache.debug_id, atomic_read(&op->op.usage),
 709               *nr_pages);
 710
 711        if (!object->backer)
 712                return -ENOBUFS;
 713
 714        space = 1;
 715        if (cachefiles_has_space(cache, 0, *nr_pages) < 0)
 716                space = 0;
 717
 718        inode = object->backer->d_inode;
 719        ASSERT(S_ISREG(inode->i_mode));
 720        ASSERT(inode->i_mapping->a_ops->bmap);
 721        ASSERT(inode->i_mapping->a_ops->readpages);
 722
 723        /* calculate the shift required to use bmap */
 724        if (inode->i_sb->s_blocksize > PAGE_SIZE)
 725                return -ENOBUFS;
 726
 727        shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;
 728
 729        pagevec_init(&pagevec, 0);
 730
 731        op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
 732        op->op.flags |= FSCACHE_OP_ASYNC;
 733        op->op.processor = cachefiles_read_copier;
 734
 735        INIT_LIST_HEAD(&backpages);
 736        nrbackpages = 0;
 737
 738        ret = space ? -ENODATA : -ENOBUFS;
 739        list_for_each_entry_safe(page, _n, pages, lru) {
 740                sector_t block0, block;
 741
 742                /* we assume the absence or presence of the first block is a
 743                 * good enough indication for the page as a whole
 744                 * - TODO: don't use bmap() for this as it is _not_ actually
 745                 *   good enough for this as it doesn't indicate errors, but
 746                 *   it's all we've got for the moment
 747                 */
 748                block0 = page->index;
 749                block0 <<= shift;
 750
 751                block = inode->i_mapping->a_ops->bmap(inode->i_mapping,
 752                                                      block0);
 753                _debug("%llx -> %llx",
 754                       (unsigned long long) block0,
 755                       (unsigned long long) block);
 756
 757                if (block) {
 758                        /* we have data - add it to the list to give to the
 759                         * backing fs */
 760                        list_move(&page->lru, &backpages);
 761                        (*nr_pages)--;
 762                        nrbackpages++;
 763                } else if (space && pagevec_add(&pagevec, page) == 0) {
 764                        fscache_mark_pages_cached(op, &pagevec);
 765                        ret = -ENODATA;
 766                }
 767        }
 768
 769        if (pagevec_count(&pagevec) > 0)
 770                fscache_mark_pages_cached(op, &pagevec);
 771
 772        if (list_empty(pages))
 773                ret = 0;
 774
 775        /* submit the apparently valid pages to the backing fs to be read from
 776         * disk */
 777        if (nrbackpages > 0) {
 778                ret2 = cachefiles_read_backing_file(object, op, &backpages,
 779                                                    &pagevec);
 780                if (ret2 == -ENOMEM || ret2 == -EINTR)
 781                        ret = ret2;
 782        }
 783
 784        if (pagevec_count(&pagevec) > 0)
 785                fscache_mark_pages_cached(op, &pagevec);
 786
 787        _leave(" = %d [nr=%u%s]",
 788               ret, *nr_pages, list_empty(pages) ? " empty" : "");
 789        return ret;
 790}
 791
 792/*
 793 * allocate a block in the cache in which to store a page
 794 * - cache withdrawal is prevented by the caller
 795 * - returns -EINTR if interrupted
 796 * - returns -ENOMEM if ran out of memory
 797 * - returns -ENOBUFS if no buffers can be made available
 798 * - returns -ENOBUFS if page is beyond EOF
 799 * - otherwise:
 800 *   - the metadata will be retained
 801 *   - 0 will be returned
 802 */
 803int cachefiles_allocate_page(struct fscache_retrieval *op,
 804                             struct page *page,
 805                             gfp_t gfp)
 806{
 807        struct cachefiles_object *object;
 808        struct cachefiles_cache *cache;
 809        struct pagevec pagevec;
 810        int ret;
 811
 812        object = container_of(op->op.object,
 813                              struct cachefiles_object, fscache);
 814        cache = container_of(object->fscache.cache,
 815                             struct cachefiles_cache, cache);
 816
 817        _enter("%p,{%lx},", object, page->index);
 818
 819        ret = cachefiles_has_space(cache, 0, 1);
 820        if (ret == 0) {
 821                pagevec_init(&pagevec, 0);
 822                pagevec_add(&pagevec, page);
 823                fscache_mark_pages_cached(op, &pagevec);
 824        } else {
 825                ret = -ENOBUFS;
 826        }
 827
 828        _leave(" = %d", ret);
 829        return ret;
 830}
 831
 832/*
 833 * allocate blocks in the cache in which to store a set of pages
 834 * - cache withdrawal is prevented by the caller
 835 * - returns -EINTR if interrupted
 836 * - returns -ENOMEM if ran out of memory
 837 * - returns -ENOBUFS if some buffers couldn't be made available
 838 * - returns -ENOBUFS if some pages are beyond EOF
 839 * - otherwise:
 840 *   - -ENODATA will be returned
 841 * - metadata will be retained for any page marked
 842 */
 843int cachefiles_allocate_pages(struct fscache_retrieval *op,
 844                              struct list_head *pages,
 845                              unsigned *nr_pages,
 846                              gfp_t gfp)
 847{
 848        struct cachefiles_object *object;
 849        struct cachefiles_cache *cache;
 850        struct pagevec pagevec;
 851        struct page *page;
 852        int ret;
 853
 854        object = container_of(op->op.object,
 855                              struct cachefiles_object, fscache);
 856        cache = container_of(object->fscache.cache,
 857                             struct cachefiles_cache, cache);
 858
 859        _enter("%p,,,%d,", object, *nr_pages);
 860
 861        ret = cachefiles_has_space(cache, 0, *nr_pages);
 862        if (ret == 0) {
 863                pagevec_init(&pagevec, 0);
 864
 865                list_for_each_entry(page, pages, lru) {
 866                        if (pagevec_add(&pagevec, page) == 0)
 867                                fscache_mark_pages_cached(op, &pagevec);
 868                }
 869
 870                if (pagevec_count(&pagevec) > 0)
 871                        fscache_mark_pages_cached(op, &pagevec);
 872                ret = -ENODATA;
 873        } else {
 874                ret = -ENOBUFS;
 875        }
 876
 877        _leave(" = %d", ret);
 878        return ret;
 879}
 880
 881/*
 882 * request a page be stored in the cache
 883 * - cache withdrawal is prevented by the caller
 884 * - this request may be ignored if there's no cache block available, in which
 885 *   case -ENOBUFS will be returned
 886 * - if the op is in progress, 0 will be returned
 887 */
 888int cachefiles_write_page(struct fscache_storage *op, struct page *page)
 889{
 890        struct cachefiles_object *object;
 891        struct cachefiles_cache *cache;
 892        mm_segment_t old_fs;
 893        struct file *file;
 894        struct path path;
 895        loff_t pos, eof;
 896        size_t len;
 897        void *data;
 898        int ret;
 899
 900        ASSERT(op != NULL);
 901        ASSERT(page != NULL);
 902
 903        object = container_of(op->op.object,
 904                              struct cachefiles_object, fscache);
 905
 906        _enter("%p,%p{%lx},,,", object, page, page->index);
 907
 908        if (!object->backer) {
 909                _leave(" = -ENOBUFS");
 910                return -ENOBUFS;
 911        }
 912
 913        ASSERT(S_ISREG(object->backer->d_inode->i_mode));
 914
 915        cache = container_of(object->fscache.cache,
 916                             struct cachefiles_cache, cache);
 917
 918        /* write the page to the backing filesystem and let it store it in its
 919         * own time */
 920        path.mnt = cache->mnt;
 921        path.dentry = object->backer;
 922        file = dentry_open(&path, O_RDWR | O_LARGEFILE, cache->cache_cred);
 923        if (IS_ERR(file)) {
 924                ret = PTR_ERR(file);
 925        } else {
 926                ret = -EIO;
 927                if (file->f_op->write) {
 928                        pos = (loff_t) page->index << PAGE_SHIFT;
 929
 930                        /* we mustn't write more data than we have, so we have
 931                         * to beware of a partial page at EOF */
 932                        eof = object->fscache.store_limit_l;
 933                        len = PAGE_SIZE;
 934                        if (eof & ~PAGE_MASK) {
 935                                ASSERTCMP(pos, <, eof);
 936                                if (eof - pos < PAGE_SIZE) {
 937                                        _debug("cut short %llx to %llx",
 938                                               pos, eof);
 939                                        len = eof - pos;
 940                                        ASSERTCMP(pos + len, ==, eof);
 941                                }
 942                        }
 943
 944                        data = kmap(page);
 945                        old_fs = get_fs();
 946                        set_fs(KERNEL_DS);
 947                        ret = file->f_op->write(
 948                                file, (const void __user *) data, len, &pos);
 949                        set_fs(old_fs);
 950                        kunmap(page);
 951                        if (ret != len)
 952                                ret = -EIO;
 953                }
 954                fput(file);
 955        }
 956
 957        if (ret < 0) {
 958                if (ret == -EIO)
 959                        cachefiles_io_error_obj(
 960                                object, "Write page to backing file failed");
 961                ret = -ENOBUFS;
 962        }
 963
 964        _leave(" = %d", ret);
 965        return ret;
 966}
 967
 968/*
 969 * detach a backing block from a page
 970 * - cache withdrawal is prevented by the caller
 971 */
 972void cachefiles_uncache_page(struct fscache_object *_object, struct page *page)
 973{
 974        struct cachefiles_object *object;
 975        struct cachefiles_cache *cache;
 976
 977        object = container_of(_object, struct cachefiles_object, fscache);
 978        cache = container_of(object->fscache.cache,
 979                             struct cachefiles_cache, cache);
 980
 981        _enter("%p,{%lu}", object, page->index);
 982
 983        spin_unlock(&object->fscache.cookie->lock);
 984}
 985
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.