1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2009, Microsoft Corporation. |
4 | * |
5 | * Authors: |
6 | * Haiyang Zhang <haiyangz@microsoft.com> |
7 | * Hank Janssen <hjanssen@microsoft.com> |
8 | */ |
9 | #include <linux/ethtool.h> |
10 | #include <linux/kernel.h> |
11 | #include <linux/sched.h> |
12 | #include <linux/wait.h> |
13 | #include <linux/highmem.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/io.h> |
16 | #include <linux/if_ether.h> |
17 | #include <linux/netdevice.h> |
18 | #include <linux/if_vlan.h> |
19 | #include <linux/nls.h> |
20 | #include <linux/vmalloc.h> |
21 | #include <linux/rtnetlink.h> |
22 | #include <linux/ucs2_string.h> |
23 | #include <linux/string.h> |
24 | #include <linux/slab.h> |
25 | |
26 | #include "hyperv_net.h" |
27 | #include "netvsc_trace.h" |
28 | |
29 | static void rndis_set_multicast(struct work_struct *w); |
30 | |
31 | #define RNDIS_EXT_LEN HV_HYP_PAGE_SIZE |
32 | struct rndis_request { |
33 | struct list_head list_ent; |
34 | struct completion wait_event; |
35 | |
36 | struct rndis_message response_msg; |
37 | /* |
38 | * The buffer for extended info after the RNDIS response message. It's |
39 | * referenced based on the data offset in the RNDIS message. Its size |
40 | * is enough for current needs, and should be sufficient for the near |
41 | * future. |
42 | */ |
43 | u8 response_ext[RNDIS_EXT_LEN]; |
44 | |
45 | /* Simplify allocation by having a netvsc packet inline */ |
46 | struct hv_netvsc_packet pkt; |
47 | |
48 | struct rndis_message request_msg; |
49 | /* |
50 | * The buffer for the extended info after the RNDIS request message. |
51 | * It is referenced and sized in a similar way as response_ext. |
52 | */ |
53 | u8 request_ext[RNDIS_EXT_LEN]; |
54 | }; |
55 | |
56 | static const u8 netvsc_hash_key[NETVSC_HASH_KEYLEN] = { |
57 | 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2, |
58 | 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0, |
59 | 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4, |
60 | 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c, |
61 | 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa |
62 | }; |
63 | |
64 | static struct rndis_device *get_rndis_device(void) |
65 | { |
66 | struct rndis_device *device; |
67 | |
68 | device = kzalloc(size: sizeof(struct rndis_device), GFP_KERNEL); |
69 | if (!device) |
70 | return NULL; |
71 | |
72 | spin_lock_init(&device->request_lock); |
73 | |
74 | INIT_LIST_HEAD(list: &device->req_list); |
75 | INIT_WORK(&device->mcast_work, rndis_set_multicast); |
76 | |
77 | device->state = RNDIS_DEV_UNINITIALIZED; |
78 | |
79 | return device; |
80 | } |
81 | |
82 | static struct rndis_request *get_rndis_request(struct rndis_device *dev, |
83 | u32 msg_type, |
84 | u32 msg_len) |
85 | { |
86 | struct rndis_request *request; |
87 | struct rndis_message *rndis_msg; |
88 | struct rndis_set_request *set; |
89 | unsigned long flags; |
90 | |
91 | request = kzalloc(size: sizeof(struct rndis_request), GFP_KERNEL); |
92 | if (!request) |
93 | return NULL; |
94 | |
95 | init_completion(x: &request->wait_event); |
96 | |
97 | rndis_msg = &request->request_msg; |
98 | rndis_msg->ndis_msg_type = msg_type; |
99 | rndis_msg->msg_len = msg_len; |
100 | |
101 | request->pkt.q_idx = 0; |
102 | |
103 | /* |
104 | * Set the request id. This field is always after the rndis header for |
105 | * request/response packet types so we just used the SetRequest as a |
106 | * template |
107 | */ |
108 | set = &rndis_msg->msg.set_req; |
109 | set->req_id = atomic_inc_return(v: &dev->new_req_id); |
110 | |
111 | /* Add to the request list */ |
112 | spin_lock_irqsave(&dev->request_lock, flags); |
113 | list_add_tail(new: &request->list_ent, head: &dev->req_list); |
114 | spin_unlock_irqrestore(lock: &dev->request_lock, flags); |
115 | |
116 | return request; |
117 | } |
118 | |
119 | static void put_rndis_request(struct rndis_device *dev, |
120 | struct rndis_request *req) |
121 | { |
122 | unsigned long flags; |
123 | |
124 | spin_lock_irqsave(&dev->request_lock, flags); |
125 | list_del(entry: &req->list_ent); |
126 | spin_unlock_irqrestore(lock: &dev->request_lock, flags); |
127 | |
128 | kfree(objp: req); |
129 | } |
130 | |
131 | static void dump_rndis_message(struct net_device *netdev, |
132 | const struct rndis_message *rndis_msg, |
133 | const void *data) |
134 | { |
135 | switch (rndis_msg->ndis_msg_type) { |
136 | case RNDIS_MSG_PACKET: |
137 | if (rndis_msg->msg_len - RNDIS_HEADER_SIZE >= sizeof(struct rndis_packet)) { |
138 | const struct rndis_packet *pkt = data + RNDIS_HEADER_SIZE; |
139 | netdev_dbg(netdev, "RNDIS_MSG_PACKET (len %u, " |
140 | "data offset %u data len %u, # oob %u, " |
141 | "oob offset %u, oob len %u, pkt offset %u, " |
142 | "pkt len %u\n" , |
143 | rndis_msg->msg_len, |
144 | pkt->data_offset, |
145 | pkt->data_len, |
146 | pkt->num_oob_data_elements, |
147 | pkt->oob_data_offset, |
148 | pkt->oob_data_len, |
149 | pkt->per_pkt_info_offset, |
150 | pkt->per_pkt_info_len); |
151 | } |
152 | break; |
153 | |
154 | case RNDIS_MSG_INIT_C: |
155 | if (rndis_msg->msg_len - RNDIS_HEADER_SIZE >= |
156 | sizeof(struct rndis_initialize_complete)) { |
157 | const struct rndis_initialize_complete *init_complete = |
158 | data + RNDIS_HEADER_SIZE; |
159 | netdev_dbg(netdev, "RNDIS_MSG_INIT_C " |
160 | "(len %u, id 0x%x, status 0x%x, major %d, minor %d, " |
161 | "device flags %d, max xfer size 0x%x, max pkts %u, " |
162 | "pkt aligned %u)\n" , |
163 | rndis_msg->msg_len, |
164 | init_complete->req_id, |
165 | init_complete->status, |
166 | init_complete->major_ver, |
167 | init_complete->minor_ver, |
168 | init_complete->dev_flags, |
169 | init_complete->max_xfer_size, |
170 | init_complete->max_pkt_per_msg, |
171 | init_complete->pkt_alignment_factor); |
172 | } |
173 | break; |
174 | |
175 | case RNDIS_MSG_QUERY_C: |
176 | if (rndis_msg->msg_len - RNDIS_HEADER_SIZE >= |
177 | sizeof(struct rndis_query_complete)) { |
178 | const struct rndis_query_complete *query_complete = |
179 | data + RNDIS_HEADER_SIZE; |
180 | netdev_dbg(netdev, "RNDIS_MSG_QUERY_C " |
181 | "(len %u, id 0x%x, status 0x%x, buf len %u, " |
182 | "buf offset %u)\n" , |
183 | rndis_msg->msg_len, |
184 | query_complete->req_id, |
185 | query_complete->status, |
186 | query_complete->info_buflen, |
187 | query_complete->info_buf_offset); |
188 | } |
189 | break; |
190 | |
191 | case RNDIS_MSG_SET_C: |
192 | if (rndis_msg->msg_len - RNDIS_HEADER_SIZE + sizeof(struct rndis_set_complete)) { |
193 | const struct rndis_set_complete *set_complete = |
194 | data + RNDIS_HEADER_SIZE; |
195 | netdev_dbg(netdev, |
196 | "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n" , |
197 | rndis_msg->msg_len, |
198 | set_complete->req_id, |
199 | set_complete->status); |
200 | } |
201 | break; |
202 | |
203 | case RNDIS_MSG_INDICATE: |
204 | if (rndis_msg->msg_len - RNDIS_HEADER_SIZE >= |
205 | sizeof(struct rndis_indicate_status)) { |
206 | const struct rndis_indicate_status *indicate_status = |
207 | data + RNDIS_HEADER_SIZE; |
208 | netdev_dbg(netdev, "RNDIS_MSG_INDICATE " |
209 | "(len %u, status 0x%x, buf len %u, buf offset %u)\n" , |
210 | rndis_msg->msg_len, |
211 | indicate_status->status, |
212 | indicate_status->status_buflen, |
213 | indicate_status->status_buf_offset); |
214 | } |
215 | break; |
216 | |
217 | default: |
218 | netdev_dbg(netdev, "0x%x (len %u)\n" , |
219 | rndis_msg->ndis_msg_type, |
220 | rndis_msg->msg_len); |
221 | break; |
222 | } |
223 | } |
224 | |
225 | static int rndis_filter_send_request(struct rndis_device *dev, |
226 | struct rndis_request *req) |
227 | { |
228 | struct hv_netvsc_packet *packet; |
229 | struct hv_page_buffer page_buf[2]; |
230 | struct hv_page_buffer *pb = page_buf; |
231 | int ret; |
232 | |
233 | /* Setup the packet to send it */ |
234 | packet = &req->pkt; |
235 | |
236 | packet->total_data_buflen = req->request_msg.msg_len; |
237 | packet->page_buf_cnt = 1; |
238 | |
239 | pb[0].pfn = virt_to_phys(address: &req->request_msg) >> |
240 | HV_HYP_PAGE_SHIFT; |
241 | pb[0].len = req->request_msg.msg_len; |
242 | pb[0].offset = offset_in_hvpage(&req->request_msg); |
243 | |
244 | /* Add one page_buf when request_msg crossing page boundary */ |
245 | if (pb[0].offset + pb[0].len > HV_HYP_PAGE_SIZE) { |
246 | packet->page_buf_cnt++; |
247 | pb[0].len = HV_HYP_PAGE_SIZE - |
248 | pb[0].offset; |
249 | pb[1].pfn = virt_to_phys(address: (void *)&req->request_msg |
250 | + pb[0].len) >> HV_HYP_PAGE_SHIFT; |
251 | pb[1].offset = 0; |
252 | pb[1].len = req->request_msg.msg_len - |
253 | pb[0].len; |
254 | } |
255 | |
256 | trace_rndis_send(ndev: dev->ndev, q: 0, msg: &req->request_msg); |
257 | |
258 | rcu_read_lock_bh(); |
259 | ret = netvsc_send(net: dev->ndev, packet, NULL, page_buffer: pb, NULL, xdp_tx: false); |
260 | rcu_read_unlock_bh(); |
261 | |
262 | return ret; |
263 | } |
264 | |
265 | static void rndis_set_link_state(struct rndis_device *rdev, |
266 | struct rndis_request *request) |
267 | { |
268 | u32 link_status; |
269 | struct rndis_query_complete *query_complete; |
270 | u32 msg_len = request->response_msg.msg_len; |
271 | |
272 | /* Ensure the packet is big enough to access its fields */ |
273 | if (msg_len - RNDIS_HEADER_SIZE < sizeof(struct rndis_query_complete)) |
274 | return; |
275 | |
276 | query_complete = &request->response_msg.msg.query_complete; |
277 | |
278 | if (query_complete->status == RNDIS_STATUS_SUCCESS && |
279 | query_complete->info_buflen >= sizeof(u32) && |
280 | query_complete->info_buf_offset >= sizeof(*query_complete) && |
281 | msg_len - RNDIS_HEADER_SIZE >= query_complete->info_buf_offset && |
282 | msg_len - RNDIS_HEADER_SIZE - query_complete->info_buf_offset |
283 | >= query_complete->info_buflen) { |
284 | memcpy(&link_status, (void *)((unsigned long)query_complete + |
285 | query_complete->info_buf_offset), sizeof(u32)); |
286 | rdev->link_state = link_status != 0; |
287 | } |
288 | } |
289 | |
290 | static void rndis_filter_receive_response(struct net_device *ndev, |
291 | struct netvsc_device *nvdev, |
292 | struct rndis_message *resp, |
293 | void *data) |
294 | { |
295 | u32 *req_id = &resp->msg.init_complete.req_id; |
296 | struct rndis_device *dev = nvdev->extension; |
297 | struct rndis_request *request = NULL; |
298 | bool found = false; |
299 | unsigned long flags; |
300 | |
301 | /* This should never happen, it means control message |
302 | * response received after device removed. |
303 | */ |
304 | if (dev->state == RNDIS_DEV_UNINITIALIZED) { |
305 | netdev_err(dev: ndev, |
306 | format: "got rndis message uninitialized\n" ); |
307 | return; |
308 | } |
309 | |
310 | /* Ensure the packet is big enough to read req_id. Req_id is the 1st |
311 | * field in any request/response message, so the payload should have at |
312 | * least sizeof(u32) bytes |
313 | */ |
314 | if (resp->msg_len - RNDIS_HEADER_SIZE < sizeof(u32)) { |
315 | netdev_err(dev: ndev, format: "rndis msg_len too small: %u\n" , |
316 | resp->msg_len); |
317 | return; |
318 | } |
319 | |
320 | /* Copy the request ID into nvchan->recv_buf */ |
321 | *req_id = *(u32 *)(data + RNDIS_HEADER_SIZE); |
322 | |
323 | spin_lock_irqsave(&dev->request_lock, flags); |
324 | list_for_each_entry(request, &dev->req_list, list_ent) { |
325 | /* |
326 | * All request/response message contains RequestId as the 1st |
327 | * field |
328 | */ |
329 | if (request->request_msg.msg.init_req.req_id == *req_id) { |
330 | found = true; |
331 | break; |
332 | } |
333 | } |
334 | spin_unlock_irqrestore(lock: &dev->request_lock, flags); |
335 | |
336 | if (found) { |
337 | if (resp->msg_len <= |
338 | sizeof(struct rndis_message) + RNDIS_EXT_LEN) { |
339 | memcpy(&request->response_msg, resp, RNDIS_HEADER_SIZE + sizeof(*req_id)); |
340 | unsafe_memcpy((void *)&request->response_msg + RNDIS_HEADER_SIZE + sizeof(*req_id), |
341 | data + RNDIS_HEADER_SIZE + sizeof(*req_id), |
342 | resp->msg_len - RNDIS_HEADER_SIZE - sizeof(*req_id), |
343 | "request->response_msg is followed by a padding of RNDIS_EXT_LEN inside rndis_request" ); |
344 | if (request->request_msg.ndis_msg_type == |
345 | RNDIS_MSG_QUERY && request->request_msg.msg. |
346 | query_req.oid == RNDIS_OID_GEN_MEDIA_CONNECT_STATUS) |
347 | rndis_set_link_state(rdev: dev, request); |
348 | } else { |
349 | netdev_err(dev: ndev, |
350 | format: "rndis response buffer overflow " |
351 | "detected (size %u max %zu)\n" , |
352 | resp->msg_len, |
353 | sizeof(struct rndis_message)); |
354 | |
355 | if (resp->ndis_msg_type == |
356 | RNDIS_MSG_RESET_C) { |
357 | /* does not have a request id field */ |
358 | request->response_msg.msg.reset_complete. |
359 | status = RNDIS_STATUS_BUFFER_OVERFLOW; |
360 | } else { |
361 | request->response_msg.msg. |
362 | init_complete.status = |
363 | RNDIS_STATUS_BUFFER_OVERFLOW; |
364 | } |
365 | } |
366 | |
367 | netvsc_dma_unmap(hv_dev: ((struct net_device_context *) |
368 | netdev_priv(dev: ndev))->device_ctx, packet: &request->pkt); |
369 | complete(&request->wait_event); |
370 | } else { |
371 | netdev_err(dev: ndev, |
372 | format: "no rndis request found for this response " |
373 | "(id 0x%x res type 0x%x)\n" , |
374 | *req_id, |
375 | resp->ndis_msg_type); |
376 | } |
377 | } |
378 | |
379 | /* |
380 | * Get the Per-Packet-Info with the specified type |
381 | * return NULL if not found. |
382 | */ |
383 | static inline void *rndis_get_ppi(struct net_device *ndev, |
384 | struct rndis_packet *rpkt, |
385 | u32 rpkt_len, u32 type, u8 internal, |
386 | u32 ppi_size, void *data) |
387 | { |
388 | struct rndis_per_packet_info *ppi; |
389 | int len; |
390 | |
391 | if (rpkt->per_pkt_info_offset == 0) |
392 | return NULL; |
393 | |
394 | /* Validate info_offset and info_len */ |
395 | if (rpkt->per_pkt_info_offset < sizeof(struct rndis_packet) || |
396 | rpkt->per_pkt_info_offset > rpkt_len) { |
397 | netdev_err(dev: ndev, format: "Invalid per_pkt_info_offset: %u\n" , |
398 | rpkt->per_pkt_info_offset); |
399 | return NULL; |
400 | } |
401 | |
402 | if (rpkt->per_pkt_info_len < sizeof(*ppi) || |
403 | rpkt->per_pkt_info_len > rpkt_len - rpkt->per_pkt_info_offset) { |
404 | netdev_err(dev: ndev, format: "Invalid per_pkt_info_len: %u\n" , |
405 | rpkt->per_pkt_info_len); |
406 | return NULL; |
407 | } |
408 | |
409 | ppi = (struct rndis_per_packet_info *)((ulong)rpkt + |
410 | rpkt->per_pkt_info_offset); |
411 | /* Copy the PPIs into nvchan->recv_buf */ |
412 | memcpy(ppi, data + RNDIS_HEADER_SIZE + rpkt->per_pkt_info_offset, rpkt->per_pkt_info_len); |
413 | len = rpkt->per_pkt_info_len; |
414 | |
415 | while (len > 0) { |
416 | /* Validate ppi_offset and ppi_size */ |
417 | if (ppi->size > len) { |
418 | netdev_err(dev: ndev, format: "Invalid ppi size: %u\n" , ppi->size); |
419 | continue; |
420 | } |
421 | |
422 | if (ppi->ppi_offset >= ppi->size) { |
423 | netdev_err(dev: ndev, format: "Invalid ppi_offset: %u\n" , ppi->ppi_offset); |
424 | continue; |
425 | } |
426 | |
427 | if (ppi->type == type && ppi->internal == internal) { |
428 | /* ppi->size should be big enough to hold the returned object. */ |
429 | if (ppi->size - ppi->ppi_offset < ppi_size) { |
430 | netdev_err(dev: ndev, format: "Invalid ppi: size %u ppi_offset %u\n" , |
431 | ppi->size, ppi->ppi_offset); |
432 | continue; |
433 | } |
434 | return (void *)((ulong)ppi + ppi->ppi_offset); |
435 | } |
436 | len -= ppi->size; |
437 | ppi = (struct rndis_per_packet_info *)((ulong)ppi + ppi->size); |
438 | } |
439 | |
440 | return NULL; |
441 | } |
442 | |
443 | static inline |
444 | void rsc_add_data(struct netvsc_channel *nvchan, |
445 | const struct ndis_pkt_8021q_info *vlan, |
446 | const struct ndis_tcp_ip_checksum_info *csum_info, |
447 | const u32 *hash_info, |
448 | void *data, u32 len) |
449 | { |
450 | u32 cnt = nvchan->rsc.cnt; |
451 | |
452 | if (cnt) { |
453 | nvchan->rsc.pktlen += len; |
454 | } else { |
455 | /* The data/values pointed by vlan, csum_info and hash_info are shared |
456 | * across the different 'fragments' of the RSC packet; store them into |
457 | * the packet itself. |
458 | */ |
459 | if (vlan != NULL) { |
460 | memcpy(&nvchan->rsc.vlan, vlan, sizeof(*vlan)); |
461 | nvchan->rsc.ppi_flags |= NVSC_RSC_VLAN; |
462 | } else { |
463 | nvchan->rsc.ppi_flags &= ~NVSC_RSC_VLAN; |
464 | } |
465 | if (csum_info != NULL) { |
466 | memcpy(&nvchan->rsc.csum_info, csum_info, sizeof(*csum_info)); |
467 | nvchan->rsc.ppi_flags |= NVSC_RSC_CSUM_INFO; |
468 | } else { |
469 | nvchan->rsc.ppi_flags &= ~NVSC_RSC_CSUM_INFO; |
470 | } |
471 | nvchan->rsc.pktlen = len; |
472 | if (hash_info != NULL) { |
473 | nvchan->rsc.hash_info = *hash_info; |
474 | nvchan->rsc.ppi_flags |= NVSC_RSC_HASH_INFO; |
475 | } else { |
476 | nvchan->rsc.ppi_flags &= ~NVSC_RSC_HASH_INFO; |
477 | } |
478 | } |
479 | |
480 | nvchan->rsc.data[cnt] = data; |
481 | nvchan->rsc.len[cnt] = len; |
482 | nvchan->rsc.cnt++; |
483 | } |
484 | |
485 | static int rndis_filter_receive_data(struct net_device *ndev, |
486 | struct netvsc_device *nvdev, |
487 | struct netvsc_channel *nvchan, |
488 | struct rndis_message *msg, |
489 | void *data, u32 data_buflen) |
490 | { |
491 | struct rndis_packet *rndis_pkt = &msg->msg.pkt; |
492 | const struct ndis_tcp_ip_checksum_info *csum_info; |
493 | const struct ndis_pkt_8021q_info *vlan; |
494 | const struct rndis_pktinfo_id *pktinfo_id; |
495 | const u32 *hash_info; |
496 | u32 data_offset, rpkt_len; |
497 | bool rsc_more = false; |
498 | int ret; |
499 | |
500 | /* Ensure data_buflen is big enough to read header fields */ |
501 | if (data_buflen < RNDIS_HEADER_SIZE + sizeof(struct rndis_packet)) { |
502 | netdev_err(dev: ndev, format: "invalid rndis pkt, data_buflen too small: %u\n" , |
503 | data_buflen); |
504 | return NVSP_STAT_FAIL; |
505 | } |
506 | |
507 | /* Copy the RNDIS packet into nvchan->recv_buf */ |
508 | memcpy(rndis_pkt, data + RNDIS_HEADER_SIZE, sizeof(*rndis_pkt)); |
509 | |
510 | /* Validate rndis_pkt offset */ |
511 | if (rndis_pkt->data_offset >= data_buflen - RNDIS_HEADER_SIZE) { |
512 | netdev_err(dev: ndev, format: "invalid rndis packet offset: %u\n" , |
513 | rndis_pkt->data_offset); |
514 | return NVSP_STAT_FAIL; |
515 | } |
516 | |
517 | /* Remove the rndis header and pass it back up the stack */ |
518 | data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset; |
519 | |
520 | rpkt_len = data_buflen - RNDIS_HEADER_SIZE; |
521 | data_buflen -= data_offset; |
522 | |
523 | /* |
524 | * Make sure we got a valid RNDIS message, now total_data_buflen |
525 | * should be the data packet size plus the trailer padding size |
526 | */ |
527 | if (unlikely(data_buflen < rndis_pkt->data_len)) { |
528 | netdev_err(dev: ndev, format: "rndis message buffer " |
529 | "overflow detected (got %u, min %u)" |
530 | "...dropping this message!\n" , |
531 | data_buflen, rndis_pkt->data_len); |
532 | return NVSP_STAT_FAIL; |
533 | } |
534 | |
535 | vlan = rndis_get_ppi(ndev, rpkt: rndis_pkt, rpkt_len, type: IEEE_8021Q_INFO, internal: 0, ppi_size: sizeof(*vlan), |
536 | data); |
537 | |
538 | csum_info = rndis_get_ppi(ndev, rpkt: rndis_pkt, rpkt_len, type: TCPIP_CHKSUM_PKTINFO, internal: 0, |
539 | ppi_size: sizeof(*csum_info), data); |
540 | |
541 | hash_info = rndis_get_ppi(ndev, rpkt: rndis_pkt, rpkt_len, type: NBL_HASH_VALUE, internal: 0, |
542 | ppi_size: sizeof(*hash_info), data); |
543 | |
544 | pktinfo_id = rndis_get_ppi(ndev, rpkt: rndis_pkt, rpkt_len, type: RNDIS_PKTINFO_ID, internal: 1, |
545 | ppi_size: sizeof(*pktinfo_id), data); |
546 | |
547 | /* Identify RSC frags, drop erroneous packets */ |
548 | if (pktinfo_id && (pktinfo_id->flag & RNDIS_PKTINFO_SUBALLOC)) { |
549 | if (pktinfo_id->flag & RNDIS_PKTINFO_1ST_FRAG) |
550 | nvchan->rsc.cnt = 0; |
551 | else if (nvchan->rsc.cnt == 0) |
552 | goto drop; |
553 | |
554 | rsc_more = true; |
555 | |
556 | if (pktinfo_id->flag & RNDIS_PKTINFO_LAST_FRAG) |
557 | rsc_more = false; |
558 | |
559 | if (rsc_more && nvchan->rsc.is_last) |
560 | goto drop; |
561 | } else { |
562 | nvchan->rsc.cnt = 0; |
563 | } |
564 | |
565 | if (unlikely(nvchan->rsc.cnt >= NVSP_RSC_MAX)) |
566 | goto drop; |
567 | |
568 | /* Put data into per channel structure. |
569 | * Also, remove the rndis trailer padding from rndis packet message |
570 | * rndis_pkt->data_len tell us the real data length, we only copy |
571 | * the data packet to the stack, without the rndis trailer padding |
572 | */ |
573 | rsc_add_data(nvchan, vlan, csum_info, hash_info, |
574 | data: data + data_offset, len: rndis_pkt->data_len); |
575 | |
576 | if (rsc_more) |
577 | return NVSP_STAT_SUCCESS; |
578 | |
579 | ret = netvsc_recv_callback(net: ndev, nvdev, nvchan); |
580 | nvchan->rsc.cnt = 0; |
581 | |
582 | return ret; |
583 | |
584 | drop: |
585 | return NVSP_STAT_FAIL; |
586 | } |
587 | |
588 | int rndis_filter_receive(struct net_device *ndev, |
589 | struct netvsc_device *net_dev, |
590 | struct netvsc_channel *nvchan, |
591 | void *data, u32 buflen) |
592 | { |
593 | struct net_device_context *net_device_ctx = netdev_priv(dev: ndev); |
594 | struct rndis_message *rndis_msg = nvchan->recv_buf; |
595 | |
596 | if (buflen < RNDIS_HEADER_SIZE) { |
597 | netdev_err(dev: ndev, format: "Invalid rndis_msg (buflen: %u)\n" , buflen); |
598 | return NVSP_STAT_FAIL; |
599 | } |
600 | |
601 | /* Copy the RNDIS msg header into nvchan->recv_buf */ |
602 | memcpy(rndis_msg, data, RNDIS_HEADER_SIZE); |
603 | |
604 | /* Validate incoming rndis_message packet */ |
605 | if (rndis_msg->msg_len < RNDIS_HEADER_SIZE || |
606 | buflen < rndis_msg->msg_len) { |
607 | netdev_err(dev: ndev, format: "Invalid rndis_msg (buflen: %u, msg_len: %u)\n" , |
608 | buflen, rndis_msg->msg_len); |
609 | return NVSP_STAT_FAIL; |
610 | } |
611 | |
612 | if (netif_msg_rx_status(net_device_ctx)) |
613 | dump_rndis_message(netdev: ndev, rndis_msg, data); |
614 | |
615 | switch (rndis_msg->ndis_msg_type) { |
616 | case RNDIS_MSG_PACKET: |
617 | return rndis_filter_receive_data(ndev, nvdev: net_dev, nvchan, |
618 | msg: rndis_msg, data, data_buflen: buflen); |
619 | case RNDIS_MSG_INIT_C: |
620 | case RNDIS_MSG_QUERY_C: |
621 | case RNDIS_MSG_SET_C: |
622 | /* completion msgs */ |
623 | rndis_filter_receive_response(ndev, nvdev: net_dev, resp: rndis_msg, data); |
624 | break; |
625 | |
626 | case RNDIS_MSG_INDICATE: |
627 | /* notification msgs */ |
628 | netvsc_linkstatus_callback(net: ndev, resp: rndis_msg, data, data_buflen: buflen); |
629 | break; |
630 | default: |
631 | netdev_err(dev: ndev, |
632 | format: "unhandled rndis message (type %u len %u)\n" , |
633 | rndis_msg->ndis_msg_type, |
634 | rndis_msg->msg_len); |
635 | return NVSP_STAT_FAIL; |
636 | } |
637 | |
638 | return NVSP_STAT_SUCCESS; |
639 | } |
640 | |
641 | static int rndis_filter_query_device(struct rndis_device *dev, |
642 | struct netvsc_device *nvdev, |
643 | u32 oid, void *result, u32 *result_size) |
644 | { |
645 | struct rndis_request *request; |
646 | u32 inresult_size = *result_size; |
647 | struct rndis_query_request *query; |
648 | struct rndis_query_complete *query_complete; |
649 | u32 msg_len; |
650 | int ret = 0; |
651 | |
652 | if (!result) |
653 | return -EINVAL; |
654 | |
655 | *result_size = 0; |
656 | request = get_rndis_request(dev, RNDIS_MSG_QUERY, |
657 | RNDIS_MESSAGE_SIZE(struct rndis_query_request)); |
658 | if (!request) { |
659 | ret = -ENOMEM; |
660 | goto cleanup; |
661 | } |
662 | |
663 | /* Setup the rndis query */ |
664 | query = &request->request_msg.msg.query_req; |
665 | query->oid = oid; |
666 | query->info_buf_offset = sizeof(struct rndis_query_request); |
667 | query->info_buflen = 0; |
668 | query->dev_vc_handle = 0; |
669 | |
670 | if (oid == OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES) { |
671 | struct ndis_offload *hwcaps; |
672 | u32 nvsp_version = nvdev->nvsp_version; |
673 | u8 ndis_rev; |
674 | size_t size; |
675 | |
676 | if (nvsp_version >= NVSP_PROTOCOL_VERSION_5) { |
677 | ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_3; |
678 | size = NDIS_OFFLOAD_SIZE; |
679 | } else if (nvsp_version >= NVSP_PROTOCOL_VERSION_4) { |
680 | ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_2; |
681 | size = NDIS_OFFLOAD_SIZE_6_1; |
682 | } else { |
683 | ndis_rev = NDIS_OFFLOAD_PARAMETERS_REVISION_1; |
684 | size = NDIS_OFFLOAD_SIZE_6_0; |
685 | } |
686 | |
687 | request->request_msg.msg_len += size; |
688 | query->info_buflen = size; |
689 | hwcaps = (struct ndis_offload *) |
690 | ((unsigned long)query + query->info_buf_offset); |
691 | |
692 | hwcaps->header.type = NDIS_OBJECT_TYPE_OFFLOAD; |
693 | hwcaps->header.revision = ndis_rev; |
694 | hwcaps->header.size = size; |
695 | |
696 | } else if (oid == OID_GEN_RECEIVE_SCALE_CAPABILITIES) { |
697 | struct ndis_recv_scale_cap *cap; |
698 | |
699 | request->request_msg.msg_len += |
700 | sizeof(struct ndis_recv_scale_cap); |
701 | query->info_buflen = sizeof(struct ndis_recv_scale_cap); |
702 | cap = (struct ndis_recv_scale_cap *)((unsigned long)query + |
703 | query->info_buf_offset); |
704 | cap->hdr.type = NDIS_OBJECT_TYPE_RSS_CAPABILITIES; |
705 | cap->hdr.rev = NDIS_RECEIVE_SCALE_CAPABILITIES_REVISION_2; |
706 | cap->hdr.size = sizeof(struct ndis_recv_scale_cap); |
707 | } |
708 | |
709 | ret = rndis_filter_send_request(dev, req: request); |
710 | if (ret != 0) |
711 | goto cleanup; |
712 | |
713 | wait_for_completion(&request->wait_event); |
714 | |
715 | /* Copy the response back */ |
716 | query_complete = &request->response_msg.msg.query_complete; |
717 | msg_len = request->response_msg.msg_len; |
718 | |
719 | /* Ensure the packet is big enough to access its fields */ |
720 | if (msg_len - RNDIS_HEADER_SIZE < sizeof(struct rndis_query_complete)) { |
721 | ret = -1; |
722 | goto cleanup; |
723 | } |
724 | |
725 | if (query_complete->info_buflen > inresult_size || |
726 | query_complete->info_buf_offset < sizeof(*query_complete) || |
727 | msg_len - RNDIS_HEADER_SIZE < query_complete->info_buf_offset || |
728 | msg_len - RNDIS_HEADER_SIZE - query_complete->info_buf_offset |
729 | < query_complete->info_buflen) { |
730 | ret = -1; |
731 | goto cleanup; |
732 | } |
733 | |
734 | memcpy(result, |
735 | (void *)((unsigned long)query_complete + |
736 | query_complete->info_buf_offset), |
737 | query_complete->info_buflen); |
738 | |
739 | *result_size = query_complete->info_buflen; |
740 | |
741 | cleanup: |
742 | if (request) |
743 | put_rndis_request(dev, req: request); |
744 | |
745 | return ret; |
746 | } |
747 | |
748 | /* Get the hardware offload capabilities */ |
749 | static int |
750 | rndis_query_hwcaps(struct rndis_device *dev, struct netvsc_device *net_device, |
751 | struct ndis_offload *caps) |
752 | { |
753 | u32 caps_len = sizeof(*caps); |
754 | int ret; |
755 | |
756 | memset(caps, 0, sizeof(*caps)); |
757 | |
758 | ret = rndis_filter_query_device(dev, nvdev: net_device, |
759 | OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES, |
760 | result: caps, result_size: &caps_len); |
761 | if (ret) |
762 | return ret; |
763 | |
764 | if (caps->header.type != NDIS_OBJECT_TYPE_OFFLOAD) { |
765 | netdev_warn(dev: dev->ndev, format: "invalid NDIS objtype %#x\n" , |
766 | caps->header.type); |
767 | return -EINVAL; |
768 | } |
769 | |
770 | if (caps->header.revision < NDIS_OFFLOAD_PARAMETERS_REVISION_1) { |
771 | netdev_warn(dev: dev->ndev, format: "invalid NDIS objrev %x\n" , |
772 | caps->header.revision); |
773 | return -EINVAL; |
774 | } |
775 | |
776 | if (caps->header.size > caps_len || |
777 | caps->header.size < NDIS_OFFLOAD_SIZE_6_0) { |
778 | netdev_warn(dev: dev->ndev, |
779 | format: "invalid NDIS objsize %u, data size %u\n" , |
780 | caps->header.size, caps_len); |
781 | return -EINVAL; |
782 | } |
783 | |
784 | return 0; |
785 | } |
786 | |
787 | static int rndis_filter_query_device_mac(struct rndis_device *dev, |
788 | struct netvsc_device *net_device) |
789 | { |
790 | u32 size = ETH_ALEN; |
791 | |
792 | return rndis_filter_query_device(dev, nvdev: net_device, |
793 | RNDIS_OID_802_3_PERMANENT_ADDRESS, |
794 | result: dev->hw_mac_adr, result_size: &size); |
795 | } |
796 | |
797 | #define NWADR_STR "NetworkAddress" |
798 | #define NWADR_STRLEN 14 |
799 | |
800 | int rndis_filter_set_device_mac(struct netvsc_device *nvdev, |
801 | const char *mac) |
802 | { |
803 | struct rndis_device *rdev = nvdev->extension; |
804 | struct rndis_request *request; |
805 | struct rndis_set_request *set; |
806 | struct rndis_config_parameter_info *cpi; |
807 | wchar_t *cfg_nwadr, *cfg_mac; |
808 | struct rndis_set_complete *set_complete; |
809 | char macstr[2*ETH_ALEN+1]; |
810 | u32 extlen = sizeof(struct rndis_config_parameter_info) + |
811 | 2*NWADR_STRLEN + 4*ETH_ALEN; |
812 | int ret; |
813 | |
814 | request = get_rndis_request(dev: rdev, RNDIS_MSG_SET, |
815 | RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); |
816 | if (!request) |
817 | return -ENOMEM; |
818 | |
819 | set = &request->request_msg.msg.set_req; |
820 | set->oid = RNDIS_OID_GEN_RNDIS_CONFIG_PARAMETER; |
821 | set->info_buflen = extlen; |
822 | set->info_buf_offset = sizeof(struct rndis_set_request); |
823 | set->dev_vc_handle = 0; |
824 | |
825 | cpi = (struct rndis_config_parameter_info *)((ulong)set + |
826 | set->info_buf_offset); |
827 | cpi->parameter_name_offset = |
828 | sizeof(struct rndis_config_parameter_info); |
829 | /* Multiply by 2 because host needs 2 bytes (utf16) for each char */ |
830 | cpi->parameter_name_length = 2*NWADR_STRLEN; |
831 | cpi->parameter_type = RNDIS_CONFIG_PARAM_TYPE_STRING; |
832 | cpi->parameter_value_offset = |
833 | cpi->parameter_name_offset + cpi->parameter_name_length; |
834 | /* Multiply by 4 because each MAC byte displayed as 2 utf16 chars */ |
835 | cpi->parameter_value_length = 4*ETH_ALEN; |
836 | |
837 | cfg_nwadr = (wchar_t *)((ulong)cpi + cpi->parameter_name_offset); |
838 | cfg_mac = (wchar_t *)((ulong)cpi + cpi->parameter_value_offset); |
839 | ret = utf8s_to_utf16s(NWADR_STR, NWADR_STRLEN, endian: UTF16_HOST_ENDIAN, |
840 | pwcs: cfg_nwadr, NWADR_STRLEN); |
841 | if (ret < 0) |
842 | goto cleanup; |
843 | snprintf(buf: macstr, size: 2*ETH_ALEN+1, fmt: "%pm" , mac); |
844 | ret = utf8s_to_utf16s(s: macstr, len: 2*ETH_ALEN, endian: UTF16_HOST_ENDIAN, |
845 | pwcs: cfg_mac, maxlen: 2*ETH_ALEN); |
846 | if (ret < 0) |
847 | goto cleanup; |
848 | |
849 | ret = rndis_filter_send_request(dev: rdev, req: request); |
850 | if (ret != 0) |
851 | goto cleanup; |
852 | |
853 | wait_for_completion(&request->wait_event); |
854 | |
855 | set_complete = &request->response_msg.msg.set_complete; |
856 | if (set_complete->status != RNDIS_STATUS_SUCCESS) |
857 | ret = -EIO; |
858 | |
859 | cleanup: |
860 | put_rndis_request(dev: rdev, req: request); |
861 | return ret; |
862 | } |
863 | |
864 | int |
865 | rndis_filter_set_offload_params(struct net_device *ndev, |
866 | struct netvsc_device *nvdev, |
867 | struct ndis_offload_params *req_offloads) |
868 | { |
869 | struct rndis_device *rdev = nvdev->extension; |
870 | struct rndis_request *request; |
871 | struct rndis_set_request *set; |
872 | struct ndis_offload_params *offload_params; |
873 | struct rndis_set_complete *set_complete; |
874 | u32 extlen = sizeof(struct ndis_offload_params); |
875 | int ret; |
876 | u32 vsp_version = nvdev->nvsp_version; |
877 | |
878 | if (vsp_version <= NVSP_PROTOCOL_VERSION_4) { |
879 | extlen = VERSION_4_OFFLOAD_SIZE; |
880 | /* On NVSP_PROTOCOL_VERSION_4 and below, we do not support |
881 | * UDP checksum offload. |
882 | */ |
883 | req_offloads->udp_ip_v4_csum = 0; |
884 | req_offloads->udp_ip_v6_csum = 0; |
885 | } |
886 | |
887 | request = get_rndis_request(dev: rdev, RNDIS_MSG_SET, |
888 | RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); |
889 | if (!request) |
890 | return -ENOMEM; |
891 | |
892 | set = &request->request_msg.msg.set_req; |
893 | set->oid = OID_TCP_OFFLOAD_PARAMETERS; |
894 | set->info_buflen = extlen; |
895 | set->info_buf_offset = sizeof(struct rndis_set_request); |
896 | set->dev_vc_handle = 0; |
897 | |
898 | offload_params = (struct ndis_offload_params *)((ulong)set + |
899 | set->info_buf_offset); |
900 | *offload_params = *req_offloads; |
901 | offload_params->header.type = NDIS_OBJECT_TYPE_DEFAULT; |
902 | offload_params->header.revision = NDIS_OFFLOAD_PARAMETERS_REVISION_3; |
903 | offload_params->header.size = extlen; |
904 | |
905 | ret = rndis_filter_send_request(dev: rdev, req: request); |
906 | if (ret != 0) |
907 | goto cleanup; |
908 | |
909 | wait_for_completion(&request->wait_event); |
910 | set_complete = &request->response_msg.msg.set_complete; |
911 | if (set_complete->status != RNDIS_STATUS_SUCCESS) { |
912 | netdev_err(dev: ndev, format: "Fail to set offload on host side:0x%x\n" , |
913 | set_complete->status); |
914 | ret = -EINVAL; |
915 | } |
916 | |
917 | cleanup: |
918 | put_rndis_request(dev: rdev, req: request); |
919 | return ret; |
920 | } |
921 | |
922 | static int (struct rndis_device *rdev, |
923 | const u8 *, u16 flag) |
924 | { |
925 | struct net_device *ndev = rdev->ndev; |
926 | struct net_device_context *ndc = netdev_priv(dev: ndev); |
927 | struct rndis_request *request; |
928 | struct rndis_set_request *set; |
929 | struct rndis_set_complete *set_complete; |
930 | u32 extlen = sizeof(struct ndis_recv_scale_param) + |
931 | 4 * ndc->rx_table_sz + NETVSC_HASH_KEYLEN; |
932 | struct ndis_recv_scale_param *; |
933 | u32 *itab; |
934 | u8 *keyp; |
935 | int i, ret; |
936 | |
937 | request = get_rndis_request( |
938 | dev: rdev, RNDIS_MSG_SET, |
939 | RNDIS_MESSAGE_SIZE(struct rndis_set_request) + extlen); |
940 | if (!request) |
941 | return -ENOMEM; |
942 | |
943 | set = &request->request_msg.msg.set_req; |
944 | set->oid = OID_GEN_RECEIVE_SCALE_PARAMETERS; |
945 | set->info_buflen = extlen; |
946 | set->info_buf_offset = sizeof(struct rndis_set_request); |
947 | set->dev_vc_handle = 0; |
948 | |
949 | rssp = (struct ndis_recv_scale_param *)(set + 1); |
950 | rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS; |
951 | rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2; |
952 | rssp->hdr.size = sizeof(struct ndis_recv_scale_param); |
953 | rssp->flag = flag; |
954 | rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 | |
955 | NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 | |
956 | NDIS_HASH_TCP_IPV6; |
957 | rssp->indirect_tabsize = 4 * ndc->rx_table_sz; |
958 | rssp->indirect_taboffset = sizeof(struct ndis_recv_scale_param); |
959 | rssp->hashkey_size = NETVSC_HASH_KEYLEN; |
960 | rssp->hashkey_offset = rssp->indirect_taboffset + |
961 | rssp->indirect_tabsize; |
962 | |
963 | /* Set indirection table entries */ |
964 | itab = (u32 *)(rssp + 1); |
965 | for (i = 0; i < ndc->rx_table_sz; i++) |
966 | itab[i] = ndc->rx_table[i]; |
967 | |
968 | /* Set hask key values */ |
969 | keyp = (u8 *)((unsigned long)rssp + rssp->hashkey_offset); |
970 | memcpy(keyp, rss_key, NETVSC_HASH_KEYLEN); |
971 | |
972 | ret = rndis_filter_send_request(dev: rdev, req: request); |
973 | if (ret != 0) |
974 | goto cleanup; |
975 | |
976 | wait_for_completion(&request->wait_event); |
977 | set_complete = &request->response_msg.msg.set_complete; |
978 | if (set_complete->status == RNDIS_STATUS_SUCCESS) { |
979 | if (!(flag & NDIS_RSS_PARAM_FLAG_DISABLE_RSS) && |
980 | !(flag & NDIS_RSS_PARAM_FLAG_HASH_KEY_UNCHANGED)) |
981 | memcpy(rdev->rss_key, rss_key, NETVSC_HASH_KEYLEN); |
982 | |
983 | } else { |
984 | netdev_err(dev: ndev, format: "Fail to set RSS parameters:0x%x\n" , |
985 | set_complete->status); |
986 | ret = -EINVAL; |
987 | } |
988 | |
989 | cleanup: |
990 | put_rndis_request(dev: rdev, req: request); |
991 | return ret; |
992 | } |
993 | |
994 | int (struct rndis_device *rdev, |
995 | const u8 *) |
996 | { |
997 | /* Disable RSS before change */ |
998 | rndis_set_rss_param_msg(rdev, rss_key, |
999 | NDIS_RSS_PARAM_FLAG_DISABLE_RSS); |
1000 | |
1001 | return rndis_set_rss_param_msg(rdev, rss_key, flag: 0); |
1002 | } |
1003 | |
1004 | static int rndis_filter_query_device_link_status(struct rndis_device *dev, |
1005 | struct netvsc_device *net_device) |
1006 | { |
1007 | u32 size = sizeof(u32); |
1008 | u32 link_status; |
1009 | |
1010 | return rndis_filter_query_device(dev, nvdev: net_device, |
1011 | RNDIS_OID_GEN_MEDIA_CONNECT_STATUS, |
1012 | result: &link_status, result_size: &size); |
1013 | } |
1014 | |
1015 | static int rndis_filter_query_link_speed(struct rndis_device *dev, |
1016 | struct netvsc_device *net_device) |
1017 | { |
1018 | u32 size = sizeof(u32); |
1019 | u32 link_speed; |
1020 | struct net_device_context *ndc; |
1021 | int ret; |
1022 | |
1023 | ret = rndis_filter_query_device(dev, nvdev: net_device, |
1024 | RNDIS_OID_GEN_LINK_SPEED, |
1025 | result: &link_speed, result_size: &size); |
1026 | |
1027 | if (!ret) { |
1028 | ndc = netdev_priv(dev: dev->ndev); |
1029 | |
1030 | /* The link speed reported from host is in 100bps unit, so |
1031 | * we convert it to Mbps here. |
1032 | */ |
1033 | ndc->speed = link_speed / 10000; |
1034 | } |
1035 | |
1036 | return ret; |
1037 | } |
1038 | |
1039 | static int rndis_filter_set_packet_filter(struct rndis_device *dev, |
1040 | u32 new_filter) |
1041 | { |
1042 | struct rndis_request *request; |
1043 | struct rndis_set_request *set; |
1044 | int ret; |
1045 | |
1046 | if (dev->filter == new_filter) |
1047 | return 0; |
1048 | |
1049 | request = get_rndis_request(dev, RNDIS_MSG_SET, |
1050 | RNDIS_MESSAGE_SIZE(struct rndis_set_request) + |
1051 | sizeof(u32)); |
1052 | if (!request) |
1053 | return -ENOMEM; |
1054 | |
1055 | /* Setup the rndis set */ |
1056 | set = &request->request_msg.msg.set_req; |
1057 | set->oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER; |
1058 | set->info_buflen = sizeof(u32); |
1059 | set->info_buf_offset = offsetof(typeof(*set), info_buf); |
1060 | memcpy(set->info_buf, &new_filter, sizeof(u32)); |
1061 | |
1062 | ret = rndis_filter_send_request(dev, req: request); |
1063 | if (ret == 0) { |
1064 | wait_for_completion(&request->wait_event); |
1065 | dev->filter = new_filter; |
1066 | } |
1067 | |
1068 | put_rndis_request(dev, req: request); |
1069 | |
1070 | return ret; |
1071 | } |
1072 | |
1073 | static void rndis_set_multicast(struct work_struct *w) |
1074 | { |
1075 | struct rndis_device *rdev |
1076 | = container_of(w, struct rndis_device, mcast_work); |
1077 | u32 filter = NDIS_PACKET_TYPE_DIRECTED; |
1078 | unsigned int flags = rdev->ndev->flags; |
1079 | |
1080 | if (flags & IFF_PROMISC) { |
1081 | filter = NDIS_PACKET_TYPE_PROMISCUOUS; |
1082 | } else { |
1083 | if (!netdev_mc_empty(rdev->ndev) || (flags & IFF_ALLMULTI)) |
1084 | filter |= NDIS_PACKET_TYPE_ALL_MULTICAST; |
1085 | if (flags & IFF_BROADCAST) |
1086 | filter |= NDIS_PACKET_TYPE_BROADCAST; |
1087 | } |
1088 | |
1089 | rndis_filter_set_packet_filter(dev: rdev, new_filter: filter); |
1090 | } |
1091 | |
1092 | void rndis_filter_update(struct netvsc_device *nvdev) |
1093 | { |
1094 | struct rndis_device *rdev = nvdev->extension; |
1095 | |
1096 | schedule_work(work: &rdev->mcast_work); |
1097 | } |
1098 | |
1099 | static int rndis_filter_init_device(struct rndis_device *dev, |
1100 | struct netvsc_device *nvdev) |
1101 | { |
1102 | struct rndis_request *request; |
1103 | struct rndis_initialize_request *init; |
1104 | struct rndis_initialize_complete *init_complete; |
1105 | u32 status; |
1106 | int ret; |
1107 | |
1108 | request = get_rndis_request(dev, RNDIS_MSG_INIT, |
1109 | RNDIS_MESSAGE_SIZE(struct rndis_initialize_request)); |
1110 | if (!request) { |
1111 | ret = -ENOMEM; |
1112 | goto cleanup; |
1113 | } |
1114 | |
1115 | /* Setup the rndis set */ |
1116 | init = &request->request_msg.msg.init_req; |
1117 | init->major_ver = RNDIS_MAJOR_VERSION; |
1118 | init->minor_ver = RNDIS_MINOR_VERSION; |
1119 | init->max_xfer_size = 0x4000; |
1120 | |
1121 | dev->state = RNDIS_DEV_INITIALIZING; |
1122 | |
1123 | ret = rndis_filter_send_request(dev, req: request); |
1124 | if (ret != 0) { |
1125 | dev->state = RNDIS_DEV_UNINITIALIZED; |
1126 | goto cleanup; |
1127 | } |
1128 | |
1129 | wait_for_completion(&request->wait_event); |
1130 | |
1131 | init_complete = &request->response_msg.msg.init_complete; |
1132 | status = init_complete->status; |
1133 | if (status == RNDIS_STATUS_SUCCESS) { |
1134 | dev->state = RNDIS_DEV_INITIALIZED; |
1135 | nvdev->max_pkt = init_complete->max_pkt_per_msg; |
1136 | nvdev->pkt_align = 1 << init_complete->pkt_alignment_factor; |
1137 | ret = 0; |
1138 | } else { |
1139 | dev->state = RNDIS_DEV_UNINITIALIZED; |
1140 | ret = -EINVAL; |
1141 | } |
1142 | |
1143 | cleanup: |
1144 | if (request) |
1145 | put_rndis_request(dev, req: request); |
1146 | |
1147 | return ret; |
1148 | } |
1149 | |
1150 | static bool netvsc_device_idle(const struct netvsc_device *nvdev) |
1151 | { |
1152 | int i; |
1153 | |
1154 | for (i = 0; i < nvdev->num_chn; i++) { |
1155 | const struct netvsc_channel *nvchan = &nvdev->chan_table[i]; |
1156 | |
1157 | if (nvchan->mrc.first != nvchan->mrc.next) |
1158 | return false; |
1159 | |
1160 | if (atomic_read(v: &nvchan->queue_sends) > 0) |
1161 | return false; |
1162 | } |
1163 | |
1164 | return true; |
1165 | } |
1166 | |
1167 | static void rndis_filter_halt_device(struct netvsc_device *nvdev, |
1168 | struct rndis_device *dev) |
1169 | { |
1170 | struct rndis_request *request; |
1171 | struct rndis_halt_request *halt; |
1172 | |
1173 | /* Attempt to do a rndis device halt */ |
1174 | request = get_rndis_request(dev, RNDIS_MSG_HALT, |
1175 | RNDIS_MESSAGE_SIZE(struct rndis_halt_request)); |
1176 | if (!request) |
1177 | goto cleanup; |
1178 | |
1179 | /* Setup the rndis set */ |
1180 | halt = &request->request_msg.msg.halt_req; |
1181 | halt->req_id = atomic_inc_return(v: &dev->new_req_id); |
1182 | |
1183 | /* Ignore return since this msg is optional. */ |
1184 | rndis_filter_send_request(dev, req: request); |
1185 | |
1186 | dev->state = RNDIS_DEV_UNINITIALIZED; |
1187 | |
1188 | cleanup: |
1189 | nvdev->destroy = true; |
1190 | |
1191 | /* Force flag to be ordered before waiting */ |
1192 | wmb(); |
1193 | |
1194 | /* Wait for all send completions */ |
1195 | wait_event(nvdev->wait_drain, netvsc_device_idle(nvdev)); |
1196 | |
1197 | if (request) |
1198 | put_rndis_request(dev, req: request); |
1199 | } |
1200 | |
1201 | static int rndis_filter_open_device(struct rndis_device *dev) |
1202 | { |
1203 | int ret; |
1204 | |
1205 | if (dev->state != RNDIS_DEV_INITIALIZED) |
1206 | return 0; |
1207 | |
1208 | ret = rndis_filter_set_packet_filter(dev, |
1209 | NDIS_PACKET_TYPE_BROADCAST | |
1210 | NDIS_PACKET_TYPE_ALL_MULTICAST | |
1211 | NDIS_PACKET_TYPE_DIRECTED); |
1212 | if (ret == 0) |
1213 | dev->state = RNDIS_DEV_DATAINITIALIZED; |
1214 | |
1215 | return ret; |
1216 | } |
1217 | |
1218 | static int rndis_filter_close_device(struct rndis_device *dev) |
1219 | { |
1220 | int ret; |
1221 | |
1222 | if (dev->state != RNDIS_DEV_DATAINITIALIZED) |
1223 | return 0; |
1224 | |
1225 | /* Make sure rndis_set_multicast doesn't re-enable filter! */ |
1226 | cancel_work_sync(work: &dev->mcast_work); |
1227 | |
1228 | ret = rndis_filter_set_packet_filter(dev, new_filter: 0); |
1229 | if (ret == -ENODEV) |
1230 | ret = 0; |
1231 | |
1232 | if (ret == 0) |
1233 | dev->state = RNDIS_DEV_INITIALIZED; |
1234 | |
1235 | return ret; |
1236 | } |
1237 | |
1238 | static void netvsc_sc_open(struct vmbus_channel *new_sc) |
1239 | { |
1240 | struct net_device *ndev = |
1241 | hv_get_drvdata(dev: new_sc->primary_channel->device_obj); |
1242 | struct net_device_context *ndev_ctx = netdev_priv(dev: ndev); |
1243 | struct netvsc_device *nvscdev; |
1244 | u16 chn_index = new_sc->offermsg.offer.sub_channel_index; |
1245 | struct netvsc_channel *nvchan; |
1246 | int ret; |
1247 | |
1248 | /* This is safe because this callback only happens when |
1249 | * new device is being setup and waiting on the channel_init_wait. |
1250 | */ |
1251 | nvscdev = rcu_dereference_raw(ndev_ctx->nvdev); |
1252 | if (!nvscdev || chn_index >= nvscdev->num_chn) |
1253 | return; |
1254 | |
1255 | nvchan = nvscdev->chan_table + chn_index; |
1256 | |
1257 | /* Because the device uses NAPI, all the interrupt batching and |
1258 | * control is done via Net softirq, not the channel handling |
1259 | */ |
1260 | set_channel_read_mode(c: new_sc, mode: HV_CALL_ISR); |
1261 | |
1262 | /* Set the channel before opening.*/ |
1263 | nvchan->channel = new_sc; |
1264 | |
1265 | new_sc->next_request_id_callback = vmbus_next_request_id; |
1266 | new_sc->request_addr_callback = vmbus_request_addr; |
1267 | new_sc->rqstor_size = netvsc_rqstor_size(ringbytes: netvsc_ring_bytes); |
1268 | new_sc->max_pkt_size = NETVSC_MAX_PKT_SIZE; |
1269 | |
1270 | ret = vmbus_open(channel: new_sc, send_ringbuffersize: netvsc_ring_bytes, |
1271 | recv_ringbuffersize: netvsc_ring_bytes, NULL, userdatalen: 0, |
1272 | onchannel_callback: netvsc_channel_cb, context: nvchan); |
1273 | if (ret == 0) |
1274 | napi_enable(n: &nvchan->napi); |
1275 | else |
1276 | netdev_notice(dev: ndev, format: "sub channel open failed: %d\n" , ret); |
1277 | |
1278 | if (atomic_inc_return(v: &nvscdev->open_chn) == nvscdev->num_chn) |
1279 | wake_up(&nvscdev->subchan_open); |
1280 | } |
1281 | |
1282 | /* Open sub-channels after completing the handling of the device probe. |
1283 | * This breaks overlap of processing the host message for the |
1284 | * new primary channel with the initialization of sub-channels. |
1285 | */ |
1286 | int rndis_set_subchannel(struct net_device *ndev, |
1287 | struct netvsc_device *nvdev, |
1288 | struct netvsc_device_info *dev_info) |
1289 | { |
1290 | struct nvsp_message *init_packet = &nvdev->channel_init_pkt; |
1291 | struct net_device_context *ndev_ctx = netdev_priv(dev: ndev); |
1292 | struct hv_device *hv_dev = ndev_ctx->device_ctx; |
1293 | struct rndis_device *rdev = nvdev->extension; |
1294 | int i, ret; |
1295 | |
1296 | ASSERT_RTNL(); |
1297 | |
1298 | memset(init_packet, 0, sizeof(struct nvsp_message)); |
1299 | init_packet->hdr.msg_type = NVSP_MSG5_TYPE_SUBCHANNEL; |
1300 | init_packet->msg.v5_msg.subchn_req.op = NVSP_SUBCHANNEL_ALLOCATE; |
1301 | init_packet->msg.v5_msg.subchn_req.num_subchannels = |
1302 | nvdev->num_chn - 1; |
1303 | trace_nvsp_send(ndev, msg: init_packet); |
1304 | |
1305 | ret = vmbus_sendpacket(channel: hv_dev->channel, buffer: init_packet, |
1306 | bufferLen: sizeof(struct nvsp_message), |
1307 | requestid: (unsigned long)init_packet, |
1308 | type: VM_PKT_DATA_INBAND, |
1309 | VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); |
1310 | if (ret) { |
1311 | netdev_err(dev: ndev, format: "sub channel allocate send failed: %d\n" , ret); |
1312 | return ret; |
1313 | } |
1314 | |
1315 | wait_for_completion(&nvdev->channel_init_wait); |
1316 | if (init_packet->msg.v5_msg.subchn_comp.status != NVSP_STAT_SUCCESS) { |
1317 | netdev_err(dev: ndev, format: "sub channel request failed\n" ); |
1318 | return -EIO; |
1319 | } |
1320 | |
1321 | /* Check that number of allocated sub channel is within the expected range */ |
1322 | if (init_packet->msg.v5_msg.subchn_comp.num_subchannels > nvdev->num_chn - 1) { |
1323 | netdev_err(dev: ndev, format: "invalid number of allocated sub channel\n" ); |
1324 | return -EINVAL; |
1325 | } |
1326 | nvdev->num_chn = 1 + |
1327 | init_packet->msg.v5_msg.subchn_comp.num_subchannels; |
1328 | |
1329 | /* wait for all sub channels to open */ |
1330 | wait_event(nvdev->subchan_open, |
1331 | atomic_read(&nvdev->open_chn) == nvdev->num_chn); |
1332 | |
1333 | for (i = 0; i < VRSS_SEND_TAB_SIZE; i++) |
1334 | ndev_ctx->tx_table[i] = i % nvdev->num_chn; |
1335 | |
1336 | /* ignore failures from setting rss parameters, still have channels */ |
1337 | if (dev_info) |
1338 | rndis_filter_set_rss_param(rdev, rss_key: dev_info->rss_key); |
1339 | else |
1340 | rndis_filter_set_rss_param(rdev, rss_key: netvsc_hash_key); |
1341 | |
1342 | netif_set_real_num_tx_queues(dev: ndev, txq: nvdev->num_chn); |
1343 | netif_set_real_num_rx_queues(dev: ndev, rxq: nvdev->num_chn); |
1344 | |
1345 | return 0; |
1346 | } |
1347 | |
1348 | static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, |
1349 | struct netvsc_device *nvdev) |
1350 | { |
1351 | struct net_device *net = rndis_device->ndev; |
1352 | struct net_device_context *net_device_ctx = netdev_priv(dev: net); |
1353 | struct ndis_offload hwcaps; |
1354 | struct ndis_offload_params offloads; |
1355 | unsigned int gso_max_size = GSO_LEGACY_MAX_SIZE; |
1356 | int ret; |
1357 | |
1358 | /* Find HW offload capabilities */ |
1359 | ret = rndis_query_hwcaps(dev: rndis_device, net_device: nvdev, caps: &hwcaps); |
1360 | if (ret != 0) |
1361 | return ret; |
1362 | |
1363 | /* A value of zero means "no change"; now turn on what we want. */ |
1364 | memset(&offloads, 0, sizeof(struct ndis_offload_params)); |
1365 | |
1366 | /* Linux does not care about IP checksum, always does in kernel */ |
1367 | offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_DISABLED; |
1368 | |
1369 | /* Reset previously set hw_features flags */ |
1370 | net->hw_features &= ~NETVSC_SUPPORTED_HW_FEATURES; |
1371 | net_device_ctx->tx_checksum_mask = 0; |
1372 | |
1373 | /* Compute tx offload settings based on hw capabilities */ |
1374 | net->hw_features |= NETIF_F_RXCSUM; |
1375 | net->hw_features |= NETIF_F_SG; |
1376 | net->hw_features |= NETIF_F_RXHASH; |
1377 | |
1378 | if ((hwcaps.csum.ip4_txcsum & NDIS_TXCSUM_ALL_TCP4) == NDIS_TXCSUM_ALL_TCP4) { |
1379 | /* Can checksum TCP */ |
1380 | net->hw_features |= NETIF_F_IP_CSUM; |
1381 | net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV4_TCP; |
1382 | |
1383 | offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; |
1384 | |
1385 | if (hwcaps.lsov2.ip4_encap & NDIS_OFFLOAD_ENCAP_8023) { |
1386 | offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED; |
1387 | net->hw_features |= NETIF_F_TSO; |
1388 | |
1389 | if (hwcaps.lsov2.ip4_maxsz < gso_max_size) |
1390 | gso_max_size = hwcaps.lsov2.ip4_maxsz; |
1391 | } |
1392 | |
1393 | if (hwcaps.csum.ip4_txcsum & NDIS_TXCSUM_CAP_UDP4) { |
1394 | offloads.udp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; |
1395 | net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV4_UDP; |
1396 | } |
1397 | } |
1398 | |
1399 | if ((hwcaps.csum.ip6_txcsum & NDIS_TXCSUM_ALL_TCP6) == NDIS_TXCSUM_ALL_TCP6) { |
1400 | net->hw_features |= NETIF_F_IPV6_CSUM; |
1401 | |
1402 | offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; |
1403 | net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV6_TCP; |
1404 | |
1405 | if ((hwcaps.lsov2.ip6_encap & NDIS_OFFLOAD_ENCAP_8023) && |
1406 | (hwcaps.lsov2.ip6_opts & NDIS_LSOV2_CAP_IP6) == NDIS_LSOV2_CAP_IP6) { |
1407 | offloads.lso_v2_ipv6 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED; |
1408 | net->hw_features |= NETIF_F_TSO6; |
1409 | |
1410 | if (hwcaps.lsov2.ip6_maxsz < gso_max_size) |
1411 | gso_max_size = hwcaps.lsov2.ip6_maxsz; |
1412 | } |
1413 | |
1414 | if (hwcaps.csum.ip6_txcsum & NDIS_TXCSUM_CAP_UDP6) { |
1415 | offloads.udp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; |
1416 | net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV6_UDP; |
1417 | } |
1418 | } |
1419 | |
1420 | if (hwcaps.rsc.ip4 && hwcaps.rsc.ip6) { |
1421 | net->hw_features |= NETIF_F_LRO; |
1422 | |
1423 | if (net->features & NETIF_F_LRO) { |
1424 | offloads.rsc_ip_v4 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; |
1425 | offloads.rsc_ip_v6 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; |
1426 | } else { |
1427 | offloads.rsc_ip_v4 = NDIS_OFFLOAD_PARAMETERS_RSC_DISABLED; |
1428 | offloads.rsc_ip_v6 = NDIS_OFFLOAD_PARAMETERS_RSC_DISABLED; |
1429 | } |
1430 | } |
1431 | |
1432 | /* In case some hw_features disappeared we need to remove them from |
1433 | * net->features list as they're no longer supported. |
1434 | */ |
1435 | net->features &= ~NETVSC_SUPPORTED_HW_FEATURES | net->hw_features; |
1436 | |
1437 | netif_set_tso_max_size(dev: net, size: gso_max_size); |
1438 | |
1439 | ret = rndis_filter_set_offload_params(ndev: net, nvdev, req_offloads: &offloads); |
1440 | |
1441 | return ret; |
1442 | } |
1443 | |
1444 | static void rndis_get_friendly_name(struct net_device *net, |
1445 | struct rndis_device *rndis_device, |
1446 | struct netvsc_device *net_device) |
1447 | { |
1448 | ucs2_char_t wname[256]; |
1449 | unsigned long len; |
1450 | u8 ifalias[256]; |
1451 | u32 size; |
1452 | |
1453 | size = sizeof(wname); |
1454 | if (rndis_filter_query_device(dev: rndis_device, nvdev: net_device, |
1455 | RNDIS_OID_GEN_FRIENDLY_NAME, |
1456 | result: wname, result_size: &size) != 0) |
1457 | return; /* ignore if host does not support */ |
1458 | |
1459 | if (size == 0) |
1460 | return; /* name not set */ |
1461 | |
1462 | /* Convert Windows Unicode string to UTF-8 */ |
1463 | len = ucs2_as_utf8(dest: ifalias, src: wname, maxlength: sizeof(ifalias)); |
1464 | |
1465 | /* ignore the default value from host */ |
1466 | if (strcmp(ifalias, "Network Adapter" ) != 0) |
1467 | dev_set_alias(net, ifalias, len); |
1468 | } |
1469 | |
1470 | struct netvsc_device *rndis_filter_device_add(struct hv_device *dev, |
1471 | struct netvsc_device_info *device_info) |
1472 | { |
1473 | struct net_device *net = hv_get_drvdata(dev); |
1474 | struct net_device_context *ndc = netdev_priv(dev: net); |
1475 | struct netvsc_device *net_device; |
1476 | struct rndis_device *rndis_device; |
1477 | struct ndis_recv_scale_cap ; |
1478 | u32 = sizeof(struct ndis_recv_scale_cap); |
1479 | u32 mtu, size; |
1480 | u32 ; |
1481 | int i, ret; |
1482 | |
1483 | rndis_device = get_rndis_device(); |
1484 | if (!rndis_device) |
1485 | return ERR_PTR(error: -ENODEV); |
1486 | |
1487 | /* Let the inner driver handle this first to create the netvsc channel |
1488 | * NOTE! Once the channel is created, we may get a receive callback |
1489 | * (RndisFilterOnReceive()) before this call is completed |
1490 | */ |
1491 | net_device = netvsc_device_add(device: dev, info: device_info); |
1492 | if (IS_ERR(ptr: net_device)) { |
1493 | kfree(objp: rndis_device); |
1494 | return net_device; |
1495 | } |
1496 | |
1497 | /* Initialize the rndis device */ |
1498 | net_device->max_chn = 1; |
1499 | net_device->num_chn = 1; |
1500 | |
1501 | net_device->extension = rndis_device; |
1502 | rndis_device->ndev = net; |
1503 | |
1504 | /* Send the rndis initialization message */ |
1505 | ret = rndis_filter_init_device(dev: rndis_device, nvdev: net_device); |
1506 | if (ret != 0) |
1507 | goto err_dev_remv; |
1508 | |
1509 | /* Get the MTU from the host */ |
1510 | size = sizeof(u32); |
1511 | ret = rndis_filter_query_device(dev: rndis_device, nvdev: net_device, |
1512 | RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE, |
1513 | result: &mtu, result_size: &size); |
1514 | if (ret == 0 && size == sizeof(u32) && mtu < net->mtu) |
1515 | net->mtu = mtu; |
1516 | |
1517 | /* Get the mac address */ |
1518 | ret = rndis_filter_query_device_mac(dev: rndis_device, net_device); |
1519 | if (ret != 0) |
1520 | goto err_dev_remv; |
1521 | |
1522 | memcpy(device_info->mac_adr, rndis_device->hw_mac_adr, ETH_ALEN); |
1523 | |
1524 | /* Get friendly name as ifalias*/ |
1525 | if (!net->ifalias) |
1526 | rndis_get_friendly_name(net, rndis_device, net_device); |
1527 | |
1528 | /* Query and set hardware capabilities */ |
1529 | ret = rndis_netdev_set_hwcaps(rndis_device, nvdev: net_device); |
1530 | if (ret != 0) |
1531 | goto err_dev_remv; |
1532 | |
1533 | rndis_filter_query_device_link_status(dev: rndis_device, net_device); |
1534 | |
1535 | netdev_dbg(net, "Device MAC %pM link state %s\n" , |
1536 | rndis_device->hw_mac_adr, |
1537 | rndis_device->link_state ? "down" : "up" ); |
1538 | |
1539 | if (net_device->nvsp_version < NVSP_PROTOCOL_VERSION_5) |
1540 | goto out; |
1541 | |
1542 | rndis_filter_query_link_speed(dev: rndis_device, net_device); |
1543 | |
1544 | /* vRSS setup */ |
1545 | memset(&rsscap, 0, rsscap_size); |
1546 | ret = rndis_filter_query_device(dev: rndis_device, nvdev: net_device, |
1547 | OID_GEN_RECEIVE_SCALE_CAPABILITIES, |
1548 | result: &rsscap, result_size: &rsscap_size); |
1549 | if (ret || rsscap.num_recv_que < 2) |
1550 | goto out; |
1551 | |
1552 | if (rsscap.num_indirect_tabent && |
1553 | rsscap.num_indirect_tabent <= ITAB_NUM_MAX) |
1554 | ndc->rx_table_sz = rsscap.num_indirect_tabent; |
1555 | else |
1556 | ndc->rx_table_sz = ITAB_NUM; |
1557 | |
1558 | ndc->rx_table = kcalloc(n: ndc->rx_table_sz, size: sizeof(u16), GFP_KERNEL); |
1559 | if (!ndc->rx_table) { |
1560 | ret = -ENOMEM; |
1561 | goto err_dev_remv; |
1562 | } |
1563 | |
1564 | /* This guarantees that num_possible_rss_qs <= num_online_cpus */ |
1565 | num_possible_rss_qs = min_t(u32, num_online_cpus(), |
1566 | rsscap.num_recv_que); |
1567 | |
1568 | net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, num_possible_rss_qs); |
1569 | |
1570 | /* We will use the given number of channels if available. */ |
1571 | net_device->num_chn = min(net_device->max_chn, device_info->num_chn); |
1572 | |
1573 | if (!netif_is_rxfh_configured(dev: net)) { |
1574 | for (i = 0; i < ndc->rx_table_sz; i++) |
1575 | ndc->rx_table[i] = ethtool_rxfh_indir_default( |
1576 | index: i, n_rx_rings: net_device->num_chn); |
1577 | } |
1578 | |
1579 | atomic_set(v: &net_device->open_chn, i: 1); |
1580 | vmbus_set_sc_create_callback(primary_channel: dev->channel, sc_cr_cb: netvsc_sc_open); |
1581 | |
1582 | for (i = 1; i < net_device->num_chn; i++) { |
1583 | ret = netvsc_alloc_recv_comp_ring(net_device, q_idx: i); |
1584 | if (ret) { |
1585 | while (--i != 0) |
1586 | vfree(addr: net_device->chan_table[i].mrc.slots); |
1587 | goto out; |
1588 | } |
1589 | } |
1590 | |
1591 | for (i = 1; i < net_device->num_chn; i++) |
1592 | netif_napi_add(dev: net, napi: &net_device->chan_table[i].napi, |
1593 | poll: netvsc_poll); |
1594 | |
1595 | return net_device; |
1596 | |
1597 | out: |
1598 | /* setting up multiple channels failed */ |
1599 | net_device->max_chn = 1; |
1600 | net_device->num_chn = 1; |
1601 | return net_device; |
1602 | |
1603 | err_dev_remv: |
1604 | rndis_filter_device_remove(dev, nvdev: net_device); |
1605 | return ERR_PTR(error: ret); |
1606 | } |
1607 | |
1608 | void rndis_filter_device_remove(struct hv_device *dev, |
1609 | struct netvsc_device *net_dev) |
1610 | { |
1611 | struct rndis_device *rndis_dev = net_dev->extension; |
1612 | struct net_device *net = hv_get_drvdata(dev); |
1613 | struct net_device_context *ndc; |
1614 | |
1615 | ndc = netdev_priv(dev: net); |
1616 | |
1617 | /* Halt and release the rndis device */ |
1618 | rndis_filter_halt_device(nvdev: net_dev, dev: rndis_dev); |
1619 | |
1620 | netvsc_device_remove(device: dev); |
1621 | |
1622 | ndc->rx_table_sz = 0; |
1623 | kfree(objp: ndc->rx_table); |
1624 | ndc->rx_table = NULL; |
1625 | } |
1626 | |
1627 | int rndis_filter_open(struct netvsc_device *nvdev) |
1628 | { |
1629 | if (!nvdev) |
1630 | return -EINVAL; |
1631 | |
1632 | return rndis_filter_open_device(dev: nvdev->extension); |
1633 | } |
1634 | |
1635 | int rndis_filter_close(struct netvsc_device *nvdev) |
1636 | { |
1637 | if (!nvdev) |
1638 | return -EINVAL; |
1639 | |
1640 | return rndis_filter_close_device(dev: nvdev->extension); |
1641 | } |
1642 | |