// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 */

#include <linux/unaligned.h>
#include "messages.h"
#include "extent_io.h"
#include "fs.h"
#include "accessors.h"

static void __cold report_setget_bounds(const struct extent_buffer *eb,
					const void *ptr, unsigned off, int size)
{
	unsigned long member_offset = (unsigned long)ptr + off;

	btrfs_warn(eb->fs_info,
		   "bad eb member %s: ptr 0x%lx start %llu member offset %lu size %d",
		   (member_offset > eb->len ? "start" : "end"),
		   (unsigned long)ptr, eb->start, member_offset, size);
}

/* Copy bytes from @src1 and @src2 to @dest. */
static __always_inline void memcpy_split_src(char *dest, const char *src1,
					     const char *src2, const size_t len1,
					     const size_t total)
{
	memcpy(dest, src1, len1);
	memcpy(dest + len1, src2, total - len1);
}

/*
 * Macro templates that define helpers to read/write extent buffer data of a
 * given size, that are also used via ctree.h for access to item members by
 * specialized helpers.
 *
 * Generic helpers:
 * - btrfs_set_8 (for 8/16/32/64)
 * - btrfs_get_8 (for 8/16/32/64)
 *
 * The set/get functions handle data spanning two pages transparently, in case
 * metadata block size is larger than page.  Every pointer to metadata items is
 * an offset into the extent buffer page array, cast to a specific type.  This
 * gives us all the type checking.
 *
 * The extent buffer pages stored in the array folios may not form a contiguous
 * phyusical range, but the API functions assume the linear offset to the range
 * from 0 to metadata node size.
 */

#define DEFINE_BTRFS_SETGET_BITS(bits)					\
u##bits btrfs_get_##bits(const struct extent_buffer *eb,		\
			 const void *ptr, unsigned long off)		\
{									\
	const unsigned long member_offset = (unsigned long)ptr + off;	\
	const unsigned long idx = get_eb_folio_index(eb, member_offset);\
	const unsigned long oif = get_eb_offset_in_folio(eb,		\
							 member_offset);\
	char *kaddr = folio_address(eb->folios[idx]) + oif;		\
	const int part = eb->folio_size - oif;				\
	u8 lebytes[sizeof(u##bits)];					\
									\
	if (unlikely(member_offset + sizeof(u##bits) > eb->len)) {	\
		report_setget_bounds(eb, ptr, off, sizeof(u##bits));	\
		return 0;						\
	}								\
	if (INLINE_EXTENT_BUFFER_PAGES == 1 || sizeof(u##bits) == 1 ||	\
	    likely(sizeof(u##bits) <= part))				\
		return get_unaligned_le##bits(kaddr);			\
									\
	if (sizeof(u##bits) == 2) {					\
		lebytes[0] = *kaddr;					\
		kaddr = folio_address(eb->folios[idx + 1]);		\
		lebytes[1] = *kaddr;					\
	} else {							\
		memcpy_split_src(lebytes, kaddr,			\
				 folio_address(eb->folios[idx + 1]),	\
				 part, sizeof(u##bits));		\
	}								\
	return get_unaligned_le##bits(lebytes);				\
}									\
void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,	\
		      unsigned long off, u##bits val)			\
{									\
	const unsigned long member_offset = (unsigned long)ptr + off;	\
	const unsigned long idx = get_eb_folio_index(eb, member_offset);\
	const unsigned long oif = get_eb_offset_in_folio(eb,		\
							 member_offset);\
	char *kaddr = folio_address(eb->folios[idx]) + oif;		\
	const int part = eb->folio_size - oif;				\
	u8 lebytes[sizeof(u##bits)];					\
									\
	if (unlikely(member_offset + sizeof(u##bits) > eb->len)) {	\
		report_setget_bounds(eb, ptr, off, sizeof(u##bits));	\
		return;							\
	}								\
	if (INLINE_EXTENT_BUFFER_PAGES == 1 || sizeof(u##bits) == 1 ||	\
	    likely(sizeof(u##bits) <= part)) {				\
		put_unaligned_le##bits(val, kaddr);			\
		return;							\
	}								\
	put_unaligned_le##bits(val, lebytes);				\
	if (sizeof(u##bits) == 2) {					\
		*kaddr = lebytes[0];					\
		kaddr = folio_address(eb->folios[idx + 1]);		\
		*kaddr = lebytes[1];					\
	} else {							\
		memcpy(kaddr, lebytes, part);				\
		kaddr = folio_address(eb->folios[idx + 1]);		\
		memcpy(kaddr, lebytes + part, sizeof(u##bits) - part);	\
	}								\
}

DEFINE_BTRFS_SETGET_BITS(8)
DEFINE_BTRFS_SETGET_BITS(16)
DEFINE_BTRFS_SETGET_BITS(32)
DEFINE_BTRFS_SETGET_BITS(64)

void btrfs_node_key(const struct extent_buffer *eb,
		    struct btrfs_disk_key *disk_key, int nr)
{
	unsigned long ptr = btrfs_node_key_ptr_offset(eb, nr);
	read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
		       struct btrfs_key_ptr, key, disk_key);
}