DRBD源码分析（二）——内核模块网络配置和启动

#ifdef KERNEL_HAS_CN_SKB_PARMS
STATIC void drbd_connector_callback(struct cn_msg *req, struct netlink_skb_parms *nsp)
{
#else
STATIC void drbd_connector_callback(void *data)
{
    struct cn_msg *req = data;
#endif
    struct drbd_nl_cfg_req *nlp = (struct drbd_nl_cfg_req *)req->data;
    struct cn_handler_struct *cm;
    struct cn_msg *cn_reply;
    struct drbd_nl_cfg_reply *reply;
    struct drbd_conf *mdev;
    int retcode, rr;
    int reply_size = sizeof(struct cn_msg)
        + sizeof(struct drbd_nl_cfg_reply)
        + sizeof(short int);

    if (!try_module_get(THIS_MODULE)) {
        printk(KERN_ERR "drbd: try_module_get() failed!\n");
        return;
    }

#ifdef KERNEL_HAS_CN_SKB_PARMS
    if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) {
        retcode = ERR_PERM;
        goto fail;
    }
#endif

    mdev = ensure_mdev(nlp);
    if (!mdev) {
        retcode = ERR_MINOR_INVALID;
        goto fail;
    }

    trace_drbd_netlink(req, 1);

    if (nlp->packet_type >= P_nl_after_last_packet) {
        retcode = ERR_PACKET_NR;
        goto fail;
    }
    printk("packet_type is %d\n", nlp->packet_type);
    cm = cnd_table + nlp->packet_type;

    /* This may happen if packet number is 0: */
    if (cm->function == NULL) {
        retcode = ERR_PACKET_NR;
        goto fail;
    }

    reply_size += cm->reply_body_size;

    /* allocation not in the IO path, cqueue thread context */
    cn_reply = kmalloc(reply_size, GFP_KERNEL);
    if (!cn_reply) {
        retcode = ERR_NOMEM;
        goto fail;
    }
    reply = (struct drbd_nl_cfg_reply *) cn_reply->data;

    reply->packet_type =
        cm->reply_body_size ? nlp->packet_type : P_nl_after_last_packet;
    reply->minor = nlp->drbd_minor;
    reply->ret_code = NO_ERROR; /* Might by modified by cm->function. */
    /* reply->tag_list; might be modified by cm->function. */

    rr = cm->function(mdev, nlp, reply);

    cn_reply->id = req->id;
    cn_reply->seq = req->seq;
    cn_reply->ack = req->ack  + 1;
    cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + rr;
    cn_reply->flags = 0;

    trace_drbd_netlink(cn_reply, 0);
    rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_KERNEL);
    if (rr && rr != -ESRCH)
        printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr);

    kfree(cn_reply);
    module_put(THIS_MODULE);
    return;
 fail:
    drbd_nl_send_reply(req, retcode);
    module_put(THIS_MODULE);
}

rr=cm->function(mdev,nlp,reply);

cm=cnd_table+nlp->packet_type;

static struct cn_handler_struct cnd_table[] = {
    [ P_primary ]        = { &drbd_nl_primary,        0 },
    [ P_secondary ]        = { &drbd_nl_secondary,        0 },
    [ P_disk_conf ]        = { &drbd_nl_disk_conf,        0 },
    [ P_detach ]        = { &drbd_nl_detach,        0 },
    [ P_net_conf ]        = { &drbd_nl_net_conf,        0 },
    [ P_disconnect ]    = { &drbd_nl_disconnect,    0 },
    [ P_resize ]        = { &drbd_nl_resize,        0 },
    [ P_syncer_conf ]    = { &drbd_nl_syncer_conf,    0 },
    [ P_invalidate ]    = { &drbd_nl_invalidate,    0 },
    [ P_invalidate_peer ]    = { &drbd_nl_invalidate_peer,    0 },
    [ P_pause_sync ]    = { &drbd_nl_pause_sync,    0 },
    [ P_resume_sync ]    = { &drbd_nl_resume_sync,    0 },
    [ P_suspend_io ]    = { &drbd_nl_suspend_io,    0 },
    [ P_resume_io ]        = { &drbd_nl_resume_io,        0 },
    [ P_outdate ]        = { &drbd_nl_outdate,        0 },
    [ P_get_config ]    = { &drbd_nl_get_config,
                    sizeof(struct syncer_conf_tag_len_struct) +
                    sizeof(struct disk_conf_tag_len_struct) +
                    sizeof(struct net_conf_tag_len_struct) },
    [ P_get_state ]        = { &drbd_nl_get_state,
                    sizeof(struct get_state_tag_len_struct) +
                    sizeof(struct sync_progress_tag_len_struct)    },
    [ P_get_uuids ]        = { &drbd_nl_get_uuids,
                    sizeof(struct get_uuids_tag_len_struct) },
    [ P_get_timeout_flag ]    = { &drbd_nl_get_timeout_flag,
                    sizeof(struct get_timeout_flag_tag_len_struct)},
    [ P_start_ov ]        = { &drbd_nl_start_ov,        0 },
    [ P_new_c_uuid ]    = { &drbd_nl_new_c_uuid,    0 },
};

int drbd_worker(struct drbd_thread* thi)
{
...
        w = NULL;
        spin_lock_irq(&mdev->data.work.q_lock);
        ERR_IF(list_empty(&mdev->data.work.q))
        {
            /* something terribly wrong in our logic.
                     * we were able to down() the semaphore,
                     * but the list is empty... doh.
                     *
                     * what is the best thing to do now?
                     * try again from scratch, restarting the receiver,
                     * asender, whatnot? could break even more ugly,
                     * e.g. when we are primary, but no good local data.
                     *
                     * I'll try to get away just starting over this loop.
                     */
            spin_unlock_irq(&mdev->data.work.q_lock);
            continue;
        }
        w = list_entry(mdev->data.work.q.next, struct drbd_work, list);
        list_del_init(&w->list);
        spin_unlock_irq(&mdev->data.work.q_lock);

        if (!w->cb(mdev, w, mdev->state.conn < C_CONNECTED))
        {
            /* dev_warn(DEV, "worker: a callback failed! \n"); */
            if (mdev->state.conn >= C_CONNECTED)
                drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE));
        }
...
}

retcode=_drbd_request_state(mdev,NS(conn,C_UNCONNECTED),CS_VERBOSE);