[linux-2.6-block.git] / fs / nfs / dns_resolve.c

/*
 * linux/fs/nfs/dns_resolve.c
 *
 * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com>
 *
 * Resolves DNS hostnames into valid ip addresses
 */

#include <linux/hash.h>
#include <linux/string.h>
#include <linux/kmod.h>
#include <linux/module.h>
#include <linux/socket.h>
#include <linux/seq_file.h>
#include <linux/inet.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/cache.h>
#include <linux/sunrpc/svcauth.h>

#include "dns_resolve.h"
#include "cache_lib.h"

#define NFS_DNS_HASHBITS 4
#define NFS_DNS_HASHTBL_SIZE (1 << NFS_DNS_HASHBITS)

static struct cache_head *nfs_dns_table[NFS_DNS_HASHTBL_SIZE];

struct nfs_dns_ent {
	struct cache_head h;

	char *hostname;
	size_t namelen;

	struct sockaddr_storage addr;
	size_t addrlen;
};


static void nfs_dns_ent_init(struct cache_head *cnew,
		struct cache_head *ckey)
{
	struct nfs_dns_ent *new;
	struct nfs_dns_ent *key;

	new = container_of(cnew, struct nfs_dns_ent, h);
	key = container_of(ckey, struct nfs_dns_ent, h);

	kfree(new->hostname);
	new->hostname = kstrndup(key->hostname, key->namelen, GFP_KERNEL);
	if (new->hostname) {
		new->namelen = key->namelen;
		memcpy(&new->addr, &key->addr, key->addrlen);
		new->addrlen = key->addrlen;
	} else {
		new->namelen = 0;
		new->addrlen = 0;
	}
}

static void nfs_dns_ent_put(struct kref *ref)
{
	struct nfs_dns_ent *item;

	item = container_of(ref, struct nfs_dns_ent, h.ref);
	kfree(item->hostname);
	kfree(item);
}

static struct cache_head *nfs_dns_ent_alloc(void)
{
	struct nfs_dns_ent *item = kmalloc(sizeof(*item), GFP_KERNEL);

	if (item != NULL) {
		item->hostname = NULL;
		item->namelen = 0;
		item->addrlen = 0;
		return &item->h;
	}
	return NULL;
};

static unsigned int nfs_dns_hash(const struct nfs_dns_ent *key)
{
	return hash_str(key->hostname, NFS_DNS_HASHBITS);
}

static void nfs_dns_request(struct cache_detail *cd,
		struct cache_head *ch,
		char **bpp, int *blen)
{
	struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);

	qword_add(bpp, blen, key->hostname);
	(*bpp)[-1] = '\n';
}

static int nfs_dns_upcall(struct cache_detail *cd,
		struct cache_head *ch)
{
	struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);
	int ret;

	ret = nfs_cache_upcall(cd, key->hostname);
	if (ret)
		ret = sunrpc_cache_pipe_upcall(cd, ch, nfs_dns_request);
	return ret;
}

static int nfs_dns_match(struct cache_head *ca,
		struct cache_head *cb)
{
	struct nfs_dns_ent *a;
	struct nfs_dns_ent *b;

	a = container_of(ca, struct nfs_dns_ent, h);
	b = container_of(cb, struct nfs_dns_ent, h);

	if (a->namelen == 0 || a->namelen != b->namelen)
		return 0;
	return memcmp(a->hostname, b->hostname, a->namelen) == 0;
}

static int nfs_dns_show(struct seq_file *m, struct cache_detail *cd,
		struct cache_head *h)
{
	struct nfs_dns_ent *item;
	long ttl;

	if (h == NULL) {
		seq_puts(m, "# ip address      hostname        ttl\n");
		return 0;
	}
	item = container_of(h, struct nfs_dns_ent, h);
	ttl = (long)item->h.expiry_time - (long)get_seconds();
	if (ttl < 0)
		ttl = 0;

	if (!test_bit(CACHE_NEGATIVE, &h->flags)) {
		char buf[INET6_ADDRSTRLEN+IPV6_SCOPE_ID_LEN+1];

		rpc_ntop((struct sockaddr *)&item->addr, buf, sizeof(buf));
		seq_printf(m, "%15s ", buf);
	} else
		seq_puts(m, "<none>          ");
	seq_printf(m, "%15s %ld\n", item->hostname, ttl);
	return 0;
}

