/*
 *  Copyright (C) 2004 Trog <trog@clamav.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 */

#ifndef __THRMGR_H__
#define __THRMGR_H__

#include <pthread.h>

#ifndef C_WINDOWS
#include <sys/time.h>
#endif

typedef struct work_item_tag {
    struct work_item_tag *next;
    void *data;
    struct timeval time_queued;//
} work_item_t;
    
typedef struct work_queue_tag {
    work_item_t *head;
    work_item_t *tail;
    int item_count;
} work_queue_t;

typedef enum {
    POOL_INVALID,
    POOL_VALID,
    POOL_EXIT
} pool_state_t;

typedef struct threadpool_tag {
    pthread_mutex_t pool_mutex;//mutex锁，用于限制同时只有一个线程对公共资源（条件变量，线程池内部变量）访问修改
    pthread_cond_t pool_cond;//条件变量，用于多线程间等待任务，有任务的信号控制
    pthread_attr_t pool_attr;//线程的属性，主要为了设置分离线程属性，即线程循环退出自动结束线程，释放资源，不用调用函数去释放资源
    //具体可参考https://www.cnblogs.com/lidabo/p/5514222.html对属性的解释
    pool_state_t state;//线程池的状态
    int thr_max;//线程池最大线程数量
    int thr_alive;//活着的线程数量，包括正在执行任务的线程和空闲等待线程
    int thr_idle;//空闲等待的线程。
    int idle_timeout;//线程等待超时时间，超时结束后，将结束本线程
    
    void (*handler)(void *);//任务操作函数，有用户传入函数指针
    
    work_queue_t *queue;//任务队列，以单向链表的方式存储任务
} threadpool_t;
/*
功能：新建线程池
参数：
int max_threads, 最大线程数
int idle_timeout,超时时间
void (*handler)(void *)函数操作句柄
*/
threadpool_t *thrmgr_new(int max_threads, int idle_timeout, void (*handler)(void *));
/*
功能：销毁线程池
参数：
threadpool_t *threadpool线程池指针
*/
void thrmgr_destroy(threadpool_t *threadpool);
/*
功能：给线程池下发任务
参数：
threadpool_t *threadpool线程池指针
void *user_data  用户要处理的数据
*/
int thrmgr_dispatch(threadpool_t *threadpool, void *user_data);

#endif

/*
 *  Copyright (C) 2004 Trog <trog@clamav.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 */

#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <errno.h>

#include "shared/output.h"

#include "thrmgr.h"
#include "others.h"

#define FALSE (0)
#define TRUE (1)
/*新建任务队列，初始化队列参数*/
static work_queue_t *work_queue_new(void)
{
    work_queue_t *work_q;
    
    work_q = (work_queue_t *) malloc(sizeof(work_queue_t));
    if (!work_q) {
        return NULL;
    }
    
    work_q->head = work_q->tail = NULL;
    work_q->item_count = 0;
    return work_q;
}
/*向任务队列中加入任务*/
static int work_queue_add(work_queue_t *work_q, void *data)
{
    work_item_t *work_item;
    
    if (!work_q) {
        return FALSE;
    }
    //申请任务内存
    work_item = (work_item_t *) malloc(sizeof(work_item_t));
    if (!work_item) {
        return FALSE;
    }
    //next指针设为空，将用户数据赋值给任务
    work_item->next = NULL;
    work_item->data = data;
    //设置任务接收时间，好像没有什么用
    gettimeofday(&(work_item->time_queued), NULL);
    //第一次插入任务首尾指针都为空，所以同时指向这个任务
    if (work_q->head == NULL) {
        work_q->head = work_q->tail = work_item;
        work_q->item_count = 1;
    } else {//以后插入时，将结尾next指针指向插入任务，
        //然后将位置指针指向最后插入的任务，
        //相当于将任务加入单向链表的末尾，然后在将尾指针指向最后一个
        work_q->tail->next = work_item;
        work_q->tail = work_item;
        work_q->item_count++;//任务数量加1
    }
    return TRUE;
}

static void *work_queue_pop(work_queue_t *work_q)
{
    work_item_t *work_item;
    void *data;
    //头指针为空，无数据返回
    if (!work_q || !work_q->head) {
        return NULL;
    }
    //获取链表中第一个任务
    work_item = work_q->head;
    //获取用户数据
    data = work_item->data;
    //将头指针向后移动一位
    work_q->head = work_item->next;
    //如果头指针是空，说明刚刚去除的任务已经是最后一个任务，需要把尾指针也置为空
    if (work_q->head == NULL) {
        work_q->tail = NULL;
    }
    //销毁任务框架内容，返回用户数据
    free(work_item);
    return data;
}

