Root/drivers/hv/channel.c

1/*
2 * Copyright (c) 2009, Microsoft Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
16 *
17 * Authors:
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
20 */
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/kernel.h>
24#include <linux/sched.h>
25#include <linux/wait.h>
26#include <linux/mm.h>
27#include <linux/slab.h>
28#include <linux/module.h>
29#include <linux/hyperv.h>
30
31#include "hyperv_vmbus.h"
32
33#define NUM_PAGES_SPANNED(addr, len) \
34((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT))
35
36/* Internal routines */
37static int create_gpadl_header(
38    void *kbuffer, /* must be phys and virt contiguous */
39    u32 size, /* page-size multiple */
40    struct vmbus_channel_msginfo **msginfo,
41    u32 *messagecount);
42static void vmbus_setevent(struct vmbus_channel *channel);
43
44/*
45 * vmbus_setevent- Trigger an event notification on the specified
46 * channel.
47 */
48static void vmbus_setevent(struct vmbus_channel *channel)
49{
50    struct hv_monitor_page *monitorpage;
51
52    if (channel->offermsg.monitor_allocated) {
53        /* Each u32 represents 32 channels */
54        sync_set_bit(channel->offermsg.child_relid & 31,
55            (unsigned long *) vmbus_connection.send_int_page +
56            (channel->offermsg.child_relid >> 5));
57
58        monitorpage = vmbus_connection.monitor_pages;
59        monitorpage++; /* Get the child to parent monitor page */
60
61        sync_set_bit(channel->monitor_bit,
62            (unsigned long *)&monitorpage->trigger_group
63                    [channel->monitor_grp].pending);
64
65    } else {
66        vmbus_set_event(channel->offermsg.child_relid);
67    }
68}
69
70/*
71 * vmbus_get_debug_info -Retrieve various channel debug info
72 */
73void vmbus_get_debug_info(struct vmbus_channel *channel,
74                  struct vmbus_channel_debug_info *debuginfo)
75{
76    struct hv_monitor_page *monitorpage;
77    u8 monitor_group = (u8)channel->offermsg.monitorid / 32;
78    u8 monitor_offset = (u8)channel->offermsg.monitorid % 32;
79
80    debuginfo->relid = channel->offermsg.child_relid;
81    debuginfo->state = channel->state;
82    memcpy(&debuginfo->interfacetype,
83           &channel->offermsg.offer.if_type, sizeof(uuid_le));
84    memcpy(&debuginfo->interface_instance,
85           &channel->offermsg.offer.if_instance,
86           sizeof(uuid_le));
87
88    monitorpage = (struct hv_monitor_page *)vmbus_connection.monitor_pages;
89
90    debuginfo->monitorid = channel->offermsg.monitorid;
91
92    debuginfo->servermonitor_pending =
93            monitorpage->trigger_group[monitor_group].pending;
94    debuginfo->servermonitor_latency =
95            monitorpage->latency[monitor_group][monitor_offset];
96    debuginfo->servermonitor_connectionid =
97            monitorpage->parameter[monitor_group]
98                    [monitor_offset].connectionid.u.id;
99
100    monitorpage++;
101
102    debuginfo->clientmonitor_pending =
103            monitorpage->trigger_group[monitor_group].pending;
104    debuginfo->clientmonitor_latency =
105            monitorpage->latency[monitor_group][monitor_offset];
106    debuginfo->clientmonitor_connectionid =
107            monitorpage->parameter[monitor_group]
108                    [monitor_offset].connectionid.u.id;
109
110    hv_ringbuffer_get_debuginfo(&channel->inbound, &debuginfo->inbound);
111    hv_ringbuffer_get_debuginfo(&channel->outbound, &debuginfo->outbound);
112}
113
114/*
115 * vmbus_open - Open the specified channel.
116 */
117int vmbus_open(struct vmbus_channel *newchannel, u32 send_ringbuffer_size,
118             u32 recv_ringbuffer_size, void *userdata, u32 userdatalen,
119             void (*onchannelcallback)(void *context), void *context)
120{
121    struct vmbus_channel_open_channel *open_msg;
122    struct vmbus_channel_msginfo *open_info = NULL;
123    void *in, *out;
124    unsigned long flags;
125    int ret, t, err = 0;
126
127    newchannel->onchannel_callback = onchannelcallback;
128    newchannel->channel_callback_context = context;
129
130    /* Allocate the ring buffer */
131    out = (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
132        get_order(send_ringbuffer_size + recv_ringbuffer_size));
133
134    if (!out)
135        return -ENOMEM;
136
137
138    in = (void *)((unsigned long)out + send_ringbuffer_size);
139
140    newchannel->ringbuffer_pages = out;
141    newchannel->ringbuffer_pagecount = (send_ringbuffer_size +
142                       recv_ringbuffer_size) >> PAGE_SHIFT;
143
144    ret = hv_ringbuffer_init(
145        &newchannel->outbound, out, send_ringbuffer_size);
146
147    if (ret != 0) {
148        err = ret;
149        goto errorout;
150    }
151
152    ret = hv_ringbuffer_init(
153        &newchannel->inbound, in, recv_ringbuffer_size);
154    if (ret != 0) {
155        err = ret;
156        goto errorout;
157    }
158
159
160    /* Establish the gpadl for the ring buffer */
161    newchannel->ringbuffer_gpadlhandle = 0;
162
163    ret = vmbus_establish_gpadl(newchannel,
164                     newchannel->outbound.ring_buffer,
165                     send_ringbuffer_size +
166                     recv_ringbuffer_size,
167                     &newchannel->ringbuffer_gpadlhandle);
168
169    if (ret != 0) {
170        err = ret;
171        goto errorout;
172    }
173
174    /* Create and init the channel open message */
175    open_info = kmalloc(sizeof(*open_info) +
176               sizeof(struct vmbus_channel_open_channel),
177               GFP_KERNEL);
178    if (!open_info) {
179        err = -ENOMEM;
180        goto errorout;
181    }
182
183    init_completion(&open_info->waitevent);
184
185    open_msg = (struct vmbus_channel_open_channel *)open_info->msg;
186    open_msg->header.msgtype = CHANNELMSG_OPENCHANNEL;
187    open_msg->openid = newchannel->offermsg.child_relid;
188    open_msg->child_relid = newchannel->offermsg.child_relid;
189    open_msg->ringbuffer_gpadlhandle = newchannel->ringbuffer_gpadlhandle;
190    open_msg->downstream_ringbuffer_pageoffset = send_ringbuffer_size >>
191                          PAGE_SHIFT;
192    open_msg->server_contextarea_gpadlhandle = 0;
193
194    if (userdatalen > MAX_USER_DEFINED_BYTES) {
195        err = -EINVAL;
196        goto errorout;
197    }
198
199    if (userdatalen)
200        memcpy(open_msg->userdata, userdata, userdatalen);
201
202    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
203    list_add_tail(&open_info->msglistentry,
204              &vmbus_connection.chn_msg_list);
205    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
206
207    ret = vmbus_post_msg(open_msg,
208                   sizeof(struct vmbus_channel_open_channel));
209
210    if (ret != 0)
211        goto cleanup;
212
213    t = wait_for_completion_timeout(&open_info->waitevent, 5*HZ);
214    if (t == 0) {
215        err = -ETIMEDOUT;
216        goto errorout;
217    }
218
219
220    if (open_info->response.open_result.status)
221        err = open_info->response.open_result.status;
222
223cleanup:
224    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
225    list_del(&open_info->msglistentry);
226    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
227
228    kfree(open_info);
229    return err;
230
231errorout:
232    hv_ringbuffer_cleanup(&newchannel->outbound);
233    hv_ringbuffer_cleanup(&newchannel->inbound);
234    free_pages((unsigned long)out,
235        get_order(send_ringbuffer_size + recv_ringbuffer_size));
236    kfree(open_info);
237    return err;
238}
239EXPORT_SYMBOL_GPL(vmbus_open);
240
241/*
242 * create_gpadl_header - Creates a gpadl for the specified buffer
243 */
244static int create_gpadl_header(void *kbuffer, u32 size,
245                     struct vmbus_channel_msginfo **msginfo,
246                     u32 *messagecount)
247{
248    int i;
249    int pagecount;
250    unsigned long long pfn;
251    struct vmbus_channel_gpadl_header *gpadl_header;
252    struct vmbus_channel_gpadl_body *gpadl_body;
253    struct vmbus_channel_msginfo *msgheader;
254    struct vmbus_channel_msginfo *msgbody = NULL;
255    u32 msgsize;
256
257    int pfnsum, pfncount, pfnleft, pfncurr, pfnsize;
258
259    pagecount = size >> PAGE_SHIFT;
260    pfn = virt_to_phys(kbuffer) >> PAGE_SHIFT;
261
262    /* do we need a gpadl body msg */
263    pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
264          sizeof(struct vmbus_channel_gpadl_header) -
265          sizeof(struct gpa_range);
266    pfncount = pfnsize / sizeof(u64);
267
268    if (pagecount > pfncount) {
269        /* we need a gpadl body */
270        /* fill in the header */
271        msgsize = sizeof(struct vmbus_channel_msginfo) +
272              sizeof(struct vmbus_channel_gpadl_header) +
273              sizeof(struct gpa_range) + pfncount * sizeof(u64);
274        msgheader = kzalloc(msgsize, GFP_KERNEL);
275        if (!msgheader)
276            goto nomem;
277
278        INIT_LIST_HEAD(&msgheader->submsglist);
279        msgheader->msgsize = msgsize;
280
281        gpadl_header = (struct vmbus_channel_gpadl_header *)
282            msgheader->msg;
283        gpadl_header->rangecount = 1;
284        gpadl_header->range_buflen = sizeof(struct gpa_range) +
285                     pagecount * sizeof(u64);
286        gpadl_header->range[0].byte_offset = 0;
287        gpadl_header->range[0].byte_count = size;
288        for (i = 0; i < pfncount; i++)
289            gpadl_header->range[0].pfn_array[i] = pfn+i;
290        *msginfo = msgheader;
291        *messagecount = 1;
292
293        pfnsum = pfncount;
294        pfnleft = pagecount - pfncount;
295
296        /* how many pfns can we fit */
297        pfnsize = MAX_SIZE_CHANNEL_MESSAGE -
298              sizeof(struct vmbus_channel_gpadl_body);
299        pfncount = pfnsize / sizeof(u64);
300
301        /* fill in the body */
302        while (pfnleft) {
303            if (pfnleft > pfncount)
304                pfncurr = pfncount;
305            else
306                pfncurr = pfnleft;
307
308            msgsize = sizeof(struct vmbus_channel_msginfo) +
309                  sizeof(struct vmbus_channel_gpadl_body) +
310                  pfncurr * sizeof(u64);
311            msgbody = kzalloc(msgsize, GFP_KERNEL);
312
313            if (!msgbody) {
314                struct vmbus_channel_msginfo *pos = NULL;
315                struct vmbus_channel_msginfo *tmp = NULL;
316                /*
317                 * Free up all the allocated messages.
318                 */
319                list_for_each_entry_safe(pos, tmp,
320                    &msgheader->submsglist,
321                    msglistentry) {
322
323                    list_del(&pos->msglistentry);
324                    kfree(pos);
325                }
326
327                goto nomem;
328            }
329
330            msgbody->msgsize = msgsize;
331            (*messagecount)++;
332            gpadl_body =
333                (struct vmbus_channel_gpadl_body *)msgbody->msg;
334
335            /*
336             * Gpadl is u32 and we are using a pointer which could
337             * be 64-bit
338             * This is governed by the guest/host protocol and
339             * so the hypervisor gurantees that this is ok.
340             */
341            for (i = 0; i < pfncurr; i++)
342                gpadl_body->pfn[i] = pfn + pfnsum + i;
343
344            /* add to msg header */
345            list_add_tail(&msgbody->msglistentry,
346                      &msgheader->submsglist);
347            pfnsum += pfncurr;
348            pfnleft -= pfncurr;
349        }
350    } else {
351        /* everything fits in a header */
352        msgsize = sizeof(struct vmbus_channel_msginfo) +
353              sizeof(struct vmbus_channel_gpadl_header) +
354              sizeof(struct gpa_range) + pagecount * sizeof(u64);
355        msgheader = kzalloc(msgsize, GFP_KERNEL);
356        if (msgheader == NULL)
357            goto nomem;
358        msgheader->msgsize = msgsize;
359
360        gpadl_header = (struct vmbus_channel_gpadl_header *)
361            msgheader->msg;
362        gpadl_header->rangecount = 1;
363        gpadl_header->range_buflen = sizeof(struct gpa_range) +
364                     pagecount * sizeof(u64);
365        gpadl_header->range[0].byte_offset = 0;
366        gpadl_header->range[0].byte_count = size;
367        for (i = 0; i < pagecount; i++)
368            gpadl_header->range[0].pfn_array[i] = pfn+i;
369
370        *msginfo = msgheader;
371        *messagecount = 1;
372    }
373
374    return 0;
375nomem:
376    kfree(msgheader);
377    kfree(msgbody);
378    return -ENOMEM;
379}
380
381/*
382 * vmbus_establish_gpadl - Estabish a GPADL for the specified buffer
383 *
384 * @channel: a channel
385 * @kbuffer: from kmalloc
386 * @size: page-size multiple
387 * @gpadl_handle: some funky thing
388 */
389int vmbus_establish_gpadl(struct vmbus_channel *channel, void *kbuffer,
390                   u32 size, u32 *gpadl_handle)
391{
392    struct vmbus_channel_gpadl_header *gpadlmsg;
393    struct vmbus_channel_gpadl_body *gpadl_body;
394    struct vmbus_channel_msginfo *msginfo = NULL;
395    struct vmbus_channel_msginfo *submsginfo;
396    u32 msgcount;
397    struct list_head *curr;
398    u32 next_gpadl_handle;
399    unsigned long flags;
400    int ret = 0;
401    int t;
402
403    next_gpadl_handle = atomic_read(&vmbus_connection.next_gpadl_handle);
404    atomic_inc(&vmbus_connection.next_gpadl_handle);
405
406    ret = create_gpadl_header(kbuffer, size, &msginfo, &msgcount);
407    if (ret)
408        return ret;
409
410    init_completion(&msginfo->waitevent);
411
412    gpadlmsg = (struct vmbus_channel_gpadl_header *)msginfo->msg;
413    gpadlmsg->header.msgtype = CHANNELMSG_GPADL_HEADER;
414    gpadlmsg->child_relid = channel->offermsg.child_relid;
415    gpadlmsg->gpadl = next_gpadl_handle;
416
417
418    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
419    list_add_tail(&msginfo->msglistentry,
420              &vmbus_connection.chn_msg_list);
421
422    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
423
424    ret = vmbus_post_msg(gpadlmsg, msginfo->msgsize -
425                   sizeof(*msginfo));
426    if (ret != 0)
427        goto cleanup;
428
429    if (msgcount > 1) {
430        list_for_each(curr, &msginfo->submsglist) {
431
432            submsginfo = (struct vmbus_channel_msginfo *)curr;
433            gpadl_body =
434                 (struct vmbus_channel_gpadl_body *)submsginfo->msg;
435
436            gpadl_body->header.msgtype =
437                CHANNELMSG_GPADL_BODY;
438            gpadl_body->gpadl = next_gpadl_handle;
439
440            ret = vmbus_post_msg(gpadl_body,
441                           submsginfo->msgsize -
442                           sizeof(*submsginfo));
443            if (ret != 0)
444                goto cleanup;
445
446        }
447    }
448    t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
449    BUG_ON(t == 0);
450
451
452    /* At this point, we received the gpadl created msg */
453    *gpadl_handle = gpadlmsg->gpadl;
454
455cleanup:
456    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
457    list_del(&msginfo->msglistentry);
458    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
459
460    kfree(msginfo);
461    return ret;
462}
463EXPORT_SYMBOL_GPL(vmbus_establish_gpadl);
464
465/*
466 * vmbus_teardown_gpadl -Teardown the specified GPADL handle
467 */
468int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle)
469{
470    struct vmbus_channel_gpadl_teardown *msg;
471    struct vmbus_channel_msginfo *info;
472    unsigned long flags;
473    int ret, t;
474
475    info = kmalloc(sizeof(*info) +
476               sizeof(struct vmbus_channel_gpadl_teardown), GFP_KERNEL);
477    if (!info)
478        return -ENOMEM;
479
480    init_completion(&info->waitevent);
481
482    msg = (struct vmbus_channel_gpadl_teardown *)info->msg;
483
484    msg->header.msgtype = CHANNELMSG_GPADL_TEARDOWN;
485    msg->child_relid = channel->offermsg.child_relid;
486    msg->gpadl = gpadl_handle;
487
488    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
489    list_add_tail(&info->msglistentry,
490              &vmbus_connection.chn_msg_list);
491    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
492    ret = vmbus_post_msg(msg,
493                   sizeof(struct vmbus_channel_gpadl_teardown));
494
495    BUG_ON(ret != 0);
496    t = wait_for_completion_timeout(&info->waitevent, 5*HZ);
497    BUG_ON(t == 0);
498
499    /* Received a torndown response */
500    spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
501    list_del(&info->msglistentry);
502    spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
503
504    kfree(info);
505    return ret;
506}
507EXPORT_SYMBOL_GPL(vmbus_teardown_gpadl);
508
509/*
510 * vmbus_close - Close the specified channel
511 */
512void vmbus_close(struct vmbus_channel *channel)
513{
514    struct vmbus_channel_close_channel *msg;
515    int ret;
516    unsigned long flags;
517
518    /* Stop callback and cancel the timer asap */
519    spin_lock_irqsave(&channel->inbound_lock, flags);
520    channel->onchannel_callback = NULL;
521    spin_unlock_irqrestore(&channel->inbound_lock, flags);
522
523    /* Send a closing message */
524
525    msg = &channel->close_msg.msg;
526
527    msg->header.msgtype = CHANNELMSG_CLOSECHANNEL;
528    msg->child_relid = channel->offermsg.child_relid;
529
530    ret = vmbus_post_msg(msg, sizeof(struct vmbus_channel_close_channel));
531
532    BUG_ON(ret != 0);
533    /* Tear down the gpadl for the channel's ring buffer */
534    if (channel->ringbuffer_gpadlhandle)
535        vmbus_teardown_gpadl(channel,
536                      channel->ringbuffer_gpadlhandle);
537
538    /* Cleanup the ring buffers for this channel */
539    hv_ringbuffer_cleanup(&channel->outbound);
540    hv_ringbuffer_cleanup(&channel->inbound);
541
542    free_pages((unsigned long)channel->ringbuffer_pages,
543        get_order(channel->ringbuffer_pagecount * PAGE_SIZE));
544
545
546}
547EXPORT_SYMBOL_GPL(vmbus_close);
548
549/**
550 * vmbus_sendpacket() - Send the specified buffer on the given channel
551 * @channel: Pointer to vmbus_channel structure.
552 * @buffer: Pointer to the buffer you want to receive the data into.
553 * @bufferlen: Maximum size of what the the buffer will hold
554 * @requestid: Identifier of the request
555 * @type: Type of packet that is being send e.g. negotiate, time
556 * packet etc.
557 *
558 * Sends data in @buffer directly to hyper-v via the vmbus
559 * This will send the data unparsed to hyper-v.
560 *
561 * Mainly used by Hyper-V drivers.
562 */
563int vmbus_sendpacket(struct vmbus_channel *channel, const void *buffer,
564               u32 bufferlen, u64 requestid,
565               enum vmbus_packet_type type, u32 flags)
566{
567    struct vmpacket_descriptor desc;
568    u32 packetlen = sizeof(struct vmpacket_descriptor) + bufferlen;
569    u32 packetlen_aligned = ALIGN(packetlen, sizeof(u64));
570    struct scatterlist bufferlist[3];
571    u64 aligned_data = 0;
572    int ret;
573
574
575    /* Setup the descriptor */
576    desc.type = type; /* VmbusPacketTypeDataInBand; */
577    desc.flags = flags; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
578    /* in 8-bytes granularity */
579    desc.offset8 = sizeof(struct vmpacket_descriptor) >> 3;
580    desc.len8 = (u16)(packetlen_aligned >> 3);
581    desc.trans_id = requestid;
582
583    sg_init_table(bufferlist, 3);
584    sg_set_buf(&bufferlist[0], &desc, sizeof(struct vmpacket_descriptor));
585    sg_set_buf(&bufferlist[1], buffer, bufferlen);
586    sg_set_buf(&bufferlist[2], &aligned_data,
587           packetlen_aligned - packetlen);
588
589    ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3);
590
591    if (ret == 0 && !hv_get_ringbuffer_interrupt_mask(&channel->outbound))
592        vmbus_setevent(channel);
593
594    return ret;
595}
596EXPORT_SYMBOL(vmbus_sendpacket);
597
598/*
599 * vmbus_sendpacket_pagebuffer - Send a range of single-page buffer
600 * packets using a GPADL Direct packet type.
601 */
602int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
603                     struct hv_page_buffer pagebuffers[],
604                     u32 pagecount, void *buffer, u32 bufferlen,
605                     u64 requestid)
606{
607    int ret;
608    int i;
609    struct vmbus_channel_packet_page_buffer desc;
610    u32 descsize;
611    u32 packetlen;
612    u32 packetlen_aligned;
613    struct scatterlist bufferlist[3];
614    u64 aligned_data = 0;
615
616    if (pagecount > MAX_PAGE_BUFFER_COUNT)
617        return -EINVAL;
618
619
620    /*
621     * Adjust the size down since vmbus_channel_packet_page_buffer is the
622     * largest size we support
623     */
624    descsize = sizeof(struct vmbus_channel_packet_page_buffer) -
625              ((MAX_PAGE_BUFFER_COUNT - pagecount) *
626              sizeof(struct hv_page_buffer));
627    packetlen = descsize + bufferlen;
628    packetlen_aligned = ALIGN(packetlen, sizeof(u64));
629
630    /* Setup the descriptor */
631    desc.type = VM_PKT_DATA_USING_GPA_DIRECT;
632    desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
633    desc.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
634    desc.length8 = (u16)(packetlen_aligned >> 3);
635    desc.transactionid = requestid;
636    desc.rangecount = pagecount;
637
638    for (i = 0; i < pagecount; i++) {
639        desc.range[i].len = pagebuffers[i].len;
640        desc.range[i].offset = pagebuffers[i].offset;
641        desc.range[i].pfn = pagebuffers[i].pfn;
642    }
643
644    sg_init_table(bufferlist, 3);
645    sg_set_buf(&bufferlist[0], &desc, descsize);
646    sg_set_buf(&bufferlist[1], buffer, bufferlen);
647    sg_set_buf(&bufferlist[2], &aligned_data,
648        packetlen_aligned - packetlen);
649
650    ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3);
651
652    if (ret == 0 && !hv_get_ringbuffer_interrupt_mask(&channel->outbound))
653        vmbus_setevent(channel);
654
655    return ret;
656}
657EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer);
658
659/*
660 * vmbus_sendpacket_multipagebuffer - Send a multi-page buffer packet
661 * using a GPADL Direct packet type.
662 */
663int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel,
664                struct hv_multipage_buffer *multi_pagebuffer,
665                void *buffer, u32 bufferlen, u64 requestid)
666{
667    int ret;
668    struct vmbus_channel_packet_multipage_buffer desc;
669    u32 descsize;
670    u32 packetlen;
671    u32 packetlen_aligned;
672    struct scatterlist bufferlist[3];
673    u64 aligned_data = 0;
674    u32 pfncount = NUM_PAGES_SPANNED(multi_pagebuffer->offset,
675                     multi_pagebuffer->len);
676
677
678    if ((pfncount < 0) || (pfncount > MAX_MULTIPAGE_BUFFER_COUNT))
679        return -EINVAL;
680
681    /*
682     * Adjust the size down since vmbus_channel_packet_multipage_buffer is
683     * the largest size we support
684     */
685    descsize = sizeof(struct vmbus_channel_packet_multipage_buffer) -
686              ((MAX_MULTIPAGE_BUFFER_COUNT - pfncount) *
687              sizeof(u64));
688    packetlen = descsize + bufferlen;
689    packetlen_aligned = ALIGN(packetlen, sizeof(u64));
690
691
692    /* Setup the descriptor */
693    desc.type = VM_PKT_DATA_USING_GPA_DIRECT;
694    desc.flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
695    desc.dataoffset8 = descsize >> 3; /* in 8-bytes grandularity */
696    desc.length8 = (u16)(packetlen_aligned >> 3);
697    desc.transactionid = requestid;
698    desc.rangecount = 1;
699
700    desc.range.len = multi_pagebuffer->len;
701    desc.range.offset = multi_pagebuffer->offset;
702
703    memcpy(desc.range.pfn_array, multi_pagebuffer->pfn_array,
704           pfncount * sizeof(u64));
705
706    sg_init_table(bufferlist, 3);
707    sg_set_buf(&bufferlist[0], &desc, descsize);
708    sg_set_buf(&bufferlist[1], buffer, bufferlen);
709    sg_set_buf(&bufferlist[2], &aligned_data,
710        packetlen_aligned - packetlen);
711
712    ret = hv_ringbuffer_write(&channel->outbound, bufferlist, 3);
713
714    if (ret == 0 && !hv_get_ringbuffer_interrupt_mask(&channel->outbound))
715        vmbus_setevent(channel);
716
717    return ret;
718}
719EXPORT_SYMBOL_GPL(vmbus_sendpacket_multipagebuffer);
720
721/**
722 * vmbus_recvpacket() - Retrieve the user packet on the specified channel
723 * @channel: Pointer to vmbus_channel structure.
724 * @buffer: Pointer to the buffer you want to receive the data into.
725 * @bufferlen: Maximum size of what the the buffer will hold
726 * @buffer_actual_len: The actual size of the data after it was received
727 * @requestid: Identifier of the request
728 *
729 * Receives directly from the hyper-v vmbus and puts the data it received
730 * into Buffer. This will receive the data unparsed from hyper-v.
731 *
732 * Mainly used by Hyper-V drivers.
733 */
734int vmbus_recvpacket(struct vmbus_channel *channel, void *buffer,
735            u32 bufferlen, u32 *buffer_actual_len, u64 *requestid)
736{
737    struct vmpacket_descriptor desc;
738    u32 packetlen;
739    u32 userlen;
740    int ret;
741
742    *buffer_actual_len = 0;
743    *requestid = 0;
744
745
746    ret = hv_ringbuffer_peek(&channel->inbound, &desc,
747                 sizeof(struct vmpacket_descriptor));
748    if (ret != 0)
749        return 0;
750
751    packetlen = desc.len8 << 3;
752    userlen = packetlen - (desc.offset8 << 3);
753
754    *buffer_actual_len = userlen;
755
756    if (userlen > bufferlen) {
757
758        pr_err("Buffer too small - got %d needs %d\n",
759               bufferlen, userlen);
760        return -ETOOSMALL;
761    }
762
763    *requestid = desc.trans_id;
764
765    /* Copy over the packet to the user buffer */
766    ret = hv_ringbuffer_read(&channel->inbound, buffer, userlen,
767                 (desc.offset8 << 3));
768
769
770    return 0;
771}
772EXPORT_SYMBOL(vmbus_recvpacket);
773
774/*
775 * vmbus_recvpacket_raw - Retrieve the raw packet on the specified channel
776 */
777int vmbus_recvpacket_raw(struct vmbus_channel *channel, void *buffer,
778                  u32 bufferlen, u32 *buffer_actual_len,
779                  u64 *requestid)
780{
781    struct vmpacket_descriptor desc;
782    u32 packetlen;
783    u32 userlen;
784    int ret;
785
786    *buffer_actual_len = 0;
787    *requestid = 0;
788
789
790    ret = hv_ringbuffer_peek(&channel->inbound, &desc,
791                 sizeof(struct vmpacket_descriptor));
792    if (ret != 0)
793        return 0;
794
795
796    packetlen = desc.len8 << 3;
797    userlen = packetlen - (desc.offset8 << 3);
798
799    *buffer_actual_len = packetlen;
800
801    if (packetlen > bufferlen) {
802        pr_err("Buffer too small - needed %d bytes but "
803            "got space for only %d bytes\n",
804            packetlen, bufferlen);
805        return -ENOBUFS;
806    }
807
808    *requestid = desc.trans_id;
809
810    /* Copy over the entire packet to the user buffer */
811    ret = hv_ringbuffer_read(&channel->inbound, buffer, packetlen, 0);
812
813    return 0;
814}
815EXPORT_SYMBOL_GPL(vmbus_recvpacket_raw);
816

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive