Unix/Linux编程：POSIX间隔式定时器

水深无声 2022-10-16 08:39 452阅读 0赞

# POSIX间隔式定时器 #

使用setitimer来设置Unix间隔式定时器，会由如下几个问题：

*  针对ITIMER\_REAL、ITIMER\_VIRTUAL 和 ITIMER\_PROF 这 3 类定时器，每种只能设置一个
 *  只能通过发送信号的方式来通知定时器到期。另外，也不能改变到期时产生的信号
 *  如果一个间隔式定时器到期多次，而且相应信号遭到阻塞时，那么会只调用一次信号处理器函数。换句话说，无从知晓是否出现过定时器溢出的情况
 *  定时器的分辨率只能达到微秒级。不过，一些系统的硬件时钟提供了更为精细的时钟分辨率，软件此时应采用这一较高分辨率

POSIX.1b 定义了一套 API 来突破这些限制，Linux 2.6 实现了这一 API。

POSIX定时器API将定时器声明周期划分为如下几个阶段：

*  以系统调用`timer_create()`创建一个新定时器，并定义定时器到期时对进程的通知方法
 *  以系统调用 `timer_settime()`来启动或停止一个定时器
 *  以系统调用`timer_delete()`删除不再需要的定时器

由 fork()创建的子进程不会继承 POSIX 定时器。调用 exec()期间亦或进程终止时将停止并删除定时器。

Linux 上，调用 POSIX 定时器 API 的程序编译时应使用-lrt 选项，从而与 librt（实时）函数库相链接

## 创建定时器：timer\_create() ##

函数timer\_create()创建一个新定时器，并以clockid指定的时钟来进行时间度量

NAME
           timer_create - create a POSIX per-process timer
    
    SYNOPSIS
           #include <signal.h>
           #include <time.h>
    
           int timer_create(clockid_t clockid, struct sigevent *sevp,
                            timer_t *timerid);

设置参数 clockid，可以使用下表的任意值，也可以采用 clock\_getcpuclocid()或pthread\_getcpuclockid()返回的 clockid 值。

<table> 
 <thead> 
  <tr> 
   <th>clockid_t</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CLOCK_REALTIME</td> 
   <td>可设定的系统级实时时钟</td> 
  </tr> 
  <tr> 
   <td>CLOCK_MONOTONIC</td> 
   <td>不可设定的恒定态时钟</td> 
  </tr> 
  <tr> 
   <td>CLOCK_PROCESS_CPUTIME_ID</td> 
   <td>每进程 CPU 时间的时钟（自 Linux 2.6.12）</td> 
  </tr> 
  <tr> 
   <td>CLOCK_THREAD_CPUTIME_ID</td> 
   <td>每线程 CPU 时间的时钟（自 Linux 2.6.12）</td> 
  </tr> 
 </tbody> 
</table>

函数返回时会在参数 timerid 所指向的缓冲区中放置定时器句柄（handle），供后续调用中指代该定时器之用。这一缓冲区的类型为 timer\_t，是一种由 SUSv3 定义的数据类型，用于标识定时器。

参数sevp可以决定定时器到期时对应用程序的通知方式，指向类型为sigevent 的数据结构。

struct sigevent
    {
        
        int sigev_notify;   //设置定时器到期后的行为
        int sigev_signo;    //设置产生信号的信号码
        union sigval   sigev_value; //设置产生信号的值
        void (*sigev_notify_function)(union sigval);//定时器到期，从该地址启动一个线程
        pthread_attr_t *sigev_notify_attributes;    //创建线程的属性
    }
     
    union sigval
    {
        
        int sival_int;  //integer value
        void *sival_ptr; //pointer value
    }

可以下标所示值之一来设置结构中的 sigev\_notify 字段。

