来源: 互联网  发布时间: 2013-11-10

          Windows socket重叠IO模型开发。

 

     利用套接字重叠IO模型，应用程序能一次投递一个或多个IO请求，当系统完成IO操作后通知应用程序。该模型以win32异步IO机制为基础。与前面介绍的所有IO模型相比较，该模型是真正意义上的异步IO模型，它能使Windows socket应用程序达到更高的性能。

     关于异步IO机制可以参考：《Windows核心编程系列》十谈谈同步设备IO与异步设备IO之异步设备IO。

     Windows socket重叠IO延续了win32 IO模型。从发送和接收的角度来看，重叠IO模型与前面介绍的Select模型、WSAAsyncSelect模型和WSAEventSelect模型都不同。因为在这三个模型中IO操作还是同步的，例如：在应用程序调用recv函数时，都会在recv函数内阻塞，直到接收数据完毕后才返回。而重叠IO模型会在调用recv后立即返回。等数据准备好后再通知应用程序。

      系统向应用程序发送通知的形式有两种：一是事件通知。二是完成例程。后面将会介绍这两种形式。

     注意：套接字的重叠IO属性不会对套接字的当前工作模式产生影响。创建具有重叠属性的套接字执行重叠IO操作，并不会改变套接字的阻塞模式。套接字的阻塞模式与重叠IO操作不相关。重叠IO模型仅仅对WSASend和WSARecv的行为有影响。 对listen，如果是阻塞模式，直到有客户请求到达时才会返回。这点要特别注意。

     与其他模型的区别

      在Windows socket中，接收数据的过程可以分为：等待数据和将数据从系统复制到用户空间两个阶段。各种IO模型的区别在于这两个阶段上。

     前三个模型的第一个阶段的区别： select模型利用select函数主动检查系统中套接字是否满足可读条件。WSAAsyncSelect模型和WSAEventSelect模型则被动等待系统的通知。

     第二个阶段的区别：此阶段前三个模型基本相同，在将数据从系统复制到用户缓冲区时，线程阻塞。而重叠IO与它们都不同，应用程序在调用输入函数后，只需等待接收系统完成的IO操作完成通知。

     套接字重叠IO模型主要有一下相关函数：

     WSASocket（）：创建套接字。 

[2]VC 一个函数实现listbox 水平滚动条

HWND hWnd=GetDlgItem(hDlg,IDC_SCREEN_LIST_NAME);  //列表选项，图片，文本，noted by luffy 01-05
	SendMessage(hWnd,LB_SETHORIZONTALEXTENT,250,0);  

横向滚动条的属性依然要设定为true

SendMessage (GetDlgItem
(IDC_LSTPROFILE),LB_SETHORIZONTALEXTENT,250,0);

第一个参数是listbox的HWND，把你的控件id换上
第二个参数就用这个
第三个是个整数，代表像素数，可以是个变量，你自己调试该用多大
第四个参数就写0就可以了。

LB_SETHORIZONTALEXTENT：这个消息就是设置水平滚动条

[3]linux ioctl实验 对初学ioctl很有帮助

    本文是我在andoid实验的ioctl的功能，如双向传递参数。贴出来希望对学习ioctl的人很有帮助。
    linux的ioctl功能是很强大的，android显示模块还有camera模块都离不开ioctl让上层和内核交互。
board中添加platform_devce
static struct ioctl_test_platform_data ioctl_pdata = {
        static struct ioctl_test_platform_data ioctl_pdata = {
        .gpio=17,
};

static struct platform_device msm_device_ioctl = {
    .name    = "gpio_test",
    .id        = -1,
    .dev    = {
        .platform_data = &ioctl_pdata,
    },
};


头文件：
ioctl_test.h

#ifndef IOCTL_TEST_H
#define IOCTL_TEST_H


/* platform data from board file */
struct ioctl_test_platform_data{
    u16 gpio;
};

struct gpio_priv_t {
    
