pagevec.c 3.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <linux/ceph/ceph_debug.h>
  3. #include <linux/module.h>
  4. #include <linux/sched.h>
  5. #include <linux/slab.h>
  6. #include <linux/file.h>
  7. #include <linux/namei.h>
  8. #include <linux/writeback.h>
  9. #include <linux/ceph/libceph.h>
  10. void ceph_put_page_vector(struct page **pages, int num_pages, bool dirty)
  11. {
  12. int i;
  13. for (i = 0; i < num_pages; i++) {
  14. if (dirty)
  15. set_page_dirty_lock(pages[i]);
  16. put_page(pages[i]);
  17. }
  18. kvfree(pages);
  19. }
  20. EXPORT_SYMBOL(ceph_put_page_vector);
  21. void ceph_release_page_vector(struct page **pages, int num_pages)
  22. {
  23. int i;
  24. for (i = 0; i < num_pages; i++)
  25. __free_pages(pages[i], 0);
  26. kfree(pages);
  27. }
  28. EXPORT_SYMBOL(ceph_release_page_vector);
  29. /*
  30. * allocate a vector new pages
  31. */
  32. struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags)
  33. {
  34. struct page **pages;
  35. int i;
  36. pages = kmalloc_array(num_pages, sizeof(*pages), flags);
  37. if (!pages)
  38. return ERR_PTR(-ENOMEM);
  39. for (i = 0; i < num_pages; i++) {
  40. pages[i] = __page_cache_alloc(flags);
  41. if (pages[i] == NULL) {
  42. ceph_release_page_vector(pages, i);
  43. return ERR_PTR(-ENOMEM);
  44. }
  45. }
  46. return pages;
  47. }
  48. EXPORT_SYMBOL(ceph_alloc_page_vector);
  49. /*
  50. * copy user data into a page vector
  51. */
  52. int ceph_copy_user_to_page_vector(struct page **pages,
  53. const void __user *data,
  54. loff_t off, size_t len)
  55. {
  56. int i = 0;
  57. int po = off & ~PAGE_MASK;
  58. int left = len;
  59. int l, bad;
  60. while (left > 0) {
  61. l = min_t(int, PAGE_SIZE-po, left);
  62. bad = copy_from_user(page_address(pages[i]) + po, data, l);
  63. if (bad == l)
  64. return -EFAULT;
  65. data += l - bad;
  66. left -= l - bad;
  67. po += l - bad;
  68. if (po == PAGE_SIZE) {
  69. po = 0;
  70. i++;
  71. }
  72. }
  73. return len;
  74. }
  75. EXPORT_SYMBOL(ceph_copy_user_to_page_vector);
  76. void ceph_copy_to_page_vector(struct page **pages,
  77. const void *data,
  78. loff_t off, size_t len)
  79. {
  80. int i = 0;
  81. size_t po = off & ~PAGE_MASK;
  82. size_t left = len;
  83. while (left > 0) {
  84. size_t l = min_t(size_t, PAGE_SIZE-po, left);
  85. memcpy(page_address(pages[i]) + po, data, l);
  86. data += l;
  87. left -= l;
  88. po += l;
  89. if (po == PAGE_SIZE) {
  90. po = 0;
  91. i++;
  92. }
  93. }
  94. }
  95. EXPORT_SYMBOL(ceph_copy_to_page_vector);
  96. void ceph_copy_from_page_vector(struct page **pages,
  97. void *data,
  98. loff_t off, size_t len)
  99. {
  100. int i = 0;
  101. size_t po = off & ~PAGE_MASK;
  102. size_t left = len;
  103. while (left > 0) {
  104. size_t l = min_t(size_t, PAGE_SIZE-po, left);
  105. memcpy(data, page_address(pages[i]) + po, l);
  106. data += l;
  107. left -= l;
  108. po += l;
  109. if (po == PAGE_SIZE) {
  110. po = 0;
  111. i++;
  112. }
  113. }
  114. }
  115. EXPORT_SYMBOL(ceph_copy_from_page_vector);
  116. /*
  117. * Zero an extent within a page vector. Offset is relative to the
  118. * start of the first page.
  119. */
  120. void ceph_zero_page_vector_range(int off, int len, struct page **pages)
  121. {
  122. int i = off >> PAGE_SHIFT;
  123. off &= ~PAGE_MASK;
  124. dout("zero_page_vector_page %u~%u\n", off, len);
  125. /* leading partial page? */
  126. if (off) {
  127. int end = min((int)PAGE_SIZE, off + len);
  128. dout("zeroing %d %p head from %d\n", i, pages[i],
  129. (int)off);
  130. zero_user_segment(pages[i], off, end);
  131. len -= (end - off);
  132. i++;
  133. }
  134. while (len >= PAGE_SIZE) {
  135. dout("zeroing %d %p len=%d\n", i, pages[i], len);
  136. zero_user_segment(pages[i], 0, PAGE_SIZE);
  137. len -= PAGE_SIZE;
  138. i++;
  139. }
  140. /* trailing partial page? */
  141. if (len) {
  142. dout("zeroing %d %p tail to %d\n", i, pages[i], (int)len);
  143. zero_user_segment(pages[i], 0, len);
  144. }
  145. }
  146. EXPORT_SYMBOL(ceph_zero_page_vector_range);