struct p9_client *clnt = fid->clnt;

struct p9_req_t *req;

int count = iov_iter_count(to);

char *dataptr;

*err = 0;

0, 11, "dqd", fid->fid,

offset, rsize);

} else {

req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,

rsize);

}

return 0;

}

if (rsize < received) {

}

if (non_zc) {

int n = copy_to_iter(dataptr, received, to);

*err = 0;

while (iov_iter_count(from)) {

if (!rsize || rsize > clnt->msize - P9_IOHDRSZ)

rsize = clnt->msize - P9_IOHDRSZ;

if (count < rsize)

rsize = count;

fid->fid, offset, rsize, count);

/* Don't bother zerocopy for small IO (< 1024) */

break;

}

if (rsize < written) {

}

p9_req_put(clnt, req);

iov_iter_revert(from, count - written - iov_iter_count(from));

if (written > len) {

pr_err("bogus RWRITE count (%d > %u)\n", written, len);

}

p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", len);

int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)

{

struct p9_client *clnt;

struct p9_req_t *req;

char *dataptr;

iov_iter_kvec(&to, ITER_DEST, &kv, 1, count);

fid->fid, offset, count);

clnt = fid->clnt;

goto free_and_error;

}

if (rsize < count) {

}

if (non_zc)

memmove(data, dataptr, count);

#include <linux/list.h>

#include <linux/jhash.h>

#include <linux/errno.h>

#include <net/9p/9p.h>

/**

struct hlist_node list;

};

/* FixMe - reduce to a reasonable size */

static struct errormap errmap[] = {

int p9_error_init(void)

{

struct errormap *c;

/* load initial error map into hash table */

for (c = errmap; c->name; c++) {

c->namelen = strlen(c->name);

INIT_HLIST_NODE(&c->list);

}

return 1;

{

int errno;

struct errormap *c;

errno = 0;

c = NULL;

if (c->namelen == len && !memcmp(c->name, errstr, len)) {

errno = c->val;

break;

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/in.h>

#include <linux/module.h>

#include <linux/net.h>

#include <linux/ipv6.h>

spin_lock(&m->req_lock);

spin_unlock(&m->req_lock);

return;

}

list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {

list_move(&req->req_list, &cancel_list);

m = container_of(work, struct p9_conn, rq);

return;

p9_debug(P9_DEBUG_TRANS, "start mux %p pos %zd\n", m, m->rc.offset);

m = container_of(work, struct p9_conn, wq);

clear_bit(Wworksched, &m->wsched);

return;

}

__poll_t n;

int err = -ECONNRESET;

return;

n = p9_fd_poll(m->client, NULL, &err);

static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)

{

__poll_t n;

struct p9_trans_fd *ts = client->trans;

struct p9_conn *m = &ts->conn;

spin_lock(&m->req_lock);

spin_unlock(&m->req_lock);

}

WRITE_ONCE(req->status, REQ_STATUS_UNSENT);

kfree(ts);

}

static int p9_bind_privport(struct socket *sock)

{

int port, err = -EINVAL;

for (port = p9_ipport_resv_max; port >= p9_ipport_resv_min; port--) {

if (err != -EADDRINUSE)

break;

}

return err;

}

static int

p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)

{

int err;

struct socket *csocket;

struct p9_fd_opts opts;

err = parse_opts(args, &opts);

if (err < 0)

return err;

return -EINVAL;

csocket = NULL;

client->trans_opts.tcp.port = opts.port;

client->trans_opts.tcp.privport = opts.privport;

SOCK_STREAM, IPPROTO_TCP, &csocket, 1);

if (err) {

pr_err("%s (%d): problem creating socket\n",

}

err = READ_ONCE(csocket->ops)->connect(csocket,

if (err < 0) {

pr_err("%s (%d): problem connecting socket to %s\n",

__func__, task_pid_nr(current), addr);

add_timer(&aarp_timer);

rc = register_netdevice_notifier(&aarp_notifier);

if (rc) {

unregister_snap_client(aarp_dl);

}

return rc;

/* General module cleanup. Called from cleanup_module() in ddp.c. */

void aarp_cleanup_module(void)

{

unregister_netdevice_notifier(&aarp_notifier);

unregister_snap_client(aarp_dl);

aarp_purge();

/* First, stop the idle timer, so it stops banging

* on the table.

*/

dev = clip_devs;

while (dev) {

return -1;

hlist_del(&to_remove->next);

/*

* If this is the only MAC connected to this VCC,

hlist_for_each_entry_safe(entry, next,

&priv->lec_arp_empty_ones, next) {

lec_arp_clear_vccs(entry);

hlist_del(&entry->next);

lec_arp_put(entry);

hlist_for_each_entry_safe(entry, next,

&priv->lec_no_forward, next) {

lec_arp_clear_vccs(entry);

hlist_del(&entry->next);

lec_arp_put(entry);

struct lec_arp_table *to_remove = from_timer(to_remove, t, timer);

struct lec_priv *priv = to_remove->priv;

pr_debug("%p %p: vpi:%d vci:%d\n",

to_remove, priv,

&priv->lec_arp_empty_ones, next) {

if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) {

hlist_del(&entry->next);

tmp = lec_arp_find(priv, mac_addr);

if (tmp) {

tmp->status = ESI_FORWARD_DIRECT;

memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN);

tmp->vcc = entry->vcc;

tmp->old_push = entry->old_push;

tmp->last_used = jiffies;

lec_arp_put(entry);

entry = tmp;

} else {

/* Temporary, changes before end of function */

}

memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN);

for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {

hlist_for_each_entry(tmp,

&priv->lec_arp_tables[i], next) {

entry = make_entry(priv, bus_mac);

if (entry == NULL)

goto out;

memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);

entry->recv_vcc = vcc;

entry->old_recv_push = old_push;

entry->recv_vcc ? entry->recv_vcc->

vci : 0);

found_entry = 1;

entry->vcc = vcc;

entry->old_push = old_push;

if (entry->status == ESI_VC_PENDING) {

&priv->lec_arp_empty_ones, next) {

if (entry->vcc == vcc) {

lec_arp_clear_vccs(entry);

hlist_del(&entry->next);

lec_arp_put(entry);

}

&priv->lec_no_forward, next) {

if (entry->recv_vcc == vcc) {

lec_arp_clear_vccs(entry);

hlist_del(&entry->next);

lec_arp_put(entry);

}

hlist_for_each_entry_safe(entry, next,

&priv->lec_arp_empty_ones, next) {

if (vcc == entry->vcc) {

ether_addr_copy(entry->mac_addr, src);

entry->status = ESI_FORWARD_DIRECT;

entry->last_used = jiffies;

/* This lets us now how our LECs are doing */

err = register_netdevice_notifier(&mpoa_notifier);

if (err < 0) {

return err;

}

}

mpc_proc_clean();

unregister_netdevice_notifier(&mpoa_notifier);

deregister_atm_ioctl(&atm_ioctl_ops);

}

if (ax25_dev) {

if (!ax25_dev->device_up) {

}

netdev_put(ax25_dev->dev, &ax25->dev_tracker);

ax25_dev_put(ax25_dev);

void ax25_ds_del_timer(ax25_dev *ax25_dev)

{

if (ax25_dev)

}

void ax25_ds_set_timer(ax25_dev *ax25_dev)

ax25_clear_queues(ax25);

if (reason == ENETUNREACH) {

} else {

if (ax25->sk && !sock_flag(ax25->sk, SOCK_DESTROY))

ax25_stop_heartbeat(ax25);

if (ax25->t3 > 0)

mod_timer(&ax25->t3timer, jiffies + ax25->t3);

else

}

void ax25_start_idletimer(ax25_cb *ax25)

if (ax25->idle > 0)

mod_timer(&ax25->idletimer, jiffies + ax25->idle);

else

}

void ax25_stop_heartbeat(ax25_cb *ax25)

{

}

void ax25_stop_t1timer(ax25_cb *ax25)

{

}

void ax25_stop_t2timer(ax25_cb *ax25)

{

}

void ax25_stop_t3timer(ax25_cb *ax25)

{

}

void ax25_stop_idletimer(ax25_cb *ax25)

{

}

int ax25_t1timer_running(ax25_cb *ax25)

config BATMAN_ADV

tristate "B.A.T.M.A.N. Advanced Meshing Protocol"

help

B.A.T.M.A.N. (better approach to mobile ad-hoc networking) is

a routing protocol for multi-hop ad-hoc mesh networks. The

atomic_dec(&tp_vars->bat_priv->tp_num);

/* kill the timer and remove its reference */

/* the worker might have rearmed itself therefore we kill it again. Note

* that if the worker should run again before invoking the following

* is OFF now

*/

batadv_tp_vars_put(tp_vars);

}

static void hidp_del_timer(struct hidp_session *session)

{

if (session->idle_to > 0)

}

static void hidp_process_report(struct hidp_session *session, int type,

{

BT_DBG("session %p state %ld", s, s->state);

}

/* ---- RFCOMM DLCs ---- */

{

BT_DBG("dlc %p state %ld", d, d->state);

rfcomm_dlc_put(d);

}

mod_timer(&pg->timer,

now + brmctx->multicast_membership_interval);

else

br_mdb_notify(cfg->br->dev, mp, pg, RTM_NEWMDB);

cfg->entry->state == MDB_TEMPORARY)

mod_timer(&ent->timer, now + br_multicast_gmi(brmctx));

else

/* Install a (S, G) forwarding entry for the source. */

err = br_mdb_add_group_src_fwd(cfg, &src->addr, brmctx, extack);

mod_timer(&pg->timer,

now + brmctx->multicast_membership_interval);

else

br_mdb_notify(cfg->br->dev, mp, pg, RTM_NEWMDB);

return;

/* the kernel is now responsible for removing this S,G */

star_mp = br_mdb_ip_get(src->br, &src->pg->key.addr);

if (!star_mp)

return;

void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx)

{

#if IS_ENABLED(CONFIG_IPV6)

#endif

}

int br_multicast_add_port(struct net_bridge_port *port)

query->startup_sent = 0;

if (try_to_del_timer_sync(&query->timer) >= 0 ||

mod_timer(&query->timer, jiffies);

}

br_multicast_find_del_pg(pmctx->port->br, pg);

del |= br_ip4_multicast_rport_del(pmctx);

del |= br_ip6_multicast_rport_del(pmctx);

#if IS_ENABLED(CONFIG_IPV6)

#endif

br_multicast_rport_del_notify(pmctx, del);

}

static void __br_multicast_stop(struct net_bridge_mcast *brmctx)

{

#if IS_ENABLED(CONFIG_IPV6)

#endif

}

case MDB_RTR_TYPE_DISABLED:

case MDB_RTR_TYPE_PERM:

br_mc_router_state_change(brmctx->br, val == MDB_RTR_TYPE_PERM);

#if IS_ENABLED(CONFIG_IPV6)

#endif

brmctx->multicast_router = val;

err = 0;

case MDB_RTR_TYPE_DISABLED:

pmctx->multicast_router = MDB_RTR_TYPE_DISABLED;

del |= br_ip4_multicast_rport_del(pmctx);

del |= br_ip6_multicast_rport_del(pmctx);

#if IS_ENABLED(CONFIG_IPV6)

#endif

br_multicast_rport_del_notify(pmctx, del);

break;

break;

case MDB_RTR_TYPE_PERM:

pmctx->multicast_router = MDB_RTR_TYPE_PERM;

br_ip4_multicast_add_router(brmctx, pmctx);

#if IS_ENABLED(CONFIG_IPV6)

#endif

br_ip6_multicast_add_router(brmctx, pmctx);

break;

br->hello_time = br->bridge_hello_time;

br->forward_delay = br->bridge_forward_delay;

br_topology_change_detection(br);

if (br->dev->flags & IFF_UP) {

br_config_bpdu_generation(br);

static void br_topology_change_acknowledged(struct net_bridge *br)

{

br->topology_change_detected = 0;

}

/* called under bridge lock */

br_set_state(p, BR_STATE_BLOCKING);

br_ifinfo_notify(RTM_NEWLINK, NULL, p);

}

}

