分类目录： C/C++

#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);

[root@Shentar /opt/drbd-8.3.5]# modprobe -all|grep drbd
/lib/modules/2.6.25-14.fc9.i686/kernel/drivers/block/drbd.ko
[root@Shentar /opt/drbd-8.3.5]# 

module_init(drbd_init)
module_exit(drbd_cleanup)

int __init drbd_init(void)
{
    int err;

    if (sizeof(struct p_handshake) != 80)
    {
        printk(KERN_ERR
               "drbd: never change the size or layout "
               "of the HandShake packet.\n");
        return -EINVAL;
    }

    if (1 > minor_count || minor_count > 255)
    {
        printk(KERN_ERR
            "drbd: invalid minor_count (%d)\n", minor_count);
#ifdef MODULE
        return -EINVAL;
#else
        minor_count = 8;
#endif
    }

    err = drbd_nl_init();
    if (err)
        return err;

    err = register_blkdev(DRBD_MAJOR, "drbd");
    if (err)
    {
        printk(KERN_ERR
               "drbd: unable to register block device major %d\n", DRBD_MAJOR);
        return err;
    }

    register_reboot_notifier(&drbd_notifier);

    /*
     * allocate all necessary structs
     */
    err = -ENOMEM;

    init_waitqueue_head(&drbd_pp_wait);

    drbd_proc = NULL; /* play safe for drbd_cleanup */
    minor_table = kzalloc(sizeof(struct drbd_conf *) * minor_count, GFP_KERNEL);
    if (!minor_table)
        goto Enomem;

    err = drbd_create_mempools();
    if (err)
        goto Enomem;

    drbd_proc = proc_create("drbd", S_IFREG | S_IRUGO, NULL, &drbd_proc_fops);
    if (!drbd_proc)
    {
        printk(KERN_ERR "drbd: unable to register proc file\n");
        goto Enomem;
    }

    rwlock_init(&global_state_lock);

    printk(KERN_INFO "drbd: initialized. "
                     "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
        API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
    printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
    printk(KERN_INFO "drbd: registered as block device major %d\n", DRBD_MAJOR);
    printk(KERN_INFO "drbd: minor_table @ 0x%p\n", minor_table);

    return 0; /* Success! */

    Enomem : drbd_cleanup();
    if (err == -ENOMEM)
            /* currently always the case */
        printk(KERN_ERR "drbd: ran out of memory\n");
    else
        printk(KERN_ERR "drbd: initialization failure\n");
    return err;
}

int cn_add_callback(struct cb_id*, char*, void (*callback) (void*));
void cn_del_callback(struct cb_id*);
int cn_netlink_send(struct cn_msg*, u32, gfp_t);

int cn_queue_add_callback(struct cn_queue_dev* dev, char* name,
    struct cb_id* id, void (*callback) (void*));
void cn_queue_del_callback(struct cn_queue_dev* dev, struct cb_id* id);

struct cn_queue_dev* cn_queue_alloc_dev(char* name, struct sock*);
void cn_queue_free_dev(struct cn_queue_dev* dev);

int cn_cb_equal(struct cb_id*, struct cb_id*);

void cn_queue_wrapper(void* data);

struct file_operations drbd_proc_fops =
{
    .owner = THIS_MODULE, .open = drbd_proc_open, .read = seq_read,
    .llseek = seq_lseek, .release = single_release, 
};