使用ksocket导致内存泄漏

我编写了一个简单的内核模块，其中包括以下ksocket连接接受代码：

.....(some ksocket initiation)

while( on_service )
{
    sockfd_c = kaccept(sockfd_s, (struct sockaddr *)&addr_cli, &addr_len);
    kclose(sockfd_c);
}

并编写一个简单的客户端连接到此套接字服务器。 在控制台中，我发现当我持续运行客户机连接时，通过“free”命令，内存使用量正在增加

kaccept（）和kclose（）的函数如下所示

int kclose(ksocket_t sockfd)                                                                                                                                                                                     
{
    struct socket *sk;
    int ret;

    sk = (struct socket *)sockfd;
    ret = sk->ops->release(sk);

    if (sk)
    {   
        sock_release(sk);
    }   

    return ret;
}

ksocket_t kaccept(ksocket_t socket, struct sockaddr *address, int *address_len)
{
    struct socket *sk;
    struct socket *new_sk = NULL;
    int ret;

    sk = (struct socket *)socket;

    sxg_debug("family = %d, type = %d, protocol = %d\n",
                sk->sk->sk_family, sk->type, sk->sk->sk_protocol);
    //new_sk = sock_alloc();
    //sock_alloc() is not exported, so i use sock_create() instead
    ret = sock_create(sk->sk->sk_family, sk->type, sk->sk->sk_protocol, &new_sk);
    if (ret < 0)
        return NULL;
    if (!new_sk)
        return NULL;

    new_sk->type = sk->type;
    new_sk->ops = sk->ops;

    ret = sk->ops->accept(sk, new_sk, 0 /*sk->file->f_flags*/);
    if (ret < 0)
        goto error_kaccept;

    if (address)
    {
        ret = new_sk->ops->getname(new_sk, address, address_len, 2);
        if (ret < 0)
            goto error_kaccept;
    }

    return new_sk;

error_kaccept:
    sock_release(new_sk);
    return NULL;
}

int-kclose（ksocket\t sockfd）
{
结构套接字*sk；
int ret；
sk=（结构套接字*）sockfd；
ret=sk->ops->release（sk）；
如果（sk）
{   
袜子释放（sk）；
}   
返回ret；
}
ksocket\u t kaccept（ksocket\u t socket，结构sockaddr*地址，int*地址）
{
结构套接字*sk；
结构套接字*new_sk=NULL；
int ret；
sk=（结构套接字*）套接字；
sxg_调试（“系列=%d，类型=%d，协议=%d\n”，
sk->sk->sk\u系列，sk->type，sk->sk->sk\u协议）；
//new_sk=sock_alloc（）；
//sock_alloc（）未导出，因此我使用sock_create（）代替
ret=sock\u create（sk->sk->sk\u系列，sk->type，sk->sk->sk\u协议和新sk）；
如果（ret<0）
返回NULL；
如果（！新建）
返回NULL；
新建sk->type=sk->type；
新建sk->ops=sk->ops；
ret=sk->ops->accept（sk，new_-sk，0/*sk->file->f_-flags*/）；
如果（ret<0）
转到错误_kaaccept；
如果（地址）
{
ret=new-sk->ops->getname（new-sk，address，address-len，2）；
如果（ret<0）
转到错误_kaaccept；
}
返回新任务；
错误接受：
袜子发布（新的）；
返回NULL；
}

---

有人知道内存泄漏的原因/方式吗？

使用

valgrind

查找内存泄漏

作为

---

我的内核版本是3.2，我正在尝试编写一个内核套接字服务器。 经过几天的战斗，我有以下发现

我使用用户sock_create（）创建一个套接字服务器，然后通过侦听和接受连接

sockfd_srv = sock_create(...)
...
while(1) {
    sockfd_srv->ops->listen();
    sockfd_cli = sock_create(...);
    sockfd_srv->ops->accept(..., &sockfd_cli);
    ....(do something)
    sock_release(sockfd_cli);
}

即使我通过sock_release（）释放客户端套接字，上述程序也会导致内存泄漏。最后，系统将内存不足

我将其更改为使用sock\u create\u lite（）而不是sock\u create（）

---

然后内存泄漏问题就消失了。

我必须纠正我的问题。最初，我认为这是内存泄漏问题。但我有以下发现。我的任务是在内核空间中创建一个套接字服务器。每次我的程序接受传入的连接（没有任何数据传输）然后关闭它时，我发现它会消耗一些内存（通过“free”命令观察）。即使我通过sock_release（）关闭套接字连接，内存使用量也不会减少。最后，系统打印“内存不足”，然后崩溃。我已经将tcp_tw_recycle和tcp_tw_reuse设置为1，以减少时间等待状态下的tcp等待时间。Linux内核版本为3.2.0。谢谢。但现在我发现这似乎是Linux内核的错误。

sockfd_srv = sock_create(...)
...
while(1) {
    sockfd_srv->ops->listen();
    sockfd_cli = sock_create(...);
    sockfd_srv->ops->accept(..., &sockfd_cli);
    ....(do something)
    sock_release(sockfd_cli);
}

sockfd_srv = sock_create(...)
...
while(1) {
    sockfd_srv->ops->listen();
    sockfd_cli = sock_create_lite(...);
    sockfd_srv->ops->accept(..., &sockfd_cli);
    ....(do something)
    sock_release(sockfd_cli);
}