if (br->stp_enabled == BR_NO_STP || br->forward_delay == 0) {

br_set_state(p, BR_STATE_FORWARDING);

br_topology_change_detection(br);

} else if (br->stp_enabled == BR_KERNEL_STP)

br_set_state(p, BR_STATE_LISTENING);

else

p->topology_change_ack = 0;

br_make_forwarding(p);

} else if (br_is_designated_port(p)) {

br_make_forwarding(p);

} else {

p->config_pending = 0;

br_port_state_selection(br);

if (!br_is_root_bridge(br) && was_root) {

if (br->topology_change_detected) {

br_transmit_tcn(br);

mod_timer(&br->tcn_timer,

br->topology_change_detected = 0;

spin_unlock_bh(&br->lock);

cancel_delayed_work_sync(&br->gc_work);

}

br_ifinfo_notify(RTM_NEWLINK, NULL, p);

if (!rcu_access_pointer(p->backup_port))

br_fdb_delete_by_port(br, p, 0, 0);

if (IS_ENABLED(CONFIG_PROC_FS)) {

can_remove_proc(net);

if (stats_timer)

}

kfree(net->can.rx_alldev_list);

config CEPH_LIB

tristate "Ceph core library"

depends on INET

select CRYPTO_AES

select CRYPTO_CBC

select CRYPTO_GCM

obj-$(CONFIG_OF) += of_net.o

obj-$(CONFIG_NET_TEST) += net_test.o

obj-$(CONFIG_NET_DEVMEM) += devmem.o

obj-$(CONFIG_FAIL_SKB_REALLOC) += skb_fault_injection.o

}

EXPORT_SYMBOL(netdev_features_change);

{

if (dev->flags & IFF_UP) {

struct netdev_notifier_change_info change_info = {

rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL, 0, NULL);

}

}

/**

* __netdev_notify_peers - notify network peers about existence of @dev,

netdev_unlock_ops(lower_dev);

}

}

/**

* dev_disable_gro_hw - disable HW Generic Receive Offload on a device

int err;

for_each_netdev(net, dev) {

err = call_netdevice_register_notifiers(nb, dev);

if (err)

goto rollback;

}

goto unlock;

}

err = dev_xdp_attach_link(dev, &extack, link);

rtnl_unlock();

if (err) {

memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);

/* Notify protocols, that a new device appeared. */

ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);

ret = notifier_to_errno(ret);

if (ret) {

/* Expect explicit free_netdev() on failure */

}

EXPORT_SYMBOL(unregister_netdev);

const char *pat, int new_ifindex,

struct netlink_ext_ack *extack)

{

* And now a mini version of register_netdevice unregister_netdevice.

*/

/* If device is running close it first. */

netif_close(dev);

/* And unlink it from device chain */

unlist_netdevice(dev);

synchronize_net();

err = netdev_change_owner(dev, net_old, net);

WARN_ON(err);

/* Add the device back in the hashes */

list_netdevice(dev);

/* Notify protocols, that a new device appeared. */

call_netdevice_notifiers(NETDEV_REGISTER, dev);

/*

* Prevent userspace races by waiting until the network

int dev_change_net_namespace(struct net_device *dev, struct net *net,

const char *pat)

{

}

EXPORT_SYMBOL_GPL(dev_change_net_namespace);

return ret;

}

EXPORT_SYMBOL_GPL(dev_xdp_propagate);

*/

#include <linux/dma-buf.h>

#include <linux/genalloc.h>

#include <linux/mm.h>

#include <linux/netdevice.h>

struct netdev_rx_queue *rxq;

unsigned long xa_idx;

unsigned int rxq_idx;

if (binding->list.next)

list_del(&binding->list);

xa_for_each(&binding->bound_rxqs, xa_idx, rxq) {

rxq_idx = get_netdev_rx_queue_index(rxq);

}

xa_erase(&net_devmem_dmabuf_bindings, binding->id);

struct net_devmem_dmabuf_binding *binding,

struct netlink_ext_ack *extack)

{

struct netdev_rx_queue *rxq;

u32 xa_idx;

int err;

rxq = __netif_get_rx_queue(dev, rxq_idx);

err = xa_alloc(&binding->bound_rxqs, &xa_idx, rxq, xa_limit_32b,

GFP_KERNEL);

if (err)

return 0;

return err;

}

struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);

struct sk_buff *skb;

cancel_work_sync(&hw_data->dm_alert_work);

while ((skb = __skb_dequeue(&hw_data->drop_queue))) {

struct devlink_trap_metadata *hw_metadata;

struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);

struct sk_buff *skb;

cancel_work_sync(&hw_data->dm_alert_work);

