1/*
  2 * Copyright (C) 2007 Oracle.  All rights reserved.
  3 *
  4 * This program is free software; you can redistribute it and/or
  5 * modify it under the terms of the GNU General Public
  6 * License v2 as published by the Free Software Foundation.
  7 *
  8 * This program is distributed in the hope that it will be useful,
  9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 11 * General Public License for more details.
 12 *
 13 * You should have received a copy of the GNU General Public
 14 * License along with this program; if not, write to the
 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 16 * Boston, MA 021110-1307, USA.
 17 */
 18
 19#include <linux/highmem.h>
 20#include <asm/unaligned.h>
 21
 22#include "ctree.h"
 23
 24static inline u8 get_unaligned_le8(const void *p)
 25{
 26       return *(u8 *)p;
 27}
 28
 29static inline void put_unaligned_le8(u8 val, void *p)
 30{
 31       *(u8 *)p = val;
 32}
 33
 34/*
 35 * this is some deeply nasty code.
 36 *
 37 * The end result is that anyone who #includes ctree.h gets a
 38 * declaration for the btrfs_set_foo functions and btrfs_foo functions,
 39 * which are wrappers of btrfs_set_token_#bits functions and
 40 * btrfs_get_token_#bits functions, which are defined in this file.
 41 *
 42 * These setget functions do all the extent_buffer related mapping
 43 * required to efficiently read and write specific fields in the extent
 44 * buffers.  Every pointer to metadata items in btrfs is really just
 45 * an unsigned long offset into the extent buffer which has been
 46 * cast to a specific type.  This gives us all the gcc type checking.
 47 *
 48 * The extent buffer api is used to do the page spanning work required to
 49 * have a metadata blocksize different from the page size.
 50 */
 51
 52#define DEFINE_BTRFS_SETGET_BITS(bits)					\
 53u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr,	\
 54			       unsigned long off,			\
 55			       struct btrfs_map_token *token)		\
 56{									\
 57	unsigned long part_offset = (unsigned long)ptr;			\
 58	unsigned long offset = part_offset + off;			\
 59	void *p;							\
 60	int err;							\
 61	char *kaddr;							\
 62	unsigned long map_start;					\
 63	unsigned long map_len;						\
 64	int size = sizeof(u##bits);					\
 65	u##bits res;							\
 66									\
 67	if (token && token->kaddr && token->offset <= offset &&		\
 68	    token->eb == eb &&						\
 69	   (token->offset + PAGE_SIZE >= offset + size)) {	\
 70		kaddr = token->kaddr;					\
 71		p = kaddr + part_offset - token->offset;		\
 72		res = get_unaligned_le##bits(p + off);			\
 73		return res;						\
 74	}								\
 75	err = map_private_extent_buffer(eb, offset, size,		\
 76					&kaddr, &map_start, &map_len);	\
 77	if (err) {							\
 78		__le##bits leres;					\
 79									\
 80		read_extent_buffer(eb, &leres, offset, size);		\
 81		return le##bits##_to_cpu(leres);			\
 82	}								\
 83	p = kaddr + part_offset - map_start;				\
 84	res = get_unaligned_le##bits(p + off);				\
 85	if (token) {							\
 86		token->kaddr = kaddr;					\
 87		token->offset = map_start;				\
 88		token->eb = eb;						\
 89	}								\
 90	return res;							\
 91}									\
 92void btrfs_set_token_##bits(struct extent_buffer *eb,			\
 93			    void *ptr, unsigned long off, u##bits val,	\
 94			    struct btrfs_map_token *token)		\
 95{									\
 96	unsigned long part_offset = (unsigned long)ptr;			\
 97	unsigned long offset = part_offset + off;			\
 98	void *p;							\
 99	int err;							\
100	char *kaddr;							\
101	unsigned long map_start;					\
102	unsigned long map_len;						\
103	int size = sizeof(u##bits);					\
104									\
105	if (token && token->kaddr && token->offset <= offset &&		\
106	    token->eb == eb &&						\
107	   (token->offset + PAGE_SIZE >= offset + size)) {	\
108		kaddr = token->kaddr;					\
109		p = kaddr + part_offset - token->offset;		\
110		put_unaligned_le##bits(val, p + off);			\
111		return;							\
112	}								\
113	err = map_private_extent_buffer(eb, offset, size,		\
114			&kaddr, &map_start, &map_len);			\
115	if (err) {							\
116		__le##bits val2;					\
117									\
118		val2 = cpu_to_le##bits(val);				\
119		write_extent_buffer(eb, &val2, offset, size);		\
120		return;							\
121	}								\
122	p = kaddr + part_offset - map_start;				\
123	put_unaligned_le##bits(val, p + off);				\
124	if (token) {							\
125		token->kaddr = kaddr;					\
126		token->offset = map_start;				\
127		token->eb = eb;						\
128	}								\
129}
130
131DEFINE_BTRFS_SETGET_BITS(8)
132DEFINE_BTRFS_SETGET_BITS(16)
133DEFINE_BTRFS_SETGET_BITS(32)
134DEFINE_BTRFS_SETGET_BITS(64)
135
136void btrfs_node_key(struct extent_buffer *eb,
137		    struct btrfs_disk_key *disk_key, int nr)
138{
139	unsigned long ptr = btrfs_node_key_ptr_offset(nr);
140	read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
141		       struct btrfs_key_ptr, key, disk_key);
142}