nldev.c 58 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189
  1. /*
  2. * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
  3. *
  4. * Redistribution and use in source and binary forms, with or without
  5. * modification, are permitted provided that the following conditions are met:
  6. *
  7. * 1. Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * 2. Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * 3. Neither the names of the copyright holders nor the names of its
  13. * contributors may be used to endorse or promote products derived from
  14. * this software without specific prior written permission.
  15. *
  16. * Alternatively, this software may be distributed under the terms of the
  17. * GNU General Public License ("GPL") version 2 as published by the Free
  18. * Software Foundation.
  19. *
  20. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30. * POSSIBILITY OF SUCH DAMAGE.
  31. */
  32. #include <linux/module.h>
  33. #include <linux/pid.h>
  34. #include <linux/pid_namespace.h>
  35. #include <linux/mutex.h>
  36. #include <net/netlink.h>
  37. #include <rdma/rdma_cm.h>
  38. #include <rdma/rdma_netlink.h>
  39. #include "core_priv.h"
  40. #include "cma_priv.h"
  41. #include "restrack.h"
  42. #include "uverbs.h"
  43. typedef int (*res_fill_func_t)(struct sk_buff*, bool,
  44. struct rdma_restrack_entry*, uint32_t);
  45. /*
  46. * Sort array elements by the netlink attribute name
  47. */
  48. static const struct nla_policy nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
  49. [RDMA_NLDEV_ATTR_CHARDEV] = { .type = NLA_U64 },
  50. [RDMA_NLDEV_ATTR_CHARDEV_ABI] = { .type = NLA_U64 },
  51. [RDMA_NLDEV_ATTR_CHARDEV_NAME] = { .type = NLA_NUL_STRING,
  52. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  53. [RDMA_NLDEV_ATTR_CHARDEV_TYPE] = { .type = NLA_NUL_STRING,
  54. .len = RDMA_NLDEV_ATTR_CHARDEV_TYPE_SIZE },
  55. [RDMA_NLDEV_ATTR_DEV_DIM] = { .type = NLA_U8 },
  56. [RDMA_NLDEV_ATTR_DEV_INDEX] = { .type = NLA_U32 },
  57. [RDMA_NLDEV_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING,
  58. .len = IB_DEVICE_NAME_MAX },
  59. [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = { .type = NLA_U8 },
  60. [RDMA_NLDEV_ATTR_DEV_PROTOCOL] = { .type = NLA_NUL_STRING,
  61. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  62. [RDMA_NLDEV_ATTR_DRIVER] = { .type = NLA_NESTED },
  63. [RDMA_NLDEV_ATTR_DRIVER_ENTRY] = { .type = NLA_NESTED },
  64. [RDMA_NLDEV_ATTR_DRIVER_PRINT_TYPE] = { .type = NLA_U8 },
  65. [RDMA_NLDEV_ATTR_DRIVER_STRING] = { .type = NLA_NUL_STRING,
  66. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  67. [RDMA_NLDEV_ATTR_DRIVER_S32] = { .type = NLA_S32 },
  68. [RDMA_NLDEV_ATTR_DRIVER_S64] = { .type = NLA_S64 },
  69. [RDMA_NLDEV_ATTR_DRIVER_U32] = { .type = NLA_U32 },
  70. [RDMA_NLDEV_ATTR_DRIVER_U64] = { .type = NLA_U64 },
  71. [RDMA_NLDEV_ATTR_FW_VERSION] = { .type = NLA_NUL_STRING,
  72. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  73. [RDMA_NLDEV_ATTR_LID] = { .type = NLA_U32 },
  74. [RDMA_NLDEV_ATTR_LINK_TYPE] = { .type = NLA_NUL_STRING,
  75. .len = IFNAMSIZ },
  76. [RDMA_NLDEV_ATTR_LMC] = { .type = NLA_U8 },
  77. [RDMA_NLDEV_ATTR_NDEV_INDEX] = { .type = NLA_U32 },
  78. [RDMA_NLDEV_ATTR_NDEV_NAME] = { .type = NLA_NUL_STRING,
  79. .len = IFNAMSIZ },
  80. [RDMA_NLDEV_ATTR_NODE_GUID] = { .type = NLA_U64 },
  81. [RDMA_NLDEV_ATTR_PORT_INDEX] = { .type = NLA_U32 },
  82. [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = { .type = NLA_U8 },
  83. [RDMA_NLDEV_ATTR_PORT_STATE] = { .type = NLA_U8 },
  84. [RDMA_NLDEV_ATTR_RES_CM_ID] = { .type = NLA_NESTED },
  85. [RDMA_NLDEV_ATTR_RES_CM_IDN] = { .type = NLA_U32 },
  86. [RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY] = { .type = NLA_NESTED },
  87. [RDMA_NLDEV_ATTR_RES_CQ] = { .type = NLA_NESTED },
  88. [RDMA_NLDEV_ATTR_RES_CQE] = { .type = NLA_U32 },
  89. [RDMA_NLDEV_ATTR_RES_CQN] = { .type = NLA_U32 },
  90. [RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = { .type = NLA_NESTED },
  91. [RDMA_NLDEV_ATTR_RES_CTXN] = { .type = NLA_U32 },
  92. [RDMA_NLDEV_ATTR_RES_DST_ADDR] = {
  93. .len = sizeof(struct __kernel_sockaddr_storage) },
  94. [RDMA_NLDEV_ATTR_RES_IOVA] = { .type = NLA_U64 },
  95. [RDMA_NLDEV_ATTR_RES_KERN_NAME] = { .type = NLA_NUL_STRING,
  96. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  97. [RDMA_NLDEV_ATTR_RES_LKEY] = { .type = NLA_U32 },
  98. [RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY] = { .type = NLA_U32 },
  99. [RDMA_NLDEV_ATTR_RES_LQPN] = { .type = NLA_U32 },
  100. [RDMA_NLDEV_ATTR_RES_MR] = { .type = NLA_NESTED },
  101. [RDMA_NLDEV_ATTR_RES_MRLEN] = { .type = NLA_U64 },
  102. [RDMA_NLDEV_ATTR_RES_MRN] = { .type = NLA_U32 },
  103. [RDMA_NLDEV_ATTR_RES_MR_ENTRY] = { .type = NLA_NESTED },
  104. [RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE] = { .type = NLA_U8 },
  105. [RDMA_NLDEV_ATTR_RES_PD] = { .type = NLA_NESTED },
  106. [RDMA_NLDEV_ATTR_RES_PDN] = { .type = NLA_U32 },
  107. [RDMA_NLDEV_ATTR_RES_PD_ENTRY] = { .type = NLA_NESTED },
  108. [RDMA_NLDEV_ATTR_RES_PID] = { .type = NLA_U32 },
  109. [RDMA_NLDEV_ATTR_RES_POLL_CTX] = { .type = NLA_U8 },
  110. [RDMA_NLDEV_ATTR_RES_PS] = { .type = NLA_U32 },
  111. [RDMA_NLDEV_ATTR_RES_QP] = { .type = NLA_NESTED },
  112. [RDMA_NLDEV_ATTR_RES_QP_ENTRY] = { .type = NLA_NESTED },
  113. [RDMA_NLDEV_ATTR_RES_RAW] = { .type = NLA_BINARY },
  114. [RDMA_NLDEV_ATTR_RES_RKEY] = { .type = NLA_U32 },
  115. [RDMA_NLDEV_ATTR_RES_RQPN] = { .type = NLA_U32 },
  116. [RDMA_NLDEV_ATTR_RES_RQ_PSN] = { .type = NLA_U32 },
  117. [RDMA_NLDEV_ATTR_RES_SQ_PSN] = { .type = NLA_U32 },
  118. [RDMA_NLDEV_ATTR_RES_SRC_ADDR] = {
  119. .len = sizeof(struct __kernel_sockaddr_storage) },
  120. [RDMA_NLDEV_ATTR_RES_STATE] = { .type = NLA_U8 },
  121. [RDMA_NLDEV_ATTR_RES_SUMMARY] = { .type = NLA_NESTED },
  122. [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY] = { .type = NLA_NESTED },
  123. [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]= { .type = NLA_U64 },
  124. [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME]= { .type = NLA_NUL_STRING,
  125. .len = RDMA_NLDEV_ATTR_EMPTY_STRING },
  126. [RDMA_NLDEV_ATTR_RES_TYPE] = { .type = NLA_U8 },
  127. [RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY]= { .type = NLA_U32 },
  128. [RDMA_NLDEV_ATTR_RES_USECNT] = { .type = NLA_U64 },
  129. [RDMA_NLDEV_ATTR_SM_LID] = { .type = NLA_U32 },
  130. [RDMA_NLDEV_ATTR_SUBNET_PREFIX] = { .type = NLA_U64 },
  131. [RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK] = { .type = NLA_U32 },
  132. [RDMA_NLDEV_ATTR_STAT_MODE] = { .type = NLA_U32 },
  133. [RDMA_NLDEV_ATTR_STAT_RES] = { .type = NLA_U32 },
  134. [RDMA_NLDEV_ATTR_STAT_COUNTER] = { .type = NLA_NESTED },
  135. [RDMA_NLDEV_ATTR_STAT_COUNTER_ENTRY] = { .type = NLA_NESTED },
  136. [RDMA_NLDEV_ATTR_STAT_COUNTER_ID] = { .type = NLA_U32 },
  137. [RDMA_NLDEV_ATTR_STAT_HWCOUNTERS] = { .type = NLA_NESTED },
  138. [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY] = { .type = NLA_NESTED },
  139. [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_NAME] = { .type = NLA_NUL_STRING },
  140. [RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_VALUE] = { .type = NLA_U64 },
  141. [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = { .type = NLA_U64 },
  142. [RDMA_NLDEV_ATTR_UVERBS_DRIVER_ID] = { .type = NLA_U32 },
  143. [RDMA_NLDEV_NET_NS_FD] = { .type = NLA_U32 },
  144. [RDMA_NLDEV_SYS_ATTR_NETNS_MODE] = { .type = NLA_U8 },
  145. };
  146. static int put_driver_name_print_type(struct sk_buff *msg, const char *name,
  147. enum rdma_nldev_print_type print_type)
  148. {
  149. if (nla_put_string(msg, RDMA_NLDEV_ATTR_DRIVER_STRING, name))
  150. return -EMSGSIZE;
  151. if (print_type != RDMA_NLDEV_PRINT_TYPE_UNSPEC &&
  152. nla_put_u8(msg, RDMA_NLDEV_ATTR_DRIVER_PRINT_TYPE, print_type))
  153. return -EMSGSIZE;
  154. return 0;
  155. }
  156. static int _rdma_nl_put_driver_u32(struct sk_buff *msg, const char *name,
  157. enum rdma_nldev_print_type print_type,
  158. u32 value)
  159. {
  160. if (put_driver_name_print_type(msg, name, print_type))
  161. return -EMSGSIZE;
  162. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_DRIVER_U32, value))
  163. return -EMSGSIZE;
  164. return 0;
  165. }
  166. static int _rdma_nl_put_driver_u64(struct sk_buff *msg, const char *name,
  167. enum rdma_nldev_print_type print_type,
  168. u64 value)
  169. {
  170. if (put_driver_name_print_type(msg, name, print_type))
  171. return -EMSGSIZE;
  172. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_DRIVER_U64, value,
  173. RDMA_NLDEV_ATTR_PAD))
  174. return -EMSGSIZE;
  175. return 0;
  176. }
  177. int rdma_nl_put_driver_string(struct sk_buff *msg, const char *name,
  178. const char *str)
  179. {
  180. if (put_driver_name_print_type(msg, name,
  181. RDMA_NLDEV_PRINT_TYPE_UNSPEC))
  182. return -EMSGSIZE;
  183. if (nla_put_string(msg, RDMA_NLDEV_ATTR_DRIVER_STRING, str))
  184. return -EMSGSIZE;
  185. return 0;
  186. }
  187. EXPORT_SYMBOL(rdma_nl_put_driver_string);
  188. int rdma_nl_put_driver_u32(struct sk_buff *msg, const char *name, u32 value)
  189. {
  190. return _rdma_nl_put_driver_u32(msg, name, RDMA_NLDEV_PRINT_TYPE_UNSPEC,
  191. value);
  192. }
  193. EXPORT_SYMBOL(rdma_nl_put_driver_u32);
  194. int rdma_nl_put_driver_u32_hex(struct sk_buff *msg, const char *name,
  195. u32 value)
  196. {
  197. return _rdma_nl_put_driver_u32(msg, name, RDMA_NLDEV_PRINT_TYPE_HEX,
  198. value);
  199. }
  200. EXPORT_SYMBOL(rdma_nl_put_driver_u32_hex);
  201. int rdma_nl_put_driver_u64(struct sk_buff *msg, const char *name, u64 value)
  202. {
  203. return _rdma_nl_put_driver_u64(msg, name, RDMA_NLDEV_PRINT_TYPE_UNSPEC,
  204. value);
  205. }
  206. EXPORT_SYMBOL(rdma_nl_put_driver_u64);
  207. int rdma_nl_put_driver_u64_hex(struct sk_buff *msg, const char *name, u64 value)
  208. {
  209. return _rdma_nl_put_driver_u64(msg, name, RDMA_NLDEV_PRINT_TYPE_HEX,
  210. value);
  211. }
  212. EXPORT_SYMBOL(rdma_nl_put_driver_u64_hex);
  213. static int fill_nldev_handle(struct sk_buff *msg, struct ib_device *device)
  214. {
  215. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_DEV_INDEX, device->index))
  216. return -EMSGSIZE;
  217. if (nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_NAME,
  218. dev_name(&device->dev)))
  219. return -EMSGSIZE;
  220. return 0;
  221. }
  222. static int fill_dev_info(struct sk_buff *msg, struct ib_device *device)
  223. {
  224. char fw[IB_FW_VERSION_NAME_MAX];
  225. int ret = 0;
  226. u8 port;
  227. if (fill_nldev_handle(msg, device))
  228. return -EMSGSIZE;
  229. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, rdma_end_port(device)))
  230. return -EMSGSIZE;
  231. BUILD_BUG_ON(sizeof(device->attrs.device_cap_flags) != sizeof(u64));
  232. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CAP_FLAGS,
  233. device->attrs.device_cap_flags,
  234. RDMA_NLDEV_ATTR_PAD))
  235. return -EMSGSIZE;
  236. ib_get_device_fw_str(device, fw);
  237. /* Device without FW has strlen(fw) = 0 */
  238. if (strlen(fw) && nla_put_string(msg, RDMA_NLDEV_ATTR_FW_VERSION, fw))
  239. return -EMSGSIZE;
  240. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_NODE_GUID,
  241. be64_to_cpu(device->node_guid),
  242. RDMA_NLDEV_ATTR_PAD))
  243. return -EMSGSIZE;
  244. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_SYS_IMAGE_GUID,
  245. be64_to_cpu(device->attrs.sys_image_guid),
  246. RDMA_NLDEV_ATTR_PAD))
  247. return -EMSGSIZE;
  248. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_NODE_TYPE, device->node_type))
  249. return -EMSGSIZE;
  250. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_DIM, device->use_cq_dim))
  251. return -EMSGSIZE;
  252. /*
  253. * Link type is determined on first port and mlx4 device
  254. * which can potentially have two different link type for the same
  255. * IB device is considered as better to be avoided in the future,
  256. */
  257. port = rdma_start_port(device);
  258. if (rdma_cap_opa_mad(device, port))
  259. ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "opa");
  260. else if (rdma_protocol_ib(device, port))
  261. ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "ib");
  262. else if (rdma_protocol_iwarp(device, port))
  263. ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "iw");
  264. else if (rdma_protocol_roce(device, port))
  265. ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL, "roce");
  266. else if (rdma_protocol_usnic(device, port))
  267. ret = nla_put_string(msg, RDMA_NLDEV_ATTR_DEV_PROTOCOL,
  268. "usnic");
  269. return ret;
  270. }
  271. static int fill_port_info(struct sk_buff *msg,
  272. struct ib_device *device, u32 port,
  273. const struct net *net)
  274. {
  275. struct net_device *netdev = NULL;
  276. struct ib_port_attr attr;
  277. int ret;
  278. u64 cap_flags = 0;
  279. if (fill_nldev_handle(msg, device))
  280. return -EMSGSIZE;
  281. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port))
  282. return -EMSGSIZE;
  283. ret = ib_query_port(device, port, &attr);
  284. if (ret)
  285. return ret;
  286. if (rdma_protocol_ib(device, port)) {
  287. BUILD_BUG_ON((sizeof(attr.port_cap_flags) +
  288. sizeof(attr.port_cap_flags2)) > sizeof(u64));
  289. cap_flags = attr.port_cap_flags |
  290. ((u64)attr.port_cap_flags2 << 32);
  291. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CAP_FLAGS,
  292. cap_flags, RDMA_NLDEV_ATTR_PAD))
  293. return -EMSGSIZE;
  294. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_SUBNET_PREFIX,
  295. attr.subnet_prefix, RDMA_NLDEV_ATTR_PAD))
  296. return -EMSGSIZE;
  297. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_LID, attr.lid))
  298. return -EMSGSIZE;
  299. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_SM_LID, attr.sm_lid))
  300. return -EMSGSIZE;
  301. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_LMC, attr.lmc))
  302. return -EMSGSIZE;
  303. }
  304. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_PORT_STATE, attr.state))
  305. return -EMSGSIZE;
  306. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_PORT_PHYS_STATE, attr.phys_state))
  307. return -EMSGSIZE;
  308. netdev = ib_device_get_netdev(device, port);
  309. if (netdev && net_eq(dev_net(netdev), net)) {
  310. ret = nla_put_u32(msg,
  311. RDMA_NLDEV_ATTR_NDEV_INDEX, netdev->ifindex);
  312. if (ret)
  313. goto out;
  314. ret = nla_put_string(msg,
  315. RDMA_NLDEV_ATTR_NDEV_NAME, netdev->name);
  316. }
  317. out:
  318. if (netdev)
  319. dev_put(netdev);
  320. return ret;
  321. }
  322. static int fill_res_info_entry(struct sk_buff *msg,
  323. const char *name, u64 curr)
  324. {
  325. struct nlattr *entry_attr;
  326. entry_attr = nla_nest_start_noflag(msg,
  327. RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY);
  328. if (!entry_attr)
  329. return -EMSGSIZE;
  330. if (nla_put_string(msg, RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME, name))
  331. goto err;
  332. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR, curr,
  333. RDMA_NLDEV_ATTR_PAD))
  334. goto err;
  335. nla_nest_end(msg, entry_attr);
  336. return 0;
  337. err:
  338. nla_nest_cancel(msg, entry_attr);
  339. return -EMSGSIZE;
  340. }
  341. static int fill_res_info(struct sk_buff *msg, struct ib_device *device)
  342. {
  343. static const char * const names[RDMA_RESTRACK_MAX] = {
  344. [RDMA_RESTRACK_PD] = "pd",
  345. [RDMA_RESTRACK_CQ] = "cq",
  346. [RDMA_RESTRACK_QP] = "qp",
  347. [RDMA_RESTRACK_CM_ID] = "cm_id",
  348. [RDMA_RESTRACK_MR] = "mr",
  349. [RDMA_RESTRACK_CTX] = "ctx",
  350. };
  351. struct nlattr *table_attr;
  352. int ret, i, curr;
  353. if (fill_nldev_handle(msg, device))
  354. return -EMSGSIZE;
  355. table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_RES_SUMMARY);
  356. if (!table_attr)
  357. return -EMSGSIZE;
  358. for (i = 0; i < RDMA_RESTRACK_MAX; i++) {
  359. if (!names[i])
  360. continue;
  361. curr = rdma_restrack_count(device, i);
  362. ret = fill_res_info_entry(msg, names[i], curr);
  363. if (ret)
  364. goto err;
  365. }
  366. nla_nest_end(msg, table_attr);
  367. return 0;
  368. err:
  369. nla_nest_cancel(msg, table_attr);
  370. return ret;
  371. }
  372. static int fill_res_name_pid(struct sk_buff *msg,
  373. struct rdma_restrack_entry *res)
  374. {
  375. int err = 0;
  376. /*
  377. * For user resources, user is should read /proc/PID/comm to get the
  378. * name of the task file.
  379. */
  380. if (rdma_is_kernel_res(res)) {
  381. err = nla_put_string(msg, RDMA_NLDEV_ATTR_RES_KERN_NAME,
  382. res->kern_name);
  383. } else {
  384. pid_t pid;
  385. pid = task_pid_vnr(res->task);
  386. /*
  387. * Task is dead and in zombie state.
  388. * There is no need to print PID anymore.
  389. */
  390. if (pid)
  391. /*
  392. * This part is racy, task can be killed and PID will
  393. * be zero right here but it is ok, next query won't
  394. * return PID. We don't promise real-time reflection
  395. * of SW objects.
  396. */
  397. err = nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PID, pid);
  398. }
  399. return err ? -EMSGSIZE : 0;
  400. }
  401. static int fill_res_qp_entry_query(struct sk_buff *msg,
  402. struct rdma_restrack_entry *res,
  403. struct ib_device *dev,
  404. struct ib_qp *qp)
  405. {
  406. struct ib_qp_init_attr qp_init_attr;
  407. struct ib_qp_attr qp_attr;
  408. int ret;
  409. ret = ib_query_qp(qp, &qp_attr, 0, &qp_init_attr);
  410. if (ret)
  411. return ret;
  412. if (qp->qp_type == IB_QPT_RC || qp->qp_type == IB_QPT_UC) {
  413. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RQPN,
  414. qp_attr.dest_qp_num))
  415. goto err;
  416. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RQ_PSN,
  417. qp_attr.rq_psn))
  418. goto err;
  419. }
  420. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_SQ_PSN, qp_attr.sq_psn))
  421. goto err;
  422. if (qp->qp_type == IB_QPT_RC || qp->qp_type == IB_QPT_UC ||
  423. qp->qp_type == IB_QPT_XRC_INI || qp->qp_type == IB_QPT_XRC_TGT) {
  424. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE,
  425. qp_attr.path_mig_state))
  426. goto err;
  427. }
  428. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, qp->qp_type))
  429. goto err;
  430. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_STATE, qp_attr.qp_state))
  431. goto err;
  432. if (dev->ops.fill_res_qp_entry)
  433. return dev->ops.fill_res_qp_entry(msg, qp);
  434. return 0;
  435. err: return -EMSGSIZE;
  436. }
  437. static int fill_res_qp_entry(struct sk_buff *msg, bool has_cap_net_admin,
  438. struct rdma_restrack_entry *res, uint32_t port)
  439. {
  440. struct ib_qp *qp = container_of(res, struct ib_qp, res);
  441. struct ib_device *dev = qp->device;
  442. int ret;
  443. if (port && port != qp->port)
  444. return -EAGAIN;
  445. /* In create_qp() port is not set yet */
  446. if (qp->port && nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, qp->port))
  447. return -EINVAL;
  448. ret = nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qp->qp_num);
  449. if (ret)
  450. return -EMSGSIZE;
  451. if (!rdma_is_kernel_res(res) &&
  452. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, qp->pd->res.id))
  453. return -EMSGSIZE;
  454. ret = fill_res_name_pid(msg, res);
  455. if (ret)
  456. return -EMSGSIZE;
  457. return fill_res_qp_entry_query(msg, res, dev, qp);
  458. }
  459. static int fill_res_qp_raw_entry(struct sk_buff *msg, bool has_cap_net_admin,
  460. struct rdma_restrack_entry *res, uint32_t port)
  461. {
  462. struct ib_qp *qp = container_of(res, struct ib_qp, res);
  463. struct ib_device *dev = qp->device;
  464. if (port && port != qp->port)
  465. return -EAGAIN;
  466. if (!dev->ops.fill_res_qp_entry_raw)
  467. return -EINVAL;
  468. return dev->ops.fill_res_qp_entry_raw(msg, qp);
  469. }
  470. static int fill_res_cm_id_entry(struct sk_buff *msg, bool has_cap_net_admin,
  471. struct rdma_restrack_entry *res, uint32_t port)
  472. {
  473. struct rdma_id_private *id_priv =
  474. container_of(res, struct rdma_id_private, res);
  475. struct ib_device *dev = id_priv->id.device;
  476. struct rdma_cm_id *cm_id = &id_priv->id;
  477. if (port && port != cm_id->port_num)
  478. return 0;
  479. if (cm_id->port_num &&
  480. nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, cm_id->port_num))
  481. goto err;
  482. if (id_priv->qp_num) {
  483. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, id_priv->qp_num))
  484. goto err;
  485. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, cm_id->qp_type))
  486. goto err;
  487. }
  488. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PS, cm_id->ps))
  489. goto err;
  490. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_STATE, id_priv->state))
  491. goto err;
  492. if (cm_id->route.addr.src_addr.ss_family &&
  493. nla_put(msg, RDMA_NLDEV_ATTR_RES_SRC_ADDR,
  494. sizeof(cm_id->route.addr.src_addr),
  495. &cm_id->route.addr.src_addr))
  496. goto err;
  497. if (cm_id->route.addr.dst_addr.ss_family &&
  498. nla_put(msg, RDMA_NLDEV_ATTR_RES_DST_ADDR,
  499. sizeof(cm_id->route.addr.dst_addr),
  500. &cm_id->route.addr.dst_addr))
  501. goto err;
  502. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CM_IDN, res->id))
  503. goto err;
  504. if (fill_res_name_pid(msg, res))
  505. goto err;
  506. if (dev->ops.fill_res_cm_id_entry)
  507. return dev->ops.fill_res_cm_id_entry(msg, cm_id);
  508. return 0;
  509. err: return -EMSGSIZE;
  510. }
  511. static int fill_res_cq_entry(struct sk_buff *msg, bool has_cap_net_admin,
  512. struct rdma_restrack_entry *res, uint32_t port)
  513. {
  514. struct ib_cq *cq = container_of(res, struct ib_cq, res);
  515. struct ib_device *dev = cq->device;
  516. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CQE, cq->cqe))
  517. return -EMSGSIZE;
  518. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_USECNT,
  519. atomic_read(&cq->usecnt), RDMA_NLDEV_ATTR_PAD))
  520. return -EMSGSIZE;
  521. /* Poll context is only valid for kernel CQs */
  522. if (rdma_is_kernel_res(res) &&
  523. nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_POLL_CTX, cq->poll_ctx))
  524. return -EMSGSIZE;
  525. if (nla_put_u8(msg, RDMA_NLDEV_ATTR_DEV_DIM, (cq->dim != NULL)))
  526. return -EMSGSIZE;
  527. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CQN, res->id))
  528. return -EMSGSIZE;
  529. if (!rdma_is_kernel_res(res) &&
  530. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CTXN,
  531. cq->uobject->uevent.uobject.context->res.id))
  532. return -EMSGSIZE;
  533. if (fill_res_name_pid(msg, res))
  534. return -EMSGSIZE;
  535. return (dev->ops.fill_res_cq_entry) ?
  536. dev->ops.fill_res_cq_entry(msg, cq) : 0;
  537. }
  538. static int fill_res_cq_raw_entry(struct sk_buff *msg, bool has_cap_net_admin,
  539. struct rdma_restrack_entry *res, uint32_t port)
  540. {
  541. struct ib_cq *cq = container_of(res, struct ib_cq, res);
  542. struct ib_device *dev = cq->device;
  543. if (!dev->ops.fill_res_cq_entry_raw)
  544. return -EINVAL;
  545. return dev->ops.fill_res_cq_entry_raw(msg, cq);
  546. }
  547. static int fill_res_mr_entry(struct sk_buff *msg, bool has_cap_net_admin,
  548. struct rdma_restrack_entry *res, uint32_t port)
  549. {
  550. struct ib_mr *mr = container_of(res, struct ib_mr, res);
  551. struct ib_device *dev = mr->pd->device;
  552. if (has_cap_net_admin) {
  553. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_RKEY, mr->rkey))
  554. return -EMSGSIZE;
  555. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LKEY, mr->lkey))
  556. return -EMSGSIZE;
  557. }
  558. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_MRLEN, mr->length,
  559. RDMA_NLDEV_ATTR_PAD))
  560. return -EMSGSIZE;
  561. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_MRN, res->id))
  562. return -EMSGSIZE;
  563. if (!rdma_is_kernel_res(res) &&
  564. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, mr->pd->res.id))
  565. return -EMSGSIZE;
  566. if (fill_res_name_pid(msg, res))
  567. return -EMSGSIZE;
  568. return (dev->ops.fill_res_mr_entry) ?
  569. dev->ops.fill_res_mr_entry(msg, mr) :
  570. 0;
  571. }
  572. static int fill_res_mr_raw_entry(struct sk_buff *msg, bool has_cap_net_admin,
  573. struct rdma_restrack_entry *res, uint32_t port)
  574. {
  575. struct ib_mr *mr = container_of(res, struct ib_mr, res);
  576. struct ib_device *dev = mr->pd->device;
  577. if (!dev->ops.fill_res_mr_entry_raw)
  578. return -EINVAL;
  579. return dev->ops.fill_res_mr_entry_raw(msg, mr);
  580. }
  581. static int fill_res_pd_entry(struct sk_buff *msg, bool has_cap_net_admin,
  582. struct rdma_restrack_entry *res, uint32_t port)
  583. {
  584. struct ib_pd *pd = container_of(res, struct ib_pd, res);
  585. if (has_cap_net_admin) {
  586. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY,
  587. pd->local_dma_lkey))
  588. goto err;
  589. if ((pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY) &&
  590. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY,
  591. pd->unsafe_global_rkey))
  592. goto err;
  593. }
  594. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_USECNT,
  595. atomic_read(&pd->usecnt), RDMA_NLDEV_ATTR_PAD))
  596. goto err;
  597. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_PDN, res->id))
  598. goto err;
  599. if (!rdma_is_kernel_res(res) &&
  600. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_CTXN,
  601. pd->uobject->context->res.id))
  602. goto err;
  603. return fill_res_name_pid(msg, res);
  604. err: return -EMSGSIZE;
  605. }
  606. static int fill_stat_counter_mode(struct sk_buff *msg,
  607. struct rdma_counter *counter)
  608. {
  609. struct rdma_counter_mode *m = &counter->mode;
  610. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, m->mode))
  611. return -EMSGSIZE;
  612. if (m->mode == RDMA_COUNTER_MODE_AUTO) {
  613. if ((m->mask & RDMA_COUNTER_MASK_QP_TYPE) &&
  614. nla_put_u8(msg, RDMA_NLDEV_ATTR_RES_TYPE, m->param.qp_type))
  615. return -EMSGSIZE;
  616. if ((m->mask & RDMA_COUNTER_MASK_PID) &&
  617. fill_res_name_pid(msg, &counter->res))
  618. return -EMSGSIZE;
  619. }
  620. return 0;
  621. }
  622. static int fill_stat_counter_qp_entry(struct sk_buff *msg, u32 qpn)
  623. {
  624. struct nlattr *entry_attr;
  625. entry_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_RES_QP_ENTRY);
  626. if (!entry_attr)
  627. return -EMSGSIZE;
  628. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn))
  629. goto err;
  630. nla_nest_end(msg, entry_attr);
  631. return 0;
  632. err:
  633. nla_nest_cancel(msg, entry_attr);
  634. return -EMSGSIZE;
  635. }
  636. static int fill_stat_counter_qps(struct sk_buff *msg,
  637. struct rdma_counter *counter)
  638. {
  639. struct rdma_restrack_entry *res;
  640. struct rdma_restrack_root *rt;
  641. struct nlattr *table_attr;
  642. struct ib_qp *qp = NULL;
  643. unsigned long id = 0;
  644. int ret = 0;
  645. table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_RES_QP);
  646. rt = &counter->device->res[RDMA_RESTRACK_QP];
  647. xa_lock(&rt->xa);
  648. xa_for_each(&rt->xa, id, res) {
  649. qp = container_of(res, struct ib_qp, res);
  650. if (!qp->counter || (qp->counter->id != counter->id))
  651. continue;
  652. ret = fill_stat_counter_qp_entry(msg, qp->qp_num);
  653. if (ret)
  654. goto err;
  655. }
  656. xa_unlock(&rt->xa);
  657. nla_nest_end(msg, table_attr);
  658. return 0;
  659. err:
  660. xa_unlock(&rt->xa);
  661. nla_nest_cancel(msg, table_attr);
  662. return ret;
  663. }
  664. int rdma_nl_stat_hwcounter_entry(struct sk_buff *msg, const char *name,
  665. u64 value)
  666. {
  667. struct nlattr *entry_attr;
  668. entry_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY);
  669. if (!entry_attr)
  670. return -EMSGSIZE;
  671. if (nla_put_string(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_NAME,
  672. name))
  673. goto err;
  674. if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_VALUE,
  675. value, RDMA_NLDEV_ATTR_PAD))
  676. goto err;
  677. nla_nest_end(msg, entry_attr);
  678. return 0;
  679. err:
  680. nla_nest_cancel(msg, entry_attr);
  681. return -EMSGSIZE;
  682. }
  683. EXPORT_SYMBOL(rdma_nl_stat_hwcounter_entry);
  684. static int fill_stat_mr_entry(struct sk_buff *msg, bool has_cap_net_admin,
  685. struct rdma_restrack_entry *res, uint32_t port)
  686. {
  687. struct ib_mr *mr = container_of(res, struct ib_mr, res);
  688. struct ib_device *dev = mr->pd->device;
  689. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_MRN, res->id))
  690. goto err;
  691. if (dev->ops.fill_stat_mr_entry)
  692. return dev->ops.fill_stat_mr_entry(msg, mr);
  693. return 0;
  694. err:
  695. return -EMSGSIZE;
  696. }
  697. static int fill_stat_counter_hwcounters(struct sk_buff *msg,
  698. struct rdma_counter *counter)
  699. {
  700. struct rdma_hw_stats *st = counter->stats;
  701. struct nlattr *table_attr;
  702. int i;
  703. table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTERS);
  704. if (!table_attr)
  705. return -EMSGSIZE;
  706. for (i = 0; i < st->num_counters; i++)
  707. if (rdma_nl_stat_hwcounter_entry(msg, st->names[i], st->value[i]))
  708. goto err;
  709. nla_nest_end(msg, table_attr);
  710. return 0;
  711. err:
  712. nla_nest_cancel(msg, table_attr);
  713. return -EMSGSIZE;
  714. }
  715. static int fill_res_counter_entry(struct sk_buff *msg, bool has_cap_net_admin,
  716. struct rdma_restrack_entry *res,
  717. uint32_t port)
  718. {
  719. struct rdma_counter *counter =
  720. container_of(res, struct rdma_counter, res);
  721. if (port && port != counter->port)
  722. return -EAGAIN;
  723. /* Dump it even query failed */
  724. rdma_counter_query_stats(counter);
  725. if (nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, counter->port) ||
  726. nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, counter->id) ||
  727. fill_stat_counter_mode(msg, counter) ||
  728. fill_stat_counter_qps(msg, counter) ||
  729. fill_stat_counter_hwcounters(msg, counter))
  730. return -EMSGSIZE;
  731. return 0;
  732. }
  733. static int nldev_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  734. struct netlink_ext_ack *extack)
  735. {
  736. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  737. struct ib_device *device;
  738. struct sk_buff *msg;
  739. u32 index;
  740. int err;
  741. err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  742. nldev_policy, extack);
  743. if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  744. return -EINVAL;
  745. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  746. device = ib_device_get_by_index(sock_net(skb->sk), index);
  747. if (!device)
  748. return -EINVAL;
  749. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  750. if (!msg) {
  751. err = -ENOMEM;
  752. goto err;
  753. }
  754. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  755. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET),
  756. 0, 0);
  757. err = fill_dev_info(msg, device);
  758. if (err)
  759. goto err_free;
  760. nlmsg_end(msg, nlh);
  761. ib_device_put(device);
  762. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  763. err_free:
  764. nlmsg_free(msg);
  765. err:
  766. ib_device_put(device);
  767. return err;
  768. }
  769. static int nldev_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  770. struct netlink_ext_ack *extack)
  771. {
  772. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  773. struct ib_device *device;
  774. u32 index;
  775. int err;
  776. err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  777. nldev_policy, extack);
  778. if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  779. return -EINVAL;
  780. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  781. device = ib_device_get_by_index(sock_net(skb->sk), index);
  782. if (!device)
  783. return -EINVAL;
  784. if (tb[RDMA_NLDEV_ATTR_DEV_NAME]) {
  785. char name[IB_DEVICE_NAME_MAX] = {};
  786. nla_strlcpy(name, tb[RDMA_NLDEV_ATTR_DEV_NAME],
  787. IB_DEVICE_NAME_MAX);
  788. if (strlen(name) == 0) {
  789. err = -EINVAL;
  790. goto done;
  791. }
  792. err = ib_device_rename(device, name);
  793. goto done;
  794. }
  795. if (tb[RDMA_NLDEV_NET_NS_FD]) {
  796. u32 ns_fd;
  797. ns_fd = nla_get_u32(tb[RDMA_NLDEV_NET_NS_FD]);
  798. err = ib_device_set_netns_put(skb, device, ns_fd);
  799. goto put_done;
  800. }
  801. if (tb[RDMA_NLDEV_ATTR_DEV_DIM]) {
  802. u8 use_dim;
  803. use_dim = nla_get_u8(tb[RDMA_NLDEV_ATTR_DEV_DIM]);
  804. err = ib_device_set_dim(device, use_dim);
  805. goto done;
  806. }
  807. done:
  808. ib_device_put(device);
  809. put_done:
  810. return err;
  811. }
  812. static int _nldev_get_dumpit(struct ib_device *device,
  813. struct sk_buff *skb,
  814. struct netlink_callback *cb,
  815. unsigned int idx)
  816. {
  817. int start = cb->args[0];
  818. struct nlmsghdr *nlh;
  819. if (idx < start)
  820. return 0;
  821. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  822. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET),
  823. 0, NLM_F_MULTI);
  824. if (fill_dev_info(skb, device)) {
  825. nlmsg_cancel(skb, nlh);
  826. goto out;
  827. }
  828. nlmsg_end(skb, nlh);
  829. idx++;
  830. out: cb->args[0] = idx;
  831. return skb->len;
  832. }
  833. static int nldev_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
  834. {
  835. /*
  836. * There is no need to take lock, because
  837. * we are relying on ib_core's locking.
  838. */
  839. return ib_enum_all_devs(_nldev_get_dumpit, skb, cb);
  840. }
  841. static int nldev_port_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  842. struct netlink_ext_ack *extack)
  843. {
  844. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  845. struct ib_device *device;
  846. struct sk_buff *msg;
  847. u32 index;
  848. u32 port;
  849. int err;
  850. err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  851. nldev_policy, extack);
  852. if (err ||
  853. !tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
  854. !tb[RDMA_NLDEV_ATTR_PORT_INDEX])
  855. return -EINVAL;
  856. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  857. device = ib_device_get_by_index(sock_net(skb->sk), index);
  858. if (!device)
  859. return -EINVAL;
  860. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  861. if (!rdma_is_port_valid(device, port)) {
  862. err = -EINVAL;
  863. goto err;
  864. }
  865. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  866. if (!msg) {
  867. err = -ENOMEM;
  868. goto err;
  869. }
  870. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  871. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET),
  872. 0, 0);
  873. err = fill_port_info(msg, device, port, sock_net(skb->sk));
  874. if (err)
  875. goto err_free;
  876. nlmsg_end(msg, nlh);
  877. ib_device_put(device);
  878. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  879. err_free:
  880. nlmsg_free(msg);
  881. err:
  882. ib_device_put(device);
  883. return err;
  884. }
  885. static int nldev_port_get_dumpit(struct sk_buff *skb,
  886. struct netlink_callback *cb)
  887. {
  888. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  889. struct ib_device *device;
  890. int start = cb->args[0];
  891. struct nlmsghdr *nlh;
  892. u32 idx = 0;
  893. u32 ifindex;
  894. int err;
  895. unsigned int p;
  896. err = nlmsg_parse_deprecated(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  897. nldev_policy, NULL);
  898. if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  899. return -EINVAL;
  900. ifindex = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  901. device = ib_device_get_by_index(sock_net(skb->sk), ifindex);
  902. if (!device)
  903. return -EINVAL;
  904. rdma_for_each_port (device, p) {
  905. /*
  906. * The dumpit function returns all information from specific
  907. * index. This specific index is taken from the netlink
  908. * messages request sent by user and it is available
  909. * in cb->args[0].
  910. *
  911. * Usually, the user doesn't fill this field and it causes
  912. * to return everything.
  913. *
  914. */
  915. if (idx < start) {
  916. idx++;
  917. continue;
  918. }
  919. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
  920. cb->nlh->nlmsg_seq,
  921. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  922. RDMA_NLDEV_CMD_PORT_GET),
  923. 0, NLM_F_MULTI);
  924. if (fill_port_info(skb, device, p, sock_net(skb->sk))) {
  925. nlmsg_cancel(skb, nlh);
  926. goto out;
  927. }
  928. idx++;
  929. nlmsg_end(skb, nlh);
  930. }
  931. out:
  932. ib_device_put(device);
  933. cb->args[0] = idx;
  934. return skb->len;
  935. }
  936. static int nldev_res_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  937. struct netlink_ext_ack *extack)
  938. {
  939. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  940. struct ib_device *device;
  941. struct sk_buff *msg;
  942. u32 index;
  943. int ret;
  944. ret = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  945. nldev_policy, extack);
  946. if (ret || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  947. return -EINVAL;
  948. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  949. device = ib_device_get_by_index(sock_net(skb->sk), index);
  950. if (!device)
  951. return -EINVAL;
  952. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  953. if (!msg) {
  954. ret = -ENOMEM;
  955. goto err;
  956. }
  957. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  958. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_RES_GET),
  959. 0, 0);
  960. ret = fill_res_info(msg, device);
  961. if (ret)
  962. goto err_free;
  963. nlmsg_end(msg, nlh);
  964. ib_device_put(device);
  965. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  966. err_free:
  967. nlmsg_free(msg);
  968. err:
  969. ib_device_put(device);
  970. return ret;
  971. }
  972. static int _nldev_res_get_dumpit(struct ib_device *device,
  973. struct sk_buff *skb,
  974. struct netlink_callback *cb,
  975. unsigned int idx)
  976. {
  977. int start = cb->args[0];
  978. struct nlmsghdr *nlh;
  979. if (idx < start)
  980. return 0;
  981. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  982. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_RES_GET),
  983. 0, NLM_F_MULTI);
  984. if (fill_res_info(skb, device)) {
  985. nlmsg_cancel(skb, nlh);
  986. goto out;
  987. }
  988. nlmsg_end(skb, nlh);
  989. idx++;
  990. out:
  991. cb->args[0] = idx;
  992. return skb->len;
  993. }
  994. static int nldev_res_get_dumpit(struct sk_buff *skb,
  995. struct netlink_callback *cb)
  996. {
  997. return ib_enum_all_devs(_nldev_res_get_dumpit, skb, cb);
  998. }
  999. struct nldev_fill_res_entry {
  1000. enum rdma_nldev_attr nldev_attr;
  1001. u8 flags;
  1002. u32 entry;
  1003. u32 id;
  1004. };
  1005. enum nldev_res_flags {
  1006. NLDEV_PER_DEV = 1 << 0,
  1007. };
  1008. static const struct nldev_fill_res_entry fill_entries[RDMA_RESTRACK_MAX] = {
  1009. [RDMA_RESTRACK_QP] = {
  1010. .nldev_attr = RDMA_NLDEV_ATTR_RES_QP,
  1011. .entry = RDMA_NLDEV_ATTR_RES_QP_ENTRY,
  1012. .id = RDMA_NLDEV_ATTR_RES_LQPN,
  1013. },
  1014. [RDMA_RESTRACK_CM_ID] = {
  1015. .nldev_attr = RDMA_NLDEV_ATTR_RES_CM_ID,
  1016. .entry = RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY,
  1017. .id = RDMA_NLDEV_ATTR_RES_CM_IDN,
  1018. },
  1019. [RDMA_RESTRACK_CQ] = {
  1020. .nldev_attr = RDMA_NLDEV_ATTR_RES_CQ,
  1021. .flags = NLDEV_PER_DEV,
  1022. .entry = RDMA_NLDEV_ATTR_RES_CQ_ENTRY,
  1023. .id = RDMA_NLDEV_ATTR_RES_CQN,
  1024. },
  1025. [RDMA_RESTRACK_MR] = {
  1026. .nldev_attr = RDMA_NLDEV_ATTR_RES_MR,
  1027. .flags = NLDEV_PER_DEV,
  1028. .entry = RDMA_NLDEV_ATTR_RES_MR_ENTRY,
  1029. .id = RDMA_NLDEV_ATTR_RES_MRN,
  1030. },
  1031. [RDMA_RESTRACK_PD] = {
  1032. .nldev_attr = RDMA_NLDEV_ATTR_RES_PD,
  1033. .flags = NLDEV_PER_DEV,
  1034. .entry = RDMA_NLDEV_ATTR_RES_PD_ENTRY,
  1035. .id = RDMA_NLDEV_ATTR_RES_PDN,
  1036. },
  1037. [RDMA_RESTRACK_COUNTER] = {
  1038. .nldev_attr = RDMA_NLDEV_ATTR_STAT_COUNTER,
  1039. .entry = RDMA_NLDEV_ATTR_STAT_COUNTER_ENTRY,
  1040. .id = RDMA_NLDEV_ATTR_STAT_COUNTER_ID,
  1041. },
  1042. };
  1043. static int res_get_common_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1044. struct netlink_ext_ack *extack,
  1045. enum rdma_restrack_type res_type,
  1046. res_fill_func_t fill_func)
  1047. {
  1048. const struct nldev_fill_res_entry *fe = &fill_entries[res_type];
  1049. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1050. struct rdma_restrack_entry *res;
  1051. struct ib_device *device;
  1052. u32 index, id, port = 0;
  1053. bool has_cap_net_admin;
  1054. struct sk_buff *msg;
  1055. int ret;
  1056. ret = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1057. nldev_policy, extack);
  1058. if (ret || !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !fe->id || !tb[fe->id])
  1059. return -EINVAL;
  1060. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1061. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1062. if (!device)
  1063. return -EINVAL;
  1064. if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
  1065. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1066. if (!rdma_is_port_valid(device, port)) {
  1067. ret = -EINVAL;
  1068. goto err;
  1069. }
  1070. }
  1071. if ((port && fe->flags & NLDEV_PER_DEV) ||
  1072. (!port && ~fe->flags & NLDEV_PER_DEV)) {
  1073. ret = -EINVAL;
  1074. goto err;
  1075. }
  1076. id = nla_get_u32(tb[fe->id]);
  1077. res = rdma_restrack_get_byid(device, res_type, id);
  1078. if (IS_ERR(res)) {
  1079. ret = PTR_ERR(res);
  1080. goto err;
  1081. }
  1082. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1083. if (!msg) {
  1084. ret = -ENOMEM;
  1085. goto err_get;
  1086. }
  1087. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1088. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1089. RDMA_NL_GET_OP(nlh->nlmsg_type)),
  1090. 0, 0);
  1091. if (fill_nldev_handle(msg, device)) {
  1092. ret = -EMSGSIZE;
  1093. goto err_free;
  1094. }
  1095. has_cap_net_admin = netlink_capable(skb, CAP_NET_ADMIN);
  1096. ret = fill_func(msg, has_cap_net_admin, res, port);
  1097. if (ret)
  1098. goto err_free;
  1099. rdma_restrack_put(res);
  1100. nlmsg_end(msg, nlh);
  1101. ib_device_put(device);
  1102. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1103. err_free:
  1104. nlmsg_free(msg);
  1105. err_get:
  1106. rdma_restrack_put(res);
  1107. err:
  1108. ib_device_put(device);
  1109. return ret;
  1110. }
  1111. static int res_get_common_dumpit(struct sk_buff *skb,
  1112. struct netlink_callback *cb,
  1113. enum rdma_restrack_type res_type,
  1114. res_fill_func_t fill_func)
  1115. {
  1116. const struct nldev_fill_res_entry *fe = &fill_entries[res_type];
  1117. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1118. struct rdma_restrack_entry *res;
  1119. struct rdma_restrack_root *rt;
  1120. int err, ret = 0, idx = 0;
  1121. struct nlattr *table_attr;
  1122. struct nlattr *entry_attr;
  1123. struct ib_device *device;
  1124. int start = cb->args[0];
  1125. bool has_cap_net_admin;
  1126. struct nlmsghdr *nlh;
  1127. unsigned long id;
  1128. u32 index, port = 0;
  1129. bool filled = false;
  1130. err = nlmsg_parse_deprecated(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1131. nldev_policy, NULL);
  1132. /*
  1133. * Right now, we are expecting the device index to get res information,
  1134. * but it is possible to extend this code to return all devices in
  1135. * one shot by checking the existence of RDMA_NLDEV_ATTR_DEV_INDEX.
  1136. * if it doesn't exist, we will iterate over all devices.
  1137. *
  1138. * But it is not needed for now.
  1139. */
  1140. if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  1141. return -EINVAL;
  1142. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1143. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1144. if (!device)
  1145. return -EINVAL;
  1146. /*
  1147. * If no PORT_INDEX is supplied, we will return all QPs from that device
  1148. */
  1149. if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
  1150. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1151. if (!rdma_is_port_valid(device, port)) {
  1152. ret = -EINVAL;
  1153. goto err_index;
  1154. }
  1155. }
  1156. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  1157. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1158. RDMA_NL_GET_OP(cb->nlh->nlmsg_type)),
  1159. 0, NLM_F_MULTI);
  1160. if (fill_nldev_handle(skb, device)) {
  1161. ret = -EMSGSIZE;
  1162. goto err;
  1163. }
  1164. table_attr = nla_nest_start_noflag(skb, fe->nldev_attr);
  1165. if (!table_attr) {
  1166. ret = -EMSGSIZE;
  1167. goto err;
  1168. }
  1169. has_cap_net_admin = netlink_capable(cb->skb, CAP_NET_ADMIN);
  1170. rt = &device->res[res_type];
  1171. xa_lock(&rt->xa);
  1172. /*
  1173. * FIXME: if the skip ahead is something common this loop should
  1174. * use xas_for_each & xas_pause to optimize, we can have a lot of
  1175. * objects.
  1176. */
  1177. xa_for_each(&rt->xa, id, res) {
  1178. if (idx < start || !rdma_restrack_get(res))
  1179. goto next;
  1180. xa_unlock(&rt->xa);
  1181. filled = true;
  1182. entry_attr = nla_nest_start_noflag(skb, fe->entry);
  1183. if (!entry_attr) {
  1184. ret = -EMSGSIZE;
  1185. rdma_restrack_put(res);
  1186. goto msg_full;
  1187. }
  1188. ret = fill_func(skb, has_cap_net_admin, res, port);
  1189. rdma_restrack_put(res);
  1190. if (ret) {
  1191. nla_nest_cancel(skb, entry_attr);
  1192. if (ret == -EMSGSIZE)
  1193. goto msg_full;
  1194. if (ret == -EAGAIN)
  1195. goto again;
  1196. goto res_err;
  1197. }
  1198. nla_nest_end(skb, entry_attr);
  1199. again: xa_lock(&rt->xa);
  1200. next: idx++;
  1201. }
  1202. xa_unlock(&rt->xa);
  1203. msg_full:
  1204. nla_nest_end(skb, table_attr);
  1205. nlmsg_end(skb, nlh);
  1206. cb->args[0] = idx;
  1207. /*
  1208. * No more entries to fill, cancel the message and
  1209. * return 0 to mark end of dumpit.
  1210. */
  1211. if (!filled)
  1212. goto err;
  1213. ib_device_put(device);
  1214. return skb->len;
  1215. res_err:
  1216. nla_nest_cancel(skb, table_attr);
  1217. err:
  1218. nlmsg_cancel(skb, nlh);
  1219. err_index:
  1220. ib_device_put(device);
  1221. return ret;
  1222. }
  1223. #define RES_GET_FUNCS(name, type) \
  1224. static int nldev_res_get_##name##_dumpit(struct sk_buff *skb, \
  1225. struct netlink_callback *cb) \
  1226. { \
  1227. return res_get_common_dumpit(skb, cb, type, \
  1228. fill_res_##name##_entry); \
  1229. } \
  1230. static int nldev_res_get_##name##_doit(struct sk_buff *skb, \
  1231. struct nlmsghdr *nlh, \
  1232. struct netlink_ext_ack *extack) \
  1233. { \
  1234. return res_get_common_doit(skb, nlh, extack, type, \
  1235. fill_res_##name##_entry); \
  1236. }
  1237. RES_GET_FUNCS(qp, RDMA_RESTRACK_QP);
  1238. RES_GET_FUNCS(qp_raw, RDMA_RESTRACK_QP);
  1239. RES_GET_FUNCS(cm_id, RDMA_RESTRACK_CM_ID);
  1240. RES_GET_FUNCS(cq, RDMA_RESTRACK_CQ);
  1241. RES_GET_FUNCS(cq_raw, RDMA_RESTRACK_CQ);
  1242. RES_GET_FUNCS(pd, RDMA_RESTRACK_PD);
  1243. RES_GET_FUNCS(mr, RDMA_RESTRACK_MR);
  1244. RES_GET_FUNCS(mr_raw, RDMA_RESTRACK_MR);
  1245. RES_GET_FUNCS(counter, RDMA_RESTRACK_COUNTER);
  1246. static LIST_HEAD(link_ops);
  1247. static DECLARE_RWSEM(link_ops_rwsem);
  1248. static const struct rdma_link_ops *link_ops_get(const char *type)
  1249. {
  1250. const struct rdma_link_ops *ops;
  1251. list_for_each_entry(ops, &link_ops, list) {
  1252. if (!strcmp(ops->type, type))
  1253. goto out;
  1254. }
  1255. ops = NULL;
  1256. out:
  1257. return ops;
  1258. }
  1259. void rdma_link_register(struct rdma_link_ops *ops)
  1260. {
  1261. down_write(&link_ops_rwsem);
  1262. if (WARN_ON_ONCE(link_ops_get(ops->type)))
  1263. goto out;
  1264. list_add(&ops->list, &link_ops);
  1265. out:
  1266. up_write(&link_ops_rwsem);
  1267. }
  1268. EXPORT_SYMBOL(rdma_link_register);
  1269. void rdma_link_unregister(struct rdma_link_ops *ops)
  1270. {
  1271. down_write(&link_ops_rwsem);
  1272. list_del(&ops->list);
  1273. up_write(&link_ops_rwsem);
  1274. }
  1275. EXPORT_SYMBOL(rdma_link_unregister);
  1276. static int nldev_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  1277. struct netlink_ext_ack *extack)
  1278. {
  1279. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1280. char ibdev_name[IB_DEVICE_NAME_MAX];
  1281. const struct rdma_link_ops *ops;
  1282. char ndev_name[IFNAMSIZ];
  1283. struct net_device *ndev;
  1284. char type[IFNAMSIZ];
  1285. int err;
  1286. err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1287. nldev_policy, extack);
  1288. if (err || !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
  1289. !tb[RDMA_NLDEV_ATTR_LINK_TYPE] || !tb[RDMA_NLDEV_ATTR_NDEV_NAME])
  1290. return -EINVAL;
  1291. nla_strlcpy(ibdev_name, tb[RDMA_NLDEV_ATTR_DEV_NAME],
  1292. sizeof(ibdev_name));
  1293. if (strchr(ibdev_name, '%') || strlen(ibdev_name) == 0)
  1294. return -EINVAL;
  1295. nla_strlcpy(type, tb[RDMA_NLDEV_ATTR_LINK_TYPE], sizeof(type));
  1296. nla_strlcpy(ndev_name, tb[RDMA_NLDEV_ATTR_NDEV_NAME],
  1297. sizeof(ndev_name));
  1298. ndev = dev_get_by_name(sock_net(skb->sk), ndev_name);
  1299. if (!ndev)
  1300. return -ENODEV;
  1301. down_read(&link_ops_rwsem);
  1302. ops = link_ops_get(type);
  1303. #ifdef CONFIG_MODULES
  1304. if (!ops) {
  1305. up_read(&link_ops_rwsem);
  1306. request_module("rdma-link-%s", type);
  1307. down_read(&link_ops_rwsem);
  1308. ops = link_ops_get(type);
  1309. }
  1310. #endif
  1311. err = ops ? ops->newlink(ibdev_name, ndev) : -EINVAL;
  1312. up_read(&link_ops_rwsem);
  1313. dev_put(ndev);
  1314. return err;
  1315. }
  1316. static int nldev_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
  1317. struct netlink_ext_ack *extack)
  1318. {
  1319. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1320. struct ib_device *device;
  1321. u32 index;
  1322. int err;
  1323. err = nlmsg_parse_deprecated(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1324. nldev_policy, extack);
  1325. if (err || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
  1326. return -EINVAL;
  1327. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1328. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1329. if (!device)
  1330. return -EINVAL;
  1331. if (!(device->attrs.device_cap_flags & IB_DEVICE_ALLOW_USER_UNREG)) {
  1332. ib_device_put(device);
  1333. return -EINVAL;
  1334. }
  1335. ib_unregister_device_and_put(device);
  1336. return 0;
  1337. }
  1338. static int nldev_get_chardev(struct sk_buff *skb, struct nlmsghdr *nlh,
  1339. struct netlink_ext_ack *extack)
  1340. {
  1341. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1342. char client_name[RDMA_NLDEV_ATTR_CHARDEV_TYPE_SIZE];
  1343. struct ib_client_nl_info data = {};
  1344. struct ib_device *ibdev = NULL;
  1345. struct sk_buff *msg;
  1346. u32 index;
  1347. int err;
  1348. err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1, nldev_policy,
  1349. extack);
  1350. if (err || !tb[RDMA_NLDEV_ATTR_CHARDEV_TYPE])
  1351. return -EINVAL;
  1352. nla_strlcpy(client_name, tb[RDMA_NLDEV_ATTR_CHARDEV_TYPE],
  1353. sizeof(client_name));
  1354. if (tb[RDMA_NLDEV_ATTR_DEV_INDEX]) {
  1355. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1356. ibdev = ib_device_get_by_index(sock_net(skb->sk), index);
  1357. if (!ibdev)
  1358. return -EINVAL;
  1359. if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
  1360. data.port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1361. if (!rdma_is_port_valid(ibdev, data.port)) {
  1362. err = -EINVAL;
  1363. goto out_put;
  1364. }
  1365. } else {
  1366. data.port = -1;
  1367. }
  1368. } else if (tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
  1369. return -EINVAL;
  1370. }
  1371. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1372. if (!msg) {
  1373. err = -ENOMEM;
  1374. goto out_put;
  1375. }
  1376. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1377. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1378. RDMA_NLDEV_CMD_GET_CHARDEV),
  1379. 0, 0);
  1380. data.nl_msg = msg;
  1381. err = ib_get_client_nl_info(ibdev, client_name, &data);
  1382. if (err)
  1383. goto out_nlmsg;
  1384. err = nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CHARDEV,
  1385. huge_encode_dev(data.cdev->devt),
  1386. RDMA_NLDEV_ATTR_PAD);
  1387. if (err)
  1388. goto out_data;
  1389. err = nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_CHARDEV_ABI, data.abi,
  1390. RDMA_NLDEV_ATTR_PAD);
  1391. if (err)
  1392. goto out_data;
  1393. if (nla_put_string(msg, RDMA_NLDEV_ATTR_CHARDEV_NAME,
  1394. dev_name(data.cdev))) {
  1395. err = -EMSGSIZE;
  1396. goto out_data;
  1397. }
  1398. nlmsg_end(msg, nlh);
  1399. put_device(data.cdev);
  1400. if (ibdev)
  1401. ib_device_put(ibdev);
  1402. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1403. out_data:
  1404. put_device(data.cdev);
  1405. out_nlmsg:
  1406. nlmsg_free(msg);
  1407. out_put:
  1408. if (ibdev)
  1409. ib_device_put(ibdev);
  1410. return err;
  1411. }
  1412. static int nldev_sys_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1413. struct netlink_ext_ack *extack)
  1414. {
  1415. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1416. struct sk_buff *msg;
  1417. int err;
  1418. err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1419. nldev_policy, extack);
  1420. if (err)
  1421. return err;
  1422. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1423. if (!msg)
  1424. return -ENOMEM;
  1425. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1426. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1427. RDMA_NLDEV_CMD_SYS_GET),
  1428. 0, 0);
  1429. err = nla_put_u8(msg, RDMA_NLDEV_SYS_ATTR_NETNS_MODE,
  1430. (u8)ib_devices_shared_netns);
  1431. if (err) {
  1432. nlmsg_free(msg);
  1433. return err;
  1434. }
  1435. nlmsg_end(msg, nlh);
  1436. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1437. }
  1438. static int nldev_set_sys_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1439. struct netlink_ext_ack *extack)
  1440. {
  1441. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1442. u8 enable;
  1443. int err;
  1444. err = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1445. nldev_policy, extack);
  1446. if (err || !tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE])
  1447. return -EINVAL;
  1448. enable = nla_get_u8(tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]);
  1449. /* Only 0 and 1 are supported */
  1450. if (enable > 1)
  1451. return -EINVAL;
  1452. err = rdma_compatdev_set(enable);
  1453. return err;
  1454. }
  1455. static int nldev_stat_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1456. struct netlink_ext_ack *extack)
  1457. {
  1458. u32 index, port, mode, mask = 0, qpn, cntn = 0;
  1459. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1460. struct ib_device *device;
  1461. struct sk_buff *msg;
  1462. int ret;
  1463. ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1464. nldev_policy, extack);
  1465. /* Currently only counter for QP is supported */
  1466. if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES] ||
  1467. !tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
  1468. !tb[RDMA_NLDEV_ATTR_PORT_INDEX] || !tb[RDMA_NLDEV_ATTR_STAT_MODE])
  1469. return -EINVAL;
  1470. if (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES]) != RDMA_NLDEV_ATTR_RES_QP)
  1471. return -EINVAL;
  1472. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1473. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1474. if (!device)
  1475. return -EINVAL;
  1476. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1477. if (!rdma_is_port_valid(device, port)) {
  1478. ret = -EINVAL;
  1479. goto err;
  1480. }
  1481. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1482. if (!msg) {
  1483. ret = -ENOMEM;
  1484. goto err;
  1485. }
  1486. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1487. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1488. RDMA_NLDEV_CMD_STAT_SET),
  1489. 0, 0);
  1490. mode = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_MODE]);
  1491. if (mode == RDMA_COUNTER_MODE_AUTO) {
  1492. if (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK])
  1493. mask = nla_get_u32(
  1494. tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK]);
  1495. ret = rdma_counter_set_auto_mode(device, port,
  1496. mask ? true : false, mask);
  1497. if (ret)
  1498. goto err_msg;
  1499. } else {
  1500. if (!tb[RDMA_NLDEV_ATTR_RES_LQPN])
  1501. goto err_msg;
  1502. qpn = nla_get_u32(tb[RDMA_NLDEV_ATTR_RES_LQPN]);
  1503. if (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]) {
  1504. cntn = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]);
  1505. ret = rdma_counter_bind_qpn(device, port, qpn, cntn);
  1506. } else {
  1507. ret = rdma_counter_bind_qpn_alloc(device, port,
  1508. qpn, &cntn);
  1509. }
  1510. if (ret)
  1511. goto err_msg;
  1512. if (fill_nldev_handle(msg, device) ||
  1513. nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) ||
  1514. nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, cntn) ||
  1515. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn)) {
  1516. ret = -EMSGSIZE;
  1517. goto err_fill;
  1518. }
  1519. }
  1520. nlmsg_end(msg, nlh);
  1521. ib_device_put(device);
  1522. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1523. err_fill:
  1524. rdma_counter_unbind_qpn(device, port, qpn, cntn);
  1525. err_msg:
  1526. nlmsg_free(msg);
  1527. err:
  1528. ib_device_put(device);
  1529. return ret;
  1530. }
  1531. static int nldev_stat_del_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1532. struct netlink_ext_ack *extack)
  1533. {
  1534. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1535. struct ib_device *device;
  1536. struct sk_buff *msg;
  1537. u32 index, port, qpn, cntn;
  1538. int ret;
  1539. ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1540. nldev_policy, extack);
  1541. if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES] ||
  1542. !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX] ||
  1543. !tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID] ||
  1544. !tb[RDMA_NLDEV_ATTR_RES_LQPN])
  1545. return -EINVAL;
  1546. if (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES]) != RDMA_NLDEV_ATTR_RES_QP)
  1547. return -EINVAL;
  1548. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1549. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1550. if (!device)
  1551. return -EINVAL;
  1552. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1553. if (!rdma_is_port_valid(device, port)) {
  1554. ret = -EINVAL;
  1555. goto err;
  1556. }
  1557. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1558. if (!msg) {
  1559. ret = -ENOMEM;
  1560. goto err;
  1561. }
  1562. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1563. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1564. RDMA_NLDEV_CMD_STAT_SET),
  1565. 0, 0);
  1566. cntn = nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID]);
  1567. qpn = nla_get_u32(tb[RDMA_NLDEV_ATTR_RES_LQPN]);
  1568. if (fill_nldev_handle(msg, device) ||
  1569. nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) ||
  1570. nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_COUNTER_ID, cntn) ||
  1571. nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_LQPN, qpn)) {
  1572. ret = -EMSGSIZE;
  1573. goto err_fill;
  1574. }
  1575. ret = rdma_counter_unbind_qpn(device, port, qpn, cntn);
  1576. if (ret)
  1577. goto err_fill;
  1578. nlmsg_end(msg, nlh);
  1579. ib_device_put(device);
  1580. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1581. err_fill:
  1582. nlmsg_free(msg);
  1583. err:
  1584. ib_device_put(device);
  1585. return ret;
  1586. }
  1587. static int stat_get_doit_default_counter(struct sk_buff *skb,
  1588. struct nlmsghdr *nlh,
  1589. struct netlink_ext_ack *extack,
  1590. struct nlattr *tb[])
  1591. {
  1592. struct rdma_hw_stats *stats;
  1593. struct nlattr *table_attr;
  1594. struct ib_device *device;
  1595. int ret, num_cnts, i;
  1596. struct sk_buff *msg;
  1597. u32 index, port;
  1598. u64 v;
  1599. if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX])
  1600. return -EINVAL;
  1601. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1602. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1603. if (!device)
  1604. return -EINVAL;
  1605. if (!device->ops.alloc_hw_stats || !device->ops.get_hw_stats) {
  1606. ret = -EINVAL;
  1607. goto err;
  1608. }
  1609. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1610. if (!rdma_is_port_valid(device, port)) {
  1611. ret = -EINVAL;
  1612. goto err;
  1613. }
  1614. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1615. if (!msg) {
  1616. ret = -ENOMEM;
  1617. goto err;
  1618. }
  1619. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1620. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1621. RDMA_NLDEV_CMD_STAT_GET),
  1622. 0, 0);
  1623. if (fill_nldev_handle(msg, device) ||
  1624. nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port)) {
  1625. ret = -EMSGSIZE;
  1626. goto err_msg;
  1627. }
  1628. stats = device->port_data ? device->port_data[port].hw_stats : NULL;
  1629. if (stats == NULL) {
  1630. ret = -EINVAL;
  1631. goto err_msg;
  1632. }
  1633. mutex_lock(&stats->lock);
  1634. num_cnts = device->ops.get_hw_stats(device, stats, port, 0);
  1635. if (num_cnts < 0) {
  1636. ret = -EINVAL;
  1637. goto err_stats;
  1638. }
  1639. table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_STAT_HWCOUNTERS);
  1640. if (!table_attr) {
  1641. ret = -EMSGSIZE;
  1642. goto err_stats;
  1643. }
  1644. for (i = 0; i < num_cnts; i++) {
  1645. v = stats->value[i] +
  1646. rdma_counter_get_hwstat_value(device, port, i);
  1647. if (rdma_nl_stat_hwcounter_entry(msg, stats->names[i], v)) {
  1648. ret = -EMSGSIZE;
  1649. goto err_table;
  1650. }
  1651. }
  1652. nla_nest_end(msg, table_attr);
  1653. mutex_unlock(&stats->lock);
  1654. nlmsg_end(msg, nlh);
  1655. ib_device_put(device);
  1656. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1657. err_table:
  1658. nla_nest_cancel(msg, table_attr);
  1659. err_stats:
  1660. mutex_unlock(&stats->lock);
  1661. err_msg:
  1662. nlmsg_free(msg);
  1663. err:
  1664. ib_device_put(device);
  1665. return ret;
  1666. }
  1667. static int stat_get_doit_qp(struct sk_buff *skb, struct nlmsghdr *nlh,
  1668. struct netlink_ext_ack *extack, struct nlattr *tb[])
  1669. {
  1670. static enum rdma_nl_counter_mode mode;
  1671. static enum rdma_nl_counter_mask mask;
  1672. struct ib_device *device;
  1673. struct sk_buff *msg;
  1674. u32 index, port;
  1675. int ret;
  1676. if (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID])
  1677. return nldev_res_get_counter_doit(skb, nlh, extack);
  1678. if (!tb[RDMA_NLDEV_ATTR_STAT_MODE] ||
  1679. !tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX])
  1680. return -EINVAL;
  1681. index = nla_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  1682. device = ib_device_get_by_index(sock_net(skb->sk), index);
  1683. if (!device)
  1684. return -EINVAL;
  1685. port = nla_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
  1686. if (!rdma_is_port_valid(device, port)) {
  1687. ret = -EINVAL;
  1688. goto err;
  1689. }
  1690. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  1691. if (!msg) {
  1692. ret = -ENOMEM;
  1693. goto err;
  1694. }
  1695. nlh = nlmsg_put(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq,
  1696. RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
  1697. RDMA_NLDEV_CMD_STAT_GET),
  1698. 0, 0);
  1699. ret = rdma_counter_get_mode(device, port, &mode, &mask);
  1700. if (ret)
  1701. goto err_msg;
  1702. if (fill_nldev_handle(msg, device) ||
  1703. nla_put_u32(msg, RDMA_NLDEV_ATTR_PORT_INDEX, port) ||
  1704. nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_MODE, mode)) {
  1705. ret = -EMSGSIZE;
  1706. goto err_msg;
  1707. }
  1708. if ((mode == RDMA_COUNTER_MODE_AUTO) &&
  1709. nla_put_u32(msg, RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK, mask)) {
  1710. ret = -EMSGSIZE;
  1711. goto err_msg;
  1712. }
  1713. nlmsg_end(msg, nlh);
  1714. ib_device_put(device);
  1715. return rdma_nl_unicast(sock_net(skb->sk), msg, NETLINK_CB(skb).portid);
  1716. err_msg:
  1717. nlmsg_free(msg);
  1718. err:
  1719. ib_device_put(device);
  1720. return ret;
  1721. }
  1722. static int nldev_stat_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh,
  1723. struct netlink_ext_ack *extack)
  1724. {
  1725. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1726. int ret;
  1727. ret = nlmsg_parse(nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1728. nldev_policy, extack);
  1729. if (ret)
  1730. return -EINVAL;
  1731. if (!tb[RDMA_NLDEV_ATTR_STAT_RES])
  1732. return stat_get_doit_default_counter(skb, nlh, extack, tb);
  1733. switch (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES])) {
  1734. case RDMA_NLDEV_ATTR_RES_QP:
  1735. ret = stat_get_doit_qp(skb, nlh, extack, tb);
  1736. break;
  1737. case RDMA_NLDEV_ATTR_RES_MR:
  1738. ret = res_get_common_doit(skb, nlh, extack, RDMA_RESTRACK_MR,
  1739. fill_stat_mr_entry);
  1740. break;
  1741. default:
  1742. ret = -EINVAL;
  1743. break;
  1744. }
  1745. return ret;
  1746. }
  1747. static int nldev_stat_get_dumpit(struct sk_buff *skb,
  1748. struct netlink_callback *cb)
  1749. {
  1750. struct nlattr *tb[RDMA_NLDEV_ATTR_MAX];
  1751. int ret;
  1752. ret = nlmsg_parse(cb->nlh, 0, tb, RDMA_NLDEV_ATTR_MAX - 1,
  1753. nldev_policy, NULL);
  1754. if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES])
  1755. return -EINVAL;
  1756. switch (nla_get_u32(tb[RDMA_NLDEV_ATTR_STAT_RES])) {
  1757. case RDMA_NLDEV_ATTR_RES_QP:
  1758. ret = nldev_res_get_counter_dumpit(skb, cb);
  1759. break;
  1760. case RDMA_NLDEV_ATTR_RES_MR:
  1761. ret = res_get_common_dumpit(skb, cb, RDMA_RESTRACK_MR,
  1762. fill_stat_mr_entry);
  1763. break;
  1764. default:
  1765. ret = -EINVAL;
  1766. break;
  1767. }
  1768. return ret;
  1769. }
  1770. static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS] = {
  1771. [RDMA_NLDEV_CMD_GET] = {
  1772. .doit = nldev_get_doit,
  1773. .dump = nldev_get_dumpit,
  1774. },
  1775. [RDMA_NLDEV_CMD_GET_CHARDEV] = {
  1776. .doit = nldev_get_chardev,
  1777. },
  1778. [RDMA_NLDEV_CMD_SET] = {
  1779. .doit = nldev_set_doit,
  1780. .flags = RDMA_NL_ADMIN_PERM,
  1781. },
  1782. [RDMA_NLDEV_CMD_NEWLINK] = {
  1783. .doit = nldev_newlink,
  1784. .flags = RDMA_NL_ADMIN_PERM,
  1785. },
  1786. [RDMA_NLDEV_CMD_DELLINK] = {
  1787. .doit = nldev_dellink,
  1788. .flags = RDMA_NL_ADMIN_PERM,
  1789. },
  1790. [RDMA_NLDEV_CMD_PORT_GET] = {
  1791. .doit = nldev_port_get_doit,
  1792. .dump = nldev_port_get_dumpit,
  1793. },
  1794. [RDMA_NLDEV_CMD_RES_GET] = {
  1795. .doit = nldev_res_get_doit,
  1796. .dump = nldev_res_get_dumpit,
  1797. },
  1798. [RDMA_NLDEV_CMD_RES_QP_GET] = {
  1799. .doit = nldev_res_get_qp_doit,
  1800. .dump = nldev_res_get_qp_dumpit,
  1801. },
  1802. [RDMA_NLDEV_CMD_RES_CM_ID_GET] = {
  1803. .doit = nldev_res_get_cm_id_doit,
  1804. .dump = nldev_res_get_cm_id_dumpit,
  1805. },
  1806. [RDMA_NLDEV_CMD_RES_CQ_GET] = {
  1807. .doit = nldev_res_get_cq_doit,
  1808. .dump = nldev_res_get_cq_dumpit,
  1809. },
  1810. [RDMA_NLDEV_CMD_RES_MR_GET] = {
  1811. .doit = nldev_res_get_mr_doit,
  1812. .dump = nldev_res_get_mr_dumpit,
  1813. },
  1814. [RDMA_NLDEV_CMD_RES_PD_GET] = {
  1815. .doit = nldev_res_get_pd_doit,
  1816. .dump = nldev_res_get_pd_dumpit,
  1817. },
  1818. [RDMA_NLDEV_CMD_SYS_GET] = {
  1819. .doit = nldev_sys_get_doit,
  1820. },
  1821. [RDMA_NLDEV_CMD_SYS_SET] = {
  1822. .doit = nldev_set_sys_set_doit,
  1823. },
  1824. [RDMA_NLDEV_CMD_STAT_SET] = {
  1825. .doit = nldev_stat_set_doit,
  1826. .flags = RDMA_NL_ADMIN_PERM,
  1827. },
  1828. [RDMA_NLDEV_CMD_STAT_GET] = {
  1829. .doit = nldev_stat_get_doit,
  1830. .dump = nldev_stat_get_dumpit,
  1831. },
  1832. [RDMA_NLDEV_CMD_STAT_DEL] = {
  1833. .doit = nldev_stat_del_doit,
  1834. .flags = RDMA_NL_ADMIN_PERM,
  1835. },
  1836. [RDMA_NLDEV_CMD_RES_QP_GET_RAW] = {
  1837. .doit = nldev_res_get_qp_raw_doit,
  1838. .dump = nldev_res_get_qp_raw_dumpit,
  1839. .flags = RDMA_NL_ADMIN_PERM,
  1840. },
  1841. [RDMA_NLDEV_CMD_RES_CQ_GET_RAW] = {
  1842. .doit = nldev_res_get_cq_raw_doit,
  1843. .dump = nldev_res_get_cq_raw_dumpit,
  1844. .flags = RDMA_NL_ADMIN_PERM,
  1845. },
  1846. [RDMA_NLDEV_CMD_RES_MR_GET_RAW] = {
  1847. .doit = nldev_res_get_mr_raw_doit,
  1848. .dump = nldev_res_get_mr_raw_dumpit,
  1849. .flags = RDMA_NL_ADMIN_PERM,
  1850. },
  1851. };
  1852. void __init nldev_init(void)
  1853. {
  1854. rdma_nl_register(RDMA_NL_NLDEV, nldev_cb_table);
  1855. }
  1856. void __exit nldev_exit(void)
  1857. {
  1858. rdma_nl_unregister(RDMA_NL_NLDEV);
  1859. }
  1860. MODULE_ALIAS_RDMA_NETLINK(RDMA_NL_NLDEV, 5);