ia64/linux-2.6.18-xen.hg

view net/ipx/ipx_route.c @ 673:3161879fdf22

[IA64] xencomm: support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap

support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Tue Sep 16 21:26:15 2008 +0900 (2008-09-16)
parents 831230e53067
children
line source
1 /*
2 * Implements the IPX routing routines.
3 * Code moved from af_ipx.c.
4 *
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 2003
6 *
7 * See net/ipx/ChangeLog.
8 */
10 #include <linux/list.h>
11 #include <linux/route.h>
12 #include <linux/spinlock.h>
14 #include <net/ipx.h>
15 #include <net/sock.h>
17 LIST_HEAD(ipx_routes);
18 DEFINE_RWLOCK(ipx_routes_lock);
20 extern struct ipx_interface *ipx_internal_net;
22 extern __u16 ipx_cksum(struct ipxhdr *packet, int length);
23 extern struct ipx_interface *ipxitf_find_using_net(__u32 net);
24 extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
25 struct sk_buff *skb, int copy);
26 extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
27 struct sk_buff *skb, int copy);
28 extern int ipxitf_send(struct ipx_interface *intrfc, struct sk_buff *skb,
29 char *node);
30 extern struct ipx_interface *ipxitf_find_using_net(__u32 net);
32 struct ipx_route *ipxrtr_lookup(__u32 net)
33 {
34 struct ipx_route *r;
36 read_lock_bh(&ipx_routes_lock);
37 list_for_each_entry(r, &ipx_routes, node)
38 if (r->ir_net == net) {
39 ipxrtr_hold(r);
40 goto unlock;
41 }
42 r = NULL;
43 unlock:
44 read_unlock_bh(&ipx_routes_lock);
45 return r;
46 }
48 /*
49 * Caller must hold a reference to intrfc
50 */
51 int ipxrtr_add_route(__u32 network, struct ipx_interface *intrfc,
52 unsigned char *node)
53 {
54 struct ipx_route *rt;
55 int rc;
57 /* Get a route structure; either existing or create */
58 rt = ipxrtr_lookup(network);
59 if (!rt) {
60 rt = kmalloc(sizeof(*rt), GFP_ATOMIC);
61 rc = -EAGAIN;
62 if (!rt)
63 goto out;
65 atomic_set(&rt->refcnt, 1);
66 ipxrtr_hold(rt);
67 write_lock_bh(&ipx_routes_lock);
68 list_add(&rt->node, &ipx_routes);
69 write_unlock_bh(&ipx_routes_lock);
70 } else {
71 rc = -EEXIST;
72 if (intrfc == ipx_internal_net)
73 goto out_put;
74 }
76 rt->ir_net = network;
77 rt->ir_intrfc = intrfc;
78 if (!node) {
79 memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
80 rt->ir_routed = 0;
81 } else {
82 memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
83 rt->ir_routed = 1;
84 }
86 rc = 0;
87 out_put:
88 ipxrtr_put(rt);
89 out:
90 return rc;
91 }
93 void ipxrtr_del_routes(struct ipx_interface *intrfc)
94 {
95 struct ipx_route *r, *tmp;
97 write_lock_bh(&ipx_routes_lock);
98 list_for_each_entry_safe(r, tmp, &ipx_routes, node)
99 if (r->ir_intrfc == intrfc) {
100 list_del(&r->node);
101 ipxrtr_put(r);
102 }
103 write_unlock_bh(&ipx_routes_lock);
104 }
106 static int ipxrtr_create(struct ipx_route_definition *rd)
107 {
108 struct ipx_interface *intrfc;
109 int rc = -ENETUNREACH;
111 /* Find the appropriate interface */
112 intrfc = ipxitf_find_using_net(rd->ipx_router_network);
113 if (!intrfc)
114 goto out;
115 rc = ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
116 ipxitf_put(intrfc);
117 out:
118 return rc;
119 }
121 static int ipxrtr_delete(__u32 net)
122 {
123 struct ipx_route *r, *tmp;
124 int rc;
126 write_lock_bh(&ipx_routes_lock);
127 list_for_each_entry_safe(r, tmp, &ipx_routes, node)
128 if (r->ir_net == net) {
129 /* Directly connected; can't lose route */
130 rc = -EPERM;
131 if (!r->ir_routed)
132 goto out;
133 list_del(&r->node);
134 ipxrtr_put(r);
135 rc = 0;
136 goto out;
137 }
138 rc = -ENOENT;
139 out:
140 write_unlock_bh(&ipx_routes_lock);
141 return rc;
142 }
144 /*
145 * The skb has to be unshared, we'll end up calling ipxitf_send, that'll
146 * modify the packet
147 */
148 int ipxrtr_route_skb(struct sk_buff *skb)
149 {
150 struct ipxhdr *ipx = ipx_hdr(skb);
151 struct ipx_route *r = ipxrtr_lookup(IPX_SKB_CB(skb)->ipx_dest_net);
153 if (!r) { /* no known route */
154 kfree_skb(skb);
155 return 0;
156 }
158 ipxitf_hold(r->ir_intrfc);
159 ipxitf_send(r->ir_intrfc, skb, r->ir_routed ?
160 r->ir_router_node : ipx->ipx_dest.node);
161 ipxitf_put(r->ir_intrfc);
162 ipxrtr_put(r);
164 return 0;
165 }
167 /*
168 * Route an outgoing frame from a socket.
169 */
170 int ipxrtr_route_packet(struct sock *sk, struct sockaddr_ipx *usipx,
171 struct iovec *iov, size_t len, int noblock)
172 {
173 struct sk_buff *skb;
174 struct ipx_sock *ipxs = ipx_sk(sk);
175 struct ipx_interface *intrfc;
176 struct ipxhdr *ipx;
177 size_t size;
178 int ipx_offset;
179 struct ipx_route *rt = NULL;
180 int rc;
182 /* Find the appropriate interface on which to send packet */
183 if (!usipx->sipx_network && ipx_primary_net) {
184 usipx->sipx_network = ipx_primary_net->if_netnum;
185 intrfc = ipx_primary_net;
186 } else {
187 rt = ipxrtr_lookup(usipx->sipx_network);
188 rc = -ENETUNREACH;
189 if (!rt)
190 goto out;
191 intrfc = rt->ir_intrfc;
192 }
194 ipxitf_hold(intrfc);
195 ipx_offset = intrfc->if_ipx_offset;
196 size = sizeof(struct ipxhdr) + len + ipx_offset;
198 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
199 if (!skb)
200 goto out_put;
202 skb_reserve(skb, ipx_offset);
203 skb->sk = sk;
205 /* Fill in IPX header */
206 skb->h.raw = skb->nh.raw = skb_put(skb, sizeof(struct ipxhdr));
207 ipx = ipx_hdr(skb);
208 ipx->ipx_pktsize = htons(len + sizeof(struct ipxhdr));
209 IPX_SKB_CB(skb)->ipx_tctrl = 0;
210 ipx->ipx_type = usipx->sipx_type;
212 IPX_SKB_CB(skb)->last_hop.index = -1;
213 #ifdef CONFIG_IPX_INTERN
214 IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
215 memcpy(ipx->ipx_source.node, ipxs->node, IPX_NODE_LEN);
216 #else
217 rc = ntohs(ipxs->port);
218 if (rc == 0x453 || rc == 0x452) {
219 /* RIP/SAP special handling for mars_nwe */
220 IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum;
221 memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
222 } else {
223 IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
224 memcpy(ipx->ipx_source.node, ipxs->intrfc->if_node,
225 IPX_NODE_LEN);
226 }
227 #endif /* CONFIG_IPX_INTERN */
228 ipx->ipx_source.sock = ipxs->port;
229 IPX_SKB_CB(skb)->ipx_dest_net = usipx->sipx_network;
230 memcpy(ipx->ipx_dest.node, usipx->sipx_node, IPX_NODE_LEN);
231 ipx->ipx_dest.sock = usipx->sipx_port;
233 rc = memcpy_fromiovec(skb_put(skb, len), iov, len);
234 if (rc) {
235 kfree_skb(skb);
236 goto out_put;
237 }
239 /* Apply checksum. Not allowed on 802.3 links. */
240 if (sk->sk_no_check || intrfc->if_dlink_type == htons(IPX_FRAME_8023))
241 ipx->ipx_checksum = 0xFFFF;
242 else
243 ipx->ipx_checksum = ipx_cksum(ipx, len + sizeof(struct ipxhdr));
245 rc = ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ?
246 rt->ir_router_node : ipx->ipx_dest.node);
247 out_put:
248 ipxitf_put(intrfc);
249 if (rt)
250 ipxrtr_put(rt);
251 out:
252 return rc;
253 }
255 /*
256 * We use a normal struct rtentry for route handling
257 */
258 int ipxrtr_ioctl(unsigned int cmd, void __user *arg)
259 {
260 struct rtentry rt; /* Use these to behave like 'other' stacks */
261 struct sockaddr_ipx *sg, *st;
262 int rc = -EFAULT;
264 if (copy_from_user(&rt, arg, sizeof(rt)))
265 goto out;
267 sg = (struct sockaddr_ipx *)&rt.rt_gateway;
268 st = (struct sockaddr_ipx *)&rt.rt_dst;
270 rc = -EINVAL;
271 if (!(rt.rt_flags & RTF_GATEWAY) || /* Direct routes are fixed */
272 sg->sipx_family != AF_IPX ||
273 st->sipx_family != AF_IPX)
274 goto out;
276 switch (cmd) {
277 case SIOCDELRT:
278 rc = ipxrtr_delete(st->sipx_network);
279 break;
280 case SIOCADDRT: {
281 struct ipx_route_definition f;
282 f.ipx_network = st->sipx_network;
283 f.ipx_router_network = sg->sipx_network;
284 memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
285 rc = ipxrtr_create(&f);
286 break;
287 }
288 }
290 out:
291 return rc;
292 }