<table> 
 <thead> 
  <tr> 
   <th>sigev_notify 的值</th> 
   <th>通 知 方 法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SIGEV_NONE</td> 
   <td>不提供定时器到期通知。进程可以使用 timer_gettime()来监控定时器的运转情况。</td> 
  </tr> 
  <tr> 
   <td>SIGEV_SIGNAL</td> 
   <td>发送 sigev_signo 信号给进程</td> 
  </tr> 
  <tr> 
   <td>SIGEV_THREAD</td> 
   <td>调用 sigev_notify_function 作为新线程的启动函数</td> 
  </tr> 
  <tr> 
   <td>SIGEV_THREAD_ID</td> 
   <td>发送 sigev_signo 信号给 sigev_notify_thread_id 所标识的线程</td> 
  </tr> 
 </tbody> 
</table>

*  SIGEV\_SIGNAL：定时器到期时，为进程生成指定于 sigev\_signo 中的信号
    
     *  如果 sigev\_signal 为实时信号，那么 sigev\_value 字段则指定了信号的伴随数据（整型或指针）
     *  通过 siginfo\_t 结构的si\_value 可获取这一数据
     *  至于 siginfo\_t 结构，既可以直接传递给该信号的处理器函数，也可以由调用 sigwaitinfo()或 sigtimerdwait()返回
 *  SIGEV\_THREAD : 定时器到期时，会调用由 sigev\_notify\_function 字段指定的函数。
    
     *  调用该函数类似于调用新线程的启动函数
     *  即允许系统实现以如下两种方式为周期性定时器产生通知：
        
         *  将每个通知分别传递给一个唯一的新线程
         *  将通知成系列发送给单个新线程。
     *  可将 sigev\_notify\_attribytes 字段置为 NULL，或是指向 pthread\_attr\_t 结构的指针，并在结构中定义线程属性。在 sigev\_value 中设定的联合体 sigval 值是传递给函数的唯一参数
 *  SIGEV\_THREAD\_ID
    
     *  这与 SIGEV\_SIGNAL 相类似，只是发送信号的目标线程 ID 要与 sigev\_notify\_thread\_id 相匹配。该线程应与调用线程同属一个进程。（伴随 SIGEV\_SIGNAL 通知，会将信号置于针对整个进程的一个队列中排队，并且，如果进程包含多条线程，那么可将信号传递给进程中的任意线程。）
     *  可用 clone()或 gettid()的返回值对 sigev\_notify\_thread\_id 赋值。
     *  设计 SIGEV\_THREAD\_ID标志，意在供线程库使用。

将参数sevp置于NULL，这相当于将sigev\_notify 置为 SIGEV\_SIGNAL，同时将 sigev\_signo置为 SIGALRM（这与其他系统可能会有出入，因为 SUSv3 的措词是：一个缺省的信号值），并将 sigev\_value.sival\_int 置为定时器 ID

在当前实现中，内核会为每个用timer\_create()创建的POSIX定时器在队列中预分配一个实时信号结构。之所以要采取预分配，旨在确保当定时器到期时，至少有一个有效结构可服务于所产生的队列化信号。这也意味着可以创建的 POSIX 定时器数量受制于排队实时信号的数量

## 启动或者停止定时器：timer\_settime() ##

NAME
           timer_settime
    
    SYNOPSIS
           #include <time.h>
    
           int timer_settime(timer_t timerid, int flags,
                             const struct itimerspec *new_value,
                             struct itimerspec * old_value);
           Link with -lrt.

*  参数 timerid 是一个定时器句柄（handle），由之前对 timer\_create()的调用返回
 *  参数new\_value中包含定时器的新设置
 *  参数old\_value中用于返回定时器的前一设置，如果对定时器的前一设置不感兴趣，可将 old\_value 设为 NULL。

参数 value 和 old\_value 都是指向结构itimerspec 的指针，该结构定义如下：

struct itimerspec {
        
                   struct timespec it_interval;  /* Timer interval */
                   struct timespec it_value;     /* Initial expiration */
               };
               
    			struct timespec {
        
                   time_t tv_sec;                /* Seconds */
                   long   tv_nsec;               /* Nanoseconds */
               };