while ((skb = __skb_dequeue(&hw_data->drop_queue))) {

struct devlink_trap_metadata *hw_metadata;

struct per_cpu_dm_data *data = &per_cpu(dm_cpu_data, cpu);

struct sk_buff *skb;

cancel_work_sync(&data->dm_alert_work);

while ((skb = __skb_dequeue(&data->drop_queue)))

consume_skb(skb);

struct per_cpu_dm_data *data = &per_cpu(dm_cpu_data, cpu);

struct sk_buff *skb;

cancel_work_sync(&data->dm_alert_work);

while ((skb = __skb_dequeue(&data->drop_queue)))

consume_skb(skb);

void dst_release(struct dst_entry *dst)

{

if (dst && rcuref_put(&dst->__rcuref)) {

dst_count_dec(dst);

call_rcu_hurry(&dst->rcu_head, dst_destroy_rcu);

}

spin_lock_bh(lock);

old = rcu_dereference_protected(*rate_est, 1);

if (old) {

est->avbps = old->avbps;

est->avpps = old->avpps;

}

else

dev_deactivate(dev);

}

/* Note: our callers are responsible for calling netdev_tracker_free().

* This is the reason we use __dev_put() instead of dev_put().

*/

netdev_tracker_free(dev, &dev->linkwatch_dev_tracker);

spin_unlock_irq(&lweventlist_lock);

linkwatch_do_dev(dev);

do_dev--;

spin_lock_irq(&lweventlist_lock);

}

spin_unlock_irq(&lweventlist_lock);

}

{

unsigned long flags;

spin_lock_irqsave(&lweventlist_lock, flags);

if (!list_empty(&dev->link_watch_list)) {

list_del_init(&dev->link_watch_list);

/* We must release netdev tracker under

* the spinlock protection.

*/

netdev_tracker_free(dev, &dev->linkwatch_dev_tracker);

}

spin_unlock_irqrestore(&lweventlist_lock, flags);

linkwatch_do_dev(dev);

}

/* Must be called with the rtnl semaphore held */

void linkwatch_run_queue(void)

#include <linux/notifier.h>

#include <linux/rtnetlink.h>

#include <net/net_namespace.h>

#include <net/netns/generic.h>

{

struct net_device *dev = netdev_notifier_info_to_dev(ptr);

struct net *net = dev_net(dev);

/* Keep enum and don't add default to trigger -Werror=switch */

switch (cmd) {

case NETDEV_UP:

case NETDEV_DOWN:

case NETDEV_REBOOT:

case NETDEV_UNREGISTER:

case NETDEV_CHANGEMTU:

case NETDEV_CHANGEADDR:

return NOTIFY_DONE;

}

static int rtnl_net_debug_net_id;

struct notifier_block *nb;

nb = net_generic(net, rtnl_net_debug_net_id);

return register_netdevice_notifier_net(net, nb);

}

};

static struct notifier_block rtnl_net_debug_block = {

};

static int __init rtnl_net_debug_init(void)

{

int ret;

if (ret)

return ret;

static int neigh_del_timer(struct neighbour *n)

{

if ((n->nud_state & NUD_IN_TIMER) &&

neigh_release(n);

return 1;

}

pneigh_queue_purge(&tbl->proxy_queue, dev ? dev_net(dev) : NULL,

tbl->family);

if (skb_queue_empty_lockless(&tbl->proxy_queue))

return 0;

}

} else if (!sched_next || tdif < sched_next)

sched_next = tdif;

}

if (sched_next)

mod_timer(&tbl->proxy_timer, jiffies + sched_next);

spin_unlock(&tbl->proxy_queue.lock);

NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;

spin_lock(&tbl->proxy_queue.lock);

if (time_before(tbl->proxy_timer.expires, sched_next))

sched_next = tbl->proxy_timer.expires;

}

/* It is not clean... Fix it to unload IPv6 module safely */

cancel_delayed_work_sync(&tbl->managed_work);

cancel_delayed_work_sync(&tbl->gc_work);

pneigh_queue_purge(&tbl->proxy_queue, NULL, tbl->family);

neigh_ifdown(tbl, NULL);

if (atomic_read(&tbl->entries))

goto err_unlock;

}

binding = net_devmem_bind_dmabuf(netdev, dmabuf_fd, info->extack);

if (IS_ERR(binding)) {

err = PTR_ERR(binding);

// SPDX-License-Identifier: GPL-2.0-or-later

#include <linux/netdevice.h>

#include <net/netdev_lock.h>

#include <net/netdev_queues.h>

}

EXPORT_SYMBOL_NS_GPL(netdev_rx_queue_restart, "NETDEV_INTERNAL");

{

struct netdev_rx_queue *rxq;

int ret;

if (!netdev_need_ops_lock(dev))

return -EOPNOTSUPP;

return -EINVAL;

return -EEXIST;

rxq->mp_params = *p;

if (ret) {

rxq->mp_params.mp_ops = NULL;

rxq->mp_params.mp_priv = NULL;

return ret;

}

struct pp_memory_provider_params *p)

{

int ret;

netdev_lock(dev);

netdev_unlock(dev);

return ret;

}

{

struct netdev_rx_queue *rxq;

if (WARN_ON_ONCE(ifq_idx >= dev->real_num_rx_queues))

return;

rxq->mp_params.mp_ops = NULL;

rxq->mp_params.mp_priv = NULL;

}

void net_mp_close_rxq(struct net_device *dev, unsigned ifq_idx,

}

EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);

{

unsigned int old = READ_ONCE(dev->operstate);

return;

} while (!try_cmpxchg(&dev->operstate, &old, newstate));

}

static void set_operstate(struct net_device *dev, unsigned char transition)

{

break;

}

}

static unsigned int rtnl_dev_get_flags(const struct net_device *dev)

char ifname[IFNAMSIZ];

int err;

err = validate_linkmsg(dev, tb, extack);

if (err < 0)

if (tb[IFLA_IFNAME])

nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);

new_ifindex = nla_get_s32_default(tb[IFLA_NEW_IFINDEX], 0);

new_ifindex, extack);

if (err)

status |= DO_SETLINK_MODIFIED;

}

if (tb[IFLA_MAP]) {

struct rtnl_link_ifmap *u_map;

struct ifmap k_map;

errout:

if (status & DO_SETLINK_MODIFIED) {

if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)

if (err < 0)

net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n",

nla_len(tb[IFLA_BROADCAST]));

if (tb[IFLA_TXQLEN])

dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);

set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));

if (tb[IFLA_LINKMODE])

dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);

if (tb[IFLA_GROUP])

*/

static inline void sock_lock_init(struct sock *sk)

{

if (sk->sk_kern_sock)

sock_lock_init_class_and_name(

sk,

cgroup_sk_free(&sk->sk_cgrp_data);

mem_cgroup_sk_free(sk);

security_sk_free(sk);

if (slab != NULL)

kmem_cache_free(slab, sk);

else

void sk_stop_timer(struct sock *sk, struct timer_list* timer)

{

__sock_put(sk);

}

EXPORT_SYMBOL(sk_stop_timer);

void sk_stop_timer_sync(struct sock *sk, struct timer_list *timer)

{

__sock_put(sk);

}

EXPORT_SYMBOL(sk_stop_timer_sync);

};

u32 ethtool_cmis_get_max_lpl_size(u8 num_of_byte_octs);

void ethtool_cmis_cdb_compose_args(struct ethtool_cmis_cdb_cmd_args *args,

enum ethtool_cmis_cdb_cmd_id cmd, u8 *lpl,

return 8 * (1 + min_t(u8, num_of_byte_octs, 15));

}

void ethtool_cmis_cdb_compose_args(struct ethtool_cmis_cdb_cmd_args *args,

enum ethtool_cmis_cdb_cmd_id cmd, u8 *lpl,

u8 lpl_len, u8 *epl, u16 epl_len,

{

args->req.id = cpu_to_be16(cmd);

args->req.lpl_len = lpl_len;

memcpy(args->req.payload, lpl, args->req.lpl_len);

if (epl) {

args->req.epl_len = cpu_to_be16(epl_len);

args->req.epl = epl;

}

args->max_duration = max_duration;

args->msleep_pre_rpl = msleep_pre_rpl;

args->rpl_exp_len = rpl_exp_len;

args->flags = flags;

/* Driver gives us current state, we want to return current config */

kparam->tcp_data_split = dev->cfg->hds_config;

}

static void ethtool_init_tsinfo(struct kernel_ethtool_ts_info *info)

u32 ethtool_op_get_link(struct net_device *dev)

{

/* Synchronize carrier state with link watch, see also rtnl_getlink() */

return netif_carrier_ok(dev) ? 1 : 0;

}

netdev_unlock_ops(req_info->dev);

rtnl_unlock();

if (ret < 0)

ret = ops->reply_size(req_info, reply_data);

if (ret < 0)

goto err_cleanup;

netdev_unlock_ops(dev);

rtnl_unlock();

if (ret < 0)

ret = ethnl_fill_reply_header(skb, dev, ctx->ops->hdr_attr);

if (ret < 0)

goto out;

out:

if (ctx->ops->cleanup_data)

ctx->ops->cleanup_data(ctx->reply_data);

ctx->reply_data->dev = NULL;

if (ret < 0)

genlmsg_cancel(skb, ehdr);

ethnl_init_reply_data(reply_data, ops, dev);

ret = ops->prepare_data(req_info, reply_data, &info);

if (ret < 0)

ret = ops->reply_size(req_info, reply_data);

if (ret < 0)

goto err_cleanup;

err_cleanup:

if (ops->cleanup_data)

ops->cleanup_data(reply_data);

kfree(reply_data);

kfree(req_info);

return;

struct net_device *dev = master->dev;

if (!is_admin_up(dev)) {

return;

}

if (has_carrier)

else

}

static bool hsr_check_carrier(struct hsr_port *master)

if (!in_dev->arp_parms)

goto out_kfree;

if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))

