def check_backlogged_hosting_devices(self, driver_mgr):
        """Checks the status of backlogged hosting devices.

        Skips newly spun up instances during their booting time as specified
        in the boot time parameter.

        Each hosting-device tracked has a key, hd_state, that represents the
        last known state for the hosting device.  Valid values for hd_state
        are ['Active', 'Unknown', 'Dead']

        Each time check_backlogged_hosting_devices is invoked, a ping-test
        is performed to determine the current state.  If the current state
        differs, hd_state is updated.

        The hd_state transitions/actions are represented by the following
        table.

        +------------+---------------------+----------------+----------------+
        | current /  | Active              | Unknown        | Dead           |
        | last state |                     |                |                |
        +============+=====================+================+================+
        | Active     | Device is reachable.| Device was     | Dead device    |
        |            | No state change     | temporarily    | recovered.     |
        |            |                     | unreachable.   | Trigger resync |
        +------------+---------------------+----------------+----------------+
        | Unknown    | Device connectivity | Device         | Not a valid    |
        |            | test failed.  Set   | connectivity   | state          |
        |            | backlog timestamp   | test failed.   | transition.    |
        |            | and wait for dead   | Dead timeout   |                |
        |            | timeout to occur.   | has not        |                |
        |            |                     | occurred yet.  |                |
        +------------+---------------------+----------------+----------------+
        | Dead       | Not a valid state   | Dead timeout   | Device is      |
        |            | transition.         | for device has | still dead.    |
        |            |                     | elapsed.       | No state       |
        |            |                     | Notify plugin  | change.        |
        +------------+---------------------+----------------+----------------+

        :returns: A dict of the format:

        ::

          {"reachable": [<hd_id>,..],
          "dead": [<hd_id>,..],
          "revived": [<hd_id>,..]}

        * reachable - a list of hosting devices that are now reachable
        * dead      - a list of hosting devices deemed dead
        * revived   - a list of hosting devices (dead to active)
        """
        response_dict = {'reachable': [], 'revived': [], 'dead': []}
        LOG.debug("Current Backlogged hosting devices: \n%s\n",
                  self.hosting_devices_backlog.keys())
        for hd_id in self.hosting_devices_backlog.keys():
            hd = self.hosting_devices_backlog[hd_id]['hd']
            if not timeutils.is_older_than(hd['created_at'],
                                           hd['booting_time']):
                LOG.info("Hosting device: %(hd_id)s @ %(ip)s hasn't "
                         "passed minimum boot time. Skipping it. ",
                         {'hd_id': hd_id, 'ip': hd['management_ip_address']})
                continue
            LOG.info("Checking hosting device: %(hd_id)s @ %(ip)s for "
                     "reachability.", {'hd_id': hd_id,
                                       'ip': hd['management_ip_address']})
            hd_state = hd['hd_state']
            if _is_pingable(hd['management_ip_address']):
                if hd_state == cc.HD_NOT_RESPONDING:
                    LOG.debug("hosting devices revived & reachable, %s" %
                              (pprint.pformat(hd)))
                    hd['hd_state'] = cc.HD_ACTIVE
                    # hosting device state
                    response_dict['reachable'].append(hd_id)
                elif hd_state == cc.HD_DEAD:
                    # test if management port is available
                    if _can_connect(hd['management_ip_address'],
                                    hd['protocol_port']) is True:
                        LOG.debug("Dead hosting devices revived %s" %
                                  (pprint.pformat(hd)))
                        hd['hd_state'] = cc.HD_ACTIVE
                        response_dict['revived'].append(hd_id)
                    else:
                        LOG.debug("Cannot connect to management port %(p)d on "
                                  "hosting device with ip %(ip)s",
                                  {'p': hd['protocol_port'],
                                   'ip': hd['management_ip_address']})
                else:
                    LOG.debug("No-op."
                              "_is_pingable is True and current"
                              " hd['hd_state']=%s" % hd_state)

                LOG.info("Hosting device: %(hd_id)s @ %(ip)s is now "
                         "reachable. Adding it to response",
                         {'hd_id': hd_id, 'ip': hd['management_ip_address']})
            else:
                LOG.info("Hosting device: %(hd_id)s %(hd_state)s"
                         " @ %(ip)s not reachable ",
                         {'hd_id': hd_id,
                          'hd_state': hd['hd_state'],
                          'ip': hd['management_ip_address']})
                if hd_state == cc.HD_ACTIVE:
                    LOG.debug("hosting device lost connectivity, %s" %
                              (pprint.pformat(hd)))
                    hd['backlog_insertion_ts'] = timeutils.utcnow()
                    hd['hd_state'] = cc.HD_NOT_RESPONDING

                elif hd_state == cc.HD_NOT_RESPONDING:
                    if timeutils.is_older_than(
                            hd['backlog_insertion_ts'],
                            cfg.CONF.cfg_agent.hosting_device_dead_timeout):
                        # current hd_state is now dead, previous state: Unknown
                        hd['hd_state'] = cc.HD_DEAD
                        LOG.debug("Hosting device: %(hd_id)s @ %(ip)s hasn't "
                                  "been reachable for the "
                                  "last %(time)d seconds. "
                                  "Marking it dead.",
                                  {'hd_id': hd_id,
                                   'ip': hd['management_ip_address'],
                                   'time': cfg.CONF.cfg_agent.
                                   hosting_device_dead_timeout})
                        response_dict['dead'].append(hd_id)
        LOG.debug("Response: %s", response_dict)
        return response_dict