bond_main.c 132 KB

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