/* Reference in_dev->dev */

netdev_hold(dev, &in_dev->dev_tracker, GFP_KERNEL);

/* Account for reference dev->ip_ptr (below) */

static void igmp_stop_timer(struct ip_mc_list *im)

{

spin_lock_bh(&im->lock);

refcount_dec(&im->refcnt);

im->tm_running = 0;

im->reporter = 0;

{

spin_lock_bh(&im->lock);

im->unsolicit_count = 0;

if ((long)(im->timer.expires-jiffies) < max_delay) {

add_timer(&im->timer);

im->tm_running = 1;

}

/* cancel the interface change timer */

WRITE_ONCE(in_dev->mr_ifc_count, 0);

__in_dev_put(in_dev);

/* clear deleted report items */

igmpv3_clear_delrec(in_dev);

#ifdef CONFIG_IP_MULTICAST

WRITE_ONCE(in_dev->mr_ifc_count, 0);

__in_dev_put(in_dev);

in_dev->mr_gq_running = 0;

__in_dev_put(in_dev);

#endif

struct inet_frag_queue *fq = ptr;

int count;

spin_lock_bh(&fq->lock);

fq->flags |= INET_FRAG_DROP;

void inet_frag_kill(struct inet_frag_queue *fq, int *refs)

{

(*refs)++;

if (!(fq->flags & INET_FRAG_COMPLETE)) {

reason = (q->flags & INET_FRAG_DROP) ?

SKB_DROP_REASON_FRAG_REASM_TIMEOUT :

SKB_CONSUMED;

/* Release all fragment data. */

fqdir = q->fqdir;

skb_dst_update_pmtu_no_confirm(skb, mtu);

return 0;

if (skb->protocol == htons(ETH_P_IP))

geneve_opt_policy[LWTUNNEL_IP_OPT_GENEVE_MAX + 1] = {

[LWTUNNEL_IP_OPT_GENEVE_CLASS] = { .type = NLA_U16 },

[LWTUNNEL_IP_OPT_GENEVE_TYPE] = { .type = NLA_U8 },

};

static const struct nla_policy

}

}

if (list_empty(&mrt->mfc_unres_queue))

spin_unlock_bh(&mfc_unres_lock);

if (found) {

}

/* fully reclaim rmem/fwd memory allocated for skb */

{

struct udp_sock *up = udp_sk(sk);

struct sk_buff_head *sk_queue;

if (likely(partial)) {

up->forward_deficit += size;

if (!rx_queue_lock_held)

spin_lock(&sk_queue->lock);

if (amt)

__sk_mem_reduce_allocated(sk, amt >> PAGE_SHIFT);

int __udp_enqueue_schedule_skb(struct sock *sk, struct sk_buff *skb)

{

struct sk_buff_head *list = &sk->sk_receive_queue;

spinlock_t *busy = NULL;

rmem = atomic_read(&sk->sk_rmem_alloc);

rcvbuf = READ_ONCE(sk->sk_rcvbuf);

/* Under mem pressure, it might be helpful to help udp_recvmsg()

* having linear skbs :

*/

if (rmem > (rcvbuf >> 1)) {

skb_condense(skb);

busy = busylock_acquire(sk);

}

udp_set_dev_scratch(skb);

atomic_add(size, &sk->sk_rmem_alloc);

static struct sk_buff *__first_packet_length(struct sock *sk,

struct sk_buff_head *rcvq,

{

struct sk_buff *skb;

{

struct sk_buff_head *rcvq = &udp_sk(sk)->reader_queue;

struct sk_buff_head *sk_queue = &sk->sk_receive_queue;

struct sk_buff *skb;

int res;

spin_lock_bh(&rcvq->lock);

#include <net/netlink.h>

#include <net/pkt_sched.h>

#include <net/l3mdev.h>

#include <linux/if_tunnel.h>

#include <linux/rtnetlink.h>

#include <linux/netconf.h>

static void addrconf_del_rs_timer(struct inet6_dev *idev)

{

__in6_dev_put(idev);

}

int err = -ENOMEM;

ASSERT_RTNL();

if (dev->mtu < IPV6_MIN_MTU && dev != blackhole_netdev)

return ERR_PTR(-EINVAL);

return ERR_PTR(err);

}

if (ndev->cnf.forwarding)

/* We refer to the device */

netdev_hold(dev, &ndev->dev_tracker, GFP_KERNEL);

rtnl_net_lock(net);

dev = __dev_get_by_index(net, ireq.ifr6_ifindex);

err = inet6_addr_add(net, dev, &cfg, 0, 0, NULL);

err = -ENODEV;

rtnl_net_unlock(net);

return err;

}

if (!dev) {

NL_SET_ERR_MSG_MOD(extack, "Unable to find the interface");

err = -ENODEV;

}

idev = ipv6_find_idev(dev);

if (IS_ERR(idev)) {

err = PTR_ERR(idev);

in6_ifa_put(ifa);

unlock:

rtnl_net_unlock(net);

return err;

}

}

static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,

u32 ext_filter_mask)

{

/* XXX - MC not implemented */

nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));

if (!nla)

if (idev->cnf.addr_gen_mode != new_val) {

WRITE_ONCE(idev->cnf.addr_gen_mode, new_val);

addrconf_init_auto_addrs(idev->dev);

}

} else if (&net->ipv6.devconf_all->addr_gen_mode == ctl->data) {

struct net_device *dev;

idev->cnf.addr_gen_mode != new_val) {

WRITE_ONCE(idev->cnf.addr_gen_mode,

new_val);

addrconf_init_auto_addrs(idev->dev);

}

}

}

struct ipv6_opt_hdr *hop;

int opt_len, len, ret_val = -ENOMSG, offset;

unsigned char *opt;

if (!txopts || !txopts->hopopt)

goto done;

{

int ret_val;

struct ipv6_opt_hdr *old, *new;

old = NULL;

if (txopts)

old = txopts->hopopt;

static void calipso_sock_delattr(struct sock *sk)

{

struct ipv6_opt_hdr *new_hop;

if (!txopts || !txopts->hopopt)

goto done;

round_jiffies(now

+ net->ipv6.sysctl.ip6_rt_gc_interval));

else

spin_unlock_bh(&net->ipv6.fib6_gc_lock);

}

{

unsigned int i;

for (i = 0; i < FIB6_TABLE_HASHSZ; i++) {

struct hlist_head *head = &net->ipv6.fib_table_hash[i];

void ip6_flowlabel_cleanup(void)

{

static_key_deferred_flush(&ipv6_flowlabel_exclusive);

unregister_pernet_subsys(&ip6_flowlabel_net_ops);

}

}

}

if (list_empty(&mrt->mfc_unres_queue))

spin_unlock_bh(&mfc_unres_lock);

if (found) {

return false;

}

void fib6_select_path(const struct net *net, struct fib6_result *res,

struct flowi6 *fl6, int oif, bool have_oif_match,

const struct sk_buff *skb, int strict)

{

struct fib6_info *sibling;

if (!match->nh && (!match->fib6_nsiblings || have_oif_match))

goto out;

return;

}

goto out;

