fs/btrfs/struct-funcs.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2007 Oracle.  All rights reserved.
0004  */
0005
0006 #include <asm/unaligned.h>
0007
0008 #include "ctree.h"
0009
0010 static bool check_setget_bounds(const struct extent_buffer *eb,
0011                 const void *ptr, unsigned off, int size)
0012 {
0013     const unsigned long member_offset = (unsigned long)ptr + off;
0014
0015     if (unlikely(member_offset + size > eb->len)) {
0016         btrfs_warn(eb->fs_info,
0017         "bad eb member %s: ptr 0x%lx start %llu member offset %lu size %d",
0018             (member_offset > eb->len ? "start" : "end"),
0019             (unsigned long)ptr, eb->start, member_offset, size);
0020         return false;
0021     }
0022
0023     return true;
0024 }
0025
0026 /*
0027  * Macro templates that define helpers to read/write extent buffer data of a
0028  * given size, that are also used via ctree.h for access to item members by
0029  * specialized helpers.
0030  *
0031  * Generic helpers:
0032  * - btrfs_set_8 (for 8/16/32/64)
0033  * - btrfs_get_8 (for 8/16/32/64)
0034  *
0035  * Generic helpers with a token (cached address of the most recently accessed
0036  * page):
0037  * - btrfs_set_token_8 (for 8/16/32/64)
0038  * - btrfs_get_token_8 (for 8/16/32/64)
0039  *
0040  * The set/get functions handle data spanning two pages transparently, in case
0041  * metadata block size is larger than page.  Every pointer to metadata items is
0042  * an offset into the extent buffer page array, cast to a specific type.  This
0043  * gives us all the type checking.
0044  *
0045  * The extent buffer pages stored in the array pages do not form a contiguous
0046  * phyusical range, but the API functions assume the linear offset to the range
0047  * from 0 to metadata node size.
0048  */
0049
0050 #define DEFINE_BTRFS_SETGET_BITS(bits)                  \
0051 u##bits btrfs_get_token_##bits(struct btrfs_map_token *token,       \
0052                    const void *ptr, unsigned long off)  \
0053 {                                   \
0054     const unsigned long member_offset = (unsigned long)ptr + off;   \
0055     const unsigned long idx = get_eb_page_index(member_offset); \
0056     const unsigned long oip = get_eb_offset_in_page(token->eb,  \
0057                             member_offset); \
0058     const int size = sizeof(u##bits);               \
0059     u8 lebytes[sizeof(u##bits)];                    \
0060     const int part = PAGE_SIZE - oip;               \
0061                                     \
0062     ASSERT(token);                          \
0063     ASSERT(token->kaddr);                       \
0064     ASSERT(check_setget_bounds(token->eb, ptr, off, size));     \
0065     if (token->offset <= member_offset &&               \
0066         member_offset + size <= token->offset + PAGE_SIZE) {    \
0067         return get_unaligned_le##bits(token->kaddr + oip);  \
0068     }                               \
0069     token->kaddr = page_address(token->eb->pages[idx]);     \
0070     token->offset = idx << PAGE_SHIFT;              \
0071     if (INLINE_EXTENT_BUFFER_PAGES == 1 || oip + size <= PAGE_SIZE ) \
0072         return get_unaligned_le##bits(token->kaddr + oip);  \
0073                                     \
0074     memcpy(lebytes, token->kaddr + oip, part);          \
0075     token->kaddr = page_address(token->eb->pages[idx + 1]);     \
0076     token->offset = (idx + 1) << PAGE_SHIFT;            \
0077     memcpy(lebytes + part, token->kaddr, size - part);      \
0078     return get_unaligned_le##bits(lebytes);             \
0079 }                                   \
0080 u##bits btrfs_get_##bits(const struct extent_buffer *eb,        \
0081              const void *ptr, unsigned long off)        \
0082 {                                   \
0083     const unsigned long member_offset = (unsigned long)ptr + off;   \
0084     const unsigned long oip = get_eb_offset_in_page(eb, member_offset); \
0085     const unsigned long idx = get_eb_page_index(member_offset); \
0086     char *kaddr = page_address(eb->pages[idx]);         \
0087     const int size = sizeof(u##bits);               \
0088     const int part = PAGE_SIZE - oip;               \
0089     u8 lebytes[sizeof(u##bits)];                    \
0090                                     \
0091     ASSERT(check_setget_bounds(eb, ptr, off, size));        \
0092     if (INLINE_EXTENT_BUFFER_PAGES == 1 || oip + size <= PAGE_SIZE) \
0093         return get_unaligned_le##bits(kaddr + oip);     \
0094                                     \
0095     memcpy(lebytes, kaddr + oip, part);             \
0096     kaddr = page_address(eb->pages[idx + 1]);           \
0097     memcpy(lebytes + part, kaddr, size - part);         \
0098     return get_unaligned_le##bits(lebytes);             \
0099 }                                   \
0100 void btrfs_set_token_##bits(struct btrfs_map_token *token,      \
0101                 const void *ptr, unsigned long off,     \
0102                 u##bits val)                \
0103 {                                   \
0104     const unsigned long member_offset = (unsigned long)ptr + off;   \
0105     const unsigned long idx = get_eb_page_index(member_offset); \
0106     const unsigned long oip = get_eb_offset_in_page(token->eb,  \
0107                             member_offset); \
0108     const int size = sizeof(u##bits);               \
0109     u8 lebytes[sizeof(u##bits)];                    \
0110     const int part = PAGE_SIZE - oip;               \
0111                                     \
0112     ASSERT(token);                          \
0113     ASSERT(token->kaddr);                       \
0114     ASSERT(check_setget_bounds(token->eb, ptr, off, size));     \
0115     if (token->offset <= member_offset &&               \
0116         member_offset + size <= token->offset + PAGE_SIZE) {    \
0117         put_unaligned_le##bits(val, token->kaddr + oip);    \
0118         return;                         \
0119     }                               \
0120     token->kaddr = page_address(token->eb->pages[idx]);     \
0121     token->offset = idx << PAGE_SHIFT;              \
0122     if (INLINE_EXTENT_BUFFER_PAGES == 1 || oip + size <= PAGE_SIZE) { \
0123         put_unaligned_le##bits(val, token->kaddr + oip);    \
0124         return;                         \
0125     }                               \
0126     put_unaligned_le##bits(val, lebytes);               \
0127     memcpy(token->kaddr + oip, lebytes, part);          \
0128     token->kaddr = page_address(token->eb->pages[idx + 1]);     \
0129     token->offset = (idx + 1) << PAGE_SHIFT;            \
0130     memcpy(token->kaddr, lebytes + part, size - part);      \
0131 }                                   \
0132 void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,    \
0133               unsigned long off, u##bits val)           \
0134 {                                   \
0135     const unsigned long member_offset = (unsigned long)ptr + off;   \
0136     const unsigned long oip = get_eb_offset_in_page(eb, member_offset); \
0137     const unsigned long idx = get_eb_page_index(member_offset); \
0138     char *kaddr = page_address(eb->pages[idx]);         \
0139     const int size = sizeof(u##bits);               \
0140     const int part = PAGE_SIZE - oip;               \
0141     u8 lebytes[sizeof(u##bits)];                    \
0142                                     \
0143     ASSERT(check_setget_bounds(eb, ptr, off, size));        \
0144     if (INLINE_EXTENT_BUFFER_PAGES == 1 || oip + size <= PAGE_SIZE) { \
0145         put_unaligned_le##bits(val, kaddr + oip);       \
0146         return;                         \
0147     }                               \
0148                                     \
0149     put_unaligned_le##bits(val, lebytes);               \
0150     memcpy(kaddr + oip, lebytes, part);             \
0151     kaddr = page_address(eb->pages[idx + 1]);           \
0152     memcpy(kaddr, lebytes + part, size - part);         \
0153 }
0154
0155 DEFINE_BTRFS_SETGET_BITS(8)
0156 DEFINE_BTRFS_SETGET_BITS(16)
0157 DEFINE_BTRFS_SETGET_BITS(32)
0158 DEFINE_BTRFS_SETGET_BITS(64)
0159
0160 void btrfs_node_key(const struct extent_buffer *eb,
0161             struct btrfs_disk_key *disk_key, int nr)
0162 {
0163     unsigned long ptr = btrfs_node_key_ptr_offset(nr);
0164     read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
0165                struct btrfs_key_ptr, key, disk_key);
0166 }