[linux-2.6-block.git] / fs / btrfs / struct-funcs.c

/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/highmem.h>
#define BTRFS_SETGET_FUNCS(name, type, member, bits)			\
u##bits btrfs_##name(struct extent_buffer *eb,				\
				   type *s)				\
{									\
	unsigned long part_offset = (unsigned long)s;			\
	unsigned long offset = part_offset + offsetof(type, member);	\
	type *p;							\
	/* ugly, but we want the fast path here */			\
	if (eb->map_token && offset >= eb->map_start &&			\
	    offset + sizeof(((type *)0)->member) <= eb->map_start +	\
	    eb->map_len) {						\
		p = (type *)(eb->kaddr + part_offset - eb->map_start);	\
		return le##bits##_to_cpu(p->member);			\
	}								\
	{								\
		int err;						\
		char *map_token;					\
		char *kaddr;						\
		int unmap_on_exit = (eb->map_token == NULL);		\
		unsigned long map_start;				\
		unsigned long map_len;					\
		__le##bits res;						\
		err = map_extent_buffer(eb, offset,			\
			        sizeof(((type *)0)->member),		\
				&map_token, &kaddr,			\
				&map_start, &map_len, KM_USER1);	\
		if (err) {						\
			read_eb_member(eb, s, type, member, &res);	\
			return le##bits##_to_cpu(res);			\
		}							\
		p = (type *)(kaddr + part_offset - map_start);		\
		res = le##bits##_to_cpu(p->member);			\
		if (unmap_on_exit)					\
			unmap_extent_buffer(eb, map_token, KM_USER1);	\
		return res;						\
	}								\
}									\
void btrfs_set_##name(struct extent_buffer *eb,				\
				    type *s, u##bits val)		\
{									\
	unsigned long part_offset = (unsigned long)s;			\
	unsigned long offset = part_offset + offsetof(type, member);	\
	type *p;							\
	/* ugly, but we want the fast path here */			\
	if (eb->map_token && offset >= eb->map_start &&			\
	    offset + sizeof(((type *)0)->member) <= eb->map_start +	\
	    eb->map_len) {						\
		p = (type *)(eb->kaddr + part_offset - eb->map_start);	\
		p->member = cpu_to_le##bits(val);			\
		return;							\
	}								\
	{								\
		int err;						\
		char *map_token;					\
		char *kaddr;						\
		int unmap_on_exit = (eb->map_token == NULL);		\
		unsigned long map_start;				\
		unsigned long map_len;					\
		err = map_extent_buffer(eb, offset,			\
			        sizeof(((type *)0)->member),		\
				&map_token, &kaddr,			\
				&map_start, &map_len, KM_USER1);	\
		if (err) {						\
			val = cpu_to_le##bits(val);			\
			write_eb_member(eb, s, type, member, &val);	\
			return;						\
		}							\
		p = (type *)(kaddr + part_offset - map_start);		\
		p->member = cpu_to_le##bits(val);			\
		if (unmap_on_exit)					\
			unmap_extent_buffer(eb, map_token, KM_USER1);	\
	}								\
}

#include "ctree.h"

