[packages/kernel.git] / 00_static_routes-2.6.0-test1-8.diff

diff -ur v2.6.0-test1/linux/include/net/ip_fib.h linux/include/net/ip_fib.h
--- v2.6.0-test1/linux/include/net/ip_fib.h	Sat Jul 26 16:38:32 2003
+++ linux/include/net/ip_fib.h	Sun Jul 27 14:23:10 2003
@@ -280,4 +280,6 @@
 #endif
 }
 
+extern rwlock_t fib_nhflags_lock;
+
 #endif  /* _NET_FIB_H */
diff -ur v2.6.0-test1/linux/net/ipv4/fib_frontend.c linux/net/ipv4/fib_frontend.c
--- v2.6.0-test1/linux/net/ipv4/fib_frontend.c	Sat Jul 26 16:38:42 2003
+++ linux/net/ipv4/fib_frontend.c	Sun Jul 27 14:23:10 2003
@@ -530,9 +530,7 @@
 	switch (event) {
 	case NETDEV_UP:
 		fib_add_ifaddr(ifa);
-#ifdef CONFIG_IP_ROUTE_MULTIPATH
 		fib_sync_up(ifa->ifa_dev->dev);
-#endif
 		rt_cache_flush(-1);
 		break;
 	case NETDEV_DOWN:
@@ -568,9 +566,7 @@
 		for_ifa(in_dev) {
 			fib_add_ifaddr(ifa);
 		} endfor_ifa(in_dev);
-#ifdef CONFIG_IP_ROUTE_MULTIPATH
 		fib_sync_up(dev);
-#endif
 		rt_cache_flush(-1);
 		break;
 	case NETDEV_DOWN:
diff -ur v2.6.0-test1/linux/net/ipv4/fib_semantics.c linux/net/ipv4/fib_semantics.c
--- v2.6.0-test1/linux/net/ipv4/fib_semantics.c	Sat Jul 26 16:38:42 2003
+++ linux/net/ipv4/fib_semantics.c	Sun Jul 27 14:23:10 2003
@@ -48,6 +48,7 @@
 static struct fib_info 	*fib_info_list;
 static rwlock_t fib_info_lock = RW_LOCK_UNLOCKED;
 int fib_info_cnt;
+rwlock_t fib_nhflags_lock = RW_LOCK_UNLOCKED;
 
 #define for_fib_info() { struct fib_info *fi; \
 	for (fi = fib_info_list; fi; fi = fi->fib_next)
@@ -403,8 +404,11 @@
 				return -EINVAL;
 			if ((dev = __dev_get_by_index(nh->nh_oif)) == NULL)
 				return -ENODEV;
-			if (!(dev->flags&IFF_UP))
-				return -ENETDOWN;
+			if (!(dev->flags&IFF_UP)) {
+				if (fi->fib_protocol != RTPROT_STATIC)
+					return -ENETDOWN;
+				nh->nh_flags |= RTNH_F_DEAD;
+			}
 			nh->nh_dev = dev;
 			dev_hold(dev);
 			nh->nh_scope = RT_SCOPE_LINK;
@@ -419,24 +423,48 @@
 			/* It is not necessary, but requires a bit of thinking */
 			if (fl.fl4_scope < RT_SCOPE_LINK)
 				fl.fl4_scope = RT_SCOPE_LINK;
-			if ((err = fib_lookup(&fl, &res)) != 0)
-				return err;
+			err = fib_lookup(&fl, &res);
 		}
