Pileus Git - ~andy/linux/blob - net/ceph/pagelist.c

   1
   2 #include <linux/module.h>
   3 #include <linux/gfp.h>
   4 #include <linux/pagemap.h>
   5 #include <linux/highmem.h>
   6 #include <linux/ceph/pagelist.h>
   7
   8 static void ceph_pagelist_unmap_tail(struct ceph_pagelist *pl)
   9 {
  10         if (pl->mapped_tail) {
  11                 struct page *page = list_entry(pl->head.prev, struct page, lru);
  12                 kunmap(page);
  13                 pl->mapped_tail = NULL;
  14         }
  15 }
  16
  17 int ceph_pagelist_release(struct ceph_pagelist *pl)
  18 {
  19         ceph_pagelist_unmap_tail(pl);
  20         while (!list_empty(&pl->head)) {
  21                 struct page *page = list_first_entry(&pl->head, struct page,
  22                                                      lru);
  23                 list_del(&page->lru);
  24                 __free_page(page);
  25         }
  26         ceph_pagelist_free_reserve(pl);
  27         return 0;
  28 }
  29 EXPORT_SYMBOL(ceph_pagelist_release);
  30
  31 static int ceph_pagelist_addpage(struct ceph_pagelist *pl)
  32 {
  33         struct page *page;
  34
  35         if (!pl->num_pages_free) {
  36                 page = __page_cache_alloc(GFP_NOFS);
  37         } else {
  38                 page = list_first_entry(&pl->free_list, struct page, lru);
  39                 list_del(&page->lru);
  40         }
  41         if (!page)
  42                 return -ENOMEM;
  43         pl->room += PAGE_SIZE;
  44         ceph_pagelist_unmap_tail(pl);
  45         list_add_tail(&page->lru, &pl->head);
  46         pl->mapped_tail = kmap(page);
  47         return 0;
  48 }
  49
  50 int ceph_pagelist_append(struct ceph_pagelist *pl, const void *buf, size_t len)
  51 {
  52         while (pl->room < len) {
  53                 size_t bit = pl->room;
  54                 int ret;
  55
  56                 memcpy(pl->mapped_tail + (pl->length & ~PAGE_CACHE_MASK),
  57                        buf, bit);
  58                 pl->length += bit;
  59                 pl->room -= bit;
  60                 buf += bit;
  61                 len -= bit;
  62                 ret = ceph_pagelist_addpage(pl);
  63                 if (ret)
  64                         return ret;
  65         }
  66
  67         memcpy(pl->mapped_tail + (pl->length & ~PAGE_CACHE_MASK), buf, len);
  68         pl->length += len;
  69         pl->room -= len;
  70         return 0;
  71 }
  72 EXPORT_SYMBOL(ceph_pagelist_append);
  73
  74 /**
  75  * Allocate enough pages for a pagelist to append the given amount
  76  * of data without without allocating.
  77  * Returns: 0 on success, -ENOMEM on error.
  78  */
  79 int ceph_pagelist_reserve(struct ceph_pagelist *pl, size_t space)
  80 {
  81         if (space <= pl->room)
  82                 return 0;
  83         space -= pl->room;
  84         space = (space + PAGE_SIZE - 1) >> PAGE_SHIFT;   /* conv to num pages */
  85
  86         while (space > pl->num_pages_free) {
  87                 struct page *page = __page_cache_alloc(GFP_NOFS);
  88                 if (!page)
  89                         return -ENOMEM;
  90                 list_add_tail(&page->lru, &pl->free_list);
  91                 ++pl->num_pages_free;
  92         }
  93         return 0;
  94 }
  95 EXPORT_SYMBOL(ceph_pagelist_reserve);
  96
  97 /**
  98  * Free any pages that have been preallocated.
  99  */
 100 int ceph_pagelist_free_reserve(struct ceph_pagelist *pl)
 101 {
 102         while (!list_empty(&pl->free_list)) {
 103                 struct page *page = list_first_entry(&pl->free_list,
 104                                                      struct page, lru);
 105                 list_del(&page->lru);
 106                 __free_page(page);
 107                 --pl->num_pages_free;
 108         }
 109         BUG_ON(pl->num_pages_free);
 110         return 0;
 111 }
 112 EXPORT_SYMBOL(ceph_pagelist_free_reserve);
 113
 114 /**
 115  * Create a truncation point.
 116  */
 117 void ceph_pagelist_set_cursor(struct ceph_pagelist *pl,
 118                               struct ceph_pagelist_cursor *c)
 119 {
 120         c->pl = pl;
 121         c->page_lru = pl->head.prev;
 122         c->room = pl->room;
 123 }
 124 EXPORT_SYMBOL(ceph_pagelist_set_cursor);
 125
 126 /**
 127  * Truncate a pagelist to the given point. Move extra pages to reserve.
 128  * This won't sleep.
 129  * Returns: 0 on success,
 130  *          -EINVAL if the pagelist doesn't match the trunc point pagelist
 131  */
 132 int ceph_pagelist_truncate(struct ceph_pagelist *pl,
 133                            struct ceph_pagelist_cursor *c)
 134 {
 135         struct page *page;
 136
 137         if (pl != c->pl)
 138                 return -EINVAL;
 139         ceph_pagelist_unmap_tail(pl);
 140         while (pl->head.prev != c->page_lru) {
 141                 page = list_entry(pl->head.prev, struct page, lru);
 142                 list_del(&page->lru);                /* remove from pagelist */
 143                 list_add_tail(&page->lru, &pl->free_list); /* add to reserve */
 144                 ++pl->num_pages_free;
 145         }
 146         pl->room = c->room;
 147         if (!list_empty(&pl->head)) {
 148                 page = list_entry(pl->head.prev, struct page, lru);
 149                 pl->mapped_tail = kmap(page);
 150         }
 151         return 0;
 152 }
 153 EXPORT_SYMBOL(ceph_pagelist_truncate);