static struct nfs_dns_ent *nfs_dns_lookup(struct cache_detail *cd,
		struct nfs_dns_ent *key)
{
	struct cache_head *ch;

	ch = sunrpc_cache_lookup(cd,
			&key->h,
			nfs_dns_hash(key));
	if (!ch)
		return NULL;
	return container_of(ch, struct nfs_dns_ent, h);
}

static struct nfs_dns_ent *nfs_dns_update(struct cache_detail *cd,
		struct nfs_dns_ent *new,
		struct nfs_dns_ent *key)
{
	struct cache_head *ch;

	ch = sunrpc_cache_update(cd,
			&new->h, &key->h,
			nfs_dns_hash(key));
	if (!ch)
		return NULL;
	return container_of(ch, struct nfs_dns_ent, h);
}

static int nfs_dns_parse(struct cache_detail *cd, char *buf, int buflen)
{
	char buf1[NFS_DNS_HOSTNAME_MAXLEN+1];
	struct nfs_dns_ent key, *item;
	unsigned long ttl;
	ssize_t len;
	int ret = -EINVAL;

	if (buf[buflen-1] != '\n')
		goto out;
	buf[buflen-1] = '\0';

	len = qword_get(&buf, buf1, sizeof(buf1));
	if (len <= 0)
		goto out;
	key.addrlen = rpc_pton(buf1, len,
			(struct sockaddr *)&key.addr,
			sizeof(key.addr));

	len = qword_get(&buf, buf1, sizeof(buf1));
	if (len <= 0)
		goto out;

	key.hostname = buf1;
	key.namelen = len;
	memset(&key.h, 0, sizeof(key.h));

	ttl = get_expiry(&buf);
	if (ttl == 0)
		goto out;
	key.h.expiry_time = ttl + get_seconds();

	ret = -ENOMEM;
	item = nfs_dns_lookup(cd, &key);
	if (item == NULL)
		goto out;

	if (key.addrlen == 0)
		set_bit(CACHE_NEGATIVE, &key.h.flags);

	item = nfs_dns_update(cd, &key, item);
	if (item == NULL)
		goto out;

	ret = 0;
	cache_put(&item->h, cd);
out:
	return ret;
}

static struct cache_detail nfs_dns_resolve = {
	.owner = THIS_MODULE,
	.hash_size = NFS_DNS_HASHTBL_SIZE,
	.hash_table = nfs_dns_table,
	.name = "dns_resolve",
	.cache_put = nfs_dns_ent_put,
	.cache_upcall = nfs_dns_upcall,
	.cache_parse = nfs_dns_parse,
	.cache_show = nfs_dns_show,
	.match = nfs_dns_match,
	.init = nfs_dns_ent_init,
	.update = nfs_dns_ent_init,
	.alloc = nfs_dns_ent_alloc,
};

static int do_cache_lookup(struct cache_detail *cd,
		struct nfs_dns_ent *key,
		struct nfs_dns_ent **item,
		struct nfs_cache_defer_req *dreq)
{
	int ret = -ENOMEM;

	*item = nfs_dns_lookup(cd, key);
	if (*item) {
		ret = cache_check(cd, &(*item)->h, &dreq->req);
		if (ret)
			*item = NULL;
	}
	return ret;
}

static int do_cache_lookup_nowait(struct cache_detail *cd,
		struct nfs_dns_ent *key,
		struct nfs_dns_ent **item)
{
	int ret = -ENOMEM;

	*item = nfs_dns_lookup(cd, key);
	if (!*item)
		goto out_err;
	ret = -ETIMEDOUT;
	if (!test_bit(CACHE_VALID, &(*item)->h.flags)
			|| (*item)->h.expiry_time < get_seconds()
			|| cd->flush_time > (*item)->h.last_refresh)
		goto out_put;
	ret = -ENOENT;
	if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))
		goto out_put;
	return 0;
out_put:
	cache_put(&(*item)->h, cd);
out_err:
	*item = NULL;
	return ret;
}

static int do_cache_lookup_wait(struct cache_detail *cd,
		struct nfs_dns_ent *key,
		struct nfs_dns_ent **item)
{
	struct nfs_cache_defer_req *dreq;
	int ret = -ENOMEM;

