![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
412 lines
9.7 KiB
C
412 lines
9.7 KiB
C
/*
|
|
* Generic HDLC support routines for Linux
|
|
* Cisco HDLC support
|
|
*
|
|
* Copyright (C) 2000 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of version 2 of the GNU General Public License
|
|
* as published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/hdlc.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/inetdevice.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pkt_sched.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/skbuff.h>
|
|
|
|
#undef DEBUG_HARD_HEADER
|
|
|
|
#define CISCO_MULTICAST 0x8F /* Cisco multicast address */
|
|
#define CISCO_UNICAST 0x0F /* Cisco unicast address */
|
|
#define CISCO_KEEPALIVE 0x8035 /* Cisco keepalive protocol */
|
|
#define CISCO_SYS_INFO 0x2000 /* Cisco interface/system info */
|
|
#define CISCO_ADDR_REQ 0 /* Cisco address request */
|
|
#define CISCO_ADDR_REPLY 1 /* Cisco address reply */
|
|
#define CISCO_KEEPALIVE_REQ 2 /* Cisco keepalive request */
|
|
|
|
|
|
struct hdlc_header {
|
|
u8 address;
|
|
u8 control;
|
|
__be16 protocol;
|
|
}__attribute__ ((packed));
|
|
|
|
|
|
struct cisco_packet {
|
|
__be32 type; /* code */
|
|
__be32 par1;
|
|
__be32 par2;
|
|
__be16 rel; /* reliability */
|
|
__be32 time;
|
|
}__attribute__ ((packed));
|
|
#define CISCO_PACKET_LEN 18
|
|
#define CISCO_BIG_PACKET_LEN 20
|
|
|
|
|
|
struct cisco_state {
|
|
cisco_proto settings;
|
|
|
|
struct timer_list timer;
|
|
spinlock_t lock;
|
|
unsigned long last_poll;
|
|
int up;
|
|
u32 txseq; /* TX sequence number, 0 = none */
|
|
u32 rxseq; /* RX sequence number */
|
|
};
|
|
|
|
|
|
static int cisco_ioctl(struct net_device *dev, struct ifreq *ifr);
|
|
|
|
|
|
static inline struct cisco_state* state(hdlc_device *hdlc)
|
|
{
|
|
return (struct cisco_state *)hdlc->state;
|
|
}
|
|
|
|
|
|
static int cisco_hard_header(struct sk_buff *skb, struct net_device *dev,
|
|
u16 type, const void *daddr, const void *saddr,
|
|
unsigned int len)
|
|
{
|
|
struct hdlc_header *data;
|
|
#ifdef DEBUG_HARD_HEADER
|
|
printk(KERN_DEBUG "%s: cisco_hard_header called\n", dev->name);
|
|
#endif
|
|
|
|
skb_push(skb, sizeof(struct hdlc_header));
|
|
data = (struct hdlc_header*)skb->data;
|
|
if (type == CISCO_KEEPALIVE)
|
|
data->address = CISCO_MULTICAST;
|
|
else
|
|
data->address = CISCO_UNICAST;
|
|
data->control = 0;
|
|
data->protocol = htons(type);
|
|
|
|
return sizeof(struct hdlc_header);
|
|
}
|
|
|
|
|
|
|
|
static void cisco_keepalive_send(struct net_device *dev, u32 type,
|
|
__be32 par1, __be32 par2)
|
|
{
|
|
struct sk_buff *skb;
|
|
struct cisco_packet *data;
|
|
|
|
skb = dev_alloc_skb(sizeof(struct hdlc_header) +
|
|
sizeof(struct cisco_packet));
|
|
if (!skb) {
|
|
printk(KERN_WARNING
|
|
"%s: Memory squeeze on cisco_keepalive_send()\n",
|
|
dev->name);
|
|
return;
|
|
}
|
|
skb_reserve(skb, 4);
|
|
cisco_hard_header(skb, dev, CISCO_KEEPALIVE, NULL, NULL, 0);
|
|
data = (struct cisco_packet*)(skb->data + 4);
|
|
|
|
data->type = htonl(type);
|
|
data->par1 = par1;
|
|
data->par2 = par2;
|
|
data->rel = cpu_to_be16(0xFFFF);
|
|
/* we will need do_div here if 1000 % HZ != 0 */
|
|
data->time = htonl((jiffies - INITIAL_JIFFIES) * (1000 / HZ));
|
|
|
|
skb_put(skb, sizeof(struct cisco_packet));
|
|
skb->priority = TC_PRIO_CONTROL;
|
|
skb->dev = dev;
|
|
skb_reset_network_header(skb);
|
|
|
|
dev_queue_xmit(skb);
|
|
}
|
|
|
|
|
|
|
|
static __be16 cisco_type_trans(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
struct hdlc_header *data = (struct hdlc_header*)skb->data;
|
|
|
|
if (skb->len < sizeof(struct hdlc_header))
|
|
return cpu_to_be16(ETH_P_HDLC);
|
|
|
|
if (data->address != CISCO_MULTICAST &&
|
|
data->address != CISCO_UNICAST)
|
|
return cpu_to_be16(ETH_P_HDLC);
|
|
|
|
switch (data->protocol) {
|
|
case cpu_to_be16(ETH_P_IP):
|
|
case cpu_to_be16(ETH_P_IPX):
|
|
case cpu_to_be16(ETH_P_IPV6):
|
|
skb_pull(skb, sizeof(struct hdlc_header));
|
|
return data->protocol;
|
|
default:
|
|
return cpu_to_be16(ETH_P_HDLC);
|
|
}
|
|
}
|
|
|
|
|
|
static int cisco_rx(struct sk_buff *skb)
|
|
{
|
|
struct net_device *dev = skb->dev;
|
|
hdlc_device *hdlc = dev_to_hdlc(dev);
|
|
struct cisco_state *st = state(hdlc);
|
|
struct hdlc_header *data = (struct hdlc_header*)skb->data;
|
|
struct cisco_packet *cisco_data;
|
|
struct in_device *in_dev;
|
|
__be32 addr, mask;
|
|
u32 ack;
|
|
|
|
if (skb->len < sizeof(struct hdlc_header))
|
|
goto rx_error;
|
|
|
|
if (data->address != CISCO_MULTICAST &&
|
|
data->address != CISCO_UNICAST)
|
|
goto rx_error;
|
|
|
|
switch (ntohs(data->protocol)) {
|
|
case CISCO_SYS_INFO:
|
|
/* Packet is not needed, drop it. */
|
|
dev_kfree_skb_any(skb);
|
|
return NET_RX_SUCCESS;
|
|
|
|
case CISCO_KEEPALIVE:
|
|
if ((skb->len != sizeof(struct hdlc_header) +
|
|
CISCO_PACKET_LEN) &&
|
|
(skb->len != sizeof(struct hdlc_header) +
|
|
CISCO_BIG_PACKET_LEN)) {
|
|
printk(KERN_INFO "%s: Invalid length of Cisco control"
|
|
" packet (%d bytes)\n", dev->name, skb->len);
|
|
goto rx_error;
|
|
}
|
|
|
|
cisco_data = (struct cisco_packet*)(skb->data + sizeof
|
|
(struct hdlc_header));
|
|
|
|
switch (ntohl (cisco_data->type)) {
|
|
case CISCO_ADDR_REQ: /* Stolen from syncppp.c :-) */
|
|
in_dev = dev->ip_ptr;
|
|
addr = 0;
|
|
mask = ~cpu_to_be32(0); /* is the mask correct? */
|
|
|
|
if (in_dev != NULL) {
|
|
struct in_ifaddr **ifap = &in_dev->ifa_list;
|
|
|
|
while (*ifap != NULL) {
|
|
if (strcmp(dev->name,
|
|
(*ifap)->ifa_label) == 0) {
|
|
addr = (*ifap)->ifa_local;
|
|
mask = (*ifap)->ifa_mask;
|
|
break;
|
|
}
|
|
ifap = &(*ifap)->ifa_next;
|
|
}
|
|
|
|
cisco_keepalive_send(dev, CISCO_ADDR_REPLY,
|
|
addr, mask);
|
|
}
|
|
dev_kfree_skb_any(skb);
|
|
return NET_RX_SUCCESS;
|
|
|
|
case CISCO_ADDR_REPLY:
|
|
printk(KERN_INFO "%s: Unexpected Cisco IP address "
|
|
"reply\n", dev->name);
|
|
goto rx_error;
|
|
|
|
case CISCO_KEEPALIVE_REQ:
|
|
spin_lock(&st->lock);
|
|
st->rxseq = ntohl(cisco_data->par1);
|
|
ack = ntohl(cisco_data->par2);
|
|
if (ack && (ack == st->txseq ||
|
|
/* our current REQ may be in transit */
|
|
ack == st->txseq - 1)) {
|
|
st->last_poll = jiffies;
|
|
if (!st->up) {
|
|
u32 sec, min, hrs, days;
|
|
sec = ntohl(cisco_data->time) / 1000;
|
|
min = sec / 60; sec -= min * 60;
|
|
hrs = min / 60; min -= hrs * 60;
|
|
days = hrs / 24; hrs -= days * 24;
|
|
printk(KERN_INFO "%s: Link up (peer "
|
|
"uptime %ud%uh%um%us)\n",
|
|
dev->name, days, hrs, min, sec);
|
|
netif_dormant_off(dev);
|
|
st->up = 1;
|
|
}
|
|
}
|
|
spin_unlock(&st->lock);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
return NET_RX_SUCCESS;
|
|
} /* switch (keepalive type) */
|
|
} /* switch (protocol) */
|
|
|
|
printk(KERN_INFO "%s: Unsupported protocol %x\n", dev->name,
|
|
ntohs(data->protocol));
|
|
dev_kfree_skb_any(skb);
|
|
return NET_RX_DROP;
|
|
|
|
rx_error:
|
|
dev->stats.rx_errors++; /* Mark error */
|
|
dev_kfree_skb_any(skb);
|
|
return NET_RX_DROP;
|
|
}
|
|
|
|
|
|
|
|
static void cisco_timer(unsigned long arg)
|
|
{
|
|
struct net_device *dev = (struct net_device *)arg;
|
|
hdlc_device *hdlc = dev_to_hdlc(dev);
|
|
struct cisco_state *st = state(hdlc);
|
|
|
|
spin_lock(&st->lock);
|
|
if (st->up &&
|
|
time_after(jiffies, st->last_poll + st->settings.timeout * HZ)) {
|
|
st->up = 0;
|
|
printk(KERN_INFO "%s: Link down\n", dev->name);
|
|
netif_dormant_on(dev);
|
|
}
|
|
|
|
cisco_keepalive_send(dev, CISCO_KEEPALIVE_REQ, htonl(++st->txseq),
|
|
htonl(st->rxseq));
|
|
spin_unlock(&st->lock);
|
|
|
|
st->timer.expires = jiffies + st->settings.interval * HZ;
|
|
st->timer.function = cisco_timer;
|
|
st->timer.data = arg;
|
|
add_timer(&st->timer);
|
|
}
|
|
|
|
|
|
|
|
static void cisco_start(struct net_device *dev)
|
|
{
|
|
hdlc_device *hdlc = dev_to_hdlc(dev);
|
|
struct cisco_state *st = state(hdlc);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&st->lock, flags);
|
|
st->up = st->txseq = st->rxseq = 0;
|
|
spin_unlock_irqrestore(&st->lock, flags);
|
|
|
|
init_timer(&st->timer);
|
|
st->timer.expires = jiffies + HZ; /* First poll after 1 s */
|
|
st->timer.function = cisco_timer;
|
|
st->timer.data = (unsigned long)dev;
|
|
add_timer(&st->timer);
|
|
}
|
|
|
|
|
|
|
|
static void cisco_stop(struct net_device *dev)
|
|
{
|
|
hdlc_device *hdlc = dev_to_hdlc(dev);
|
|
struct cisco_state *st = state(hdlc);
|
|
unsigned long flags;
|
|
|
|
del_timer_sync(&st->timer);
|
|
|
|
spin_lock_irqsave(&st->lock, flags);
|
|
netif_dormant_on(dev);
|
|
st->up = st->txseq = 0;
|
|
spin_unlock_irqrestore(&st->lock, flags);
|
|
}
|
|
|
|
|
|
static struct hdlc_proto proto = {
|
|
.start = cisco_start,
|
|
.stop = cisco_stop,
|
|
.type_trans = cisco_type_trans,
|
|
.ioctl = cisco_ioctl,
|
|
.netif_rx = cisco_rx,
|
|
.module = THIS_MODULE,
|
|
};
|
|
|
|
static const struct header_ops cisco_header_ops = {
|
|
.create = cisco_hard_header,
|
|
};
|
|
|
|
static int cisco_ioctl(struct net_device *dev, struct ifreq *ifr)
|
|
{
|
|
cisco_proto __user *cisco_s = ifr->ifr_settings.ifs_ifsu.cisco;
|
|
const size_t size = sizeof(cisco_proto);
|
|
cisco_proto new_settings;
|
|
hdlc_device *hdlc = dev_to_hdlc(dev);
|
|
int result;
|
|
|
|
switch (ifr->ifr_settings.type) {
|
|
case IF_GET_PROTO:
|
|
if (dev_to_hdlc(dev)->proto != &proto)
|
|
return -EINVAL;
|
|
ifr->ifr_settings.type = IF_PROTO_CISCO;
|
|
if (ifr->ifr_settings.size < size) {
|
|
ifr->ifr_settings.size = size; /* data size wanted */
|
|
return -ENOBUFS;
|
|
}
|
|
if (copy_to_user(cisco_s, &state(hdlc)->settings, size))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
case IF_PROTO_CISCO:
|
|
if (!capable(CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
|
|
if (dev->flags & IFF_UP)
|
|
return -EBUSY;
|
|
|
|
if (copy_from_user(&new_settings, cisco_s, size))
|
|
return -EFAULT;
|
|
|
|
if (new_settings.interval < 1 ||
|
|
new_settings.timeout < 2)
|
|
return -EINVAL;
|
|
|
|
result = hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT);
|
|
if (result)
|
|
return result;
|
|
|
|
result = attach_hdlc_protocol(dev, &proto,
|
|
sizeof(struct cisco_state));
|
|
if (result)
|
|
return result;
|
|
|
|
memcpy(&state(hdlc)->settings, &new_settings, size);
|
|
spin_lock_init(&state(hdlc)->lock);
|
|
dev->header_ops = &cisco_header_ops;
|
|
dev->type = ARPHRD_CISCO;
|
|
netif_dormant_on(dev);
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
|
|
static int __init mod_init(void)
|
|
{
|
|
register_hdlc_protocol(&proto);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static void __exit mod_exit(void)
|
|
{
|
|
unregister_hdlc_protocol(&proto);
|
|
}
|
|
|
|
|
|
module_init(mod_init);
|
|
module_exit(mod_exit);
|
|
|
|
MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
|
|
MODULE_DESCRIPTION("Cisco HDLC protocol support for generic HDLC");
|
|
MODULE_LICENSE("GPL v2");
|