精华内容
下载资源
问答
  • 套接字缓冲区

    2015-04-05 16:29:33
    12.4.2 套接字缓冲区操作基本原理 在传输过程中,存在着多个套接字缓冲区,这些缓冲区组成一个链表,每个链表都有一个链表头sk_buff_head ,链表中每个节点分别对应内存中一块的数据区。因此对它的操作有两种基本...

    12.4.2 套接字缓冲区操作基本原理

    在传输过程中,存在着多个套接字缓冲区,这些缓冲区组成一个链表,每个链表都有一个链表头sk_buff_head ,链表中每个节点分别对应内存中一块的数据区。因此对它的操作有两种基本方式:第一种是对缓冲区链表进行操作;第二种是对缓冲区对应的数据区进行控制。

    当我们向物理接口发送数据时或当我们从物理接口接收数据时,我们就利用链表操作;当我们要对数据区的内容进行处理时,我们就利用内存操作例程。这种操作机制对网络传输是非常有效的。

    前面我们讲过,每个协议都要在发送数据时向缓冲区添加自己的协议头和协议尾,而在接收数据时去掉协议头和协议尾,那么具体的操作是怎样进行的呢?我们先看看对缓冲区操作的两个基本的函数:

    void append_frame(char *buf, int len){

        struct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);     /*创建一个缓冲区*/

       if(skb==NULL)

                  my_dropped++;   

       else    {             

                      kb_put(skb,len);

                      memcpy(skb->data,data,len);      /*向缓冲区添加数据*/                            

                     skb_append(&my_list, skb);  /*将该缓冲区加入缓冲区队列*/                  

                  }

      }

    void process_frame(void){

        struct sk_buff *skb;   

        while((skb=skb_dequeue(&my_list))!=NULL) 

         {

    process_data(skb);                                              /*将缓冲区的数据传递给协议层*/

    kfree_skb(skb, FREE_READ);                                 /*释放缓冲区,缓冲区从此消失*/

         }

     }

     

    这两个非常简单的程序片段,虽然它们不是源程序,但是它们恰当地描述了处理数据包的工作原理,append_frame( )描述了分配缓冲区。创建数据包过程process_frame( )描述了传递数据包,释放缓冲区的的过程。关于它们的源程序,可以去参见 net/core/dev.c  中netif_rx( )函数和net_bh( )函数。你可以看出它们和上面我们提到的两个函数非常相似。这两个函数非常复杂,因为他们必须保证数据能够被正确的协议接收并且要负责流程的控制,但是他们最基本的操作是相同的。

     

    让我们再看看上面提到的函数--append_frame( )。当 alloc_skb( ) 函数获得一个长度为 len字节的缓冲区(如图12.12 (a))后,该缓冲区包含以下内容:

    ◆缓冲区的头部有零字节的头部空间

    ◆零字节的数据空间

    ◆缓冲区的尾部有零字节的尾部空间

    再看skb_put( )函数(如图12.12 (d)),它的作用是从数据区的尾部向缓冲区尾部不断扩大数据区大小,为后面的memcpy( )函数分配空间。

     

    当一个缓冲区创建以后,所有的可用空间都在缓冲区的尾部。在没有向其中添加数据之前,首先被执行的函数调用是 skb_receive( )(如图12.12  (b)),它使你在缓冲区头部指定一定的空闲空间,因此许多发送数据的例程都是这样开头的:

    skb=alloc_skb(len+headspace, GFP_KERNEL);

     

    skb_reserve(skb, headspace);

    skb_put(skb,len);   

    memcpy_fromfs(skb->data,data,len);

    pass_to_m_protocol(skb);

     

    图12.12向我们展示了以上过程进行时,sk_buff 的变化情况:


    图12.12 sk_buff 的变化过程

     

    展开全文
  • 套接字缓冲区相关

    2016-10-02 20:44:00
    套接字缓冲区相关 书里面讲了三种方式(TCP,UDP,SCTP)的发送相关,但是原理基本是相同的,只是根据不同协议的特点有些变化.下面 以TCP为例,试着描述一下这个过程. TCP缓冲区 每一个TCP套接字都有一个发送缓冲区,这个...

    套接字缓冲区相关

    书里面讲了三种方式(TCP,UDP,SCTP)的发送相关,但是原理基本是相同的,只是根据不同协议的特点有些变化.下面
    以TCP为例,试着描述一下这个过程.

    TCP缓冲区

    每一个TCP套接字都有一个发送缓冲区,这个缓冲区是在内核中的.当我们调用write将数据写入套接字的时候,数据被传入
    内核,放入套接字发送缓冲区(大小可以由SO_SNDBUF来设定).如果缓冲区已满,那么write函数将被阻塞,进程被投入睡眠状态.
    直到数据全部被传入内核的套接字缓冲区中.需要注意的是,当write返回的时候并不代表对端已经收到了这些数据,只是说明这些
    数据被写到了内核中的缓冲区里面.
    当数据到达内核中以后,内核中的TCP程序会对其进行一次加工,将数据以MSS(maximum segment size)大小分块,并给每个数据块
    安上一个TCP首部,随后发给IP程序.
    IP程序可能会对数据进行进一步的分片,取决于MSS的大小.有的系统在实现中使用了路径MTU发现机制,会尽量减少分片的情况.通用的
    做法就是给数据包加上IP头,按照其目的IP地址查找路由表确定网络接口,然后传递给数据链路层.
    数据链路层中会维护一个队列,如果队列已满,则会沿协议栈返回一个错误,最终由TCP捕获这个错误,并重传该数据.
    TCP缓冲区一个很重要的问题就是何时从套接字缓冲区中将已发送的数据丢弃.我们知道TCP是一个可靠的传输协议,所以TCP实现了关于确认数据
    到达的相关机制,即当对端确认数据到达的ack返回时,则认定我们发送的数据已经被对方接受.此时内核中的套接字缓冲区才会将数据删除.在确认的
    ack到达之前,内核的套接字缓冲区中会为数据维护一个副本,防止数据由于损坏或者丢失造成重传的时候内核已经将其删除了.

    UDP缓冲区

    UDP套接字的缓冲机制就不在详述,因为UDP是一个不可靠协议,所以它并不会维护一个真正的套接字缓冲区,而是直接沿协议栈向下传递,被复制到某种
    格式的内核缓冲区当中.但是如果UDP打算传送一个大于"缓冲区大小"(即SO_SNDBUF的大小)的数据报时,则会返回一个EMSGSIZE的错误.它经过内核中
    的UDP和IP程序,并被发送到数据链路层的缓冲队列当中,如果队列已满则返回一个ENOBUFS的错误(有的系统并不会返回错误).可以看到,UDP并不会为
    用户程序维护一个状态.

    转载于:https://www.cnblogs.com/xinglong/p/5928068.html

    展开全文
  • 套接字缓冲区函数 函数名 功能 函数形成 参数 描述 skb_queue_empty 检查队列是否为空 int skb_queue_empty (struct sk_buff_head * list) list为队列头 如果队列为空返回真,否则...

     

    套接字缓冲区函数

    函数名

    功能

    函数形成

    参数

    描述

    skb_queue_empty

    检查队列是否为空

    int skb_queue_empty (struct sk_buff_head * list)

    list为队列头

    如果队列为空返回真,否则返回假

    skb_get

    引用缓冲区

    struct sk_buff * skb_get (struct sk_buff * skb)

    skb为要引用的缓冲区

    对套接字缓冲区再引用一次,返回指向缓冲区的指针

    kfree_skb

    释放一个sk_buff

    void kfree_skb (struct sk_buff * skb)

    sk为要释放的缓冲区

    删除对一个缓冲区的引用,如果其引用计数变为0,则释放它

    skb_cloned

    缓冲区是否是克隆的

    int skb_cloned (struct sk_buff * skb)

    skb为要检查的缓冲区

    如果以skb_clone标志来产生缓冲区,并且是缓冲区多个共享拷贝中的一个,则返回真。克隆的缓冲区具有共享数据,因此在正常情况下不必对其进行写。

     

    skb_shared

    缓冲区是否是共享的

    int skb_shared (struct sk_buff * skb)

    skb为要检查的缓冲区

    如果有多于一个的人引用这个缓冲区就返回真。

    skb_share_check

    检查缓冲区是否共享的,如果是就克隆它

    struct sk_buff * skb_share_check (struct sk_buff * skb, int pri)

    skb为要检查的缓冲区,pri为内存分配的优先级

    如果缓冲区是共享的,就克隆这个缓冲区,并把原来缓冲区的引用计数减1,返回新克隆的缓冲区。如果不是共享的,则返回原来的缓冲区。当从中断状态或全局锁调用该函数时,pri必须是GFP_ATOMIC。

     内存分配失败则返回NULL。

    skb_unshare

    产生一个共享缓冲区的拷贝

    struct sk_buff * skb_unshare (struct sk_buff * skb, int pri);

    skb为要检查的缓冲区,pri为内存分配的优先级

    如果套接字缓冲区是克隆的,那么这个函数就创建一个新的数据拷贝,并把原来缓冲区的引用计数减1,返回引用计数为1的新拷贝。如果不是克隆的,就返回原缓冲区。当从中断状态或全局锁调用该函数时,pri必须是GFP_ATOMIC。

     内存分配失败则返回NULL。

    skb_queue_len

    获得队列的长度

    __u32 skb_queue_len (struct sk_buff_head * list_)

    list_为测量的链表

     

    返回&sk_buff 队列的指针。

    __skb_queue_head

    在链表首部对一个缓冲区排队

    void __skb_queue_head (struct sk_buff_head * list, struct sk_buff * newsk)

    list为要使用的链表,

    newsk为要排队的缓冲区。

    在链表首部对一个缓冲区进行排队。这个函数没有锁,因此在调用它之前必须持有必要的锁。一个缓冲区不能同时放在两个链表中。

    skb_queue_head

    在链表首部对一个缓冲区排队

    void skb_queue_head (struct sk_buff_head * list, struct sk_buff * newsk)

    list为要使用的链表,

    newsk为要排队的缓冲区。

    在链表首部对一个缓冲区进行排队。这个函持有锁,因此可以安全地使用。一个缓冲区不能同时放在两个链表中。

    __skb_queue_tail

    在链表尾部对一个缓冲区排队

    void __skb_queue_tail (struct sk_buff_head * list, struct sk_buff * newsk)

    list为要使用的链表,

    newsk为要排队的缓冲区。

    在链表尾部对一个缓冲区进行排队。这个函数没有锁,因此在调用它之前必须持有必要的锁。一个缓冲区不能同时放在两个链表中。

    skb_queue_tail

    在链表尾部对一个缓冲区排队

    void skb_queue_tail (struct sk_buff_head * list, struct sk_buff * newsk)

    list为要使用的链表,

    newsk为要排队的缓冲区。

    在链表尾部对一个缓冲区进行排队。这个函持有锁,因此可以安全地使用。一个缓冲区不能同时放在两个链表中。

    __skb_dequeue

    从队列的首部删除一个缓冲区

    struct sk_buff * __skb_dequeue (struct sk_buff_head * list)

    list为要操作的队列

    删除链表首部。这个函数不持有任何锁,因此使用时应当持有适当的锁。如果队链表为空则返回NULL,成功则返回首部元素。

    skb_dequeue

    从队列的首部删除一个缓冲区

    struct sk_buff * skb_dequeue (struct sk_buff_head * list)

    list为要操作的队列

    删除链表首部,这个函数持有锁,因此可以安全地使用。如果队链表为空则返回NULL,成功则返回首部元素。

    skb_insert

    插入一个缓冲区

    void skb_insert (struct sk_buff * old, struct sk_buff * newsk)

    old为插入之前的缓冲区,newsk为要插入的缓冲区

    把一个数据包放在链表中给定的包之前。该函数持有链表锁,并且是原子操作。一个缓冲区不能同时放在两个链表中。

    skb_append

    追加一个缓冲区

    void skb_append (struct sk_buff * old, struct sk_buff * newsk)

    old为插入之前的缓冲区,newsk为要插入的缓冲区

    把一个数据包放在链表中给定的包之前。该函数持有链表锁,并且是原子操作。一个缓冲区不能同时放在两个链表中。

    skb_unlink

    从链表删除一个缓冲区

    void skb_unlink (struct sk_buff * skb);

    Skb为要删除的缓冲区

    把一个数据包放在链表中给定的包之前。该函数持有链表锁,并且是原子操作。

     

    _skb_dequeue_tail

    从队尾删除

    struct sk_buff * __skb_dequeue_tail (struct sk_buff_head * list)

    List为要操作的链表

    从链表尾部删除。这个函数不持有任何锁,因此必须持以合适的锁来使用。如果链表为空,则返回NULL,成功则返首部元素。

    skb_dequeue_tail

    从队头删除

    struct sk_buff * skb_dequeue_tail (struct sk_buff_head * list)

    List为要操作的链表

    删除链表尾部,这个函数持有锁,因此可以安全地使用。如果队链表为空则返回NULL,成功则返回首部元素。

    skb_put

    把数据加到缓冲区

    unsigned char * skb_put (struct sk_buff * skb, unsigned int len)

    skb为要使用的缓冲区,len为要增加的数据长度

    这个函数扩充缓冲区所使用的数据区。如果扩充后超过缓冲区总长度,内核会产生警告。函数返回的指针指向所扩充数据的第一个字节。

    skb_push

    把数据加到缓冲区的开始

    unsigned char * skb_push (struct sk_buff * skb, unsigned int len);

    skb为要使用的缓冲区,len为要增加的数据长度

    这个函数扩充在缓冲区的开始处缓冲区所使用的数据区。如果扩充后超过缓冲区首部空间的总长度,内核会产生警告。函数返回的指针指向所扩充数据的第一个字节。

    skb_pull

    从缓冲区的开始删除数据

    unsigned char * skb_pull (struct sk_buff * skb, unsigned int len)

    skb为要使用的缓冲区,len为要删除的数据长度

    这个函数从链表开始处删除数据,把腾出的内存归还给首部空间。把指向下一个缓冲区的指针返回。

    skb_headroom

    缓冲区首部空闲空间的字节数

    int skb_headroom (const struct sk_buff * skb)

     

    skb为要检查的缓冲区

    返回&sk_buff首部空闲空间的字节数

    skb_tailroom

    缓冲区尾部的空闲字节数

    int skb_tailroom (const struct sk_buff * skb)

    skb为要检查的缓冲区

    返回&sk_buff尾部空闲空间的字节数

    skb_reserve

    调整头部的空间

    void skb_reserve (struct sk_buff * skb, unsigned int len)

    skb为要改变的缓冲区,len为要删除的字节数

    通过减少尾部空间,增加一个空&sk_buff的首部空间。这仅仅适用于空缓冲区。

     

    skb_trim

    从缓冲区删除尾部

    void skb_trim (struct sk_buff * skb, unsigned int len);

    skb为要改变的缓冲区,len为新的长度

    通过从尾部删除数据,剪切缓冲区的长度。如果缓冲区已经处于指定的长度,则不用改变。

    skb_orphan

    使一个缓冲区成为孤儿

    void skb_orphan (struct sk_buff * skb);

    skb是要成为孤儿的缓冲区

    如果一个缓冲区当前有一个拥有者,我们就调用拥有者的析构函数,使skb没有拥有者。该缓冲区继续存在,但以前的拥有者不再对其“负责”。

    skb_queue_purge

    使一个链表空

    void skb_queue_purge (struct sk_buff_head * list)

    list为要腾空的链表

    删除在&sk_buff链表上的所有缓冲区。这个函数持有链表锁,并且是原子的。

    __skb_queue_purge

    使一个链表空

    void __skb_queue_purge (struct sk_buff_head * list);

    list为要腾空的链表

    删除在&sk_buff链表上的所有缓冲区。这个函数不持有链表锁,调用者必须持有相关的锁来使用它。

    dev_alloc_skb

    为发送分配一个skbuff

    struct sk_buff * dev_alloc_skb (unsigned int length)

    Length为要分配的长度

    分配一个新的&sk_buff,并赋予它一个引用计数。这个缓冲区有未确定的头空间。用户应该分配自己需要的头空间。

      如果没有空闲内存,则返回NULL。尽管这个函数是分配内存,但也可以从中断来调用。

    skb_cow

    当需要时拷贝skb的首部

    struct sk_buff * skb_cow (struct sk_buff * skb, unsigned int headroom)

    Skb为要拷贝的缓冲区,headroom为需要的头空间

    如果传递过来的缓冲区缺乏足够的头空间或是克隆的,则该缓冲区被拷贝,并且附加的头空间变为可用。如果没有空闲的内存,则返回空。如果缓冲区拷贝成功,则返回新的缓冲区,否则返回已存在的缓冲区。

    skb_over_panic

    私有函数

    void skb_over_panic (struct sk_buff * skb, int sz, void * here)

    skb为缓冲区,sz为大小,here为地址。

    用户不可调用。

    skb_under_panic

    私有函数

    void skb_under_panic (struct sk_buff * skb, int sz, void * here)

    skb为缓冲区,sz为大小,here为地址。

    用户不可调用。

    alloc_skb

    分配一个网络缓冲区

    struct sk_buff * alloc_skb (unsigned int size, int gfp_mask)

    size为要分配的大小,gfp_mask为分配掩码

    分配一个新的&sk_buff。返回的缓冲区没有size大小的头空间和尾空间。新缓冲区的引用计数为1。返回值为一缓冲区,如果失败则返回空。从中断分配缓冲区,掩码只能使用GFP_ATOMIC的gfp_mask。

    __kfree_skb

    私有函数

    void __kfree_skb (struct sk_buff * skb)

    skb为缓冲区

    释放一个sk_buff。释放与该缓冲区相关的所有事情,清除状态。这是一个内部使用的函数,用户应当调用kfree_skb。

    skb_clone

    复制一个sk_buff

    struct sk_buff * skb_clone (struct sk_buff * skb, int gfp_mask)

    skb为要克隆的缓冲区,gfp_mask为分配掩码。

    复制一个&sk_buff。新缓冲区不是由套接字拥有。两个拷贝共享相同的数据包而不是结构。新缓冲区的引用计数为1。如果分配失败,函数返回NULL,否则返回新的缓冲区。如果从中断调用这个函数,掩码只能使用GFP_ATOMIC的gfp_mask。

    skb_copy

    创建一个sk_buff的私有拷贝

    struct sk_buff * skb_copy (const struct sk_buff * skb, int gfp_mask)

    skb为要拷贝的缓冲区,gfp_mask为分配优先级。

    既拷贝&sk_buff也拷贝其数据。该函数用在调用者希望修改数据并需要数据的私有拷贝来进行改变时。失败返回NULL,成功返回指向缓冲区的指针。

    返回的缓冲区其引用计数为1。如果从中断调用,则必须传递的优先级为GFP_ATOMIC。

    skb_copy_expand

    拷贝并扩展sk_buff

    struct sk_buff * skb_copy_expand (const struct sk_buff * skb, int

    newheadroom, int newtailroom, int gfp_mask);

    skb为要拷贝的缓冲区,newheadroom为头部的新空闲字节数,newtailroom为尾部的新空闲字节数。

    既拷贝&sk_buff也拷贝其数据,同时分配额外的空间。当调用者希望修改数据并需要对私有数据进行改变,以及给新的域更多的空间时调用该函数。失败返回NULL,成功返回指向缓冲区的指针。

    返回的缓冲区其引用计数为1。如果从中断调用,则必须传递的优先级为GFP_ATOMIC。

     

     

    转载于:https://www.cnblogs.com/jinrize/archive/2009/11/29/1612877.html

    展开全文
  • 前面一篇文章分析了套接字缓冲区sk_buff的创建过程,但一般来讲,一个套接字缓冲区总是属于一个套接字,所以,除了调用sk_buff本身的alloc_skb函数创建一个套接字缓冲区,套接字本身还要对sk_buff进行一些操作,以及...
    前面一篇文章分析了套接字缓冲区sk_buff的创建过程,但一般来讲,一个套接字缓冲区总是属于一个套接字,所以,除了调用sk_buff本身的alloc_skb函数创建一个套接字缓冲区,套接字本身还要对sk_buff进行一些操作,以及设置自身的一些成员值。下面我们来分析这个过程。
        如果检查到待发送数据报没有传输层协议头(不是传输层的tcp或udp数据报),套接字创建缓冲区的函数是sock_alloc_send_skb,它的函数原型是:
        struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
                int noblock, int *errcode)
        它直接调用函数:
        static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
                unsigned long header_len,
                unsigned long data_len,
                int noblock, int *errcode)
        参数sk是要创建缓冲区的那个套接字,header_len是sk_buff中,成员data指向的那块数据区的长度,而data_len则是指除那块数据区以外的被分片的数据的总长。noblock指示是否阻塞模式。对于非传输层协议包,不使用分散/聚集IO,所以,置data_len为0。
        网络层代表一个套接字的结构体struct sock有两个成员sk_wmem_alloc和sk_sndbuf,sk_wmem_alloc表示在这个套接字上已经分配的写缓冲区(发送缓冲区)的总长,每次分配完一个属于它的写sk_buff,这个值总是加上sk_buff->truesize。而sk_sndbuf则是这个socket所允许的最大发送缓冲区。它的值在系统初始化的时候设为变量sysctl_wmem_max的值,可以通过系统调用进行修改。其缺省值sysctl_wmem_max为107520字节,因为它的计算长度还包括了struct sk_buff,所以,一般认为其缺省值是64K数据。
        而对于传输层协议包,我们使用sock_wmalloc创建套接字缓冲区,这是一个更为简单的创建函数,没有超时、出错判断机制,直接通过调用alloc_skb创建一个sk_buff并返回。但对于传输层协议有一个不同点就是sk_wmem_alloc最大可以达到两倍sk_sndbuf,即缺省的发送缓冲区可以达到128K。
        到这里,我们就不难理解struct sk_buff中另外两个成员的含义了:
        len是指数据包全部数据的长度,包括data指向的数据和end后面的分片的数据的总长,而data_len只包括分片的数据的长度。而truesize的最终值是len+sizeof(struct sk_buff)。
    展开全文
  • 深度探索套接字缓冲区

    千次阅读 2014-11-14 12:45:28
    套接字缓冲区用结构体struct sk_buff表示,它用于在网络子系统中的各层之间传递数据,处于一个核心地位,非常之重要。它包含了一组成员数据用于承载网络数据,同时,也定义了在这些数据上操作的一组函数。下面是其...
  • 由前两篇博客知道,通过SO_SNDBUF与SO_RCVBUF可以设置TCP套接字的发送缓冲区和接收缓冲区的大小。当设置TCP套接字接收缓冲区的大小时,函数调用的顺序很重要。这是因为TCP的窗口规模选项是在建立连接时用SYN分节与对...
  • 当从一个套接字读写内容时,你需要一个缓冲区,用来保存读取和写入的数据。缓冲区内存的有效时间必须比I/O操作的时间要长;你需要保证它们在I/O操作结束之前不被释放。 对于同步操作来说,这很容易;当然,这个缓冲...
  • 有时候我们需要控制套接字的行为(如修改缓冲区的大小),这个时候我们就要学习套接字选项。 int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t *optlen) int setsockopt(int sockfd,int ...
  • 套接字缓冲区用结构体struct sk_buff表示,它用于在网络子系统中的各层之间传递数据,处于一个核心地位,非常之重要。它包含了一组成员数据用于承载网络数据,同时,也定义了在这些数据上操作的一组函数。下面是其...
  • 该应用进程将被投入睡眠,这里假设该套接字是阻塞的,它是通常的默认设置,内核将不从write系统调用返回,直到应用进程缓冲区中的所有数据都复制到套接字发送缓冲区。因此,从写一个TCP套接字的write调用成功返回...
  • 在传输过程中,存在着多个套接字缓冲区,这些缓冲区组成一个链表,每个链表都有一个链表头sk_buff_head ,链表中每个节点分别对应内存中一块的数据区。因此对它的操作有两种基本方式:第一种是对缓冲区链表进行操作...
  • Linux网络协议栈之套接字缓冲区

    万次阅读 2012-06-05 17:21:25
    首先,我们看看贯穿网络协议栈各层的一个最关键数据结构——套接字缓冲区(sk_buff结构)。  一个封包就存储在这个数据结构中。所有网络分层都会使用这个结构来存储其报头、有关数据的信息,以及用来协调工作的...
  • 首先,我们看看贯穿网络协议栈各层的一个最关键数据结构——套接字缓冲区(sk_buff结构)。  一个封包就存储在这个数据结构中。所有网络分层都会使用这个结构来存储其报头、有关数据的信息,以及用来协调工作的...
  • 该应用进程将被投入睡眠,这里假设该套接字是阻塞的,它是通常的默认设置,内核将不从write系统调用返回,直到应用进程缓冲区中的所有数据都复制到套接字发送缓冲区。因此,从写一个TCP套接字的write调用成功返回...
  • 当设置TCP套接字缓冲区大小时,函数的调用顺序很重要。因为TCP的窗口规模选项是在建立连接时用SYN分节与对端互换得到的。 对于客户端,这意味着缓冲区选项必须在调用connect之前设置。对于服务端,这意味着该选项...
  • 深度探索套接字缓冲区 sk_buff skb

    千次阅读 2011-11-17 13:43:16
     套接字缓冲区用结构体struct sk_buff表示,它用于在网络子系统中的各层之间传递数据,处于一个核心地位,非常之重要。它包含了一组成员数据用于承载网络数据,同时,也定义了在这些数据上操作的一组函数。下面是其...
  • 该应用进程将被投入睡眠,这里假设该套接字是阻塞的,它是通常的默认设置,内核将不从write系统调用返回,直到应用进程缓冲区中的所有数据都复制到套接字发送缓冲区。因此,从写一个TCP套接字的write调用成功返回...
  • 内核源码学习:套接字缓冲区提供的函数2008-09-18 18:21 1.操纵sk_buff链表的函数  sk_buff链表是一个双向链表,它包括一个链表头而且每一个缓冲区都有一个prev和next指针,指向链表中前一个和后一个...
  • 该应用进程将被投入睡眠,这里假设该套接字是阻塞的,它是通常的默认设置,内核将不从write系统调用返回,直到应用进程缓冲区中的所有数据都复制到套接字发送缓冲区。因此,从写一个TCP套接字的write调用成功返回...
  • <p>I'm writing a udp client and set udp socket send buffer by SetWriteBuffer.... ... err =conn.SetWriteBuffer(64*1024*1024) </code></pre> ...<p>as above, how can I test set the value is effective or get ...
  • 套接字缓冲区的大小

    2014-03-28 13:22:30
    SO_RCVBUF:接受缓冲区大小 SO_SNDBUF: 发送缓冲区大小 操作程序举例: socklen_t optlen; optlen = sizeof(int); /*get SO_RCVBUF*/ int rcvbuflen; if(0 != getsockopt(listenfd,SOL_SOCKET,SO_RCVBUF,&...
  • 关于套接字缓冲区

    2012-12-21 09:29:01
    我们知道,对每个套接字,系统都会分配一个发送缓冲区和接收缓冲区, 而且这个缓冲区的长度我们可以设置。 我的问题是,我如何知道: 1)在不调用 recv 的情况下, 当前接收缓冲区中,有多少数据. 2)...
  • 问题:???? 1.在Unix或Linux中,每一个套接字都对应有一个套接字缓冲区,那么,我们应该如何看待这个套接字缓冲区????? 其作用是什么??? 原理是什么????
  • Qt套接字缓冲区数据如何清空?

    千次阅读 2017-10-06 14:50:44
    //我的是因为缓冲区不够,可以用这一句申请内存。 receiver->setSocketOption( QAbstractSocket::ReceiveBufferSizeSocketOption, 1024*1024*100 ); //给套接字申请一个100M的内存空间

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,860
精华内容 744
关键字:

套接字缓冲区