ia64/linux-2.6.18-xen.hg

view drivers/net/mii.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
3 mii.c: MII interface library
5 Maintained by Jeff Garzik <jgarzik@pobox.com>
6 Copyright 2001,2002 Jeff Garzik
8 Various code came from myson803.c and other files by
9 Donald Becker. Copyright:
11 Written 1998-2002 by Donald Becker.
13 This software may be used and distributed according
14 to the terms of the GNU General Public License (GPL),
15 incorporated herein by reference. Drivers based on
16 or derived from this code fall under the GPL and must
17 retain the authorship, copyright and license notice.
18 This file is not a complete program and may only be
19 used when the entire operating system is licensed
20 under the GPL.
22 The author may be reached as becker@scyld.com, or C/O
23 Scyld Computing Corporation
24 410 Severn Ave., Suite 210
25 Annapolis MD 21403
28 */
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/netdevice.h>
33 #include <linux/ethtool.h>
34 #include <linux/mii.h>
36 int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
37 {
38 struct net_device *dev = mii->dev;
39 u32 advert, bmcr, lpa, nego;
40 u32 advert2 = 0, bmcr2 = 0, lpa2 = 0;
42 ecmd->supported =
43 (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
44 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
45 SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
46 if (mii->supports_gmii)
47 ecmd->supported |= SUPPORTED_1000baseT_Half |
48 SUPPORTED_1000baseT_Full;
50 /* only supports twisted-pair */
51 ecmd->port = PORT_MII;
53 /* only supports internal transceiver */
54 ecmd->transceiver = XCVR_INTERNAL;
56 /* this isn't fully supported at higher layers */
57 ecmd->phy_address = mii->phy_id;
59 ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
60 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
61 if (mii->supports_gmii)
62 advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
64 if (advert & ADVERTISE_10HALF)
65 ecmd->advertising |= ADVERTISED_10baseT_Half;
66 if (advert & ADVERTISE_10FULL)
67 ecmd->advertising |= ADVERTISED_10baseT_Full;
68 if (advert & ADVERTISE_100HALF)
69 ecmd->advertising |= ADVERTISED_100baseT_Half;
70 if (advert & ADVERTISE_100FULL)
71 ecmd->advertising |= ADVERTISED_100baseT_Full;
72 if (advert2 & ADVERTISE_1000HALF)
73 ecmd->advertising |= ADVERTISED_1000baseT_Half;
74 if (advert2 & ADVERTISE_1000FULL)
75 ecmd->advertising |= ADVERTISED_1000baseT_Full;
77 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
78 lpa = mii->mdio_read(dev, mii->phy_id, MII_LPA);
79 if (mii->supports_gmii) {
80 bmcr2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
81 lpa2 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
82 }
83 if (bmcr & BMCR_ANENABLE) {
84 ecmd->advertising |= ADVERTISED_Autoneg;
85 ecmd->autoneg = AUTONEG_ENABLE;
87 nego = mii_nway_result(advert & lpa);
88 if ((bmcr2 & (ADVERTISE_1000HALF | ADVERTISE_1000FULL)) &
89 (lpa2 >> 2))
90 ecmd->speed = SPEED_1000;
91 else if (nego == LPA_100FULL || nego == LPA_100HALF)
92 ecmd->speed = SPEED_100;
93 else
94 ecmd->speed = SPEED_10;
95 if ((lpa2 & LPA_1000FULL) || nego == LPA_100FULL ||
96 nego == LPA_10FULL) {
97 ecmd->duplex = DUPLEX_FULL;
98 mii->full_duplex = 1;
99 } else {
100 ecmd->duplex = DUPLEX_HALF;
101 mii->full_duplex = 0;
102 }
103 } else {
104 ecmd->autoneg = AUTONEG_DISABLE;
106 ecmd->speed = ((bmcr & BMCR_SPEED1000 &&
107 (bmcr & BMCR_SPEED100) == 0) ? SPEED_1000 :
108 (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10);
109 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
110 }
112 /* ignore maxtxpkt, maxrxpkt for now */
114 return 0;
115 }
117 int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
118 {
119 struct net_device *dev = mii->dev;
121 if (ecmd->speed != SPEED_10 &&
122 ecmd->speed != SPEED_100 &&
123 ecmd->speed != SPEED_1000)
124 return -EINVAL;
125 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
126 return -EINVAL;
127 if (ecmd->port != PORT_MII)
128 return -EINVAL;
129 if (ecmd->transceiver != XCVR_INTERNAL)
130 return -EINVAL;
131 if (ecmd->phy_address != mii->phy_id)
132 return -EINVAL;
133 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
134 return -EINVAL;
135 if ((ecmd->speed == SPEED_1000) && (!mii->supports_gmii))
136 return -EINVAL;
138 /* ignore supported, maxtxpkt, maxrxpkt */
140 if (ecmd->autoneg == AUTONEG_ENABLE) {
141 u32 bmcr, advert, tmp;
142 u32 advert2 = 0, tmp2 = 0;
144 if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
145 ADVERTISED_10baseT_Full |
146 ADVERTISED_100baseT_Half |
147 ADVERTISED_100baseT_Full |
148 ADVERTISED_1000baseT_Half |
149 ADVERTISED_1000baseT_Full)) == 0)
150 return -EINVAL;
152 /* advertise only what has been requested */
153 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
154 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
155 if (mii->supports_gmii) {
156 advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
157 tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
158 }
159 if (ecmd->advertising & ADVERTISED_10baseT_Half)
160 tmp |= ADVERTISE_10HALF;
161 if (ecmd->advertising & ADVERTISED_10baseT_Full)
162 tmp |= ADVERTISE_10FULL;
163 if (ecmd->advertising & ADVERTISED_100baseT_Half)
164 tmp |= ADVERTISE_100HALF;
165 if (ecmd->advertising & ADVERTISED_100baseT_Full)
166 tmp |= ADVERTISE_100FULL;
167 if (mii->supports_gmii) {
168 if (ecmd->advertising & ADVERTISED_1000baseT_Half)
169 tmp2 |= ADVERTISE_1000HALF;
170 if (ecmd->advertising & ADVERTISED_1000baseT_Full)
171 tmp2 |= ADVERTISE_1000FULL;
172 }
173 if (advert != tmp) {
174 mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
175 mii->advertising = tmp;
176 }
177 if ((mii->supports_gmii) && (advert2 != tmp2))
178 mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
180 /* turn on autonegotiation, and force a renegotiate */
181 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
182 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
183 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
185 mii->force_media = 0;
186 } else {
187 u32 bmcr, tmp;
189 /* turn off auto negotiation, set speed and duplexity */
190 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
191 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
192 BMCR_SPEED1000 | BMCR_FULLDPLX);
193 if (ecmd->speed == SPEED_1000)
194 tmp |= BMCR_SPEED1000;
195 else if (ecmd->speed == SPEED_100)
196 tmp |= BMCR_SPEED100;
197 if (ecmd->duplex == DUPLEX_FULL) {
198 tmp |= BMCR_FULLDPLX;
199 mii->full_duplex = 1;
200 } else
201 mii->full_duplex = 0;
202 if (bmcr != tmp)
203 mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
205 mii->force_media = 1;
206 }
207 return 0;
208 }
210 int mii_check_gmii_support(struct mii_if_info *mii)
211 {
212 int reg;
214 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
215 if (reg & BMSR_ESTATEN) {
216 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
217 if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
218 return 1;
219 }
221 return 0;
222 }
224 int mii_link_ok (struct mii_if_info *mii)
225 {
226 /* first, a dummy read, needed to latch some MII phys */
227 mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
228 if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
229 return 1;
230 return 0;
231 }
233 int mii_nway_restart (struct mii_if_info *mii)
234 {
235 int bmcr;
236 int r = -EINVAL;
238 /* if autoneg is off, it's an error */
239 bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
241 if (bmcr & BMCR_ANENABLE) {
242 bmcr |= BMCR_ANRESTART;
243 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
244 r = 0;
245 }
247 return r;
248 }
250 void mii_check_link (struct mii_if_info *mii)
251 {
252 int cur_link = mii_link_ok(mii);
253 int prev_link = netif_carrier_ok(mii->dev);
255 if (cur_link && !prev_link)
256 netif_carrier_on(mii->dev);
257 else if (prev_link && !cur_link)
258 netif_carrier_off(mii->dev);
259 }
261 unsigned int mii_check_media (struct mii_if_info *mii,
262 unsigned int ok_to_print,
263 unsigned int init_media)
264 {
265 unsigned int old_carrier, new_carrier;
266 int advertise, lpa, media, duplex;
267 int lpa2 = 0;
269 /* if forced media, go no further */
270 if (mii->force_media)
271 return 0; /* duplex did not change */
273 /* check current and old link status */
274 old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
275 new_carrier = (unsigned int) mii_link_ok(mii);
277 /* if carrier state did not change, this is a "bounce",
278 * just exit as everything is already set correctly
279 */
280 if ((!init_media) && (old_carrier == new_carrier))
281 return 0; /* duplex did not change */
283 /* no carrier, nothing much to do */
284 if (!new_carrier) {
285 netif_carrier_off(mii->dev);
286 if (ok_to_print)
287 printk(KERN_INFO "%s: link down\n", mii->dev->name);
288 return 0; /* duplex did not change */
289 }
291 /*
292 * we have carrier, see who's on the other end
293 */
294 netif_carrier_on(mii->dev);
296 /* get MII advertise and LPA values */
297 if ((!init_media) && (mii->advertising))
298 advertise = mii->advertising;
299 else {
300 advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
301 mii->advertising = advertise;
302 }
303 lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
304 if (mii->supports_gmii)
305 lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
307 /* figure out media and duplex from advertise and LPA values */
308 media = mii_nway_result(lpa & advertise);
309 duplex = (media & ADVERTISE_FULL) ? 1 : 0;
310 if (lpa2 & LPA_1000FULL)
311 duplex = 1;
313 if (ok_to_print)
314 printk(KERN_INFO "%s: link up, %sMbps, %s-duplex, lpa 0x%04X\n",
315 mii->dev->name,
316 lpa2 & (LPA_1000FULL | LPA_1000HALF) ? "1000" :
317 media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ? "100" : "10",
318 duplex ? "full" : "half",
319 lpa);
321 if ((init_media) || (mii->full_duplex != duplex)) {
322 mii->full_duplex = duplex;
323 return 1; /* duplex changed */
324 }
326 return 0; /* duplex did not change */
327 }
329 int generic_mii_ioctl(struct mii_if_info *mii_if,
330 struct mii_ioctl_data *mii_data, int cmd,
331 unsigned int *duplex_chg_out)
332 {
333 int rc = 0;
334 unsigned int duplex_changed = 0;
336 if (duplex_chg_out)
337 *duplex_chg_out = 0;
339 mii_data->phy_id &= mii_if->phy_id_mask;
340 mii_data->reg_num &= mii_if->reg_num_mask;
342 switch(cmd) {
343 case SIOCGMIIPHY:
344 mii_data->phy_id = mii_if->phy_id;
345 /* fall through */
347 case SIOCGMIIREG:
348 mii_data->val_out =
349 mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
350 mii_data->reg_num);
351 break;
353 case SIOCSMIIREG: {
354 u16 val = mii_data->val_in;
356 if (!capable(CAP_NET_ADMIN))
357 return -EPERM;
359 if (mii_data->phy_id == mii_if->phy_id) {
360 switch(mii_data->reg_num) {
361 case MII_BMCR: {
362 unsigned int new_duplex = 0;
363 if (val & (BMCR_RESET|BMCR_ANENABLE))
364 mii_if->force_media = 0;
365 else
366 mii_if->force_media = 1;
367 if (mii_if->force_media &&
368 (val & BMCR_FULLDPLX))
369 new_duplex = 1;
370 if (mii_if->full_duplex != new_duplex) {
371 duplex_changed = 1;
372 mii_if->full_duplex = new_duplex;
373 }
374 break;
375 }
376 case MII_ADVERTISE:
377 mii_if->advertising = val;
378 break;
379 default:
380 /* do nothing */
381 break;
382 }
383 }
385 mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
386 mii_data->reg_num, val);
387 break;
388 }
390 default:
391 rc = -EOPNOTSUPP;
392 break;
393 }
395 if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
396 *duplex_chg_out = 1;
398 return rc;
399 }
401 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
402 MODULE_DESCRIPTION ("MII hardware support library");
403 MODULE_LICENSE("GPL");
405 EXPORT_SYMBOL(mii_link_ok);
406 EXPORT_SYMBOL(mii_nway_restart);
407 EXPORT_SYMBOL(mii_ethtool_gset);
408 EXPORT_SYMBOL(mii_ethtool_sset);
409 EXPORT_SYMBOL(mii_check_link);
410 EXPORT_SYMBOL(mii_check_media);
411 EXPORT_SYMBOL(mii_check_gmii_support);
412 EXPORT_SYMBOL(generic_mii_ioctl);