*  it\_value指定了定时器首次到期的时间
 *  it\_interval 指定是否时周期性定时器
    
     *  如果 it\_interval 的任一子字段非 0，那么这就是一个周期性定时器，在经历了由 it\_value 指定的初次到期后，会按这些子字段指定的频率周期性到期。
     *  如果 it\_interval 的下属字段均为 0，那么这个定时器将只到期一次。
 *  flags：
    
     *  若将 flags 置为 0，则会将 value.it\_value 视为始于 timer\_settime()调用时间点的相对值。
     *  如果将 flags 设为 TIMER\_ABSTIME，那么 value.it\_value 则是一个绝对时间（从时钟值 0 开始）。一旦时钟过了这一时间，定时器会立即到期

为了启动定时器，需要调用函数 timer\_settime()，并将 value.it\_value 的一个或全部下属字段设为非 0 值。如果之前曾经配备过定时器，timer\_settime()会将之前的设置替换掉

如果定时器的值和间隔时间并非对应时钟分辨率（由 clock\_getres()返回）的整数倍，那么会对这些值做向上取整处理。

定时器每次到期时，都会按特定方式通知进程，这种方式由创建定时器的 timer\_create()定义。如果结构 it\_interval 包含非 0 值，那么会用这些值来重新加载 it\_value 结构。

要解除定时器，需要调用 timer\_settime()，并将 value.it\_value 的所有字段指定为 0。

## 获取定时器的当前值：timer\_gettime() ##

SYNOPSIS
           #include <time.h>
    
           int timer_gettime(timer_t timerid, struct itimerspec *curr_value);
    
           Link with -lrt.

系统调用 timer\_gettime()返回由 timerid 指定 POSIX 定时器的间隔以及剩余时间。

*  curr\_value指针所指向的itimerspec 结构中返回的时时间间隔以及距离下次定时器到期的时间。即使是以 TIMER\_ABSTIME 标志创建的绝对时间定时器，在 curr\_value.it\_value 字段中返回的也是距离定时器下次到期的时间值
 *  如果返回结构 curr\_value.it\_value 的两个字段均为 0，那么定时器当前处于停止状态。如果返回结构 curr\_value.it\_interval 的两个字段都是 0，那么该定时器仅在 curr\_value.it\_value 给定的时间到期过一次

## 删除定时器 ##

每个 POSIX 定时器都会消耗少量系统资源。所以，一旦使用完毕，应当用 timer\_delete()来移除定时器并释放这些资源

NAME
           timer_delete - 删除每个进程计时器的POSIX
    
    SYNOPSIS
           #include <time.h>
    
           int timer_delete(timer_t timerid);
    
           Link with -lrt.

参数 timerid 是之前调用 timer\_create()时返回的句柄。对于已启动的定时器，会在移除前自动将其停止。如果因定时器到期而已经存在待定（pending）信号，那么信号会保持这一状态。（SUSv3 对此并未加以规范，所以其他的一些 UNIX 实现可能会有不同行为。）当进程终止时，会自动删除所有定时器。

## 通过信号发出通知 ##

如果选择通过信号来接收定时器通知，那么处理这些信号时既可以采用信号处理器函数，也可以调用 sigwaitinfo()或是 sigtimerdwait()。接收进程借助这两个方法可以获得一个siginfo\_t结构，其中包含与信号相关的深入信息。（要在信号处理器函数中使用这种特性，创建信号处理器函数时需设置 SA\_SIGINFO 标志。）在结构 siginfo\_t 中设置如下字段：

*  si\_signo：包含由定时器产生的信号
 *  si\_code：置为SI\_TIMER，表示这是因POSIX定时器到期而产生的信号。
 *  si\_value：将该字段置为以 timer\_create()创建定时器时在 evp.sigev\_value 中提供的值。为 evp.sigev\_value 指定不同的值，可以将到期时发送同类信号的不同定时器区分开来。

调用timer\_creater()时，通常将 evp.sigev\_value.sival\_ptr 赋值为当前调用中参数timerid的地址。从而允许信号处理器函数(或者sigwaitinfo()调用)获得产生信号的定时器ID（另外，也可以将调用函数 timer\_create()时给定的 timerid 参数置于一结构中，并将结构地址赋予 evp.sigev\_value.sival\_ptr。

Linux 还为 siginfo\_t 结构提供了如下非标准字段。