void thrmgr_destroy(threadpool_t *threadpool)
{
    if (!threadpool || (threadpool->state != POOL_VALID)) {
        return;
    }
    //上锁
      if (pthread_mutex_lock(&threadpool->pool_mutex) != 0) {
           logg("!Mutex lock failed\n");
            exit(-1);
    }
    //设置线程池状态为退出
    threadpool->state = POOL_EXIT;
    
    /* wait for threads to exit */
    //线程池中有活的线程,广播信号变量，让所有线程都获取到信号，自动返回结束线程
    if (threadpool->thr_alive > 0) {
        if (pthread_cond_broadcast(&(threadpool->pool_cond)) != 0) {
            pthread_mutex_unlock(&threadpool->pool_mutex);
            return;
        }
    }
    while (threadpool->thr_alive > 0) {//等待最后一个线程结束时，即thr_alive==0时，会广播一个信号，告诉所有线程都结束了
        if (pthread_cond_wait (&threadpool->pool_cond, &threadpool->pool_mutex) != 0) {
            pthread_mutex_unlock(&threadpool->pool_mutex);
            return;
        }
    }
      if (pthread_mutex_unlock(&threadpool->pool_mutex) != 0) {
            logg("!Mutex unlock failed\n");
            exit(-1);
      }
    //释放资源
    pthread_mutex_destroy(&(threadpool->pool_mutex));
    pthread_cond_destroy(&(threadpool->pool_cond));
    pthread_attr_destroy(&(threadpool->pool_attr));
    free(threadpool->queue);
    free(threadpool);
    return;
}

threadpool_t *thrmgr_new(int max_threads, int idle_timeout, void (*handler)(void *))
{
    threadpool_t *threadpool;
#if defined(C_BIGSTACK) || defined(C_BSD)
    size_t stacksize;
#endif
    
    if (max_threads <= 0) {
        return NULL;
    }
    //创建线程池对象
    threadpool = (threadpool_t *) malloc(sizeof(threadpool_t));
    if (!threadpool) {
        return NULL;
    }
    //创建任务队列
    threadpool->queue = work_queue_new();
    if (!threadpool->queue) {
        free(threadpool);
        return NULL;
    }    
    //线程池创建只是创建对象，没有启动任何线程，线程是在接收到任务才开始创建线程
    threadpool->thr_max = max_threads;
    threadpool->thr_alive = 0;
    threadpool->thr_idle = 0;
    threadpool->idle_timeout = idle_timeout;
    threadpool->handler = handler;
    //初始化锁
    pthread_mutex_init(&(threadpool->pool_mutex), NULL);
    if (pthread_cond_init(&(threadpool->pool_cond), NULL) != 0) {
        pthread_mutex_destroy(&(threadpool->pool_mutex));
        free(threadpool->queue);
        free(threadpool);
        return NULL;
    }
    //初始化线程属性对象
    if (pthread_attr_init(&(threadpool->pool_attr)) != 0) {
        pthread_cond_destroy(&(threadpool->pool_cond));
        pthread_mutex_destroy(&(threadpool->pool_mutex));
        free(threadpool->queue);
        free(threadpool);
        return NULL;
    }
    //将线程属性对象参数设置为分离的线程属性（PTHREAD_CREATE_DETACHED），即线程执行到末尾，自动回收资源，不用调用回收函数来回收
    if (pthread_attr_setdetachstate(&(threadpool->pool_attr), PTHREAD_CREATE_DETACHED) != 0) {
        pthread_attr_destroy(&(threadpool->pool_attr));
        pthread_cond_destroy(&(threadpool->pool_cond));
        pthread_mutex_destroy(&(threadpool->pool_mutex));
        free(threadpool->queue);
        free(threadpool);
        return NULL;
    }
    //设置线程堆栈大小
#if defined(C_BIGSTACK) || defined(C_BSD)
    pthread_attr_getstacksize(&(threadpool->pool_attr), &stacksize);
    stacksize = stacksize + 64 * 1024;
    if (stacksize < 1048576) stacksize = 1048576; /* at least 1MB please */
    logg("Set stacksize to %u\n", stacksize);
    pthread_attr_setstacksize(&(threadpool->pool_attr), stacksize);
#endif
    threadpool->state = POOL_VALID;
    //线程池状态设置为可用状态
    return threadpool;
}

