You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

netvsc.c 22KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848
  1. /*
  2. * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public License as
  6. * published by the Free Software Foundation; either version 2 of the
  7. * License, or (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful, but
  10. * WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12. * General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17. * 02110-1301, USA.
  18. *
  19. * You can also choose to distribute this program under the terms of
  20. * the Unmodified Binary Distribution Licence (as given in the file
  21. * COPYING.UBDL), provided that you have satisfied its requirements.
  22. */
  23. FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  24. /** @file
  25. *
  26. * Hyper-V network virtual service client
  27. *
  28. * The network virtual service client (NetVSC) connects to the network
  29. * virtual service provider (NetVSP) via the Hyper-V virtual machine
  30. * bus (VMBus). It provides a transport layer for RNDIS packets.
  31. */
  32. #include <errno.h>
  33. #include <unistd.h>
  34. #include <byteswap.h>
  35. #include <ipxe/umalloc.h>
  36. #include <ipxe/rndis.h>
  37. #include <ipxe/vmbus.h>
  38. #include "netvsc.h"
  39. /**
  40. * Send control message and wait for completion
  41. *
  42. * @v netvsc NetVSC device
  43. * @v xrid Relative transaction ID
  44. * @v data Data
  45. * @v len Length of data
  46. * @ret rc Return status code
  47. */
  48. static int netvsc_control ( struct netvsc_device *netvsc, unsigned int xrid,
  49. const void *data, size_t len ) {
  50. uint64_t xid = ( NETVSC_BASE_XID + xrid );
  51. unsigned int i;
  52. int rc;
  53. /* Send control message */
  54. if ( ( rc = vmbus_send_control ( netvsc->vmdev, xid, data, len ) ) !=0){
  55. DBGC ( netvsc, "NETVSC %s could not send control message: %s\n",
  56. netvsc->name, strerror ( rc ) );
  57. return rc;
  58. }
  59. /* Record transaction ID */
  60. netvsc->wait_xrid = xrid;
  61. /* Wait for operation to complete */
  62. for ( i = 0 ; i < NETVSC_MAX_WAIT_MS ; i++ ) {
  63. /* Check for completion */
  64. if ( ! netvsc->wait_xrid )
  65. return netvsc->wait_rc;
  66. /* Poll VMBus device */
  67. vmbus_poll ( netvsc->vmdev );
  68. /* Delay for 1ms */
  69. mdelay ( 1 );
  70. }
  71. DBGC ( netvsc, "NETVSC %s timed out waiting for XRID %d\n",
  72. netvsc->name, xrid );
  73. vmbus_dump_channel ( netvsc->vmdev );
  74. return -ETIMEDOUT;
  75. }
  76. /**
  77. * Handle generic completion
  78. *
  79. * @v netvsc NetVSC device
  80. * @v data Data
  81. * @v len Length of data
  82. * @ret rc Return status code
  83. */
  84. static int netvsc_completed ( struct netvsc_device *netvsc __unused,
  85. const void *data __unused, size_t len __unused ) {
  86. return 0;
  87. }
  88. /**
  89. * Initialise communication
  90. *
  91. * @v netvsc NetVSC device
  92. * @ret rc Return status code
  93. */
  94. static int netvsc_initialise ( struct netvsc_device *netvsc ) {
  95. struct netvsc_init_message msg;
  96. int rc;
  97. /* Construct message */
  98. memset ( &msg, 0, sizeof ( msg ) );
  99. msg.header.type = cpu_to_le32 ( NETVSC_INIT_MSG );
  100. msg.min = cpu_to_le32 ( NETVSC_VERSION_1 );
  101. msg.max = cpu_to_le32 ( NETVSC_VERSION_1 );
  102. /* Send message and wait for completion */
  103. if ( ( rc = netvsc_control ( netvsc, NETVSC_INIT_XRID, &msg,
  104. sizeof ( msg ) ) ) != 0 ) {
  105. DBGC ( netvsc, "NETVSC %s could not initialise: %s\n",
  106. netvsc->name, strerror ( rc ) );
  107. return rc;
  108. }
  109. return 0;
  110. }
  111. /**
  112. * Handle initialisation completion
  113. *
  114. * @v netvsc NetVSC device
  115. * @v data Data
  116. * @v len Length of data
  117. * @ret rc Return status code
  118. */
  119. static int
  120. netvsc_initialised ( struct netvsc_device *netvsc, const void *data,
  121. size_t len ) {
  122. const struct netvsc_init_completion *cmplt = data;
  123. /* Check completion */
  124. if ( len < sizeof ( *cmplt ) ) {
  125. DBGC ( netvsc, "NETVSC %s underlength initialisation "
  126. "completion (%zd bytes)\n", netvsc->name, len );
  127. return -EINVAL;
  128. }
  129. if ( cmplt->header.type != cpu_to_le32 ( NETVSC_INIT_CMPLT ) ) {
  130. DBGC ( netvsc, "NETVSC %s unexpected initialisation completion "
  131. "type %d\n", netvsc->name,
  132. le32_to_cpu ( cmplt->header.type ) );
  133. return -EPROTO;
  134. }
  135. if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
  136. DBGC ( netvsc, "NETVSC %s initialisation failure status %d\n",
  137. netvsc->name, le32_to_cpu ( cmplt->status ) );
  138. return -EPROTO;
  139. }
  140. return 0;
  141. }
  142. /**
  143. * Set NDIS version
  144. *
  145. * @v netvsc NetVSC device
  146. * @ret rc Return status code
  147. */
  148. static int netvsc_ndis_version ( struct netvsc_device *netvsc ) {
  149. struct netvsc_ndis_version_message msg;
  150. int rc;
  151. /* Construct message */
  152. memset ( &msg, 0, sizeof ( msg ) );
  153. msg.header.type = cpu_to_le32 ( NETVSC_NDIS_VERSION_MSG );
  154. msg.major = cpu_to_le32 ( NETVSC_NDIS_MAJOR );
  155. msg.minor = cpu_to_le32 ( NETVSC_NDIS_MINOR );
  156. /* Send message and wait for completion */
  157. if ( ( rc = netvsc_control ( netvsc, NETVSC_NDIS_VERSION_XRID,
  158. &msg, sizeof ( msg ) ) ) != 0 ) {
  159. DBGC ( netvsc, "NETVSC %s could not set NDIS version: %s\n",
  160. netvsc->name, strerror ( rc ) );
  161. return rc;
  162. }
  163. return 0;
  164. }
  165. /**
  166. * Establish data buffer
  167. *
  168. * @v netvsc NetVSC device
  169. * @v buffer Data buffer
  170. * @ret rc Return status code
  171. */
  172. static int netvsc_establish_buffer ( struct netvsc_device *netvsc,
  173. struct netvsc_buffer *buffer ) {
  174. struct netvsc_establish_buffer_message msg;
  175. int rc;
  176. /* Construct message */
  177. memset ( &msg, 0, sizeof ( msg ) );
  178. msg.header.type = cpu_to_le32 ( buffer->establish_type );
  179. msg.gpadl = cpu_to_le32 ( buffer->gpadl );
  180. msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
  181. /* Send message and wait for completion */
  182. if ( ( rc = netvsc_control ( netvsc, buffer->establish_xrid, &msg,
  183. sizeof ( msg ) ) ) != 0 ) {
  184. DBGC ( netvsc, "NETVSC %s could not establish buffer: %s\n",
  185. netvsc->name, strerror ( rc ) );
  186. return rc;
  187. }
  188. return 0;
  189. }
  190. /**
  191. * Handle establish receive data buffer completion
  192. *
  193. * @v netvsc NetVSC device
  194. * @v data Data
  195. * @v len Length of data
  196. * @ret rc Return status code
  197. */
  198. static int netvsc_rx_established_buffer ( struct netvsc_device *netvsc,
  199. const void *data, size_t len ) {
  200. const struct netvsc_rx_establish_buffer_completion *cmplt = data;
  201. /* Check completion */
  202. if ( len < sizeof ( *cmplt ) ) {
  203. DBGC ( netvsc, "NETVSC %s underlength buffer completion (%zd "
  204. "bytes)\n", netvsc->name, len );
  205. return -EINVAL;
  206. }
  207. if ( cmplt->header.type != cpu_to_le32 ( NETVSC_RX_ESTABLISH_CMPLT ) ) {
  208. DBGC ( netvsc, "NETVSC %s unexpected buffer completion type "
  209. "%d\n", netvsc->name, le32_to_cpu ( cmplt->header.type));
  210. return -EPROTO;
  211. }
  212. if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) {
  213. DBGC ( netvsc, "NETVSC %s buffer failure status %d\n",
  214. netvsc->name, le32_to_cpu ( cmplt->status ) );
  215. return -EPROTO;
  216. }
  217. return 0;
  218. }
  219. /**
  220. * Revoke data buffer
  221. *
  222. * @v netvsc NetVSC device
  223. * @v buffer Data buffer
  224. * @ret rc Return status code
  225. */
  226. static int netvsc_revoke_buffer ( struct netvsc_device *netvsc,
  227. struct netvsc_buffer *buffer ) {
  228. struct netvsc_revoke_buffer_message msg;
  229. int rc;
  230. /* Construct message */
  231. memset ( &msg, 0, sizeof ( msg ) );
  232. msg.header.type = cpu_to_le32 ( buffer->revoke_type );
  233. msg.pageset = buffer->pages.pageset; /* Already protocol-endian */
  234. /* Send message and wait for completion */
  235. if ( ( rc = netvsc_control ( netvsc, buffer->revoke_xrid,
  236. &msg, sizeof ( msg ) ) ) != 0 ) {
  237. DBGC ( netvsc, "NETVSC %s could not revoke buffer: %s\n",
  238. netvsc->name, strerror ( rc ) );
  239. return rc;
  240. }
  241. return 0;
  242. }
  243. /**
  244. * Handle received control packet
  245. *
  246. * @v vmdev VMBus device
  247. * @v xid Transaction ID
  248. * @v data Data
  249. * @v len Length of data
  250. * @ret rc Return status code
  251. */
  252. static int netvsc_recv_control ( struct vmbus_device *vmdev, uint64_t xid,
  253. const void *data, size_t len ) {
  254. struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
  255. struct netvsc_device *netvsc = rndis->priv;
  256. DBGC ( netvsc, "NETVSC %s received unsupported control packet "
  257. "(%08llx):\n", netvsc->name, xid );
  258. DBGC_HDA ( netvsc, 0, data, len );
  259. return -ENOTSUP;
  260. }
  261. /**
  262. * Handle received data packet
  263. *
  264. * @v vmdev VMBus device
  265. * @v xid Transaction ID
  266. * @v data Data
  267. * @v len Length of data
  268. * @v list List of I/O buffers
  269. * @ret rc Return status code
  270. */
  271. static int netvsc_recv_data ( struct vmbus_device *vmdev, uint64_t xid,
  272. const void *data, size_t len,
  273. struct list_head *list ) {
  274. struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
  275. struct netvsc_device *netvsc = rndis->priv;
  276. const struct netvsc_rndis_message *msg = data;
  277. struct io_buffer *iobuf;
  278. struct io_buffer *tmp;
  279. int rc;
  280. /* Sanity check */
  281. if ( len < sizeof ( *msg ) ) {
  282. DBGC ( netvsc, "NETVSC %s received underlength RNDIS packet "
  283. "(%zd bytes)\n", netvsc->name, len );
  284. rc = -EINVAL;
  285. goto err_sanity;
  286. }
  287. if ( msg->header.type != cpu_to_le32 ( NETVSC_RNDIS_MSG ) ) {
  288. DBGC ( netvsc, "NETVSC %s received unexpected RNDIS packet "
  289. "type %d\n", netvsc->name,
  290. le32_to_cpu ( msg->header.type ) );
  291. rc = -EINVAL;
  292. goto err_sanity;
  293. }
  294. /* Send completion back to host */
  295. if ( ( rc = vmbus_send_completion ( vmdev, xid, NULL, 0 ) ) != 0 ) {
  296. DBGC ( netvsc, "NETVSC %s could not send completion: %s\n",
  297. netvsc->name, strerror ( rc ) );
  298. goto err_completion;
  299. }
  300. /* Hand off to RNDIS */
  301. list_for_each_entry_safe ( iobuf, tmp, list, list ) {
  302. list_del ( &iobuf->list );
  303. rndis_rx ( rndis, iob_disown ( iobuf ) );
  304. }
  305. return 0;
  306. err_completion:
  307. err_sanity:
  308. list_for_each_entry_safe ( iobuf, tmp, list, list ) {
  309. list_del ( &iobuf->list );
  310. free_iob ( iobuf );
  311. }
  312. return rc;
  313. }
  314. /**
  315. * Handle received completion packet
  316. *
  317. * @v vmdev VMBus device
  318. * @v xid Transaction ID
  319. * @v data Data
  320. * @v len Length of data
  321. * @ret rc Return status code
  322. */
  323. static int netvsc_recv_completion ( struct vmbus_device *vmdev, uint64_t xid,
  324. const void *data, size_t len ) {
  325. struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
  326. struct netvsc_device *netvsc = rndis->priv;
  327. struct io_buffer *iobuf;
  328. int ( * completion ) ( struct netvsc_device *netvsc,
  329. const void *data, size_t len );
  330. unsigned int xrid = ( xid - NETVSC_BASE_XID );
  331. unsigned int tx_id;
  332. int rc;
  333. /* Handle transmit completion, if applicable */
  334. tx_id = ( xrid - NETVSC_TX_BASE_XRID );
  335. if ( ( tx_id < NETVSC_TX_NUM_DESC ) &&
  336. ( ( iobuf = netvsc->tx.iobufs[tx_id] ) != NULL ) ) {
  337. /* Free buffer ID */
  338. netvsc->tx.iobufs[tx_id] = NULL;
  339. netvsc->tx.ids[ ( netvsc->tx.id_cons++ ) &
  340. ( netvsc->tx.count - 1 ) ] = tx_id;
  341. /* Hand back to RNDIS */
  342. rndis_tx_complete ( rndis, iobuf );
  343. return 0;
  344. }
  345. /* Otherwise determine completion handler */
  346. if ( xrid == NETVSC_INIT_XRID ) {
  347. completion = netvsc_initialised;
  348. } else if ( xrid == NETVSC_RX_ESTABLISH_XRID ) {
  349. completion = netvsc_rx_established_buffer;
  350. } else if ( ( netvsc->wait_xrid != 0 ) &&
  351. ( xrid == netvsc->wait_xrid ) ) {
  352. completion = netvsc_completed;
  353. } else {
  354. DBGC ( netvsc, "NETVSC %s received unexpected completion "
  355. "(%08llx)\n", netvsc->name, xid );
  356. return -EPIPE;
  357. }
  358. /* Hand off to completion handler */
  359. rc = completion ( netvsc, data, len );
  360. /* Record completion handler result if applicable */
  361. if ( xrid == netvsc->wait_xrid ) {
  362. netvsc->wait_xrid = 0;
  363. netvsc->wait_rc = rc;
  364. }
  365. return rc;
  366. }
  367. /**
  368. * Handle received cancellation packet
  369. *
  370. * @v vmdev VMBus device
  371. * @v xid Transaction ID
  372. * @ret rc Return status code
  373. */
  374. static int netvsc_recv_cancellation ( struct vmbus_device *vmdev,
  375. uint64_t xid ) {
  376. struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
  377. struct netvsc_device *netvsc = rndis->priv;
  378. DBGC ( netvsc, "NETVSC %s received unsupported cancellation packet "
  379. "(%08llx):\n", netvsc->name, xid );
  380. return -ENOTSUP;
  381. }
  382. /** VMBus channel operations */
  383. static struct vmbus_channel_operations netvsc_channel_operations = {
  384. .recv_control = netvsc_recv_control,
  385. .recv_data = netvsc_recv_data,
  386. .recv_completion = netvsc_recv_completion,
  387. .recv_cancellation = netvsc_recv_cancellation,
  388. };
  389. /**
  390. * Poll for completed and received packets
  391. *
  392. * @v rndis RNDIS device
  393. */
  394. static void netvsc_poll ( struct rndis_device *rndis ) {
  395. struct netvsc_device *netvsc = rndis->priv;
  396. struct vmbus_device *vmdev = netvsc->vmdev;
  397. /* Poll VMBus device */
  398. while ( vmbus_has_data ( vmdev ) )
  399. vmbus_poll ( vmdev );
  400. }
  401. /**
  402. * Transmit packet
  403. *
  404. * @v rndis RNDIS device
  405. * @v iobuf I/O buffer
  406. * @ret rc Return status code
  407. *
  408. * If this method returns success then the RNDIS device must
  409. * eventually report completion via rndis_tx_complete().
  410. */
  411. static int netvsc_transmit ( struct rndis_device *rndis,
  412. struct io_buffer *iobuf ) {
  413. struct netvsc_device *netvsc = rndis->priv;
  414. struct rndis_header *header = iobuf->data;
  415. struct netvsc_rndis_message msg;
  416. unsigned int tx_id;
  417. unsigned int xrid;
  418. uint64_t xid;
  419. int rc;
  420. /* Sanity check */
  421. assert ( iob_len ( iobuf ) >= sizeof ( *header ) );
  422. assert ( iob_len ( iobuf ) == le32_to_cpu ( header->len ) );
  423. /* Check that we have space in the transmit ring */
  424. if ( netvsc_ring_is_full ( &netvsc->tx ) )
  425. return rndis_tx_defer ( rndis, iobuf );
  426. /* Allocate buffer ID and calculate transaction ID */
  427. tx_id = netvsc->tx.ids[ netvsc->tx.id_prod & ( netvsc->tx.count - 1 ) ];
  428. assert ( netvsc->tx.iobufs[tx_id] == NULL );
  429. xrid = ( NETVSC_TX_BASE_XRID + tx_id );
  430. xid = ( NETVSC_BASE_XID + xrid );
  431. /* Construct message */
  432. memset ( &msg, 0, sizeof ( msg ) );
  433. msg.header.type = cpu_to_le32 ( NETVSC_RNDIS_MSG );
  434. msg.channel = ( ( header->type == cpu_to_le32 ( RNDIS_PACKET_MSG ) ) ?
  435. NETVSC_RNDIS_DATA : NETVSC_RNDIS_CONTROL );
  436. msg.buffer = cpu_to_le32 ( NETVSC_RNDIS_NO_BUFFER );
  437. /* Send message */
  438. if ( ( rc = vmbus_send_data ( netvsc->vmdev, xid, &msg, sizeof ( msg ),
  439. iobuf ) ) != 0 ) {
  440. DBGC ( netvsc, "NETVSC %s could not send RNDIS message: %s\n",
  441. netvsc->name, strerror ( rc ) );
  442. return rc;
  443. }
  444. /* Store I/O buffer and consume buffer ID */
  445. netvsc->tx.iobufs[tx_id] = iobuf;
  446. netvsc->tx.id_prod++;
  447. return 0;
  448. }
  449. /**
  450. * Cancel transmission
  451. *
  452. * @v netvsc NetVSC device
  453. * @v iobuf I/O buffer
  454. * @v tx_id Transmission ID
  455. */
  456. static void netvsc_cancel_transmit ( struct netvsc_device *netvsc,
  457. struct io_buffer *iobuf,
  458. unsigned int tx_id ) {
  459. unsigned int xrid;
  460. uint64_t xid;
  461. /* Send cancellation */
  462. xrid = ( NETVSC_TX_BASE_XRID + tx_id );
  463. xid = ( NETVSC_BASE_XID + xrid );
  464. DBGC ( netvsc, "NETVSC %s cancelling transmission %#x\n",
  465. netvsc->name, tx_id );
  466. vmbus_send_cancellation ( netvsc->vmdev, xid );
  467. /* Report back to RNDIS */
  468. rndis_tx_complete_err ( netvsc->rndis, iobuf, -ECANCELED );
  469. }
  470. /**
  471. * Create descriptor ring
  472. *
  473. * @v netvsc NetVSC device
  474. * @v ring Descriptor ring
  475. * @ret rc Return status code
  476. */
  477. static int netvsc_create_ring ( struct netvsc_device *netvsc __unused,
  478. struct netvsc_ring *ring ) {
  479. unsigned int i;
  480. /* Initialise buffer ID ring */
  481. for ( i = 0 ; i < ring->count ; i++ ) {
  482. ring->ids[i] = i;
  483. assert ( ring->iobufs[i] == NULL );
  484. }
  485. ring->id_prod = 0;
  486. ring->id_cons = 0;
  487. return 0;
  488. }
  489. /**
  490. * Destroy descriptor ring
  491. *
  492. * @v netvsc NetVSC device
  493. * @v ring Descriptor ring
  494. * @v discard Method used to discard outstanding buffer, or NULL
  495. */
  496. static void netvsc_destroy_ring ( struct netvsc_device *netvsc,
  497. struct netvsc_ring *ring,
  498. void ( * discard ) ( struct netvsc_device *,
  499. struct io_buffer *,
  500. unsigned int ) ) {
  501. struct io_buffer *iobuf;
  502. unsigned int i;
  503. /* Flush any outstanding buffers */
  504. for ( i = 0 ; i < ring->count ; i++ ) {
  505. iobuf = ring->iobufs[i];
  506. if ( ! iobuf )
  507. continue;
  508. ring->iobufs[i] = NULL;
  509. ring->ids[ ( ring->id_cons++ ) & ( ring->count - 1 ) ] = i;
  510. if ( discard )
  511. discard ( netvsc, iobuf, i );
  512. }
  513. /* Sanity check */
  514. assert ( netvsc_ring_is_empty ( ring ) );
  515. }
  516. /**
  517. * Copy data from data buffer
  518. *
  519. * @v pages Transfer page set
  520. * @v data Data buffer
  521. * @v offset Offset within page set
  522. * @v len Length within page set
  523. * @ret rc Return status code
  524. */
  525. static int netvsc_buffer_copy ( struct vmbus_xfer_pages *pages, void *data,
  526. size_t offset, size_t len ) {
  527. struct netvsc_buffer *buffer =
  528. container_of ( pages, struct netvsc_buffer, pages );
  529. /* Sanity check */
  530. if ( ( offset > buffer->len ) || ( len > ( buffer->len - offset ) ) )
  531. return -ERANGE;
  532. /* Copy data from buffer */
  533. copy_from_user ( data, buffer->data, offset, len );
  534. return 0;
  535. }
  536. /** Transfer page set operations */
  537. static struct vmbus_xfer_pages_operations netvsc_xfer_pages_operations = {
  538. .copy = netvsc_buffer_copy,
  539. };
  540. /**
  541. * Create data buffer
  542. *
  543. * @v netvsc NetVSC device
  544. * @v buffer Data buffer
  545. * @ret rc Return status code
  546. */
  547. static int netvsc_create_buffer ( struct netvsc_device *netvsc,
  548. struct netvsc_buffer *buffer ) {
  549. struct vmbus_device *vmdev = netvsc->vmdev;
  550. int gpadl;
  551. int rc;
  552. /* Allocate receive buffer */
  553. buffer->data = umalloc ( buffer->len );
  554. if ( ! buffer->data ) {
  555. DBGC ( netvsc, "NETVSC %s could not allocate %zd-byte buffer\n",
  556. netvsc->name, buffer->len );
  557. rc = -ENOMEM;
  558. goto err_alloc;
  559. }
  560. /* Establish GPA descriptor list */
  561. gpadl = vmbus_establish_gpadl ( vmdev, buffer->data, buffer->len );
  562. if ( gpadl < 0 ) {
  563. rc = gpadl;
  564. DBGC ( netvsc, "NETVSC %s could not establish GPADL: %s\n",
  565. netvsc->name, strerror ( rc ) );
  566. goto err_establish_gpadl;
  567. }
  568. buffer->gpadl = gpadl;
  569. /* Register transfer page set */
  570. if ( ( rc = vmbus_register_pages ( vmdev, &buffer->pages ) ) != 0 ) {
  571. DBGC ( netvsc, "NETVSC %s could not register transfer pages: "
  572. "%s\n", netvsc->name, strerror ( rc ) );
  573. goto err_register_pages;
  574. }
  575. return 0;
  576. vmbus_unregister_pages ( vmdev, &buffer->pages );
  577. err_register_pages:
  578. vmbus_gpadl_teardown ( vmdev, gpadl );
  579. err_establish_gpadl:
  580. ufree ( buffer->data );
  581. err_alloc:
  582. return rc;
  583. }
  584. /**
  585. * Destroy data buffer
  586. *
  587. * @v netvsc NetVSC device
  588. * @v buffer Data buffer
  589. */
  590. static void netvsc_destroy_buffer ( struct netvsc_device *netvsc,
  591. struct netvsc_buffer *buffer ) {
  592. struct vmbus_device *vmdev = netvsc->vmdev;
  593. int rc;
  594. /* Unregister transfer pages */
  595. vmbus_unregister_pages ( vmdev, &buffer->pages );
  596. /* Tear down GPA descriptor list */
  597. if ( ( rc = vmbus_gpadl_teardown ( vmdev, buffer->gpadl ) ) != 0 ) {
  598. DBGC ( netvsc, "NETVSC %s could not tear down GPADL: %s\n",
  599. netvsc->name, strerror ( rc ) );
  600. /* Death is imminent. The host may well continue to
  601. * write to the data buffer. The best we can do is
  602. * leak memory for now and hope that the host doesn't
  603. * write to this region after we load an OS.
  604. */
  605. return;
  606. }
  607. /* Free buffer */
  608. ufree ( buffer->data );
  609. }
  610. /**
  611. * Open device
  612. *
  613. * @v rndis RNDIS device
  614. * @ret rc Return status code
  615. */
  616. static int netvsc_open ( struct rndis_device *rndis ) {
  617. struct netvsc_device *netvsc = rndis->priv;
  618. int rc;
  619. /* Initialise receive buffer */
  620. if ( ( rc = netvsc_create_buffer ( netvsc, &netvsc->rx ) ) != 0 )
  621. goto err_create_rx;
  622. /* Open channel */
  623. if ( ( rc = vmbus_open ( netvsc->vmdev, &netvsc_channel_operations,
  624. PAGE_SIZE, PAGE_SIZE, NETVSC_MTU ) ) != 0 ) {
  625. DBGC ( netvsc, "NETVSC %s could not open VMBus: %s\n",
  626. netvsc->name, strerror ( rc ) );
  627. goto err_vmbus_open;
  628. }
  629. /* Initialise communication with NetVSP */
  630. if ( ( rc = netvsc_initialise ( netvsc ) ) != 0 )
  631. goto err_initialise;
  632. if ( ( rc = netvsc_ndis_version ( netvsc ) ) != 0 )
  633. goto err_ndis_version;
  634. /* Initialise transmit ring */
  635. if ( ( rc = netvsc_create_ring ( netvsc, &netvsc->tx ) ) != 0 )
  636. goto err_create_tx;
  637. /* Establish receive buffer */
  638. if ( ( rc = netvsc_establish_buffer ( netvsc, &netvsc->rx ) ) != 0 )
  639. goto err_establish_rx;
  640. return 0;
  641. netvsc_revoke_buffer ( netvsc, &netvsc->rx );
  642. err_establish_rx:
  643. netvsc_destroy_ring ( netvsc, &netvsc->tx, NULL );
  644. err_create_tx:
  645. err_ndis_version:
  646. err_initialise:
  647. vmbus_close ( netvsc->vmdev );
  648. err_vmbus_open:
  649. netvsc_destroy_buffer ( netvsc, &netvsc->rx );
  650. err_create_rx:
  651. return rc;
  652. }
  653. /**
  654. * Close device
  655. *
  656. * @v rndis RNDIS device
  657. */
  658. static void netvsc_close ( struct rndis_device *rndis ) {
  659. struct netvsc_device *netvsc = rndis->priv;
  660. /* Revoke receive buffer */
  661. netvsc_revoke_buffer ( netvsc, &netvsc->rx );
  662. /* Destroy transmit ring */
  663. netvsc_destroy_ring ( netvsc, &netvsc->tx, netvsc_cancel_transmit );
  664. /* Close channel */
  665. vmbus_close ( netvsc->vmdev );
  666. /* Destroy receive buffer */
  667. netvsc_destroy_buffer ( netvsc, &netvsc->rx );
  668. }
  669. /** RNDIS operations */
  670. static struct rndis_operations netvsc_operations = {
  671. .open = netvsc_open,
  672. .close = netvsc_close,
  673. .transmit = netvsc_transmit,
  674. .poll = netvsc_poll,
  675. };
  676. /**
  677. * Probe device
  678. *
  679. * @v vmdev VMBus device
  680. * @ret rc Return status code
  681. */
  682. static int netvsc_probe ( struct vmbus_device *vmdev ) {
  683. struct netvsc_device *netvsc;
  684. struct rndis_device *rndis;
  685. int rc;
  686. /* Allocate and initialise structure */
  687. rndis = alloc_rndis ( sizeof ( *netvsc ) );
  688. if ( ! rndis ) {
  689. rc = -ENOMEM;
  690. goto err_alloc;
  691. }
  692. rndis_init ( rndis, &netvsc_operations );
  693. rndis->netdev->dev = &vmdev->dev;
  694. netvsc = rndis->priv;
  695. netvsc->vmdev = vmdev;
  696. netvsc->rndis = rndis;
  697. netvsc->name = vmdev->dev.name;
  698. netvsc_init_ring ( &netvsc->tx, NETVSC_TX_NUM_DESC,
  699. netvsc->tx_iobufs, netvsc->tx_ids );
  700. netvsc_init_buffer ( &netvsc->rx, NETVSC_RX_BUF_PAGESET,
  701. &netvsc_xfer_pages_operations,
  702. NETVSC_RX_ESTABLISH_MSG, NETVSC_RX_ESTABLISH_XRID,
  703. NETVSC_RX_REVOKE_MSG, NETVSC_RX_REVOKE_XRID,
  704. NETVSC_RX_BUF_LEN );
  705. vmbus_set_drvdata ( vmdev, rndis );
  706. /* Register RNDIS device */
  707. if ( ( rc = register_rndis ( rndis ) ) != 0 ) {
  708. DBGC ( netvsc, "NETVSC %s could not register: %s\n",
  709. netvsc->name, strerror ( rc ) );
  710. goto err_register;
  711. }
  712. return 0;
  713. unregister_rndis ( rndis );
  714. err_register:
  715. free_rndis ( rndis );
  716. err_alloc:
  717. return rc;
  718. }
  719. /**
  720. * Remove device
  721. *
  722. * @v vmdev VMBus device
  723. */
  724. static void netvsc_remove ( struct vmbus_device *vmdev ) {
  725. struct rndis_device *rndis = vmbus_get_drvdata ( vmdev );
  726. /* Unregister RNDIS device */
  727. unregister_rndis ( rndis );
  728. /* Free RNDIS device */
  729. free_rndis ( rndis );
  730. }
  731. /** NetVSC driver */
  732. struct vmbus_driver netvsc_driver __vmbus_driver = {
  733. .name = "netvsc",
  734. .type = VMBUS_TYPE ( 0xf8615163, 0xdf3e, 0x46c5, 0x913f,
  735. 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e ),
  736. .probe = netvsc_probe,
  737. .remove = netvsc_remove,
  738. };