*  si\_overrun：包含了定时器溢出个数
 *  si\_timerid，其中包含一个标识符，供系统内部识别定时器之用（与 timer\_create()返回的 ID 不同）。对于应用程序来说没什么用处。

## 定时器溢出：timer\_getoverrun ##

假设已经选择通过信号（即 sigev\_notify 为 SIGEV\_SIGNAL）传递的方式来接收定时器到期通知。进一步假设，在捕获或接收相关信号之前，定时器多次到期。这可能是因为：

*  进程再次获得调度前的延时所致。
 *  直接调用sigprocmask()阻塞了相关信号的发送
 *  …

那么，如何知道发生了这些定时器溢出呢？

也许会认为实时信号有助于解决这个问题，因为可以对实时信号的多个实例进行排队。不过，由于对排队实时信号有数量上的限制，结果证明这种方法也无法奏效。所以 POSIX.1b委员会选用了另一种方法：一旦选择通过信号来接收定时器通知，那么即使是调用了实时信号，也绝不会对该信号的多个实例进行排队。相反，在接受信号后(无论是通过信号处理器函数还是调用sigwaitinfo())，可以获取定时器溢出计数，即在信号生成与接收之间发生的定时器到期额外次数。如果上次收到信号后定时器发生了 3 次到期，那么溢出计数是 2。

接收到定时器信号之后，有两种方法可以获得定时器溢出的值：

*  调用timer\_getoverrun()。这是由 SUSv3 指定去获取溢出计数的方法
 *  使用随信号一同返回的结构 siginfo\_t 中的 si\_overrun 字段值。这种方法可以避免  
    timer\_getoverrun()的系统调用开销，但同时也是一种 Linux 扩展方法，无法移植。

每次收到定时器信号后，都会重置定时器溢出计数，如果自处理或者接收定时器信号之后，定时器仅到期一次，则溢出计数为 0（即无溢出）

SYNOPSIS
           #include <time.h>
    
           int timer_getoverrun(timer_t timerid);
    
           Link with -lrt.

函数 timer\_getoverrun()返回由参数 timerid 指定定时器的溢出值。

根据 SUSv3 规定（表 21-1），函数 timer\_getoverrun()是异步信号安全的函数之一，故而在  
信号处理器函数内部调用也是安全的。

## 通过线程来通知 ##

SIGEV\_THREAD标志允许程序从一个独立的线程中调用函数来获取定时器到期通知