	dreq = nfs_cache_defer_req_alloc();
	if (!dreq)
		goto out;
	ret = do_cache_lookup(cd, key, item, dreq);
	if (ret == -EAGAIN) {
		ret = nfs_cache_wait_for_upcall(dreq);
		if (!ret)
			ret = do_cache_lookup_nowait(cd, key, item);
	}
	nfs_cache_defer_req_put(dreq);
out:
	return ret;
}

ssize_t nfs_dns_resolve_name(char *name, size_t namelen,
		struct sockaddr *sa, size_t salen)
{
	struct nfs_dns_ent key = {
		.hostname = name,
		.namelen = namelen,
	};
	struct nfs_dns_ent *item = NULL;
	ssize_t ret;

	ret = do_cache_lookup_wait(&nfs_dns_resolve, &key, &item);
	if (ret == 0) {
		if (salen >= item->addrlen) {
			memcpy(sa, &item->addr, item->addrlen);
			ret = item->addrlen;
		} else
			ret = -EOVERFLOW;
		cache_put(&item->h, &nfs_dns_resolve);
	} else if (ret == -ENOENT)
		ret = -ESRCH;
	return ret;
}

int nfs_dns_resolver_init(void)
{
	return nfs_cache_register(&nfs_dns_resolve);
}

void nfs_dns_resolver_destroy(void)
{
	nfs_cache_unregister(&nfs_dns_resolve);
}
Commit	Line	Data
e571cbf1 TM	1	/*
	2	* linux/fs/nfs/dns_resolve.c
	3	*
	4	* Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com>
	5	*
	6	* Resolves DNS hostnames into valid ip addresses
	7	*/
	8
	9	#include <linux/hash.h>
	10	#include <linux/string.h>
	11	#include <linux/kmod.h>
	12	#include <linux/module.h>
	13	#include <linux/socket.h>
	14	#include <linux/seq_file.h>
	15	#include <linux/inet.h>
	16	#include <linux/sunrpc/clnt.h>
	17	#include <linux/sunrpc/cache.h>
	18	#include <linux/sunrpc/svcauth.h>
	19
	20	#include "dns_resolve.h"
	21	#include "cache_lib.h"
	22
	23	#define NFS_DNS_HASHBITS 4
	24	#define NFS_DNS_HASHTBL_SIZE (1 << NFS_DNS_HASHBITS)
	25
	26	static struct cache_head *nfs_dns_table[NFS_DNS_HASHTBL_SIZE];
	27
	28	struct nfs_dns_ent {
	29	struct cache_head h;
	30
	31	char *hostname;
	32	size_t namelen;
	33
	34	struct sockaddr_storage addr;
	35	size_t addrlen;
	36	};
	37
	38
	39	static void nfs_dns_ent_init(struct cache_head *cnew,
	40	struct cache_head *ckey)
	41	{
	42	struct nfs_dns_ent *new;
	43	struct nfs_dns_ent *key;
	44
	45	new = container_of(cnew, struct nfs_dns_ent, h);
	46	key = container_of(ckey, struct nfs_dns_ent, h);
	47
	48	kfree(new->hostname);
	49	new->hostname = kstrndup(key->hostname, key->namelen, GFP_KERNEL);
	50	if (new->hostname) {
	51	new->namelen = key->namelen;
	52	memcpy(&new->addr, &key->addr, key->addrlen);
	53	new->addrlen = key->addrlen;
	54	} else {
	55	new->namelen = 0;
	56	new->addrlen = 0;
	57	}
	58	}
	59
	60	static void nfs_dns_ent_put(struct kref *ref)
	61	{
	62	struct nfs_dns_ent *item;
	63
	64	item = container_of(ref, struct nfs_dns_ent, h.ref);
65	kfree(item->hostname);
66	kfree(item);
67	}
68
69	static struct cache_head *nfs_dns_ent_alloc(void)
70	{
71	struct nfs_dns_ent item = kmalloc(sizeof(item), GFP_KERNEL);
72
73	if (item != NULL) {
74	item->hostname = NULL;
75	item->namelen = 0;
76	item->addrlen = 0;
77	return &item->h;
78	}
79	return NULL;
80	};
81
82	static unsigned int nfs_dns_hash(const struct nfs_dns_ent *key)
83	{
84	return hash_str(key->hostname, NFS_DNS_HASHBITS);
85	}
86
87	static void nfs_dns_request(struct cache_detail *cd,
88	struct cache_head *ch,
89	char *bpp, int blen)
90	{
91	struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);
92
93	qword_add(bpp, blen, key->hostname);
94	(*bpp)[-1] = '\n';
95	}
96
97	static int nfs_dns_upcall(struct cache_detail *cd,
98	struct cache_head *ch)
99	{
100	struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);
101	int ret;
102
103	ret = nfs_cache_upcall(cd, key->hostname);
104	if (ret)
105	ret = sunrpc_cache_pipe_upcall(cd, ch, nfs_dns_request);
106	return ret;
107	}
108
109	static int nfs_dns_match(struct cache_head *ca,
110	struct cache_head *cb)
111	{
112	struct nfs_dns_ent *a;
113	struct nfs_dns_ent *b;
114
115	a = container_of(ca, struct nfs_dns_ent, h);
116	b = container_of(cb, struct nfs_dns_ent, h);
117
118	if (a->namelen == 0 \|\| a->namelen != b->namelen)
119	return 0;
120	return memcmp(a->hostname, b->hostname, a->namelen) == 0;
121	}
122
123	static int nfs_dns_show(struct seq_file m, struct cache_detail cd,
124	struct cache_head *h)
125	{
126	struct nfs_dns_ent *item;
127	long ttl;
128
129	if (h == NULL) {
130	seq_puts(m, "# ip address hostname ttl\n");
131	return 0;
132	}
133	item = container_of(h, struct nfs_dns_ent, h);
134	ttl = (long)item->h.expiry_time - (long)get_seconds();
135	if (ttl < 0)
136	ttl = 0;
137
138	if (!test_bit(CACHE_NEGATIVE, &h->flags)) {
139	char buf[INET6_ADDRSTRLEN+IPV6_SCOPE_ID_LEN+1];
140
141	rpc_ntop((struct sockaddr *)&item->addr, buf, sizeof(buf));
142	seq_printf(m, "%15s ", buf);
143	} else
144	seq_puts(m, "<none> ");
145	seq_printf(m, "%15s %ld\n", item->hostname, ttl);
146	return 0;
147	}
148
0a6566ec	149	static struct nfs_dns_ent nfs_dns_lookup(struct cache_detail cd,
e571cbf1 TM	150	struct nfs_dns_ent *key)
	151	{
	152	struct cache_head *ch;
	153
	154	ch = sunrpc_cache_lookup(cd,
	155	&key->h,
	156	nfs_dns_hash(key));
	157	if (!ch)
	158	return NULL;
	159	return container_of(ch, struct nfs_dns_ent, h);
	160	}
	161
