struct-funcs.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2007 Oracle. All rights reserved.
  4. */
  5. #include <asm/unaligned.h>
  6. #include "ctree.h"
  7. static bool check_setget_bounds(const struct extent_buffer *eb,
  8. const void *ptr, unsigned off, int size)
  9. {
  10. const unsigned long member_offset = (unsigned long)ptr + off;
  11. if (member_offset > eb->len) {
  12. btrfs_warn(eb->fs_info,
  13. "bad eb member start: ptr 0x%lx start %llu member offset %lu size %d",
  14. (unsigned long)ptr, eb->start, member_offset, size);
  15. return false;
  16. }
  17. if (member_offset + size > eb->len) {
  18. btrfs_warn(eb->fs_info,
  19. "bad eb member end: ptr 0x%lx start %llu member offset %lu size %d",
  20. (unsigned long)ptr, eb->start, member_offset, size);
  21. return false;
  22. }
  23. return true;
  24. }
  25. /*
  26. * Macro templates that define helpers to read/write extent buffer data of a
  27. * given size, that are also used via ctree.h for access to item members by
  28. * specialized helpers.
  29. *
  30. * Generic helpers:
  31. * - btrfs_set_8 (for 8/16/32/64)
  32. * - btrfs_get_8 (for 8/16/32/64)
  33. *
  34. * Generic helpers with a token (cached address of the most recently accessed
  35. * page):
  36. * - btrfs_set_token_8 (for 8/16/32/64)
  37. * - btrfs_get_token_8 (for 8/16/32/64)
  38. *
  39. * The set/get functions handle data spanning two pages transparently, in case
  40. * metadata block size is larger than page. Every pointer to metadata items is
  41. * an offset into the extent buffer page array, cast to a specific type. This
  42. * gives us all the type checking.
  43. *
  44. * The extent buffer pages stored in the array pages do not form a contiguous
  45. * phyusical range, but the API functions assume the linear offset to the range
  46. * from 0 to metadata node size.
  47. */
  48. #define DEFINE_BTRFS_SETGET_BITS(bits) \
  49. u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
  50. const void *ptr, unsigned long off) \
  51. { \
  52. const unsigned long member_offset = (unsigned long)ptr + off; \
  53. const unsigned long idx = member_offset >> PAGE_SHIFT; \
  54. const unsigned long oip = offset_in_page(member_offset); \
  55. const int size = sizeof(u##bits); \
  56. u8 lebytes[sizeof(u##bits)]; \
  57. const int part = PAGE_SIZE - oip; \
  58. \
  59. ASSERT(token); \
  60. ASSERT(token->kaddr); \
  61. ASSERT(check_setget_bounds(token->eb, ptr, off, size)); \
  62. if (token->offset <= member_offset && \
  63. member_offset + size <= token->offset + PAGE_SIZE) { \
  64. return get_unaligned_le##bits(token->kaddr + oip); \
  65. } \
  66. token->kaddr = page_address(token->eb->pages[idx]); \
  67. token->offset = idx << PAGE_SHIFT; \
  68. if (oip + size <= PAGE_SIZE) \
  69. return get_unaligned_le##bits(token->kaddr + oip); \
  70. \
  71. memcpy(lebytes, token->kaddr + oip, part); \
  72. token->kaddr = page_address(token->eb->pages[idx + 1]); \
  73. token->offset = (idx + 1) << PAGE_SHIFT; \
  74. memcpy(lebytes + part, token->kaddr, size - part); \
  75. return get_unaligned_le##bits(lebytes); \
  76. } \
  77. u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
  78. const void *ptr, unsigned long off) \
  79. { \
  80. const unsigned long member_offset = (unsigned long)ptr + off; \
  81. const unsigned long oip = offset_in_page(member_offset); \
  82. const unsigned long idx = member_offset >> PAGE_SHIFT; \
  83. char *kaddr = page_address(eb->pages[idx]); \
  84. const int size = sizeof(u##bits); \
  85. const int part = PAGE_SIZE - oip; \
  86. u8 lebytes[sizeof(u##bits)]; \
  87. \
  88. ASSERT(check_setget_bounds(eb, ptr, off, size)); \
  89. if (oip + size <= PAGE_SIZE) \
  90. return get_unaligned_le##bits(kaddr + oip); \
  91. \
  92. memcpy(lebytes, kaddr + oip, part); \
  93. kaddr = page_address(eb->pages[idx + 1]); \
  94. memcpy(lebytes + part, kaddr, size - part); \
  95. return get_unaligned_le##bits(lebytes); \
  96. } \
  97. void btrfs_set_token_##bits(struct btrfs_map_token *token, \
  98. const void *ptr, unsigned long off, \
  99. u##bits val) \
  100. { \
  101. const unsigned long member_offset = (unsigned long)ptr + off; \
  102. const unsigned long idx = member_offset >> PAGE_SHIFT; \
  103. const unsigned long oip = offset_in_page(member_offset); \
  104. const int size = sizeof(u##bits); \
  105. u8 lebytes[sizeof(u##bits)]; \
  106. const int part = PAGE_SIZE - oip; \
  107. \
  108. ASSERT(token); \
  109. ASSERT(token->kaddr); \
  110. ASSERT(check_setget_bounds(token->eb, ptr, off, size)); \
  111. if (token->offset <= member_offset && \
  112. member_offset + size <= token->offset + PAGE_SIZE) { \
  113. put_unaligned_le##bits(val, token->kaddr + oip); \
  114. return; \
  115. } \
  116. token->kaddr = page_address(token->eb->pages[idx]); \
  117. token->offset = idx << PAGE_SHIFT; \
  118. if (oip + size <= PAGE_SIZE) { \
  119. put_unaligned_le##bits(val, token->kaddr + oip); \
  120. return; \
  121. } \
  122. put_unaligned_le##bits(val, lebytes); \
  123. memcpy(token->kaddr + oip, lebytes, part); \
  124. token->kaddr = page_address(token->eb->pages[idx + 1]); \
  125. token->offset = (idx + 1) << PAGE_SHIFT; \
  126. memcpy(token->kaddr, lebytes + part, size - part); \
  127. } \
  128. void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr, \
  129. unsigned long off, u##bits val) \
  130. { \
  131. const unsigned long member_offset = (unsigned long)ptr + off; \
  132. const unsigned long oip = offset_in_page(member_offset); \
  133. const unsigned long idx = member_offset >> PAGE_SHIFT; \
  134. char *kaddr = page_address(eb->pages[idx]); \
  135. const int size = sizeof(u##bits); \
  136. const int part = PAGE_SIZE - oip; \
  137. u8 lebytes[sizeof(u##bits)]; \
  138. \
  139. ASSERT(check_setget_bounds(eb, ptr, off, size)); \
  140. if (oip + size <= PAGE_SIZE) { \
  141. put_unaligned_le##bits(val, kaddr + oip); \
  142. return; \
  143. } \
  144. \
  145. put_unaligned_le##bits(val, lebytes); \
  146. memcpy(kaddr + oip, lebytes, part); \
  147. kaddr = page_address(eb->pages[idx + 1]); \
  148. memcpy(kaddr, lebytes + part, size - part); \
  149. }
  150. DEFINE_BTRFS_SETGET_BITS(8)
  151. DEFINE_BTRFS_SETGET_BITS(16)
  152. DEFINE_BTRFS_SETGET_BITS(32)
  153. DEFINE_BTRFS_SETGET_BITS(64)
  154. void btrfs_node_key(const struct extent_buffer *eb,
  155. struct btrfs_disk_key *disk_key, int nr)
  156. {
  157. unsigned long ptr = btrfs_node_key_ptr_offset(nr);
  158. read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
  159. struct btrfs_key_ptr, key, disk_key);
  160. }