-		err = -EINVAL;
-		if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
-			goto out;
-		nh->nh_scope = res.scope;
-		nh->nh_oif = FIB_RES_OIF(res);
-		if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
-			goto out;
-		dev_hold(nh->nh_dev);
-		err = -ENETDOWN;
-		if (!(nh->nh_dev->flags & IFF_UP))
-			goto out;
-		err = 0;
+		if (err) {
+			struct in_device *in_dev;
+
+			if (err != -ENETUNREACH ||
+			    fi->fib_protocol != RTPROT_STATIC)
+				return err;
+
+			in_dev = inetdev_by_index(nh->nh_oif);
+			if (in_dev == NULL ||
+			    in_dev->dev->flags & IFF_UP) {
+				if (in_dev)
+					in_dev_put(in_dev);
+				return err;
+			}
+			nh->nh_flags |= RTNH_F_DEAD;
+			nh->nh_scope = RT_SCOPE_LINK;
+			nh->nh_dev = in_dev->dev;
+			dev_hold(nh->nh_dev);
+			in_dev_put(in_dev);
+		} else {
+			err = -EINVAL;
+			if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
+				goto out;
+			nh->nh_scope = res.scope;
+			nh->nh_oif = FIB_RES_OIF(res);
+			if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
+				goto out;
+			dev_hold(nh->nh_dev);
+			if (!(nh->nh_dev->flags & IFF_UP)) {
+				if (fi->fib_protocol != RTPROT_STATIC) {
+					err = -ENETDOWN;
+					goto out;
+				}
+				nh->nh_flags |= RTNH_F_DEAD;
+			}
+			err = 0;
 out:
-		fib_res_put(&res);
-		return err;
+			fib_res_put(&res);
+			return err;
+		}
 	} else {
 		struct in_device *in_dev;
 
@@ -447,8 +475,11 @@
 		if (in_dev == NULL)
 			return -ENODEV;
 		if (!(in_dev->dev->flags&IFF_UP)) {
-			in_dev_put(in_dev);
-			return -ENETDOWN;
+			if (fi->fib_protocol != RTPROT_STATIC) {
+				in_dev_put(in_dev);
+				return -ENETDOWN;
+			}
+			nh->nh_flags |= RTNH_F_DEAD;
 		}
 		nh->nh_dev = in_dev->dev;
 		dev_hold(nh->nh_dev);
@@ -910,22 +941,35 @@
 		if (local && fi->fib_prefsrc == local) {
 			fi->fib_flags |= RTNH_F_DEAD;
 			ret++;
-		} else if (dev && fi->fib_nhs) {
+		} else if (fi->fib_nhs) {
 			int dead = 0;
 
 			change_nexthops(fi) {
-				if (nh->nh_flags&RTNH_F_DEAD)
-					dead++;
-				else if (nh->nh_dev == dev &&
-					 nh->nh_scope != scope) {
-					nh->nh_flags |= RTNH_F_DEAD;
+				if (nh->nh_flags&RTNH_F_DEAD) {
+					if (fi->fib_protocol!=RTPROT_STATIC ||
+					    nh->nh_dev == NULL ||
+					    !__in_dev_get(nh->nh_dev) ||
+					    nh->nh_dev->flags&IFF_UP)
+						dead++;
+				} else if ((nh->nh_dev == dev && dev &&
+					    nh->nh_scope != scope) ||
+					    (local == nh->nh_gw && local &&
+					     nh->nh_oif)) {
+					write_lock_bh(&fib_nhflags_lock);
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
-					spin_lock_bh(&fib_multipath_lock);
+					spin_lock(&fib_multipath_lock);
+					nh->nh_flags |= RTNH_F_DEAD;
 					fi->fib_power -= nh->nh_power;
 					nh->nh_power = 0;
-					spin_unlock_bh(&fib_multipath_lock);
+					spin_unlock(&fib_multipath_lock);
+#else
+					nh->nh_flags |= RTNH_F_DEAD;
 #endif
-					dead++;
+					write_unlock_bh(&fib_nhflags_lock);
+					if (fi->fib_protocol!=RTPROT_STATIC ||
+					    force ||
+					    (dev && __in_dev_get(dev) == NULL))
+						dead++;
 				}
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 				if (force > 1 && nh->nh_dev == dev) {
@@ -943,37 +987,56 @@
 	return ret;
 }
 
-#ifdef CONFIG_IP_ROUTE_MULTIPATH
-
 /*
-   Dead device goes up. We wake up dead nexthops.
-   It takes sense only on multipath routes.
+   Dead device goes up or new address is added. We wake up dead nexthops.
  */
 
 int fib_sync_up(struct net_device *dev)
 {
-	int ret = 0;
+	struct fib_result res;
+	int ret, rep;
 
+repeat:
 	if (!(dev->flags&IFF_UP))
 		return 0;
 
+	ret = 0;
+	rep = 0;
 	for_fib_info() {
 		int alive = 0;
 
 		change_nexthops(fi) {
-			if (!(nh->nh_flags&RTNH_F_DEAD)) {
-				alive++;
+			if (!(nh->nh_flags&RTNH_F_DEAD))
 				continue;
-			}
 			if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
 				continue;
 			if (nh->nh_dev != dev || __in_dev_get(dev) == NULL)
 				continue;
+			if (nh->nh_gw && fi->fib_protocol == RTPROT_STATIC) {
+				struct flowi fl = {
+					.nl_u = { .ip4_u =
+						  { .daddr = nh->nh_gw,
+						    .scope = nh->nh_scope } },
+					.oif =  nh->nh_oif,
+				};
+				if (fib_lookup(&fl, &res) != 0)
+					continue;
+				if (res.type != RTN_UNICAST &&
+				    res.type != RTN_LOCAL) {
+					fib_res_put(&res);
+					continue;
+				}
+				nh->nh_scope = res.scope;
+				fib_res_put(&res);
+				rep = 1;
+			}
 			alive++;
+#ifdef CONFIG_IP_ROUTE_MULTIPATH
 			spin_lock_bh(&fib_multipath_lock);
 			nh->nh_power = 0;
 			nh->nh_flags &= ~RTNH_F_DEAD;
 			spin_unlock_bh(&fib_multipath_lock);
+#endif
 		} endfor_nexthops(fi)
 
 		if (alive > 0) {
@@ -981,8 +1044,12 @@
 			ret++;
 		}
 	} endfor_fib_info();
+	if (rep)
+		goto repeat;
 	return ret;
 }
+
+#ifdef CONFIG_IP_ROUTE_MULTIPATH
 
 /*
    The algorithm is suboptimal, but it provides really
Commit	Line	Data
e7b0439e	1	diff -ur v2.6.0-test1/linux/include/net/ip_fib.h linux/include/net/ip_fib.h
	2	--- v2.6.0-test1/linux/include/net/ip_fib.h Sat Jul 26 16:38:32 2003
	3	+++ linux/include/net/ip_fib.h Sun Jul 27 14:23:10 2003
	4	@@ -280,4 +280,6 @@
	5	#endif
	6	}
	7
	8	+extern rwlock_t fib_nhflags_lock;
	9	+
	10	#endif /* _NET_FIB_H */
	11	diff -ur v2.6.0-test1/linux/net/ipv4/fib_frontend.c linux/net/ipv4/fib_frontend.c
	12	--- v2.6.0-test1/linux/net/ipv4/fib_frontend.c Sat Jul 26 16:38:42 2003
	13	+++ linux/net/ipv4/fib_frontend.c Sun Jul 27 14:23:10 2003
	14	@@ -530,9 +530,7 @@
	15	switch (event) {
	16	case NETDEV_UP:
	17	fib_add_ifaddr(ifa);
	18	-#ifdef CONFIG_IP_ROUTE_MULTIPATH
	19	fib_sync_up(ifa->ifa_dev->dev);
	20	-#endif
	21	rt_cache_flush(-1);
	22	break;
	23	case NETDEV_DOWN:
	24	@@ -568,9 +566,7 @@
	25	for_ifa(in_dev) {
	26	fib_add_ifaddr(ifa);
	27	} endfor_ifa(in_dev);
	28	-#ifdef CONFIG_IP_ROUTE_MULTIPATH
	29	fib_sync_up(dev);
	30	-#endif
	31	rt_cache_flush(-1);
	32	break;
	33	case NETDEV_DOWN:
	34	diff -ur v2.6.0-test1/linux/net/ipv4/fib_semantics.c linux/net/ipv4/fib_semantics.c
	35	--- v2.6.0-test1/linux/net/ipv4/fib_semantics.c Sat Jul 26 16:38:42 2003
	36	+++ linux/net/ipv4/fib_semantics.c Sun Jul 27 14:23:10 2003
	37	@@ -48,6 +48,7 @@
	38	static struct fib_info *fib_info_list;
	39	static rwlock_t fib_info_lock = RW_LOCK_UNLOCKED;
	40	int fib_info_cnt;
	41	+rwlock_t fib_nhflags_lock = RW_LOCK_UNLOCKED;
	42
	43	#define for_fib_info() { struct fib_info *fi; \
	44	for (fi = fib_info_list; fi; fi = fi->fib_next)
	45	@@ -403,8 +404,11 @@
	46	return -EINVAL;
	47	if ((dev = __dev_get_by_index(nh->nh_oif)) == NULL)
	48	return -ENODEV;
	49	- if (!(dev->flags&IFF_UP))
	50	- return -ENETDOWN;
	51	+ if (!(dev->flags&IFF_UP)) {
	52	+ if (fi->fib_protocol != RTPROT_STATIC)
	53	+ return -ENETDOWN;
	54	+ nh->nh_flags \|= RTNH_F_DEAD;
	55	+ }
	56	nh->nh_dev = dev;
	57	dev_hold(dev);
	58	nh->nh_scope = RT_SCOPE_LINK;
	59	@@ -419,24 +423,48 @@
	60	/* It is not necessary, but requires a bit of thinking */
	61	if (fl.fl4_scope < RT_SCOPE_LINK)
	62	fl.fl4_scope = RT_SCOPE_LINK;
	63	- if ((err = fib_lookup(&fl, &res)) != 0)
	64	- return err;
65	+ err = fib_lookup(&fl, &res);
66	}
67	- err = -EINVAL;
68	- if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
69	- goto out;
70	- nh->nh_scope = res.scope;
71	- nh->nh_oif = FIB_RES_OIF(res);
72	- if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
73	- goto out;
74	- dev_hold(nh->nh_dev);
75	- err = -ENETDOWN;
76	- if (!(nh->nh_dev->flags & IFF_UP))
77	- goto out;
78	- err = 0;
79	+ if (err) {
80	+ struct in_device *in_dev;
81	+
82	+ if (err != -ENETUNREACH \|\|
83	+ fi->fib_protocol != RTPROT_STATIC)
84	+ return err;
85	+
86	+ in_dev = inetdev_by_index(nh->nh_oif);
87	+ if (in_dev == NULL \|\|
88	+ in_dev->dev->flags & IFF_UP) {
89	+ if (in_dev)
90	+ in_dev_put(in_dev);
91	+ return err;
92	+ }
93	+ nh->nh_flags \|= RTNH_F_DEAD;
94	+ nh->nh_scope = RT_SCOPE_LINK;
95	+ nh->nh_dev = in_dev->dev;
96	+ dev_hold(nh->nh_dev);
97	+ in_dev_put(in_dev);
98	+ } else {
99	+ err = -EINVAL;
100	+ if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
101	+ goto out;
102	+ nh->nh_scope = res.scope;
103	+ nh->nh_oif = FIB_RES_OIF(res);
104	+ if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
105	+ goto out;
106	+ dev_hold(nh->nh_dev);
107	+ if (!(nh->nh_dev->flags & IFF_UP)) {
108	+ if (fi->fib_protocol != RTPROT_STATIC) {
109	+ err = -ENETDOWN;
110	+ goto out;
111	+ }
112	+ nh->nh_flags \|= RTNH_F_DEAD;
113	+ }
114	+ err = 0;
115	out:
116	- fib_res_put(&res);
117	- return err;
118	+ fib_res_put(&res);
119	+ return err;
120	+ }
121	} else {
122	struct in_device *in_dev;
123
124	@@ -447,8 +475,11 @@
125	if (in_dev == NULL)
126	return -ENODEV;
127	if (!(in_dev->dev->flags&IFF_UP)) {
128	- in_dev_put(in_dev);
129	- return -ENETDOWN;
130	+ if (fi->fib_protocol != RTPROT_STATIC) {
131	+ in_dev_put(in_dev);
132	+ return -ENETDOWN;
133	+ }
134	+ nh->nh_flags \|= RTNH_F_DEAD;
135	}
136	nh->nh_dev = in_dev->dev;
137	dev_hold(nh->nh_dev);
138	@@ -910,22 +941,35 @@
139	if (local && fi->fib_prefsrc == local) {
140	fi->fib_flags \|= RTNH_F_DEAD;
141	ret++;
142	- } else if (dev && fi->fib_nhs) {
143	+ } else if (fi->fib_nhs) {
144	int dead = 0;
145
146	change_nexthops(fi) {
147	- if (nh->nh_flags&RTNH_F_DEAD)
148	- dead++;
149	- else if (nh->nh_dev == dev &&
150	- nh->nh_scope != scope) {
151	- nh->nh_flags \|= RTNH_F_DEAD;
152	+ if (nh->nh_flags&RTNH_F_DEAD) {
153	+ if (fi->fib_protocol!=RTPROT_STATIC \|\|
154	+ nh->nh_dev == NULL \|\|
155	+ !__in_dev_get(nh->nh_dev) \|\|
156	+ nh->nh_dev->flags&IFF_UP)
157	+ dead++;
158	+ } else if ((nh->nh_dev == dev && dev &&
159	+ nh->nh_scope != scope) \|\|
160	+ (local == nh->nh_gw && local &&
161	+ nh->nh_oif)) {
162	+ write_lock_bh(&fib_nhflags_lock);
163	#ifdef CONFIG_IP_ROUTE_MULTIPATH
164	- spin_lock_bh(&fib_multipath_lock);
165	+ spin_lock(&fib_multipath_lock);
166	+ nh->nh_flags \|= RTNH_F_DEAD;
167	fi->fib_power -= nh->nh_power;
168	nh->nh_power = 0;
169	- spin_unlock_bh(&fib_multipath_lock);
170	+ spin_unlock(&fib_multipath_lock);
171	+#else
172	+ nh->nh_flags \|= RTNH_F_DEAD;
173	#endif
174	- dead++;
175	+ write_unlock_bh(&fib_nhflags_lock);
176	+ if (fi->fib_protocol!=RTPROT_STATIC \|\|
177	+ force \|\|
178	+ (dev && __in_dev_get(dev) == NULL))
179	+ dead++;
180	}
181	#ifdef CONFIG_IP_ROUTE_MULTIPATH
182	if (force > 1 && nh->nh_dev == dev) {
183	@@ -943,37 +987,56 @@
184	return ret;
185	}
186
187	-#ifdef CONFIG_IP_ROUTE_MULTIPATH
188	-
189	/*
190	- Dead device goes up. We wake up dead nexthops.
191	- It takes sense only on multipath routes.
192	+ Dead device goes up or new address is added. We wake up dead nexthops.
193	*/
194
195	int fib_sync_up(struct net_device *dev)
196	{
197	- int ret = 0;
198	+ struct fib_result res;
199	+ int ret, rep;
200
201	+repeat:
202	if (!(dev->flags&IFF_UP))
203	return 0;
204
205	+ ret = 0;
206	+ rep = 0;
207	for_fib_info() {
208	int alive = 0;
209
210	change_nexthops(fi) {
211	- if (!(nh->nh_flags&RTNH_F_DEAD)) {
212	- alive++;
213	+ if (!(nh->nh_flags&RTNH_F_DEAD))
214	continue;
215	- }
216	if (nh->nh_dev == NULL \|\| !(nh->nh_dev->flags&IFF_UP))
217	continue;
218	if (nh->nh_dev != dev \|\| __in_dev_get(dev) == NULL)
219	continue;
220	+ if (nh->nh_gw && fi->fib_protocol == RTPROT_STATIC) {
221	+ struct flowi fl = {
222	+ .nl_u = { .ip4_u =
223	+ { .daddr = nh->nh_gw,
224	+ .scope = nh->nh_scope } },
225	+ .oif = nh->nh_oif,
226	+ };
227	+ if (fib_lookup(&fl, &res) != 0)
228	+ continue;
229	+ if (res.type != RTN_UNICAST &&
230	+ res.type != RTN_LOCAL) {
231	+ fib_res_put(&res);
232	+ continue;
233	+ }
234	+ nh->nh_scope = res.scope;
235	+ fib_res_put(&res);
236	+ rep = 1;
237	+ }
238	alive++;
239	+#ifdef CONFIG_IP_ROUTE_MULTIPATH
240	spin_lock_bh(&fib_multipath_lock);
241	nh->nh_power = 0;
242	nh->nh_flags &= ~RTNH_F_DEAD;
243	spin_unlock_bh(&fib_multipath_lock);
244	+#endif
245	} endfor_nexthops(fi)
246
247	if (alive > 0) {
248	@@ -981,8 +1044,12 @@
249	ret++;
250	}
251	} endfor_fib_info();
252	+ if (rep)
253	+ goto repeat;
254	return ret;
255	}
256	+
257	+#ifdef CONFIG_IP_ROUTE_MULTIPATH
258
259	/*
260	The algorithm is suboptimal, but it provides really