static void *thrmgr_worker(void *arg)
{
    threadpool_t *threadpool = (threadpool_t *) arg;
    void *job_data;
    int retval, must_exit = FALSE;
    struct timespec timeout;
    
    /* loop looking for work */
    for (;;) 
    {//锁住，要修改公共变量了threadpool，如果这里锁住，pthread_cond_timedwait等待状态，后面的释放锁不执行，加入任务的函数thrmgr_dispatch中pthread_cond_signal信号也是在锁内部，
        //不就一直发不出去，那么这边在等，不释放锁，那边在争锁，又发不出去，不是死锁了吗。其实不然，pthread_cond_timedwait内部会先释放锁，然后等待信号，然后thrmgr_dispatch就可以进入锁发送信号了。
        //然后这边等到信号后再锁住，修改信号状态值，然后返回函数。pthread_cond_timedwait内部有一个释放锁，再锁住的过程。
        if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0) {
            /* Fatal error */
            logg("!Fatal: mutex lock failed\n");
            exit(-2);
        }
        timeout.tv_sec = time(NULL) + threadpool->idle_timeout;
        timeout.tv_nsec = 0;
        //等待线程数量加1
        threadpool->thr_idle++;
        //获取到任务退出循环,否则进入等待
        while (((job_data=work_queue_pop(threadpool->queue)) == NULL)&& (threadpool->state != POOL_EXIT))
        {
            /* Sleep, awaiting wakeup */
            //接收到第一个任务时，才会 创建第一个线程，所以第一次会接收到信号并处理，第二次循环如果没有任务，
            //则会在这里等待，线程被挂起，超时后往下执行
            retval = pthread_cond_timedwait(&(threadpool->pool_cond),&(threadpool->pool_mutex), &timeout);
            //如果是超时的，说明空闲超时，需要结束该线程，设置变量，让线程自动结束
            if (retval == ETIMEDOUT) {
                must_exit = TRUE;
                break;//跳出等待
            }
        }//等待结束，等待线程数量减1
        threadpool->thr_idle--;
        //如果线程状态为退出，也将must_exit置为true
        if (threadpool->state == POOL_EXIT) {
            must_exit = TRUE;
        }
        //threadpool变量修改结束，释放锁
        if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0) {
            /* Fatal error */
            logg("!Fatal: mutex unlock failed\n");
            exit(-2);
        }//如果任务不为空，执行任务
        if (job_data) {
            threadpool->handler(job_data);
        } 
        else if (must_exit)//如果是线程空闲太久或者线程池状态为退出，则退出线程
        {
            break;
        }
    }
    //又要操作公共变量threadpool->thr_alive了，锁住，不让别人来打扰
    if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0) {
        /* Fatal error */
        logg("!Fatal: mutex lock failed\n");
        exit(-2);
    }
    //线程即将推出，将活着的线程数量减1
    threadpool->thr_alive--;
    //最后一个线程了，临死前发出最后一个广播信号，告诉destory函数最后一个线程已经阵亡，可以结束了
    if (threadpool->thr_alive == 0) {
        /* signal that all threads are finished */
        pthread_cond_broadcast(&threadpool->pool_cond);
    }
    //修改公共变量结束，释放锁
    if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0) {
        /* Fatal error */
        logg("!Fatal: mutex unlock failed\n");
        exit(-2);
    }
    return NULL;
}
/*向线程池下发任务*/
int thrmgr_dispatch(threadpool_t *threadpool, void *user_data)
{
    pthread_t thr_id;

    if (!threadpool) {
        return FALSE;
    }

    /* Lock the threadpool */
    //需要访问公共对象任务队列了，开始锁住
    if (pthread_mutex_lock(&(threadpool->pool_mutex)) != 0) {
        logg("!Mutex lock failed\n");
        return FALSE;
    }

    if (threadpool->state != POOL_VALID) {
        if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0) {
            logg("!Mutex unlock failed\n");
            return FALSE;
        }
        return FALSE;
    }//向任务队列中加入任务
    if (!work_queue_add(threadpool->queue, user_data))
    {
        if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0) {
            logg("!Mutex unlock failed\n");
            return FALSE;
        }
        return FALSE;
    }
    //空闲等待线程数量为0，要么任务太多，要么第一次添加任务，线程池内线程数量为空
    if ((threadpool->thr_idle == 0) &&(threadpool->thr_alive < threadpool->thr_max)) 
    {
        /* Start a new thread */
        //启动线程
        if (pthread_create(&thr_id, &(threadpool->pool_attr),thrmgr_worker, threadpool) != 0)
        {
            logg("!pthread_create failed\n");
        } 
        else 
        {
            threadpool->thr_alive++;//成功创建，活线程数量加1
        }
    }
    //发送一个信号，告诉空闲等待线程，有任务了
    pthread_cond_signal(&(threadpool->pool_cond));

    if (pthread_mutex_unlock(&(threadpool->pool_mutex)) != 0) {
        logg("!Mutex unlock failed\n");
        return FALSE;
    }
    return TRUE;
}