#include <stdio.h>
    #include <time.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <string.h>
    #include <unistd.h>
    #include <signal.h>
    #include <time.h>
    #include <pthread.h>
    static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
    static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    
    static int expireCnt = 0;           /* Number of expirations of all timers */
    
    char *
    currTime(const char *format)
    {
        
    #define BUF_SIZE 1000
        static char buf[BUF_SIZE];  /* Nonreentrant */
        time_t t;
        size_t s;
        struct tm *tm;
    
        t = time(NULL);
        tm = localtime(&t);
        if (tm == NULL)
            return NULL;
    
        s = strftime(buf, BUF_SIZE, (format != NULL) ? format : "%c", tm);
    
        return (s == 0) ? NULL : buf;
    }
    
    static void threadFunc(union sigval sv){
        
        time_t *tidptr;
        int s;
    
        tidptr = static_cast<time_t *>(sv.sival_ptr);
    
        printf("[%s] Thread notify\n", currTime("%T"));
        printf("    timer ID=%ld\n", (long) *tidptr);
        printf("    timer_getoverrun()=%d\n", timer_getoverrun(tidptr));
    
        s = pthread_mutex_lock(&mtx);
        if (s != 0){
        
            printf( "%d pthread_mutex_lock", s);
            exit(EXIT_FAILURE);
        }
    
        expireCnt += 1 + timer_getoverrun(tidptr);
    
        s = pthread_mutex_unlock(&mtx);
        if (s != 0){
        
            printf( "%d pthread_mutex_unlock", s);
            exit(EXIT_FAILURE);
        }
    
        s = pthread_cond_signal(&cond);
        if (s != 0){
        
            printf( "%d pthread_cond_signal", s);
            exit(EXIT_FAILURE);
        }
    }
    
    void
    itimerspecFromStr(char *str, struct itimerspec *tsp)
    {
        
        char *dupstr ,*cptr, *sptr;
    
        dupstr = strdup(str);
    
        cptr = strchr(dupstr, ':');
        if (cptr != NULL)
            *cptr = '\0';
    
        sptr = strchr(dupstr, '/');
        if (sptr != NULL)
            *sptr = '\0';
    
        tsp->it_value.tv_sec = atoi(dupstr);
        tsp->it_value.tv_nsec = (sptr != NULL) ? atoi(sptr + 1) : 0;
    
        if (cptr == NULL) {
        
            tsp->it_interval.tv_sec = 0;
            tsp->it_interval.tv_nsec = 0;
        } else {
        
            sptr = strchr(cptr + 1, '/');
            if (sptr != NULL)
                *sptr = '\0';
            tsp->it_interval.tv_sec = atoi(cptr + 1);
            tsp->it_interval.tv_nsec = (sptr != NULL) ? atoi(sptr + 1) : 0;
        }
        free(dupstr);
    }
    
    int main(int argc, char *argv[])
    {
        
        struct sigevent sev;
        struct itimerspec ts;
        timer_t *tidlist;
        int s, j;
    
        if (argc < 2){
        
            printf("%s secs[/nsecs][:int-secs[/int-nsecs]]...\n", argv[0]);
            exit(1);
        }
    
    
        tidlist = static_cast<timer_t *>(calloc(argc - 1, sizeof(timer_t)));
        if (tidlist == NULL){
        
            perror("malloc");
            exit(1);
        }
    
    
        sev.sigev_notify = SIGEV_THREAD;            /* Notify via thread */
        sev.sigev_notify_function = threadFunc;     /* Thread start function */
        sev.sigev_notify_attributes = NULL;
    
        for (j = 0; j < argc - 1; j++) {
        
            itimerspecFromStr(argv[j + 1], &ts);
    
            sev.sigev_value.sival_ptr = &tidlist[j];
            /* Passed as argument to threadFunc() */
    
            if (timer_create(CLOCK_REALTIME, &sev, &tidlist[j]) == -1){
        
                perror("timer_create");
                exit(1);
            }
    
            printf("Timer ID: %ld (%s)\n", (long) tidlist[j], argv[j + 1]);
    
            if (timer_settime(tidlist[j], 0, &ts, NULL) == -1){
        
                perror("timer_settime");
                exit(1);
            }
    
        }
    
        /* 主线程等待发出信号的条件变量
            每次调用线程通知函数时。我们
           打印一条消息，以便用户可以看到发生了这种情况。*/
    
        s = pthread_mutex_lock(&mtx);
        if (s != 0){
        
            perror("pthread_mutex_lock");
            exit(1);
        }
    
        for (;;) {
        
            s = pthread_cond_wait(&cond, &mtx);
            if (s != 0){
        
                printf( "%d pthread_cond_wait", s);
                exit(1);
            }
    
            printf("main(): expireCnt = %d\n", expireCnt);
        }
    }

在本例中，程序创建了两个定时器：一个定时器首次到期时间为 5 秒，并设置了 5 秒的时间间隔；另一个初次到期时间为 10 秒，并设置了 10 秒的时间间隔  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

# 例子 #

## 新进程派驻的通知方式 ##

