trace.h 89 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #undef TRACE_SYSTEM
  3. #define TRACE_SYSTEM cfg80211
  4. #if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ)
  5. #define __RDEV_OPS_TRACE
  6. #include <linux/tracepoint.h>
  7. #include <linux/rtnetlink.h>
  8. #include <linux/etherdevice.h>
  9. #include <net/cfg80211.h>
  10. #include "core.h"
  11. #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
  12. #define MAC_ASSIGN(entry_mac, given_mac) do { \
  13. if (given_mac) \
  14. memcpy(__entry->entry_mac, given_mac, ETH_ALEN); \
  15. else \
  16. eth_zero_addr(__entry->entry_mac); \
  17. } while (0)
  18. #define MAC_PR_FMT "%pM"
  19. #define MAC_PR_ARG(entry_mac) (__entry->entry_mac)
  20. #define MAXNAME 32
  21. #define WIPHY_ENTRY __array(char, wiphy_name, 32)
  22. #define WIPHY_ASSIGN strlcpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME)
  23. #define WIPHY_PR_FMT "%s"
  24. #define WIPHY_PR_ARG __entry->wiphy_name
  25. #define WDEV_ENTRY __field(u32, id)
  26. #define WDEV_ASSIGN (__entry->id) = (!IS_ERR_OR_NULL(wdev) \
  27. ? wdev->identifier : 0)
  28. #define WDEV_PR_FMT "wdev(%u)"
  29. #define WDEV_PR_ARG (__entry->id)
  30. #define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \
  31. __field(int, ifindex)
  32. #define NETDEV_ASSIGN \
  33. do { \
  34. memcpy(__entry->name, netdev->name, IFNAMSIZ); \
  35. (__entry->ifindex) = (netdev->ifindex); \
  36. } while (0)
  37. #define NETDEV_PR_FMT "netdev:%s(%d)"
  38. #define NETDEV_PR_ARG __entry->name, __entry->ifindex
  39. #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout) \
  40. __field(u16, dot11MeshConfirmTimeout) \
  41. __field(u16, dot11MeshHoldingTimeout) \
  42. __field(u16, dot11MeshMaxPeerLinks) \
  43. __field(u8, dot11MeshMaxRetries) \
  44. __field(u8, dot11MeshTTL) \
  45. __field(u8, element_ttl) \
  46. __field(bool, auto_open_plinks) \
  47. __field(u32, dot11MeshNbrOffsetMaxNeighbor) \
  48. __field(u8, dot11MeshHWMPmaxPREQretries) \
  49. __field(u32, path_refresh_time) \
  50. __field(u32, dot11MeshHWMPactivePathTimeout) \
  51. __field(u16, min_discovery_timeout) \
  52. __field(u16, dot11MeshHWMPpreqMinInterval) \
  53. __field(u16, dot11MeshHWMPperrMinInterval) \
  54. __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
  55. __field(u8, dot11MeshHWMPRootMode) \
  56. __field(u16, dot11MeshHWMPRannInterval) \
  57. __field(bool, dot11MeshGateAnnouncementProtocol) \
  58. __field(bool, dot11MeshForwarding) \
  59. __field(s32, rssi_threshold) \
  60. __field(u16, ht_opmode) \
  61. __field(u32, dot11MeshHWMPactivePathToRootTimeout) \
  62. __field(u16, dot11MeshHWMProotInterval) \
  63. __field(u16, dot11MeshHWMPconfirmationInterval)
  64. #define MESH_CFG_ASSIGN \
  65. do { \
  66. __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
  67. __entry->dot11MeshConfirmTimeout = \
  68. conf->dot11MeshConfirmTimeout; \
  69. __entry->dot11MeshHoldingTimeout = \
  70. conf->dot11MeshHoldingTimeout; \
  71. __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
  72. __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries; \
  73. __entry->dot11MeshTTL = conf->dot11MeshTTL; \
  74. __entry->element_ttl = conf->element_ttl; \
  75. __entry->auto_open_plinks = conf->auto_open_plinks; \
  76. __entry->dot11MeshNbrOffsetMaxNeighbor = \
  77. conf->dot11MeshNbrOffsetMaxNeighbor; \
  78. __entry->dot11MeshHWMPmaxPREQretries = \
  79. conf->dot11MeshHWMPmaxPREQretries; \
  80. __entry->path_refresh_time = conf->path_refresh_time; \
  81. __entry->dot11MeshHWMPactivePathTimeout = \
  82. conf->dot11MeshHWMPactivePathTimeout; \
  83. __entry->min_discovery_timeout = conf->min_discovery_timeout; \
  84. __entry->dot11MeshHWMPpreqMinInterval = \
  85. conf->dot11MeshHWMPpreqMinInterval; \
  86. __entry->dot11MeshHWMPperrMinInterval = \
  87. conf->dot11MeshHWMPperrMinInterval; \
  88. __entry->dot11MeshHWMPnetDiameterTraversalTime = \
  89. conf->dot11MeshHWMPnetDiameterTraversalTime; \
  90. __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
  91. __entry->dot11MeshHWMPRannInterval = \
  92. conf->dot11MeshHWMPRannInterval; \
  93. __entry->dot11MeshGateAnnouncementProtocol = \
  94. conf->dot11MeshGateAnnouncementProtocol; \
  95. __entry->dot11MeshForwarding = conf->dot11MeshForwarding; \
  96. __entry->rssi_threshold = conf->rssi_threshold; \
  97. __entry->ht_opmode = conf->ht_opmode; \
  98. __entry->dot11MeshHWMPactivePathToRootTimeout = \
  99. conf->dot11MeshHWMPactivePathToRootTimeout; \
  100. __entry->dot11MeshHWMProotInterval = \
  101. conf->dot11MeshHWMProotInterval; \
  102. __entry->dot11MeshHWMPconfirmationInterval = \
  103. conf->dot11MeshHWMPconfirmationInterval; \
  104. } while (0)
  105. #define CHAN_ENTRY __field(enum nl80211_band, band) \
  106. __field(u16, center_freq)
  107. #define CHAN_ASSIGN(chan) \
  108. do { \
  109. if (chan) { \
  110. __entry->band = chan->band; \
  111. __entry->center_freq = chan->center_freq; \
  112. } else { \
  113. __entry->band = 0; \
  114. __entry->center_freq = 0; \
  115. } \
  116. } while (0)
  117. #define CHAN_PR_FMT "band: %d, freq: %u"
  118. #define CHAN_PR_ARG __entry->band, __entry->center_freq
  119. #define CHAN_DEF_ENTRY __field(enum nl80211_band, band) \
  120. __field(u32, control_freq) \
  121. __field(u32, width) \
  122. __field(u32, center_freq1) \
  123. __field(u32, center_freq2)
  124. #define CHAN_DEF_ASSIGN(chandef) \
  125. do { \
  126. if ((chandef) && (chandef)->chan) { \
  127. __entry->band = (chandef)->chan->band; \
  128. __entry->control_freq = \
  129. (chandef)->chan->center_freq; \
  130. __entry->width = (chandef)->width; \
  131. __entry->center_freq1 = (chandef)->center_freq1;\
  132. __entry->center_freq2 = (chandef)->center_freq2;\
  133. } else { \
  134. __entry->band = 0; \
  135. __entry->control_freq = 0; \
  136. __entry->width = 0; \
  137. __entry->center_freq1 = 0; \
  138. __entry->center_freq2 = 0; \
  139. } \
  140. } while (0)
  141. #define CHAN_DEF_PR_FMT \
  142. "band: %d, control freq: %u, width: %d, cf1: %u, cf2: %u"
  143. #define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq, \
  144. __entry->width, __entry->center_freq1, \
  145. __entry->center_freq2
  146. #define SINFO_ENTRY __field(int, generation) \
  147. __field(u32, connected_time) \
  148. __field(u32, inactive_time) \
  149. __field(u32, rx_bytes) \
  150. __field(u32, tx_bytes) \
  151. __field(u32, rx_packets) \
  152. __field(u32, tx_packets) \
  153. __field(u32, tx_retries) \
  154. __field(u32, tx_failed) \
  155. __field(u32, rx_dropped_misc) \
  156. __field(u32, beacon_loss_count) \
  157. __field(u16, llid) \
  158. __field(u16, plid) \
  159. __field(u8, plink_state)
  160. #define SINFO_ASSIGN \
  161. do { \
  162. __entry->generation = sinfo->generation; \
  163. __entry->connected_time = sinfo->connected_time; \
  164. __entry->inactive_time = sinfo->inactive_time; \
  165. __entry->rx_bytes = sinfo->rx_bytes; \
  166. __entry->tx_bytes = sinfo->tx_bytes; \
  167. __entry->rx_packets = sinfo->rx_packets; \
  168. __entry->tx_packets = sinfo->tx_packets; \
  169. __entry->tx_retries = sinfo->tx_retries; \
  170. __entry->tx_failed = sinfo->tx_failed; \
  171. __entry->rx_dropped_misc = sinfo->rx_dropped_misc; \
  172. __entry->beacon_loss_count = sinfo->beacon_loss_count; \
  173. __entry->llid = sinfo->llid; \
  174. __entry->plid = sinfo->plid; \
  175. __entry->plink_state = sinfo->plink_state; \
  176. } while (0)
  177. #define BOOL_TO_STR(bo) (bo) ? "true" : "false"
  178. #define QOS_MAP_ENTRY __field(u8, num_des) \
  179. __array(u8, dscp_exception, \
  180. 2 * IEEE80211_QOS_MAP_MAX_EX) \
  181. __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN)
  182. #define QOS_MAP_ASSIGN(qos_map) \
  183. do { \
  184. if ((qos_map)) { \
  185. __entry->num_des = (qos_map)->num_des; \
  186. memcpy(__entry->dscp_exception, \
  187. &(qos_map)->dscp_exception, \
  188. 2 * IEEE80211_QOS_MAP_MAX_EX); \
  189. memcpy(__entry->up, &(qos_map)->up, \
  190. IEEE80211_QOS_MAP_LEN_MIN); \
  191. } else { \
  192. __entry->num_des = 0; \
  193. memset(__entry->dscp_exception, 0, \
  194. 2 * IEEE80211_QOS_MAP_MAX_EX); \
  195. memset(__entry->up, 0, \
  196. IEEE80211_QOS_MAP_LEN_MIN); \
  197. } \
  198. } while (0)
  199. /*************************************************************
  200. * rdev->ops traces *
  201. *************************************************************/
  202. TRACE_EVENT(rdev_suspend,
  203. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
  204. TP_ARGS(wiphy, wow),
  205. TP_STRUCT__entry(
  206. WIPHY_ENTRY
  207. __field(bool, any)
  208. __field(bool, disconnect)
  209. __field(bool, magic_pkt)
  210. __field(bool, gtk_rekey_failure)
  211. __field(bool, eap_identity_req)
  212. __field(bool, four_way_handshake)
  213. __field(bool, rfkill_release)
  214. __field(bool, valid_wow)
  215. ),
  216. TP_fast_assign(
  217. WIPHY_ASSIGN;
  218. if (wow) {
  219. __entry->any = wow->any;
  220. __entry->disconnect = wow->disconnect;
  221. __entry->magic_pkt = wow->magic_pkt;
  222. __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
  223. __entry->eap_identity_req = wow->eap_identity_req;
  224. __entry->four_way_handshake = wow->four_way_handshake;
  225. __entry->rfkill_release = wow->rfkill_release;
  226. __entry->valid_wow = true;
  227. } else {
  228. __entry->valid_wow = false;
  229. }
  230. ),
  231. TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
  232. "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
  233. "four way handshake: %d, rfkill release: %d.",
  234. WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
  235. __entry->any, __entry->disconnect, __entry->magic_pkt,
  236. __entry->gtk_rekey_failure, __entry->eap_identity_req,
  237. __entry->four_way_handshake, __entry->rfkill_release)
  238. );
  239. TRACE_EVENT(rdev_return_int,
  240. TP_PROTO(struct wiphy *wiphy, int ret),
  241. TP_ARGS(wiphy, ret),
  242. TP_STRUCT__entry(
  243. WIPHY_ENTRY
  244. __field(int, ret)
  245. ),
  246. TP_fast_assign(
  247. WIPHY_ASSIGN;
  248. __entry->ret = ret;
  249. ),
  250. TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
  251. );
  252. TRACE_EVENT(rdev_scan,
  253. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request),
  254. TP_ARGS(wiphy, request),
  255. TP_STRUCT__entry(
  256. WIPHY_ENTRY
  257. ),
  258. TP_fast_assign(
  259. WIPHY_ASSIGN;
  260. ),
  261. TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
  262. );
  263. DECLARE_EVENT_CLASS(wiphy_only_evt,
  264. TP_PROTO(struct wiphy *wiphy),
  265. TP_ARGS(wiphy),
  266. TP_STRUCT__entry(
  267. WIPHY_ENTRY
  268. ),
  269. TP_fast_assign(
  270. WIPHY_ASSIGN;
  271. ),
  272. TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
  273. );
  274. DEFINE_EVENT(wiphy_only_evt, rdev_resume,
  275. TP_PROTO(struct wiphy *wiphy),
  276. TP_ARGS(wiphy)
  277. );
  278. DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
  279. TP_PROTO(struct wiphy *wiphy),
  280. TP_ARGS(wiphy)
  281. );
  282. DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna,
  283. TP_PROTO(struct wiphy *wiphy),
  284. TP_ARGS(wiphy)
  285. );
  286. DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
  287. TP_PROTO(struct wiphy *wiphy),
  288. TP_ARGS(wiphy)
  289. );
  290. DECLARE_EVENT_CLASS(wiphy_enabled_evt,
  291. TP_PROTO(struct wiphy *wiphy, bool enabled),
  292. TP_ARGS(wiphy, enabled),
  293. TP_STRUCT__entry(
  294. WIPHY_ENTRY
  295. __field(bool, enabled)
  296. ),
  297. TP_fast_assign(
  298. WIPHY_ASSIGN;
  299. __entry->enabled = enabled;
  300. ),
  301. TP_printk(WIPHY_PR_FMT ", %senabled ",
  302. WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
  303. );
  304. DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
  305. TP_PROTO(struct wiphy *wiphy, bool enabled),
  306. TP_ARGS(wiphy, enabled)
  307. );
  308. TRACE_EVENT(rdev_add_virtual_intf,
  309. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
  310. TP_ARGS(wiphy, name, type),
  311. TP_STRUCT__entry(
  312. WIPHY_ENTRY
  313. __string(vir_intf_name, name ? name : "<noname>")
  314. __field(enum nl80211_iftype, type)
  315. ),
  316. TP_fast_assign(
  317. WIPHY_ASSIGN;
  318. __assign_str(vir_intf_name, name ? name : "<noname>");
  319. __entry->type = type;
  320. ),
  321. TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
  322. WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
  323. );
  324. DECLARE_EVENT_CLASS(wiphy_wdev_evt,
  325. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  326. TP_ARGS(wiphy, wdev),
  327. TP_STRUCT__entry(
  328. WIPHY_ENTRY
  329. WDEV_ENTRY
  330. ),
  331. TP_fast_assign(
  332. WIPHY_ASSIGN;
  333. WDEV_ASSIGN;
  334. ),
  335. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
  336. );
  337. DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
  338. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  339. TP_ARGS(wiphy, wdev)
  340. );
  341. DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
  342. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  343. TP_ARGS(wiphy, wdev)
  344. );
  345. TRACE_EVENT(rdev_change_virtual_intf,
  346. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  347. enum nl80211_iftype type),
  348. TP_ARGS(wiphy, netdev, type),
  349. TP_STRUCT__entry(
  350. WIPHY_ENTRY
  351. NETDEV_ENTRY
  352. __field(enum nl80211_iftype, type)
  353. ),
  354. TP_fast_assign(
  355. WIPHY_ASSIGN;
  356. NETDEV_ASSIGN;
  357. __entry->type = type;
  358. ),
  359. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d",
  360. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
  361. );
  362. DECLARE_EVENT_CLASS(key_handle,
  363. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  364. bool pairwise, const u8 *mac_addr),
  365. TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr),
  366. TP_STRUCT__entry(
  367. WIPHY_ENTRY
  368. NETDEV_ENTRY
  369. MAC_ENTRY(mac_addr)
  370. __field(u8, key_index)
  371. __field(bool, pairwise)
  372. ),
  373. TP_fast_assign(
  374. WIPHY_ASSIGN;
  375. NETDEV_ASSIGN;
  376. MAC_ASSIGN(mac_addr, mac_addr);
  377. __entry->key_index = key_index;
  378. __entry->pairwise = pairwise;
  379. ),
  380. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key_index: %u, pairwise: %s, mac addr: " MAC_PR_FMT,
  381. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
  382. BOOL_TO_STR(__entry->pairwise), MAC_PR_ARG(mac_addr))
  383. );
  384. DEFINE_EVENT(key_handle, rdev_add_key,
  385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  386. bool pairwise, const u8 *mac_addr),
  387. TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
  388. );
  389. DEFINE_EVENT(key_handle, rdev_get_key,
  390. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  391. bool pairwise, const u8 *mac_addr),
  392. TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
  393. );
  394. DEFINE_EVENT(key_handle, rdev_del_key,
  395. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  396. bool pairwise, const u8 *mac_addr),
  397. TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
  398. );
  399. TRACE_EVENT(rdev_set_default_key,
  400. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  401. bool unicast, bool multicast),
  402. TP_ARGS(wiphy, netdev, key_index, unicast, multicast),
  403. TP_STRUCT__entry(
  404. WIPHY_ENTRY
  405. NETDEV_ENTRY
  406. __field(u8, key_index)
  407. __field(bool, unicast)
  408. __field(bool, multicast)
  409. ),
  410. TP_fast_assign(
  411. WIPHY_ASSIGN;
  412. NETDEV_ASSIGN;
  413. __entry->key_index = key_index;
  414. __entry->unicast = unicast;
  415. __entry->multicast = multicast;
  416. ),
  417. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u, unicast: %s, multicast: %s",
  418. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
  419. BOOL_TO_STR(__entry->unicast),
  420. BOOL_TO_STR(__entry->multicast))
  421. );
  422. TRACE_EVENT(rdev_set_default_mgmt_key,
  423. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index),
  424. TP_ARGS(wiphy, netdev, key_index),
  425. TP_STRUCT__entry(
  426. WIPHY_ENTRY
  427. NETDEV_ENTRY
  428. __field(u8, key_index)
  429. ),
  430. TP_fast_assign(
  431. WIPHY_ASSIGN;
  432. NETDEV_ASSIGN;
  433. __entry->key_index = key_index;
  434. ),
  435. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u",
  436. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index)
  437. );
  438. TRACE_EVENT(rdev_start_ap,
  439. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  440. struct cfg80211_ap_settings *settings),
  441. TP_ARGS(wiphy, netdev, settings),
  442. TP_STRUCT__entry(
  443. WIPHY_ENTRY
  444. NETDEV_ENTRY
  445. CHAN_DEF_ENTRY
  446. __field(int, beacon_interval)
  447. __field(int, dtim_period)
  448. __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
  449. __field(enum nl80211_hidden_ssid, hidden_ssid)
  450. __field(u32, wpa_ver)
  451. __field(bool, privacy)
  452. __field(enum nl80211_auth_type, auth_type)
  453. __field(int, inactivity_timeout)
  454. ),
  455. TP_fast_assign(
  456. WIPHY_ASSIGN;
  457. NETDEV_ASSIGN;
  458. CHAN_DEF_ASSIGN(&settings->chandef);
  459. __entry->beacon_interval = settings->beacon_interval;
  460. __entry->dtim_period = settings->dtim_period;
  461. __entry->hidden_ssid = settings->hidden_ssid;
  462. __entry->wpa_ver = settings->crypto.wpa_versions;
  463. __entry->privacy = settings->privacy;
  464. __entry->auth_type = settings->auth_type;
  465. __entry->inactivity_timeout = settings->inactivity_timeout;
  466. memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  467. memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
  468. ),
  469. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, "
  470. CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, "
  471. "hidden ssid: %d, wpa versions: %u, privacy: %s, "
  472. "auth type: %d, inactivity timeout: %d",
  473. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG,
  474. __entry->beacon_interval, __entry->dtim_period,
  475. __entry->hidden_ssid, __entry->wpa_ver,
  476. BOOL_TO_STR(__entry->privacy), __entry->auth_type,
  477. __entry->inactivity_timeout)
  478. );
  479. TRACE_EVENT(rdev_change_beacon,
  480. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  481. struct cfg80211_beacon_data *info),
  482. TP_ARGS(wiphy, netdev, info),
  483. TP_STRUCT__entry(
  484. WIPHY_ENTRY
  485. NETDEV_ENTRY
  486. __dynamic_array(u8, head, info ? info->head_len : 0)
  487. __dynamic_array(u8, tail, info ? info->tail_len : 0)
  488. __dynamic_array(u8, beacon_ies, info ? info->beacon_ies_len : 0)
  489. __dynamic_array(u8, proberesp_ies,
  490. info ? info->proberesp_ies_len : 0)
  491. __dynamic_array(u8, assocresp_ies,
  492. info ? info->assocresp_ies_len : 0)
  493. __dynamic_array(u8, probe_resp, info ? info->probe_resp_len : 0)
  494. ),
  495. TP_fast_assign(
  496. WIPHY_ASSIGN;
  497. NETDEV_ASSIGN;
  498. if (info) {
  499. if (info->head)
  500. memcpy(__get_dynamic_array(head), info->head,
  501. info->head_len);
  502. if (info->tail)
  503. memcpy(__get_dynamic_array(tail), info->tail,
  504. info->tail_len);
  505. if (info->beacon_ies)
  506. memcpy(__get_dynamic_array(beacon_ies),
  507. info->beacon_ies, info->beacon_ies_len);
  508. if (info->proberesp_ies)
  509. memcpy(__get_dynamic_array(proberesp_ies),
  510. info->proberesp_ies,
  511. info->proberesp_ies_len);
  512. if (info->assocresp_ies)
  513. memcpy(__get_dynamic_array(assocresp_ies),
  514. info->assocresp_ies,
  515. info->assocresp_ies_len);
  516. if (info->probe_resp)
  517. memcpy(__get_dynamic_array(probe_resp),
  518. info->probe_resp, info->probe_resp_len);
  519. }
  520. ),
  521. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
  522. );
  523. DECLARE_EVENT_CLASS(wiphy_netdev_evt,
  524. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  525. TP_ARGS(wiphy, netdev),
  526. TP_STRUCT__entry(
  527. WIPHY_ENTRY
  528. NETDEV_ENTRY
  529. ),
  530. TP_fast_assign(
  531. WIPHY_ASSIGN;
  532. NETDEV_ASSIGN;
  533. ),
  534. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
  535. );
  536. DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap,
  537. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  538. TP_ARGS(wiphy, netdev)
  539. );
  540. DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
  541. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  542. TP_ARGS(wiphy, netdev)
  543. );
  544. DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
  545. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  546. TP_ARGS(wiphy, netdev)
  547. );
  548. DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
  549. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  550. TP_ARGS(wiphy, netdev)
  551. );
  552. DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
  553. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  554. TP_ARGS(wiphy, netdev)
  555. );
  556. DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
  557. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  558. TP_ARGS(wiphy, netdev)
  559. );
  560. DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
  561. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  562. TP_ARGS(wiphy, netdev)
  563. );
  564. DEFINE_EVENT(wiphy_netdev_evt, rdev_end_cac,
  565. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
  566. TP_ARGS(wiphy, netdev)
  567. );
  568. DECLARE_EVENT_CLASS(station_add_change,
  569. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
  570. struct station_parameters *params),
  571. TP_ARGS(wiphy, netdev, mac, params),
  572. TP_STRUCT__entry(
  573. WIPHY_ENTRY
  574. NETDEV_ENTRY
  575. MAC_ENTRY(sta_mac)
  576. __field(u32, sta_flags_mask)
  577. __field(u32, sta_flags_set)
  578. __field(u32, sta_modify_mask)
  579. __field(int, listen_interval)
  580. __field(u16, capability)
  581. __field(u16, aid)
  582. __field(u8, plink_action)
  583. __field(u8, plink_state)
  584. __field(u8, uapsd_queues)
  585. __field(u8, max_sp)
  586. __field(u8, opmode_notif)
  587. __field(bool, opmode_notif_used)
  588. __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
  589. __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
  590. __array(char, vlan, IFNAMSIZ)
  591. __dynamic_array(u8, supported_rates,
  592. params->supported_rates_len)
  593. __dynamic_array(u8, ext_capab, params->ext_capab_len)
  594. __dynamic_array(u8, supported_channels,
  595. params->supported_channels_len)
  596. __dynamic_array(u8, supported_oper_classes,
  597. params->supported_oper_classes_len)
  598. ),
  599. TP_fast_assign(
  600. WIPHY_ASSIGN;
  601. NETDEV_ASSIGN;
  602. MAC_ASSIGN(sta_mac, mac);
  603. __entry->sta_flags_mask = params->sta_flags_mask;
  604. __entry->sta_flags_set = params->sta_flags_set;
  605. __entry->sta_modify_mask = params->sta_modify_mask;
  606. __entry->listen_interval = params->listen_interval;
  607. __entry->aid = params->aid;
  608. __entry->plink_action = params->plink_action;
  609. __entry->plink_state = params->plink_state;
  610. __entry->uapsd_queues = params->uapsd_queues;
  611. memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
  612. if (params->ht_capa)
  613. memcpy(__entry->ht_capa, params->ht_capa,
  614. sizeof(struct ieee80211_ht_cap));
  615. memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
  616. if (params->vht_capa)
  617. memcpy(__entry->vht_capa, params->vht_capa,
  618. sizeof(struct ieee80211_vht_cap));
  619. memset(__entry->vlan, 0, sizeof(__entry->vlan));
  620. if (params->vlan)
  621. memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
  622. if (params->supported_rates && params->supported_rates_len)
  623. memcpy(__get_dynamic_array(supported_rates),
  624. params->supported_rates,
  625. params->supported_rates_len);
  626. if (params->ext_capab && params->ext_capab_len)
  627. memcpy(__get_dynamic_array(ext_capab),
  628. params->ext_capab,
  629. params->ext_capab_len);
  630. if (params->supported_channels &&
  631. params->supported_channels_len)
  632. memcpy(__get_dynamic_array(supported_channels),
  633. params->supported_channels,
  634. params->supported_channels_len);
  635. if (params->supported_oper_classes &&
  636. params->supported_oper_classes_len)
  637. memcpy(__get_dynamic_array(supported_oper_classes),
  638. params->supported_oper_classes,
  639. params->supported_oper_classes_len);
  640. __entry->max_sp = params->max_sp;
  641. __entry->capability = params->capability;
  642. __entry->opmode_notif = params->opmode_notif;
  643. __entry->opmode_notif_used = params->opmode_notif_used;
  644. ),
  645. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
  646. ", station flags mask: %u, station flags set: %u, "
  647. "station modify mask: %u, listen interval: %d, aid: %u, "
  648. "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
  649. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
  650. __entry->sta_flags_mask, __entry->sta_flags_set,
  651. __entry->sta_modify_mask, __entry->listen_interval,
  652. __entry->aid, __entry->plink_action, __entry->plink_state,
  653. __entry->uapsd_queues, __entry->vlan)
  654. );
  655. DEFINE_EVENT(station_add_change, rdev_add_station,
  656. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
  657. struct station_parameters *params),
  658. TP_ARGS(wiphy, netdev, mac, params)
  659. );
  660. DEFINE_EVENT(station_add_change, rdev_change_station,
  661. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
  662. struct station_parameters *params),
  663. TP_ARGS(wiphy, netdev, mac, params)
  664. );
  665. DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
  666. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
  667. TP_ARGS(wiphy, netdev, mac),
  668. TP_STRUCT__entry(
  669. WIPHY_ENTRY
  670. NETDEV_ENTRY
  671. MAC_ENTRY(sta_mac)
  672. ),
  673. TP_fast_assign(
  674. WIPHY_ASSIGN;
  675. NETDEV_ASSIGN;
  676. MAC_ASSIGN(sta_mac, mac);
  677. ),
  678. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
  679. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac))
  680. );
  681. DECLARE_EVENT_CLASS(station_del,
  682. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  683. struct station_del_parameters *params),
  684. TP_ARGS(wiphy, netdev, params),
  685. TP_STRUCT__entry(
  686. WIPHY_ENTRY
  687. NETDEV_ENTRY
  688. MAC_ENTRY(sta_mac)
  689. __field(u8, subtype)
  690. __field(u16, reason_code)
  691. ),
  692. TP_fast_assign(
  693. WIPHY_ASSIGN;
  694. NETDEV_ASSIGN;
  695. MAC_ASSIGN(sta_mac, params->mac);
  696. __entry->subtype = params->subtype;
  697. __entry->reason_code = params->reason_code;
  698. ),
  699. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
  700. ", subtype: %u, reason_code: %u",
  701. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
  702. __entry->subtype, __entry->reason_code)
  703. );
  704. DEFINE_EVENT(station_del, rdev_del_station,
  705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  706. struct station_del_parameters *params),
  707. TP_ARGS(wiphy, netdev, params)
  708. );
  709. DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
  710. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
  711. TP_ARGS(wiphy, netdev, mac)
  712. );
  713. DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
  714. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
  715. TP_ARGS(wiphy, netdev, mac)
  716. );
  717. DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer,
  718. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
  719. TP_ARGS(wiphy, netdev, mac)
  720. );
  721. TRACE_EVENT(rdev_dump_station,
  722. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
  723. u8 *mac),
  724. TP_ARGS(wiphy, netdev, idx, mac),
  725. TP_STRUCT__entry(
  726. WIPHY_ENTRY
  727. NETDEV_ENTRY
  728. MAC_ENTRY(sta_mac)
  729. __field(int, idx)
  730. ),
  731. TP_fast_assign(
  732. WIPHY_ASSIGN;
  733. NETDEV_ASSIGN;
  734. MAC_ASSIGN(sta_mac, mac);
  735. __entry->idx = idx;
  736. ),
  737. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT ", idx: %d",
  738. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
  739. __entry->idx)
  740. );
  741. TRACE_EVENT(rdev_return_int_station_info,
  742. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
  743. TP_ARGS(wiphy, ret, sinfo),
  744. TP_STRUCT__entry(
  745. WIPHY_ENTRY
  746. __field(int, ret)
  747. SINFO_ENTRY
  748. ),
  749. TP_fast_assign(
  750. WIPHY_ASSIGN;
  751. __entry->ret = ret;
  752. SINFO_ASSIGN;
  753. ),
  754. TP_printk(WIPHY_PR_FMT ", returned %d" ,
  755. WIPHY_PR_ARG, __entry->ret)
  756. );
  757. DECLARE_EVENT_CLASS(mpath_evt,
  758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
  759. u8 *next_hop),
  760. TP_ARGS(wiphy, netdev, dst, next_hop),
  761. TP_STRUCT__entry(
  762. WIPHY_ENTRY
  763. NETDEV_ENTRY
  764. MAC_ENTRY(dst)
  765. MAC_ENTRY(next_hop)
  766. ),
  767. TP_fast_assign(
  768. WIPHY_ASSIGN;
  769. NETDEV_ASSIGN;
  770. MAC_ASSIGN(dst, dst);
  771. MAC_ASSIGN(next_hop, next_hop);
  772. ),
  773. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT ", next hop: " MAC_PR_FMT,
  774. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dst),
  775. MAC_PR_ARG(next_hop))
  776. );
  777. DEFINE_EVENT(mpath_evt, rdev_add_mpath,
  778. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
  779. u8 *next_hop),
  780. TP_ARGS(wiphy, netdev, dst, next_hop)
  781. );
  782. DEFINE_EVENT(mpath_evt, rdev_change_mpath,
  783. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
  784. u8 *next_hop),
  785. TP_ARGS(wiphy, netdev, dst, next_hop)
  786. );
  787. DEFINE_EVENT(mpath_evt, rdev_get_mpath,
  788. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
  789. u8 *next_hop),
  790. TP_ARGS(wiphy, netdev, dst, next_hop)
  791. );
  792. TRACE_EVENT(rdev_dump_mpath,
  793. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
  794. u8 *dst, u8 *next_hop),
  795. TP_ARGS(wiphy, netdev, idx, dst, next_hop),
  796. TP_STRUCT__entry(
  797. WIPHY_ENTRY
  798. NETDEV_ENTRY
  799. MAC_ENTRY(dst)
  800. MAC_ENTRY(next_hop)
  801. __field(int, idx)
  802. ),
  803. TP_fast_assign(
  804. WIPHY_ASSIGN;
  805. NETDEV_ASSIGN;
  806. MAC_ASSIGN(dst, dst);
  807. MAC_ASSIGN(next_hop, next_hop);
  808. __entry->idx = idx;
  809. ),
  810. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
  811. MAC_PR_FMT ", next hop: " MAC_PR_FMT,
  812. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
  813. MAC_PR_ARG(next_hop))
  814. );
  815. TRACE_EVENT(rdev_get_mpp,
  816. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  817. u8 *dst, u8 *mpp),
  818. TP_ARGS(wiphy, netdev, dst, mpp),
  819. TP_STRUCT__entry(
  820. WIPHY_ENTRY
  821. NETDEV_ENTRY
  822. MAC_ENTRY(dst)
  823. MAC_ENTRY(mpp)
  824. ),
  825. TP_fast_assign(
  826. WIPHY_ASSIGN;
  827. NETDEV_ASSIGN;
  828. MAC_ASSIGN(dst, dst);
  829. MAC_ASSIGN(mpp, mpp);
  830. ),
  831. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT
  832. ", mpp: " MAC_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG,
  833. MAC_PR_ARG(dst), MAC_PR_ARG(mpp))
  834. );
  835. TRACE_EVENT(rdev_dump_mpp,
  836. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
  837. u8 *dst, u8 *mpp),
  838. TP_ARGS(wiphy, netdev, idx, mpp, dst),
  839. TP_STRUCT__entry(
  840. WIPHY_ENTRY
  841. NETDEV_ENTRY
  842. MAC_ENTRY(dst)
  843. MAC_ENTRY(mpp)
  844. __field(int, idx)
  845. ),
  846. TP_fast_assign(
  847. WIPHY_ASSIGN;
  848. NETDEV_ASSIGN;
  849. MAC_ASSIGN(dst, dst);
  850. MAC_ASSIGN(mpp, mpp);
  851. __entry->idx = idx;
  852. ),
  853. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
  854. MAC_PR_FMT ", mpp: " MAC_PR_FMT,
  855. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
  856. MAC_PR_ARG(mpp))
  857. );
  858. TRACE_EVENT(rdev_return_int_mpath_info,
  859. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
  860. TP_ARGS(wiphy, ret, pinfo),
  861. TP_STRUCT__entry(
  862. WIPHY_ENTRY
  863. __field(int, ret)
  864. __field(int, generation)
  865. __field(u32, filled)
  866. __field(u32, frame_qlen)
  867. __field(u32, sn)
  868. __field(u32, metric)
  869. __field(u32, exptime)
  870. __field(u32, discovery_timeout)
  871. __field(u8, discovery_retries)
  872. __field(u8, flags)
  873. ),
  874. TP_fast_assign(
  875. WIPHY_ASSIGN;
  876. __entry->ret = ret;
  877. __entry->generation = pinfo->generation;
  878. __entry->filled = pinfo->filled;
  879. __entry->frame_qlen = pinfo->frame_qlen;
  880. __entry->sn = pinfo->sn;
  881. __entry->metric = pinfo->metric;
  882. __entry->exptime = pinfo->exptime;
  883. __entry->discovery_timeout = pinfo->discovery_timeout;
  884. __entry->discovery_retries = pinfo->discovery_retries;
  885. __entry->flags = pinfo->flags;
  886. ),
  887. TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
  888. "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
  889. " discovery timeout: %u, discovery retries: %u, flags: %u",
  890. WIPHY_PR_ARG, __entry->ret, __entry->generation,
  891. __entry->filled, __entry->frame_qlen, __entry->sn,
  892. __entry->metric, __entry->exptime, __entry->discovery_timeout,
  893. __entry->discovery_retries, __entry->flags)
  894. );
  895. TRACE_EVENT(rdev_return_int_mesh_config,
  896. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
  897. TP_ARGS(wiphy, ret, conf),
  898. TP_STRUCT__entry(
  899. WIPHY_ENTRY
  900. MESH_CFG_ENTRY
  901. __field(int, ret)
  902. ),
  903. TP_fast_assign(
  904. WIPHY_ASSIGN;
  905. MESH_CFG_ASSIGN;
  906. __entry->ret = ret;
  907. ),
  908. TP_printk(WIPHY_PR_FMT ", returned: %d",
  909. WIPHY_PR_ARG, __entry->ret)
  910. );
  911. TRACE_EVENT(rdev_update_mesh_config,
  912. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
  913. const struct mesh_config *conf),
  914. TP_ARGS(wiphy, netdev, mask, conf),
  915. TP_STRUCT__entry(
  916. WIPHY_ENTRY
  917. NETDEV_ENTRY
  918. MESH_CFG_ENTRY
  919. __field(u32, mask)
  920. ),
  921. TP_fast_assign(
  922. WIPHY_ASSIGN;
  923. NETDEV_ASSIGN;
  924. MESH_CFG_ASSIGN;
  925. __entry->mask = mask;
  926. ),
  927. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
  928. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
  929. );
  930. TRACE_EVENT(rdev_join_mesh,
  931. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  932. const struct mesh_config *conf,
  933. const struct mesh_setup *setup),
  934. TP_ARGS(wiphy, netdev, conf, setup),
  935. TP_STRUCT__entry(
  936. WIPHY_ENTRY
  937. NETDEV_ENTRY
  938. MESH_CFG_ENTRY
  939. ),
  940. TP_fast_assign(
  941. WIPHY_ASSIGN;
  942. NETDEV_ASSIGN;
  943. MESH_CFG_ASSIGN;
  944. ),
  945. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
  946. WIPHY_PR_ARG, NETDEV_PR_ARG)
  947. );
  948. TRACE_EVENT(rdev_change_bss,
  949. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  950. struct bss_parameters *params),
  951. TP_ARGS(wiphy, netdev, params),
  952. TP_STRUCT__entry(
  953. WIPHY_ENTRY
  954. NETDEV_ENTRY
  955. __field(int, use_cts_prot)
  956. __field(int, use_short_preamble)
  957. __field(int, use_short_slot_time)
  958. __field(int, ap_isolate)
  959. __field(int, ht_opmode)
  960. ),
  961. TP_fast_assign(
  962. WIPHY_ASSIGN;
  963. NETDEV_ASSIGN;
  964. __entry->use_cts_prot = params->use_cts_prot;
  965. __entry->use_short_preamble = params->use_short_preamble;
  966. __entry->use_short_slot_time = params->use_short_slot_time;
  967. __entry->ap_isolate = params->ap_isolate;
  968. __entry->ht_opmode = params->ht_opmode;
  969. ),
  970. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
  971. "use short preamble: %d, use short slot time: %d, "
  972. "ap isolate: %d, ht opmode: %d",
  973. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
  974. __entry->use_short_preamble, __entry->use_short_slot_time,
  975. __entry->ap_isolate, __entry->ht_opmode)
  976. );
  977. TRACE_EVENT(rdev_set_txq_params,
  978. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  979. struct ieee80211_txq_params *params),
  980. TP_ARGS(wiphy, netdev, params),
  981. TP_STRUCT__entry(
  982. WIPHY_ENTRY
  983. NETDEV_ENTRY
  984. __field(enum nl80211_ac, ac)
  985. __field(u16, txop)
  986. __field(u16, cwmin)
  987. __field(u16, cwmax)
  988. __field(u8, aifs)
  989. ),
  990. TP_fast_assign(
  991. WIPHY_ASSIGN;
  992. NETDEV_ASSIGN;
  993. __entry->ac = params->ac;
  994. __entry->txop = params->txop;
  995. __entry->cwmin = params->cwmin;
  996. __entry->cwmax = params->cwmax;
  997. __entry->aifs = params->aifs;
  998. ),
  999. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
  1000. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
  1001. __entry->cwmin, __entry->cwmax, __entry->aifs)
  1002. );
  1003. TRACE_EVENT(rdev_libertas_set_mesh_channel,
  1004. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1005. struct ieee80211_channel *chan),
  1006. TP_ARGS(wiphy, netdev, chan),
  1007. TP_STRUCT__entry(
  1008. WIPHY_ENTRY
  1009. NETDEV_ENTRY
  1010. CHAN_ENTRY
  1011. ),
  1012. TP_fast_assign(
  1013. WIPHY_ASSIGN;
  1014. NETDEV_ASSIGN;
  1015. CHAN_ASSIGN(chan);
  1016. ),
  1017. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
  1018. NETDEV_PR_ARG, CHAN_PR_ARG)
  1019. );
  1020. TRACE_EVENT(rdev_set_monitor_channel,
  1021. TP_PROTO(struct wiphy *wiphy,
  1022. struct cfg80211_chan_def *chandef),
  1023. TP_ARGS(wiphy, chandef),
  1024. TP_STRUCT__entry(
  1025. WIPHY_ENTRY
  1026. CHAN_DEF_ENTRY
  1027. ),
  1028. TP_fast_assign(
  1029. WIPHY_ASSIGN;
  1030. CHAN_DEF_ASSIGN(chandef);
  1031. ),
  1032. TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
  1033. WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
  1034. );
  1035. TRACE_EVENT(rdev_auth,
  1036. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1037. struct cfg80211_auth_request *req),
  1038. TP_ARGS(wiphy, netdev, req),
  1039. TP_STRUCT__entry(
  1040. WIPHY_ENTRY
  1041. NETDEV_ENTRY
  1042. MAC_ENTRY(bssid)
  1043. __field(enum nl80211_auth_type, auth_type)
  1044. ),
  1045. TP_fast_assign(
  1046. WIPHY_ASSIGN;
  1047. NETDEV_ASSIGN;
  1048. if (req->bss)
  1049. MAC_ASSIGN(bssid, req->bss->bssid);
  1050. else
  1051. eth_zero_addr(__entry->bssid);
  1052. __entry->auth_type = req->auth_type;
  1053. ),
  1054. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: " MAC_PR_FMT,
  1055. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
  1056. MAC_PR_ARG(bssid))
  1057. );
  1058. TRACE_EVENT(rdev_assoc,
  1059. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1060. struct cfg80211_assoc_request *req),
  1061. TP_ARGS(wiphy, netdev, req),
  1062. TP_STRUCT__entry(
  1063. WIPHY_ENTRY
  1064. NETDEV_ENTRY
  1065. MAC_ENTRY(bssid)
  1066. MAC_ENTRY(prev_bssid)
  1067. __field(bool, use_mfp)
  1068. __field(u32, flags)
  1069. ),
  1070. TP_fast_assign(
  1071. WIPHY_ASSIGN;
  1072. NETDEV_ASSIGN;
  1073. if (req->bss)
  1074. MAC_ASSIGN(bssid, req->bss->bssid);
  1075. else
  1076. eth_zero_addr(__entry->bssid);
  1077. MAC_ASSIGN(prev_bssid, req->prev_bssid);
  1078. __entry->use_mfp = req->use_mfp;
  1079. __entry->flags = req->flags;
  1080. ),
  1081. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
  1082. ", previous bssid: " MAC_PR_FMT ", use mfp: %s, flags: %u",
  1083. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
  1084. MAC_PR_ARG(prev_bssid), BOOL_TO_STR(__entry->use_mfp),
  1085. __entry->flags)
  1086. );
  1087. TRACE_EVENT(rdev_deauth,
  1088. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1089. struct cfg80211_deauth_request *req),
  1090. TP_ARGS(wiphy, netdev, req),
  1091. TP_STRUCT__entry(
  1092. WIPHY_ENTRY
  1093. NETDEV_ENTRY
  1094. MAC_ENTRY(bssid)
  1095. __field(u16, reason_code)
  1096. ),
  1097. TP_fast_assign(
  1098. WIPHY_ASSIGN;
  1099. NETDEV_ASSIGN;
  1100. MAC_ASSIGN(bssid, req->bssid);
  1101. __entry->reason_code = req->reason_code;
  1102. ),
  1103. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", reason: %u",
  1104. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
  1105. __entry->reason_code)
  1106. );
  1107. TRACE_EVENT(rdev_disassoc,
  1108. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1109. struct cfg80211_disassoc_request *req),
  1110. TP_ARGS(wiphy, netdev, req),
  1111. TP_STRUCT__entry(
  1112. WIPHY_ENTRY
  1113. NETDEV_ENTRY
  1114. MAC_ENTRY(bssid)
  1115. __field(u16, reason_code)
  1116. __field(bool, local_state_change)
  1117. ),
  1118. TP_fast_assign(
  1119. WIPHY_ASSIGN;
  1120. NETDEV_ASSIGN;
  1121. if (req->bss)
  1122. MAC_ASSIGN(bssid, req->bss->bssid);
  1123. else
  1124. eth_zero_addr(__entry->bssid);
  1125. __entry->reason_code = req->reason_code;
  1126. __entry->local_state_change = req->local_state_change;
  1127. ),
  1128. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
  1129. ", reason: %u, local state change: %s",
  1130. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
  1131. __entry->reason_code,
  1132. BOOL_TO_STR(__entry->local_state_change))
  1133. );
  1134. TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
  1135. TP_PROTO(struct wiphy *wiphy,
  1136. struct wireless_dev *wdev, u64 cookie),
  1137. TP_ARGS(wiphy, wdev, cookie),
  1138. TP_STRUCT__entry(
  1139. WIPHY_ENTRY
  1140. WDEV_ENTRY
  1141. __field(u64, cookie)
  1142. ),
  1143. TP_fast_assign(
  1144. WIPHY_ASSIGN;
  1145. WDEV_ASSIGN;
  1146. __entry->cookie = cookie;
  1147. ),
  1148. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ",
  1149. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
  1150. );
  1151. TRACE_EVENT(rdev_set_power_mgmt,
  1152. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1153. bool enabled, int timeout),
  1154. TP_ARGS(wiphy, netdev, enabled, timeout),
  1155. TP_STRUCT__entry(
  1156. WIPHY_ENTRY
  1157. NETDEV_ENTRY
  1158. __field(bool, enabled)
  1159. __field(int, timeout)
  1160. ),
  1161. TP_fast_assign(
  1162. WIPHY_ASSIGN;
  1163. NETDEV_ASSIGN;
  1164. __entry->enabled = enabled;
  1165. __entry->timeout = timeout;
  1166. ),
  1167. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ",
  1168. WIPHY_PR_ARG, NETDEV_PR_ARG,
  1169. __entry->enabled ? "" : "not ", __entry->timeout)
  1170. );
  1171. TRACE_EVENT(rdev_connect,
  1172. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1173. struct cfg80211_connect_params *sme),
  1174. TP_ARGS(wiphy, netdev, sme),
  1175. TP_STRUCT__entry(
  1176. WIPHY_ENTRY
  1177. NETDEV_ENTRY
  1178. MAC_ENTRY(bssid)
  1179. __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
  1180. __field(enum nl80211_auth_type, auth_type)
  1181. __field(bool, privacy)
  1182. __field(u32, wpa_versions)
  1183. __field(u32, flags)
  1184. MAC_ENTRY(prev_bssid)
  1185. ),
  1186. TP_fast_assign(
  1187. WIPHY_ASSIGN;
  1188. NETDEV_ASSIGN;
  1189. MAC_ASSIGN(bssid, sme->bssid);
  1190. memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  1191. memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
  1192. __entry->auth_type = sme->auth_type;
  1193. __entry->privacy = sme->privacy;
  1194. __entry->wpa_versions = sme->crypto.wpa_versions;
  1195. __entry->flags = sme->flags;
  1196. MAC_ASSIGN(prev_bssid, sme->prev_bssid);
  1197. ),
  1198. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
  1199. ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
  1200. "flags: %u, previous bssid: " MAC_PR_FMT,
  1201. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid,
  1202. __entry->auth_type, BOOL_TO_STR(__entry->privacy),
  1203. __entry->wpa_versions, __entry->flags, MAC_PR_ARG(prev_bssid))
  1204. );
  1205. TRACE_EVENT(rdev_update_connect_params,
  1206. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1207. struct cfg80211_connect_params *sme, u32 changed),
  1208. TP_ARGS(wiphy, netdev, sme, changed),
  1209. TP_STRUCT__entry(
  1210. WIPHY_ENTRY
  1211. NETDEV_ENTRY
  1212. __field(u32, changed)
  1213. ),
  1214. TP_fast_assign(
  1215. WIPHY_ASSIGN;
  1216. NETDEV_ASSIGN;
  1217. __entry->changed = changed;
  1218. ),
  1219. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u",
  1220. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->changed)
  1221. );
  1222. TRACE_EVENT(rdev_set_cqm_rssi_config,
  1223. TP_PROTO(struct wiphy *wiphy,
  1224. struct net_device *netdev, s32 rssi_thold,
  1225. u32 rssi_hyst),
  1226. TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
  1227. TP_STRUCT__entry(
  1228. WIPHY_ENTRY
  1229. NETDEV_ENTRY
  1230. __field(s32, rssi_thold)
  1231. __field(u32, rssi_hyst)
  1232. ),
  1233. TP_fast_assign(
  1234. WIPHY_ASSIGN;
  1235. NETDEV_ASSIGN;
  1236. __entry->rssi_thold = rssi_thold;
  1237. __entry->rssi_hyst = rssi_hyst;
  1238. ),
  1239. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
  1240. ", rssi_thold: %d, rssi_hyst: %u ",
  1241. WIPHY_PR_ARG, NETDEV_PR_ARG,
  1242. __entry->rssi_thold, __entry->rssi_hyst)
  1243. );
  1244. TRACE_EVENT(rdev_set_cqm_rssi_range_config,
  1245. TP_PROTO(struct wiphy *wiphy,
  1246. struct net_device *netdev, s32 low, s32 high),
  1247. TP_ARGS(wiphy, netdev, low, high),
  1248. TP_STRUCT__entry(
  1249. WIPHY_ENTRY
  1250. NETDEV_ENTRY
  1251. __field(s32, rssi_low)
  1252. __field(s32, rssi_high)
  1253. ),
  1254. TP_fast_assign(
  1255. WIPHY_ASSIGN;
  1256. NETDEV_ASSIGN;
  1257. __entry->rssi_low = low;
  1258. __entry->rssi_high = high;
  1259. ),
  1260. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
  1261. ", range: %d - %d ",
  1262. WIPHY_PR_ARG, NETDEV_PR_ARG,
  1263. __entry->rssi_low, __entry->rssi_high)
  1264. );
  1265. TRACE_EVENT(rdev_set_cqm_txe_config,
  1266. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
  1267. u32 pkts, u32 intvl),
  1268. TP_ARGS(wiphy, netdev, rate, pkts, intvl),
  1269. TP_STRUCT__entry(
  1270. WIPHY_ENTRY
  1271. NETDEV_ENTRY
  1272. __field(u32, rate)
  1273. __field(u32, pkts)
  1274. __field(u32, intvl)
  1275. ),
  1276. TP_fast_assign(
  1277. WIPHY_ASSIGN;
  1278. NETDEV_ASSIGN;
  1279. __entry->rate = rate;
  1280. __entry->pkts = pkts;
  1281. __entry->intvl = intvl;
  1282. ),
  1283. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
  1284. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
  1285. __entry->intvl)
  1286. );
  1287. TRACE_EVENT(rdev_disconnect,
  1288. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1289. u16 reason_code),
  1290. TP_ARGS(wiphy, netdev, reason_code),
  1291. TP_STRUCT__entry(
  1292. WIPHY_ENTRY
  1293. NETDEV_ENTRY
  1294. __field(u16, reason_code)
  1295. ),
  1296. TP_fast_assign(
  1297. WIPHY_ASSIGN;
  1298. NETDEV_ASSIGN;
  1299. __entry->reason_code = reason_code;
  1300. ),
  1301. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
  1302. NETDEV_PR_ARG, __entry->reason_code)
  1303. );
  1304. TRACE_EVENT(rdev_join_ibss,
  1305. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1306. struct cfg80211_ibss_params *params),
  1307. TP_ARGS(wiphy, netdev, params),
  1308. TP_STRUCT__entry(
  1309. WIPHY_ENTRY
  1310. NETDEV_ENTRY
  1311. MAC_ENTRY(bssid)
  1312. __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
  1313. ),
  1314. TP_fast_assign(
  1315. WIPHY_ASSIGN;
  1316. NETDEV_ASSIGN;
  1317. MAC_ASSIGN(bssid, params->bssid);
  1318. memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  1319. memcpy(__entry->ssid, params->ssid, params->ssid_len);
  1320. ),
  1321. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", ssid: %s",
  1322. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid)
  1323. );
  1324. TRACE_EVENT(rdev_join_ocb,
  1325. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1326. const struct ocb_setup *setup),
  1327. TP_ARGS(wiphy, netdev, setup),
  1328. TP_STRUCT__entry(
  1329. WIPHY_ENTRY
  1330. NETDEV_ENTRY
  1331. ),
  1332. TP_fast_assign(
  1333. WIPHY_ASSIGN;
  1334. NETDEV_ASSIGN;
  1335. ),
  1336. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
  1337. WIPHY_PR_ARG, NETDEV_PR_ARG)
  1338. );
  1339. TRACE_EVENT(rdev_set_wiphy_params,
  1340. TP_PROTO(struct wiphy *wiphy, u32 changed),
  1341. TP_ARGS(wiphy, changed),
  1342. TP_STRUCT__entry(
  1343. WIPHY_ENTRY
  1344. __field(u32, changed)
  1345. ),
  1346. TP_fast_assign(
  1347. WIPHY_ASSIGN;
  1348. __entry->changed = changed;
  1349. ),
  1350. TP_printk(WIPHY_PR_FMT ", changed: %u",
  1351. WIPHY_PR_ARG, __entry->changed)
  1352. );
  1353. DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power,
  1354. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1355. TP_ARGS(wiphy, wdev)
  1356. );
  1357. TRACE_EVENT(rdev_set_tx_power,
  1358. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1359. enum nl80211_tx_power_setting type, int mbm),
  1360. TP_ARGS(wiphy, wdev, type, mbm),
  1361. TP_STRUCT__entry(
  1362. WIPHY_ENTRY
  1363. WDEV_ENTRY
  1364. __field(enum nl80211_tx_power_setting, type)
  1365. __field(int, mbm)
  1366. ),
  1367. TP_fast_assign(
  1368. WIPHY_ASSIGN;
  1369. WDEV_ASSIGN;
  1370. __entry->type = type;
  1371. __entry->mbm = mbm;
  1372. ),
  1373. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d",
  1374. WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm)
  1375. );
  1376. TRACE_EVENT(rdev_return_int_int,
  1377. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
  1378. TP_ARGS(wiphy, func_ret, func_fill),
  1379. TP_STRUCT__entry(
  1380. WIPHY_ENTRY
  1381. __field(int, func_ret)
  1382. __field(int, func_fill)
  1383. ),
  1384. TP_fast_assign(
  1385. WIPHY_ASSIGN;
  1386. __entry->func_ret = func_ret;
  1387. __entry->func_fill = func_fill;
  1388. ),
  1389. TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
  1390. WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
  1391. );
  1392. #ifdef CONFIG_NL80211_TESTMODE
  1393. TRACE_EVENT(rdev_testmode_cmd,
  1394. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1395. TP_ARGS(wiphy, wdev),
  1396. TP_STRUCT__entry(
  1397. WIPHY_ENTRY
  1398. WDEV_ENTRY
  1399. ),
  1400. TP_fast_assign(
  1401. WIPHY_ASSIGN;
  1402. WDEV_ASSIGN;
  1403. ),
  1404. TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
  1405. );
  1406. TRACE_EVENT(rdev_testmode_dump,
  1407. TP_PROTO(struct wiphy *wiphy),
  1408. TP_ARGS(wiphy),
  1409. TP_STRUCT__entry(
  1410. WIPHY_ENTRY
  1411. ),
  1412. TP_fast_assign(
  1413. WIPHY_ASSIGN;
  1414. ),
  1415. TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
  1416. );
  1417. #endif /* CONFIG_NL80211_TESTMODE */
  1418. TRACE_EVENT(rdev_set_bitrate_mask,
  1419. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1420. const u8 *peer, const struct cfg80211_bitrate_mask *mask),
  1421. TP_ARGS(wiphy, netdev, peer, mask),
  1422. TP_STRUCT__entry(
  1423. WIPHY_ENTRY
  1424. NETDEV_ENTRY
  1425. MAC_ENTRY(peer)
  1426. ),
  1427. TP_fast_assign(
  1428. WIPHY_ASSIGN;
  1429. NETDEV_ASSIGN;
  1430. MAC_ASSIGN(peer, peer);
  1431. ),
  1432. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
  1433. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
  1434. );
  1435. TRACE_EVENT(rdev_mgmt_frame_register,
  1436. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1437. u16 frame_type, bool reg),
  1438. TP_ARGS(wiphy, wdev, frame_type, reg),
  1439. TP_STRUCT__entry(
  1440. WIPHY_ENTRY
  1441. WDEV_ENTRY
  1442. __field(u16, frame_type)
  1443. __field(bool, reg)
  1444. ),
  1445. TP_fast_assign(
  1446. WIPHY_ASSIGN;
  1447. WDEV_ASSIGN;
  1448. __entry->frame_type = frame_type;
  1449. __entry->reg = reg;
  1450. ),
  1451. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", frame_type: 0x%.2x, reg: %s ",
  1452. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->frame_type,
  1453. __entry->reg ? "true" : "false")
  1454. );
  1455. TRACE_EVENT(rdev_return_int_tx_rx,
  1456. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
  1457. TP_ARGS(wiphy, ret, tx, rx),
  1458. TP_STRUCT__entry(
  1459. WIPHY_ENTRY
  1460. __field(int, ret)
  1461. __field(u32, tx)
  1462. __field(u32, rx)
  1463. ),
  1464. TP_fast_assign(
  1465. WIPHY_ASSIGN;
  1466. __entry->ret = ret;
  1467. __entry->tx = tx;
  1468. __entry->rx = rx;
  1469. ),
  1470. TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
  1471. WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
  1472. );
  1473. TRACE_EVENT(rdev_return_void_tx_rx,
  1474. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
  1475. u32 rx, u32 rx_max),
  1476. TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
  1477. TP_STRUCT__entry(
  1478. WIPHY_ENTRY
  1479. __field(u32, tx)
  1480. __field(u32, tx_max)
  1481. __field(u32, rx)
  1482. __field(u32, rx_max)
  1483. ),
  1484. TP_fast_assign(
  1485. WIPHY_ASSIGN;
  1486. __entry->tx = tx;
  1487. __entry->tx_max = tx_max;
  1488. __entry->rx = rx;
  1489. __entry->rx_max = rx_max;
  1490. ),
  1491. TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
  1492. WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
  1493. __entry->rx_max)
  1494. );
  1495. DECLARE_EVENT_CLASS(tx_rx_evt,
  1496. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
  1497. TP_ARGS(wiphy, rx, tx),
  1498. TP_STRUCT__entry(
  1499. WIPHY_ENTRY
  1500. __field(u32, tx)
  1501. __field(u32, rx)
  1502. ),
  1503. TP_fast_assign(
  1504. WIPHY_ASSIGN;
  1505. __entry->tx = tx;
  1506. __entry->rx = rx;
  1507. ),
  1508. TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ",
  1509. WIPHY_PR_ARG, __entry->tx, __entry->rx)
  1510. );
  1511. DEFINE_EVENT(tx_rx_evt, rdev_set_antenna,
  1512. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
  1513. TP_ARGS(wiphy, rx, tx)
  1514. );
  1515. DECLARE_EVENT_CLASS(wiphy_netdev_id_evt,
  1516. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
  1517. TP_ARGS(wiphy, netdev, id),
  1518. TP_STRUCT__entry(
  1519. WIPHY_ENTRY
  1520. NETDEV_ENTRY
  1521. __field(u64, id)
  1522. ),
  1523. TP_fast_assign(
  1524. WIPHY_ASSIGN;
  1525. NETDEV_ASSIGN;
  1526. __entry->id = id;
  1527. ),
  1528. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu",
  1529. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id)
  1530. );
  1531. DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start,
  1532. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
  1533. TP_ARGS(wiphy, netdev, id)
  1534. );
  1535. DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop,
  1536. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
  1537. TP_ARGS(wiphy, netdev, id)
  1538. );
  1539. TRACE_EVENT(rdev_tdls_mgmt,
  1540. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1541. u8 *peer, u8 action_code, u8 dialog_token,
  1542. u16 status_code, u32 peer_capability,
  1543. bool initiator, const u8 *buf, size_t len),
  1544. TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code,
  1545. peer_capability, initiator, buf, len),
  1546. TP_STRUCT__entry(
  1547. WIPHY_ENTRY
  1548. NETDEV_ENTRY
  1549. MAC_ENTRY(peer)
  1550. __field(u8, action_code)
  1551. __field(u8, dialog_token)
  1552. __field(u16, status_code)
  1553. __field(u32, peer_capability)
  1554. __field(bool, initiator)
  1555. __dynamic_array(u8, buf, len)
  1556. ),
  1557. TP_fast_assign(
  1558. WIPHY_ASSIGN;
  1559. NETDEV_ASSIGN;
  1560. MAC_ASSIGN(peer, peer);
  1561. __entry->action_code = action_code;
  1562. __entry->dialog_token = dialog_token;
  1563. __entry->status_code = status_code;
  1564. __entry->peer_capability = peer_capability;
  1565. __entry->initiator = initiator;
  1566. memcpy(__get_dynamic_array(buf), buf, len);
  1567. ),
  1568. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", action_code: %u, "
  1569. "dialog_token: %u, status_code: %u, peer_capability: %u "
  1570. "initiator: %s buf: %#.2x ",
  1571. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
  1572. __entry->action_code, __entry->dialog_token,
  1573. __entry->status_code, __entry->peer_capability,
  1574. BOOL_TO_STR(__entry->initiator),
  1575. ((u8 *)__get_dynamic_array(buf))[0])
  1576. );
  1577. TRACE_EVENT(rdev_dump_survey,
  1578. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx),
  1579. TP_ARGS(wiphy, netdev, idx),
  1580. TP_STRUCT__entry(
  1581. WIPHY_ENTRY
  1582. NETDEV_ENTRY
  1583. __field(int, idx)
  1584. ),
  1585. TP_fast_assign(
  1586. WIPHY_ASSIGN;
  1587. NETDEV_ASSIGN;
  1588. __entry->idx = idx;
  1589. ),
  1590. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d",
  1591. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
  1592. );
  1593. TRACE_EVENT(rdev_return_int_survey_info,
  1594. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
  1595. TP_ARGS(wiphy, ret, info),
  1596. TP_STRUCT__entry(
  1597. WIPHY_ENTRY
  1598. CHAN_ENTRY
  1599. __field(int, ret)
  1600. __field(u64, time)
  1601. __field(u64, time_busy)
  1602. __field(u64, time_ext_busy)
  1603. __field(u64, time_rx)
  1604. __field(u64, time_tx)
  1605. __field(u64, time_scan)
  1606. __field(u32, filled)
  1607. __field(s8, noise)
  1608. ),
  1609. TP_fast_assign(
  1610. WIPHY_ASSIGN;
  1611. CHAN_ASSIGN(info->channel);
  1612. __entry->ret = ret;
  1613. __entry->time = info->time;
  1614. __entry->time_busy = info->time_busy;
  1615. __entry->time_ext_busy = info->time_ext_busy;
  1616. __entry->time_rx = info->time_rx;
  1617. __entry->time_tx = info->time_tx;
  1618. __entry->time_scan = info->time_scan;
  1619. __entry->filled = info->filled;
  1620. __entry->noise = info->noise;
  1621. ),
  1622. TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
  1623. ", channel time: %llu, channel time busy: %llu, "
  1624. "channel time extension busy: %llu, channel time rx: %llu, "
  1625. "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d",
  1626. WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
  1627. __entry->time, __entry->time_busy,
  1628. __entry->time_ext_busy, __entry->time_rx,
  1629. __entry->time_tx, __entry->time_scan,
  1630. __entry->filled, __entry->noise)
  1631. );
  1632. TRACE_EVENT(rdev_tdls_oper,
  1633. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1634. u8 *peer, enum nl80211_tdls_operation oper),
  1635. TP_ARGS(wiphy, netdev, peer, oper),
  1636. TP_STRUCT__entry(
  1637. WIPHY_ENTRY
  1638. NETDEV_ENTRY
  1639. MAC_ENTRY(peer)
  1640. __field(enum nl80211_tdls_operation, oper)
  1641. ),
  1642. TP_fast_assign(
  1643. WIPHY_ASSIGN;
  1644. NETDEV_ASSIGN;
  1645. MAC_ASSIGN(peer, peer);
  1646. __entry->oper = oper;
  1647. ),
  1648. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", oper: %d",
  1649. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper)
  1650. );
  1651. DECLARE_EVENT_CLASS(rdev_pmksa,
  1652. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1653. struct cfg80211_pmksa *pmksa),
  1654. TP_ARGS(wiphy, netdev, pmksa),
  1655. TP_STRUCT__entry(
  1656. WIPHY_ENTRY
  1657. NETDEV_ENTRY
  1658. MAC_ENTRY(bssid)
  1659. ),
  1660. TP_fast_assign(
  1661. WIPHY_ASSIGN;
  1662. NETDEV_ASSIGN;
  1663. MAC_ASSIGN(bssid, pmksa->bssid);
  1664. ),
  1665. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT,
  1666. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid))
  1667. );
  1668. TRACE_EVENT(rdev_probe_client,
  1669. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1670. const u8 *peer),
  1671. TP_ARGS(wiphy, netdev, peer),
  1672. TP_STRUCT__entry(
  1673. WIPHY_ENTRY
  1674. NETDEV_ENTRY
  1675. MAC_ENTRY(peer)
  1676. ),
  1677. TP_fast_assign(
  1678. WIPHY_ASSIGN;
  1679. NETDEV_ASSIGN;
  1680. MAC_ASSIGN(peer, peer);
  1681. ),
  1682. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
  1683. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
  1684. );
  1685. DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
  1686. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1687. struct cfg80211_pmksa *pmksa),
  1688. TP_ARGS(wiphy, netdev, pmksa)
  1689. );
  1690. DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
  1691. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1692. struct cfg80211_pmksa *pmksa),
  1693. TP_ARGS(wiphy, netdev, pmksa)
  1694. );
  1695. TRACE_EVENT(rdev_remain_on_channel,
  1696. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1697. struct ieee80211_channel *chan,
  1698. unsigned int duration),
  1699. TP_ARGS(wiphy, wdev, chan, duration),
  1700. TP_STRUCT__entry(
  1701. WIPHY_ENTRY
  1702. WDEV_ENTRY
  1703. CHAN_ENTRY
  1704. __field(unsigned int, duration)
  1705. ),
  1706. TP_fast_assign(
  1707. WIPHY_ASSIGN;
  1708. WDEV_ASSIGN;
  1709. CHAN_ASSIGN(chan);
  1710. __entry->duration = duration;
  1711. ),
  1712. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u",
  1713. WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration)
  1714. );
  1715. TRACE_EVENT(rdev_return_int_cookie,
  1716. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
  1717. TP_ARGS(wiphy, ret, cookie),
  1718. TP_STRUCT__entry(
  1719. WIPHY_ENTRY
  1720. __field(int, ret)
  1721. __field(u64, cookie)
  1722. ),
  1723. TP_fast_assign(
  1724. WIPHY_ASSIGN;
  1725. __entry->ret = ret;
  1726. __entry->cookie = cookie;
  1727. ),
  1728. TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
  1729. WIPHY_PR_ARG, __entry->ret, __entry->cookie)
  1730. );
  1731. TRACE_EVENT(rdev_cancel_remain_on_channel,
  1732. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
  1733. TP_ARGS(wiphy, wdev, cookie),
  1734. TP_STRUCT__entry(
  1735. WIPHY_ENTRY
  1736. WDEV_ENTRY
  1737. __field(u64, cookie)
  1738. ),
  1739. TP_fast_assign(
  1740. WIPHY_ASSIGN;
  1741. WDEV_ASSIGN;
  1742. __entry->cookie = cookie;
  1743. ),
  1744. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu",
  1745. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
  1746. );
  1747. TRACE_EVENT(rdev_mgmt_tx,
  1748. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1749. struct cfg80211_mgmt_tx_params *params),
  1750. TP_ARGS(wiphy, wdev, params),
  1751. TP_STRUCT__entry(
  1752. WIPHY_ENTRY
  1753. WDEV_ENTRY
  1754. CHAN_ENTRY
  1755. __field(bool, offchan)
  1756. __field(unsigned int, wait)
  1757. __field(bool, no_cck)
  1758. __field(bool, dont_wait_for_ack)
  1759. ),
  1760. TP_fast_assign(
  1761. WIPHY_ASSIGN;
  1762. WDEV_ASSIGN;
  1763. CHAN_ASSIGN(params->chan);
  1764. __entry->offchan = params->offchan;
  1765. __entry->wait = params->wait;
  1766. __entry->no_cck = params->no_cck;
  1767. __entry->dont_wait_for_ack = params->dont_wait_for_ack;
  1768. ),
  1769. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
  1770. " wait: %u, no cck: %s, dont wait for ack: %s",
  1771. WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
  1772. BOOL_TO_STR(__entry->offchan), __entry->wait,
  1773. BOOL_TO_STR(__entry->no_cck),
  1774. BOOL_TO_STR(__entry->dont_wait_for_ack))
  1775. );
  1776. TRACE_EVENT(rdev_tx_control_port,
  1777. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1778. const u8 *buf, size_t len, const u8 *dest, __be16 proto,
  1779. bool unencrypted),
  1780. TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted),
  1781. TP_STRUCT__entry(
  1782. WIPHY_ENTRY
  1783. NETDEV_ENTRY
  1784. MAC_ENTRY(dest)
  1785. __field(__be16, proto)
  1786. __field(bool, unencrypted)
  1787. ),
  1788. TP_fast_assign(
  1789. WIPHY_ASSIGN;
  1790. NETDEV_ASSIGN;
  1791. MAC_ASSIGN(dest, dest);
  1792. __entry->proto = proto;
  1793. __entry->unencrypted = unencrypted;
  1794. ),
  1795. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ","
  1796. " proto: 0x%x, unencrypted: %s",
  1797. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dest),
  1798. be16_to_cpu(__entry->proto),
  1799. BOOL_TO_STR(__entry->unencrypted))
  1800. );
  1801. TRACE_EVENT(rdev_set_noack_map,
  1802. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1803. u16 noack_map),
  1804. TP_ARGS(wiphy, netdev, noack_map),
  1805. TP_STRUCT__entry(
  1806. WIPHY_ENTRY
  1807. NETDEV_ENTRY
  1808. __field(u16, noack_map)
  1809. ),
  1810. TP_fast_assign(
  1811. WIPHY_ASSIGN;
  1812. NETDEV_ASSIGN;
  1813. __entry->noack_map = noack_map;
  1814. ),
  1815. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u",
  1816. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
  1817. );
  1818. DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel,
  1819. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1820. TP_ARGS(wiphy, wdev)
  1821. );
  1822. TRACE_EVENT(rdev_return_chandef,
  1823. TP_PROTO(struct wiphy *wiphy, int ret,
  1824. struct cfg80211_chan_def *chandef),
  1825. TP_ARGS(wiphy, ret, chandef),
  1826. TP_STRUCT__entry(
  1827. WIPHY_ENTRY
  1828. __field(int, ret)
  1829. CHAN_DEF_ENTRY
  1830. ),
  1831. TP_fast_assign(
  1832. WIPHY_ASSIGN;
  1833. if (ret == 0)
  1834. CHAN_DEF_ASSIGN(chandef);
  1835. else
  1836. CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL);
  1837. __entry->ret = ret;
  1838. ),
  1839. TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d",
  1840. WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret)
  1841. );
  1842. DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device,
  1843. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1844. TP_ARGS(wiphy, wdev)
  1845. );
  1846. DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device,
  1847. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1848. TP_ARGS(wiphy, wdev)
  1849. );
  1850. TRACE_EVENT(rdev_start_nan,
  1851. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1852. struct cfg80211_nan_conf *conf),
  1853. TP_ARGS(wiphy, wdev, conf),
  1854. TP_STRUCT__entry(
  1855. WIPHY_ENTRY
  1856. WDEV_ENTRY
  1857. __field(u8, master_pref)
  1858. __field(u8, bands);
  1859. ),
  1860. TP_fast_assign(
  1861. WIPHY_ASSIGN;
  1862. WDEV_ASSIGN;
  1863. __entry->master_pref = conf->master_pref;
  1864. __entry->bands = conf->bands;
  1865. ),
  1866. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
  1867. ", master preference: %u, bands: 0x%0x",
  1868. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
  1869. __entry->bands)
  1870. );
  1871. TRACE_EVENT(rdev_nan_change_conf,
  1872. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1873. struct cfg80211_nan_conf *conf, u32 changes),
  1874. TP_ARGS(wiphy, wdev, conf, changes),
  1875. TP_STRUCT__entry(
  1876. WIPHY_ENTRY
  1877. WDEV_ENTRY
  1878. __field(u8, master_pref)
  1879. __field(u8, bands);
  1880. __field(u32, changes);
  1881. ),
  1882. TP_fast_assign(
  1883. WIPHY_ASSIGN;
  1884. WDEV_ASSIGN;
  1885. __entry->master_pref = conf->master_pref;
  1886. __entry->bands = conf->bands;
  1887. __entry->changes = changes;
  1888. ),
  1889. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
  1890. ", master preference: %u, bands: 0x%0x, changes: %x",
  1891. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
  1892. __entry->bands, __entry->changes)
  1893. );
  1894. DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan,
  1895. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1896. TP_ARGS(wiphy, wdev)
  1897. );
  1898. TRACE_EVENT(rdev_add_nan_func,
  1899. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1900. const struct cfg80211_nan_func *func),
  1901. TP_ARGS(wiphy, wdev, func),
  1902. TP_STRUCT__entry(
  1903. WIPHY_ENTRY
  1904. WDEV_ENTRY
  1905. __field(u8, func_type)
  1906. __field(u64, cookie)
  1907. ),
  1908. TP_fast_assign(
  1909. WIPHY_ASSIGN;
  1910. WDEV_ASSIGN;
  1911. __entry->func_type = func->type;
  1912. __entry->cookie = func->cookie
  1913. ),
  1914. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu",
  1915. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type,
  1916. __entry->cookie)
  1917. );
  1918. TRACE_EVENT(rdev_del_nan_func,
  1919. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1920. u64 cookie),
  1921. TP_ARGS(wiphy, wdev, cookie),
  1922. TP_STRUCT__entry(
  1923. WIPHY_ENTRY
  1924. WDEV_ENTRY
  1925. __field(u64, cookie)
  1926. ),
  1927. TP_fast_assign(
  1928. WIPHY_ASSIGN;
  1929. WDEV_ASSIGN;
  1930. __entry->cookie = cookie;
  1931. ),
  1932. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu",
  1933. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
  1934. );
  1935. TRACE_EVENT(rdev_set_mac_acl,
  1936. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1937. struct cfg80211_acl_data *params),
  1938. TP_ARGS(wiphy, netdev, params),
  1939. TP_STRUCT__entry(
  1940. WIPHY_ENTRY
  1941. NETDEV_ENTRY
  1942. __field(u32, acl_policy)
  1943. ),
  1944. TP_fast_assign(
  1945. WIPHY_ASSIGN;
  1946. NETDEV_ASSIGN;
  1947. __entry->acl_policy = params->acl_policy;
  1948. ),
  1949. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d",
  1950. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy)
  1951. );
  1952. TRACE_EVENT(rdev_update_ft_ies,
  1953. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  1954. struct cfg80211_update_ft_ies_params *ftie),
  1955. TP_ARGS(wiphy, netdev, ftie),
  1956. TP_STRUCT__entry(
  1957. WIPHY_ENTRY
  1958. NETDEV_ENTRY
  1959. __field(u16, md)
  1960. __dynamic_array(u8, ie, ftie->ie_len)
  1961. ),
  1962. TP_fast_assign(
  1963. WIPHY_ASSIGN;
  1964. NETDEV_ASSIGN;
  1965. __entry->md = ftie->md;
  1966. memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len);
  1967. ),
  1968. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x",
  1969. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md)
  1970. );
  1971. TRACE_EVENT(rdev_crit_proto_start,
  1972. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  1973. enum nl80211_crit_proto_id protocol, u16 duration),
  1974. TP_ARGS(wiphy, wdev, protocol, duration),
  1975. TP_STRUCT__entry(
  1976. WIPHY_ENTRY
  1977. WDEV_ENTRY
  1978. __field(u16, proto)
  1979. __field(u16, duration)
  1980. ),
  1981. TP_fast_assign(
  1982. WIPHY_ASSIGN;
  1983. WDEV_ASSIGN;
  1984. __entry->proto = protocol;
  1985. __entry->duration = duration;
  1986. ),
  1987. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u",
  1988. WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration)
  1989. );
  1990. TRACE_EVENT(rdev_crit_proto_stop,
  1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  1992. TP_ARGS(wiphy, wdev),
  1993. TP_STRUCT__entry(
  1994. WIPHY_ENTRY
  1995. WDEV_ENTRY
  1996. ),
  1997. TP_fast_assign(
  1998. WIPHY_ASSIGN;
  1999. WDEV_ASSIGN;
  2000. ),
  2001. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
  2002. WIPHY_PR_ARG, WDEV_PR_ARG)
  2003. );
  2004. TRACE_EVENT(rdev_channel_switch,
  2005. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2006. struct cfg80211_csa_settings *params),
  2007. TP_ARGS(wiphy, netdev, params),
  2008. TP_STRUCT__entry(
  2009. WIPHY_ENTRY
  2010. NETDEV_ENTRY
  2011. CHAN_DEF_ENTRY
  2012. __field(bool, radar_required)
  2013. __field(bool, block_tx)
  2014. __field(u8, count)
  2015. __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon)
  2016. __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp)
  2017. ),
  2018. TP_fast_assign(
  2019. WIPHY_ASSIGN;
  2020. NETDEV_ASSIGN;
  2021. CHAN_DEF_ASSIGN(&params->chandef);
  2022. __entry->radar_required = params->radar_required;
  2023. __entry->block_tx = params->block_tx;
  2024. __entry->count = params->count;
  2025. memcpy(__get_dynamic_array(bcn_ofs),
  2026. params->counter_offsets_beacon,
  2027. params->n_counter_offsets_beacon * sizeof(u16));
  2028. /* probe response offsets are optional */
  2029. if (params->n_counter_offsets_presp)
  2030. memcpy(__get_dynamic_array(pres_ofs),
  2031. params->counter_offsets_presp,
  2032. params->n_counter_offsets_presp * sizeof(u16));
  2033. ),
  2034. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
  2035. ", block_tx: %d, count: %u, radar_required: %d",
  2036. WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
  2037. __entry->block_tx, __entry->count, __entry->radar_required)
  2038. );
  2039. TRACE_EVENT(rdev_set_qos_map,
  2040. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2041. struct cfg80211_qos_map *qos_map),
  2042. TP_ARGS(wiphy, netdev, qos_map),
  2043. TP_STRUCT__entry(
  2044. WIPHY_ENTRY
  2045. NETDEV_ENTRY
  2046. QOS_MAP_ENTRY
  2047. ),
  2048. TP_fast_assign(
  2049. WIPHY_ASSIGN;
  2050. NETDEV_ASSIGN;
  2051. QOS_MAP_ASSIGN(qos_map);
  2052. ),
  2053. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u",
  2054. WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des)
  2055. );
  2056. TRACE_EVENT(rdev_set_ap_chanwidth,
  2057. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2058. struct cfg80211_chan_def *chandef),
  2059. TP_ARGS(wiphy, netdev, chandef),
  2060. TP_STRUCT__entry(
  2061. WIPHY_ENTRY
  2062. NETDEV_ENTRY
  2063. CHAN_DEF_ENTRY
  2064. ),
  2065. TP_fast_assign(
  2066. WIPHY_ASSIGN;
  2067. NETDEV_ASSIGN;
  2068. CHAN_DEF_ASSIGN(chandef);
  2069. ),
  2070. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
  2071. WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
  2072. );
  2073. TRACE_EVENT(rdev_add_tx_ts,
  2074. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2075. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time),
  2076. TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time),
  2077. TP_STRUCT__entry(
  2078. WIPHY_ENTRY
  2079. NETDEV_ENTRY
  2080. MAC_ENTRY(peer)
  2081. __field(u8, tsid)
  2082. __field(u8, user_prio)
  2083. __field(u16, admitted_time)
  2084. ),
  2085. TP_fast_assign(
  2086. WIPHY_ASSIGN;
  2087. NETDEV_ASSIGN;
  2088. MAC_ASSIGN(peer, peer);
  2089. __entry->tsid = tsid;
  2090. __entry->user_prio = user_prio;
  2091. __entry->admitted_time = admitted_time;
  2092. ),
  2093. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d, UP %d, time %d",
  2094. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
  2095. __entry->tsid, __entry->user_prio, __entry->admitted_time)
  2096. );
  2097. TRACE_EVENT(rdev_del_tx_ts,
  2098. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2099. u8 tsid, const u8 *peer),
  2100. TP_ARGS(wiphy, netdev, tsid, peer),
  2101. TP_STRUCT__entry(
  2102. WIPHY_ENTRY
  2103. NETDEV_ENTRY
  2104. MAC_ENTRY(peer)
  2105. __field(u8, tsid)
  2106. ),
  2107. TP_fast_assign(
  2108. WIPHY_ASSIGN;
  2109. NETDEV_ASSIGN;
  2110. MAC_ASSIGN(peer, peer);
  2111. __entry->tsid = tsid;
  2112. ),
  2113. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d",
  2114. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tsid)
  2115. );
  2116. TRACE_EVENT(rdev_tdls_channel_switch,
  2117. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2118. const u8 *addr, u8 oper_class,
  2119. struct cfg80211_chan_def *chandef),
  2120. TP_ARGS(wiphy, netdev, addr, oper_class, chandef),
  2121. TP_STRUCT__entry(
  2122. WIPHY_ENTRY
  2123. NETDEV_ENTRY
  2124. MAC_ENTRY(addr)
  2125. __field(u8, oper_class)
  2126. CHAN_DEF_ENTRY
  2127. ),
  2128. TP_fast_assign(
  2129. WIPHY_ASSIGN;
  2130. NETDEV_ASSIGN;
  2131. MAC_ASSIGN(addr, addr);
  2132. CHAN_DEF_ASSIGN(chandef);
  2133. ),
  2134. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT
  2135. " oper class %d, " CHAN_DEF_PR_FMT,
  2136. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr),
  2137. __entry->oper_class, CHAN_DEF_PR_ARG)
  2138. );
  2139. TRACE_EVENT(rdev_tdls_cancel_channel_switch,
  2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2141. const u8 *addr),
  2142. TP_ARGS(wiphy, netdev, addr),
  2143. TP_STRUCT__entry(
  2144. WIPHY_ENTRY
  2145. NETDEV_ENTRY
  2146. MAC_ENTRY(addr)
  2147. ),
  2148. TP_fast_assign(
  2149. WIPHY_ASSIGN;
  2150. NETDEV_ASSIGN;
  2151. MAC_ASSIGN(addr, addr);
  2152. ),
  2153. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
  2154. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr))
  2155. );
  2156. TRACE_EVENT(rdev_set_pmk,
  2157. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2158. struct cfg80211_pmk_conf *pmk_conf),
  2159. TP_ARGS(wiphy, netdev, pmk_conf),
  2160. TP_STRUCT__entry(
  2161. WIPHY_ENTRY
  2162. NETDEV_ENTRY
  2163. MAC_ENTRY(aa)
  2164. __field(u8, pmk_len)
  2165. __field(u8, pmk_r0_name_len)
  2166. __dynamic_array(u8, pmk, pmk_conf->pmk_len)
  2167. __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN)
  2168. ),
  2169. TP_fast_assign(
  2170. WIPHY_ASSIGN;
  2171. NETDEV_ASSIGN;
  2172. MAC_ASSIGN(aa, pmk_conf->aa);
  2173. __entry->pmk_len = pmk_conf->pmk_len;
  2174. __entry->pmk_r0_name_len =
  2175. pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0;
  2176. memcpy(__get_dynamic_array(pmk), pmk_conf->pmk,
  2177. pmk_conf->pmk_len);
  2178. memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name,
  2179. pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0);
  2180. ),
  2181. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT
  2182. "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG,
  2183. NETDEV_PR_ARG, MAC_PR_ARG(aa), __entry->pmk_len,
  2184. __print_array(__get_dynamic_array(pmk),
  2185. __get_dynamic_array_len(pmk), 1),
  2186. __entry->pmk_r0_name_len ?
  2187. __print_array(__get_dynamic_array(pmk_r0_name),
  2188. __get_dynamic_array_len(pmk_r0_name), 1) : "")
  2189. );
  2190. TRACE_EVENT(rdev_del_pmk,
  2191. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa),
  2192. TP_ARGS(wiphy, netdev, aa),
  2193. TP_STRUCT__entry(
  2194. WIPHY_ENTRY
  2195. NETDEV_ENTRY
  2196. MAC_ENTRY(aa)
  2197. ),
  2198. TP_fast_assign(
  2199. WIPHY_ASSIGN;
  2200. NETDEV_ASSIGN;
  2201. MAC_ASSIGN(aa, aa);
  2202. ),
  2203. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
  2204. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(aa))
  2205. );
  2206. TRACE_EVENT(rdev_external_auth,
  2207. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2208. struct cfg80211_external_auth_params *params),
  2209. TP_ARGS(wiphy, netdev, params),
  2210. TP_STRUCT__entry(WIPHY_ENTRY
  2211. NETDEV_ENTRY
  2212. MAC_ENTRY(bssid)
  2213. __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1)
  2214. __field(u16, status)
  2215. ),
  2216. TP_fast_assign(WIPHY_ASSIGN;
  2217. NETDEV_ASSIGN;
  2218. MAC_ASSIGN(bssid, params->bssid);
  2219. memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  2220. memcpy(__entry->ssid, params->ssid.ssid,
  2221. params->ssid.ssid_len);
  2222. __entry->status = params->status;
  2223. ),
  2224. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
  2225. ", ssid: %s, status: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
  2226. __entry->bssid, __entry->ssid, __entry->status)
  2227. );
  2228. /*************************************************************
  2229. * cfg80211 exported functions traces *
  2230. *************************************************************/
  2231. TRACE_EVENT(cfg80211_return_bool,
  2232. TP_PROTO(bool ret),
  2233. TP_ARGS(ret),
  2234. TP_STRUCT__entry(
  2235. __field(bool, ret)
  2236. ),
  2237. TP_fast_assign(
  2238. __entry->ret = ret;
  2239. ),
  2240. TP_printk("returned %s", BOOL_TO_STR(__entry->ret))
  2241. );
  2242. DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt,
  2243. TP_PROTO(struct net_device *netdev, const u8 *macaddr),
  2244. TP_ARGS(netdev, macaddr),
  2245. TP_STRUCT__entry(
  2246. NETDEV_ENTRY
  2247. MAC_ENTRY(macaddr)
  2248. ),
  2249. TP_fast_assign(
  2250. NETDEV_ASSIGN;
  2251. MAC_ASSIGN(macaddr, macaddr);
  2252. ),
  2253. TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
  2254. NETDEV_PR_ARG, MAC_PR_ARG(macaddr))
  2255. );
  2256. DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate,
  2257. TP_PROTO(struct net_device *netdev, const u8 *macaddr),
  2258. TP_ARGS(netdev, macaddr)
  2259. );
  2260. DECLARE_EVENT_CLASS(netdev_evt_only,
  2261. TP_PROTO(struct net_device *netdev),
  2262. TP_ARGS(netdev),
  2263. TP_STRUCT__entry(
  2264. NETDEV_ENTRY
  2265. ),
  2266. TP_fast_assign(
  2267. NETDEV_ASSIGN;
  2268. ),
  2269. TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG)
  2270. );
  2271. DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth,
  2272. TP_PROTO(struct net_device *netdev),
  2273. TP_ARGS(netdev)
  2274. );
  2275. TRACE_EVENT(cfg80211_send_rx_assoc,
  2276. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss),
  2277. TP_ARGS(netdev, bss),
  2278. TP_STRUCT__entry(
  2279. NETDEV_ENTRY
  2280. MAC_ENTRY(bssid)
  2281. CHAN_ENTRY
  2282. ),
  2283. TP_fast_assign(
  2284. NETDEV_ASSIGN;
  2285. MAC_ASSIGN(bssid, bss->bssid);
  2286. CHAN_ASSIGN(bss->channel);
  2287. ),
  2288. TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", " CHAN_PR_FMT,
  2289. NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
  2290. );
  2291. DECLARE_EVENT_CLASS(netdev_frame_event,
  2292. TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
  2293. TP_ARGS(netdev, buf, len),
  2294. TP_STRUCT__entry(
  2295. NETDEV_ENTRY
  2296. __dynamic_array(u8, frame, len)
  2297. ),
  2298. TP_fast_assign(
  2299. NETDEV_ASSIGN;
  2300. memcpy(__get_dynamic_array(frame), buf, len);
  2301. ),
  2302. TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
  2303. NETDEV_PR_ARG,
  2304. le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
  2305. );
  2306. DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt,
  2307. TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
  2308. TP_ARGS(netdev, buf, len)
  2309. );
  2310. DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt,
  2311. TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
  2312. TP_ARGS(netdev, buf, len)
  2313. );
  2314. TRACE_EVENT(cfg80211_tx_mlme_mgmt,
  2315. TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
  2316. TP_ARGS(netdev, buf, len),
  2317. TP_STRUCT__entry(
  2318. NETDEV_ENTRY
  2319. __dynamic_array(u8, frame, len)
  2320. ),
  2321. TP_fast_assign(
  2322. NETDEV_ASSIGN;
  2323. memcpy(__get_dynamic_array(frame), buf, len);
  2324. ),
  2325. TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
  2326. NETDEV_PR_ARG,
  2327. le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
  2328. );
  2329. DECLARE_EVENT_CLASS(netdev_mac_evt,
  2330. TP_PROTO(struct net_device *netdev, const u8 *mac),
  2331. TP_ARGS(netdev, mac),
  2332. TP_STRUCT__entry(
  2333. NETDEV_ENTRY
  2334. MAC_ENTRY(mac)
  2335. ),
  2336. TP_fast_assign(
  2337. NETDEV_ASSIGN;
  2338. MAC_ASSIGN(mac, mac)
  2339. ),
  2340. TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
  2341. NETDEV_PR_ARG, MAC_PR_ARG(mac))
  2342. );
  2343. DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout,
  2344. TP_PROTO(struct net_device *netdev, const u8 *mac),
  2345. TP_ARGS(netdev, mac)
  2346. );
  2347. DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout,
  2348. TP_PROTO(struct net_device *netdev, const u8 *mac),
  2349. TP_ARGS(netdev, mac)
  2350. );
  2351. TRACE_EVENT(cfg80211_michael_mic_failure,
  2352. TP_PROTO(struct net_device *netdev, const u8 *addr,
  2353. enum nl80211_key_type key_type, int key_id, const u8 *tsc),
  2354. TP_ARGS(netdev, addr, key_type, key_id, tsc),
  2355. TP_STRUCT__entry(
  2356. NETDEV_ENTRY
  2357. MAC_ENTRY(addr)
  2358. __field(enum nl80211_key_type, key_type)
  2359. __field(int, key_id)
  2360. __array(u8, tsc, 6)
  2361. ),
  2362. TP_fast_assign(
  2363. NETDEV_ASSIGN;
  2364. MAC_ASSIGN(addr, addr);
  2365. __entry->key_type = key_type;
  2366. __entry->key_id = key_id;
  2367. if (tsc)
  2368. memcpy(__entry->tsc, tsc, 6);
  2369. ),
  2370. TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm",
  2371. NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type,
  2372. __entry->key_id, __entry->tsc)
  2373. );
  2374. TRACE_EVENT(cfg80211_ready_on_channel,
  2375. TP_PROTO(struct wireless_dev *wdev, u64 cookie,
  2376. struct ieee80211_channel *chan,
  2377. unsigned int duration),
  2378. TP_ARGS(wdev, cookie, chan, duration),
  2379. TP_STRUCT__entry(
  2380. WDEV_ENTRY
  2381. __field(u64, cookie)
  2382. CHAN_ENTRY
  2383. __field(unsigned int, duration)
  2384. ),
  2385. TP_fast_assign(
  2386. WDEV_ASSIGN;
  2387. __entry->cookie = cookie;
  2388. CHAN_ASSIGN(chan);
  2389. __entry->duration = duration;
  2390. ),
  2391. TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u",
  2392. WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
  2393. __entry->duration)
  2394. );
  2395. TRACE_EVENT(cfg80211_ready_on_channel_expired,
  2396. TP_PROTO(struct wireless_dev *wdev, u64 cookie,
  2397. struct ieee80211_channel *chan),
  2398. TP_ARGS(wdev, cookie, chan),
  2399. TP_STRUCT__entry(
  2400. WDEV_ENTRY
  2401. __field(u64, cookie)
  2402. CHAN_ENTRY
  2403. ),
  2404. TP_fast_assign(
  2405. WDEV_ASSIGN;
  2406. __entry->cookie = cookie;
  2407. CHAN_ASSIGN(chan);
  2408. ),
  2409. TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
  2410. WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
  2411. );
  2412. TRACE_EVENT(cfg80211_new_sta,
  2413. TP_PROTO(struct net_device *netdev, const u8 *mac_addr,
  2414. struct station_info *sinfo),
  2415. TP_ARGS(netdev, mac_addr, sinfo),
  2416. TP_STRUCT__entry(
  2417. NETDEV_ENTRY
  2418. MAC_ENTRY(mac_addr)
  2419. SINFO_ENTRY
  2420. ),
  2421. TP_fast_assign(
  2422. NETDEV_ASSIGN;
  2423. MAC_ASSIGN(mac_addr, mac_addr);
  2424. SINFO_ASSIGN;
  2425. ),
  2426. TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT,
  2427. NETDEV_PR_ARG, MAC_PR_ARG(mac_addr))
  2428. );
  2429. DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta,
  2430. TP_PROTO(struct net_device *netdev, const u8 *macaddr),
  2431. TP_ARGS(netdev, macaddr)
  2432. );
  2433. TRACE_EVENT(cfg80211_rx_mgmt,
  2434. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm),
  2435. TP_ARGS(wdev, freq, sig_dbm),
  2436. TP_STRUCT__entry(
  2437. WDEV_ENTRY
  2438. __field(int, freq)
  2439. __field(int, sig_dbm)
  2440. ),
  2441. TP_fast_assign(
  2442. WDEV_ASSIGN;
  2443. __entry->freq = freq;
  2444. __entry->sig_dbm = sig_dbm;
  2445. ),
  2446. TP_printk(WDEV_PR_FMT ", freq: %d, sig dbm: %d",
  2447. WDEV_PR_ARG, __entry->freq, __entry->sig_dbm)
  2448. );
  2449. TRACE_EVENT(cfg80211_mgmt_tx_status,
  2450. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
  2451. TP_ARGS(wdev, cookie, ack),
  2452. TP_STRUCT__entry(
  2453. WDEV_ENTRY
  2454. __field(u64, cookie)
  2455. __field(bool, ack)
  2456. ),
  2457. TP_fast_assign(
  2458. WDEV_ASSIGN;
  2459. __entry->cookie = cookie;
  2460. __entry->ack = ack;
  2461. ),
  2462. TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
  2463. WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
  2464. );
  2465. TRACE_EVENT(cfg80211_rx_control_port,
  2466. TP_PROTO(struct net_device *netdev, struct sk_buff *skb,
  2467. bool unencrypted),
  2468. TP_ARGS(netdev, skb, unencrypted),
  2469. TP_STRUCT__entry(
  2470. NETDEV_ENTRY
  2471. __field(int, len)
  2472. MAC_ENTRY(from)
  2473. __field(u16, proto)
  2474. __field(bool, unencrypted)
  2475. ),
  2476. TP_fast_assign(
  2477. NETDEV_ASSIGN;
  2478. __entry->len = skb->len;
  2479. MAC_ASSIGN(from, eth_hdr(skb)->h_source);
  2480. __entry->proto = be16_to_cpu(skb->protocol);
  2481. __entry->unencrypted = unencrypted;
  2482. ),
  2483. TP_printk(NETDEV_PR_FMT ", len=%d, " MAC_PR_FMT ", proto: 0x%x, unencrypted: %s",
  2484. NETDEV_PR_ARG, __entry->len, MAC_PR_ARG(from),
  2485. __entry->proto, BOOL_TO_STR(__entry->unencrypted))
  2486. );
  2487. TRACE_EVENT(cfg80211_cqm_rssi_notify,
  2488. TP_PROTO(struct net_device *netdev,
  2489. enum nl80211_cqm_rssi_threshold_event rssi_event,
  2490. s32 rssi_level),
  2491. TP_ARGS(netdev, rssi_event, rssi_level),
  2492. TP_STRUCT__entry(
  2493. NETDEV_ENTRY
  2494. __field(enum nl80211_cqm_rssi_threshold_event, rssi_event)
  2495. __field(s32, rssi_level)
  2496. ),
  2497. TP_fast_assign(
  2498. NETDEV_ASSIGN;
  2499. __entry->rssi_event = rssi_event;
  2500. __entry->rssi_level = rssi_level;
  2501. ),
  2502. TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d",
  2503. NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level)
  2504. );
  2505. TRACE_EVENT(cfg80211_reg_can_beacon,
  2506. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
  2507. enum nl80211_iftype iftype, bool check_no_ir),
  2508. TP_ARGS(wiphy, chandef, iftype, check_no_ir),
  2509. TP_STRUCT__entry(
  2510. WIPHY_ENTRY
  2511. CHAN_DEF_ENTRY
  2512. __field(enum nl80211_iftype, iftype)
  2513. __field(bool, check_no_ir)
  2514. ),
  2515. TP_fast_assign(
  2516. WIPHY_ASSIGN;
  2517. CHAN_DEF_ASSIGN(chandef);
  2518. __entry->iftype = iftype;
  2519. __entry->check_no_ir = check_no_ir;
  2520. ),
  2521. TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s",
  2522. WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype,
  2523. BOOL_TO_STR(__entry->check_no_ir))
  2524. );
  2525. TRACE_EVENT(cfg80211_chandef_dfs_required,
  2526. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
  2527. TP_ARGS(wiphy, chandef),
  2528. TP_STRUCT__entry(
  2529. WIPHY_ENTRY
  2530. CHAN_DEF_ENTRY
  2531. ),
  2532. TP_fast_assign(
  2533. WIPHY_ASSIGN;
  2534. CHAN_DEF_ASSIGN(chandef);
  2535. ),
  2536. TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
  2537. WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
  2538. );
  2539. TRACE_EVENT(cfg80211_ch_switch_notify,
  2540. TP_PROTO(struct net_device *netdev,
  2541. struct cfg80211_chan_def *chandef),
  2542. TP_ARGS(netdev, chandef),
  2543. TP_STRUCT__entry(
  2544. NETDEV_ENTRY
  2545. CHAN_DEF_ENTRY
  2546. ),
  2547. TP_fast_assign(
  2548. NETDEV_ASSIGN;
  2549. CHAN_DEF_ASSIGN(chandef);
  2550. ),
  2551. TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
  2552. NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
  2553. );
  2554. TRACE_EVENT(cfg80211_ch_switch_started_notify,
  2555. TP_PROTO(struct net_device *netdev,
  2556. struct cfg80211_chan_def *chandef),
  2557. TP_ARGS(netdev, chandef),
  2558. TP_STRUCT__entry(
  2559. NETDEV_ENTRY
  2560. CHAN_DEF_ENTRY
  2561. ),
  2562. TP_fast_assign(
  2563. NETDEV_ASSIGN;
  2564. CHAN_DEF_ASSIGN(chandef);
  2565. ),
  2566. TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
  2567. NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
  2568. );
  2569. TRACE_EVENT(cfg80211_radar_event,
  2570. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
  2571. TP_ARGS(wiphy, chandef),
  2572. TP_STRUCT__entry(
  2573. WIPHY_ENTRY
  2574. CHAN_DEF_ENTRY
  2575. ),
  2576. TP_fast_assign(
  2577. WIPHY_ASSIGN;
  2578. CHAN_DEF_ASSIGN(chandef);
  2579. ),
  2580. TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
  2581. WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
  2582. );
  2583. TRACE_EVENT(cfg80211_cac_event,
  2584. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt),
  2585. TP_ARGS(netdev, evt),
  2586. TP_STRUCT__entry(
  2587. NETDEV_ENTRY
  2588. __field(enum nl80211_radar_event, evt)
  2589. ),
  2590. TP_fast_assign(
  2591. NETDEV_ASSIGN;
  2592. __entry->evt = evt;
  2593. ),
  2594. TP_printk(NETDEV_PR_FMT ", event: %d",
  2595. NETDEV_PR_ARG, __entry->evt)
  2596. );
  2597. DECLARE_EVENT_CLASS(cfg80211_rx_evt,
  2598. TP_PROTO(struct net_device *netdev, const u8 *addr),
  2599. TP_ARGS(netdev, addr),
  2600. TP_STRUCT__entry(
  2601. NETDEV_ENTRY
  2602. MAC_ENTRY(addr)
  2603. ),
  2604. TP_fast_assign(
  2605. NETDEV_ASSIGN;
  2606. MAC_ASSIGN(addr, addr);
  2607. ),
  2608. TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr))
  2609. );
  2610. DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
  2611. TP_PROTO(struct net_device *netdev, const u8 *addr),
  2612. TP_ARGS(netdev, addr)
  2613. );
  2614. DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame,
  2615. TP_PROTO(struct net_device *netdev, const u8 *addr),
  2616. TP_ARGS(netdev, addr)
  2617. );
  2618. TRACE_EVENT(cfg80211_ibss_joined,
  2619. TP_PROTO(struct net_device *netdev, const u8 *bssid,
  2620. struct ieee80211_channel *channel),
  2621. TP_ARGS(netdev, bssid, channel),
  2622. TP_STRUCT__entry(
  2623. NETDEV_ENTRY
  2624. MAC_ENTRY(bssid)
  2625. CHAN_ENTRY
  2626. ),
  2627. TP_fast_assign(
  2628. NETDEV_ASSIGN;
  2629. MAC_ASSIGN(bssid, bssid);
  2630. CHAN_ASSIGN(channel);
  2631. ),
  2632. TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT,
  2633. NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
  2634. );
  2635. TRACE_EVENT(cfg80211_probe_status,
  2636. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
  2637. bool acked),
  2638. TP_ARGS(netdev, addr, cookie, acked),
  2639. TP_STRUCT__entry(
  2640. NETDEV_ENTRY
  2641. MAC_ENTRY(addr)
  2642. __field(u64, cookie)
  2643. __field(bool, acked)
  2644. ),
  2645. TP_fast_assign(
  2646. NETDEV_ASSIGN;
  2647. MAC_ASSIGN(addr, addr);
  2648. __entry->cookie = cookie;
  2649. __entry->acked = acked;
  2650. ),
  2651. TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s",
  2652. NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie,
  2653. BOOL_TO_STR(__entry->acked))
  2654. );
  2655. TRACE_EVENT(cfg80211_cqm_pktloss_notify,
  2656. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets),
  2657. TP_ARGS(netdev, peer, num_packets),
  2658. TP_STRUCT__entry(
  2659. NETDEV_ENTRY
  2660. MAC_ENTRY(peer)
  2661. __field(u32, num_packets)
  2662. ),
  2663. TP_fast_assign(
  2664. NETDEV_ASSIGN;
  2665. MAC_ASSIGN(peer, peer);
  2666. __entry->num_packets = num_packets;
  2667. ),
  2668. TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u",
  2669. NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets)
  2670. );
  2671. DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify,
  2672. TP_PROTO(struct net_device *netdev, const u8 *macaddr),
  2673. TP_ARGS(netdev, macaddr)
  2674. );
  2675. TRACE_EVENT(cfg80211_pmksa_candidate_notify,
  2676. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid,
  2677. bool preauth),
  2678. TP_ARGS(netdev, index, bssid, preauth),
  2679. TP_STRUCT__entry(
  2680. NETDEV_ENTRY
  2681. __field(int, index)
  2682. MAC_ENTRY(bssid)
  2683. __field(bool, preauth)
  2684. ),
  2685. TP_fast_assign(
  2686. NETDEV_ASSIGN;
  2687. __entry->index = index;
  2688. MAC_ASSIGN(bssid, bssid);
  2689. __entry->preauth = preauth;
  2690. ),
  2691. TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s",
  2692. NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid),
  2693. BOOL_TO_STR(__entry->preauth))
  2694. );
  2695. TRACE_EVENT(cfg80211_report_obss_beacon,
  2696. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len,
  2697. int freq, int sig_dbm),
  2698. TP_ARGS(wiphy, frame, len, freq, sig_dbm),
  2699. TP_STRUCT__entry(
  2700. WIPHY_ENTRY
  2701. __field(int, freq)
  2702. __field(int, sig_dbm)
  2703. ),
  2704. TP_fast_assign(
  2705. WIPHY_ASSIGN;
  2706. __entry->freq = freq;
  2707. __entry->sig_dbm = sig_dbm;
  2708. ),
  2709. TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d",
  2710. WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm)
  2711. );
  2712. TRACE_EVENT(cfg80211_tdls_oper_request,
  2713. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer,
  2714. enum nl80211_tdls_operation oper, u16 reason_code),
  2715. TP_ARGS(wiphy, netdev, peer, oper, reason_code),
  2716. TP_STRUCT__entry(
  2717. WIPHY_ENTRY
  2718. NETDEV_ENTRY
  2719. MAC_ENTRY(peer)
  2720. __field(enum nl80211_tdls_operation, oper)
  2721. __field(u16, reason_code)
  2722. ),
  2723. TP_fast_assign(
  2724. WIPHY_ASSIGN;
  2725. NETDEV_ASSIGN;
  2726. MAC_ASSIGN(peer, peer);
  2727. __entry->oper = oper;
  2728. __entry->reason_code = reason_code;
  2729. ),
  2730. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u",
  2731. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper,
  2732. __entry->reason_code)
  2733. );
  2734. TRACE_EVENT(cfg80211_scan_done,
  2735. TP_PROTO(struct cfg80211_scan_request *request,
  2736. struct cfg80211_scan_info *info),
  2737. TP_ARGS(request, info),
  2738. TP_STRUCT__entry(
  2739. __field(u32, n_channels)
  2740. __dynamic_array(u8, ie, request ? request->ie_len : 0)
  2741. __array(u32, rates, NUM_NL80211_BANDS)
  2742. __field(u32, wdev_id)
  2743. MAC_ENTRY(wiphy_mac)
  2744. __field(bool, no_cck)
  2745. __field(bool, aborted)
  2746. __field(u64, scan_start_tsf)
  2747. MAC_ENTRY(tsf_bssid)
  2748. ),
  2749. TP_fast_assign(
  2750. if (request) {
  2751. memcpy(__get_dynamic_array(ie), request->ie,
  2752. request->ie_len);
  2753. memcpy(__entry->rates, request->rates,
  2754. NUM_NL80211_BANDS);
  2755. __entry->wdev_id = request->wdev ?
  2756. request->wdev->identifier : 0;
  2757. if (request->wiphy)
  2758. MAC_ASSIGN(wiphy_mac,
  2759. request->wiphy->perm_addr);
  2760. __entry->no_cck = request->no_cck;
  2761. }
  2762. if (info) {
  2763. __entry->aborted = info->aborted;
  2764. __entry->scan_start_tsf = info->scan_start_tsf;
  2765. MAC_ASSIGN(tsf_bssid, info->tsf_bssid);
  2766. }
  2767. ),
  2768. TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: " MAC_PR_FMT,
  2769. BOOL_TO_STR(__entry->aborted),
  2770. (unsigned long long)__entry->scan_start_tsf,
  2771. MAC_PR_ARG(tsf_bssid))
  2772. );
  2773. DECLARE_EVENT_CLASS(wiphy_id_evt,
  2774. TP_PROTO(struct wiphy *wiphy, u64 id),
  2775. TP_ARGS(wiphy, id),
  2776. TP_STRUCT__entry(
  2777. WIPHY_ENTRY
  2778. __field(u64, id)
  2779. ),
  2780. TP_fast_assign(
  2781. WIPHY_ASSIGN;
  2782. __entry->id = id;
  2783. ),
  2784. TP_printk(WIPHY_PR_FMT ", id: %llu", WIPHY_PR_ARG, __entry->id)
  2785. );
  2786. DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped,
  2787. TP_PROTO(struct wiphy *wiphy, u64 id),
  2788. TP_ARGS(wiphy, id)
  2789. );
  2790. DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results,
  2791. TP_PROTO(struct wiphy *wiphy, u64 id),
  2792. TP_ARGS(wiphy, id)
  2793. );
  2794. TRACE_EVENT(cfg80211_get_bss,
  2795. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
  2796. const u8 *bssid, const u8 *ssid, size_t ssid_len,
  2797. enum ieee80211_bss_type bss_type,
  2798. enum ieee80211_privacy privacy),
  2799. TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy),
  2800. TP_STRUCT__entry(
  2801. WIPHY_ENTRY
  2802. CHAN_ENTRY
  2803. MAC_ENTRY(bssid)
  2804. __dynamic_array(u8, ssid, ssid_len)
  2805. __field(enum ieee80211_bss_type, bss_type)
  2806. __field(enum ieee80211_privacy, privacy)
  2807. ),
  2808. TP_fast_assign(
  2809. WIPHY_ASSIGN;
  2810. CHAN_ASSIGN(channel);
  2811. MAC_ASSIGN(bssid, bssid);
  2812. memcpy(__get_dynamic_array(ssid), ssid, ssid_len);
  2813. __entry->bss_type = bss_type;
  2814. __entry->privacy = privacy;
  2815. ),
  2816. TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT
  2817. ", buf: %#.2x, bss_type: %d, privacy: %d",
  2818. WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid),
  2819. ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type,
  2820. __entry->privacy)
  2821. );
  2822. TRACE_EVENT(cfg80211_inform_bss_frame,
  2823. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data,
  2824. struct ieee80211_mgmt *mgmt, size_t len),
  2825. TP_ARGS(wiphy, data, mgmt, len),
  2826. TP_STRUCT__entry(
  2827. WIPHY_ENTRY
  2828. CHAN_ENTRY
  2829. __field(enum nl80211_bss_scan_width, scan_width)
  2830. __dynamic_array(u8, mgmt, len)
  2831. __field(s32, signal)
  2832. __field(u64, ts_boottime)
  2833. __field(u64, parent_tsf)
  2834. MAC_ENTRY(parent_bssid)
  2835. ),
  2836. TP_fast_assign(
  2837. WIPHY_ASSIGN;
  2838. CHAN_ASSIGN(data->chan);
  2839. __entry->scan_width = data->scan_width;
  2840. if (mgmt)
  2841. memcpy(__get_dynamic_array(mgmt), mgmt, len);
  2842. __entry->signal = data->signal;
  2843. __entry->ts_boottime = data->boottime_ns;
  2844. __entry->parent_tsf = data->parent_tsf;
  2845. MAC_ASSIGN(parent_bssid, data->parent_bssid);
  2846. ),
  2847. TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT
  2848. "(scan_width: %d) signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: "
  2849. MAC_PR_FMT, WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width,
  2850. __entry->signal, (unsigned long long)__entry->ts_boottime,
  2851. (unsigned long long)__entry->parent_tsf,
  2852. MAC_PR_ARG(parent_bssid))
  2853. );
  2854. DECLARE_EVENT_CLASS(cfg80211_bss_evt,
  2855. TP_PROTO(struct cfg80211_bss *pub),
  2856. TP_ARGS(pub),
  2857. TP_STRUCT__entry(
  2858. MAC_ENTRY(bssid)
  2859. CHAN_ENTRY
  2860. ),
  2861. TP_fast_assign(
  2862. MAC_ASSIGN(bssid, pub->bssid);
  2863. CHAN_ASSIGN(pub->channel);
  2864. ),
  2865. TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG)
  2866. );
  2867. DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
  2868. TP_PROTO(struct cfg80211_bss *pub),
  2869. TP_ARGS(pub)
  2870. );
  2871. TRACE_EVENT(cfg80211_return_uint,
  2872. TP_PROTO(unsigned int ret),
  2873. TP_ARGS(ret),
  2874. TP_STRUCT__entry(
  2875. __field(unsigned int, ret)
  2876. ),
  2877. TP_fast_assign(
  2878. __entry->ret = ret;
  2879. ),
  2880. TP_printk("ret: %d", __entry->ret)
  2881. );
  2882. TRACE_EVENT(cfg80211_return_u32,
  2883. TP_PROTO(u32 ret),
  2884. TP_ARGS(ret),
  2885. TP_STRUCT__entry(
  2886. __field(u32, ret)
  2887. ),
  2888. TP_fast_assign(
  2889. __entry->ret = ret;
  2890. ),
  2891. TP_printk("ret: %u", __entry->ret)
  2892. );
  2893. TRACE_EVENT(cfg80211_report_wowlan_wakeup,
  2894. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
  2895. struct cfg80211_wowlan_wakeup *wakeup),
  2896. TP_ARGS(wiphy, wdev, wakeup),
  2897. TP_STRUCT__entry(
  2898. WIPHY_ENTRY
  2899. WDEV_ENTRY
  2900. __field(bool, non_wireless)
  2901. __field(bool, disconnect)
  2902. __field(bool, magic_pkt)
  2903. __field(bool, gtk_rekey_failure)
  2904. __field(bool, eap_identity_req)
  2905. __field(bool, four_way_handshake)
  2906. __field(bool, rfkill_release)
  2907. __field(s32, pattern_idx)
  2908. __field(u32, packet_len)
  2909. __dynamic_array(u8, packet,
  2910. wakeup ? wakeup->packet_present_len : 0)
  2911. ),
  2912. TP_fast_assign(
  2913. WIPHY_ASSIGN;
  2914. WDEV_ASSIGN;
  2915. __entry->non_wireless = !wakeup;
  2916. __entry->disconnect = wakeup ? wakeup->disconnect : false;
  2917. __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false;
  2918. __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false;
  2919. __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false;
  2920. __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false;
  2921. __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false;
  2922. __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false;
  2923. __entry->packet_len = wakeup ? wakeup->packet_len : false;
  2924. if (wakeup && wakeup->packet && wakeup->packet_present_len)
  2925. memcpy(__get_dynamic_array(packet), wakeup->packet,
  2926. wakeup->packet_present_len);
  2927. ),
  2928. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
  2929. );
  2930. TRACE_EVENT(cfg80211_ft_event,
  2931. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2932. struct cfg80211_ft_event_params *ft_event),
  2933. TP_ARGS(wiphy, netdev, ft_event),
  2934. TP_STRUCT__entry(
  2935. WIPHY_ENTRY
  2936. NETDEV_ENTRY
  2937. __dynamic_array(u8, ies, ft_event->ies_len)
  2938. MAC_ENTRY(target_ap)
  2939. __dynamic_array(u8, ric_ies, ft_event->ric_ies_len)
  2940. ),
  2941. TP_fast_assign(
  2942. WIPHY_ASSIGN;
  2943. NETDEV_ASSIGN;
  2944. if (ft_event->ies)
  2945. memcpy(__get_dynamic_array(ies), ft_event->ies,
  2946. ft_event->ies_len);
  2947. MAC_ASSIGN(target_ap, ft_event->target_ap);
  2948. if (ft_event->ric_ies)
  2949. memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies,
  2950. ft_event->ric_ies_len);
  2951. ),
  2952. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT,
  2953. WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap))
  2954. );
  2955. TRACE_EVENT(cfg80211_stop_iface,
  2956. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  2957. TP_ARGS(wiphy, wdev),
  2958. TP_STRUCT__entry(
  2959. WIPHY_ENTRY
  2960. WDEV_ENTRY
  2961. ),
  2962. TP_fast_assign(
  2963. WIPHY_ASSIGN;
  2964. WDEV_ASSIGN;
  2965. ),
  2966. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
  2967. WIPHY_PR_ARG, WDEV_PR_ARG)
  2968. );
  2969. TRACE_EVENT(rdev_start_radar_detection,
  2970. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2971. struct cfg80211_chan_def *chandef,
  2972. u32 cac_time_ms),
  2973. TP_ARGS(wiphy, netdev, chandef, cac_time_ms),
  2974. TP_STRUCT__entry(
  2975. WIPHY_ENTRY
  2976. NETDEV_ENTRY
  2977. CHAN_DEF_ENTRY
  2978. __field(u32, cac_time_ms)
  2979. ),
  2980. TP_fast_assign(
  2981. WIPHY_ASSIGN;
  2982. NETDEV_ASSIGN;
  2983. CHAN_DEF_ASSIGN(chandef);
  2984. __entry->cac_time_ms = cac_time_ms;
  2985. ),
  2986. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
  2987. ", cac_time_ms=%u",
  2988. WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
  2989. __entry->cac_time_ms)
  2990. );
  2991. TRACE_EVENT(rdev_set_mcast_rate,
  2992. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  2993. int *mcast_rate),
  2994. TP_ARGS(wiphy, netdev, mcast_rate),
  2995. TP_STRUCT__entry(
  2996. WIPHY_ENTRY
  2997. NETDEV_ENTRY
  2998. __array(int, mcast_rate, NUM_NL80211_BANDS)
  2999. ),
  3000. TP_fast_assign(
  3001. WIPHY_ASSIGN;
  3002. NETDEV_ASSIGN;
  3003. memcpy(__entry->mcast_rate, mcast_rate,
  3004. sizeof(int) * NUM_NL80211_BANDS);
  3005. ),
  3006. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", "
  3007. "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 60GHz=0x%x]",
  3008. WIPHY_PR_ARG, NETDEV_PR_ARG,
  3009. __entry->mcast_rate[NL80211_BAND_2GHZ],
  3010. __entry->mcast_rate[NL80211_BAND_5GHZ],
  3011. __entry->mcast_rate[NL80211_BAND_60GHZ])
  3012. );
  3013. TRACE_EVENT(rdev_set_coalesce,
  3014. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce),
  3015. TP_ARGS(wiphy, coalesce),
  3016. TP_STRUCT__entry(
  3017. WIPHY_ENTRY
  3018. __field(int, n_rules)
  3019. ),
  3020. TP_fast_assign(
  3021. WIPHY_ASSIGN;
  3022. __entry->n_rules = coalesce ? coalesce->n_rules : 0;
  3023. ),
  3024. TP_printk(WIPHY_PR_FMT ", n_rules=%d",
  3025. WIPHY_PR_ARG, __entry->n_rules)
  3026. );
  3027. DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan,
  3028. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  3029. TP_ARGS(wiphy, wdev)
  3030. );
  3031. TRACE_EVENT(rdev_set_multicast_to_unicast,
  3032. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
  3033. const bool enabled),
  3034. TP_ARGS(wiphy, netdev, enabled),
  3035. TP_STRUCT__entry(
  3036. WIPHY_ENTRY
  3037. NETDEV_ENTRY
  3038. __field(bool, enabled)
  3039. ),
  3040. TP_fast_assign(
  3041. WIPHY_ASSIGN;
  3042. NETDEV_ASSIGN;
  3043. __entry->enabled = enabled;
  3044. ),
  3045. TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s",
  3046. WIPHY_PR_ARG, NETDEV_PR_ARG,
  3047. BOOL_TO_STR(__entry->enabled))
  3048. );
  3049. TRACE_EVENT(rdev_get_txq_stats,
  3050. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
  3051. TP_ARGS(wiphy, wdev),
  3052. TP_STRUCT__entry(
  3053. WIPHY_ENTRY
  3054. WDEV_ENTRY
  3055. ),
  3056. TP_fast_assign(
  3057. WIPHY_ASSIGN;
  3058. WDEV_ASSIGN;
  3059. ),
  3060. TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
  3061. );
  3062. #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
  3063. #undef TRACE_INCLUDE_PATH
  3064. #define TRACE_INCLUDE_PATH .
  3065. #undef TRACE_INCLUDE_FILE
  3066. #define TRACE_INCLUDE_FILE trace
  3067. #include <trace/define_trace.h>