bond_main.c 125 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807
  1. /*
  2. * originally based on the dummy device.
  3. *
  4. * Copyright 1999, Thomas Davis, tadavis@lbl.gov.
  5. * Licensed under the GPL. Based on dummy.c, and eql.c devices.
  6. *
  7. * bonding.c: an Ethernet Bonding driver
  8. *
  9. * This is useful to talk to a Cisco EtherChannel compatible equipment:
  10. * Cisco 5500
  11. * Sun Trunking (Solaris)
  12. * Alteon AceDirector Trunks
  13. * Linux Bonding
  14. * and probably many L2 switches ...
  15. *
  16. * How it works:
  17. * ifconfig bond0 ipaddress netmask up
  18. * will setup a network device, with an ip address. No mac address
  19. * will be assigned at this time. The hw mac address will come from
  20. * the first slave bonded to the channel. All slaves will then use
  21. * this hw mac address.
  22. *
  23. * ifconfig bond0 down
  24. * will release all slaves, marking them as down.
  25. *
  26. * ifenslave bond0 eth0
  27. * will attach eth0 to bond0 as a slave. eth0 hw mac address will either
  28. * a: be used as initial mac address
  29. * b: if a hw mac address already is there, eth0's hw mac address
  30. * will then be set from bond0.
  31. *
  32. */
  33. //#define BONDING_DEBUG 1
  34. #include <linux/kernel.h>
  35. #include <linux/module.h>
  36. #include <linux/types.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/interrupt.h>
  39. #include <linux/ptrace.h>
  40. #include <linux/ioport.h>
  41. #include <linux/in.h>
  42. #include <net/ip.h>
  43. #include <linux/ip.h>
  44. #include <linux/tcp.h>
  45. #include <linux/udp.h>
  46. #include <linux/slab.h>
  47. #include <linux/string.h>
  48. #include <linux/init.h>
  49. #include <linux/timer.h>
  50. #include <linux/socket.h>
  51. #include <linux/ctype.h>
  52. #include <linux/inet.h>
  53. #include <linux/bitops.h>
  54. #include <asm/system.h>
  55. #include <asm/io.h>
  56. #include <asm/dma.h>
  57. #include <asm/uaccess.h>
  58. #include <linux/errno.h>
  59. #include <linux/netdevice.h>
  60. #include <linux/inetdevice.h>
  61. #include <linux/igmp.h>
  62. #include <linux/etherdevice.h>
  63. #include <linux/skbuff.h>
  64. #include <net/sock.h>
  65. #include <linux/rtnetlink.h>
  66. #include <linux/proc_fs.h>
  67. #include <linux/seq_file.h>
  68. #include <linux/smp.h>
  69. #include <linux/if_ether.h>
  70. #include <net/arp.h>
  71. #include <linux/mii.h>
  72. #include <linux/ethtool.h>
  73. #include <linux/if_vlan.h>
  74. #include <linux/if_bonding.h>
  75. #include <net/route.h>
  76. #include "bonding.h"
  77. #include "bond_3ad.h"
  78. #include "bond_alb.h"
  79. /*---------------------------- Module parameters ----------------------------*/
  80. /* monitor all links that often (in milliseconds). <=0 disables monitoring */
  81. #define BOND_LINK_MON_INTERV 0
  82. #define BOND_LINK_ARP_INTERV 0
  83. static int max_bonds = BOND_DEFAULT_MAX_BONDS;
  84. static int miimon = BOND_LINK_MON_INTERV;
  85. static int updelay = 0;
  86. static int downdelay = 0;
  87. static int use_carrier = 1;
  88. static char *mode = NULL;
  89. static char *primary = NULL;
  90. static char *lacp_rate = NULL;
  91. static char *xmit_hash_policy = NULL;
  92. static int arp_interval = BOND_LINK_ARP_INTERV;
  93. static char *arp_ip_target[BOND_MAX_ARP_TARGETS] = { NULL, };
  94. static char *arp_validate = NULL;
  95. struct bond_params bonding_defaults;
  96. module_param(max_bonds, int, 0);
  97. MODULE_PARM_DESC(max_bonds, "Max number of bonded devices");
  98. module_param(miimon, int, 0);
  99. MODULE_PARM_DESC(miimon, "Link check interval in milliseconds");
  100. module_param(updelay, int, 0);
  101. MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds");
  102. module_param(downdelay, int, 0);
  103. MODULE_PARM_DESC(downdelay, "Delay before considering link down, "
  104. "in milliseconds");
  105. module_param(use_carrier, int, 0);
  106. MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; "
  107. "0 for off, 1 for on (default)");
  108. module_param(mode, charp, 0);
  109. MODULE_PARM_DESC(mode, "Mode of operation : 0 for balance-rr, "
  110. "1 for active-backup, 2 for balance-xor, "
  111. "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, "
  112. "6 for balance-alb");
  113. module_param(primary, charp, 0);
  114. MODULE_PARM_DESC(primary, "Primary network device to use");
  115. module_param(lacp_rate, charp, 0);
  116. MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner "
  117. "(slow/fast)");
  118. module_param(xmit_hash_policy, charp, 0);
  119. MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method: 0 for layer 2 (default)"
  120. ", 1 for layer 3+4");
  121. module_param(arp_interval, int, 0);
  122. MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds");
  123. module_param_array(arp_ip_target, charp, NULL, 0);
  124. MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form");
  125. module_param(arp_validate, charp, 0);
  126. MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes: none (default), active, backup or all");
  127. /*----------------------------- Global variables ----------------------------*/
  128. static const char * const version =
  129. DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n";
  130. LIST_HEAD(bond_dev_list);
  131. #ifdef CONFIG_PROC_FS
  132. static struct proc_dir_entry *bond_proc_dir = NULL;
  133. #endif
  134. extern struct rw_semaphore bonding_rwsem;
  135. static u32 arp_target[BOND_MAX_ARP_TARGETS] = { 0, } ;
  136. static int arp_ip_count = 0;
  137. static int bond_mode = BOND_MODE_ROUNDROBIN;
  138. static int xmit_hashtype= BOND_XMIT_POLICY_LAYER2;
  139. static int lacp_fast = 0;
  140. struct bond_parm_tbl bond_lacp_tbl[] = {
  141. { "slow", AD_LACP_SLOW},
  142. { "fast", AD_LACP_FAST},
  143. { NULL, -1},
  144. };
  145. struct bond_parm_tbl bond_mode_tbl[] = {
  146. { "balance-rr", BOND_MODE_ROUNDROBIN},
  147. { "active-backup", BOND_MODE_ACTIVEBACKUP},
  148. { "balance-xor", BOND_MODE_XOR},
  149. { "broadcast", BOND_MODE_BROADCAST},
  150. { "802.3ad", BOND_MODE_8023AD},
  151. { "balance-tlb", BOND_MODE_TLB},
  152. { "balance-alb", BOND_MODE_ALB},
  153. { NULL, -1},
  154. };
  155. struct bond_parm_tbl xmit_hashtype_tbl[] = {
  156. { "layer2", BOND_XMIT_POLICY_LAYER2},
  157. { "layer3+4", BOND_XMIT_POLICY_LAYER34},
  158. { NULL, -1},
  159. };
  160. struct bond_parm_tbl arp_validate_tbl[] = {
  161. { "none", BOND_ARP_VALIDATE_NONE},
  162. { "active", BOND_ARP_VALIDATE_ACTIVE},
  163. { "backup", BOND_ARP_VALIDATE_BACKUP},
  164. { "all", BOND_ARP_VALIDATE_ALL},
  165. { NULL, -1},
  166. };
  167. /*-------------------------- Forward declarations ---------------------------*/
  168. static void bond_send_gratuitous_arp(struct bonding *bond);
  169. /*---------------------------- General routines -----------------------------*/
  170. static const char *bond_mode_name(int mode)
  171. {
  172. switch (mode) {
  173. case BOND_MODE_ROUNDROBIN :
  174. return "load balancing (round-robin)";
  175. case BOND_MODE_ACTIVEBACKUP :
  176. return "fault-tolerance (active-backup)";
  177. case BOND_MODE_XOR :
  178. return "load balancing (xor)";
  179. case BOND_MODE_BROADCAST :
  180. return "fault-tolerance (broadcast)";
  181. case BOND_MODE_8023AD:
  182. return "IEEE 802.3ad Dynamic link aggregation";
  183. case BOND_MODE_TLB:
  184. return "transmit load balancing";
  185. case BOND_MODE_ALB:
  186. return "adaptive load balancing";
  187. default:
  188. return "unknown";
  189. }
  190. }
  191. /*---------------------------------- VLAN -----------------------------------*/
  192. /**
  193. * bond_add_vlan - add a new vlan id on bond
  194. * @bond: bond that got the notification
  195. * @vlan_id: the vlan id to add
  196. *
  197. * Returns -ENOMEM if allocation failed.
  198. */
  199. static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id)
  200. {
  201. struct vlan_entry *vlan;
  202. dprintk("bond: %s, vlan id %d\n",
  203. (bond ? bond->dev->name: "None"), vlan_id);
  204. vlan = kmalloc(sizeof(struct vlan_entry), GFP_KERNEL);
  205. if (!vlan) {
  206. return -ENOMEM;
  207. }
  208. INIT_LIST_HEAD(&vlan->vlan_list);
  209. vlan->vlan_id = vlan_id;
  210. vlan->vlan_ip = 0;
  211. write_lock_bh(&bond->lock);
  212. list_add_tail(&vlan->vlan_list, &bond->vlan_list);
  213. write_unlock_bh(&bond->lock);
  214. dprintk("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name);
  215. return 0;
  216. }
  217. /**
  218. * bond_del_vlan - delete a vlan id from bond
  219. * @bond: bond that got the notification
  220. * @vlan_id: the vlan id to delete
  221. *
  222. * returns -ENODEV if @vlan_id was not found in @bond.
  223. */
  224. static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id)
  225. {
  226. struct vlan_entry *vlan, *next;
  227. int res = -ENODEV;
  228. dprintk("bond: %s, vlan id %d\n", bond->dev->name, vlan_id);
  229. write_lock_bh(&bond->lock);
  230. list_for_each_entry_safe(vlan, next, &bond->vlan_list, vlan_list) {
  231. if (vlan->vlan_id == vlan_id) {
  232. list_del(&vlan->vlan_list);
  233. if ((bond->params.mode == BOND_MODE_TLB) ||
  234. (bond->params.mode == BOND_MODE_ALB)) {
  235. bond_alb_clear_vlan(bond, vlan_id);
  236. }
  237. dprintk("removed VLAN ID %d from bond %s\n", vlan_id,
  238. bond->dev->name);
  239. kfree(vlan);
  240. if (list_empty(&bond->vlan_list) &&
  241. (bond->slave_cnt == 0)) {
  242. /* Last VLAN removed and no slaves, so
  243. * restore block on adding VLANs. This will
  244. * be removed once new slaves that are not
  245. * VLAN challenged will be added.
  246. */
  247. bond->dev->features |= NETIF_F_VLAN_CHALLENGED;
  248. }
  249. res = 0;
  250. goto out;
  251. }
  252. }
  253. dprintk("couldn't find VLAN ID %d in bond %s\n", vlan_id,
  254. bond->dev->name);
  255. out:
  256. write_unlock_bh(&bond->lock);
  257. return res;
  258. }
  259. /**
  260. * bond_has_challenged_slaves
  261. * @bond: the bond we're working on
  262. *
  263. * Searches the slave list. Returns 1 if a vlan challenged slave
  264. * was found, 0 otherwise.
  265. *
  266. * Assumes bond->lock is held.
  267. */
  268. static int bond_has_challenged_slaves(struct bonding *bond)
  269. {
  270. struct slave *slave;
  271. int i;
  272. bond_for_each_slave(bond, slave, i) {
  273. if (slave->dev->features & NETIF_F_VLAN_CHALLENGED) {
  274. dprintk("found VLAN challenged slave - %s\n",
  275. slave->dev->name);
  276. return 1;
  277. }
  278. }
  279. dprintk("no VLAN challenged slaves found\n");
  280. return 0;
  281. }
  282. /**
  283. * bond_next_vlan - safely skip to the next item in the vlans list.
  284. * @bond: the bond we're working on
  285. * @curr: item we're advancing from
  286. *
  287. * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL,
  288. * or @curr->next otherwise (even if it is @curr itself again).
  289. *
  290. * Caller must hold bond->lock
  291. */
  292. struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr)
  293. {
  294. struct vlan_entry *next, *last;
  295. if (list_empty(&bond->vlan_list)) {
  296. return NULL;
  297. }
  298. if (!curr) {
  299. next = list_entry(bond->vlan_list.next,
  300. struct vlan_entry, vlan_list);
  301. } else {
  302. last = list_entry(bond->vlan_list.prev,
  303. struct vlan_entry, vlan_list);
  304. if (last == curr) {
  305. next = list_entry(bond->vlan_list.next,
  306. struct vlan_entry, vlan_list);
  307. } else {
  308. next = list_entry(curr->vlan_list.next,
  309. struct vlan_entry, vlan_list);
  310. }
  311. }
  312. return next;
  313. }
  314. /**
  315. * bond_dev_queue_xmit - Prepare skb for xmit.
  316. *
  317. * @bond: bond device that got this skb for tx.
  318. * @skb: hw accel VLAN tagged skb to transmit
  319. * @slave_dev: slave that is supposed to xmit this skbuff
  320. *
  321. * When the bond gets an skb to transmit that is
  322. * already hardware accelerated VLAN tagged, and it
  323. * needs to relay this skb to a slave that is not
  324. * hw accel capable, the skb needs to be "unaccelerated",
  325. * i.e. strip the hwaccel tag and re-insert it as part
  326. * of the payload.
  327. */
  328. int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev)
  329. {
  330. unsigned short vlan_id;
  331. if (!list_empty(&bond->vlan_list) &&
  332. !(slave_dev->features & NETIF_F_HW_VLAN_TX) &&
  333. vlan_get_tag(skb, &vlan_id) == 0) {
  334. skb->dev = slave_dev;
  335. skb = vlan_put_tag(skb, vlan_id);
  336. if (!skb) {
  337. /* vlan_put_tag() frees the skb in case of error,
  338. * so return success here so the calling functions
  339. * won't attempt to free is again.
  340. */
  341. return 0;
  342. }
  343. } else {
  344. skb->dev = slave_dev;
  345. }
  346. skb->priority = 1;
  347. dev_queue_xmit(skb);
  348. return 0;
  349. }
  350. /*
  351. * In the following 3 functions, bond_vlan_rx_register(), bond_vlan_rx_add_vid
  352. * and bond_vlan_rx_kill_vid, We don't protect the slave list iteration with a
  353. * lock because:
  354. * a. This operation is performed in IOCTL context,
  355. * b. The operation is protected by the RTNL semaphore in the 8021q code,
  356. * c. Holding a lock with BH disabled while directly calling a base driver
  357. * entry point is generally a BAD idea.
  358. *
  359. * The design of synchronization/protection for this operation in the 8021q
  360. * module is good for one or more VLAN devices over a single physical device
  361. * and cannot be extended for a teaming solution like bonding, so there is a
  362. * potential race condition here where a net device from the vlan group might
  363. * be referenced (either by a base driver or the 8021q code) while it is being
  364. * removed from the system. However, it turns out we're not making matters
  365. * worse, and if it works for regular VLAN usage it will work here too.
  366. */
  367. /**
  368. * bond_vlan_rx_register - Propagates registration to slaves
  369. * @bond_dev: bonding net device that got called
  370. * @grp: vlan group being registered
  371. */
  372. static void bond_vlan_rx_register(struct net_device *bond_dev, struct vlan_group *grp)
  373. {
  374. struct bonding *bond = bond_dev->priv;
  375. struct slave *slave;
  376. int i;
  377. bond->vlgrp = grp;
  378. bond_for_each_slave(bond, slave, i) {
  379. struct net_device *slave_dev = slave->dev;
  380. if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
  381. slave_dev->vlan_rx_register) {
  382. slave_dev->vlan_rx_register(slave_dev, grp);
  383. }
  384. }
  385. }
  386. /**
  387. * bond_vlan_rx_add_vid - Propagates adding an id to slaves
  388. * @bond_dev: bonding net device that got called
  389. * @vid: vlan id being added
  390. */
  391. static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid)
  392. {
  393. struct bonding *bond = bond_dev->priv;
  394. struct slave *slave;
  395. int i, res;
  396. bond_for_each_slave(bond, slave, i) {
  397. struct net_device *slave_dev = slave->dev;
  398. if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
  399. slave_dev->vlan_rx_add_vid) {
  400. slave_dev->vlan_rx_add_vid(slave_dev, vid);
  401. }
  402. }
  403. res = bond_add_vlan(bond, vid);
  404. if (res) {
  405. printk(KERN_ERR DRV_NAME
  406. ": %s: Error: Failed to add vlan id %d\n",
  407. bond_dev->name, vid);
  408. }
  409. }
  410. /**
  411. * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves
  412. * @bond_dev: bonding net device that got called
  413. * @vid: vlan id being removed
  414. */
  415. static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid)
  416. {
  417. struct bonding *bond = bond_dev->priv;
  418. struct slave *slave;
  419. struct net_device *vlan_dev;
  420. int i, res;
  421. bond_for_each_slave(bond, slave, i) {
  422. struct net_device *slave_dev = slave->dev;
  423. if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) &&
  424. slave_dev->vlan_rx_kill_vid) {
  425. /* Save and then restore vlan_dev in the grp array,
  426. * since the slave's driver might clear it.
  427. */
  428. vlan_dev = vlan_group_get_device(bond->vlgrp, vid);
  429. slave_dev->vlan_rx_kill_vid(slave_dev, vid);
  430. vlan_group_set_device(bond->vlgrp, vid, vlan_dev);
  431. }
  432. }
  433. res = bond_del_vlan(bond, vid);
  434. if (res) {
  435. printk(KERN_ERR DRV_NAME
  436. ": %s: Error: Failed to remove vlan id %d\n",
  437. bond_dev->name, vid);
  438. }
  439. }
  440. static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev)
  441. {
  442. struct vlan_entry *vlan;
  443. write_lock_bh(&bond->lock);
  444. if (list_empty(&bond->vlan_list)) {
  445. goto out;
  446. }
  447. if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
  448. slave_dev->vlan_rx_register) {
  449. slave_dev->vlan_rx_register(slave_dev, bond->vlgrp);
  450. }
  451. if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
  452. !(slave_dev->vlan_rx_add_vid)) {
  453. goto out;
  454. }
  455. list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
  456. slave_dev->vlan_rx_add_vid(slave_dev, vlan->vlan_id);
  457. }
  458. out:
  459. write_unlock_bh(&bond->lock);
  460. }
  461. static void bond_del_vlans_from_slave(struct bonding *bond, struct net_device *slave_dev)
  462. {
  463. struct vlan_entry *vlan;
  464. struct net_device *vlan_dev;
  465. write_lock_bh(&bond->lock);
  466. if (list_empty(&bond->vlan_list)) {
  467. goto out;
  468. }
  469. if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) ||
  470. !(slave_dev->vlan_rx_kill_vid)) {
  471. goto unreg;
  472. }
  473. list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
  474. /* Save and then restore vlan_dev in the grp array,
  475. * since the slave's driver might clear it.
  476. */
  477. vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
  478. slave_dev->vlan_rx_kill_vid(slave_dev, vlan->vlan_id);
  479. vlan_group_set_device(bond->vlgrp, vlan->vlan_id, vlan_dev);
  480. }
  481. unreg:
  482. if ((slave_dev->features & NETIF_F_HW_VLAN_RX) &&
  483. slave_dev->vlan_rx_register) {
  484. slave_dev->vlan_rx_register(slave_dev, NULL);
  485. }
  486. out:
  487. write_unlock_bh(&bond->lock);
  488. }
  489. /*------------------------------- Link status -------------------------------*/
  490. /*
  491. * Set the carrier state for the master according to the state of its
  492. * slaves. If any slaves are up, the master is up. In 802.3ad mode,
  493. * do special 802.3ad magic.
  494. *
  495. * Returns zero if carrier state does not change, nonzero if it does.
  496. */
  497. static int bond_set_carrier(struct bonding *bond)
  498. {
  499. struct slave *slave;
  500. int i;
  501. if (bond->slave_cnt == 0)
  502. goto down;
  503. if (bond->params.mode == BOND_MODE_8023AD)
  504. return bond_3ad_set_carrier(bond);
  505. bond_for_each_slave(bond, slave, i) {
  506. if (slave->link == BOND_LINK_UP) {
  507. if (!netif_carrier_ok(bond->dev)) {
  508. netif_carrier_on(bond->dev);
  509. return 1;
  510. }
  511. return 0;
  512. }
  513. }
  514. down:
  515. if (netif_carrier_ok(bond->dev)) {
  516. netif_carrier_off(bond->dev);
  517. return 1;
  518. }
  519. return 0;
  520. }
  521. /*
  522. * Get link speed and duplex from the slave's base driver
  523. * using ethtool. If for some reason the call fails or the
  524. * values are invalid, fake speed and duplex to 100/Full
  525. * and return error.
  526. */
  527. static int bond_update_speed_duplex(struct slave *slave)
  528. {
  529. struct net_device *slave_dev = slave->dev;
  530. static int (* ioctl)(struct net_device *, struct ifreq *, int);
  531. struct ifreq ifr;
  532. struct ethtool_cmd etool;
  533. /* Fake speed and duplex */
  534. slave->speed = SPEED_100;
  535. slave->duplex = DUPLEX_FULL;
  536. if (slave_dev->ethtool_ops) {
  537. int res;
  538. if (!slave_dev->ethtool_ops->get_settings) {
  539. return -1;
  540. }
  541. res = slave_dev->ethtool_ops->get_settings(slave_dev, &etool);
  542. if (res < 0) {
  543. return -1;
  544. }
  545. goto verify;
  546. }
  547. ioctl = slave_dev->do_ioctl;
  548. strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
  549. etool.cmd = ETHTOOL_GSET;
  550. ifr.ifr_data = (char*)&etool;
  551. if (!ioctl || (IOCTL(slave_dev, &ifr, SIOCETHTOOL) < 0)) {
  552. return -1;
  553. }
  554. verify:
  555. switch (etool.speed) {
  556. case SPEED_10:
  557. case SPEED_100:
  558. case SPEED_1000:
  559. case SPEED_10000:
  560. break;
  561. default:
  562. return -1;
  563. }
  564. switch (etool.duplex) {
  565. case DUPLEX_FULL:
  566. case DUPLEX_HALF:
  567. break;
  568. default:
  569. return -1;
  570. }
  571. slave->speed = etool.speed;
  572. slave->duplex = etool.duplex;
  573. return 0;
  574. }
  575. /*
  576. * if <dev> supports MII link status reporting, check its link status.
  577. *
  578. * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(),
  579. * depening upon the setting of the use_carrier parameter.
  580. *
  581. * Return either BMSR_LSTATUS, meaning that the link is up (or we
  582. * can't tell and just pretend it is), or 0, meaning that the link is
  583. * down.
  584. *
  585. * If reporting is non-zero, instead of faking link up, return -1 if
  586. * both ETHTOOL and MII ioctls fail (meaning the device does not
  587. * support them). If use_carrier is set, return whatever it says.
  588. * It'd be nice if there was a good way to tell if a driver supports
  589. * netif_carrier, but there really isn't.
  590. */
  591. static int bond_check_dev_link(struct bonding *bond, struct net_device *slave_dev, int reporting)
  592. {
  593. static int (* ioctl)(struct net_device *, struct ifreq *, int);
  594. struct ifreq ifr;
  595. struct mii_ioctl_data *mii;
  596. struct ethtool_value etool;
  597. if (bond->params.use_carrier) {
  598. return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0;
  599. }
  600. ioctl = slave_dev->do_ioctl;
  601. if (ioctl) {
  602. /* TODO: set pointer to correct ioctl on a per team member */
  603. /* bases to make this more efficient. that is, once */
  604. /* we determine the correct ioctl, we will always */
  605. /* call it and not the others for that team */
  606. /* member. */
  607. /*
  608. * We cannot assume that SIOCGMIIPHY will also read a
  609. * register; not all network drivers (e.g., e100)
  610. * support that.
  611. */
  612. /* Yes, the mii is overlaid on the ifreq.ifr_ifru */
  613. strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
  614. mii = if_mii(&ifr);
  615. if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) {
  616. mii->reg_num = MII_BMSR;
  617. if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0) {
  618. return (mii->val_out & BMSR_LSTATUS);
  619. }
  620. }
  621. }
  622. /* try SIOCETHTOOL ioctl, some drivers cache ETHTOOL_GLINK */
  623. /* for a period of time so we attempt to get link status */
  624. /* from it last if the above MII ioctls fail... */
  625. if (slave_dev->ethtool_ops) {
  626. if (slave_dev->ethtool_ops->get_link) {
  627. u32 link;
  628. link = slave_dev->ethtool_ops->get_link(slave_dev);
  629. return link ? BMSR_LSTATUS : 0;
  630. }
  631. }
  632. if (ioctl) {
  633. strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ);
  634. etool.cmd = ETHTOOL_GLINK;
  635. ifr.ifr_data = (char*)&etool;
  636. if (IOCTL(slave_dev, &ifr, SIOCETHTOOL) == 0) {
  637. if (etool.data == 1) {
  638. return BMSR_LSTATUS;
  639. } else {
  640. dprintk("SIOCETHTOOL shows link down\n");
  641. return 0;
  642. }
  643. }
  644. }
  645. /*
  646. * If reporting, report that either there's no dev->do_ioctl,
  647. * or both SIOCGMIIREG and SIOCETHTOOL failed (meaning that we
  648. * cannot report link status). If not reporting, pretend
  649. * we're ok.
  650. */
  651. return (reporting ? -1 : BMSR_LSTATUS);
  652. }
  653. /*----------------------------- Multicast list ------------------------------*/
  654. /*
  655. * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise
  656. */
  657. static inline int bond_is_dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2)
  658. {
  659. return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 &&
  660. dmi1->dmi_addrlen == dmi2->dmi_addrlen;
  661. }
  662. /*
  663. * returns dmi entry if found, NULL otherwise
  664. */
  665. static struct dev_mc_list *bond_mc_list_find_dmi(struct dev_mc_list *dmi, struct dev_mc_list *mc_list)
  666. {
  667. struct dev_mc_list *idmi;
  668. for (idmi = mc_list; idmi; idmi = idmi->next) {
  669. if (bond_is_dmi_same(dmi, idmi)) {
  670. return idmi;
  671. }
  672. }
  673. return NULL;
  674. }
  675. /*
  676. * Push the promiscuity flag down to appropriate slaves
  677. */
  678. static void bond_set_promiscuity(struct bonding *bond, int inc)
  679. {
  680. if (USES_PRIMARY(bond->params.mode)) {
  681. /* write lock already acquired */
  682. if (bond->curr_active_slave) {
  683. dev_set_promiscuity(bond->curr_active_slave->dev, inc);
  684. }
  685. } else {
  686. struct slave *slave;
  687. int i;
  688. bond_for_each_slave(bond, slave, i) {
  689. dev_set_promiscuity(slave->dev, inc);
  690. }
  691. }
  692. }
  693. /*
  694. * Push the allmulti flag down to all slaves
  695. */
  696. static void bond_set_allmulti(struct bonding *bond, int inc)
  697. {
  698. if (USES_PRIMARY(bond->params.mode)) {
  699. /* write lock already acquired */
  700. if (bond->curr_active_slave) {
  701. dev_set_allmulti(bond->curr_active_slave->dev, inc);
  702. }
  703. } else {
  704. struct slave *slave;
  705. int i;
  706. bond_for_each_slave(bond, slave, i) {
  707. dev_set_allmulti(slave->dev, inc);
  708. }
  709. }
  710. }
  711. /*
  712. * Add a Multicast address to slaves
  713. * according to mode
  714. */
  715. static void bond_mc_add(struct bonding *bond, void *addr, int alen)
  716. {
  717. if (USES_PRIMARY(bond->params.mode)) {
  718. /* write lock already acquired */
  719. if (bond->curr_active_slave) {
  720. dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0);
  721. }
  722. } else {
  723. struct slave *slave;
  724. int i;
  725. bond_for_each_slave(bond, slave, i) {
  726. dev_mc_add(slave->dev, addr, alen, 0);
  727. }
  728. }
  729. }
  730. /*
  731. * Remove a multicast address from slave
  732. * according to mode
  733. */
  734. static void bond_mc_delete(struct bonding *bond, void *addr, int alen)
  735. {
  736. if (USES_PRIMARY(bond->params.mode)) {
  737. /* write lock already acquired */
  738. if (bond->curr_active_slave) {
  739. dev_mc_delete(bond->curr_active_slave->dev, addr, alen, 0);
  740. }
  741. } else {
  742. struct slave *slave;
  743. int i;
  744. bond_for_each_slave(bond, slave, i) {
  745. dev_mc_delete(slave->dev, addr, alen, 0);
  746. }
  747. }
  748. }
  749. /*
  750. * Retrieve the list of registered multicast addresses for the bonding
  751. * device and retransmit an IGMP JOIN request to the current active
  752. * slave.
  753. */
  754. static void bond_resend_igmp_join_requests(struct bonding *bond)
  755. {
  756. struct in_device *in_dev;
  757. struct ip_mc_list *im;
  758. rcu_read_lock();
  759. in_dev = __in_dev_get_rcu(bond->dev);
  760. if (in_dev) {
  761. for (im = in_dev->mc_list; im; im = im->next) {
  762. ip_mc_rejoin_group(im);
  763. }
  764. }
  765. rcu_read_unlock();
  766. }
  767. /*
  768. * Totally destroys the mc_list in bond
  769. */
  770. static void bond_mc_list_destroy(struct bonding *bond)
  771. {
  772. struct dev_mc_list *dmi;
  773. dmi = bond->mc_list;
  774. while (dmi) {
  775. bond->mc_list = dmi->next;
  776. kfree(dmi);
  777. dmi = bond->mc_list;
  778. }
  779. bond->mc_list = NULL;
  780. }
  781. /*
  782. * Copy all the Multicast addresses from src to the bonding device dst
  783. */
  784. static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond,
  785. gfp_t gfp_flag)
  786. {
  787. struct dev_mc_list *dmi, *new_dmi;
  788. for (dmi = mc_list; dmi; dmi = dmi->next) {
  789. new_dmi = kmalloc(sizeof(struct dev_mc_list), gfp_flag);
  790. if (!new_dmi) {
  791. /* FIXME: Potential memory leak !!! */
  792. return -ENOMEM;
  793. }
  794. new_dmi->next = bond->mc_list;
  795. bond->mc_list = new_dmi;
  796. new_dmi->dmi_addrlen = dmi->dmi_addrlen;
  797. memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen);
  798. new_dmi->dmi_users = dmi->dmi_users;
  799. new_dmi->dmi_gusers = dmi->dmi_gusers;
  800. }
  801. return 0;
  802. }
  803. /*
  804. * flush all members of flush->mc_list from device dev->mc_list
  805. */
  806. static void bond_mc_list_flush(struct net_device *bond_dev, struct net_device *slave_dev)
  807. {
  808. struct bonding *bond = bond_dev->priv;
  809. struct dev_mc_list *dmi;
  810. for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
  811. dev_mc_delete(slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
  812. }
  813. if (bond->params.mode == BOND_MODE_8023AD) {
  814. /* del lacpdu mc addr from mc list */
  815. u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
  816. dev_mc_delete(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
  817. }
  818. }
  819. /*--------------------------- Active slave change ---------------------------*/
  820. /*
  821. * Update the mc list and multicast-related flags for the new and
  822. * old active slaves (if any) according to the multicast mode, and
  823. * promiscuous flags unconditionally.
  824. */
  825. static void bond_mc_swap(struct bonding *bond, struct slave *new_active, struct slave *old_active)
  826. {
  827. struct dev_mc_list *dmi;
  828. if (!USES_PRIMARY(bond->params.mode)) {
  829. /* nothing to do - mc list is already up-to-date on
  830. * all slaves
  831. */
  832. return;
  833. }
  834. if (old_active) {
  835. if (bond->dev->flags & IFF_PROMISC) {
  836. dev_set_promiscuity(old_active->dev, -1);
  837. }
  838. if (bond->dev->flags & IFF_ALLMULTI) {
  839. dev_set_allmulti(old_active->dev, -1);
  840. }
  841. for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
  842. dev_mc_delete(old_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
  843. }
  844. }
  845. if (new_active) {
  846. if (bond->dev->flags & IFF_PROMISC) {
  847. dev_set_promiscuity(new_active->dev, 1);
  848. }
  849. if (bond->dev->flags & IFF_ALLMULTI) {
  850. dev_set_allmulti(new_active->dev, 1);
  851. }
  852. for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) {
  853. dev_mc_add(new_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
  854. }
  855. bond_resend_igmp_join_requests(bond);
  856. }
  857. }
  858. /**
  859. * find_best_interface - select the best available slave to be the active one
  860. * @bond: our bonding struct
  861. *
  862. * Warning: Caller must hold curr_slave_lock for writing.
  863. */
  864. static struct slave *bond_find_best_slave(struct bonding *bond)
  865. {
  866. struct slave *new_active, *old_active;
  867. struct slave *bestslave = NULL;
  868. int mintime = bond->params.updelay;
  869. int i;
  870. new_active = old_active = bond->curr_active_slave;
  871. if (!new_active) { /* there were no active slaves left */
  872. if (bond->slave_cnt > 0) { /* found one slave */
  873. new_active = bond->first_slave;
  874. } else {
  875. return NULL; /* still no slave, return NULL */
  876. }
  877. }
  878. /* first try the primary link; if arping, a link must tx/rx traffic
  879. * before it can be considered the curr_active_slave - also, we would skip
  880. * slaves between the curr_active_slave and primary_slave that may be up
  881. * and able to arp
  882. */
  883. if ((bond->primary_slave) &&
  884. (!bond->params.arp_interval) &&
  885. (IS_UP(bond->primary_slave->dev))) {
  886. new_active = bond->primary_slave;
  887. }
  888. /* remember where to stop iterating over the slaves */
  889. old_active = new_active;
  890. bond_for_each_slave_from(bond, new_active, i, old_active) {
  891. if (IS_UP(new_active->dev)) {
  892. if (new_active->link == BOND_LINK_UP) {
  893. return new_active;
  894. } else if (new_active->link == BOND_LINK_BACK) {
  895. /* link up, but waiting for stabilization */
  896. if (new_active->delay < mintime) {
  897. mintime = new_active->delay;
  898. bestslave = new_active;
  899. }
  900. }
  901. }
  902. }
  903. return bestslave;
  904. }
  905. /**
  906. * change_active_interface - change the active slave into the specified one
  907. * @bond: our bonding struct
  908. * @new: the new slave to make the active one
  909. *
  910. * Set the new slave to the bond's settings and unset them on the old
  911. * curr_active_slave.
  912. * Setting include flags, mc-list, promiscuity, allmulti, etc.
  913. *
  914. * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP,
  915. * because it is apparently the best available slave we have, even though its
  916. * updelay hasn't timed out yet.
  917. *
  918. * Warning: Caller must hold curr_slave_lock for writing.
  919. */
  920. void bond_change_active_slave(struct bonding *bond, struct slave *new_active)
  921. {
  922. struct slave *old_active = bond->curr_active_slave;
  923. if (old_active == new_active) {
  924. return;
  925. }
  926. if (new_active) {
  927. if (new_active->link == BOND_LINK_BACK) {
  928. if (USES_PRIMARY(bond->params.mode)) {
  929. printk(KERN_INFO DRV_NAME
  930. ": %s: making interface %s the new "
  931. "active one %d ms earlier.\n",
  932. bond->dev->name, new_active->dev->name,
  933. (bond->params.updelay - new_active->delay) * bond->params.miimon);
  934. }
  935. new_active->delay = 0;
  936. new_active->link = BOND_LINK_UP;
  937. new_active->jiffies = jiffies;
  938. if (bond->params.mode == BOND_MODE_8023AD) {
  939. bond_3ad_handle_link_change(new_active, BOND_LINK_UP);
  940. }
  941. if ((bond->params.mode == BOND_MODE_TLB) ||
  942. (bond->params.mode == BOND_MODE_ALB)) {
  943. bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP);
  944. }
  945. } else {
  946. if (USES_PRIMARY(bond->params.mode)) {
  947. printk(KERN_INFO DRV_NAME
  948. ": %s: making interface %s the new "
  949. "active one.\n",
  950. bond->dev->name, new_active->dev->name);
  951. }
  952. }
  953. }
  954. if (USES_PRIMARY(bond->params.mode)) {
  955. bond_mc_swap(bond, new_active, old_active);
  956. }
  957. if ((bond->params.mode == BOND_MODE_TLB) ||
  958. (bond->params.mode == BOND_MODE_ALB)) {
  959. bond_alb_handle_active_change(bond, new_active);
  960. if (old_active)
  961. bond_set_slave_inactive_flags(old_active);
  962. if (new_active)
  963. bond_set_slave_active_flags(new_active);
  964. } else {
  965. bond->curr_active_slave = new_active;
  966. }
  967. if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
  968. if (old_active) {
  969. bond_set_slave_inactive_flags(old_active);
  970. }
  971. if (new_active) {
  972. bond_set_slave_active_flags(new_active);
  973. }
  974. bond_send_gratuitous_arp(bond);
  975. }
  976. }
  977. /**
  978. * bond_select_active_slave - select a new active slave, if needed
  979. * @bond: our bonding struct
  980. *
  981. * This functions shoud be called when one of the following occurs:
  982. * - The old curr_active_slave has been released or lost its link.
  983. * - The primary_slave has got its link back.
  984. * - A slave has got its link back and there's no old curr_active_slave.
  985. *
  986. * Warning: Caller must hold curr_slave_lock for writing.
  987. */
  988. void bond_select_active_slave(struct bonding *bond)
  989. {
  990. struct slave *best_slave;
  991. int rv;
  992. best_slave = bond_find_best_slave(bond);
  993. if (best_slave != bond->curr_active_slave) {
  994. bond_change_active_slave(bond, best_slave);
  995. rv = bond_set_carrier(bond);
  996. if (!rv)
  997. return;
  998. if (netif_carrier_ok(bond->dev)) {
  999. printk(KERN_INFO DRV_NAME
  1000. ": %s: first active interface up!\n",
  1001. bond->dev->name);
  1002. } else {
  1003. printk(KERN_INFO DRV_NAME ": %s: "
  1004. "now running without any active interface !\n",
  1005. bond->dev->name);
  1006. }
  1007. }
  1008. }
  1009. /*--------------------------- slave list handling ---------------------------*/
  1010. /*
  1011. * This function attaches the slave to the end of list.
  1012. *
  1013. * bond->lock held for writing by caller.
  1014. */
  1015. static void bond_attach_slave(struct bonding *bond, struct slave *new_slave)
  1016. {
  1017. if (bond->first_slave == NULL) { /* attaching the first slave */
  1018. new_slave->next = new_slave;
  1019. new_slave->prev = new_slave;
  1020. bond->first_slave = new_slave;
  1021. } else {
  1022. new_slave->next = bond->first_slave;
  1023. new_slave->prev = bond->first_slave->prev;
  1024. new_slave->next->prev = new_slave;
  1025. new_slave->prev->next = new_slave;
  1026. }
  1027. bond->slave_cnt++;
  1028. }
  1029. /*
  1030. * This function detaches the slave from the list.
  1031. * WARNING: no check is made to verify if the slave effectively
  1032. * belongs to <bond>.
  1033. * Nothing is freed on return, structures are just unchained.
  1034. * If any slave pointer in bond was pointing to <slave>,
  1035. * it should be changed by the calling function.
  1036. *
  1037. * bond->lock held for writing by caller.
  1038. */
  1039. static void bond_detach_slave(struct bonding *bond, struct slave *slave)
  1040. {
  1041. if (slave->next) {
  1042. slave->next->prev = slave->prev;
  1043. }
  1044. if (slave->prev) {
  1045. slave->prev->next = slave->next;
  1046. }
  1047. if (bond->first_slave == slave) { /* slave is the first slave */
  1048. if (bond->slave_cnt > 1) { /* there are more slave */
  1049. bond->first_slave = slave->next;
  1050. } else {
  1051. bond->first_slave = NULL; /* slave was the last one */
  1052. }
  1053. }
  1054. slave->next = NULL;
  1055. slave->prev = NULL;
  1056. bond->slave_cnt--;
  1057. }
  1058. /*---------------------------------- IOCTL ----------------------------------*/
  1059. static int bond_sethwaddr(struct net_device *bond_dev,
  1060. struct net_device *slave_dev)
  1061. {
  1062. dprintk("bond_dev=%p\n", bond_dev);
  1063. dprintk("slave_dev=%p\n", slave_dev);
  1064. dprintk("slave_dev->addr_len=%d\n", slave_dev->addr_len);
  1065. memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len);
  1066. return 0;
  1067. }
  1068. #define BOND_INTERSECT_FEATURES \
  1069. (NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_TSO | NETIF_F_UFO)
  1070. /*
  1071. * Compute the common dev->feature set available to all slaves. Some
  1072. * feature bits are managed elsewhere, so preserve feature bits set on
  1073. * master device that are not part of the examined set.
  1074. */
  1075. static int bond_compute_features(struct bonding *bond)
  1076. {
  1077. unsigned long features = BOND_INTERSECT_FEATURES;
  1078. struct slave *slave;
  1079. struct net_device *bond_dev = bond->dev;
  1080. unsigned short max_hard_header_len = ETH_HLEN;
  1081. int i;
  1082. bond_for_each_slave(bond, slave, i) {
  1083. features &= (slave->dev->features & BOND_INTERSECT_FEATURES);
  1084. if (slave->dev->hard_header_len > max_hard_header_len)
  1085. max_hard_header_len = slave->dev->hard_header_len;
  1086. }
  1087. if ((features & NETIF_F_SG) &&
  1088. !(features & NETIF_F_ALL_CSUM))
  1089. features &= ~NETIF_F_SG;
  1090. /*
  1091. * features will include NETIF_F_TSO (NETIF_F_UFO) iff all
  1092. * slave devices support NETIF_F_TSO (NETIF_F_UFO), which
  1093. * implies that all slaves also support scatter-gather
  1094. * (NETIF_F_SG), which implies that features also includes
  1095. * NETIF_F_SG. So no need to check whether we have an
  1096. * illegal combination of NETIF_F_{TSO,UFO} and
  1097. * !NETIF_F_SG
  1098. */
  1099. features |= (bond_dev->features & ~BOND_INTERSECT_FEATURES);
  1100. bond_dev->features = features;
  1101. bond_dev->hard_header_len = max_hard_header_len;
  1102. return 0;
  1103. }
  1104. /* enslave device <slave> to bond device <master> */
  1105. int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev)
  1106. {
  1107. struct bonding *bond = bond_dev->priv;
  1108. struct slave *new_slave = NULL;
  1109. struct dev_mc_list *dmi;
  1110. struct sockaddr addr;
  1111. int link_reporting;
  1112. int old_features = bond_dev->features;
  1113. int res = 0;
  1114. if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL &&
  1115. slave_dev->do_ioctl == NULL) {
  1116. printk(KERN_WARNING DRV_NAME
  1117. ": %s: Warning: no link monitoring support for %s\n",
  1118. bond_dev->name, slave_dev->name);
  1119. }
  1120. /* bond must be initialized by bond_open() before enslaving */
  1121. if (!(bond_dev->flags & IFF_UP)) {
  1122. dprintk("Error, master_dev is not up\n");
  1123. return -EPERM;
  1124. }
  1125. /* already enslaved */
  1126. if (slave_dev->flags & IFF_SLAVE) {
  1127. dprintk("Error, Device was already enslaved\n");
  1128. return -EBUSY;
  1129. }
  1130. /* vlan challenged mutual exclusion */
  1131. /* no need to lock since we're protected by rtnl_lock */
  1132. if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) {
  1133. dprintk("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
  1134. if (!list_empty(&bond->vlan_list)) {
  1135. printk(KERN_ERR DRV_NAME
  1136. ": %s: Error: cannot enslave VLAN "
  1137. "challenged slave %s on VLAN enabled "
  1138. "bond %s\n", bond_dev->name, slave_dev->name,
  1139. bond_dev->name);
  1140. return -EPERM;
  1141. } else {
  1142. printk(KERN_WARNING DRV_NAME
  1143. ": %s: Warning: enslaved VLAN challenged "
  1144. "slave %s. Adding VLANs will be blocked as "
  1145. "long as %s is part of bond %s\n",
  1146. bond_dev->name, slave_dev->name, slave_dev->name,
  1147. bond_dev->name);
  1148. bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
  1149. }
  1150. } else {
  1151. dprintk("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name);
  1152. if (bond->slave_cnt == 0) {
  1153. /* First slave, and it is not VLAN challenged,
  1154. * so remove the block of adding VLANs over the bond.
  1155. */
  1156. bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
  1157. }
  1158. }
  1159. /*
  1160. * Old ifenslave binaries are no longer supported. These can
  1161. * be identified with moderate accurary by the state of the slave:
  1162. * the current ifenslave will set the interface down prior to
  1163. * enslaving it; the old ifenslave will not.
  1164. */
  1165. if ((slave_dev->flags & IFF_UP)) {
  1166. printk(KERN_ERR DRV_NAME ": %s is up. "
  1167. "This may be due to an out of date ifenslave.\n",
  1168. slave_dev->name);
  1169. res = -EPERM;
  1170. goto err_undo_flags;
  1171. }
  1172. if (slave_dev->set_mac_address == NULL) {
  1173. printk(KERN_ERR DRV_NAME
  1174. ": %s: Error: The slave device you specified does "
  1175. "not support setting the MAC address. "
  1176. "Your kernel likely does not support slave "
  1177. "devices.\n", bond_dev->name);
  1178. res = -EOPNOTSUPP;
  1179. goto err_undo_flags;
  1180. }
  1181. new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL);
  1182. if (!new_slave) {
  1183. res = -ENOMEM;
  1184. goto err_undo_flags;
  1185. }
  1186. /* save slave's original flags before calling
  1187. * netdev_set_master and dev_open
  1188. */
  1189. new_slave->original_flags = slave_dev->flags;
  1190. /*
  1191. * Save slave's original ("permanent") mac address for modes
  1192. * that need it, and for restoring it upon release, and then
  1193. * set it to the master's address
  1194. */
  1195. memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN);
  1196. /*
  1197. * Set slave to master's mac address. The application already
  1198. * set the master's mac address to that of the first slave
  1199. */
  1200. memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
  1201. addr.sa_family = slave_dev->type;
  1202. res = dev_set_mac_address(slave_dev, &addr);
  1203. if (res) {
  1204. dprintk("Error %d calling set_mac_address\n", res);
  1205. goto err_free;
  1206. }
  1207. res = netdev_set_master(slave_dev, bond_dev);
  1208. if (res) {
  1209. dprintk("Error %d calling netdev_set_master\n", res);
  1210. goto err_close;
  1211. }
  1212. /* open the slave since the application closed it */
  1213. res = dev_open(slave_dev);
  1214. if (res) {
  1215. dprintk("Openning slave %s failed\n", slave_dev->name);
  1216. goto err_restore_mac;
  1217. }
  1218. new_slave->dev = slave_dev;
  1219. slave_dev->priv_flags |= IFF_BONDING;
  1220. if ((bond->params.mode == BOND_MODE_TLB) ||
  1221. (bond->params.mode == BOND_MODE_ALB)) {
  1222. /* bond_alb_init_slave() must be called before all other stages since
  1223. * it might fail and we do not want to have to undo everything
  1224. */
  1225. res = bond_alb_init_slave(bond, new_slave);
  1226. if (res) {
  1227. goto err_unset_master;
  1228. }
  1229. }
  1230. /* If the mode USES_PRIMARY, then the new slave gets the
  1231. * master's promisc (and mc) settings only if it becomes the
  1232. * curr_active_slave, and that is taken care of later when calling
  1233. * bond_change_active()
  1234. */
  1235. if (!USES_PRIMARY(bond->params.mode)) {
  1236. /* set promiscuity level to new slave */
  1237. if (bond_dev->flags & IFF_PROMISC) {
  1238. dev_set_promiscuity(slave_dev, 1);
  1239. }
  1240. /* set allmulti level to new slave */
  1241. if (bond_dev->flags & IFF_ALLMULTI) {
  1242. dev_set_allmulti(slave_dev, 1);
  1243. }
  1244. /* upload master's mc_list to new slave */
  1245. for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
  1246. dev_mc_add (slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0);
  1247. }
  1248. }
  1249. if (bond->params.mode == BOND_MODE_8023AD) {
  1250. /* add lacpdu mc addr to mc list */
  1251. u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
  1252. dev_mc_add(slave_dev, lacpdu_multicast, ETH_ALEN, 0);
  1253. }
  1254. bond_add_vlans_on_slave(bond, slave_dev);
  1255. write_lock_bh(&bond->lock);
  1256. bond_attach_slave(bond, new_slave);
  1257. new_slave->delay = 0;
  1258. new_slave->link_failure_count = 0;
  1259. bond_compute_features(bond);
  1260. new_slave->last_arp_rx = jiffies;
  1261. if (bond->params.miimon && !bond->params.use_carrier) {
  1262. link_reporting = bond_check_dev_link(bond, slave_dev, 1);
  1263. if ((link_reporting == -1) && !bond->params.arp_interval) {
  1264. /*
  1265. * miimon is set but a bonded network driver
  1266. * does not support ETHTOOL/MII and
  1267. * arp_interval is not set. Note: if
  1268. * use_carrier is enabled, we will never go
  1269. * here (because netif_carrier is always
  1270. * supported); thus, we don't need to change
  1271. * the messages for netif_carrier.
  1272. */
  1273. printk(KERN_WARNING DRV_NAME
  1274. ": %s: Warning: MII and ETHTOOL support not "
  1275. "available for interface %s, and "
  1276. "arp_interval/arp_ip_target module parameters "
  1277. "not specified, thus bonding will not detect "
  1278. "link failures! see bonding.txt for details.\n",
  1279. bond_dev->name, slave_dev->name);
  1280. } else if (link_reporting == -1) {
  1281. /* unable get link status using mii/ethtool */
  1282. printk(KERN_WARNING DRV_NAME
  1283. ": %s: Warning: can't get link status from "
  1284. "interface %s; the network driver associated "
  1285. "with this interface does not support MII or "
  1286. "ETHTOOL link status reporting, thus miimon "
  1287. "has no effect on this interface.\n",
  1288. bond_dev->name, slave_dev->name);
  1289. }
  1290. }
  1291. /* check for initial state */
  1292. if (!bond->params.miimon ||
  1293. (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) {
  1294. if (bond->params.updelay) {
  1295. dprintk("Initial state of slave_dev is "
  1296. "BOND_LINK_BACK\n");
  1297. new_slave->link = BOND_LINK_BACK;
  1298. new_slave->delay = bond->params.updelay;
  1299. } else {
  1300. dprintk("Initial state of slave_dev is "
  1301. "BOND_LINK_UP\n");
  1302. new_slave->link = BOND_LINK_UP;
  1303. }
  1304. new_slave->jiffies = jiffies;
  1305. } else {
  1306. dprintk("Initial state of slave_dev is "
  1307. "BOND_LINK_DOWN\n");
  1308. new_slave->link = BOND_LINK_DOWN;
  1309. }
  1310. if (bond_update_speed_duplex(new_slave) &&
  1311. (new_slave->link != BOND_LINK_DOWN)) {
  1312. printk(KERN_WARNING DRV_NAME
  1313. ": %s: Warning: failed to get speed and duplex from %s, "
  1314. "assumed to be 100Mb/sec and Full.\n",
  1315. bond_dev->name, new_slave->dev->name);
  1316. if (bond->params.mode == BOND_MODE_8023AD) {
  1317. printk(KERN_WARNING DRV_NAME
  1318. ": %s: Warning: Operation of 802.3ad mode requires ETHTOOL "
  1319. "support in base driver for proper aggregator "
  1320. "selection.\n", bond_dev->name);
  1321. }
  1322. }
  1323. if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) {
  1324. /* if there is a primary slave, remember it */
  1325. if (strcmp(bond->params.primary, new_slave->dev->name) == 0) {
  1326. bond->primary_slave = new_slave;
  1327. }
  1328. }
  1329. switch (bond->params.mode) {
  1330. case BOND_MODE_ACTIVEBACKUP:
  1331. bond_set_slave_inactive_flags(new_slave);
  1332. bond_select_active_slave(bond);
  1333. break;
  1334. case BOND_MODE_8023AD:
  1335. /* in 802.3ad mode, the internal mechanism
  1336. * will activate the slaves in the selected
  1337. * aggregator
  1338. */
  1339. bond_set_slave_inactive_flags(new_slave);
  1340. /* if this is the first slave */
  1341. if (bond->slave_cnt == 1) {
  1342. SLAVE_AD_INFO(new_slave).id = 1;
  1343. /* Initialize AD with the number of times that the AD timer is called in 1 second
  1344. * can be called only after the mac address of the bond is set
  1345. */
  1346. bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL,
  1347. bond->params.lacp_fast);
  1348. } else {
  1349. SLAVE_AD_INFO(new_slave).id =
  1350. SLAVE_AD_INFO(new_slave->prev).id + 1;
  1351. }
  1352. bond_3ad_bind_slave(new_slave);
  1353. break;
  1354. case BOND_MODE_TLB:
  1355. case BOND_MODE_ALB:
  1356. new_slave->state = BOND_STATE_ACTIVE;
  1357. if ((!bond->curr_active_slave) &&
  1358. (new_slave->link != BOND_LINK_DOWN)) {
  1359. /* first slave or no active slave yet, and this link
  1360. * is OK, so make this interface the active one
  1361. */
  1362. bond_change_active_slave(bond, new_slave);
  1363. } else {
  1364. bond_set_slave_inactive_flags(new_slave);
  1365. }
  1366. break;
  1367. default:
  1368. dprintk("This slave is always active in trunk mode\n");
  1369. /* always active in trunk mode */
  1370. new_slave->state = BOND_STATE_ACTIVE;
  1371. /* In trunking mode there is little meaning to curr_active_slave
  1372. * anyway (it holds no special properties of the bond device),
  1373. * so we can change it without calling change_active_interface()
  1374. */
  1375. if (!bond->curr_active_slave) {
  1376. bond->curr_active_slave = new_slave;
  1377. }
  1378. break;
  1379. } /* switch(bond_mode) */
  1380. bond_set_carrier(bond);
  1381. write_unlock_bh(&bond->lock);
  1382. res = bond_create_slave_symlinks(bond_dev, slave_dev);
  1383. if (res)
  1384. goto err_unset_master;
  1385. printk(KERN_INFO DRV_NAME
  1386. ": %s: enslaving %s as a%s interface with a%s link.\n",
  1387. bond_dev->name, slave_dev->name,
  1388. new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup",
  1389. new_slave->link != BOND_LINK_DOWN ? "n up" : " down");
  1390. /* enslave is successful */
  1391. return 0;
  1392. /* Undo stages on error */
  1393. err_unset_master:
  1394. netdev_set_master(slave_dev, NULL);
  1395. err_close:
  1396. dev_close(slave_dev);
  1397. err_restore_mac:
  1398. memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN);
  1399. addr.sa_family = slave_dev->type;
  1400. dev_set_mac_address(slave_dev, &addr);
  1401. err_free:
  1402. kfree(new_slave);
  1403. err_undo_flags:
  1404. bond_dev->features = old_features;
  1405. return res;
  1406. }
  1407. /*
  1408. * Try to release the slave device <slave> from the bond device <master>
  1409. * It is legal to access curr_active_slave without a lock because all the function
  1410. * is write-locked.
  1411. *
  1412. * The rules for slave state should be:
  1413. * for Active/Backup:
  1414. * Active stays on all backups go down
  1415. * for Bonded connections:
  1416. * The first up interface should be left on and all others downed.
  1417. */
  1418. int bond_release(struct net_device *bond_dev, struct net_device *slave_dev)
  1419. {
  1420. struct bonding *bond = bond_dev->priv;
  1421. struct slave *slave, *oldcurrent;
  1422. struct sockaddr addr;
  1423. int mac_addr_differ;
  1424. /* slave is not a slave or master is not master of this slave */
  1425. if (!(slave_dev->flags & IFF_SLAVE) ||
  1426. (slave_dev->master != bond_dev)) {
  1427. printk(KERN_ERR DRV_NAME
  1428. ": %s: Error: cannot release %s.\n",
  1429. bond_dev->name, slave_dev->name);
  1430. return -EINVAL;
  1431. }
  1432. write_lock_bh(&bond->lock);
  1433. slave = bond_get_slave_by_dev(bond, slave_dev);
  1434. if (!slave) {
  1435. /* not a slave of this bond */
  1436. printk(KERN_INFO DRV_NAME
  1437. ": %s: %s not enslaved\n",
  1438. bond_dev->name, slave_dev->name);
  1439. write_unlock_bh(&bond->lock);
  1440. return -EINVAL;
  1441. }
  1442. mac_addr_differ = memcmp(bond_dev->dev_addr,
  1443. slave->perm_hwaddr,
  1444. ETH_ALEN);
  1445. if (!mac_addr_differ && (bond->slave_cnt > 1)) {
  1446. printk(KERN_WARNING DRV_NAME
  1447. ": %s: Warning: the permanent HWaddr of %s "
  1448. "- %02X:%02X:%02X:%02X:%02X:%02X - is "
  1449. "still in use by %s. Set the HWaddr of "
  1450. "%s to a different address to avoid "
  1451. "conflicts.\n",
  1452. bond_dev->name,
  1453. slave_dev->name,
  1454. slave->perm_hwaddr[0],
  1455. slave->perm_hwaddr[1],
  1456. slave->perm_hwaddr[2],
  1457. slave->perm_hwaddr[3],
  1458. slave->perm_hwaddr[4],
  1459. slave->perm_hwaddr[5],
  1460. bond_dev->name,
  1461. slave_dev->name);
  1462. }
  1463. /* Inform AD package of unbinding of slave. */
  1464. if (bond->params.mode == BOND_MODE_8023AD) {
  1465. /* must be called before the slave is
  1466. * detached from the list
  1467. */
  1468. bond_3ad_unbind_slave(slave);
  1469. }
  1470. printk(KERN_INFO DRV_NAME
  1471. ": %s: releasing %s interface %s\n",
  1472. bond_dev->name,
  1473. (slave->state == BOND_STATE_ACTIVE)
  1474. ? "active" : "backup",
  1475. slave_dev->name);
  1476. oldcurrent = bond->curr_active_slave;
  1477. bond->current_arp_slave = NULL;
  1478. /* release the slave from its bond */
  1479. bond_detach_slave(bond, slave);
  1480. bond_compute_features(bond);
  1481. if (bond->primary_slave == slave) {
  1482. bond->primary_slave = NULL;
  1483. }
  1484. if (oldcurrent == slave) {
  1485. bond_change_active_slave(bond, NULL);
  1486. }
  1487. if ((bond->params.mode == BOND_MODE_TLB) ||
  1488. (bond->params.mode == BOND_MODE_ALB)) {
  1489. /* Must be called only after the slave has been
  1490. * detached from the list and the curr_active_slave
  1491. * has been cleared (if our_slave == old_current),
  1492. * but before a new active slave is selected.
  1493. */
  1494. bond_alb_deinit_slave(bond, slave);
  1495. }
  1496. if (oldcurrent == slave)
  1497. bond_select_active_slave(bond);
  1498. if (bond->slave_cnt == 0) {
  1499. bond_set_carrier(bond);
  1500. /* if the last slave was removed, zero the mac address
  1501. * of the master so it will be set by the application
  1502. * to the mac address of the first slave
  1503. */
  1504. memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
  1505. if (list_empty(&bond->vlan_list)) {
  1506. bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
  1507. } else {
  1508. printk(KERN_WARNING DRV_NAME
  1509. ": %s: Warning: clearing HW address of %s while it "
  1510. "still has VLANs.\n",
  1511. bond_dev->name, bond_dev->name);
  1512. printk(KERN_WARNING DRV_NAME
  1513. ": %s: When re-adding slaves, make sure the bond's "
  1514. "HW address matches its VLANs'.\n",
  1515. bond_dev->name);
  1516. }
  1517. } else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) &&
  1518. !bond_has_challenged_slaves(bond)) {
  1519. printk(KERN_INFO DRV_NAME
  1520. ": %s: last VLAN challenged slave %s "
  1521. "left bond %s. VLAN blocking is removed\n",
  1522. bond_dev->name, slave_dev->name, bond_dev->name);
  1523. bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED;
  1524. }
  1525. write_unlock_bh(&bond->lock);
  1526. /* must do this from outside any spinlocks */
  1527. bond_destroy_slave_symlinks(bond_dev, slave_dev);
  1528. bond_del_vlans_from_slave(bond, slave_dev);
  1529. /* If the mode USES_PRIMARY, then we should only remove its
  1530. * promisc and mc settings if it was the curr_active_slave, but that was
  1531. * already taken care of above when we detached the slave
  1532. */
  1533. if (!USES_PRIMARY(bond->params.mode)) {
  1534. /* unset promiscuity level from slave */
  1535. if (bond_dev->flags & IFF_PROMISC) {
  1536. dev_set_promiscuity(slave_dev, -1);
  1537. }
  1538. /* unset allmulti level from slave */
  1539. if (bond_dev->flags & IFF_ALLMULTI) {
  1540. dev_set_allmulti(slave_dev, -1);
  1541. }
  1542. /* flush master's mc_list from slave */
  1543. bond_mc_list_flush(bond_dev, slave_dev);
  1544. }
  1545. netdev_set_master(slave_dev, NULL);
  1546. /* close slave before restoring its mac address */
  1547. dev_close(slave_dev);
  1548. /* restore original ("permanent") mac address */
  1549. memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
  1550. addr.sa_family = slave_dev->type;
  1551. dev_set_mac_address(slave_dev, &addr);
  1552. slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
  1553. IFF_SLAVE_INACTIVE | IFF_BONDING |
  1554. IFF_SLAVE_NEEDARP);
  1555. kfree(slave);
  1556. return 0; /* deletion OK */
  1557. }
  1558. /*
  1559. * This function releases all slaves.
  1560. */
  1561. static int bond_release_all(struct net_device *bond_dev)
  1562. {
  1563. struct bonding *bond = bond_dev->priv;
  1564. struct slave *slave;
  1565. struct net_device *slave_dev;
  1566. struct sockaddr addr;
  1567. write_lock_bh(&bond->lock);
  1568. netif_carrier_off(bond_dev);
  1569. if (bond->slave_cnt == 0) {
  1570. goto out;
  1571. }
  1572. bond->current_arp_slave = NULL;
  1573. bond->primary_slave = NULL;
  1574. bond_change_active_slave(bond, NULL);
  1575. while ((slave = bond->first_slave) != NULL) {
  1576. /* Inform AD package of unbinding of slave
  1577. * before slave is detached from the list.
  1578. */
  1579. if (bond->params.mode == BOND_MODE_8023AD) {
  1580. bond_3ad_unbind_slave(slave);
  1581. }
  1582. slave_dev = slave->dev;
  1583. bond_detach_slave(bond, slave);
  1584. if ((bond->params.mode == BOND_MODE_TLB) ||
  1585. (bond->params.mode == BOND_MODE_ALB)) {
  1586. /* must be called only after the slave
  1587. * has been detached from the list
  1588. */
  1589. bond_alb_deinit_slave(bond, slave);
  1590. }
  1591. bond_compute_features(bond);
  1592. /* now that the slave is detached, unlock and perform
  1593. * all the undo steps that should not be called from
  1594. * within a lock.
  1595. */
  1596. write_unlock_bh(&bond->lock);
  1597. bond_destroy_slave_symlinks(bond_dev, slave_dev);
  1598. bond_del_vlans_from_slave(bond, slave_dev);
  1599. /* If the mode USES_PRIMARY, then we should only remove its
  1600. * promisc and mc settings if it was the curr_active_slave, but that was
  1601. * already taken care of above when we detached the slave
  1602. */
  1603. if (!USES_PRIMARY(bond->params.mode)) {
  1604. /* unset promiscuity level from slave */
  1605. if (bond_dev->flags & IFF_PROMISC) {
  1606. dev_set_promiscuity(slave_dev, -1);
  1607. }
  1608. /* unset allmulti level from slave */
  1609. if (bond_dev->flags & IFF_ALLMULTI) {
  1610. dev_set_allmulti(slave_dev, -1);
  1611. }
  1612. /* flush master's mc_list from slave */
  1613. bond_mc_list_flush(bond_dev, slave_dev);
  1614. }
  1615. netdev_set_master(slave_dev, NULL);
  1616. /* close slave before restoring its mac address */
  1617. dev_close(slave_dev);
  1618. /* restore original ("permanent") mac address*/
  1619. memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN);
  1620. addr.sa_family = slave_dev->type;
  1621. dev_set_mac_address(slave_dev, &addr);
  1622. slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB |
  1623. IFF_SLAVE_INACTIVE);
  1624. kfree(slave);
  1625. /* re-acquire the lock before getting the next slave */
  1626. write_lock_bh(&bond->lock);
  1627. }
  1628. /* zero the mac address of the master so it will be
  1629. * set by the application to the mac address of the
  1630. * first slave
  1631. */
  1632. memset(bond_dev->dev_addr, 0, bond_dev->addr_len);
  1633. if (list_empty(&bond->vlan_list)) {
  1634. bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
  1635. } else {
  1636. printk(KERN_WARNING DRV_NAME
  1637. ": %s: Warning: clearing HW address of %s while it "
  1638. "still has VLANs.\n",
  1639. bond_dev->name, bond_dev->name);
  1640. printk(KERN_WARNING DRV_NAME
  1641. ": %s: When re-adding slaves, make sure the bond's "
  1642. "HW address matches its VLANs'.\n",
  1643. bond_dev->name);
  1644. }
  1645. printk(KERN_INFO DRV_NAME
  1646. ": %s: released all slaves\n",
  1647. bond_dev->name);
  1648. out:
  1649. write_unlock_bh(&bond->lock);
  1650. return 0;
  1651. }
  1652. /*
  1653. * This function changes the active slave to slave <slave_dev>.
  1654. * It returns -EINVAL in the following cases.
  1655. * - <slave_dev> is not found in the list.
  1656. * - There is not active slave now.
  1657. * - <slave_dev> is already active.
  1658. * - The link state of <slave_dev> is not BOND_LINK_UP.
  1659. * - <slave_dev> is not running.
  1660. * In these cases, this fuction does nothing.
  1661. * In the other cases, currnt_slave pointer is changed and 0 is returned.
  1662. */
  1663. static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev)
  1664. {
  1665. struct bonding *bond = bond_dev->priv;
  1666. struct slave *old_active = NULL;
  1667. struct slave *new_active = NULL;
  1668. int res = 0;
  1669. if (!USES_PRIMARY(bond->params.mode)) {
  1670. return -EINVAL;
  1671. }
  1672. /* Verify that master_dev is indeed the master of slave_dev */
  1673. if (!(slave_dev->flags & IFF_SLAVE) ||
  1674. (slave_dev->master != bond_dev)) {
  1675. return -EINVAL;
  1676. }
  1677. write_lock_bh(&bond->lock);
  1678. old_active = bond->curr_active_slave;
  1679. new_active = bond_get_slave_by_dev(bond, slave_dev);
  1680. /*
  1681. * Changing to the current active: do nothing; return success.
  1682. */
  1683. if (new_active && (new_active == old_active)) {
  1684. write_unlock_bh(&bond->lock);
  1685. return 0;
  1686. }
  1687. if ((new_active) &&
  1688. (old_active) &&
  1689. (new_active->link == BOND_LINK_UP) &&
  1690. IS_UP(new_active->dev)) {
  1691. bond_change_active_slave(bond, new_active);
  1692. } else {
  1693. res = -EINVAL;
  1694. }
  1695. write_unlock_bh(&bond->lock);
  1696. return res;
  1697. }
  1698. static int bond_info_query(struct net_device *bond_dev, struct ifbond *info)
  1699. {
  1700. struct bonding *bond = bond_dev->priv;
  1701. info->bond_mode = bond->params.mode;
  1702. info->miimon = bond->params.miimon;
  1703. read_lock_bh(&bond->lock);
  1704. info->num_slaves = bond->slave_cnt;
  1705. read_unlock_bh(&bond->lock);
  1706. return 0;
  1707. }
  1708. static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info)
  1709. {
  1710. struct bonding *bond = bond_dev->priv;
  1711. struct slave *slave;
  1712. int i, found = 0;
  1713. if (info->slave_id < 0) {
  1714. return -ENODEV;
  1715. }
  1716. read_lock_bh(&bond->lock);
  1717. bond_for_each_slave(bond, slave, i) {
  1718. if (i == (int)info->slave_id) {
  1719. found = 1;
  1720. break;
  1721. }
  1722. }
  1723. read_unlock_bh(&bond->lock);
  1724. if (found) {
  1725. strcpy(info->slave_name, slave->dev->name);
  1726. info->link = slave->link;
  1727. info->state = slave->state;
  1728. info->link_failure_count = slave->link_failure_count;
  1729. } else {
  1730. return -ENODEV;
  1731. }
  1732. return 0;
  1733. }
  1734. /*-------------------------------- Monitoring -------------------------------*/
  1735. /* this function is called regularly to monitor each slave's link. */
  1736. void bond_mii_monitor(struct net_device *bond_dev)
  1737. {
  1738. struct bonding *bond = bond_dev->priv;
  1739. struct slave *slave, *oldcurrent;
  1740. int do_failover = 0;
  1741. int delta_in_ticks;
  1742. int i;
  1743. read_lock(&bond->lock);
  1744. delta_in_ticks = (bond->params.miimon * HZ) / 1000;
  1745. if (bond->kill_timers) {
  1746. goto out;
  1747. }
  1748. if (bond->slave_cnt == 0) {
  1749. goto re_arm;
  1750. }
  1751. /* we will try to read the link status of each of our slaves, and
  1752. * set their IFF_RUNNING flag appropriately. For each slave not
  1753. * supporting MII status, we won't do anything so that a user-space
  1754. * program could monitor the link itself if needed.
  1755. */
  1756. read_lock(&bond->curr_slave_lock);
  1757. oldcurrent = bond->curr_active_slave;
  1758. read_unlock(&bond->curr_slave_lock);
  1759. bond_for_each_slave(bond, slave, i) {
  1760. struct net_device *slave_dev = slave->dev;
  1761. int link_state;
  1762. u16 old_speed = slave->speed;
  1763. u8 old_duplex = slave->duplex;
  1764. link_state = bond_check_dev_link(bond, slave_dev, 0);
  1765. switch (slave->link) {
  1766. case BOND_LINK_UP: /* the link was up */
  1767. if (link_state == BMSR_LSTATUS) {
  1768. /* link stays up, nothing more to do */
  1769. break;
  1770. } else { /* link going down */
  1771. slave->link = BOND_LINK_FAIL;
  1772. slave->delay = bond->params.downdelay;
  1773. if (slave->link_failure_count < UINT_MAX) {
  1774. slave->link_failure_count++;
  1775. }
  1776. if (bond->params.downdelay) {
  1777. printk(KERN_INFO DRV_NAME
  1778. ": %s: link status down for %s "
  1779. "interface %s, disabling it in "
  1780. "%d ms.\n",
  1781. bond_dev->name,
  1782. IS_UP(slave_dev)
  1783. ? ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
  1784. ? ((slave == oldcurrent)
  1785. ? "active " : "backup ")
  1786. : "")
  1787. : "idle ",
  1788. slave_dev->name,
  1789. bond->params.downdelay * bond->params.miimon);
  1790. }
  1791. }
  1792. /* no break ! fall through the BOND_LINK_FAIL test to
  1793. ensure proper action to be taken
  1794. */
  1795. case BOND_LINK_FAIL: /* the link has just gone down */
  1796. if (link_state != BMSR_LSTATUS) {
  1797. /* link stays down */
  1798. if (slave->delay <= 0) {
  1799. /* link down for too long time */
  1800. slave->link = BOND_LINK_DOWN;
  1801. /* in active/backup mode, we must
  1802. * completely disable this interface
  1803. */
  1804. if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP) ||
  1805. (bond->params.mode == BOND_MODE_8023AD)) {
  1806. bond_set_slave_inactive_flags(slave);
  1807. }
  1808. printk(KERN_INFO DRV_NAME
  1809. ": %s: link status definitely "
  1810. "down for interface %s, "
  1811. "disabling it\n",
  1812. bond_dev->name,
  1813. slave_dev->name);
  1814. /* notify ad that the link status has changed */
  1815. if (bond->params.mode == BOND_MODE_8023AD) {
  1816. bond_3ad_handle_link_change(slave, BOND_LINK_DOWN);
  1817. }
  1818. if ((bond->params.mode == BOND_MODE_TLB) ||
  1819. (bond->params.mode == BOND_MODE_ALB)) {
  1820. bond_alb_handle_link_change(bond, slave, BOND_LINK_DOWN);
  1821. }
  1822. if (slave == oldcurrent) {
  1823. do_failover = 1;
  1824. }
  1825. } else {
  1826. slave->delay--;
  1827. }
  1828. } else {
  1829. /* link up again */
  1830. slave->link = BOND_LINK_UP;
  1831. slave->jiffies = jiffies;
  1832. printk(KERN_INFO DRV_NAME
  1833. ": %s: link status up again after %d "
  1834. "ms for interface %s.\n",
  1835. bond_dev->name,
  1836. (bond->params.downdelay - slave->delay) * bond->params.miimon,
  1837. slave_dev->name);
  1838. }
  1839. break;
  1840. case BOND_LINK_DOWN: /* the link was down */
  1841. if (link_state != BMSR_LSTATUS) {
  1842. /* the link stays down, nothing more to do */
  1843. break;
  1844. } else { /* link going up */
  1845. slave->link = BOND_LINK_BACK;
  1846. slave->delay = bond->params.updelay;
  1847. if (bond->params.updelay) {
  1848. /* if updelay == 0, no need to
  1849. advertise about a 0 ms delay */
  1850. printk(KERN_INFO DRV_NAME
  1851. ": %s: link status up for "
  1852. "interface %s, enabling it "
  1853. "in %d ms.\n",
  1854. bond_dev->name,
  1855. slave_dev->name,
  1856. bond->params.updelay * bond->params.miimon);
  1857. }
  1858. }
  1859. /* no break ! fall through the BOND_LINK_BACK state in
  1860. case there's something to do.
  1861. */
  1862. case BOND_LINK_BACK: /* the link has just come back */
  1863. if (link_state != BMSR_LSTATUS) {
  1864. /* link down again */
  1865. slave->link = BOND_LINK_DOWN;
  1866. printk(KERN_INFO DRV_NAME
  1867. ": %s: link status down again after %d "
  1868. "ms for interface %s.\n",
  1869. bond_dev->name,
  1870. (bond->params.updelay - slave->delay) * bond->params.miimon,
  1871. slave_dev->name);
  1872. } else {
  1873. /* link stays up */
  1874. if (slave->delay == 0) {
  1875. /* now the link has been up for long time enough */
  1876. slave->link = BOND_LINK_UP;
  1877. slave->jiffies = jiffies;
  1878. if (bond->params.mode == BOND_MODE_8023AD) {
  1879. /* prevent it from being the active one */
  1880. slave->state = BOND_STATE_BACKUP;
  1881. } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) {
  1882. /* make it immediately active */
  1883. slave->state = BOND_STATE_ACTIVE;
  1884. } else if (slave != bond->primary_slave) {
  1885. /* prevent it from being the active one */
  1886. slave->state = BOND_STATE_BACKUP;
  1887. }
  1888. printk(KERN_INFO DRV_NAME
  1889. ": %s: link status definitely "
  1890. "up for interface %s.\n",
  1891. bond_dev->name,
  1892. slave_dev->name);
  1893. /* notify ad that the link status has changed */
  1894. if (bond->params.mode == BOND_MODE_8023AD) {
  1895. bond_3ad_handle_link_change(slave, BOND_LINK_UP);
  1896. }
  1897. if ((bond->params.mode == BOND_MODE_TLB) ||
  1898. (bond->params.mode == BOND_MODE_ALB)) {
  1899. bond_alb_handle_link_change(bond, slave, BOND_LINK_UP);
  1900. }
  1901. if ((!oldcurrent) ||
  1902. (slave == bond->primary_slave)) {
  1903. do_failover = 1;
  1904. }
  1905. } else {
  1906. slave->delay--;
  1907. }
  1908. }
  1909. break;
  1910. default:
  1911. /* Should not happen */
  1912. printk(KERN_ERR DRV_NAME
  1913. ": %s: Error: %s Illegal value (link=%d)\n",
  1914. bond_dev->name,
  1915. slave->dev->name,
  1916. slave->link);
  1917. goto out;
  1918. } /* end of switch (slave->link) */
  1919. bond_update_speed_duplex(slave);
  1920. if (bond->params.mode == BOND_MODE_8023AD) {
  1921. if (old_speed != slave->speed) {
  1922. bond_3ad_adapter_speed_changed(slave);
  1923. }
  1924. if (old_duplex != slave->duplex) {
  1925. bond_3ad_adapter_duplex_changed(slave);
  1926. }
  1927. }
  1928. } /* end of for */
  1929. if (do_failover) {
  1930. write_lock(&bond->curr_slave_lock);
  1931. bond_select_active_slave(bond);
  1932. write_unlock(&bond->curr_slave_lock);
  1933. } else
  1934. bond_set_carrier(bond);
  1935. re_arm:
  1936. if (bond->params.miimon) {
  1937. mod_timer(&bond->mii_timer, jiffies + delta_in_ticks);
  1938. }
  1939. out:
  1940. read_unlock(&bond->lock);
  1941. }
  1942. static u32 bond_glean_dev_ip(struct net_device *dev)
  1943. {
  1944. struct in_device *idev;
  1945. struct in_ifaddr *ifa;
  1946. __be32 addr = 0;
  1947. if (!dev)
  1948. return 0;
  1949. rcu_read_lock();
  1950. idev = __in_dev_get_rcu(dev);
  1951. if (!idev)
  1952. goto out;
  1953. ifa = idev->ifa_list;
  1954. if (!ifa)
  1955. goto out;
  1956. addr = ifa->ifa_local;
  1957. out:
  1958. rcu_read_unlock();
  1959. return addr;
  1960. }
  1961. static int bond_has_ip(struct bonding *bond)
  1962. {
  1963. struct vlan_entry *vlan, *vlan_next;
  1964. if (bond->master_ip)
  1965. return 1;
  1966. if (list_empty(&bond->vlan_list))
  1967. return 0;
  1968. list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
  1969. vlan_list) {
  1970. if (vlan->vlan_ip)
  1971. return 1;
  1972. }
  1973. return 0;
  1974. }
  1975. static int bond_has_this_ip(struct bonding *bond, u32 ip)
  1976. {
  1977. struct vlan_entry *vlan, *vlan_next;
  1978. if (ip == bond->master_ip)
  1979. return 1;
  1980. if (list_empty(&bond->vlan_list))
  1981. return 0;
  1982. list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
  1983. vlan_list) {
  1984. if (ip == vlan->vlan_ip)
  1985. return 1;
  1986. }
  1987. return 0;
  1988. }
  1989. /*
  1990. * We go to the (large) trouble of VLAN tagging ARP frames because
  1991. * switches in VLAN mode (especially if ports are configured as
  1992. * "native" to a VLAN) might not pass non-tagged frames.
  1993. */
  1994. static void bond_arp_send(struct net_device *slave_dev, int arp_op, u32 dest_ip, u32 src_ip, unsigned short vlan_id)
  1995. {
  1996. struct sk_buff *skb;
  1997. dprintk("arp %d on slave %s: dst %x src %x vid %d\n", arp_op,
  1998. slave_dev->name, dest_ip, src_ip, vlan_id);
  1999. skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip,
  2000. NULL, slave_dev->dev_addr, NULL);
  2001. if (!skb) {
  2002. printk(KERN_ERR DRV_NAME ": ARP packet allocation failed\n");
  2003. return;
  2004. }
  2005. if (vlan_id) {
  2006. skb = vlan_put_tag(skb, vlan_id);
  2007. if (!skb) {
  2008. printk(KERN_ERR DRV_NAME ": failed to insert VLAN tag\n");
  2009. return;
  2010. }
  2011. }
  2012. arp_xmit(skb);
  2013. }
  2014. static void bond_arp_send_all(struct bonding *bond, struct slave *slave)
  2015. {
  2016. int i, vlan_id, rv;
  2017. u32 *targets = bond->params.arp_targets;
  2018. struct vlan_entry *vlan, *vlan_next;
  2019. struct net_device *vlan_dev;
  2020. struct flowi fl;
  2021. struct rtable *rt;
  2022. for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
  2023. if (!targets[i])
  2024. continue;
  2025. dprintk("basa: target %x\n", targets[i]);
  2026. if (list_empty(&bond->vlan_list)) {
  2027. dprintk("basa: empty vlan: arp_send\n");
  2028. bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
  2029. bond->master_ip, 0);
  2030. continue;
  2031. }
  2032. /*
  2033. * If VLANs are configured, we do a route lookup to
  2034. * determine which VLAN interface would be used, so we
  2035. * can tag the ARP with the proper VLAN tag.
  2036. */
  2037. memset(&fl, 0, sizeof(fl));
  2038. fl.fl4_dst = targets[i];
  2039. fl.fl4_tos = RTO_ONLINK;
  2040. rv = ip_route_output_key(&rt, &fl);
  2041. if (rv) {
  2042. if (net_ratelimit()) {
  2043. printk(KERN_WARNING DRV_NAME
  2044. ": %s: no route to arp_ip_target %u.%u.%u.%u\n",
  2045. bond->dev->name, NIPQUAD(fl.fl4_dst));
  2046. }
  2047. continue;
  2048. }
  2049. /*
  2050. * This target is not on a VLAN
  2051. */
  2052. if (rt->u.dst.dev == bond->dev) {
  2053. ip_rt_put(rt);
  2054. dprintk("basa: rtdev == bond->dev: arp_send\n");
  2055. bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
  2056. bond->master_ip, 0);
  2057. continue;
  2058. }
  2059. vlan_id = 0;
  2060. list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
  2061. vlan_list) {
  2062. vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
  2063. if (vlan_dev == rt->u.dst.dev) {
  2064. vlan_id = vlan->vlan_id;
  2065. dprintk("basa: vlan match on %s %d\n",
  2066. vlan_dev->name, vlan_id);
  2067. break;
  2068. }
  2069. }
  2070. if (vlan_id) {
  2071. ip_rt_put(rt);
  2072. bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i],
  2073. vlan->vlan_ip, vlan_id);
  2074. continue;
  2075. }
  2076. if (net_ratelimit()) {
  2077. printk(KERN_WARNING DRV_NAME
  2078. ": %s: no path to arp_ip_target %u.%u.%u.%u via rt.dev %s\n",
  2079. bond->dev->name, NIPQUAD(fl.fl4_dst),
  2080. rt->u.dst.dev ? rt->u.dst.dev->name : "NULL");
  2081. }
  2082. ip_rt_put(rt);
  2083. }
  2084. }
  2085. /*
  2086. * Kick out a gratuitous ARP for an IP on the bonding master plus one
  2087. * for each VLAN above us.
  2088. */
  2089. static void bond_send_gratuitous_arp(struct bonding *bond)
  2090. {
  2091. struct slave *slave = bond->curr_active_slave;
  2092. struct vlan_entry *vlan;
  2093. struct net_device *vlan_dev;
  2094. dprintk("bond_send_grat_arp: bond %s slave %s\n", bond->dev->name,
  2095. slave ? slave->dev->name : "NULL");
  2096. if (!slave)
  2097. return;
  2098. if (bond->master_ip) {
  2099. bond_arp_send(slave->dev, ARPOP_REPLY, bond->master_ip,
  2100. bond->master_ip, 0);
  2101. }
  2102. list_for_each_entry(vlan, &bond->vlan_list, vlan_list) {
  2103. vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
  2104. if (vlan->vlan_ip) {
  2105. bond_arp_send(slave->dev, ARPOP_REPLY, vlan->vlan_ip,
  2106. vlan->vlan_ip, vlan->vlan_id);
  2107. }
  2108. }
  2109. }
  2110. static void bond_validate_arp(struct bonding *bond, struct slave *slave, u32 sip, u32 tip)
  2111. {
  2112. int i;
  2113. u32 *targets = bond->params.arp_targets;
  2114. targets = bond->params.arp_targets;
  2115. for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) {
  2116. dprintk("bva: sip %u.%u.%u.%u tip %u.%u.%u.%u t[%d] "
  2117. "%u.%u.%u.%u bhti(tip) %d\n",
  2118. NIPQUAD(sip), NIPQUAD(tip), i, NIPQUAD(targets[i]),
  2119. bond_has_this_ip(bond, tip));
  2120. if (sip == targets[i]) {
  2121. if (bond_has_this_ip(bond, tip))
  2122. slave->last_arp_rx = jiffies;
  2123. return;
  2124. }
  2125. }
  2126. }
  2127. static int bond_arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
  2128. {
  2129. struct arphdr *arp;
  2130. struct slave *slave;
  2131. struct bonding *bond;
  2132. unsigned char *arp_ptr;
  2133. u32 sip, tip;
  2134. if (!(dev->priv_flags & IFF_BONDING) || !(dev->flags & IFF_MASTER))
  2135. goto out;
  2136. bond = dev->priv;
  2137. read_lock(&bond->lock);
  2138. dprintk("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",
  2139. bond->dev->name, skb->dev ? skb->dev->name : "NULL",
  2140. orig_dev ? orig_dev->name : "NULL");
  2141. slave = bond_get_slave_by_dev(bond, orig_dev);
  2142. if (!slave || !slave_do_arp_validate(bond, slave))
  2143. goto out_unlock;
  2144. /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
  2145. if (!pskb_may_pull(skb, (sizeof(struct arphdr) +
  2146. (2 * dev->addr_len) +
  2147. (2 * sizeof(u32)))))
  2148. goto out_unlock;
  2149. arp = arp_hdr(skb);
  2150. if (arp->ar_hln != dev->addr_len ||
  2151. skb->pkt_type == PACKET_OTHERHOST ||
  2152. skb->pkt_type == PACKET_LOOPBACK ||
  2153. arp->ar_hrd != htons(ARPHRD_ETHER) ||
  2154. arp->ar_pro != htons(ETH_P_IP) ||
  2155. arp->ar_pln != 4)
  2156. goto out_unlock;
  2157. arp_ptr = (unsigned char *)(arp + 1);
  2158. arp_ptr += dev->addr_len;
  2159. memcpy(&sip, arp_ptr, 4);
  2160. arp_ptr += 4 + dev->addr_len;
  2161. memcpy(&tip, arp_ptr, 4);
  2162. dprintk("bond_arp_rcv: %s %s/%d av %d sv %d sip %u.%u.%u.%u"
  2163. " tip %u.%u.%u.%u\n", bond->dev->name, slave->dev->name,
  2164. slave->state, bond->params.arp_validate,
  2165. slave_do_arp_validate(bond, slave), NIPQUAD(sip), NIPQUAD(tip));
  2166. /*
  2167. * Backup slaves won't see the ARP reply, but do come through
  2168. * here for each ARP probe (so we swap the sip/tip to validate
  2169. * the probe). In a "redundant switch, common router" type of
  2170. * configuration, the ARP probe will (hopefully) travel from
  2171. * the active, through one switch, the router, then the other
  2172. * switch before reaching the backup.
  2173. */
  2174. if (slave->state == BOND_STATE_ACTIVE)
  2175. bond_validate_arp(bond, slave, sip, tip);
  2176. else
  2177. bond_validate_arp(bond, slave, tip, sip);
  2178. out_unlock:
  2179. read_unlock(&bond->lock);
  2180. out:
  2181. dev_kfree_skb(skb);
  2182. return NET_RX_SUCCESS;
  2183. }
  2184. /*
  2185. * this function is called regularly to monitor each slave's link
  2186. * ensuring that traffic is being sent and received when arp monitoring
  2187. * is used in load-balancing mode. if the adapter has been dormant, then an
  2188. * arp is transmitted to generate traffic. see activebackup_arp_monitor for
  2189. * arp monitoring in active backup mode.
  2190. */
  2191. void bond_loadbalance_arp_mon(struct net_device *bond_dev)
  2192. {
  2193. struct bonding *bond = bond_dev->priv;
  2194. struct slave *slave, *oldcurrent;
  2195. int do_failover = 0;
  2196. int delta_in_ticks;
  2197. int i;
  2198. read_lock(&bond->lock);
  2199. delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
  2200. if (bond->kill_timers) {
  2201. goto out;
  2202. }
  2203. if (bond->slave_cnt == 0) {
  2204. goto re_arm;
  2205. }
  2206. read_lock(&bond->curr_slave_lock);
  2207. oldcurrent = bond->curr_active_slave;
  2208. read_unlock(&bond->curr_slave_lock);
  2209. /* see if any of the previous devices are up now (i.e. they have
  2210. * xmt and rcv traffic). the curr_active_slave does not come into
  2211. * the picture unless it is null. also, slave->jiffies is not needed
  2212. * here because we send an arp on each slave and give a slave as
  2213. * long as it needs to get the tx/rx within the delta.
  2214. * TODO: what about up/down delay in arp mode? it wasn't here before
  2215. * so it can wait
  2216. */
  2217. bond_for_each_slave(bond, slave, i) {
  2218. if (slave->link != BOND_LINK_UP) {
  2219. if (((jiffies - slave->dev->trans_start) <= delta_in_ticks) &&
  2220. ((jiffies - slave->dev->last_rx) <= delta_in_ticks)) {
  2221. slave->link = BOND_LINK_UP;
  2222. slave->state = BOND_STATE_ACTIVE;
  2223. /* primary_slave has no meaning in round-robin
  2224. * mode. the window of a slave being up and
  2225. * curr_active_slave being null after enslaving
  2226. * is closed.
  2227. */
  2228. if (!oldcurrent) {
  2229. printk(KERN_INFO DRV_NAME
  2230. ": %s: link status definitely "
  2231. "up for interface %s, ",
  2232. bond_dev->name,
  2233. slave->dev->name);
  2234. do_failover = 1;
  2235. } else {
  2236. printk(KERN_INFO DRV_NAME
  2237. ": %s: interface %s is now up\n",
  2238. bond_dev->name,
  2239. slave->dev->name);
  2240. }
  2241. }
  2242. } else {
  2243. /* slave->link == BOND_LINK_UP */
  2244. /* not all switches will respond to an arp request
  2245. * when the source ip is 0, so don't take the link down
  2246. * if we don't know our ip yet
  2247. */
  2248. if (((jiffies - slave->dev->trans_start) >= (2*delta_in_ticks)) ||
  2249. (((jiffies - slave->dev->last_rx) >= (2*delta_in_ticks)) &&
  2250. bond_has_ip(bond))) {
  2251. slave->link = BOND_LINK_DOWN;
  2252. slave->state = BOND_STATE_BACKUP;
  2253. if (slave->link_failure_count < UINT_MAX) {
  2254. slave->link_failure_count++;
  2255. }
  2256. printk(KERN_INFO DRV_NAME
  2257. ": %s: interface %s is now down.\n",
  2258. bond_dev->name,
  2259. slave->dev->name);
  2260. if (slave == oldcurrent) {
  2261. do_failover = 1;
  2262. }
  2263. }
  2264. }
  2265. /* note: if switch is in round-robin mode, all links
  2266. * must tx arp to ensure all links rx an arp - otherwise
  2267. * links may oscillate or not come up at all; if switch is
  2268. * in something like xor mode, there is nothing we can
  2269. * do - all replies will be rx'ed on same link causing slaves
  2270. * to be unstable during low/no traffic periods
  2271. */
  2272. if (IS_UP(slave->dev)) {
  2273. bond_arp_send_all(bond, slave);
  2274. }
  2275. }
  2276. if (do_failover) {
  2277. write_lock(&bond->curr_slave_lock);
  2278. bond_select_active_slave(bond);
  2279. write_unlock(&bond->curr_slave_lock);
  2280. }
  2281. re_arm:
  2282. if (bond->params.arp_interval) {
  2283. mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
  2284. }
  2285. out:
  2286. read_unlock(&bond->lock);
  2287. }
  2288. /*
  2289. * When using arp monitoring in active-backup mode, this function is
  2290. * called to determine if any backup slaves have went down or a new
  2291. * current slave needs to be found.
  2292. * The backup slaves never generate traffic, they are considered up by merely
  2293. * receiving traffic. If the current slave goes down, each backup slave will
  2294. * be given the opportunity to tx/rx an arp before being taken down - this
  2295. * prevents all slaves from being taken down due to the current slave not
  2296. * sending any traffic for the backups to receive. The arps are not necessarily
  2297. * necessary, any tx and rx traffic will keep the current slave up. While any
  2298. * rx traffic will keep the backup slaves up, the current slave is responsible
  2299. * for generating traffic to keep them up regardless of any other traffic they
  2300. * may have received.
  2301. * see loadbalance_arp_monitor for arp monitoring in load balancing mode
  2302. */
  2303. void bond_activebackup_arp_mon(struct net_device *bond_dev)
  2304. {
  2305. struct bonding *bond = bond_dev->priv;
  2306. struct slave *slave;
  2307. int delta_in_ticks;
  2308. int i;
  2309. read_lock(&bond->lock);
  2310. delta_in_ticks = (bond->params.arp_interval * HZ) / 1000;
  2311. if (bond->kill_timers) {
  2312. goto out;
  2313. }
  2314. if (bond->slave_cnt == 0) {
  2315. goto re_arm;
  2316. }
  2317. /* determine if any slave has come up or any backup slave has
  2318. * gone down
  2319. * TODO: what about up/down delay in arp mode? it wasn't here before
  2320. * so it can wait
  2321. */
  2322. bond_for_each_slave(bond, slave, i) {
  2323. if (slave->link != BOND_LINK_UP) {
  2324. if ((jiffies - slave_last_rx(bond, slave)) <=
  2325. delta_in_ticks) {
  2326. slave->link = BOND_LINK_UP;
  2327. write_lock(&bond->curr_slave_lock);
  2328. if ((!bond->curr_active_slave) &&
  2329. ((jiffies - slave->dev->trans_start) <= delta_in_ticks)) {
  2330. bond_change_active_slave(bond, slave);
  2331. bond->current_arp_slave = NULL;
  2332. } else if (bond->curr_active_slave != slave) {
  2333. /* this slave has just come up but we
  2334. * already have a current slave; this
  2335. * can also happen if bond_enslave adds
  2336. * a new slave that is up while we are
  2337. * searching for a new slave
  2338. */
  2339. bond_set_slave_inactive_flags(slave);
  2340. bond->current_arp_slave = NULL;
  2341. }
  2342. bond_set_carrier(bond);
  2343. if (slave == bond->curr_active_slave) {
  2344. printk(KERN_INFO DRV_NAME
  2345. ": %s: %s is up and now the "
  2346. "active interface\n",
  2347. bond_dev->name,
  2348. slave->dev->name);
  2349. netif_carrier_on(bond->dev);
  2350. } else {
  2351. printk(KERN_INFO DRV_NAME
  2352. ": %s: backup interface %s is "
  2353. "now up\n",
  2354. bond_dev->name,
  2355. slave->dev->name);
  2356. }
  2357. write_unlock(&bond->curr_slave_lock);
  2358. }
  2359. } else {
  2360. read_lock(&bond->curr_slave_lock);
  2361. if ((slave != bond->curr_active_slave) &&
  2362. (!bond->current_arp_slave) &&
  2363. (((jiffies - slave_last_rx(bond, slave)) >= 3*delta_in_ticks) &&
  2364. bond_has_ip(bond))) {
  2365. /* a backup slave has gone down; three times
  2366. * the delta allows the current slave to be
  2367. * taken out before the backup slave.
  2368. * note: a non-null current_arp_slave indicates
  2369. * the curr_active_slave went down and we are
  2370. * searching for a new one; under this
  2371. * condition we only take the curr_active_slave
  2372. * down - this gives each slave a chance to
  2373. * tx/rx traffic before being taken out
  2374. */
  2375. read_unlock(&bond->curr_slave_lock);
  2376. slave->link = BOND_LINK_DOWN;
  2377. if (slave->link_failure_count < UINT_MAX) {
  2378. slave->link_failure_count++;
  2379. }
  2380. bond_set_slave_inactive_flags(slave);
  2381. printk(KERN_INFO DRV_NAME
  2382. ": %s: backup interface %s is now down\n",
  2383. bond_dev->name,
  2384. slave->dev->name);
  2385. } else {
  2386. read_unlock(&bond->curr_slave_lock);
  2387. }
  2388. }
  2389. }
  2390. read_lock(&bond->curr_slave_lock);
  2391. slave = bond->curr_active_slave;
  2392. read_unlock(&bond->curr_slave_lock);
  2393. if (slave) {
  2394. /* if we have sent traffic in the past 2*arp_intervals but
  2395. * haven't xmit and rx traffic in that time interval, select
  2396. * a different slave. slave->jiffies is only updated when
  2397. * a slave first becomes the curr_active_slave - not necessarily
  2398. * after every arp; this ensures the slave has a full 2*delta
  2399. * before being taken out. if a primary is being used, check
  2400. * if it is up and needs to take over as the curr_active_slave
  2401. */
  2402. if ((((jiffies - slave->dev->trans_start) >= (2*delta_in_ticks)) ||
  2403. (((jiffies - slave_last_rx(bond, slave)) >= (2*delta_in_ticks)) &&
  2404. bond_has_ip(bond))) &&
  2405. ((jiffies - slave->jiffies) >= 2*delta_in_ticks)) {
  2406. slave->link = BOND_LINK_DOWN;
  2407. if (slave->link_failure_count < UINT_MAX) {
  2408. slave->link_failure_count++;
  2409. }
  2410. printk(KERN_INFO DRV_NAME
  2411. ": %s: link status down for active interface "
  2412. "%s, disabling it\n",
  2413. bond_dev->name,
  2414. slave->dev->name);
  2415. write_lock(&bond->curr_slave_lock);
  2416. bond_select_active_slave(bond);
  2417. slave = bond->curr_active_slave;
  2418. write_unlock(&bond->curr_slave_lock);
  2419. bond->current_arp_slave = slave;
  2420. if (slave) {
  2421. slave->jiffies = jiffies;
  2422. }
  2423. } else if ((bond->primary_slave) &&
  2424. (bond->primary_slave != slave) &&
  2425. (bond->primary_slave->link == BOND_LINK_UP)) {
  2426. /* at this point, slave is the curr_active_slave */
  2427. printk(KERN_INFO DRV_NAME
  2428. ": %s: changing from interface %s to primary "
  2429. "interface %s\n",
  2430. bond_dev->name,
  2431. slave->dev->name,
  2432. bond->primary_slave->dev->name);
  2433. /* primary is up so switch to it */
  2434. write_lock(&bond->curr_slave_lock);
  2435. bond_change_active_slave(bond, bond->primary_slave);
  2436. write_unlock(&bond->curr_slave_lock);
  2437. slave = bond->primary_slave;
  2438. slave->jiffies = jiffies;
  2439. } else {
  2440. bond->current_arp_slave = NULL;
  2441. }
  2442. /* the current slave must tx an arp to ensure backup slaves
  2443. * rx traffic
  2444. */
  2445. if (slave && bond_has_ip(bond)) {
  2446. bond_arp_send_all(bond, slave);
  2447. }
  2448. }
  2449. /* if we don't have a curr_active_slave, search for the next available
  2450. * backup slave from the current_arp_slave and make it the candidate
  2451. * for becoming the curr_active_slave
  2452. */
  2453. if (!slave) {
  2454. if (!bond->current_arp_slave) {
  2455. bond->current_arp_slave = bond->first_slave;
  2456. }
  2457. if (bond->current_arp_slave) {
  2458. bond_set_slave_inactive_flags(bond->current_arp_slave);
  2459. /* search for next candidate */
  2460. bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) {
  2461. if (IS_UP(slave->dev)) {
  2462. slave->link = BOND_LINK_BACK;
  2463. bond_set_slave_active_flags(slave);
  2464. bond_arp_send_all(bond, slave);
  2465. slave->jiffies = jiffies;
  2466. bond->current_arp_slave = slave;
  2467. break;
  2468. }
  2469. /* if the link state is up at this point, we
  2470. * mark it down - this can happen if we have
  2471. * simultaneous link failures and
  2472. * reselect_active_interface doesn't make this
  2473. * one the current slave so it is still marked
  2474. * up when it is actually down
  2475. */
  2476. if (slave->link == BOND_LINK_UP) {
  2477. slave->link = BOND_LINK_DOWN;
  2478. if (slave->link_failure_count < UINT_MAX) {
  2479. slave->link_failure_count++;
  2480. }
  2481. bond_set_slave_inactive_flags(slave);
  2482. printk(KERN_INFO DRV_NAME
  2483. ": %s: backup interface %s is "
  2484. "now down.\n",
  2485. bond_dev->name,
  2486. slave->dev->name);
  2487. }
  2488. }
  2489. }
  2490. }
  2491. re_arm:
  2492. if (bond->params.arp_interval) {
  2493. mod_timer(&bond->arp_timer, jiffies + delta_in_ticks);
  2494. }
  2495. out:
  2496. read_unlock(&bond->lock);
  2497. }
  2498. /*------------------------------ proc/seq_file-------------------------------*/
  2499. #ifdef CONFIG_PROC_FS
  2500. #define SEQ_START_TOKEN ((void *)1)
  2501. static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
  2502. {
  2503. struct bonding *bond = seq->private;
  2504. loff_t off = 0;
  2505. struct slave *slave;
  2506. int i;
  2507. /* make sure the bond won't be taken away */
  2508. read_lock(&dev_base_lock);
  2509. read_lock_bh(&bond->lock);
  2510. if (*pos == 0) {
  2511. return SEQ_START_TOKEN;
  2512. }
  2513. bond_for_each_slave(bond, slave, i) {
  2514. if (++off == *pos) {
  2515. return slave;
  2516. }
  2517. }
  2518. return NULL;
  2519. }
  2520. static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2521. {
  2522. struct bonding *bond = seq->private;
  2523. struct slave *slave = v;
  2524. ++*pos;
  2525. if (v == SEQ_START_TOKEN) {
  2526. return bond->first_slave;
  2527. }
  2528. slave = slave->next;
  2529. return (slave == bond->first_slave) ? NULL : slave;
  2530. }
  2531. static void bond_info_seq_stop(struct seq_file *seq, void *v)
  2532. {
  2533. struct bonding *bond = seq->private;
  2534. read_unlock_bh(&bond->lock);
  2535. read_unlock(&dev_base_lock);
  2536. }
  2537. static void bond_info_show_master(struct seq_file *seq)
  2538. {
  2539. struct bonding *bond = seq->private;
  2540. struct slave *curr;
  2541. int i;
  2542. u32 target;
  2543. read_lock(&bond->curr_slave_lock);
  2544. curr = bond->curr_active_slave;
  2545. read_unlock(&bond->curr_slave_lock);
  2546. seq_printf(seq, "Bonding Mode: %s\n",
  2547. bond_mode_name(bond->params.mode));
  2548. if (bond->params.mode == BOND_MODE_XOR ||
  2549. bond->params.mode == BOND_MODE_8023AD) {
  2550. seq_printf(seq, "Transmit Hash Policy: %s (%d)\n",
  2551. xmit_hashtype_tbl[bond->params.xmit_policy].modename,
  2552. bond->params.xmit_policy);
  2553. }
  2554. if (USES_PRIMARY(bond->params.mode)) {
  2555. seq_printf(seq, "Primary Slave: %s\n",
  2556. (bond->primary_slave) ?
  2557. bond->primary_slave->dev->name : "None");
  2558. seq_printf(seq, "Currently Active Slave: %s\n",
  2559. (curr) ? curr->dev->name : "None");
  2560. }
  2561. seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
  2562. "up" : "down");
  2563. seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon);
  2564. seq_printf(seq, "Up Delay (ms): %d\n",
  2565. bond->params.updelay * bond->params.miimon);
  2566. seq_printf(seq, "Down Delay (ms): %d\n",
  2567. bond->params.downdelay * bond->params.miimon);
  2568. /* ARP information */
  2569. if(bond->params.arp_interval > 0) {
  2570. int printed=0;
  2571. seq_printf(seq, "ARP Polling Interval (ms): %d\n",
  2572. bond->params.arp_interval);
  2573. seq_printf(seq, "ARP IP target/s (n.n.n.n form):");
  2574. for(i = 0; (i < BOND_MAX_ARP_TARGETS) ;i++) {
  2575. if (!bond->params.arp_targets[i])
  2576. continue;
  2577. if (printed)
  2578. seq_printf(seq, ",");
  2579. target = ntohl(bond->params.arp_targets[i]);
  2580. seq_printf(seq, " %d.%d.%d.%d", HIPQUAD(target));
  2581. printed = 1;
  2582. }
  2583. seq_printf(seq, "\n");
  2584. }
  2585. if (bond->params.mode == BOND_MODE_8023AD) {
  2586. struct ad_info ad_info;
  2587. seq_puts(seq, "\n802.3ad info\n");
  2588. seq_printf(seq, "LACP rate: %s\n",
  2589. (bond->params.lacp_fast) ? "fast" : "slow");
  2590. if (bond_3ad_get_active_agg_info(bond, &ad_info)) {
  2591. seq_printf(seq, "bond %s has no active aggregator\n",
  2592. bond->dev->name);
  2593. } else {
  2594. seq_printf(seq, "Active Aggregator Info:\n");
  2595. seq_printf(seq, "\tAggregator ID: %d\n",
  2596. ad_info.aggregator_id);
  2597. seq_printf(seq, "\tNumber of ports: %d\n",
  2598. ad_info.ports);
  2599. seq_printf(seq, "\tActor Key: %d\n",
  2600. ad_info.actor_key);
  2601. seq_printf(seq, "\tPartner Key: %d\n",
  2602. ad_info.partner_key);
  2603. seq_printf(seq, "\tPartner Mac Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
  2604. ad_info.partner_system[0],
  2605. ad_info.partner_system[1],
  2606. ad_info.partner_system[2],
  2607. ad_info.partner_system[3],
  2608. ad_info.partner_system[4],
  2609. ad_info.partner_system[5]);
  2610. }
  2611. }
  2612. }
  2613. static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave)
  2614. {
  2615. struct bonding *bond = seq->private;
  2616. seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
  2617. seq_printf(seq, "MII Status: %s\n",
  2618. (slave->link == BOND_LINK_UP) ? "up" : "down");
  2619. seq_printf(seq, "Link Failure Count: %u\n",
  2620. slave->link_failure_count);
  2621. seq_printf(seq,
  2622. "Permanent HW addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
  2623. slave->perm_hwaddr[0], slave->perm_hwaddr[1],
  2624. slave->perm_hwaddr[2], slave->perm_hwaddr[3],
  2625. slave->perm_hwaddr[4], slave->perm_hwaddr[5]);
  2626. if (bond->params.mode == BOND_MODE_8023AD) {
  2627. const struct aggregator *agg
  2628. = SLAVE_AD_INFO(slave).port.aggregator;
  2629. if (agg) {
  2630. seq_printf(seq, "Aggregator ID: %d\n",
  2631. agg->aggregator_identifier);
  2632. } else {
  2633. seq_puts(seq, "Aggregator ID: N/A\n");
  2634. }
  2635. }
  2636. }
  2637. static int bond_info_seq_show(struct seq_file *seq, void *v)
  2638. {
  2639. if (v == SEQ_START_TOKEN) {
  2640. seq_printf(seq, "%s\n", version);
  2641. bond_info_show_master(seq);
  2642. } else {
  2643. bond_info_show_slave(seq, v);
  2644. }
  2645. return 0;
  2646. }
  2647. static struct seq_operations bond_info_seq_ops = {
  2648. .start = bond_info_seq_start,
  2649. .next = bond_info_seq_next,
  2650. .stop = bond_info_seq_stop,
  2651. .show = bond_info_seq_show,
  2652. };
  2653. static int bond_info_open(struct inode *inode, struct file *file)
  2654. {
  2655. struct seq_file *seq;
  2656. struct proc_dir_entry *proc;
  2657. int res;
  2658. res = seq_open(file, &bond_info_seq_ops);
  2659. if (!res) {
  2660. /* recover the pointer buried in proc_dir_entry data */
  2661. seq = file->private_data;
  2662. proc = PDE(inode);
  2663. seq->private = proc->data;
  2664. }
  2665. return res;
  2666. }
  2667. static const struct file_operations bond_info_fops = {
  2668. .owner = THIS_MODULE,
  2669. .open = bond_info_open,
  2670. .read = seq_read,
  2671. .llseek = seq_lseek,
  2672. .release = seq_release,
  2673. };
  2674. static int bond_create_proc_entry(struct bonding *bond)
  2675. {
  2676. struct net_device *bond_dev = bond->dev;
  2677. if (bond_proc_dir) {
  2678. bond->proc_entry = create_proc_entry(bond_dev->name,
  2679. S_IRUGO,
  2680. bond_proc_dir);
  2681. if (bond->proc_entry == NULL) {
  2682. printk(KERN_WARNING DRV_NAME
  2683. ": Warning: Cannot create /proc/net/%s/%s\n",
  2684. DRV_NAME, bond_dev->name);
  2685. } else {
  2686. bond->proc_entry->data = bond;
  2687. bond->proc_entry->proc_fops = &bond_info_fops;
  2688. bond->proc_entry->owner = THIS_MODULE;
  2689. memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
  2690. }
  2691. }
  2692. return 0;
  2693. }
  2694. static void bond_remove_proc_entry(struct bonding *bond)
  2695. {
  2696. if (bond_proc_dir && bond->proc_entry) {
  2697. remove_proc_entry(bond->proc_file_name, bond_proc_dir);
  2698. memset(bond->proc_file_name, 0, IFNAMSIZ);
  2699. bond->proc_entry = NULL;
  2700. }
  2701. }
  2702. /* Create the bonding directory under /proc/net, if doesn't exist yet.
  2703. * Caller must hold rtnl_lock.
  2704. */
  2705. static void bond_create_proc_dir(void)
  2706. {
  2707. int len = strlen(DRV_NAME);
  2708. for (bond_proc_dir = proc_net->subdir; bond_proc_dir;
  2709. bond_proc_dir = bond_proc_dir->next) {
  2710. if ((bond_proc_dir->namelen == len) &&
  2711. !memcmp(bond_proc_dir->name, DRV_NAME, len)) {
  2712. break;
  2713. }
  2714. }
  2715. if (!bond_proc_dir) {
  2716. bond_proc_dir = proc_mkdir(DRV_NAME, proc_net);
  2717. if (bond_proc_dir) {
  2718. bond_proc_dir->owner = THIS_MODULE;
  2719. } else {
  2720. printk(KERN_WARNING DRV_NAME
  2721. ": Warning: cannot create /proc/net/%s\n",
  2722. DRV_NAME);
  2723. }
  2724. }
  2725. }
  2726. /* Destroy the bonding directory under /proc/net, if empty.
  2727. * Caller must hold rtnl_lock.
  2728. */
  2729. static void bond_destroy_proc_dir(void)
  2730. {
  2731. struct proc_dir_entry *de;
  2732. if (!bond_proc_dir) {
  2733. return;
  2734. }
  2735. /* verify that the /proc dir is empty */
  2736. for (de = bond_proc_dir->subdir; de; de = de->next) {
  2737. /* ignore . and .. */
  2738. if (*(de->name) != '.') {
  2739. break;
  2740. }
  2741. }
  2742. if (de) {
  2743. if (bond_proc_dir->owner == THIS_MODULE) {
  2744. bond_proc_dir->owner = NULL;
  2745. }
  2746. } else {
  2747. remove_proc_entry(DRV_NAME, proc_net);
  2748. bond_proc_dir = NULL;
  2749. }
  2750. }
  2751. #endif /* CONFIG_PROC_FS */
  2752. /*-------------------------- netdev event handling --------------------------*/
  2753. /*
  2754. * Change device name
  2755. */
  2756. static int bond_event_changename(struct bonding *bond)
  2757. {
  2758. #ifdef CONFIG_PROC_FS
  2759. bond_remove_proc_entry(bond);
  2760. bond_create_proc_entry(bond);
  2761. #endif
  2762. down_write(&(bonding_rwsem));
  2763. bond_destroy_sysfs_entry(bond);
  2764. bond_create_sysfs_entry(bond);
  2765. up_write(&(bonding_rwsem));
  2766. return NOTIFY_DONE;
  2767. }
  2768. static int bond_master_netdev_event(unsigned long event, struct net_device *bond_dev)
  2769. {
  2770. struct bonding *event_bond = bond_dev->priv;
  2771. switch (event) {
  2772. case NETDEV_CHANGENAME:
  2773. return bond_event_changename(event_bond);
  2774. case NETDEV_UNREGISTER:
  2775. /*
  2776. * TODO: remove a bond from the list?
  2777. */
  2778. break;
  2779. default:
  2780. break;
  2781. }
  2782. return NOTIFY_DONE;
  2783. }
  2784. static int bond_slave_netdev_event(unsigned long event, struct net_device *slave_dev)
  2785. {
  2786. struct net_device *bond_dev = slave_dev->master;
  2787. struct bonding *bond = bond_dev->priv;
  2788. switch (event) {
  2789. case NETDEV_UNREGISTER:
  2790. if (bond_dev) {
  2791. bond_release(bond_dev, slave_dev);
  2792. }
  2793. break;
  2794. case NETDEV_CHANGE:
  2795. /*
  2796. * TODO: is this what we get if somebody
  2797. * sets up a hierarchical bond, then rmmod's
  2798. * one of the slave bonding devices?
  2799. */
  2800. break;
  2801. case NETDEV_DOWN:
  2802. /*
  2803. * ... Or is it this?
  2804. */
  2805. break;
  2806. case NETDEV_CHANGEMTU:
  2807. /*
  2808. * TODO: Should slaves be allowed to
  2809. * independently alter their MTU? For
  2810. * an active-backup bond, slaves need
  2811. * not be the same type of device, so
  2812. * MTUs may vary. For other modes,
  2813. * slaves arguably should have the
  2814. * same MTUs. To do this, we'd need to
  2815. * take over the slave's change_mtu
  2816. * function for the duration of their
  2817. * servitude.
  2818. */
  2819. break;
  2820. case NETDEV_CHANGENAME:
  2821. /*
  2822. * TODO: handle changing the primary's name
  2823. */
  2824. break;
  2825. case NETDEV_FEAT_CHANGE:
  2826. bond_compute_features(bond);
  2827. break;
  2828. default:
  2829. break;
  2830. }
  2831. return NOTIFY_DONE;
  2832. }
  2833. /*
  2834. * bond_netdev_event: handle netdev notifier chain events.
  2835. *
  2836. * This function receives events for the netdev chain. The caller (an
  2837. * ioctl handler calling blocking_notifier_call_chain) holds the necessary
  2838. * locks for us to safely manipulate the slave devices (RTNL lock,
  2839. * dev_probe_lock).
  2840. */
  2841. static int bond_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
  2842. {
  2843. struct net_device *event_dev = (struct net_device *)ptr;
  2844. dprintk("event_dev: %s, event: %lx\n",
  2845. (event_dev ? event_dev->name : "None"),
  2846. event);
  2847. if (!(event_dev->priv_flags & IFF_BONDING))
  2848. return NOTIFY_DONE;
  2849. if (event_dev->flags & IFF_MASTER) {
  2850. dprintk("IFF_MASTER\n");
  2851. return bond_master_netdev_event(event, event_dev);
  2852. }
  2853. if (event_dev->flags & IFF_SLAVE) {
  2854. dprintk("IFF_SLAVE\n");
  2855. return bond_slave_netdev_event(event, event_dev);
  2856. }
  2857. return NOTIFY_DONE;
  2858. }
  2859. /*
  2860. * bond_inetaddr_event: handle inetaddr notifier chain events.
  2861. *
  2862. * We keep track of device IPs primarily to use as source addresses in
  2863. * ARP monitor probes (rather than spewing out broadcasts all the time).
  2864. *
  2865. * We track one IP for the main device (if it has one), plus one per VLAN.
  2866. */
  2867. static int bond_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
  2868. {
  2869. struct in_ifaddr *ifa = ptr;
  2870. struct net_device *vlan_dev, *event_dev = ifa->ifa_dev->dev;
  2871. struct bonding *bond, *bond_next;
  2872. struct vlan_entry *vlan, *vlan_next;
  2873. list_for_each_entry_safe(bond, bond_next, &bond_dev_list, bond_list) {
  2874. if (bond->dev == event_dev) {
  2875. switch (event) {
  2876. case NETDEV_UP:
  2877. bond->master_ip = ifa->ifa_local;
  2878. return NOTIFY_OK;
  2879. case NETDEV_DOWN:
  2880. bond->master_ip = bond_glean_dev_ip(bond->dev);
  2881. return NOTIFY_OK;
  2882. default:
  2883. return NOTIFY_DONE;
  2884. }
  2885. }
  2886. if (list_empty(&bond->vlan_list))
  2887. continue;
  2888. list_for_each_entry_safe(vlan, vlan_next, &bond->vlan_list,
  2889. vlan_list) {
  2890. vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id);
  2891. if (vlan_dev == event_dev) {
  2892. switch (event) {
  2893. case NETDEV_UP:
  2894. vlan->vlan_ip = ifa->ifa_local;
  2895. return NOTIFY_OK;
  2896. case NETDEV_DOWN:
  2897. vlan->vlan_ip =
  2898. bond_glean_dev_ip(vlan_dev);
  2899. return NOTIFY_OK;
  2900. default:
  2901. return NOTIFY_DONE;
  2902. }
  2903. }
  2904. }
  2905. }
  2906. return NOTIFY_DONE;
  2907. }
  2908. static struct notifier_block bond_netdev_notifier = {
  2909. .notifier_call = bond_netdev_event,
  2910. };
  2911. static struct notifier_block bond_inetaddr_notifier = {
  2912. .notifier_call = bond_inetaddr_event,
  2913. };
  2914. /*-------------------------- Packet type handling ---------------------------*/
  2915. /* register to receive lacpdus on a bond */
  2916. static void bond_register_lacpdu(struct bonding *bond)
  2917. {
  2918. struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);
  2919. /* initialize packet type */
  2920. pk_type->type = PKT_TYPE_LACPDU;
  2921. pk_type->dev = bond->dev;
  2922. pk_type->func = bond_3ad_lacpdu_recv;
  2923. dev_add_pack(pk_type);
  2924. }
  2925. /* unregister to receive lacpdus on a bond */
  2926. static void bond_unregister_lacpdu(struct bonding *bond)
  2927. {
  2928. dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
  2929. }
  2930. void bond_register_arp(struct bonding *bond)
  2931. {
  2932. struct packet_type *pt = &bond->arp_mon_pt;
  2933. if (pt->type)
  2934. return;
  2935. pt->type = htons(ETH_P_ARP);
  2936. pt->dev = bond->dev;
  2937. pt->func = bond_arp_rcv;
  2938. dev_add_pack(pt);
  2939. }
  2940. void bond_unregister_arp(struct bonding *bond)
  2941. {
  2942. struct packet_type *pt = &bond->arp_mon_pt;
  2943. dev_remove_pack(pt);
  2944. pt->type = 0;
  2945. }
  2946. /*---------------------------- Hashing Policies -----------------------------*/
  2947. /*
  2948. * Hash for the output device based upon layer 3 and layer 4 data. If
  2949. * the packet is a frag or not TCP or UDP, just use layer 3 data. If it is
  2950. * altogether not IP, mimic bond_xmit_hash_policy_l2()
  2951. */
  2952. static int bond_xmit_hash_policy_l34(struct sk_buff *skb,
  2953. struct net_device *bond_dev, int count)
  2954. {
  2955. struct ethhdr *data = (struct ethhdr *)skb->data;
  2956. struct iphdr *iph = ip_hdr(skb);
  2957. u16 *layer4hdr = (u16 *)((u32 *)iph + iph->ihl);
  2958. int layer4_xor = 0;
  2959. if (skb->protocol == __constant_htons(ETH_P_IP)) {
  2960. if (!(iph->frag_off & __constant_htons(IP_MF|IP_OFFSET)) &&
  2961. (iph->protocol == IPPROTO_TCP ||
  2962. iph->protocol == IPPROTO_UDP)) {
  2963. layer4_xor = htons((*layer4hdr ^ *(layer4hdr + 1)));
  2964. }
  2965. return (layer4_xor ^
  2966. ((ntohl(iph->saddr ^ iph->daddr)) & 0xffff)) % count;
  2967. }
  2968. return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count;
  2969. }
  2970. /*
  2971. * Hash for the output device based upon layer 2 data
  2972. */
  2973. static int bond_xmit_hash_policy_l2(struct sk_buff *skb,
  2974. struct net_device *bond_dev, int count)
  2975. {
  2976. struct ethhdr *data = (struct ethhdr *)skb->data;
  2977. return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count;
  2978. }
  2979. /*-------------------------- Device entry points ----------------------------*/
  2980. static int bond_open(struct net_device *bond_dev)
  2981. {
  2982. struct bonding *bond = bond_dev->priv;
  2983. struct timer_list *mii_timer = &bond->mii_timer;
  2984. struct timer_list *arp_timer = &bond->arp_timer;
  2985. bond->kill_timers = 0;
  2986. if ((bond->params.mode == BOND_MODE_TLB) ||
  2987. (bond->params.mode == BOND_MODE_ALB)) {
  2988. struct timer_list *alb_timer = &(BOND_ALB_INFO(bond).alb_timer);
  2989. /* bond_alb_initialize must be called before the timer
  2990. * is started.
  2991. */
  2992. if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) {
  2993. /* something went wrong - fail the open operation */
  2994. return -1;
  2995. }
  2996. init_timer(alb_timer);
  2997. alb_timer->expires = jiffies + 1;
  2998. alb_timer->data = (unsigned long)bond;
  2999. alb_timer->function = (void *)&bond_alb_monitor;
  3000. add_timer(alb_timer);
  3001. }
  3002. if (bond->params.miimon) { /* link check interval, in milliseconds. */
  3003. init_timer(mii_timer);
  3004. mii_timer->expires = jiffies + 1;
  3005. mii_timer->data = (unsigned long)bond_dev;
  3006. mii_timer->function = (void *)&bond_mii_monitor;
  3007. add_timer(mii_timer);
  3008. }
  3009. if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
  3010. init_timer(arp_timer);
  3011. arp_timer->expires = jiffies + 1;
  3012. arp_timer->data = (unsigned long)bond_dev;
  3013. if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) {
  3014. arp_timer->function = (void *)&bond_activebackup_arp_mon;
  3015. } else {
  3016. arp_timer->function = (void *)&bond_loadbalance_arp_mon;
  3017. }
  3018. if (bond->params.arp_validate)
  3019. bond_register_arp(bond);
  3020. add_timer(arp_timer);
  3021. }
  3022. if (bond->params.mode == BOND_MODE_8023AD) {
  3023. struct timer_list *ad_timer = &(BOND_AD_INFO(bond).ad_timer);
  3024. init_timer(ad_timer);
  3025. ad_timer->expires = jiffies + 1;
  3026. ad_timer->data = (unsigned long)bond;
  3027. ad_timer->function = (void *)&bond_3ad_state_machine_handler;
  3028. add_timer(ad_timer);
  3029. /* register to receive LACPDUs */
  3030. bond_register_lacpdu(bond);
  3031. }
  3032. return 0;
  3033. }
  3034. static int bond_close(struct net_device *bond_dev)
  3035. {
  3036. struct bonding *bond = bond_dev->priv;
  3037. if (bond->params.mode == BOND_MODE_8023AD) {
  3038. /* Unregister the receive of LACPDUs */
  3039. bond_unregister_lacpdu(bond);
  3040. }
  3041. if (bond->params.arp_validate)
  3042. bond_unregister_arp(bond);
  3043. write_lock_bh(&bond->lock);
  3044. /* signal timers not to re-arm */
  3045. bond->kill_timers = 1;
  3046. write_unlock_bh(&bond->lock);
  3047. /* del_timer_sync must run without holding the bond->lock
  3048. * because a running timer might be trying to hold it too
  3049. */
  3050. if (bond->params.miimon) { /* link check interval, in milliseconds. */
  3051. del_timer_sync(&bond->mii_timer);
  3052. }
  3053. if (bond->params.arp_interval) { /* arp interval, in milliseconds. */
  3054. del_timer_sync(&bond->arp_timer);
  3055. }
  3056. switch (bond->params.mode) {
  3057. case BOND_MODE_8023AD:
  3058. del_timer_sync(&(BOND_AD_INFO(bond).ad_timer));
  3059. break;
  3060. case BOND_MODE_TLB:
  3061. case BOND_MODE_ALB:
  3062. del_timer_sync(&(BOND_ALB_INFO(bond).alb_timer));
  3063. break;
  3064. default:
  3065. break;
  3066. }
  3067. if ((bond->params.mode == BOND_MODE_TLB) ||
  3068. (bond->params.mode == BOND_MODE_ALB)) {
  3069. /* Must be called only after all
  3070. * slaves have been released
  3071. */
  3072. bond_alb_deinitialize(bond);
  3073. }
  3074. return 0;
  3075. }
  3076. static struct net_device_stats *bond_get_stats(struct net_device *bond_dev)
  3077. {
  3078. struct bonding *bond = bond_dev->priv;
  3079. struct net_device_stats *stats = &(bond->stats), *sstats;
  3080. struct slave *slave;
  3081. int i;
  3082. memset(stats, 0, sizeof(struct net_device_stats));
  3083. read_lock_bh(&bond->lock);
  3084. bond_for_each_slave(bond, slave, i) {
  3085. sstats = slave->dev->get_stats(slave->dev);
  3086. stats->rx_packets += sstats->rx_packets;
  3087. stats->rx_bytes += sstats->rx_bytes;
  3088. stats->rx_errors += sstats->rx_errors;
  3089. stats->rx_dropped += sstats->rx_dropped;
  3090. stats->tx_packets += sstats->tx_packets;
  3091. stats->tx_bytes += sstats->tx_bytes;
  3092. stats->tx_errors += sstats->tx_errors;
  3093. stats->tx_dropped += sstats->tx_dropped;
  3094. stats->multicast += sstats->multicast;
  3095. stats->collisions += sstats->collisions;
  3096. stats->rx_length_errors += sstats->rx_length_errors;
  3097. stats->rx_over_errors += sstats->rx_over_errors;
  3098. stats->rx_crc_errors += sstats->rx_crc_errors;
  3099. stats->rx_frame_errors += sstats->rx_frame_errors;
  3100. stats->rx_fifo_errors += sstats->rx_fifo_errors;
  3101. stats->rx_missed_errors += sstats->rx_missed_errors;
  3102. stats->tx_aborted_errors += sstats->tx_aborted_errors;
  3103. stats->tx_carrier_errors += sstats->tx_carrier_errors;
  3104. stats->tx_fifo_errors += sstats->tx_fifo_errors;
  3105. stats->tx_heartbeat_errors += sstats->tx_heartbeat_errors;
  3106. stats->tx_window_errors += sstats->tx_window_errors;
  3107. }
  3108. read_unlock_bh(&bond->lock);
  3109. return stats;
  3110. }
  3111. static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd)
  3112. {
  3113. struct net_device *slave_dev = NULL;
  3114. struct ifbond k_binfo;
  3115. struct ifbond __user *u_binfo = NULL;
  3116. struct ifslave k_sinfo;
  3117. struct ifslave __user *u_sinfo = NULL;
  3118. struct mii_ioctl_data *mii = NULL;
  3119. int res = 0;
  3120. dprintk("bond_ioctl: master=%s, cmd=%d\n",
  3121. bond_dev->name, cmd);
  3122. switch (cmd) {
  3123. case SIOCGMIIPHY:
  3124. mii = if_mii(ifr);
  3125. if (!mii) {
  3126. return -EINVAL;
  3127. }
  3128. mii->phy_id = 0;
  3129. /* Fall Through */
  3130. case SIOCGMIIREG:
  3131. /*
  3132. * We do this again just in case we were called by SIOCGMIIREG
  3133. * instead of SIOCGMIIPHY.
  3134. */
  3135. mii = if_mii(ifr);
  3136. if (!mii) {
  3137. return -EINVAL;
  3138. }
  3139. if (mii->reg_num == 1) {
  3140. struct bonding *bond = bond_dev->priv;
  3141. mii->val_out = 0;
  3142. read_lock_bh(&bond->lock);
  3143. read_lock(&bond->curr_slave_lock);
  3144. if (netif_carrier_ok(bond->dev)) {
  3145. mii->val_out = BMSR_LSTATUS;
  3146. }
  3147. read_unlock(&bond->curr_slave_lock);
  3148. read_unlock_bh(&bond->lock);
  3149. }
  3150. return 0;
  3151. case BOND_INFO_QUERY_OLD:
  3152. case SIOCBONDINFOQUERY:
  3153. u_binfo = (struct ifbond __user *)ifr->ifr_data;
  3154. if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) {
  3155. return -EFAULT;
  3156. }
  3157. res = bond_info_query(bond_dev, &k_binfo);
  3158. if (res == 0) {
  3159. if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) {
  3160. return -EFAULT;
  3161. }
  3162. }
  3163. return res;
  3164. case BOND_SLAVE_INFO_QUERY_OLD:
  3165. case SIOCBONDSLAVEINFOQUERY:
  3166. u_sinfo = (struct ifslave __user *)ifr->ifr_data;
  3167. if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) {
  3168. return -EFAULT;
  3169. }
  3170. res = bond_slave_info_query(bond_dev, &k_sinfo);
  3171. if (res == 0) {
  3172. if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) {
  3173. return -EFAULT;
  3174. }
  3175. }
  3176. return res;
  3177. default:
  3178. /* Go on */
  3179. break;
  3180. }
  3181. if (!capable(CAP_NET_ADMIN)) {
  3182. return -EPERM;
  3183. }
  3184. down_write(&(bonding_rwsem));
  3185. slave_dev = dev_get_by_name(ifr->ifr_slave);
  3186. dprintk("slave_dev=%p: \n", slave_dev);
  3187. if (!slave_dev) {
  3188. res = -ENODEV;
  3189. } else {
  3190. dprintk("slave_dev->name=%s: \n", slave_dev->name);
  3191. switch (cmd) {
  3192. case BOND_ENSLAVE_OLD:
  3193. case SIOCBONDENSLAVE:
  3194. res = bond_enslave(bond_dev, slave_dev);
  3195. break;
  3196. case BOND_RELEASE_OLD:
  3197. case SIOCBONDRELEASE:
  3198. res = bond_release(bond_dev, slave_dev);
  3199. break;
  3200. case BOND_SETHWADDR_OLD:
  3201. case SIOCBONDSETHWADDR:
  3202. res = bond_sethwaddr(bond_dev, slave_dev);
  3203. break;
  3204. case BOND_CHANGE_ACTIVE_OLD:
  3205. case SIOCBONDCHANGEACTIVE:
  3206. res = bond_ioctl_change_active(bond_dev, slave_dev);
  3207. break;
  3208. default:
  3209. res = -EOPNOTSUPP;
  3210. }
  3211. dev_put(slave_dev);
  3212. }
  3213. up_write(&(bonding_rwsem));
  3214. return res;
  3215. }
  3216. static void bond_set_multicast_list(struct net_device *bond_dev)
  3217. {
  3218. struct bonding *bond = bond_dev->priv;
  3219. struct dev_mc_list *dmi;
  3220. write_lock_bh(&bond->lock);
  3221. /*
  3222. * Do promisc before checking multicast_mode
  3223. */
  3224. if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC)) {
  3225. bond_set_promiscuity(bond, 1);
  3226. }
  3227. if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC)) {
  3228. bond_set_promiscuity(bond, -1);
  3229. }
  3230. /* set allmulti flag to slaves */
  3231. if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI)) {
  3232. bond_set_allmulti(bond, 1);
  3233. }
  3234. if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI)) {
  3235. bond_set_allmulti(bond, -1);
  3236. }
  3237. bond->flags = bond_dev->flags;
  3238. /* looking for addresses to add to slaves' mc list */
  3239. for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) {
  3240. if (!bond_mc_list_find_dmi(dmi, bond->mc_list)) {
  3241. bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen);
  3242. }
  3243. }
  3244. /* looking for addresses to delete from slaves' list */
  3245. for (dmi = bond->mc_list; dmi; dmi = dmi->next) {
  3246. if (!bond_mc_list_find_dmi(dmi, bond_dev->mc_list)) {
  3247. bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen);
  3248. }
  3249. }
  3250. /* save master's multicast list */
  3251. bond_mc_list_destroy(bond);
  3252. bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC);
  3253. write_unlock_bh(&bond->lock);
  3254. }
  3255. /*
  3256. * Change the MTU of all of a master's slaves to match the master
  3257. */
  3258. static int bond_change_mtu(struct net_device *bond_dev, int new_mtu)
  3259. {
  3260. struct bonding *bond = bond_dev->priv;
  3261. struct slave *slave, *stop_at;
  3262. int res = 0;
  3263. int i;
  3264. dprintk("bond=%p, name=%s, new_mtu=%d\n", bond,
  3265. (bond_dev ? bond_dev->name : "None"), new_mtu);
  3266. /* Can't hold bond->lock with bh disabled here since
  3267. * some base drivers panic. On the other hand we can't
  3268. * hold bond->lock without bh disabled because we'll
  3269. * deadlock. The only solution is to rely on the fact
  3270. * that we're under rtnl_lock here, and the slaves
  3271. * list won't change. This doesn't solve the problem
  3272. * of setting the slave's MTU while it is
  3273. * transmitting, but the assumption is that the base
  3274. * driver can handle that.
  3275. *
  3276. * TODO: figure out a way to safely iterate the slaves
  3277. * list, but without holding a lock around the actual
  3278. * call to the base driver.
  3279. */
  3280. bond_for_each_slave(bond, slave, i) {
  3281. dprintk("s %p s->p %p c_m %p\n", slave,
  3282. slave->prev, slave->dev->change_mtu);
  3283. res = dev_set_mtu(slave->dev, new_mtu);
  3284. if (res) {
  3285. /* If we failed to set the slave's mtu to the new value
  3286. * we must abort the operation even in ACTIVE_BACKUP
  3287. * mode, because if we allow the backup slaves to have
  3288. * different mtu values than the active slave we'll
  3289. * need to change their mtu when doing a failover. That
  3290. * means changing their mtu from timer context, which
  3291. * is probably not a good idea.
  3292. */
  3293. dprintk("err %d %s\n", res, slave->dev->name);
  3294. goto unwind;
  3295. }
  3296. }
  3297. bond_dev->mtu = new_mtu;
  3298. return 0;
  3299. unwind:
  3300. /* unwind from head to the slave that failed */
  3301. stop_at = slave;
  3302. bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
  3303. int tmp_res;
  3304. tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu);
  3305. if (tmp_res) {
  3306. dprintk("unwind err %d dev %s\n", tmp_res,
  3307. slave->dev->name);
  3308. }
  3309. }
  3310. return res;
  3311. }
  3312. /*
  3313. * Change HW address
  3314. *
  3315. * Note that many devices must be down to change the HW address, and
  3316. * downing the master releases all slaves. We can make bonds full of
  3317. * bonding devices to test this, however.
  3318. */
  3319. static int bond_set_mac_address(struct net_device *bond_dev, void *addr)
  3320. {
  3321. struct bonding *bond = bond_dev->priv;
  3322. struct sockaddr *sa = addr, tmp_sa;
  3323. struct slave *slave, *stop_at;
  3324. int res = 0;
  3325. int i;
  3326. dprintk("bond=%p, name=%s\n", bond, (bond_dev ? bond_dev->name : "None"));
  3327. if (!is_valid_ether_addr(sa->sa_data)) {
  3328. return -EADDRNOTAVAIL;
  3329. }
  3330. /* Can't hold bond->lock with bh disabled here since
  3331. * some base drivers panic. On the other hand we can't
  3332. * hold bond->lock without bh disabled because we'll
  3333. * deadlock. The only solution is to rely on the fact
  3334. * that we're under rtnl_lock here, and the slaves
  3335. * list won't change. This doesn't solve the problem
  3336. * of setting the slave's hw address while it is
  3337. * transmitting, but the assumption is that the base
  3338. * driver can handle that.
  3339. *
  3340. * TODO: figure out a way to safely iterate the slaves
  3341. * list, but without holding a lock around the actual
  3342. * call to the base driver.
  3343. */
  3344. bond_for_each_slave(bond, slave, i) {
  3345. dprintk("slave %p %s\n", slave, slave->dev->name);
  3346. if (slave->dev->set_mac_address == NULL) {
  3347. res = -EOPNOTSUPP;
  3348. dprintk("EOPNOTSUPP %s\n", slave->dev->name);
  3349. goto unwind;
  3350. }
  3351. res = dev_set_mac_address(slave->dev, addr);
  3352. if (res) {
  3353. /* TODO: consider downing the slave
  3354. * and retry ?
  3355. * User should expect communications
  3356. * breakage anyway until ARP finish
  3357. * updating, so...
  3358. */
  3359. dprintk("err %d %s\n", res, slave->dev->name);
  3360. goto unwind;
  3361. }
  3362. }
  3363. /* success */
  3364. memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len);
  3365. return 0;
  3366. unwind:
  3367. memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len);
  3368. tmp_sa.sa_family = bond_dev->type;
  3369. /* unwind from head to the slave that failed */
  3370. stop_at = slave;
  3371. bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) {
  3372. int tmp_res;
  3373. tmp_res = dev_set_mac_address(slave->dev, &tmp_sa);
  3374. if (tmp_res) {
  3375. dprintk("unwind err %d dev %s\n", tmp_res,
  3376. slave->dev->name);
  3377. }
  3378. }
  3379. return res;
  3380. }
  3381. static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev)
  3382. {
  3383. struct bonding *bond = bond_dev->priv;
  3384. struct slave *slave, *start_at;
  3385. int i;
  3386. int res = 1;
  3387. read_lock(&bond->lock);
  3388. if (!BOND_IS_OK(bond)) {
  3389. goto out;
  3390. }
  3391. read_lock(&bond->curr_slave_lock);
  3392. slave = start_at = bond->curr_active_slave;
  3393. read_unlock(&bond->curr_slave_lock);
  3394. if (!slave) {
  3395. goto out;
  3396. }
  3397. bond_for_each_slave_from(bond, slave, i, start_at) {
  3398. if (IS_UP(slave->dev) &&
  3399. (slave->link == BOND_LINK_UP) &&
  3400. (slave->state == BOND_STATE_ACTIVE)) {
  3401. res = bond_dev_queue_xmit(bond, skb, slave->dev);
  3402. write_lock(&bond->curr_slave_lock);
  3403. bond->curr_active_slave = slave->next;
  3404. write_unlock(&bond->curr_slave_lock);
  3405. break;
  3406. }
  3407. }
  3408. out:
  3409. if (res) {
  3410. /* no suitable interface, frame not sent */
  3411. dev_kfree_skb(skb);
  3412. }
  3413. read_unlock(&bond->lock);
  3414. return 0;
  3415. }
  3416. /*
  3417. * in active-backup mode, we know that bond->curr_active_slave is always valid if
  3418. * the bond has a usable interface.
  3419. */
  3420. static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev)
  3421. {
  3422. struct bonding *bond = bond_dev->priv;
  3423. int res = 1;
  3424. read_lock(&bond->lock);
  3425. read_lock(&bond->curr_slave_lock);
  3426. if (!BOND_IS_OK(bond)) {
  3427. goto out;
  3428. }
  3429. if (!bond->curr_active_slave)
  3430. goto out;
  3431. res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev);
  3432. out:
  3433. if (res) {
  3434. /* no suitable interface, frame not sent */
  3435. dev_kfree_skb(skb);
  3436. }
  3437. read_unlock(&bond->curr_slave_lock);
  3438. read_unlock(&bond->lock);
  3439. return 0;
  3440. }
  3441. /*
  3442. * In bond_xmit_xor() , we determine the output device by using a pre-
  3443. * determined xmit_hash_policy(), If the selected device is not enabled,
  3444. * find the next active slave.
  3445. */
  3446. static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev)
  3447. {
  3448. struct bonding *bond = bond_dev->priv;
  3449. struct slave *slave, *start_at;
  3450. int slave_no;
  3451. int i;
  3452. int res = 1;
  3453. read_lock(&bond->lock);
  3454. if (!BOND_IS_OK(bond)) {
  3455. goto out;
  3456. }
  3457. slave_no = bond->xmit_hash_policy(skb, bond_dev, bond->slave_cnt);
  3458. bond_for_each_slave(bond, slave, i) {
  3459. slave_no--;
  3460. if (slave_no < 0) {
  3461. break;
  3462. }
  3463. }
  3464. start_at = slave;
  3465. bond_for_each_slave_from(bond, slave, i, start_at) {
  3466. if (IS_UP(slave->dev) &&
  3467. (slave->link == BOND_LINK_UP) &&
  3468. (slave->state == BOND_STATE_ACTIVE)) {
  3469. res = bond_dev_queue_xmit(bond, skb, slave->dev);
  3470. break;
  3471. }
  3472. }
  3473. out:
  3474. if (res) {
  3475. /* no suitable interface, frame not sent */
  3476. dev_kfree_skb(skb);
  3477. }
  3478. read_unlock(&bond->lock);
  3479. return 0;
  3480. }
  3481. /*
  3482. * in broadcast mode, we send everything to all usable interfaces.
  3483. */
  3484. static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev)
  3485. {
  3486. struct bonding *bond = bond_dev->priv;
  3487. struct slave *slave, *start_at;
  3488. struct net_device *tx_dev = NULL;
  3489. int i;
  3490. int res = 1;
  3491. read_lock(&bond->lock);
  3492. if (!BOND_IS_OK(bond)) {
  3493. goto out;
  3494. }
  3495. read_lock(&bond->curr_slave_lock);
  3496. start_at = bond->curr_active_slave;
  3497. read_unlock(&bond->curr_slave_lock);
  3498. if (!start_at) {
  3499. goto out;
  3500. }
  3501. bond_for_each_slave_from(bond, slave, i, start_at) {
  3502. if (IS_UP(slave->dev) &&
  3503. (slave->link == BOND_LINK_UP) &&
  3504. (slave->state == BOND_STATE_ACTIVE)) {
  3505. if (tx_dev) {
  3506. struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  3507. if (!skb2) {
  3508. printk(KERN_ERR DRV_NAME
  3509. ": %s: Error: bond_xmit_broadcast(): "
  3510. "skb_clone() failed\n",
  3511. bond_dev->name);
  3512. continue;
  3513. }
  3514. res = bond_dev_queue_xmit(bond, skb2, tx_dev);
  3515. if (res) {
  3516. dev_kfree_skb(skb2);
  3517. continue;
  3518. }
  3519. }
  3520. tx_dev = slave->dev;
  3521. }
  3522. }
  3523. if (tx_dev) {
  3524. res = bond_dev_queue_xmit(bond, skb, tx_dev);
  3525. }
  3526. out:
  3527. if (res) {
  3528. /* no suitable interface, frame not sent */
  3529. dev_kfree_skb(skb);
  3530. }
  3531. /* frame sent to all suitable interfaces */
  3532. read_unlock(&bond->lock);
  3533. return 0;
  3534. }
  3535. /*------------------------- Device initialization ---------------------------*/
  3536. /*
  3537. * set bond mode specific net device operations
  3538. */
  3539. void bond_set_mode_ops(struct bonding *bond, int mode)
  3540. {
  3541. struct net_device *bond_dev = bond->dev;
  3542. switch (mode) {
  3543. case BOND_MODE_ROUNDROBIN:
  3544. bond_dev->hard_start_xmit = bond_xmit_roundrobin;
  3545. break;
  3546. case BOND_MODE_ACTIVEBACKUP:
  3547. bond_dev->hard_start_xmit = bond_xmit_activebackup;
  3548. break;
  3549. case BOND_MODE_XOR:
  3550. bond_dev->hard_start_xmit = bond_xmit_xor;
  3551. if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34)
  3552. bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
  3553. else
  3554. bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
  3555. break;
  3556. case BOND_MODE_BROADCAST:
  3557. bond_dev->hard_start_xmit = bond_xmit_broadcast;
  3558. break;
  3559. case BOND_MODE_8023AD:
  3560. bond_set_master_3ad_flags(bond);
  3561. bond_dev->hard_start_xmit = bond_3ad_xmit_xor;
  3562. if (bond->params.xmit_policy == BOND_XMIT_POLICY_LAYER34)
  3563. bond->xmit_hash_policy = bond_xmit_hash_policy_l34;
  3564. else
  3565. bond->xmit_hash_policy = bond_xmit_hash_policy_l2;
  3566. break;
  3567. case BOND_MODE_ALB:
  3568. bond_set_master_alb_flags(bond);
  3569. /* FALLTHRU */
  3570. case BOND_MODE_TLB:
  3571. bond_dev->hard_start_xmit = bond_alb_xmit;
  3572. bond_dev->set_mac_address = bond_alb_set_mac_address;
  3573. break;
  3574. default:
  3575. /* Should never happen, mode already checked */
  3576. printk(KERN_ERR DRV_NAME
  3577. ": %s: Error: Unknown bonding mode %d\n",
  3578. bond_dev->name,
  3579. mode);
  3580. break;
  3581. }
  3582. }
  3583. static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
  3584. struct ethtool_drvinfo *drvinfo)
  3585. {
  3586. strncpy(drvinfo->driver, DRV_NAME, 32);
  3587. strncpy(drvinfo->version, DRV_VERSION, 32);
  3588. snprintf(drvinfo->fw_version, 32, "%d", BOND_ABI_VERSION);
  3589. }
  3590. static const struct ethtool_ops bond_ethtool_ops = {
  3591. .get_tx_csum = ethtool_op_get_tx_csum,
  3592. .get_tso = ethtool_op_get_tso,
  3593. .get_ufo = ethtool_op_get_ufo,
  3594. .get_sg = ethtool_op_get_sg,
  3595. .get_drvinfo = bond_ethtool_get_drvinfo,
  3596. };
  3597. /*
  3598. * Does not allocate but creates a /proc entry.
  3599. * Allowed to fail.
  3600. */
  3601. static int bond_init(struct net_device *bond_dev, struct bond_params *params)
  3602. {
  3603. struct bonding *bond = bond_dev->priv;
  3604. dprintk("Begin bond_init for %s\n", bond_dev->name);
  3605. /* initialize rwlocks */
  3606. rwlock_init(&bond->lock);
  3607. rwlock_init(&bond->curr_slave_lock);
  3608. bond->params = *params; /* copy params struct */
  3609. /* Initialize pointers */
  3610. bond->first_slave = NULL;
  3611. bond->curr_active_slave = NULL;
  3612. bond->current_arp_slave = NULL;
  3613. bond->primary_slave = NULL;
  3614. bond->dev = bond_dev;
  3615. INIT_LIST_HEAD(&bond->vlan_list);
  3616. /* Initialize the device entry points */
  3617. bond_dev->open = bond_open;
  3618. bond_dev->stop = bond_close;
  3619. bond_dev->get_stats = bond_get_stats;
  3620. bond_dev->do_ioctl = bond_do_ioctl;
  3621. bond_dev->ethtool_ops = &bond_ethtool_ops;
  3622. bond_dev->set_multicast_list = bond_set_multicast_list;
  3623. bond_dev->change_mtu = bond_change_mtu;
  3624. bond_dev->set_mac_address = bond_set_mac_address;
  3625. bond_set_mode_ops(bond, bond->params.mode);
  3626. bond_dev->destructor = free_netdev;
  3627. /* Initialize the device options */
  3628. bond_dev->tx_queue_len = 0;
  3629. bond_dev->flags |= IFF_MASTER|IFF_MULTICAST;
  3630. bond_dev->priv_flags |= IFF_BONDING;
  3631. /* At first, we block adding VLANs. That's the only way to
  3632. * prevent problems that occur when adding VLANs over an
  3633. * empty bond. The block will be removed once non-challenged
  3634. * slaves are enslaved.
  3635. */
  3636. bond_dev->features |= NETIF_F_VLAN_CHALLENGED;
  3637. /* don't acquire bond device's netif_tx_lock when
  3638. * transmitting */
  3639. bond_dev->features |= NETIF_F_LLTX;
  3640. /* By default, we declare the bond to be fully
  3641. * VLAN hardware accelerated capable. Special
  3642. * care is taken in the various xmit functions
  3643. * when there are slaves that are not hw accel
  3644. * capable
  3645. */
  3646. bond_dev->vlan_rx_register = bond_vlan_rx_register;
  3647. bond_dev->vlan_rx_add_vid = bond_vlan_rx_add_vid;
  3648. bond_dev->vlan_rx_kill_vid = bond_vlan_rx_kill_vid;
  3649. bond_dev->features |= (NETIF_F_HW_VLAN_TX |
  3650. NETIF_F_HW_VLAN_RX |
  3651. NETIF_F_HW_VLAN_FILTER);
  3652. #ifdef CONFIG_PROC_FS
  3653. bond_create_proc_entry(bond);
  3654. #endif
  3655. list_add_tail(&bond->bond_list, &bond_dev_list);
  3656. return 0;
  3657. }
  3658. /* De-initialize device specific data.
  3659. * Caller must hold rtnl_lock.
  3660. */
  3661. void bond_deinit(struct net_device *bond_dev)
  3662. {
  3663. struct bonding *bond = bond_dev->priv;
  3664. list_del(&bond->bond_list);
  3665. #ifdef CONFIG_PROC_FS
  3666. bond_remove_proc_entry(bond);
  3667. #endif
  3668. }
  3669. /* Unregister and free all bond devices.
  3670. * Caller must hold rtnl_lock.
  3671. */
  3672. static void bond_free_all(void)
  3673. {
  3674. struct bonding *bond, *nxt;
  3675. list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) {
  3676. struct net_device *bond_dev = bond->dev;
  3677. bond_mc_list_destroy(bond);
  3678. /* Release the bonded slaves */
  3679. bond_release_all(bond_dev);
  3680. bond_deinit(bond_dev);
  3681. unregister_netdevice(bond_dev);
  3682. }
  3683. #ifdef CONFIG_PROC_FS
  3684. bond_destroy_proc_dir();
  3685. #endif
  3686. }
  3687. /*------------------------- Module initialization ---------------------------*/
  3688. /*
  3689. * Convert string input module parms. Accept either the
  3690. * number of the mode or its string name.
  3691. */
  3692. int bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl)
  3693. {
  3694. int i;
  3695. for (i = 0; tbl[i].modename; i++) {
  3696. if ((isdigit(*mode_arg) &&
  3697. tbl[i].mode == simple_strtol(mode_arg, NULL, 0)) ||
  3698. (strncmp(mode_arg, tbl[i].modename,
  3699. strlen(tbl[i].modename)) == 0)) {
  3700. return tbl[i].mode;
  3701. }
  3702. }
  3703. return -1;
  3704. }
  3705. static int bond_check_params(struct bond_params *params)
  3706. {
  3707. int arp_validate_value;
  3708. /*
  3709. * Convert string parameters.
  3710. */
  3711. if (mode) {
  3712. bond_mode = bond_parse_parm(mode, bond_mode_tbl);
  3713. if (bond_mode == -1) {
  3714. printk(KERN_ERR DRV_NAME
  3715. ": Error: Invalid bonding mode \"%s\"\n",
  3716. mode == NULL ? "NULL" : mode);
  3717. return -EINVAL;
  3718. }
  3719. }
  3720. if (xmit_hash_policy) {
  3721. if ((bond_mode != BOND_MODE_XOR) &&
  3722. (bond_mode != BOND_MODE_8023AD)) {
  3723. printk(KERN_INFO DRV_NAME
  3724. ": xor_mode param is irrelevant in mode %s\n",
  3725. bond_mode_name(bond_mode));
  3726. } else {
  3727. xmit_hashtype = bond_parse_parm(xmit_hash_policy,
  3728. xmit_hashtype_tbl);
  3729. if (xmit_hashtype == -1) {
  3730. printk(KERN_ERR DRV_NAME
  3731. ": Error: Invalid xmit_hash_policy \"%s\"\n",
  3732. xmit_hash_policy == NULL ? "NULL" :
  3733. xmit_hash_policy);
  3734. return -EINVAL;
  3735. }
  3736. }
  3737. }
  3738. if (lacp_rate) {
  3739. if (bond_mode != BOND_MODE_8023AD) {
  3740. printk(KERN_INFO DRV_NAME
  3741. ": lacp_rate param is irrelevant in mode %s\n",
  3742. bond_mode_name(bond_mode));
  3743. } else {
  3744. lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl);
  3745. if (lacp_fast == -1) {
  3746. printk(KERN_ERR DRV_NAME
  3747. ": Error: Invalid lacp rate \"%s\"\n",
  3748. lacp_rate == NULL ? "NULL" : lacp_rate);
  3749. return -EINVAL;
  3750. }
  3751. }
  3752. }
  3753. if (max_bonds < 1 || max_bonds > INT_MAX) {
  3754. printk(KERN_WARNING DRV_NAME
  3755. ": Warning: max_bonds (%d) not in range %d-%d, so it "
  3756. "was reset to BOND_DEFAULT_MAX_BONDS (%d)\n",
  3757. max_bonds, 1, INT_MAX, BOND_DEFAULT_MAX_BONDS);
  3758. max_bonds = BOND_DEFAULT_MAX_BONDS;
  3759. }
  3760. if (miimon < 0) {
  3761. printk(KERN_WARNING DRV_NAME
  3762. ": Warning: miimon module parameter (%d), "
  3763. "not in range 0-%d, so it was reset to %d\n",
  3764. miimon, INT_MAX, BOND_LINK_MON_INTERV);
  3765. miimon = BOND_LINK_MON_INTERV;
  3766. }
  3767. if (updelay < 0) {
  3768. printk(KERN_WARNING DRV_NAME
  3769. ": Warning: updelay module parameter (%d), "
  3770. "not in range 0-%d, so it was reset to 0\n",
  3771. updelay, INT_MAX);
  3772. updelay = 0;
  3773. }
  3774. if (downdelay < 0) {
  3775. printk(KERN_WARNING DRV_NAME
  3776. ": Warning: downdelay module parameter (%d), "
  3777. "not in range 0-%d, so it was reset to 0\n",
  3778. downdelay, INT_MAX);
  3779. downdelay = 0;
  3780. }
  3781. if ((use_carrier != 0) && (use_carrier != 1)) {
  3782. printk(KERN_WARNING DRV_NAME
  3783. ": Warning: use_carrier module parameter (%d), "
  3784. "not of valid value (0/1), so it was set to 1\n",
  3785. use_carrier);
  3786. use_carrier = 1;
  3787. }
  3788. /* reset values for 802.3ad */
  3789. if (bond_mode == BOND_MODE_8023AD) {
  3790. if (!miimon) {
  3791. printk(KERN_WARNING DRV_NAME
  3792. ": Warning: miimon must be specified, "
  3793. "otherwise bonding will not detect link "
  3794. "failure, speed and duplex which are "
  3795. "essential for 802.3ad operation\n");
  3796. printk(KERN_WARNING "Forcing miimon to 100msec\n");
  3797. miimon = 100;
  3798. }
  3799. }
  3800. /* reset values for TLB/ALB */
  3801. if ((bond_mode == BOND_MODE_TLB) ||
  3802. (bond_mode == BOND_MODE_ALB)) {
  3803. if (!miimon) {
  3804. printk(KERN_WARNING DRV_NAME
  3805. ": Warning: miimon must be specified, "
  3806. "otherwise bonding will not detect link "
  3807. "failure and link speed which are essential "
  3808. "for TLB/ALB load balancing\n");
  3809. printk(KERN_WARNING "Forcing miimon to 100msec\n");
  3810. miimon = 100;
  3811. }
  3812. }
  3813. if (bond_mode == BOND_MODE_ALB) {
  3814. printk(KERN_NOTICE DRV_NAME
  3815. ": In ALB mode you might experience client "
  3816. "disconnections upon reconnection of a link if the "
  3817. "bonding module updelay parameter (%d msec) is "
  3818. "incompatible with the forwarding delay time of the "
  3819. "switch\n",
  3820. updelay);
  3821. }
  3822. if (!miimon) {
  3823. if (updelay || downdelay) {
  3824. /* just warn the user the up/down delay will have
  3825. * no effect since miimon is zero...
  3826. */
  3827. printk(KERN_WARNING DRV_NAME
  3828. ": Warning: miimon module parameter not set "
  3829. "and updelay (%d) or downdelay (%d) module "
  3830. "parameter is set; updelay and downdelay have "
  3831. "no effect unless miimon is set\n",
  3832. updelay, downdelay);
  3833. }
  3834. } else {
  3835. /* don't allow arp monitoring */
  3836. if (arp_interval) {
  3837. printk(KERN_WARNING DRV_NAME
  3838. ": Warning: miimon (%d) and arp_interval (%d) "
  3839. "can't be used simultaneously, disabling ARP "
  3840. "monitoring\n",
  3841. miimon, arp_interval);
  3842. arp_interval = 0;
  3843. }
  3844. if ((updelay % miimon) != 0) {
  3845. printk(KERN_WARNING DRV_NAME
  3846. ": Warning: updelay (%d) is not a multiple "
  3847. "of miimon (%d), updelay rounded to %d ms\n",
  3848. updelay, miimon, (updelay / miimon) * miimon);
  3849. }
  3850. updelay /= miimon;
  3851. if ((downdelay % miimon) != 0) {
  3852. printk(KERN_WARNING DRV_NAME
  3853. ": Warning: downdelay (%d) is not a multiple "
  3854. "of miimon (%d), downdelay rounded to %d ms\n",
  3855. downdelay, miimon,
  3856. (downdelay / miimon) * miimon);
  3857. }
  3858. downdelay /= miimon;
  3859. }
  3860. if (arp_interval < 0) {
  3861. printk(KERN_WARNING DRV_NAME
  3862. ": Warning: arp_interval module parameter (%d) "
  3863. ", not in range 0-%d, so it was reset to %d\n",
  3864. arp_interval, INT_MAX, BOND_LINK_ARP_INTERV);
  3865. arp_interval = BOND_LINK_ARP_INTERV;
  3866. }
  3867. for (arp_ip_count = 0;
  3868. (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[arp_ip_count];
  3869. arp_ip_count++) {
  3870. /* not complete check, but should be good enough to
  3871. catch mistakes */
  3872. if (!isdigit(arp_ip_target[arp_ip_count][0])) {
  3873. printk(KERN_WARNING DRV_NAME
  3874. ": Warning: bad arp_ip_target module parameter "
  3875. "(%s), ARP monitoring will not be performed\n",
  3876. arp_ip_target[arp_ip_count]);
  3877. arp_interval = 0;
  3878. } else {
  3879. u32 ip = in_aton(arp_ip_target[arp_ip_count]);
  3880. arp_target[arp_ip_count] = ip;
  3881. }
  3882. }
  3883. if (arp_interval && !arp_ip_count) {
  3884. /* don't allow arping if no arp_ip_target given... */
  3885. printk(KERN_WARNING DRV_NAME
  3886. ": Warning: arp_interval module parameter (%d) "
  3887. "specified without providing an arp_ip_target "
  3888. "parameter, arp_interval was reset to 0\n",
  3889. arp_interval);
  3890. arp_interval = 0;
  3891. }
  3892. if (arp_validate) {
  3893. if (bond_mode != BOND_MODE_ACTIVEBACKUP) {
  3894. printk(KERN_ERR DRV_NAME
  3895. ": arp_validate only supported in active-backup mode\n");
  3896. return -EINVAL;
  3897. }
  3898. if (!arp_interval) {
  3899. printk(KERN_ERR DRV_NAME
  3900. ": arp_validate requires arp_interval\n");
  3901. return -EINVAL;
  3902. }
  3903. arp_validate_value = bond_parse_parm(arp_validate,
  3904. arp_validate_tbl);
  3905. if (arp_validate_value == -1) {
  3906. printk(KERN_ERR DRV_NAME
  3907. ": Error: invalid arp_validate \"%s\"\n",
  3908. arp_validate == NULL ? "NULL" : arp_validate);
  3909. return -EINVAL;
  3910. }
  3911. } else
  3912. arp_validate_value = 0;
  3913. if (miimon) {
  3914. printk(KERN_INFO DRV_NAME
  3915. ": MII link monitoring set to %d ms\n",
  3916. miimon);
  3917. } else if (arp_interval) {
  3918. int i;
  3919. printk(KERN_INFO DRV_NAME
  3920. ": ARP monitoring set to %d ms, validate %s, with %d target(s):",
  3921. arp_interval,
  3922. arp_validate_tbl[arp_validate_value].modename,
  3923. arp_ip_count);
  3924. for (i = 0; i < arp_ip_count; i++)
  3925. printk (" %s", arp_ip_target[i]);
  3926. printk("\n");
  3927. } else {
  3928. /* miimon and arp_interval not set, we need one so things
  3929. * work as expected, see bonding.txt for details
  3930. */
  3931. printk(KERN_WARNING DRV_NAME
  3932. ": Warning: either miimon or arp_interval and "
  3933. "arp_ip_target module parameters must be specified, "
  3934. "otherwise bonding will not detect link failures! see "
  3935. "bonding.txt for details.\n");
  3936. }
  3937. if (primary && !USES_PRIMARY(bond_mode)) {
  3938. /* currently, using a primary only makes sense
  3939. * in active backup, TLB or ALB modes
  3940. */
  3941. printk(KERN_WARNING DRV_NAME
  3942. ": Warning: %s primary device specified but has no "
  3943. "effect in %s mode\n",
  3944. primary, bond_mode_name(bond_mode));
  3945. primary = NULL;
  3946. }
  3947. /* fill params struct with the proper values */
  3948. params->mode = bond_mode;
  3949. params->xmit_policy = xmit_hashtype;
  3950. params->miimon = miimon;
  3951. params->arp_interval = arp_interval;
  3952. params->arp_validate = arp_validate_value;
  3953. params->updelay = updelay;
  3954. params->downdelay = downdelay;
  3955. params->use_carrier = use_carrier;
  3956. params->lacp_fast = lacp_fast;
  3957. params->primary[0] = 0;
  3958. if (primary) {
  3959. strncpy(params->primary, primary, IFNAMSIZ);
  3960. params->primary[IFNAMSIZ - 1] = 0;
  3961. }
  3962. memcpy(params->arp_targets, arp_target, sizeof(arp_target));
  3963. return 0;
  3964. }
  3965. static struct lock_class_key bonding_netdev_xmit_lock_key;
  3966. /* Create a new bond based on the specified name and bonding parameters.
  3967. * If name is NULL, obtain a suitable "bond%d" name for us.
  3968. * Caller must NOT hold rtnl_lock; we need to release it here before we
  3969. * set up our sysfs entries.
  3970. */
  3971. int bond_create(char *name, struct bond_params *params, struct bonding **newbond)
  3972. {
  3973. struct net_device *bond_dev;
  3974. int res;
  3975. rtnl_lock();
  3976. bond_dev = alloc_netdev(sizeof(struct bonding), name ? name : "",
  3977. ether_setup);
  3978. if (!bond_dev) {
  3979. printk(KERN_ERR DRV_NAME
  3980. ": %s: eek! can't alloc netdev!\n",
  3981. name);
  3982. res = -ENOMEM;
  3983. goto out_rtnl;
  3984. }
  3985. if (!name) {
  3986. res = dev_alloc_name(bond_dev, "bond%d");
  3987. if (res < 0)
  3988. goto out_netdev;
  3989. }
  3990. /* bond_init() must be called after dev_alloc_name() (for the
  3991. * /proc files), but before register_netdevice(), because we
  3992. * need to set function pointers.
  3993. */
  3994. res = bond_init(bond_dev, params);
  3995. if (res < 0) {
  3996. goto out_netdev;
  3997. }
  3998. SET_MODULE_OWNER(bond_dev);
  3999. res = register_netdevice(bond_dev);
  4000. if (res < 0) {
  4001. goto out_bond;
  4002. }
  4003. lockdep_set_class(&bond_dev->_xmit_lock, &bonding_netdev_xmit_lock_key);
  4004. if (newbond)
  4005. *newbond = bond_dev->priv;
  4006. netif_carrier_off(bond_dev);
  4007. rtnl_unlock(); /* allows sysfs registration of net device */
  4008. res = bond_create_sysfs_entry(bond_dev->priv);
  4009. if (res < 0) {
  4010. rtnl_lock();
  4011. goto out_bond;
  4012. }
  4013. return 0;
  4014. out_bond:
  4015. bond_deinit(bond_dev);
  4016. out_netdev:
  4017. free_netdev(bond_dev);
  4018. out_rtnl:
  4019. rtnl_unlock();
  4020. return res;
  4021. }
  4022. static int __init bonding_init(void)
  4023. {
  4024. int i;
  4025. int res;
  4026. printk(KERN_INFO "%s", version);
  4027. res = bond_check_params(&bonding_defaults);
  4028. if (res) {
  4029. goto out;
  4030. }
  4031. #ifdef CONFIG_PROC_FS
  4032. bond_create_proc_dir();
  4033. #endif
  4034. for (i = 0; i < max_bonds; i++) {
  4035. res = bond_create(NULL, &bonding_defaults, NULL);
  4036. if (res)
  4037. goto err;
  4038. }
  4039. res = bond_create_sysfs();
  4040. if (res)
  4041. goto err;
  4042. register_netdevice_notifier(&bond_netdev_notifier);
  4043. register_inetaddr_notifier(&bond_inetaddr_notifier);
  4044. goto out;
  4045. err:
  4046. rtnl_lock();
  4047. bond_free_all();
  4048. bond_destroy_sysfs();
  4049. rtnl_unlock();
  4050. out:
  4051. return res;
  4052. }
  4053. static void __exit bonding_exit(void)
  4054. {
  4055. unregister_netdevice_notifier(&bond_netdev_notifier);
  4056. unregister_inetaddr_notifier(&bond_inetaddr_notifier);
  4057. rtnl_lock();
  4058. bond_free_all();
  4059. bond_destroy_sysfs();
  4060. rtnl_unlock();
  4061. }
  4062. module_init(bonding_init);
  4063. module_exit(bonding_exit);
  4064. MODULE_LICENSE("GPL");
  4065. MODULE_VERSION(DRV_VERSION);
  4066. MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION);
  4067. MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others");
  4068. MODULE_SUPPORTED_DEVICE("most ethernet devices");
  4069. /*
  4070. * Local variables:
  4071. * c-indent-level: 8
  4072. * c-basic-offset: 8
  4073. * tab-width: 8
  4074. * End:
  4075. */