goto out;
        }
 
-       rt = addrconf_dst_alloc(net, idev, addr, false);
+       rt = addrconf_dst_alloc(net, idev, addr, false, gfp_flags);
        if (IS_ERR(rt)) {
                err = PTR_ERR(rt);
                rt = NULL;
 
 static void
 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
-                     unsigned long expires, u32 flags)
+                     unsigned long expires, u32 flags, gfp_t gfp_flags)
 {
        struct fib6_config cfg = {
                .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
                cfg.fc_flags |= RTF_NONEXTHOP;
 #endif
 
-       ip6_route_add(&cfg, NULL);
+       ip6_route_add(&cfg, gfp_flags, NULL);
 }
 
 
 
        ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
 
-       ip6_route_add(&cfg, NULL);
+       ip6_route_add(&cfg, GFP_ATOMIC, NULL);
 }
 
 static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
                                expires = jiffies_to_clock_t(rt_expires);
                        }
                        addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
-                                             dev, expires, flags);
+                                             dev, expires, flags, GFP_ATOMIC);
                }
                ip6_rt_put(rt);
        }
        if (!IS_ERR(ifp)) {
                if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
                        addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
-                                             expires, flags);
+                                             expires, flags, GFP_KERNEL);
                }
 
                /* Send a netlink notification if DAD is enabled and
 
        if (addr.s6_addr32[3]) {
                add_addr(idev, &addr, plen, scope);
-               addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags);
+               addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags,
+                                     GFP_ATOMIC);
                return;
        }
 
 
                                add_addr(idev, &addr, plen, flag);
                                addrconf_prefix_route(&addr, plen, idev->dev, 0,
-                                                     pflags);
+                                                     pflags, GFP_ATOMIC);
                        }
                }
        }
        ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
                            INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, true, NULL);
        if (!IS_ERR(ifp)) {
-               addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
+               addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev,
+                                     0, 0, GFP_ATOMIC);
                addrconf_dad_start(ifp);
                in6_ifa_put(ifp);
        }
                        addrconf_add_linklocal(idev, &addr,
                                               IFA_F_STABLE_PRIVACY);
                else if (prefix_route)
-                       addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
+                       addrconf_prefix_route(&addr, 64, idev->dev,
+                                             0, 0, GFP_KERNEL);
                break;
        case IN6_ADDR_GEN_MODE_EUI64:
                /* addrconf_add_linklocal also adds a prefix_route and we
                if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
                        addrconf_add_linklocal(idev, &addr, 0);
                else if (prefix_route)
-                       addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
+                       addrconf_prefix_route(&addr, 64, idev->dev,
+                                             0, 0, GFP_ATOMIC);
                break;
        case IN6_ADDR_GEN_MODE_NONE:
        default:
        if (!ifp->rt || !ifp->rt->rt6i_node) {
                struct rt6_info *rt, *prev;
 
-               rt = addrconf_dst_alloc(net, idev, &ifp->addr, false);
+               rt = addrconf_dst_alloc(net, idev, &ifp->addr, false,
+                                       GFP_ATOMIC);
                if (IS_ERR(rt))
                        return PTR_ERR(rt);
 
 
        if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
                addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
-                                     idev->dev, 0, 0);
+                                     idev->dev, 0, 0, GFP_ATOMIC);
        }
 
        if (ifp->state == INET6_IFADDR_STATE_PREDAD)
                ipv6_ifa_notify(0, ifp);
 
        if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
-               addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
-                                     expires, flags);
+               addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
+                                     ifp->idev->dev, expires, flags,
+                                     GFP_KERNEL);
        } else if (had_prefixroute) {
                enum cleanup_prefix_rt_t action;
                unsigned long rt_expires;
                        addrconf_join_anycast(ifp);
                if (!ipv6_addr_any(&ifp->peer_addr))
                        addrconf_prefix_route(&ifp->peer_addr, 128,
-                                             ifp->idev->dev, 0, 0);
+                                             ifp->idev->dev, 0, 0,
+                                             GFP_KERNEL);
                break;
        case RTM_DELADDR:
                if (ifp->idev->cnf.forwarding)
 
 }
 
 static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg,
+                                             gfp_t gfp_flags,
                                              struct netlink_ext_ack *extack)
 {
        struct net *net = cfg->fc_nlinfo.nl_net;
        return ERR_PTR(err);
 }
 
-int ip6_route_add(struct fib6_config *cfg, struct netlink_ext_ack *extack)
+int ip6_route_add(struct fib6_config *cfg, gfp_t gfp_flags,
+                 struct netlink_ext_ack *extack)
 {
        struct rt6_info *rt;
        int err;
 
-       rt = ip6_route_info_create(cfg, extack);
+       rt = ip6_route_info_create(cfg, gfp_flags, extack);
        if (IS_ERR(rt))
                return PTR_ERR(rt);
 
        if (!prefixlen)
                cfg.fc_flags |= RTF_DEFAULT;
 
-       ip6_route_add(&cfg, NULL);
+       ip6_route_add(&cfg, GFP_ATOMIC, NULL);
 
        return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
 }
 
        cfg.fc_gateway = *gwaddr;
 
-       if (!ip6_route_add(&cfg, NULL)) {
+       if (!ip6_route_add(&cfg, GFP_ATOMIC, NULL)) {
                struct fib6_table *table;
 
                table = fib6_get_table(dev_net(dev), cfg.fc_table);
                rtnl_lock();
                switch (cmd) {
                case SIOCADDRT:
-                       err = ip6_route_add(&cfg, NULL);
+                       err = ip6_route_add(&cfg, GFP_KERNEL, NULL);
                        break;
                case SIOCDELRT:
                        err = ip6_route_del(&cfg, NULL);
 struct rt6_info *addrconf_dst_alloc(struct net *net,
                                    struct inet6_dev *idev,
                                    const struct in6_addr *addr,
-                                   bool anycast)
+                                   bool anycast, gfp_t gfp_flags)
 {
        u32 tb_id;
        struct net_device *dev = idev->dev;
                }
 
                r_cfg.fc_flags |= (rtnh->rtnh_flags & RTNH_F_ONLINK);
-               rt = ip6_route_info_create(&r_cfg, extack);
+               rt = ip6_route_info_create(&r_cfg, GFP_KERNEL, extack);
                if (IS_ERR(rt)) {
                        err = PTR_ERR(rt);
                        rt = NULL;
        if (cfg.fc_mp)
                return ip6_route_multipath_add(&cfg, extack);
        else
-               return ip6_route_add(&cfg, extack);
+               return ip6_route_add(&cfg, GFP_KERNEL, extack);
 }
 
 static size_t rt6_nlmsg_size(struct rt6_info *rt)