fs/nfs/dns_resolve.c

   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 #ifdef CONFIG_NFS_USE_KERNEL_DNS
  10
  11 #include <linux/sunrpc/clnt.h>
  12 #include <linux/dns_resolver.h>
  13
  14 ssize_t nfs_dns_resolve_name(struct net *net, char *name, size_t namelen,
  15                 struct sockaddr *sa, size_t salen)
  16 {
  17         ssize_t ret;
  18         char *ip_addr = NULL;
  19         int ip_len;
  20
  21         ip_len = dns_query(NULL, name, namelen, NULL, &ip_addr, NULL);
  22         if (ip_len > 0)
  23                 ret = rpc_pton(&init_net, ip_addr, ip_len, sa, salen);
  24         else
  25                 ret = -ESRCH;
  26         kfree(ip_addr);
  27         return ret;
  28 }
  29
  30 #else
  31
  32 #include <linux/hash.h>
  33 #include <linux/string.h>
  34 #include <linux/kmod.h>
  35 #include <linux/slab.h>
  36 #include <linux/module.h>
  37 #include <linux/socket.h>
  38 #include <linux/seq_file.h>
  39 #include <linux/inet.h>
  40 #include <linux/sunrpc/clnt.h>
  41 #include <linux/sunrpc/cache.h>
  42 #include <linux/sunrpc/svcauth.h>
  43 #include <linux/sunrpc/rpc_pipe_fs.h>
  44
  45 #include "dns_resolve.h"
  46 #include "cache_lib.h"
  47 #include "netns.h"
  48
  49 #define NFS_DNS_HASHBITS 4
  50 #define NFS_DNS_HASHTBL_SIZE (1 << NFS_DNS_HASHBITS)
  51
  52 struct nfs_dns_ent {
  53         struct cache_head h;
  54
  55         char *hostname;
  56         size_t namelen;
  57
  58         struct sockaddr_storage addr;
  59         size_t addrlen;
  60 };
  61
  62
  63 static void nfs_dns_ent_update(struct cache_head *cnew,
  64                 struct cache_head *ckey)
  65 {
  66         struct nfs_dns_ent *new;
  67         struct nfs_dns_ent *key;
  68
  69         new = container_of(cnew, struct nfs_dns_ent, h);
  70         key = container_of(ckey, struct nfs_dns_ent, h);
  71
  72         memcpy(&new->addr, &key->addr, key->addrlen);
  73         new->addrlen = key->addrlen;
  74 }
  75
  76 static void nfs_dns_ent_init(struct cache_head *cnew,
  77                 struct cache_head *ckey)
  78 {
  79         struct nfs_dns_ent *new;
  80         struct nfs_dns_ent *key;
  81
  82         new = container_of(cnew, struct nfs_dns_ent, h);
  83         key = container_of(ckey, struct nfs_dns_ent, h);
  84
  85         kfree(new->hostname);
  86         new->hostname = kstrndup(key->hostname, key->namelen, GFP_KERNEL);
  87         if (new->hostname) {
  88                 new->namelen = key->namelen;
  89                 nfs_dns_ent_update(cnew, ckey);
  90         } else {
  91                 new->namelen = 0;
  92                 new->addrlen = 0;
  93         }
  94 }
  95
  96 static void nfs_dns_ent_put(struct kref *ref)
  97 {
  98         struct nfs_dns_ent *item;
  99
 100         item = container_of(ref, struct nfs_dns_ent, h.ref);
 101         kfree(item->hostname);
 102         kfree(item);
 103 }
 104
 105 static struct cache_head *nfs_dns_ent_alloc(void)
 106 {
 107         struct nfs_dns_ent *item = kmalloc(sizeof(*item), GFP_KERNEL);
 108
 109         if (item != NULL) {
 110                 item->hostname = NULL;
 111                 item->namelen = 0;
 112                 item->addrlen = 0;
 113                 return &item->h;
 114         }
 115         return NULL;
 116 };
 117
 118 static unsigned int nfs_dns_hash(const struct nfs_dns_ent *key)
 119 {
 120         return hash_str(key->hostname, NFS_DNS_HASHBITS);
 121 }
 122
 123 static void nfs_dns_request(struct cache_detail *cd,
 124                 struct cache_head *ch,
 125                 char **bpp, int *blen)
 126 {
 127         struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);
 128
 129         qword_add(bpp, blen, key->hostname);
 130         (*bpp)[-1] = '\n';
 131 }
 132
 133 static int nfs_dns_upcall(struct cache_detail *cd,
 134                 struct cache_head *ch)
 135 {
 136         struct nfs_dns_ent *key = container_of(ch, struct nfs_dns_ent, h);
 137         int ret;
 138
 139         ret = nfs_cache_upcall(cd, key->hostname);
 140         if (ret)
 141                 ret = sunrpc_cache_pipe_upcall(cd, ch, nfs_dns_request);
 142         return ret;
 143 }
 144
 145 static int nfs_dns_match(struct cache_head *ca,
 146                 struct cache_head *cb)
 147 {
 148         struct nfs_dns_ent *a;
 149         struct nfs_dns_ent *b;
 150
 151         a = container_of(ca, struct nfs_dns_ent, h);
 152         b = container_of(cb, struct nfs_dns_ent, h);
 153
 154         if (a->namelen == 0 || a->namelen != b->namelen)
 155                 return 0;
 156         return memcmp(a->hostname, b->hostname, a->namelen) == 0;
 157 }
 158
 159 static int nfs_dns_show(struct seq_file *m, struct cache_detail *cd,
 160                 struct cache_head *h)
 161 {
 162         struct nfs_dns_ent *item;
 163         long ttl;
 164
 165         if (h == NULL) {
 166                 seq_puts(m, "# ip address      hostname        ttl\n");
 167                 return 0;
 168         }
 169         item = container_of(h, struct nfs_dns_ent, h);
 170         ttl = item->h.expiry_time - seconds_since_boot();
 171         if (ttl < 0)
 172                 ttl = 0;
 173
 174         if (!test_bit(CACHE_NEGATIVE, &h->flags)) {
 175                 char buf[INET6_ADDRSTRLEN+IPV6_SCOPE_ID_LEN+1];
 176
 177                 rpc_ntop((struct sockaddr *)&item->addr, buf, sizeof(buf));
 178                 seq_printf(m, "%15s ", buf);
 179         } else
 180                 seq_puts(m, "<none>          ");
 181         seq_printf(m, "%15s %ld\n", item->hostname, ttl);
 182         return 0;
 183 }
 184
 185 static struct nfs_dns_ent *nfs_dns_lookup(struct cache_detail *cd,
 186                 struct nfs_dns_ent *key)
 187 {
 188         struct cache_head *ch;
 189
 190         ch = sunrpc_cache_lookup(cd,
 191                         &key->h,
 192                         nfs_dns_hash(key));
 193         if (!ch)
 194                 return NULL;
 195         return container_of(ch, struct nfs_dns_ent, h);
 196 }
 197
 198 static struct nfs_dns_ent *nfs_dns_update(struct cache_detail *cd,
 199                 struct nfs_dns_ent *new,
 200                 struct nfs_dns_ent *key)
 201 {
 202         struct cache_head *ch;
 203
 204         ch = sunrpc_cache_update(cd,
 205                         &new->h, &key->h,
 206                         nfs_dns_hash(key));
 207         if (!ch)
 208                 return NULL;
 209         return container_of(ch, struct nfs_dns_ent, h);
 210 }
 211
 212 static int nfs_dns_parse(struct cache_detail *cd, char *buf, int buflen)
 213 {
 214         char buf1[NFS_DNS_HOSTNAME_MAXLEN+1];
 215         struct nfs_dns_ent key, *item;
 216         unsigned long ttl;
 217         ssize_t len;
 218         int ret = -EINVAL;
 219
 220         if (buf[buflen-1] != '\n')
 221                 goto out;
 222         buf[buflen-1] = '\0';
 223
 224         len = qword_get(&buf, buf1, sizeof(buf1));
 225         if (len <= 0)
 226                 goto out;
 227         key.addrlen = rpc_pton(&init_net, buf1, len,
 228                         (struct sockaddr *)&key.addr,
 229                         sizeof(key.addr));
 230
 231         len = qword_get(&buf, buf1, sizeof(buf1));
 232         if (len <= 0)
 233                 goto out;
 234
 235         key.hostname = buf1;
 236         key.namelen = len;
 237         memset(&key.h, 0, sizeof(key.h));
 238
 239         ttl = get_expiry(&buf);
 240         if (ttl == 0)
 241                 goto out;
 242         key.h.expiry_time = ttl + seconds_since_boot();
 243
 244         ret = -ENOMEM;
 245         item = nfs_dns_lookup(cd, &key);
 246         if (item == NULL)
 247                 goto out;
 248
 249         if (key.addrlen == 0)
 250                 set_bit(CACHE_NEGATIVE, &key.h.flags);
 251
 252         item = nfs_dns_update(cd, &key, item);
 253         if (item == NULL)
 254                 goto out;
 255
 256         ret = 0;
 257         cache_put(&item->h, cd);
 258 out:
 259         return ret;
 260 }
 261
 262 static int do_cache_lookup(struct cache_detail *cd,
 263                 struct nfs_dns_ent *key,
 264                 struct nfs_dns_ent **item,
 265                 struct nfs_cache_defer_req *dreq)
 266 {
 267         int ret = -ENOMEM;
 268
 269         *item = nfs_dns_lookup(cd, key);
 270         if (*item) {
 271                 ret = cache_check(cd, &(*item)->h, &dreq->req);
 272                 if (ret)
 273                         *item = NULL;
 274         }
 275         return ret;
 276 }
 277
 278 static int do_cache_lookup_nowait(struct cache_detail *cd,
 279                 struct nfs_dns_ent *key,
 280                 struct nfs_dns_ent **item)
 281 {
 282         int ret = -ENOMEM;
 283
 284         *item = nfs_dns_lookup(cd, key);
 285         if (!*item)
 286                 goto out_err;
 287         ret = -ETIMEDOUT;
 288         if (!test_bit(CACHE_VALID, &(*item)->h.flags)
 289                         || (*item)->h.expiry_time < seconds_since_boot()
 290                         || cd->flush_time > (*item)->h.last_refresh)
 291                 goto out_put;
 292         ret = -ENOENT;
 293         if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))
 294                 goto out_put;
 295         return 0;
 296 out_put:
 297         cache_put(&(*item)->h, cd);
 298 out_err:
 299         *item = NULL;
 300         return ret;
 301 }
 302
 303 static int do_cache_lookup_wait(struct cache_detail *cd,
 304                 struct nfs_dns_ent *key,
 305                 struct nfs_dns_ent **item)
 306 {
 307         struct nfs_cache_defer_req *dreq;
 308         int ret = -ENOMEM;
 309
 310         dreq = nfs_cache_defer_req_alloc();
 311         if (!dreq)
 312                 goto out;
 313         ret = do_cache_lookup(cd, key, item, dreq);
 314         if (ret == -EAGAIN) {
 315                 ret = nfs_cache_wait_for_upcall(dreq);
 316                 if (!ret)
 317                         ret = do_cache_lookup_nowait(cd, key, item);
 318         }
 319         nfs_cache_defer_req_put(dreq);
 320 out:
 321         return ret;
 322 }
 323
 324 ssize_t nfs_dns_resolve_name(struct net *net, char *name,
 325                 size_t namelen, struct sockaddr *sa, size_t salen)
 326 {
 327         struct nfs_dns_ent key = {
 328                 .hostname = name,
 329                 .namelen = namelen,
 330         };
 331         struct nfs_dns_ent *item = NULL;
 332         ssize_t ret;
 333         struct nfs_net *nn = net_generic(net, nfs_net_id);
 334
 335         ret = do_cache_lookup_wait(nn->nfs_dns_resolve, &key, &item);
 336         if (ret == 0) {
 337                 if (salen >= item->addrlen) {
 338                         memcpy(sa, &item->addr, item->addrlen);
 339                         ret = item->addrlen;
 340                 } else
 341                         ret = -EOVERFLOW;
 342                 cache_put(&item->h, nn->nfs_dns_resolve);
 343         } else if (ret == -ENOENT)
 344                 ret = -ESRCH;
 345         return ret;
 346 }
 347
 348 int nfs_dns_resolver_cache_init(struct net *net)
 349 {
 350         int err = -ENOMEM;
 351         struct nfs_net *nn = net_generic(net, nfs_net_id);
 352         struct cache_detail *cd;
 353         struct cache_head **tbl;
 354
 355         cd = kzalloc(sizeof(struct cache_detail), GFP_KERNEL);
 356         if (cd == NULL)
 357                 goto err_cd;
 358
 359         tbl = kzalloc(NFS_DNS_HASHTBL_SIZE * sizeof(struct cache_head *),
 360                         GFP_KERNEL);
 361         if (tbl == NULL)
 362                 goto err_tbl;
 363
 364         cd->owner = THIS_MODULE,
 365         cd->hash_size = NFS_DNS_HASHTBL_SIZE,
 366         cd->hash_table = tbl,
 367         cd->name = "dns_resolve",
 368         cd->cache_put = nfs_dns_ent_put,
 369         cd->cache_upcall = nfs_dns_upcall,
 370         cd->cache_parse = nfs_dns_parse,
 371         cd->cache_show = nfs_dns_show,
 372         cd->match = nfs_dns_match,
 373         cd->init = nfs_dns_ent_init,
 374         cd->update = nfs_dns_ent_update,
 375         cd->alloc = nfs_dns_ent_alloc,
 376
 377         nfs_cache_init(cd);
 378         err = nfs_cache_register_net(net, cd);
 379         if (err)
 380                 goto err_reg;
 381         nn->nfs_dns_resolve = cd;
 382         return 0;
 383
 384 err_reg:
 385         nfs_cache_destroy(cd);
 386         kfree(cd->hash_table);
 387 err_tbl:
 388         kfree(cd);
 389 err_cd:
 390         return err;
 391 }
 392
 393 void nfs_dns_resolver_cache_destroy(struct net *net)
 394 {
 395         struct nfs_net *nn = net_generic(net, nfs_net_id);
 396         struct cache_detail *cd = nn->nfs_dns_resolve;
 397
 398         nfs_cache_unregister_net(net, cd);
 399         nfs_cache_destroy(cd);
 400         kfree(cd->hash_table);
 401         kfree(cd);
 402 }
 403
 404 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
 405                            void *ptr)
 406 {
 407         struct super_block *sb = ptr;
 408         struct net *net = sb->s_fs_info;
 409         struct nfs_net *nn = net_generic(net, nfs_net_id);
 410         struct cache_detail *cd = nn->nfs_dns_resolve;
 411         int ret = 0;
 412
 413         if (cd == NULL)
 414                 return 0;
 415
 416         if (!try_module_get(THIS_MODULE))
 417                 return 0;
 418
 419         switch (event) {
 420         case RPC_PIPEFS_MOUNT:
 421                 ret = nfs_cache_register_sb(sb, cd);
 422                 break;
 423         case RPC_PIPEFS_UMOUNT:
 424                 nfs_cache_unregister_sb(sb, cd);
 425                 break;
 426         default:
 427                 ret = -ENOTSUPP;
 428                 break;
 429         }
 430         module_put(THIS_MODULE);
 431         return ret;
 432 }
 433
 434 static struct notifier_block nfs_dns_resolver_block = {
 435         .notifier_call  = rpc_pipefs_event,
 436 };
 437
 438 int nfs_dns_resolver_init(void)
 439 {
 440         return rpc_pipefs_notifier_register(&nfs_dns_resolver_block);
 441 }
 442
 443 void nfs_dns_resolver_destroy(void)
 444 {
 445         rpc_pipefs_notifier_unregister(&nfs_dns_resolver_block);
 446 }
 447 #endif