fib6_siblings) {

const struct fib6_nh *nh = sibling->fib6_nh;

int nh_upper_bound;

nh_upper_bound = atomic_read(&nh->fib_nh_upper_bound);

continue;

if (rt6_score_route(nh, sibling->fib6_flags, oif, strict) < 0)

break;

spin_unlock_bh(&lapb->lock);

/* Wait for running timers to stop */

__lapb_remove_cb(lapb);

void lapb_start_t1timer(struct lapb_cb *lapb)

{

lapb->t1timer.function = lapb_t1timer_expiry;

lapb->t1timer.expires = jiffies + lapb->t1;

void lapb_start_t2timer(struct lapb_cb *lapb)

{

lapb->t2timer.function = lapb_t2timer_expiry;

lapb->t2timer.expires = jiffies + lapb->t2;

void lapb_stop_t1timer(struct lapb_cb *lapb)

{

lapb->t1timer_running = false;

}

void lapb_stop_t2timer(struct lapb_cb *lapb)

{

lapb->t2timer_running = false;

}

int lapb_t1timer_running(struct lapb_cb *lapb)

struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);

llc->remote_busy_flag = 0;

nr = LLC_I_GET_NR(pdu);

llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);

}

struct llc_sock *llc = llc_sk(sk);

if (llc->data_flag == 2)

return 0;

}

{

struct llc_sock *llc = llc_sk(sk);

llc->ack_must_be_send = 0;

llc->ack_pf = 0;

return 0;

int llc_conn_ac_stop_ack_timer(struct sock *sk, struct sk_buff *skb)

{

return 0;

}

{

struct llc_sock *llc = llc_sk(sk);

llc_conn_set_p_flag(sk, 0);

return 0;

}

int llc_conn_ac_stop_rej_timer(struct sock *sk, struct sk_buff *skb)

{

return 0;

}

/* On loopback we don't queue I frames in unack_pdu_q queue. */

if (acked > 0 || (llc->dev->flags & IFF_LOOPBACK)) {

llc->retry_count = 0;

if (llc->failed_data_req) {

/* already, we did not accept data from upper layer

* (tx_window full or unacceptable state). Now, we

struct llc_sock *llc = llc_sk(sk);

if (sync) {

} else {

}

llc->ack_must_be_send = 0;

if (!tid_rx)

return;

/* make sure ieee80211_sta_reorder_release() doesn't re-arm the timer */

spin_lock_bh(&tid_rx->reorder_lock);

tid_rx->removed = true;

spin_unlock_bh(&tid_rx->reorder_lock);

call_rcu(&tid_rx->rcu_head, ieee80211_free_tid_rx);

}

ht_dbg(sta->sdata, "Tx BA session stop requested for %pM tid %u\n",

sta->sta.addr, tid);

/*

* After this packets are no longer handed right through

return;

}

ht_dbg(sta->sdata, "switched off addBA timer for %pM tid %d\n",

sta->sta.addr, tid);

skb_queue_purge(&sdata->skb_queue);

return 0;

}

netif_addr_unlock_bh(sdata->dev);

}

wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);

WARN(ieee80211_vif_is_mld(&sdata->vif),

return;

tpt_trig->running = false;

led_trigger_event(&local->tpt_led, LED_OFF);

}

else {

clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);

/* stop running timer */

}

}

local->total_ps_buffered -= skb_queue_len(&ifmsh->ps.bc_buf);

skb_queue_purge(&ifmsh->ps.bc_buf);

/* clear any mesh work (for next join) we may have accrued */

ifmsh->wrkq_flags = 0;

}

spin_unlock_bh(&sta->mesh->plink_lock);

if (!sdata->u.mesh.user_mpm)

mesh_path_flush_by_nexthop(sta);

/* make sure no readers can access nexthop sta from here on */

/*

* This STA is valid because sta_info_destroy() will

* it cannot be re-added (by deleting the plink.)

*/

sta = mesh->plink_sta;

return;

}

if (sta->mesh->plink_state == NL80211_PLINK_LISTEN ||

sta->mesh->plink_state == NL80211_PLINK_ESTAB) {

mpl_dbg(sta->sdata,

break;

case NL80211_PLINK_HOLDING:

/* holding timer */

mesh_plink_fsm_restart(sta);

break;

default:

struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;

u64 changed = 0;

sta->mesh->plink_state = NL80211_PLINK_ESTAB;

changed |= mesh_plink_inc_estab_count(sdata);

changed |= mesh_set_ht_prot_mode(sdata);

case NL80211_PLINK_HOLDING:

switch (event) {

case CLS_ACPT:

mesh_plink_fsm_restart(sta);

break;

case OPN_ACPT:

} else if (conf->flags & IEEE80211_CONF_PS) {

conf->flags &= ~IEEE80211_CONF_PS;

ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

wiphy_work_cancel(local->hw.wiphy,

&local->dynamic_ps_enable_work);

}

sdata->deflink.ap_power_level = IEEE80211_UNSET_POWER_LEVEL;

wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);

/* Disable ARP filtering */

/* disassociated - set to defaults now */

ieee80211_set_wmm_default(&sdata->deflink, false, false);

sdata->vif.bss_conf.dtim_period = 0;

sdata->vif.bss_conf.beacon_rate = NULL;

* running is the timeout for the authentication response which

* which is not relevant anymore.

*/

sta_info_destroy_addr(sdata, auth_data->ap_addr);

/* other links are destroyed */

* running is the timeout for the association response which

* which is not relevant anymore.

*/

sta_info_destroy_addr(sdata, assoc_data->ap_addr);

eth_zero_addr(sdata->deflink.u.mgd.bssid);

ifmgd->assoc_req_ies = NULL;

ifmgd->assoc_req_ies_len = 0;

spin_unlock_bh(&ifmgd->teardown_lock);

}

void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,

skb_queue_purge(&sdata->skb_queue);

/* If the timer fired while we waited for it, it will have

* requeued the work. Now the work will be running again

* but will not rearm the timer again because it checks

/* FIXME: what to do when local->pspolling is true? */

wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);

flush_workqueue(local->workqueue);

/* Don't try to run timers while suspended. */

/*

* Note that this particular timer doesn't need to be

* restarted at resume.

*/

wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);

local->wowlan = wowlan;

if (local->wowlan) {

tid_agg_rx->reorder_time[j] + 1 +

HT_RX_REORDER_BUF_TIMEOUT);

} else {

}

}

void sta_info_stop(struct ieee80211_local *local)

{

rhltable_destroy(&local->sta_hash);

rhltable_destroy(&local->link_sta_hash);

}

* keys), stop any pending expiry events. the timer cannot be re-queued

* as the sk is no longer observable

*/

}

static void mctp_sk_destruct(struct sock *sk)

list_del(&entry->list);

spin_unlock_bh(&msk->pm.lock);

if (add_timer)

sk_stop_timer_sync(sk, add_timer);

goto dispose_child;

}

SUBFLOW_REQ_INC_STATS(req, MPTCP_MIB_JOINACKMAC);

subflow_add_reset_reason(skb, MPTCP_RST_EPROHIBIT);

goto dispose_child;

}

/* move the msk reference ownership to the subflow */

subflow_req->msk = NULL;

ctx->conn = (struct sock *)owner;

nc->monitor.enabled = false;

spin_unlock_irqrestore(&nc->lock, flags);

}

struct ncsi_channel *ncsi_find_channel(struct ncsi_package *np,

if (nr->enabled) {

nr->enabled = false;

}

spin_lock_irqsave(&ndp->lock, flags);

bool 'SCTP protocol connection tracking support'

depends on NETFILTER_ADVANCED

default y

help

With this option enabled, the layer 3 independent connection

tracking code will be able to do state tracking on SCTP connections.

config NF_TABLES

select NETFILTER_NETLINK

tristate "Netfilter nf_tables support"

help

nftables is the new packet classification framework that intends to

struct mtype *map = set->data;

if (SET_WITH_TIMEOUT(set))

}