0a6566ec	162	static struct nfs_dns_ent nfs_dns_update(struct cache_detail cd,
e571cbf1 TM	163	struct nfs_dns_ent *new,
	164	struct nfs_dns_ent *key)
	165	{
	166	struct cache_head *ch;
	167
	168	ch = sunrpc_cache_update(cd,
	169	&new->h, &key->h,
	170	nfs_dns_hash(key));
	171	if (!ch)
	172	return NULL;
	173	return container_of(ch, struct nfs_dns_ent, h);
	174	}
	175
	176	static int nfs_dns_parse(struct cache_detail cd, char buf, int buflen)
	177	{
	178	char buf1[NFS_DNS_HOSTNAME_MAXLEN+1];
	179	struct nfs_dns_ent key, *item;
	180	unsigned long ttl;
	181	ssize_t len;
	182	int ret = -EINVAL;
	183
	184	if (buf[buflen-1] != '\n')
	185	goto out;
	186	buf[buflen-1] = '\0';
	187
	188	len = qword_get(&buf, buf1, sizeof(buf1));
	189	if (len <= 0)
	190	goto out;
	191	key.addrlen = rpc_pton(buf1, len,
	192	(struct sockaddr *)&key.addr,
	193	sizeof(key.addr));
	194
	195	len = qword_get(&buf, buf1, sizeof(buf1));
	196	if (len <= 0)
	197	goto out;
	198
	199	key.hostname = buf1;
	200	key.namelen = len;
	201	memset(&key.h, 0, sizeof(key.h));
	202
	203	ttl = get_expiry(&buf);
	204	if (ttl == 0)
	205	goto out;
	206	key.h.expiry_time = ttl + get_seconds();
	207
	208	ret = -ENOMEM;
	209	item = nfs_dns_lookup(cd, &key);
	210	if (item == NULL)
	211	goto out;
	212
	213	if (key.addrlen == 0)
	214	set_bit(CACHE_NEGATIVE, &key.h.flags);
	215
	216	item = nfs_dns_update(cd, &key, item);
	217	if (item == NULL)
	218	goto out;
	219
	220	ret = 0;
	221	cache_put(&item->h, cd);
	222	out:
	223	return ret;
	224	}
	225
	226	static struct cache_detail nfs_dns_resolve = {
227	.owner = THIS_MODULE,
228	.hash_size = NFS_DNS_HASHTBL_SIZE,
229	.hash_table = nfs_dns_table,
230	.name = "dns_resolve",
231	.cache_put = nfs_dns_ent_put,
232	.cache_upcall = nfs_dns_upcall,
233	.cache_parse = nfs_dns_parse,
234	.cache_show = nfs_dns_show,
235	.match = nfs_dns_match,
236	.init = nfs_dns_ent_init,
237	.update = nfs_dns_ent_init,
238	.alloc = nfs_dns_ent_alloc,
239	};
240
241	static int do_cache_lookup(struct cache_detail *cd,
242	struct nfs_dns_ent *key,
243	struct nfs_dns_ent **item,
244	struct nfs_cache_defer_req *dreq)
245	{
246	int ret = -ENOMEM;
247
248	*item = nfs_dns_lookup(cd, key);
249	if (*item) {
250	ret = cache_check(cd, &(*item)->h, &dreq->req);
251	if (ret)
252	*item = NULL;
253	}
254	return ret;
255	}
256
257	static int do_cache_lookup_nowait(struct cache_detail *cd,
258	struct nfs_dns_ent *key,
259	struct nfs_dns_ent **item)
260	{
261	int ret = -ENOMEM;
262
263	*item = nfs_dns_lookup(cd, key);
264	if (!*item)
265	goto out_err;
266	ret = -ETIMEDOUT;
267	if (!test_bit(CACHE_VALID, &(*item)->h.flags)
268	\|\| (*item)->h.expiry_time < get_seconds()
269	\|\| cd->flush_time > (*item)->h.last_refresh)
270	goto out_put;
271	ret = -ENOENT;
272	if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))
273	goto out_put;
274	return 0;
275	out_put:
276	cache_put(&(*item)->h, cd);
277	out_err:
278	*item = NULL;
279	return ret;
280	}
281
282	static int do_cache_lookup_wait(struct cache_detail *cd,
283	struct nfs_dns_ent *key,
284	struct nfs_dns_ent **item)
285	{
286	struct nfs_cache_defer_req *dreq;
287	int ret = -ENOMEM;
288
289	dreq = nfs_cache_defer_req_alloc();
290	if (!dreq)
291	goto out;
292	ret = do_cache_lookup(cd, key, item, dreq);
293	if (ret == -EAGAIN) {
294	ret = nfs_cache_wait_for_upcall(dreq);
295	if (!ret)
296	ret = do_cache_lookup_nowait(cd, key, item);
297	}
298	nfs_cache_defer_req_put(dreq);
299	out:
300	return ret;
301	}
302
303	ssize_t nfs_dns_resolve_name(char *name, size_t namelen,
304	struct sockaddr *sa, size_t salen)
305	{
306	struct nfs_dns_ent key = {
307	.hostname = name,
308	.namelen = namelen,
309	};
310	struct nfs_dns_ent *item = NULL;
311	ssize_t ret;
312
313	ret = do_cache_lookup_wait(&nfs_dns_resolve, &key, &item);
314	if (ret == 0) {
315	if (salen >= item->addrlen) {
316	memcpy(sa, &item->addr, item->addrlen);
317	ret = item->addrlen;
318	} else
319	ret = -EOVERFLOW;
320	cache_put(&item->h, &nfs_dns_resolve);
321	} else if (ret == -ENOENT)
322	ret = -ESRCH;
323	return ret;
324	}
325
326	int nfs_dns_resolver_init(void)
327	{
328	return nfs_cache_register(&nfs_dns_resolve);
329	}
330
331	void nfs_dns_resolver_destroy(void)
332	{
333	nfs_cache_unregister(&nfs_dns_resolve);
334	}
335