Ubuntu主机环境，设备端log:
root@udx710-module:~# 
[  324.516525] c0 configfs-gadget gadget: rndis_close
[  324.521239] c0 rndis_set_param_medium: 0 0
[  324.525296] c0 rndis_signal_disconnect
[  324.529023] c0 rndis_indicate_status_msg: status 1073807372
​
Windows主机环境，设备端log:
root@udx710-module:~#  
[  191.340507] c1 configfs-gadget gadget: rndis_close
[  191.345223] c1 rndis_set_param_medium: 0 0
[  191.349285] c1 rndis_signal_disconnect
[  191.353008] c1 rndis_indicate_status_msg: status 1073807372
[  191.364621] c1 configfs-gadget gadget: rndis reqa1.01 v0000 i0000 l4096

drivers/usb/gadget/function/rndis.c
​
int rndis_signal_disconnect(struct rndis_params *params)
{
  params->media_state = RNDIS_MEDIA_STATE_DISCONNECTED;
  return rndis_indicate_status_msg(params, RNDIS_STATUS_MEDIA_DISCONNECT);
}
​
/*
 * Device to Host Comunication
 */
static int rndis_indicate_status_msg(struct rndis_params *params, u32 status)
{
  rndis_indicate_status_msg_type *resp;
  rndis_resp_t *r;
​
  if (params->state == RNDIS_UNINITIALIZED)
    return -ENOTSUPP;
​
  r = rndis_add_response(params, sizeof(rndis_indicate_status_msg_type));
  if (!r)
    return -ENOMEM;
  resp = (rndis_indicate_status_msg_type *)r->buf;
​
  resp->MessageType = cpu_to_le32(RNDIS_MSG_INDICATE);
  resp->MessageLength = cpu_to_le32(20);
  resp->Status = cpu_to_le32(status);
  resp->StatusBufferLength = cpu_to_le32(0);
  resp->StatusBufferOffset = cpu_to_le32(0);
​
  params->resp_avail(params->v);
  return 0;
}
​
drivers/usb/gadget/function/f_rndis.c
​
static void rndis_response_available(void *_rndis)
{
  struct f_rndis      *rndis = _rndis;
  struct usb_request    *req = rndis->notify_req;
  struct usb_composite_dev  *cdev = rndis->port.func.config->cdev;
  __le32        *data = req->buf;
  int        status;
​
  if (atomic_inc_return(&rndis->notify_count) != 1)
    return;
​
  /* Send RNDIS RESPONSE_AVAILABLE notification; a
   * USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
   *
   * This is the only notification defined by RNDIS.
   */
  data[0] = cpu_to_le32(1);
  data[1] = cpu_to_le32(0);
​
  status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
  if (status) {
    atomic_dec(&rndis->notify_count);
    DBG(cdev, "notify/0 --> %d\n", status);
  }
}

drivers/net/usb/rndis_host.c
void rndis_status(struct usbnet *dev, struct urb *urb)
{
  netdev_dbg(dev->net, "rndis status urb, len %d stat %d\n",
       urb->actual_length, urb->status);
  // FIXME for keepalives, respond immediately (asynchronously)
  // if not an RNDIS status, do like cdc_status(dev,urb) does
}
​
static const struct driver_info  rndis_info = {
  .description =  "RNDIS device",
  .flags =  FLAG_ETHER | FLAG_POINTTOPOINT | FLAG_FRAMING_RN | FLAG_NO_SETINT,
  .bind =    rndis_bind,
  .unbind =  rndis_unbind,
  .status =  rndis_status,
  .rx_fixup =  rndis_rx_fixup,
  .tx_fixup =  rndis_tx_fixup,
};

/*
 * RNDIS is NDIS remoted over USB.  It's a MSFT variant of CDC ACM ... of
 * course ACM was intended for modems, not Ethernet links!  USB's standard
 * for Ethernet links is "CDC Ethernet", which is significantly simpler.
 *
 * NOTE that Microsoft's "RNDIS 1.0" specification is incomplete.  Issues
 * include:
 *    - Power management in particular relies on information that's scattered
 *  through other documentation, and which is incomplete or incorrect even
 *  there.
 *    - There are various undocumented protocol requirements, such as the
 *  need to send unused garbage in control-OUT messages.
 *    - In some cases, MS-Windows will emit undocumented requests; this
 *  matters more to peripheral implementations than host ones.
 *
 * Moreover there's a no-open-specs variant of RNDIS called "ActiveSync".
 *
 * For these reasons and others, ** USE OF RNDIS IS STRONGLY DISCOURAGED ** in
 * favor of such non-proprietary alternatives as CDC Ethernet or the newer (and
 * currently rare) "Ethernet Emulation Model" (EEM).
 */

static void ecm_do_notify(struct f_ecm *ecm)
{
  struct usb_request    *req = ecm->notify_req;
  struct usb_cdc_notification  *event;
...
  event = req->buf;
  switch (ecm->notify_state) {
 ...
  case ECM_NOTIFY_CONNECT:
    event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
    if (ecm->is_open)
      event->wValue = cpu_to_le16(1);
    else
      event->wValue = cpu_to_le16(0);
    event->wLength = 0;
    req->length = sizeof *event;
​
    DBG(cdev, "notify connect %s\n",
        ecm->is_open ? "true" : "false");
    ecm->notify_state = ECM_NOTIFY_SPEED;
    break;
...
}

void usbnet_cdc_status(struct usbnet *dev, struct urb *urb)
{
  struct usb_cdc_notification  *event;
...
  event = urb->transfer_buffer;
  switch (event->bNotificationType) {
  case USB_CDC_NOTIFY_NETWORK_CONNECTION:
    netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n",
        event->wValue ? "on" : "off");
    usbnet_link_change(dev, !!event->wValue, 0);
    break;
...
  }
}
​
static const struct driver_info  cdc_info = {
  .description =  "CDC Ethernet Device",
  .flags =  FLAG_ETHER | FLAG_POINTTOPOINT,
  .bind =    usbnet_cdc_bind,
  .unbind =  usbnet_cdc_unbind,
  .status =  usbnet_cdc_status,
  .set_rx_mode =  usbnet_cdc_update_filter,
  .manage_power =  usbnet_manage_power,
};