static const struct ip_set_type_variant mtype = {

config IP_VS_PROTO_SCTP

bool "SCTP load balancing support"

help

This option enables support for load balancing SCTP transport

protocol. Say Y if unsure.

/* Try to delete connection while not holding reference */

static void ip_vs_conn_del(struct ip_vs_conn *cp)

{

/* Drop cp->control chain too */

if (cp->control)

cp->timeout = 0;

/* Try to delete connection while holding reference */

static void ip_vs_conn_del_put(struct ip_vs_conn *cp)

{

/* Drop cp->control chain too */

if (cp->control)

cp->timeout = 0;

struct ip_vs_conn *ct = cp->control;

/* delete the timer if it is activated by other users */

/* does anybody control me? */

if (ct) {

{

struct ip_vs_dest *dest, *nxt;

/* No need to use dest_trash_lock */

list_for_each_entry_safe(dest, nxt, &ipvs->dest_trash, t_list) {

list_del(&dest->t_list);

bool nf_ct_remove_expect(struct nf_conntrack_expect *exp)

{

nf_ct_unlink_expect(exp);

nf_ct_expect_put(exp);

return true;

if (exp->flags & NF_CT_EXPECT_PERMANENT || !unlink) {

refcount_inc(&exp->use);

return exp;

nf_ct_unlink_expect(exp);

return exp;

}

nf_ct_put(exp->master);

return NULL;

hlist_for_each_entry_safe(exp, next,

&nf_ct_expect_hash[i],

hnode) {

nf_ct_unlink_expect(exp);

nf_ct_expect_put(exp);

}

if (!net_eq(nf_ct_exp_net(exp), net))

continue;

nf_ct_unlink_expect_report(exp, portid, report);

nf_ct_expect_put(exp);

}

/* after list removal, usage count == 1 */

spin_lock_bh(&nf_conntrack_expect_lock);

nf_ct_unlink_expect_report(exp, NETLINK_CB(skb).portid,

nlmsg_report(info->nlh));

nf_ct_expect_put(exp);

const struct nlattr * const cda[])

{

if (cda[CTA_EXPECT_TIMEOUT]) {

return -ETIME;

x->timeout.expires = jiffies +

err = nft_netdev_register_hooks(ctx->net, &hook.list);

if (err < 0)

goto err_hooks;

}

}

if (nla[NFTA_CHAIN_COUNTERS]) {

if (!nft_is_base_chain(chain)) {

err = -EOPNOTSUPP;

__nfulnl_flush(struct nfulnl_instance *inst)

{

/* timer holds a reference */

instance_put(inst);

if (inst->skb)

__nfulnl_send(inst);

nft_setelem_expr_foreach(expr, elem_expr, size) {

if (expr->ops->gc &&

return true;

}

NFT_PIPAPO_AVX2_BUCKET_LOAD8(5, lt, 8, pkt[8], bsize);

NFT_PIPAPO_AVX2_AND(6, 2, 3);

NFT_PIPAPO_AVX2_BUCKET_LOAD8(7, lt, 9, pkt[9], bsize);

NFT_PIPAPO_AVX2_BUCKET_LOAD8(1, lt, 10, pkt[10], bsize);

NFT_PIPAPO_AVX2_AND(2, 6, 7);

NFT_PIPAPO_AVX2_BUCKET_LOAD8(3, lt, 11, pkt[11], bsize);

static const struct nla_policy nft_tunnel_opts_geneve_policy[NFTA_TUNNEL_KEY_GENEVE_MAX + 1] = {

[NFTA_TUNNEL_KEY_GENEVE_CLASS] = { .type = NLA_U16 },

[NFTA_TUNNEL_KEY_GENEVE_TYPE] = { .type = NLA_U8 },

};

static int nft_tunnel_obj_geneve_init(const struct nlattr *attr,

struct nft_tunnel_opts *opts)

{

struct nlattr *tb[NFTA_TUNNEL_KEY_GENEVE_MAX + 1];

int err, data_len;

if (!inner)

goto failure;

while (opts->len > offset) {

if (nla_put_be16(skb, NFTA_TUNNEL_KEY_GENEVE_CLASS,

opt->opt_class) ||

nla_put_u8(skb, NFTA_TUNNEL_KEY_GENEVE_TYPE,

void nr_loopback_clear(void)

{

skb_queue_purge(&loopback_queue);

}

}

if (dev->ops->check_presence)

dev->ops->deactivate_target(dev, dev->active_target, mode);

dev->active_target = NULL;

}

if (dev->ops->check_presence)

rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb,

cb_context);

device_unlock(&dev->dev);

if (dev->ops->check_presence) {

cancel_work_sync(&dev->check_pres_work);

}

static void __nfc_hci_cmd_completion(struct nfc_hci_dev *hdev, int err,

struct sk_buff *skb)

{

if (hdev->cmd_pending_msg->cb)

hdev->cmd_pending_msg->cb(hdev->cmd_pending_msg->cb_context,

mutex_unlock(&hdev->msg_tx_mutex);

cancel_work_sync(&hdev->msg_tx_work);

cancel_work_sync(&hdev->msg_rx_work);

if (skb_queue_empty(&shdlc->ack_pending_q)) {

if (shdlc->t2_active) {

shdlc->t2_active = false;

pr_debug("All sent frames acked. Stopped T2(retransmit)\n");

if (llc_shdlc_x_lteq_y_lt_z(shdlc->dnr, y_nr, shdlc->ns)) {

if (shdlc->t2_active) {

shdlc->t2_active = false;

pr_debug("Stopped T2(retransmit)\n");

}

{

pr_debug("result=%d\n", r);

if (r == 0) {

shdlc->ns = 0;

(shdlc->rnr == false)) {

if (shdlc->t1_active) {

shdlc->t1_active = false;

pr_debug("Stopped T1(send ack)\n");

}

static void local_cleanup(struct nfc_llcp_local *local)

{

nfc_llcp_socket_release(local, false, ENXIO);

skb_queue_purge(&local->tx_queue);

cancel_work_sync(&local->tx_work);

cancel_work_sync(&local->rx_work);

cancel_work_sync(&local->timeout_work);

kfree_skb(local->rx_pending);

local->rx_pending = NULL;

cancel_work_sync(&local->sdreq_timeout_work);

nfc_llcp_free_sdp_tlv_list(&local->pending_sdreqs);

}

static void __nfc_llcp_recv(struct nfc_llcp_local *local, struct sk_buff *skb)

{

local->rx_pending = skb;

schedule_work(&local->rx_work);

}

* there is a queued/running cmd_work

*/

flush_workqueue(ndev->cmd_wq);

mutex_unlock(&ndev->req_lock);

return 0;

}

/* Flush cmd wq */

flush_workqueue(ndev->cmd_wq);

/* Clear flags except NCI_UNREG */

ndev->flags &= BIT(NCI_UNREG);

pr_debug("len %d, err %d\n", skb ? skb->len : 0, err);

/* data exchange is complete, stop the data timer */

clear_bit(NCI_DATA_EXCHANGE_TO, &ndev->flags);

if (cb) {

__u16 rsp_opcode = nci_opcode(skb->data);

/* we got a rsp, stop the cmd timer */

pr_debug("NCI RX: MT=rsp, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",

nci_pbf(skb->data),

(!NF_NAT || NF_NAT) && \

(!NETFILTER_CONNCOUNT || NETFILTER_CONNCOUNT)))

depends on PSAMPLE || !PSAMPLE

select MPLS

select NET_MPLS_GSO

select DST_CACHE

pskb_trim(skb, ovs_mac_header_len(key));

}

if (likely(!mru ||

(skb->len <= mru + vport->dev->hard_header_len))) {

ovs_vport_send(vport, skb, ovs_key_mac_proto(key));

static void prb_del_retire_blk_timer(struct tpacket_kbdq_core *pkc)

{

}

static void prb_shutdown_retire_blk_timer(struct packet_sock *po,

void rose_start_ftimer(struct rose_neigh *neigh)

{

neigh->ftimer.function = rose_ftimer_expiry;

neigh->ftimer.expires =

static void rose_start_t0timer(struct rose_neigh *neigh)

{

neigh->t0timer.function = rose_t0timer_expiry;

neigh->t0timer.expires =

void rose_stop_ftimer(struct rose_neigh *neigh)

{

}

void rose_stop_t0timer(struct rose_neigh *neigh)

{

}

int rose_ftimer_running(struct rose_neigh *neigh)

{

struct sk_buff *skb;

while ((skb = skb_dequeue(&loopback_queue)) != NULL) {

skb->sk = NULL;

{

struct rose_neigh *s;

skb_queue_purge(&rose_neigh->queue);

out:

if (__rxrpc_call_is_complete(call)) {

if (!test_bit(RXRPC_CALL_DISCONNECTED, &call->flags))

rxrpc_disconnect_call(call);

if (call->security)

{

struct rxrpc_call *call = container_of(work, struct rxrpc_call, destroyer);

rxrpc_cleanup_tx_buffers(call);

rxrpc_cleanup_rx_buffers(call);

ASSERTCMP(__rxrpc_call_state(call), ==, RXRPC_CALL_COMPLETE);

ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));

if (rcu_read_lock_held())

/* Can't use the rxrpc workqueue as we need to cancel/flush

local->kill_all_client_conns = true;

while ((conn = list_first_entry_or_null(&local->idle_client_conns,

struct rxrpc_connection, cache_link))) {

!conn->channels[3].call);

ASSERT(list_empty(&conn->cache_link));

cancel_work_sync(&conn->processor); /* Processing may restart the timer */

write_lock(&rxnet->conn_lock);

list_del_init(&conn->proc_link);

dead = __refcount_dec_and_test(&conn->ref, &r);

trace_rxrpc_conn(debug_id, r - 1, why);

if (dead) {

cancel_work(&conn->processor);

if (in_softirq() || work_busy(&conn->processor) ||

atomic_dec(&rxnet->nr_conns);

rxrpc_queue_work(&rxnet->service_conn_reaper);

flush_workqueue(rxrpc_workqueue);

struct rxrpc_net *rxnet = rxrpc_net(net);

rxnet->live = false;

cancel_work_sync(&rxnet->peer_keepalive_work);

/* Remove the timer again as the worker may have restarted it. */

rxrpc_destroy_all_calls(rxnet);

rxrpc_destroy_all_connections(rxnet);

rxrpc_destroy_all_peers(rxnet);

config NET_ACT_CSUM

tristate "Checksum Updating"

depends on NET_CLS_ACT && INET

help

Say Y here to update some common checksum after some direct

packet alterations.

[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS] = { .type = NLA_U16 },

[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE] = { .type = NLA_U8 },

[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA] = { .type = NLA_BINARY,

};

static const struct nla_policy

struct tcmsg *tcm;

struct nlmsghdr *nlh;

unsigned char *b = skb_tail_pointer(skb);

nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);

if (!nlh)

return skb->len;

out_nlmsg_trim:

nla_put_failure:

nlmsg_trim(skb, b);

}

static int tfilter_notify(struct net *net, struct sk_buff *oskb,

if (!unicast && !rtnl_notify_needed(net, n->nlmsg_flags, RTNLGRP_TC))

return 0;

if (unicast)

err = rtnl_unicast(skb, net, portid);

if (!rtnl_notify_needed(net, n->nlmsg_flags, RTNLGRP_TC))

return tp->ops->delete(tp, fh, last, rtnl_held, extack);

NL_SET_ERR_MSG(extack, "Failed to build del event notification");

}

err = tp->ops->delete(tp, fh, last, rtnl_held, extack);

[TCA_FLOWER_KEY_ENC_OPT_GENEVE_CLASS] = { .type = NLA_U16 },

[TCA_FLOWER_KEY_ENC_OPT_GENEVE_TYPE] = { .type = NLA_U8 },

[TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA] = { .type = NLA_BINARY,

};

static const struct nla_policy

&q->stats, qdisc_pkt_len, codel_get_enqueue_time,

drop_func, dequeue_func);

qdisc_tree_reduce_backlog(sch, q->stats.drop_count, q->stats.drop_len);

q->stats.drop_count = 0;

q->stats.drop_len = 0;

return -ENOBUFS;

gnet_stats_basic_sync_init(&cl->bstats);

cl->common.classid = classid;

cl->quantum = quantum;

cl->qdisc = qdisc_create_dflt(sch->dev_queue,

{

struct drr_class *cl = (struct drr_class *)arg;

}

static int drr_dump_class(struct Qdisc *sch, unsigned long arg,

if (unlikely(skb == NULL))

goto out;

if (cl->qdisc->q.qlen == 0)

bstats_update(&cl->bstats, skb);

qdisc_bstats_update(sch, skb);

for (i = 0; i < q->clhash.hashsize; i++) {

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

if (cl->qdisc->q.qlen)

qdisc_reset(cl->qdisc);

}

}

* to remove them.

*/

if (!ets_class_is_strict(q, cl) && sch->q.qlen)

}

static int ets_class_dump(struct Qdisc *sch, unsigned long arg,

if (unlikely(!skb))

goto out;

if (cl->qdisc->q.qlen == 0)

return ets_qdisc_dequeue_skb(sch, skb);

}

}

for (i = q->nbands; i < oldbands; i++) {

if (i >= q->nstrict && q->classes[i].qdisc->q.qlen)

qdisc_tree_flush_backlog(q->classes[i].qdisc);

}

WRITE_ONCE(q->nstrict, nstrict);

for (band = q->nstrict; band < q->nbands; band++) {

if (q->classes[band].qdisc->q.qlen)

}

for (band = 0; band < q->nbands; band++)

qdisc_reset(q->classes[band].qdisc);

}

qdisc_bstats_update(sch, skb);

flow->deficit -= qdisc_pkt_len(skb);

qdisc_tree_reduce_backlog(sch, q->cstats.drop_count,

q->cstats.drop_len);

q->cstats.drop_count = 0;

tcf_block_put(q->block);

q->p_params.tupdate = 0;

kvfree(q->flows);

}

static void netdev_watchdog_down(struct net_device *dev)

{

netif_tx_lock_bh(dev);

netdev_put(dev, &dev->watchdog_dev_tracker);

netif_tx_unlock_bh(dev);

}

static inline void

eltree_remove(struct hfsc_class *cl)

{

}

static inline void

/* vttree is now handled in update_vf() so that update_vf(cl, 0, 0)

* needs to be called explicitly to remove a class from vttree.

*/

if (cl->cl_flags & HFSC_RSC)

eltree_remove(cl);

}

{

struct htb_class *cl = (struct htb_class *)arg;

htb_deactivate(qdisc_priv(sch), cl);

}

struct pie_sched_data *q = qdisc_priv(sch);

q->params.tupdate = 0;

}

static struct Qdisc_ops pie_qdisc_ops __read_mostly = {

struct qfq_aggregate *agg = cl->agg;

if (list_empty(&agg->active)) /* agg is now inactive */

qfq_deactivate_agg(q, agg);

}

gnet_stats_basic_sync_init(&cl->bstats);

cl->common.classid = classid;

cl->deficit = lmax;

cl->qdisc = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,

classid, NULL);

cl->deficit -= (int) len;

if (cl->qdisc->q.qlen == 0) /* no more packets, remove from list */

else if (cl->deficit < qdisc_pkt_len(cl->qdisc->ops->peek(cl->qdisc))) {

cl->deficit += agg->lmax;

list_move_tail(&cl->alist, &agg->active);

struct qfq_sched *q = qdisc_priv(sch);

struct qfq_class *cl = (struct qfq_class *)arg;

qfq_deactivate_class(q, cl);

}

tcf_qevent_destroy(&q->qe_mark, sch);

tcf_qevent_destroy(&q->qe_early_drop, sch);

red_offload(sch, false);

qdisc_put(q->qdisc);

}

max_P);

red_set_vars(&q->vars);

if (ctl->flags & TC_RED_ADAPTATIVE)

mod_timer(&q->adapt_timer, jiffies + HZ/2);

struct red_parms *p = NULL;

struct sk_buff *to_free = NULL;

struct sk_buff *tail = NULL;

if (opt->nla_len < nla_attr_size(sizeof(*ctl)))

return -EINVAL;

if (!p)

return -ENOMEM;

}

sch_tree_lock(sch);

if (ctl->quantum)

if (ctl->flows)

if (ctl->divisor) {

}

if (ctl_v1) {

if (ctl_v1->depth)

if (p) {

ctl_v1->qth_min, ctl_v1->qth_max,

ctl_v1->Wlog,

ctl_v1->Plog, ctl_v1->Scell_log,

NULL,

ctl_v1->max_P);

}

}

if (ctl->limit) {

}

qlen = sch->q.qlen;

while (sch->q.qlen > q->limit) {

rtnl_kfree_skbs(to_free, tail);

qdisc_tree_reduce_backlog(sch, qlen - sch->q.qlen, dropped);

if (q->perturb_period) {

mod_timer(&q->perturb_timer, jiffies + q->perturb_period);

get_random_bytes(&q->perturbation, sizeof(q->perturbation));

tcf_block_put(q->block);

WRITE_ONCE(q->perturb_period, 0);

sfq_free(q->ht);

sfq_free(q->slots);

kfree(q->red_parms);

/* Check to update highest and lowest priorities. */

if (skb_queue_empty(lp_qdisc)) {

if (q->lowest_prio == q->highest_prio) {

q->lowest_prio = prio;

q->highest_prio = prio;

} else {

/* Update highest priority field. */

if (skb_queue_empty(hpq)) {

if (q->lowest_prio == q->highest_prio) {

q->highest_prio = 0;

q->lowest_prio = SKBPRIO_MAX_PRIORITY - 1;

} else {

tristate "The SCTP Protocol"

depends on INET

depends on IPV6 || IPV6=n

select CRYPTO

select CRYPTO_HMAC

select CRYPTO_SHA1

select NET_UDP_TUNNEL

help

Stream Control Transmission Protocol

* on our state.

*/

for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {

sctp_association_put(asoc);

}

/* Stop the SACK timer. */

timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];

sctp_association_put(asoc);

}

}

pr_debug("%s: unrecognized next header type "

"encountered!\n", __func__);

sctp_transport_put(t);

sctp_do_sm(net, SCTP_EVENT_T_OTHER,

SCTP_MIB_OUTCTRLCHUNKS);

asoc->stats.octrlchunks++;

asoc->peer.sack_needed = 0;

sctp_association_put(asoc);

}

}

* as the receiver acknowledged any data.

*/

if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&

sctp_association_put(asoc);

/* Mark the destination transport address as

* address.

*/

if (!transport->flight_size) {

sctp_transport_put(transport);

} else if (restart_timer) {

if (!mod_timer(&transport->T3_rtx_timer,

struct sctp_sockaddr_entry *temp;

spin_lock_bh(&net->sctp.addr_wq_lock);

list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {

list_del(&addrw->list);

kfree(addrw);

list_for_each_entry(t, &asoc->peer.transport_addr_list,

transports) {

sctp_transport_put(t);

}

}

list_for_each_entry(t, &asoc->peer.transport_addr_list,

transports) {

sctp_transport_put(t);

}

}

case SCTP_CMD_TIMER_STOP:

timer = &asoc->timers[cmd->obj.to];

sctp_association_put(asoc);

break;

/* Forward declarations for internal helper functions. */

static bool sctp_writeable(const struct sock *sk);

static void sctp_wfree(struct sk_buff *skb);

static int sctp_wait_for_packet(struct sock *sk, int *err, long *timeo_p);

static int sctp_wait_for_connect(struct sctp_association *, long *timeo_p);

static int sctp_wait_for_accept(struct sock *sk, long timeo);

if (sctp_wspace(asoc) <= 0 || !sk_wmem_schedule(sk, msg_len)) {

timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);

if (err)

goto err;

if (unlikely(sinfo->sinfo_stream >= asoc->stream.outcnt)) {

/* Helper function to wait for space in the sndbuf. */

{

struct sock *sk = asoc->base.sk;

long current_timeo = *timeo_p;

pr_debug("%s: asoc:%p, timeo:%ld, msg_len:%zu\n", __func__, asoc,

*timeo_p, msg_len);

sctp_association_hold(asoc);

/* Wait on the association specific sndbuf space. */

TASK_INTERRUPTIBLE);

if (asoc->base.dead)

goto do_dead;

goto do_nonblock;

if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING)

goto do_error;

out:

finish_wait(&asoc->wait, &wait);

sctp_association_put(asoc);

return err;

struct sctp_transport *t;

t = asoc->strreset_chunk->transport;

sctp_transport_put(t);

sctp_chunk_put(asoc->strreset_chunk);

struct sctp_transport *t;

t = asoc->strreset_chunk->transport;

sctp_transport_put(t);

sctp_chunk_put(asoc->strreset_chunk);

/* remove everything for this reconf request */

if (!asoc->strreset_outstanding) {

t = asoc->strreset_chunk->transport;

sctp_transport_put(t);

sctp_chunk_put(asoc->strreset_chunk);

return ret;

}

static int proc_sctp_do_udp_port(const struct ctl_table *ctl, int write,

void *buffer, size_t *lenp, loff_t *ppos)

{

if (new_value > max || new_value < min)

return -EINVAL;

net->sctp.udp_port = new_value;

sctp_udp_sock_stop(net);

if (new_value) {

lock_sock(sk);

sctp_sk(sk)->udp_port = htons(net->sctp.udp_port);

release_sock(sk);

}

return ret;

*/

void sctp_transport_free(struct sctp_transport *transport)

{

/* Try to delete the heartbeat timer. */

sctp_transport_put(transport);

/* Delete the T3_rtx timer if it's active.

* structure hang around in memory since we know

* the transport is going away.

*/

sctp_transport_put(transport);

sctp_transport_put(transport);

sctp_transport_put(transport);

/* Delete the ICMP proto unreachable timer if it's active. */

sctp_transport_put(transport);

sctp_transport_put(transport);

void sctp_transport_immediate_rtx(struct sctp_transport *t)

{

/* Stop pending T3_rtx_timer */

sctp_transport_put(t);

sctp_retransmit(&t->asoc->outqueue, t, SCTP_RTXR_T3_RTX);

spin_unlock(&xprt->queue_lock);

/* Turn off autodisconnect */

return 0;

}

* can only run *before* del_time_sync(), never after.

*/

spin_lock(&xprt->transport_lock);

spin_unlock(&xprt->transport_lock);

/*

if (unlikely(l->backlog[imp].len >= l->backlog[imp].limit)) {

if (imp == TIPC_SYSTEM_IMPORTANCE) {

pr_warn("%s<%s>, link overflow", link_rst_msg, l->name);

return -ENOBUFS;

}

rc = link_schedule_user(l, hdr);

trace_tipc_node_delete(node, true, " ");

tipc_node_delete_from_list(node);

tipc_node_put(node);

}

{

tipc_nametbl_unsubscribe(sub);

if (sub->evt.s.timeout != TIPC_WAIT_FOREVER)

list_del(&sub->sub_list);

tipc_sub_put(sub);

}

return do_tls_setsockopt(sk, optname, optval, optlen);

}

struct tls_context *tls_ctx_create(struct sock *sk)

{

struct inet_connection_sock *icsk = inet_csk(sk);

prot[TLS_BASE][TLS_BASE] = *base;

prot[TLS_BASE][TLS_BASE].setsockopt = tls_setsockopt;

prot[TLS_BASE][TLS_BASE].getsockopt = tls_getsockopt;

prot[TLS_BASE][TLS_BASE].close = tls_sk_proto_close;

prot[TLS_SW][TLS_BASE] = prot[TLS_BASE][TLS_BASE];

timeout = vsk->connect_timeout;

prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

if (flags & O_NONBLOCK) {

/* If we're not going to block, we schedule a timeout

* function to generate a timeout on the connection

trace_wiphy_delayed_work_queue(wiphy, &dwork->work, delay);

if (!delay) {

wiphy_work_queue(wiphy, &dwork->work);

return;

}

{

lockdep_assert_held(&wiphy->mtx);

wiphy_work_cancel(wiphy, &dwork->work);

}

EXPORT_SYMBOL_GPL(wiphy_delayed_work_cancel);

{

lockdep_assert_held(&wiphy->mtx);

wiphy_work_flush(wiphy, &dwork->work);

}

EXPORT_SYMBOL_GPL(wiphy_delayed_work_flush);

static inline void x25_stop_t20timer(struct x25_neigh *nb)

{

}

/*

void x25_stop_heartbeat(struct sock *sk)

{

}

void x25_start_t2timer(struct sock *sk)

void x25_stop_timer(struct sock *sk)

{

}

unsigned long x25_display_timer(struct sock *sk)

* if there is space in it. This avoids having to implement

* any buffering in the Tx path.

*/

goto out;

skb = xsk_build_skb(xs, &desc);

if (IS_ERR(skb)) {

{

BUG_ON(!policy->walk.dead);

BUG();

xfrm_dev_policy_free(policy);

atomic_inc(&policy->genid);

xfrm_pol_put(policy);

skb_queue_purge(&policy->polq.hold_queue);

xfrm_pol_put(policy);

/* XXX: Flush state cache */

spin_lock_bh(&pq->hold_queue.lock);

skb_queue_splice_init(&pq->hold_queue, &list);

xfrm_pol_put(old);

spin_unlock_bh(&pq->hold_queue.lock);

sched_next = jiffies + pq->timeout;

if (time_before(pq->hold_timer.expires, sched_next))

sched_next = pq->hold_timer.expires;

xfrm_pol_put(pol);

if (x->mode_cbs && x->mode_cbs->destroy_state)

x->mode_cbs->destroy_state(x);

hrtimer_cancel(&x->mtimer);

kfree(x->aead);

kfree(x->aalg);

kfree(x->ealg);