#include <stdio.h>
    #include <signal.h>
    #include <time.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    void timer_thread(union sigval v)
    {
        
        printf("timer_thread function! %d\n", v.sival_int);
    }
    
    int main()
    {
        
        timer_t timerid;
        struct sigevent evp;
        memset(&evp, 0, sizeof(struct sigevent));       //清零初始化
    
        evp.sigev_value.sival_int = 111;                //也是标识定时器的，回调函数可以获得
        evp.sigev_notify = SIGEV_THREAD;                //线程通知的方式，派驻新线程
        evp.sigev_notify_function = timer_thread;       //线程函数地址
    
        if (timer_create(CLOCK_REALTIME, &evp, &timerid) == -1)
        {
        
            perror("fail to timer_create");
            exit(-1);
        }
    
        /* 第一次间隔it.it_value这么长,以后每次都是it.it_interval这么长,就是说it.it_value变0的时候会>装载it.it_interval的值 */
        struct itimerspec it;
        it.it_interval.tv_sec = 1;  // 回调函数执行频率为1s运行1次
        it.it_interval.tv_nsec = 0;
        it.it_value.tv_sec = 3;     // 倒计时3秒开始调用回调函数
        it.it_value.tv_nsec = 0;
    
        if (timer_settime(timerid, 0, &it, NULL) == -1)
        {
        
            perror("fail to timer_settime");
            exit(-1);
        }
    
    
        while (1){
        
            pause();
        }
    
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

## 通知方式为信号的处理方式 ##

#include <signal.h>
    #include <time.h>
    #include <stdio.h>
    
    void handle(int i )
    {
        
        time_t t;
        char p[32];
    
        time(&t);
        strftime(p, sizeof(p), "%T", localtime(&t));
    
        printf("time is %s\n", p);
    }
    
    
    
    int main()
    {
        
        struct sigevent evp;
        struct itimerspec ts;
        timer_t timer;
        int ret;
    
        signal(SIGUSR1, handle);    //  为信号SIGUSR1指定信号处理函数
    
        evp.sigev_value.sival_ptr = &timer;
        evp.sigev_notify = SIGEV_SIGNAL;  //定时器到期时，为进程生成指定于 sigev_signo 中的信号
        evp.sigev_signo = SIGUSR1;        //生成的信号是SIGUSR1
        ret = timer_create(CLOCK_REALTIME, &evp, &timer);
        if( ret )
            perror("timer_create");
    
        ts.it_interval.tv_sec = 1;   // 回调函数执行频率为1s运行1次
        ts.it_interval.tv_nsec = 0;
        ts.it_value.tv_sec = 3;
        ts.it_value.tv_nsec = 0;
    
        ret = timer_settime(timer, 0, &ts, NULL);  // 启动定时器
        if( ret )
            perror("timer_settime");
    
        while(1);
    }

![在这里插入图片描述][20210528153456985.png]

#include <stdio.h>
    #include <time.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <string.h>
    #include <unistd.h>
    
    #define CLOCKID CLOCK_REALTIME
    
    void sig_handler(int signo)
    {
        
        printf("timer_signal function! %d\n", signo);
    }
    
    int main()
    {
        
        struct sigaction act;
        memset(&act, 0, sizeof(act));
        act.sa_handler = sig_handler;
        act.sa_flags = 0;
        sigemptyset(&act.sa_mask);
        if (sigaction(SIGUSR1, &act, NULL) == -1)
        {
        
            perror("fail to sigaction");
            exit(-1);
        }
    
        timer_t timerid;
        struct sigevent evp;
        memset(&evp, 0, sizeof(struct sigevent));
        evp.sigev_signo = SIGUSR1;  //#define	SIGUSR1		10	/* User-defined signal 1 (POSIX).  */
        evp.sigev_notify = SIGEV_SIGNAL;
        if (timer_create(CLOCK_REALTIME, &evp, &timerid) == -1)
        {
        
            perror("fail to timer_create");
            exit(-1);
        }
    
        struct itimerspec it;
        it.it_interval.tv_sec = 2;
        it.it_interval.tv_nsec = 0;
        it.it_value.tv_sec = 1;
        it.it_value.tv_nsec = 0;
        if (timer_settime(timerid, 0, &it, 0) == -1)
        {
        
            perror("fail to timer_settime");
            exit(-1);
        }
    
        pause();
    
        return 0;
    }

![在这里插入图片描述][20210528155638790.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221014/bdc0167aec4e480c9e6b8e71d9759f92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20221014/006fbd73e3094d2ba249cbfab1fb9a6f.png
[20210528153456985.png]: /images/20221014/86200b720933466580afe197abf1e6de.png
[20210528155638790.png]: /images/20221014/d86342f1805548b5b80d3bb92c0afe8f.png