fs/nfs/dns_resolve.c

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