net/ceph/pagelist.c

   1 #include <linux/module.h>
   2 #include <linux/gfp.h>
   3 #include <linux/pagemap.h>
   4 #include <linux/highmem.h>
   5 #include <linux/ceph/pagelist.h>
   6
   7 static void ceph_pagelist_unmap_tail(struct ceph_pagelist *pl)
   8 {
   9         if (pl->mapped_tail) {
  10                 struct page *page = list_entry(pl->head.prev, struct page, lru);
  11                 kunmap(page);
  12                 pl->mapped_tail = NULL;
  13         }
  14 }
  15
  16 int ceph_pagelist_release(struct ceph_pagelist *pl)
  17 {
  18         ceph_pagelist_unmap_tail(pl);
  19         while (!list_empty(&pl->head)) {
  20                 struct page *page = list_first_entry(&pl->head, struct page,
  21                                                      lru);
  22                 list_del(&page->lru);
  23                 __free_page(page);
  24         }
  25         ceph_pagelist_free_reserve(pl);
  26         return 0;
  27 }
  28 EXPORT_SYMBOL(ceph_pagelist_release);
  29
  30 static int ceph_pagelist_addpage(struct ceph_pagelist *pl)
  31 {
  32         struct page *page;
  33
  34         if (!pl->num_pages_free) {
  35                 page = __page_cache_alloc(GFP_NOFS);
  36         } else {
  37                 page = list_first_entry(&pl->free_list, struct page, lru);
  38                 list_del(&page->lru);
  39                 --pl->num_pages_free;
  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 /* Allocate enough pages for a pagelist to append the given amount
  75  * of data without without allocating.
  76  * Returns: 0 on success, -ENOMEM on error.
  77  */
  78 int ceph_pagelist_reserve(struct ceph_pagelist *pl, size_t space)
  79 {
  80         if (space <= pl->room)
  81                 return 0;
  82         space -= pl->room;
  83         space = (space + PAGE_SIZE - 1) >> PAGE_SHIFT;   /* conv to num pages */
  84
  85         while (space > pl->num_pages_free) {
  86                 struct page *page = __page_cache_alloc(GFP_NOFS);
  87                 if (!page)
  88                         return -ENOMEM;
  89                 list_add_tail(&page->lru, &pl->free_list);
  90                 ++pl->num_pages_free;
  91         }
  92         return 0;
  93 }
  94 EXPORT_SYMBOL(ceph_pagelist_reserve);
  95
  96 /* Free any pages that have been preallocated. */
  97 int ceph_pagelist_free_reserve(struct ceph_pagelist *pl)
  98 {
  99         while (!list_empty(&pl->free_list)) {
 100                 struct page *page = list_first_entry(&pl->free_list,
 101                                                      struct page, lru);
 102                 list_del(&page->lru);
 103                 __free_page(page);
 104                 --pl->num_pages_free;
 105         }
 106         BUG_ON(pl->num_pages_free);
 107         return 0;
 108 }
 109 EXPORT_SYMBOL(ceph_pagelist_free_reserve);
 110
 111 /* Create a truncation point. */
 112 void ceph_pagelist_set_cursor(struct ceph_pagelist *pl,
 113                               struct ceph_pagelist_cursor *c)
 114 {
 115         c->pl = pl;
 116         c->page_lru = pl->head.prev;
 117         c->room = pl->room;
 118 }
 119 EXPORT_SYMBOL(ceph_pagelist_set_cursor);
 120
 121 /* Truncate a pagelist to the given point. Move extra pages to reserve.
 122  * This won't sleep.
 123  * Returns: 0 on success,
 124  *          -EINVAL if the pagelist doesn't match the trunc point pagelist
 125  */
 126 int ceph_pagelist_truncate(struct ceph_pagelist *pl,
 127                            struct ceph_pagelist_cursor *c)
 128 {
 129         struct page *page;
 130
 131         if (pl != c->pl)
 132                 return -EINVAL;
 133         ceph_pagelist_unmap_tail(pl);
 134         while (pl->head.prev != c->page_lru) {
 135                 page = list_entry(pl->head.prev, struct page, lru);
 136                 /* move from pagelist to reserve */
 137                 list_move_tail(&page->lru, &pl->free_list);
 138                 ++pl->num_pages_free;
 139         }
 140         pl->room = c->room;
 141         if (!list_empty(&pl->head)) {
 142                 page = list_entry(pl->head.prev, struct page, lru);
 143                 pl->mapped_tail = kmap(page);
 144         }
 145         return 0;
 146 }
 147 EXPORT_SYMBOL(ceph_pagelist_truncate);