* @skb: skbuff
* @hlen: hardware length
* @iov: io vector
- *
+ *
* Caller _must_ check that skb will fit to this iovec.
*
* Returns: 0 - success.
* is linked into kernel lists and may not be freed until it has been
* removed from the kernel lists.
*
- * This call does not sleep therefore it can not
+ * This call does not sleep therefore it can not
* guarantee all CPU's that are in middle of receiving packets
* will see the new packet type (until the next received packet).
*/
* Remove a protocol handler that was previously added to the kernel
* protocol handlers by dev_add_pack(). The passed &packet_type is removed
* from the kernel lists and can be freed or reused once this function
- * returns.
+ * returns.
*
* The packet type might still be in use by receivers
* and must not be freed until after all the CPU's have gone
void dev_remove_pack(struct packet_type *pt)
{
__dev_remove_pack(pt);
-
+
synchronize_net();
}
* @mask: bitmask of bits in if_flags to check
*
* Search for any interface with the given flags. Returns NULL if a device
- * is not found or a pointer to the device. The device returned has
+ * is not found or a pointer to the device. The device returned has
* had a reference added and the pointer is safe until the user calls
* dev_put to indicate they have finished with it.
*/
void dev_load(const char *name)
{
- struct net_device *dev;
+ struct net_device *dev;
read_lock(&dev_base_lock);
dev = __dev_get_by_name(name);
clear_bit(__LINK_STATE_START, &dev->state);
}
- /*
+ /*
* If it went open OK then:
*/
* is returned on a failure.
*
* When registered all registration and up events are replayed
- * to the new notifier to allow device to have a race free
+ * to the new notifier to allow device to have a race free
* view of the network device list.
*/
for (dev = dev_base; dev; dev = dev->next) {
nb->notifier_call(nb, NETDEV_REGISTER, dev);
- if (dev->flags & IFF_UP)
+ if (dev->flags & IFF_UP)
nb->notifier_call(nb, NETDEV_UP, dev);
}
}
if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
netif_running(dev)) {
netif_wake_queue(dev);
- __netdev_watchdog_up(dev);
+ __netdev_watchdog_up(dev);
}
}
EXPORT_SYMBOL(netif_device_attach);
out_set_summed:
skb->ip_summed = CHECKSUM_NONE;
-out:
+out:
return ret;
}
void netdev_rx_csum_fault(struct net_device *dev)
{
if (net_ratelimit()) {
- printk(KERN_ERR "%s: hw csum failure.\n",
+ printk(KERN_ERR "%s: hw csum failure.\n",
dev ? dev->name : "<unknown>");
dump_stack();
}
if (unlikely(netif_queue_stopped(dev) && skb->next))
return NETDEV_TX_BUSY;
} while (skb->next);
-
+
skb->destructor = DEV_GSO_CB(skb)->destructor;
out_kfree_skb:
(!(dev->features & NETIF_F_GEN_CSUM) &&
(!(dev->features & NETIF_F_IP_CSUM) ||
skb->protocol != htons(ETH_P_IP))))
- if (skb_checksum_help(skb))
- goto out_kfree_skb;
+ if (skb_checksum_help(skb))
+ goto out_kfree_skb;
gso:
spin_lock_prefetch(&dev->queue_lock);
- /* Disable soft irqs for various locks below. Also
- * stops preemption for RCU.
+ /* Disable soft irqs for various locks below. Also
+ * stops preemption for RCU.
*/
- rcu_read_lock_bh();
+ rcu_read_lock_bh();
- /* Updates of qdisc are serialized by queue_lock.
- * The struct Qdisc which is pointed to by qdisc is now a
- * rcu structure - it may be accessed without acquiring
+ /* Updates of qdisc are serialized by queue_lock.
+ * The struct Qdisc which is pointed to by qdisc is now a
+ * rcu structure - it may be accessed without acquiring
* a lock (but the structure may be stale.) The freeing of the
- * qdisc will be deferred until it's known that there are no
+ * qdisc will be deferred until it's known that there are no
* more references to it.
- *
- * If the qdisc has an enqueue function, we still need to
+ *
+ * If the qdisc has an enqueue function, we still need to
* hold the queue_lock before calling it, since queue_lock
* also serializes access to the device queue.
*/
if (*pt_prev) {
*ret = deliver_skb(*pskb, *pt_prev, orig_dev);
*pt_prev = NULL;
- }
-
+ }
+
return br_handle_frame_hook(port, pskb);
}
#else
* when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
* a compare and 2 stores extra right now if we dont have it on
* but have CONFIG_NET_CLS_ACT
- * NOTE: This doesnt stop any functionality; if you dont have
+ * NOTE: This doesnt stop any functionality; if you dont have
* the ingress scheduler, you just cant add policies on ingress.
*
*/
-static int ing_filter(struct sk_buff *skb)
+static int ing_filter(struct sk_buff *skb)
{
struct Qdisc *q;
struct net_device *dev = skb->dev;
int result = TC_ACT_OK;
-
+
if (dev->qdisc_ingress) {
__u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
if (MAX_RED_LOOP < ttl++) {
list_for_each_entry_rcu(ptype, &ptype_all, list) {
if (!ptype->dev || ptype->dev == skb->dev) {
- if (pt_prev)
+ if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = ptype;
}
list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
if (ptype->type == type &&
(!ptype->dev || ptype->dev == skb->dev)) {
- if (pt_prev)
+ if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = ptype;
}
total += done;
}
}
- }
+ }
/*
* All done. Write the updated control block back to the caller.
struct netif_rx_stats *rc = NULL;
while (*pos < NR_CPUS)
- if (cpu_online(*pos)) {
+ if (cpu_online(*pos)) {
rc = &per_cpu(netdev_rx_stat, *pos);
break;
} else
}
slave->master = master;
-
+
synchronize_net();
if (old)
dev_mc_upload(dev);
printk(KERN_INFO "device %s %s promiscuous mode\n",
dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
- "left");
+ "left");
audit_log(current->audit_context, GFP_ATOMIC,
AUDIT_ANOM_PROMISCUOUS,
"dev=%s prom=%d old_prom=%d auid=%u",
dev->name, (dev->flags & IFF_PROMISC),
(old_flags & IFF_PROMISC),
- audit_get_loginuid(current->audit_context));
+ audit_get_loginuid(current->audit_context));
}
}
rtnl_unlock();
if (IW_IS_GET(cmd) &&
copy_to_user(arg, &ifr,
- sizeof(struct ifreq)))
+ sizeof(struct ifreq)))
ret = -EFAULT;
return ret;
}
goto out;
}
}
-
+
if (!dev_valid_name(dev->name)) {
ret = -EINVAL;
goto out;
= hlist_entry(p, struct net_device, name_hlist);
if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
ret = -EEXIST;
- goto out;
+ goto out;
}
- }
+ }
/* Fix illegal SG+CSUM combinations. */
if ((dev->features & NETIF_F_SG) &&
if (err < 0)
goto out;
}
-
+
err = register_netdevice(dev);
out:
rtnl_unlock();
* for netdevice notification, and cleanup and put back the
* reference if they receive an UNREGISTER event.
* We can get stuck here if buggy protocols don't correctly
- * call dev_put.
+ * call dev_put.
*/
static void netdev_wait_allrefs(struct net_device *dev)
{
* free_netdev - free network device
* @dev: device
*
- * This function does the last stage of destroying an allocated device
- * interface. The reference to the device object is released.
+ * This function does the last stage of destroying an allocated device
+ * interface. The reference to the device object is released.
* If this is the last reference then it will be freed.
*/
void free_netdev(struct net_device *dev)
kfree((char *)dev - dev->padded);
#endif
}
-
+
/* Synchronize with packet receive processing. */
-void synchronize_net(void)
+void synchronize_net(void)
{
might_sleep();
synchronize_rcu();
/* Shutdown queueing discipline. */
dev_shutdown(dev);
-
+
/* Notify protocols, that we are about to destroy
this device. They should clean all the things.
*/
raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
-
+
/*
* Flush the multicast chain
*/
goto out;
INIT_LIST_HEAD(&ptype_all);
- for (i = 0; i < 16; i++)
+ for (i = 0; i < 16; i++)
INIT_LIST_HEAD(&ptype_base[i]);
for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
/*
- * Linux NET3: Multicast List maintenance.
+ * Linux NET3: Multicast List maintenance.
*
* Authors:
- * Tim Kordas <tjk@nostromo.eeap.cwru.edu>
+ * Tim Kordas <tjk@nostromo.eeap.cwru.edu>
* Richard Underwood <richard@wuzz.demon.co.uk>
*
* Stir fried together from the IP multicast and CAP patches above
- * Alan Cox <Alan.Cox@linux.org>
+ * Alan Cox <Alan.Cox@linux.org>
*
* Fixes:
* Alan Cox : Update the device on a real delete
/*
- * Device multicast list maintenance.
+ * Device multicast list maintenance.
*
- * This is used both by IP and by the user level maintenance functions.
- * Unlike BSD we maintain a usage count on a given multicast address so
- * that a casual user application can add/delete multicasts used by
+ * This is used both by IP and by the user level maintenance functions.
+ * Unlike BSD we maintain a usage count on a given multicast address so
+ * that a casual user application can add/delete multicasts used by
* protocols without doing damage to the protocols when it deletes the
* entries. It also helps IP as it tracks overlapping maps.
*
/*
* Update the multicast list into the physical NIC controller.
*/
-
+
static void __dev_mc_upload(struct net_device *dev)
{
/* Don't do anything till we up the interface
/*
* Delete a device level multicast
*/
-
+
int dev_mc_delete(struct net_device *dev, void *addr, int alen, int glbl)
{
int err = 0;
* loaded filter is now wrong. Fix it
*/
__dev_mc_upload(dev);
-
+
netif_tx_unlock_bh(dev);
return 0;
}
/*
* Add a device level multicast
*/
-
+
int dev_mc_add(struct net_device *dev, void *addr, int alen, int glbl)
{
int err = 0;
dev->mc_count++;
__dev_mc_upload(dev);
-
+
netif_tx_unlock_bh(dev);
return 0;
void dev_mc_discard(struct net_device *dev)
{
netif_tx_lock_bh(dev);
-
+
while (dev->mc_list != NULL) {
struct dev_mc_list *tmp = dev->mc_list;
dev->mc_list = tmp->next;
read_lock(&dev_base_lock);
for (dev = dev_base; dev; dev = dev->next) {
- if (off++ == *pos)
+ if (off++ == *pos)
return dev;
}
return NULL;
* 4) All operations modify state, so a spinlock is used.
*/
static struct dst_entry *dst_garbage_list;
-#if RT_CACHE_DEBUG >= 2
+#if RT_CACHE_DEBUG >= 2
static atomic_t dst_total = ATOMIC_INIT(0);
#endif
static DEFINE_SPINLOCK(dst_lock);
dst->path = dst;
dst->input = dst_discard_in;
dst->output = dst_discard_out;
-#if RT_CACHE_DEBUG >= 2
+#if RT_CACHE_DEBUG >= 2
atomic_inc(&dst_total);
#endif
atomic_inc(&ops->entries);
dst->ops->destroy(dst);
if (dst->dev)
dev_put(dst->dev);
-#if RT_CACHE_DEBUG >= 2
+#if RT_CACHE_DEBUG >= 2
atomic_dec(&dst_total);
#endif
kmem_cache_free(dst->ops->kmem_cachep, dst);
#include <linux/netdevice.h>
#include <asm/uaccess.h>
-/*
+/*
* Some useful ethtool_ops methods that're device independent.
* If we find that all drivers want to do the same thing here,
* we can turn these into dev_() function calls.
unsigned char len = dev->addr_len;
if ( addr->size < len )
return -ETOOSMALL;
-
+
addr->size = len;
memcpy(data, dev->perm_addr, len);
return 0;
}
-
+
u32 ethtool_op_get_ufo(struct net_device *dev)
{
if (copy_from_user(&edata, useraddr, sizeof(edata)))
return -EFAULT;
- if (edata.data &&
+ if (edata.data &&
!(dev->features & NETIF_F_ALL_CSUM))
return -EINVAL;
default:
rc = -EOPNOTSUPP;
}
-
+
if(dev->ethtool_ops->complete)
dev->ethtool_ops->complete(dev);
}
static inline void *load_pointer(struct sk_buff *skb, int k,
- unsigned int size, void *buffer)
+ unsigned int size, void *buffer)
{
if (k >= 0)
return skb_header_pointer(skb, k, size, buffer);
*/
for (pc = 0; pc < flen; pc++) {
fentry = &filter[pc];
-
+
switch (fentry->code) {
case BPF_ALU|BPF_ADD|BPF_X:
A += X;
*/
int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
{
- struct sk_filter *fp;
+ struct sk_filter *fp;
unsigned int fsize = sizeof(struct sock_filter) * fprog->len;
int err;
if (!fp)
return -ENOMEM;
if (copy_from_user(fp->insns, fprog->filter, fsize)) {
- sock_kfree_s(sk, fp, fsize+sizeof(*fp));
+ sock_kfree_s(sk, fp, fsize+sizeof(*fp));
return -EFAULT;
}
* configuration TLV is created. Upon each interval, the latest statistics
* will be read from &bstats and the estimated rate will be stored in
* &rate_est with the statistics lock grabed during this period.
- *
+ *
* Returns 0 on success or a negative error code.
*/
int gen_new_estimator(struct gnet_stats_basic *bstats,
*
* Replaces the configuration of a rate estimator by calling
* gen_kill_estimator() and gen_new_estimator().
- *
+ *
* Returns 0 on success or a negative error code.
*/
int
gen_kill_estimator(bstats, rate_est);
return gen_new_estimator(bstats, rate_est, stats_lock, opt);
}
-
+
EXPORT_SYMBOL(gen_kill_estimator);
EXPORT_SYMBOL(gen_new_estimator);
int xstats_type, spinlock_t *lock, struct gnet_dump *d)
{
memset(d, 0, sizeof(*d));
-
+
spin_lock_bh(lock);
d->lock = lock;
if (type)
int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode)
{
int size, err, ct;
-
+
if (m->msg_namelen) {
if (mode == VERIFY_READ) {
err = move_addr_to_kernel(m->msg_name, m->msg_namelen,
*
* Note: this modifies the original iovec.
*/
-
+
int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
{
while (len > 0) {
*
* Note: this modifies the original iovec.
*/
-
+
int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len)
{
while (len > 0) {
if (partial_cnt) {
copy -= partial_cnt;
if (copy_from_user(kdata + copy, base + copy,
- partial_cnt))
+ partial_cnt))
goto out_fault;
}
}
kdata += copy + partial_cnt;
iov++;
}
- *csump = csum;
+ *csump = csum;
out:
return err;
dev_put(dev);
}
-}
+}
static void linkwatch_event(struct work_struct *dummy)
* per second so that a runaway driver does not
* cause a storm of messages on the netlink
* socket
- */
+ */
linkwatch_nextevent = jiffies + HZ;
clear_bit(LW_RUNNING, &linkwatch_flags);
struct neighbour *n;
int key_len = tbl->key_len;
u32 hash_val = tbl->hash(pkey, dev);
-
+
NEIGH_CACHE_STAT_INC(tbl, lookups);
read_lock_bh(&tbl->lock);
np = &n->next;
}
- /* Cycle through all hash buckets every base_reachable_time/2 ticks.
- * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
- * base_reachable_time.
+ /* Cycle through all hash buckets every base_reachable_time/2 ticks.
+ * ARP entry timeouts range from 1/2 base_reachable_time to 3/2
+ * base_reachable_time.
*/
expire = tbl->parms.base_reachable_time >> 1;
expire /= (tbl->hash_mask + 1);
}
if (state & NUD_REACHABLE) {
- if (time_before_eq(now,
+ if (time_before_eq(now,
neigh->confirmed + neigh->parms->reachable_time)) {
NEIGH_PRINTK2("neigh %p is still alive.\n", neigh);
next = neigh->confirmed + neigh->parms->reachable_time;
notify = 1;
}
} else if (state & NUD_DELAY) {
- if (time_before_eq(now,
+ if (time_before_eq(now,
neigh->confirmed + neigh->parms->delay_probe_time)) {
NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh);
neigh->nud_state = NUD_REACHABLE;
goto out_unlock_bh;
now = jiffies;
-
+
if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
if (neigh->parms->mcast_probes + neigh->parms->app_probes) {
atomic_set(&neigh->probes, neigh->parms->ucast_probes);
NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
if it is different.
NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
- lladdr instead of overriding it
+ lladdr instead of overriding it
if it is different.
It also allows to retain current state
if lladdr is unchanged.
NEIGH_UPDATE_F_ADMIN means that the change is administrative.
- NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
+ NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
NTF_ROUTER flag.
NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
a router.
old = neigh->nud_state;
err = -EPERM;
- if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
+ if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
(old & (NUD_NOARP | NUD_PERMANENT)))
goto out;
- compare new & old
- if they are different, check override flag
*/
- if ((old & NUD_VALID) &&
+ if ((old & NUD_VALID) &&
!memcmp(lladdr, neigh->ha, dev->addr_len))
lladdr = neigh->ha;
} else {
neigh_del_timer(neigh);
if (new & NUD_IN_TIMER) {
neigh_hold(neigh);
- neigh_add_timer(neigh, (jiffies +
- ((new & NUD_REACHABLE) ?
+ neigh_add_timer(neigh, (jiffies +
+ ((new & NUD_REACHABLE) ?
neigh->parms->reachable_time :
0)));
}
struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
lladdr || !dev->addr_len);
if (neigh)
- neigh_update(neigh, lladdr, NUD_STALE,
+ neigh_update(neigh, lladdr, NUD_STALE,
NEIGH_UPDATE_F_OVERRIDE);
return neigh;
}
if (dev->hard_header &&
dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
- skb->len) < 0 &&
+ skb->len) < 0 &&
dev->rebuild_header(skb))
return 0;
tbl->stats = alloc_percpu(struct neigh_statistics);
if (!tbl->stats)
panic("cannot create neighbour cache statistics");
-
+
#ifdef CONFIG_PROC_FS
tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat);
- if (!tbl->pde)
+ if (!tbl->pde)
panic("cannot create neighbour proc dir entry");
tbl->pde->proc_fops = &neigh_stat_seq_fops;
tbl->pde->data = tbl;
err = -ENOENT;
goto out_dev_put;
}
-
+
neigh = __neigh_lookup_errno(tbl, dst, dev);
if (IS_ERR(neigh)) {
err = PTR_ERR(neigh);
nlmsg_cancel(skb, nlh);
return -EMSGSIZE;
}
-
+
static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl,
int ifindex)
{
struct neigh_parms *p;
-
+
for (p = &tbl->parms; p; p = p->next)
if ((p->dev && p->dev->ifindex == ifindex) ||
(!p->dev && !ifindex))
goto errout_locked;
}
- /*
+ /*
* We acquire tbl->lock to be nice to the periodic timers and
* make sure they always see a consistent set of values.
*/
if (*pos == 0)
return SEQ_START_TOKEN;
-
+
for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
if (!cpu_possible(cpu))
continue;
};
int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
- int p_id, int pdev_id, char *p_name,
+ int p_id, int pdev_id, char *p_name,
proc_handler *handler, ctl_handler *strategy)
{
struct neigh_sysctl_table *t = kmemdup(&neigh_sysctl_template,
t->neigh_vars[14].procname = NULL;
t->neigh_vars[15].procname = NULL;
} else {
- dev_name_source = t->neigh_dev[0].procname;
+ dev_name_source = t->neigh_dev[0].procname;
t->neigh_vars[12].data = (int *)(p + 1);
t->neigh_vars[13].data = (int *)(p + 1) + 1;
t->neigh_vars[14].data = (int *)(p + 1) + 2;
goto free;
}
- t->neigh_dev[0].procname = dev_name;
+ t->neigh_dev[0].procname = dev_name;
t->neigh_neigh_dir[0].ctl_name = pdev_id;
* net-sysfs.c - network device class and attributes
*
* Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
static const char fmt_dec[] = "%d\n";
static const char fmt_ulong[] = "%lu\n";
-static inline int dev_isalive(const struct net_device *dev)
+static inline int dev_isalive(const struct net_device *dev)
{
return dev->reg_state <= NETREG_REGISTERED;
}
read_lock(&dev_base_lock);
if (dev_isalive(dev) && dev->get_stats &&
- (stats = (*dev->get_stats)(dev)))
+ (stats = (*dev->get_stats)(dev)))
ret = sprintf(buf, fmt_ulong,
*(unsigned long *)(((u8 *) stats) + offset));
struct net_device *dev = to_net_dev(d);
const struct iw_statistics *iw = NULL;
ssize_t ret = -EINVAL;
-
+
read_lock(&dev_base_lock);
if (dev_isalive(dev)) {
if(dev->wireless_handlers &&
#endif
/*
- * netdev_release -- destroy and free a dead device.
+ * netdev_release -- destroy and free a dead device.
* Called when last reference to device kobject is gone.
*/
static void netdev_release(struct device *d)
{
int status = NETDEV_TX_BUSY;
unsigned long tries;
- struct net_device *dev = np->dev;
- struct netpoll_info *npinfo = np->dev->npinfo;
+ struct net_device *dev = np->dev;
+ struct netpoll_info *npinfo = np->dev->npinfo;
- if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
- __kfree_skb(skb);
- return;
- }
+ if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
+ __kfree_skb(skb);
+ return;
+ }
/* don't get messages out of order, and no recursion */
if (skb_queue_len(&npinfo->txq) == 0 &&
}
atleast = jiffies + HZ/10;
- atmost = jiffies + 4*HZ;
+ atmost = jiffies + 4*HZ;
while (!netif_carrier_ok(ndev)) {
if (time_after(jiffies, atmost)) {
printk(KERN_NOTICE
np->dev->npinfo = NULL;
if (atomic_dec_and_test(&npinfo->refcnt)) {
skb_queue_purge(&npinfo->arp_tx);
- skb_queue_purge(&npinfo->txq);
+ skb_queue_purge(&npinfo->txq);
cancel_rearming_delayed_work(&npinfo->tx_work);
- flush_scheduled_work();
+ flush_scheduled_work();
kfree(npinfo);
}
*
*
* A tool for loading the network with preconfigurated packets.
- * The tool is implemented as a linux module. Parameters are output
+ * The tool is implemented as a linux module. Parameters are output
* device, delay (to hard_xmit), number of packets, and whether
* to use multiple SKBs or just the same one.
* pktgen uses the installed interface's output routine.
* * Add IOCTL interface to easily get counters & configuration.
* --Ben Greear <greearb@candelatech.com>
*
- * Renamed multiskb to clone_skb and cleaned up sending core for two distinct
- * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0
+ * Renamed multiskb to clone_skb and cleaned up sending core for two distinct
+ * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0
* as a "fastpath" with a configurable number of clones after alloc's.
- * clone_skb=0 means all packets are allocated this also means ranges time
- * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100
+ * clone_skb=0 means all packets are allocated this also means ranges time
+ * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100
* clones.
*
- * Also moved to /proc/net/pktgen/
+ * Also moved to /proc/net/pktgen/
* --ro
*
* Sept 10: Fixed threading/locking. Lots of bone-headed and more clever
*
* Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br)
*
- *
+ *
* 021124 Finished major redesign and rewrite for new functionality.
* See Documentation/networking/pktgen.txt for how to use this.
*
* The new operation:
- * For each CPU one thread/process is created at start. This process checks
- * for running devices in the if_list and sends packets until count is 0 it
- * also the thread checks the thread->control which is used for inter-process
- * communication. controlling process "posts" operations to the threads this
+ * For each CPU one thread/process is created at start. This process checks
+ * for running devices in the if_list and sends packets until count is 0 it
+ * also the thread checks the thread->control which is used for inter-process
+ * communication. controlling process "posts" operations to the threads this
* way. The if_lock should be possible to remove when add/rem_device is merged
* into this too.
*
- * By design there should only be *one* "controlling" process. In practice
- * multiple write accesses gives unpredictable result. Understood by "write"
+ * By design there should only be *one* "controlling" process. In practice
+ * multiple write accesses gives unpredictable result. Understood by "write"
* to /proc gives result code thats should be read be the "writer".
* For practical use this should be no problem.
*
- * Note when adding devices to a specific CPU there good idea to also assign
- * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.
+ * Note when adding devices to a specific CPU there good idea to also assign
+ * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.
* --ro
*
- * Fix refcount off by one if first packet fails, potential null deref,
+ * Fix refcount off by one if first packet fails, potential null deref,
* memleak 030710- KJP
*
* First "ranges" functionality for ipv6 030726 --ro
* Included flow support. 030802 ANK.
*
* Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org>
- *
+ *
* Remove if fix from added Harald Welte <laforge@netfilter.org> 040419
* ia64 compilation fix from Aron Griffis <aron@hp.com> 040604
*
- * New xmit() return, do_div and misc clean up by Stephen Hemminger
+ * New xmit() return, do_div and misc clean up by Stephen Hemminger
* <shemminger@osdl.org> 040923
*
- * Randy Dunlap fixed u64 printk compiler waring
+ * Randy Dunlap fixed u64 printk compiler waring
*
* Remove FCS from BW calculation. Lennert Buytenhek <buytenh@wantstofly.org>
* New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213
*
- * Corrections from Nikolai Malykh (nmalykh@bilim.com)
+ * Corrections from Nikolai Malykh (nmalykh@bilim.com)
* Removed unused flags F_SET_SRCMAC & F_SET_SRCIP 041230
*
- * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com>
+ * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com>
* 050103
*
* MPLS support by Steven Whitehouse <steve@chygwyn.com>
/*
* How do we know if the architecture we are running on
* supports division with 64 bit base?
- *
+ *
*/
#if defined(__sparc_v9__) || defined(__powerpc64__) || defined(__alpha__) || defined(__x86_64__) || defined(__ia64__)
};
/*
- * /proc handling functions
+ * /proc handling functions
*
*/
if (pkt_dev->flags & F_IPV6) {
/*
- * Skip this automatic address setting until locks or functions
+ * Skip this automatic address setting until locks or functions
* gets exported
*/
}
/*
- * scan_ip6, fmt_ip taken from dietlibc-0.21
+ * scan_ip6, fmt_ip taken from dietlibc-0.21
* Author Felix von Leitner <felix-dietlibc@fefe.de>
*
- * Slightly modified for kernel.
+ * Slightly modified for kernel.
* Should be candidate for net/ipv4/utils.c
* --ro
*/
out:;
}
-/*
+/*
* Main loop of the thread goes here
*/
return pkt_dev;
}
-/*
- * Adds a dev at front of if_list.
+/*
+ * Adds a dev at front of if_list.
*/
static int add_dev_to_thread(struct pktgen_thread *t,
return 0;
}
-/*
- * Removes a device from the thread if_list.
+/*
+ * Removes a device from the thread if_list.
*/
static void _rem_dev_from_if_list(struct pktgen_thread *t,
struct pktgen_dev *pkt_dev)
panic("rtnetlink_init: cannot allocate rta_buf\n");
rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv,
- THIS_MODULE);
+ THIS_MODULE);
if (rtnl == NULL)
panic("rtnetlink_init: cannot initialize rtnetlink\n");
netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV);
/*
- * Only allow a user to send credentials, that they could set with
+ * Only allow a user to send credentials, that they could set with
* setu(g)id.
*/
if (fpl->count + num > SCM_MAX_FD)
return -EINVAL;
-
+
/*
* Verify the descriptors and increment the usage count.
*/
-
+
for (i=0; i< num; i++)
{
int fd = fdp[i];
/* The first check was omitted in <= 2.2.5. The reasoning was
that parser checks cmsg_len in any case, so that
additional check would be work duplication.
- But if cmsg_level is not SOL_SOCKET, we do not check
+ But if cmsg_level is not SOL_SOCKET, we do not check
for too short ancillary data object at all! Oops.
OK, let's add it...
*/
p->fp = NULL;
}
return 0;
-
+
error:
scm_destroy(p);
return err;
err = -EFAULT;
if (copy_to_user(cm, &cmhdr, sizeof cmhdr))
- goto out;
+ goto out;
if (copy_to_user(CMSG_DATA(cm), data, cmlen - sizeof(struct cmsghdr)))
goto out;
cmlen = CMSG_SPACE(len);
void skb_over_panic(struct sk_buff *skb, int sz, void *here)
{
printk(KERN_EMERG "skb_over_panic: text:%p len:%d put:%d head:%p "
- "data:%p tail:%p end:%p dev:%s\n",
+ "data:%p tail:%p end:%p dev:%s\n",
here, skb->len, sz, skb->head, skb->data, skb->tail, skb->end,
skb->dev ? skb->dev->name : "<NULL>");
BUG();
void skb_under_panic(struct sk_buff *skb, int sz, void *here)
{
printk(KERN_EMERG "skb_under_panic: text:%p len:%d put:%d head:%p "
- "data:%p tail:%p end:%p dev:%s\n",
+ "data:%p tail:%p end:%p dev:%s\n",
here, skb->len, sz, skb->head, skb->data, skb->tail, skb->end,
skb->dev ? skb->dev->name : "<NULL>");
BUG();
int node = dev->dev.parent ? dev_to_node(dev->dev.parent) : -1;
struct sk_buff *skb;
- skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask, 0, node);
+ skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask, 0, node);
if (likely(skb)) {
skb_reserve(skb, NET_SKB_PAD);
skb->dev = dev;
*
* May return error in out of memory cases. The skb is freed on error.
*/
-
+
int skb_pad(struct sk_buff *skb, int pad)
{
int err;
int ntail;
-
+
/* If the skbuff is non linear tailroom is always zero.. */
if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {
memset(skb->data+skb->len, 0, pad);
free_skb:
kfree_skb(skb);
return err;
-}
-
+}
+
/* Trims skb to length len. It can change skb pointers.
*/
* Alan Cox : TCP ack handling is buggy, the DESTROY timer
* was buggy. Put a remove_sock() in the handler
* for memory when we hit 0. Also altered the timer
- * code. The ACK stuff can wait and needs major
+ * code. The ACK stuff can wait and needs major
* TCP layer surgery.
* Alan Cox : Fixed TCP ack bug, removed remove sock
* and fixed timer/inet_bh race.
{
static int warned;
static char warncomm[TASK_COMM_LEN];
- if (strcmp(warncomm, current->comm) && warned < 5) {
- strcpy(warncomm, current->comm);
+ if (strcmp(warncomm, current->comm) && warned < 5) {
+ strcpy(warncomm, current->comm);
printk(KERN_WARNING "process `%s' is using obsolete "
"%s SO_BSDCOMPAT\n", warncomm, name);
warned++;
}
static void sock_disable_timestamp(struct sock *sk)
-{
- if (sock_flag(sk, SOCK_TIMESTAMP)) {
+{
+ if (sock_flag(sk, SOCK_TIMESTAMP)) {
sock_reset_flag(sk, SOCK_TIMESTAMP);
net_disable_timestamp();
}
int valbool;
struct linger ling;
int ret = 0;
-
+
/*
* Options without arguments
*/
return 0;
}
#endif
-
- if(optlen<sizeof(int))
- return(-EINVAL);
-
+
+ if(optlen<sizeof(int))
+ return(-EINVAL);
+
if (get_user(val, (int __user *)optval))
return -EFAULT;
-
- valbool = val?1:0;
+
+ valbool = val?1:0;
lock_sock(sk);
- switch(optname)
- {
- case SO_DEBUG:
+ switch(optname)
+ {
+ case SO_DEBUG:
if(val && !capable(CAP_NET_ADMIN))
{
ret = -EACCES;
case SO_TYPE:
case SO_ERROR:
ret = -ENOPROTOOPT;
- break;
+ break;
case SO_DONTROUTE:
if (valbool)
sock_set_flag(sk, SOCK_LOCALROUTE);
about it this is right. Otherwise apps have to
play 'guess the biggest size' games. RCVBUF/SNDBUF
are treated in BSD as hints */
-
+
if (val > sysctl_wmem_max)
val = sysctl_wmem_max;
set_sndbuf:
about it this is right. Otherwise apps have to
play 'guess the biggest size' games. RCVBUF/SNDBUF
are treated in BSD as hints */
-
+
if (val > sysctl_rmem_max)
val = sysctl_rmem_max;
set_rcvbuf:
sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
break;
- case SO_OOBINLINE:
+ case SO_OOBINLINE:
sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
break;
- case SO_NO_CHECK:
+ case SO_NO_CHECK:
sk->sk_no_check = valbool;
break;
case SO_PRIORITY:
- if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
+ if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
sk->sk_priority = val;
else
ret = -EPERM;
#ifdef CONFIG_NETDEVICES
case SO_BINDTODEVICE:
{
- char devname[IFNAMSIZ];
+ char devname[IFNAMSIZ];
- /* Sorry... */
+ /* Sorry... */
if (!capable(CAP_NET_RAW)) {
ret = -EPERM;
break;
/* Bind this socket to a particular device like "eth0",
* as specified in the passed interface name. If the
- * name is "" or the option length is zero the socket
- * is not bound.
- */
+ * name is "" or the option length is zero the socket
+ * is not bound.
+ */
if (!valbool) {
sk->sk_bound_dev_if = 0;
case SO_DETACH_FILTER:
rcu_read_lock_bh();
filter = rcu_dereference(sk->sk_filter);
- if (filter) {
+ if (filter) {
rcu_assign_pointer(sk->sk_filter, NULL);
sk_filter_release(sk, filter);
rcu_read_unlock_bh();
/* We implement the SO_SNDLOWAT etc to
not be settable (1003.1g 5.3) */
default:
- ret = -ENOPROTOOPT;
+ ret = -ENOPROTOOPT;
break;
- }
+ }
release_sock(sk);
return ret;
}
char __user *optval, int __user *optlen)
{
struct sock *sk = sock->sk;
-
+
union
{
- int val;
- struct linger ling;
+ int val;
+ struct linger ling;
struct timeval tm;
} v;
-
+
unsigned int lv = sizeof(int);
int len;
-
- if(get_user(len,optlen))
- return -EFAULT;
+
+ if(get_user(len,optlen))
+ return -EFAULT;
if(len < 0)
return -EINVAL;
-
- switch(optname)
- {
- case SO_DEBUG:
+
+ switch(optname)
+ {
+ case SO_DEBUG:
v.val = sock_flag(sk, SOCK_DBG);
break;
-
+
case SO_DONTROUTE:
v.val = sock_flag(sk, SOCK_LOCALROUTE);
break;
-
+
case SO_BROADCAST:
v.val = !!sock_flag(sk, SOCK_BROADCAST);
break;
case SO_SNDBUF:
v.val = sk->sk_sndbuf;
break;
-
+
case SO_RCVBUF:
v.val = sk->sk_rcvbuf;
break;
break;
case SO_TYPE:
- v.val = sk->sk_type;
+ v.val = sk->sk_type;
break;
case SO_ERROR:
case SO_OOBINLINE:
v.val = !!sock_flag(sk, SOCK_URGINLINE);
break;
-
+
case SO_NO_CHECK:
v.val = sk->sk_no_check;
break;
case SO_PRIORITY:
v.val = sk->sk_priority;
break;
-
- case SO_LINGER:
+
+ case SO_LINGER:
lv = sizeof(v.ling);
v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
- v.ling.l_linger = sk->sk_lingertime / HZ;
+ v.ling.l_linger = sk->sk_lingertime / HZ;
break;
-
+
case SO_BSDCOMPAT:
sock_warn_obsolete_bsdism("getsockopt");
break;
case SO_SNDLOWAT:
v.val=1;
- break;
+ break;
case SO_PASSCRED:
v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
if (copy_to_user(optval, &v, len))
return -EFAULT;
lenout:
- if (put_user(len, optlen))
- return -EFAULT;
- return 0;
+ if (put_user(len, optlen))
+ return -EFAULT;
+ return 0;
}
/*
sk->sk_prot = sk->sk_prot_creator = prot;
sock_lock_init(sk);
}
-
+
if (security_sk_alloc(sk, family, priority))
goto out_free;
*/
-/*
- * Write buffer destructor automatically called from kfree_skb.
+/*
+ * Write buffer destructor automatically called from kfree_skb.
*/
void sock_wfree(struct sk_buff *skb)
{
sock_put(sk);
}
-/*
- * Read buffer destructor automatically called from kfree_skb.
+/*
+ * Read buffer destructor automatically called from kfree_skb.
*/
void sock_rfree(struct sk_buff *skb)
{
/*
* Allocate a skb from the socket's receive buffer.
- */
+ */
struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
gfp_t priority)
{
return NULL;
}
-/*
+/*
* Allocate a memory block from the socket's option memory buffer.
- */
+ */
void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
{
if ((unsigned)size <= sysctl_optmem_max &&
atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
void *mem;
/* First do the add, to avoid the race if kmalloc
- * might sleep.
+ * might sleep.
*/
atomic_add(size, &sk->sk_omem_alloc);
mem = kmalloc(size, priority);
return NULL;
}
-struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
+struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
int noblock, int *errcode)
{
return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
return -EOPNOTSUPP;
}
-int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
+int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
int len, int flags)
{
return -EOPNOTSUPP;
return -EOPNOTSUPP;
}
-int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
+int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
int *len, int peer)
{
return -EOPNOTSUPP;
read_lock(&sk->sk_callback_lock);
if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
wake_up_interruptible(sk->sk_sleep);
- sk_wake_async(sk,0,POLL_ERR);
+ sk_wake_async(sk,0,POLL_ERR);
read_unlock(&sk->sk_callback_lock);
}
sk->sk_send_head = NULL;
init_timer(&sk->sk_timer);
-
+
sk->sk_allocation = GFP_KERNEL;
sk->sk_rcvbuf = sysctl_rmem_default;
sk->sk_sndbuf = sysctl_wmem_default;
EXPORT_SYMBOL(release_sock);
int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
-{
+{
if (!sock_flag(sk, SOCK_TIMESTAMP))
sock_enable_timestamp(sk);
- if (sk->sk_stamp.tv_sec == -1)
+ if (sk->sk_stamp.tv_sec == -1)
return -ENOENT;
if (sk->sk_stamp.tv_sec == 0)
do_gettimeofday(&sk->sk_stamp);
return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ?
- -EFAULT : 0;
-}
+ -EFAULT : 0;
+}
EXPORT_SYMBOL(sock_get_timestamp);
void sock_enable_timestamp(struct sock *sk)
-{
- if (!sock_flag(sk, SOCK_TIMESTAMP)) {
+{
+ if (!sock_flag(sk, SOCK_TIMESTAMP)) {
sock_set_flag(sk, SOCK_TIMESTAMP);
net_enable_timestamp();
}
}
-EXPORT_SYMBOL(sock_enable_timestamp);
+EXPORT_SYMBOL(sock_enable_timestamp);
/*
* Get a socket option on an socket.
sk->sk_write_pending++;
done = sk_wait_event(sk, timeo_p,
!sk->sk_err &&
- !((1 << sk->sk_state) &
+ !((1 << sk->sk_state) &
~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));
finish_wait(sk->sk_sleep, &wait);
sk->sk_write_pending--;
set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
sk->sk_write_pending++;
- sk_wait_event(sk, ¤t_timeo, !sk->sk_err &&
+ sk_wait_event(sk, ¤t_timeo, !sk->sk_err &&
!(sk->sk_shutdown & SEND_SHUTDOWN) &&
sk_stream_memory_free(sk) &&
vm_wait);
if (copy > len)
copy = len;
cookie = dma_memcpy_to_iovec(chan, to, pinned_list,
- skb->data + offset, copy);
+ skb->data + offset, copy);
if (cookie < 0)
goto fault;
len -= copy;
if (copy > len)
copy = len;
cookie = dma_skb_copy_datagram_iovec(chan, list,
- offset - start, to, copy,
- pinned_list);
+ offset - start, to, copy,
+ pinned_list);
if (cookie < 0)
goto fault;
len -= copy;
}
fault:
- return -EFAULT;
+ return -EFAULT;
}
int net_msg_cost = 5*HZ;
int net_msg_burst = 10;
-/*
+/*
* All net warning printk()s should be guarded by this function.
- */
+ */
int net_ratelimit(void)
{
return __printk_ratelimit(net_msg_cost, net_msg_burst);
.header_type = IW_HEADER_TYPE_ADDR,
},
[IWEVEXPIRED - IWEVFIRST] = {
- .header_type = IW_HEADER_TYPE_ADDR,
+ .header_type = IW_HEADER_TYPE_ADDR,
},
[IWEVGENIE - IWEVFIRST] = {
.header_type = IW_HEADER_TYPE_POINT,
.max_tokens = IW_GENERIC_IE_MAX,
},
[IWEVMICHAELMICFAILURE - IWEVFIRST] = {
- .header_type = IW_HEADER_TYPE_POINT,
+ .header_type = IW_HEADER_TYPE_POINT,
.token_size = 1,
.max_tokens = sizeof(struct iw_michaelmicfailure),
},
dev->name, stats->status, stats->qual.qual,
stats->qual.updated & IW_QUAL_QUAL_UPDATED
? '.' : ' ',
- ((__s32) stats->qual.level) -
+ ((__s32) stats->qual.level) -
((stats->qual.updated & IW_QUAL_DBM) ? 0x100 : 0),
stats->qual.updated & IW_QUAL_LEVEL_UPDATED
? '.' : ' ',
- ((__s32) stats->qual.noise) -
+ ((__s32) stats->qual.noise) -
((stats->qual.updated & IW_QUAL_DBM) ? 0x100 : 0),
stats->qual.updated & IW_QUAL_NOISE_UPDATED
? '.' : ' ',
iwr->u.data.length *
descr->token_size);
if (err)
- ret = -EFAULT;
+ ret = -EFAULT;
#ifdef WE_IOCTL_DEBUG
printk(KERN_DEBUG "%s (WE) : Wrote %d bytes\n",
dev->name,
err = copy_to_user(iwr->u.data.pointer, extra,
extra_size);
if (err)
- ret = -EFAULT;
+ ret = -EFAULT;
#ifdef WE_IOCTL_DEBUG
printk(KERN_DEBUG "%s (WE) : Wrote %d elem\n",
dev->name, iwr->u.data.length);
/* A bunch of special cases, then the generic case...
* Note that 'cmd' is already filtered in dev_ioctl() with
* (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) */
- switch(cmd)
+ switch(cmd)
{
case SIOCGIWSTATS:
/* Get Wireless Stats */
* The best the driver could do is to log an error message.
* We will do it ourselves instead...
*/
- printk(KERN_ERR "%s (WE) : Invalid/Unknown Wireless Event (0x%04X)\n",
+ printk(KERN_ERR "%s (WE) : Invalid/Unknown Wireless Event (0x%04X)\n",
dev->name, cmd);
return;
}
if(descr->header_type == IW_HEADER_TYPE_POINT) {
/* Check if number of token fits within bounds */
if(wrqu->data.length > descr->max_tokens) {
- printk(KERN_ERR "%s (WE) : Wireless Event too big (%d)\n", dev->name, wrqu->data.length);
+ printk(KERN_ERR "%s (WE) : Wireless Event too big (%d)\n", dev->name, wrqu->data.length);
return;
}
if(wrqu->data.length < descr->min_tokens) {
- printk(KERN_ERR "%s (WE) : Wireless Event too small (%d)\n", dev->name, wrqu->data.length);
+ printk(KERN_ERR "%s (WE) : Wireless Event too small (%d)\n", dev->name, wrqu->data.length);
return;
}
/* Calculate extra_len - extra is NULL for restricted events */
projects / linux-2.6-omap-h63xx.git / commitdiff