void btrfs_node_key(struct extent_buffer *eb,
		    struct btrfs_disk_key *disk_key, int nr)
{
	unsigned long ptr = btrfs_node_key_ptr_offset(nr);
	if (eb->map_token && ptr >= eb->map_start &&
	    ptr + sizeof(*disk_key) <= eb->map_start + eb->map_len) {
		memcpy(disk_key, eb->kaddr + ptr - eb->map_start,
			sizeof(*disk_key));
		return;
	} else if (eb->map_token) {
		unmap_extent_buffer(eb, eb->map_token, KM_USER1);
		eb->map_token = NULL;
	}
	read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
		       struct btrfs_key_ptr, key, disk_key);
}
Commit	Line	Data
0f82731f CM	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	#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
	21	u##bits btrfs_##name(struct extent_buffer *eb, \
	22	type *s) \
	23	{ \
df68b8a7 DM	24	unsigned long part_offset = (unsigned long)s; \
	25	unsigned long offset = part_offset + offsetof(type, member); \
	26	type *p; \
0f82731f CM	27	/* ugly, but we want the fast path here */ \
	28	if (eb->map_token && offset >= eb->map_start && \
	29	offset + sizeof(((type *)0)->member) <= eb->map_start + \
	30	eb->map_len) { \
df68b8a7 DM	31	p = (type *)(eb->kaddr + part_offset - eb->map_start); \
df68b8a7 DM	32	return le##bits##_to_cpu(p->member); \
0f82731f CM	33	} \
	34	{ \
	35	int err; \
	36	char *map_token; \
	37	char *kaddr; \
	38	int unmap_on_exit = (eb->map_token == NULL); \
	39	unsigned long map_start; \
	40	unsigned long map_len; \
	41	__le##bits res; \
	42	err = map_extent_buffer(eb, offset, \
	43	sizeof(((type *)0)->member), \
	44	&map_token, &kaddr, \
	45	&map_start, &map_len, KM_USER1); \
	46	if (err) { \
	47	read_eb_member(eb, s, type, member, &res); \
	48	return le##bits##_to_cpu(res); \
	49	} \
df68b8a7 DM	50	p = (type *)(kaddr + part_offset - map_start); \
df68b8a7 DM	51	res = le##bits##_to_cpu(p->member); \
0f82731f CM	52	if (unmap_on_exit) \
	53	unmap_extent_buffer(eb, map_token, KM_USER1); \
	54	return res; \
	55	} \
	56	} \
	57	void btrfs_set_##name(struct extent_buffer *eb, \
	58	type *s, u##bits val) \
	59	{ \
df68b8a7 DM	60	unsigned long part_offset = (unsigned long)s; \
	61	unsigned long offset = part_offset + offsetof(type, member); \
	62	type *p; \
0f82731f CM	63	/* ugly, but we want the fast path here */ \
	64	if (eb->map_token && offset >= eb->map_start && \
	65	offset + sizeof(((type *)0)->member) <= eb->map_start + \
	66	eb->map_len) { \
df68b8a7 DM	67	p = (type *)(eb->kaddr + part_offset - eb->map_start); \
df68b8a7 DM	68	p->member = cpu_to_le##bits(val); \
0f82731f CM	69	return; \
	70	} \
	71	{ \
	72	int err; \
	73	char *map_token; \
	74	char *kaddr; \
	75	int unmap_on_exit = (eb->map_token == NULL); \
	76	unsigned long map_start; \
	77	unsigned long map_len; \
	78	err = map_extent_buffer(eb, offset, \
	79	sizeof(((type *)0)->member), \
	80	&map_token, &kaddr, \
	81	&map_start, &map_len, KM_USER1); \
	82	if (err) { \
	83	val = cpu_to_le##bits(val); \
	84	write_eb_member(eb, s, type, member, &val); \
	85	return; \
	86	} \
df68b8a7 DM	87	p = (type *)(kaddr + part_offset - map_start); \
df68b8a7 DM	88	p->member = cpu_to_le##bits(val); \
0f82731f CM	89	if (unmap_on_exit) \
	90	unmap_extent_buffer(eb, map_token, KM_USER1); \
	91	} \
	92	}
	93
	94	#include "ctree.h"
	95
e644d021 CM	96	void btrfs_node_key(struct extent_buffer *eb,
	97	struct btrfs_disk_key *disk_key, int nr)
	98	{
	99	unsigned long ptr = btrfs_node_key_ptr_offset(nr);
	100	if (eb->map_token && ptr >= eb->map_start &&
	101	ptr + sizeof(*disk_key) <= eb->map_start + eb->map_len) {
	102	memcpy(disk_key, eb->kaddr + ptr - eb->map_start,
	103	sizeof(*disk_key));
	104	return;
	105	} else if (eb->map_token) {
	106	unmap_extent_buffer(eb, eb->map_token, KM_USER1);
	107	eb->map_token = NULL;
	108	}
	109	read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
	110	struct btrfs_key_ptr, key, disk_key);
	111	}