    int gpio;
    int state0;
    int state1;
    int state2;
    int state3;
    
};

#define GPIO_TEST_IOC_MAGIC          0x92

#define GPIO_TEST_SET_HIGH          _IO(GPIO_TEST_IOC_MAGIC, 1)
#define GPIO_TEST_SET_LOW           _IO(GPIO_TEST_IOC_MAGIC, 2)

#define GPIO_TEST_WRITE_STRUCT           _IOW(GPIO_TEST_IOC_MAGIC, 3,struct gpio_priv_t *)
#define GPIO_TEST_WRITE_INT         _IOW(GPIO_TEST_IOC_MAGIC, 4,unsigned int *)

#define GPIO_TEST_READ_STRUCT          _IOR(GPIO_TEST_IOC_MAGIC, 5,struct gpio_priv_t *)
#define GPIO_TEST_READ_INT          _IOR(GPIO_TEST_IOC_MAGIC, 6,unsigned int *)




#endif




driver:
生成设备节点：/dev/gpio_test
ioctl_test.c

#define pr_fmt(fmt) "%s: " fmt, __func__

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/regulator/consumer.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <mach/gpio.h>
#include<linux/ioctl_test.h>


static struct gpio_priv_t *gpio_priv;


static int gpio_test_open(struct inode *inode, struct file *filp)
{
    if (gpio_priv == NULL)
        return -ENODEV;

    filp->private_data = gpio_priv;

    return 0;
}

static int gpio_test_release(struct inode *inode, struct file *filp)
{

    filp->private_data = NULL;

    return 0;
}


static long
gpio_test_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int err = 0;
    void __user *argp = (void __user *)arg;
    int value0;
    int value1 ;
    

    /* Verify user arguments. */
    if (_IOC_TYPE(cmd) != GPIO_TEST_IOC_MAGIC)
        return -ENOTTY;

    switch (cmd) {
    case GPIO_TEST_SET_HIGH:
        printk("GPIO_TEST_SET_HIGH\n");
        if (arg == 0) {
            pr_err("user space arg not supplied\n");
            err = -EFAULT;
            break;
        }
        gpio_set_value(17,1);

        break;

    case GPIO_TEST_SET_LOW:
        printk("GPIO_TEST_SET_LOW\n");
        if (arg == 0) {
            pr_err("user space arg not supplied\n");
            err = -EFAULT;
            break;
        }
        gpio_set_value(17,0);

        break;

    case GPIO_TEST_WRITE_STRUCT:
        printk("GPIO_TEST_WRITE\n");
        if (copy_from_user(gpio_priv, argp, sizeof(struct gpio_priv_t)))
            return -EFAULT;
        printk("gpio_priv->state0=%d\n",gpio_priv->state0);
        printk("gpio_priv->state1=%d\n",gpio_priv->state1);
        printk("gpio_priv->state2=%d\n",gpio_priv->state2);

        break;

    case GPIO_TEST_READ_STRUCT:
        printk("GPIO_TEST_READ\n");
        gpio_priv->state0=1;
        gpio_priv->state1=2;
        gpio_priv->state2=3;
        if (copy_to_user(argp, gpio_priv, sizeof(struct gpio_priv_t)))
            return -EFAULT;

        break;
        
    case GPIO_TEST_WRITE_INT:
        printk("GPIO_TEST_WRITE_INT\n");
        if(copy_from_user(&value0,argp,sizeof(int)))
            return -EFAULT;
        printk("value0 = %d\n",value0);
        break;

    case GPIO_TEST_READ_INT:
        printk("GPIO_TEST_READ_INT\n");
        value1=101;
        if (copy_to_user(argp, &value1, sizeof(int)))
            return -EFAULT;
        break;
        
    default:
        pr_err("Invalid ioctl command.\n");
        return -ENOTTY;
    }

    return err;
}

static const struct file_operations gpio_test_fops = {
    .owner = THIS_MODULE,
    .unlocked_ioctl = gpio_test_ioctl,
    .open = gpio_test_open,
    .release = gpio_test_release
};

static struct miscdevice gpio_test_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "gpio_test",
    .fops = &gpio_test_fops
};


static int gpio_test_probe(struct platform_device *pdev)
{
    int ret = 0;

    printk("gpio_test_probe 0\n");
    
    /* Initialize */
    gpio_priv = kzalloc(sizeof(struct gpio_priv_t), GFP_KERNEL);

    if (gpio_priv == NULL) {
        pr_alert("Not enough memory to initialize device\n");
        return -ENOMEM;
    }

    ret = misc_register(&gpio_test_dev);
    
    if (ret < 0)
        goto err;
    return 0;

err:
    printk("gpio_test register failed\n");
    

    kfree(gpio_priv);
    gpio_priv = NULL;

    return ret;

}

static int __devexit gpio_test_remove(struct platform_device *plat)
{

    kfree(gpio_priv);
    gpio_priv = NULL;

    misc_deregister(&gpio_test_dev);
    printk("gpio_test remove\n");
    return 0;
}

static struct platform_driver gpio_test_driver = {
    .probe = gpio_test_probe,
    .remove = gpio_test_remove,
    .driver = {
        .name = "gpio_test",
        .owner = THIS_MODULE,
    },
};

static int __init gpio_test_init(void)
    
{
    printk("