Explication détaillée du mécanisme de délai d'attente du script PHP

Dans notre développement quotidien, nous avons peut-être rencontré la situation où les scripts PHP exécutent un délai d'attente. Lorsque nous rencontrons cette situation, nous utilisons souvent set_time_limit (mode non sécurisé), ou modifions le fichier de configuration et redémarrons le serveur, ou modifions le programme. réduire le temps d'exécution du programme dans la plage autorisée pour résoudre ce problème. J'espère que cela aide tout le monde.

Lors du développement PHP, max_input_time et max_execution_time sont souvent définis pour contrôler le délai d'attente du script. Mais je n’ai jamais réfléchi au principe qui se cache derrière.

Profitez du temps libre de ces deux jours pour étudier cette question.

Configuration du délai d'attente

Le fonctionnement de la configuration ini de PHP est un sujet courant.

Tout d'abord, nous le configurons dans php.ini. Lorsque php démarre (étape php_module_startup), il essaiera de lire le fichier ini et de l'analyser. Pour faire simple, le processus d'analyse consiste à analyser le fichier ini, à extraire les paires clé-valeur légales et à les enregistrer dans la table configuration_hash.

OK, alors php appellera ensuite zend_startup_extensions pour démarrer chaque module (y compris le module php Core et toutes les extensions qui doivent être chargées). Dans la fonction de démarrage de chaque module, l'action REGISTER_INI_ENTRIES sera complétée. REGISTER_INI_ENTRIES se charge de retirer certaines configurations correspondant au module de la table configuration_hash, puis d'appeler la fonction de traitement, et enfin de stocker les valeurs traitées dans la variable globale du module.

Les deux configurations max_input_time et max_execution_time appartiennent au module php Core. Pour php Core, REGISTER_INI_ENTRIES apparaît toujours dans php_module_startup. Les configurations qui appartiennent également au module php Core incluent expose_php, display_errors, memory_limit, etc...

Le diagramme schématique est le suivant :

---->php_module_startup----------->php_request_startup---->
    |
    |
    |-->REGISTER_INI_ENTRIES
    |
    |
    |-->zend_startup_extensions
    |     |
    |     |-->zm_startup_date
    |     |     |-->REGISTER_INI_ENTRIES
    |     |
    |     |-->zm_startup_json
    |     |     |-->REGISTER_INI_ENTRIES
    |
    |
    |-->do otherthings

Comme mentionné ci-dessus, pour différentes configurations, REGISTER_INI_ENTRIES appellera différentes fonctions à traiter. Regardons directement la fonction correspondant à max_execution_time :

static PHP_INI_MH(OnUpdateTimeout)
{
  // php启动阶段走这里
  if (stage == PHP_INI_STAGE_STARTUP) {
    // 将超时设置保存到EG(timeout_seconds)中
    EG(timeout_seconds) = atoi(new_value);
    return SUCCESS;
  }
 
  // php执行过程中的ini set则走这里
  zend_unset_timeout(TSRMLS_C);
  EG(timeout_seconds) = atoi(new_value);
  zend_set_timeout(EG(timeout_seconds), 0);
  return SUCCESS;
}

Nous ne regarderons que la moitié supérieure pour l'instant, car nous devons uniquement nous concentrer sur la phase de démarrage de PHP. Le comportement de cette fonction est très simple. Stockez max_execution_time dans EG(timeout_seconds).

Quant à max_input_time, il n'y a pas de fonction de traitement spéciale. Par défaut, max_input_time sera stocké dans PG (max_input_time).

Ainsi, lorsque REGISTER_INI_ENTRIES est terminé, ce qui se passe est :

max_execution_time ----> Dépôt EG(timeout_seconds)

max_input_time ----> )

Contrôle du délai d'expiration de la demande

Maintenant que nous comprenons ce qui se passe dans la phase de démarrage de php, continuons à regarder comment php traite réellement la demande, comment gérer les délais d'attente.

Il y a le code suivant dans la fonction php_request_startup :

if (PG(max_input_time) == -1) {
  zend_set_timeout(EG(timeout_seconds), 1);
} else {
  zend_set_timeout(PG(max_input_time), 1);
}

Le timing de php_request_startup est très particulier.

En prenant cgi comme exemple, php_request_startup ne sera appelé qu'après que php aura obtenu la requête originale et certaines variables d'environnement CGI de CGI. Lorsque le code ci-dessus est réellement exécuté, puisque la requête a été obtenue, SG (request_info) est dans un état prêt, mais les variables super globales telles que $_GET, $_POST, $_FILE et ainsi de suite en PHP n'ont pas encore été générées.

Compréhension du code :

1. Si l'utilisateur configure max_input_time sur -1, ou ne le configure pas, alors le cycle de vie du script n'est limité que par EG (timeout_seconds).

2. Sinon, le contrôle du délai d'attente dans la phase de démarrage de la requête est soumis au PG (max_input_time).

3. La fonction zend_set_timeout est responsable du réglage de la minuterie. Une fois le temps spécifié écoulé, le minuteur en informera le processus php. zend_set_timeout sera analysé en détail ci-dessous.

Une fois php_request_startup terminé, il entre dans la phase d'exécution réelle de php, c'est-à-dire php_execute_script. Vous pouvez voir dans php_execute_script :

// 设定执行超时
if (PG(max_input_time) != -1) {
#ifdef PHP_WIN32
  zend_unset_timeout(TSRMLS_C); // 关闭之前的定时器
#endif
  zend_set_timeout(INI_INT("max_execution_time"), 0);
}
 
// 进入执行
retval = (zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, NULL, 3, prepend_file_p, primary_file, append_file_p) == SUCCESS);

OK Si le code est exécuté ici et que le délai d'expiration de max_input_time ne s'est pas produit, le délai d'expiration de max_execution_time sera respécifié.

Appelle également zend_set_timeout et passe max_execution_time. Portez une attention particulière au fait que vous devez appeler explicitement zend_unset_timeout pour désactiver le minuteur d'origine sous Windows, mais pas sous Linux. Cela est dû aux principes de mise en œuvre différents des timers sur les deux plateformes, qui seront décrits en détail ci-dessous.

Enfin, une image est utilisée pour représenter le processus de contrôle du délai d'attente. Le cas de gauche montre que l'utilisateur a configuré à la fois max_input_time et max_execution_time. La différence à droite est que l'utilisateur a uniquement configuré max_execution_time :

zend_set_timeout

Comme mentionné précédemment, le zend_set_timeout fonction utilise pour régler la minuterie. Examinons spécifiquement l'implémentation :

void zend_set_timeout(long seconds, int reset_signals) /* {{{ */
{
  TSRMLS_FETCH();
 
  // 赋值
  EG(timeout_seconds) = seconds;
 
#ifdef ZEND_WIN32
  if(!seconds) {
    return;
  }
   
  // 启动定时器线程
  if (timeout_thread_initialized == 0 && InterlockedIncrement(&timeout_thread_initialized) == 1) {
    /* We start up this process-wide thread here and not in zend_startup(), because if Zend
     * is initialized inside a DllMain(), you're not supposed to start threads from it.
     */
    zend_init_timeout_thread();
  }
   
  // 向线程发送WM_REGISTER_ZEND_TIMEOUT消息
  PostThreadMessage(timeout_thread_id, WM_REGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(),
                                  (LPARAM) seconds);
#else
 
  // linux平台下
  struct itimerval t_r;    /* timeout requested */
  int signo;
 
  if (seconds) {
    t_r.it_value.tv_sec = seconds;
    t_r.it_value.tv_usec = t_r.it_interval.tv_sec = t_r.it_interval.tv_usec = 0;
 
    // 设置定时器，seconds秒后会发送SIGPROF信号
    setitimer(ITIMER_PROF, &t_r, NULL);
  }
  signo = SIGPROF;
 
  if (reset_signals) {
    sigset_t sigset;
 
    // 设置SIGPROF信号对应的处理函数为zend_timeout
    signal(signo, zend_timeout);
     
    // 防屏蔽
    sigemptyset(&sigset);
    sigaddset(&sigset, signo);
    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
  }
#endif
}

L'implémentation ci-dessus peut fondamentalement être complètement divisée en deux plates-formes :

Regardez d'abord Linux :

Le timer sous Linux est beaucoup plus simple, il suffit d'appeler la fonction setitimer De plus, zend_set_timeout définit également le gestionnaire du signal SIGPROF sur zend_timeout.

注意，调用setitimer的时候，将it_interval设置成0，表明这个定时器只触发一次，而不会每隔一段时间触发一次。setitimer可以以三种方式计时，php中采用的是ITIMER_PROF，它同时计算了用户代码和内核代码的执行时间。一旦时间到了，会产生SIGPROF信号。

当php进程接收到SIGPROF信号，不管当前正在执行什么，都会跳转进入到zend_timeout。zend_timeout才是实际处理超时的函数。

再看windows：

首先会启动一个子线程，该线程主要用于设置定时器，同时维护EG(timed_out)变量。

子线程一旦生成，主线程便会向子线程发送一条消息：WM_REGISTER_ZEND_TIMEOUT。子线程接收到WM_REGISTER_ZEND_TIMEOUT之后，产生一个定时器并开始计时。同时，子线程会设置EG(timed_out) = 0。这很重要！windows平台下正是通过判断EG(timed_out)是否为1，来决定是否超时。

如果定时器到时间了，子线程收到WM_TIMER消息，则取消定时器，并且设置EG(timed_out) = 1。

如果需要关闭定时器，则子线程会收到WM_UNREGISTER_ZEND_TIMEOUT消息。关闭定时器，并不会改变EG(timed_out)。

相关代码还是很清晰的：

static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  switch (message) {
    case WM_DESTROY:
      PostQuitMessage(0);
      break;
     
    // 生成一个定时器，开始计时
    case WM_REGISTER_ZEND_TIMEOUT:
      /* wParam is the thread id pointer, lParam is the timeout amount in seconds */
      if (lParam == 0) {
        KillTimer(timeout_window, wParam);
      } else {
        SetTimer(timeout_window, wParam, lParam*1000, NULL);
        EG(timed_out) = 0;
      }
      break;
     
    // 关闭定时器
    case WM_UNREGISTER_ZEND_TIMEOUT:
      /* wParam is the thread id pointer */
      KillTimer(timeout_window, wParam);
      break;
     
    // 超时了，也需关闭定时器
    case WM_TIMER: {
        KillTimer(timeout_window, wParam);
        EG(timed_out) = 1;
      }
      break;
    default:
      return DefWindowProc(hWnd, message, wParam, lParam);
  }
  return 0;
}

根据上文描述，最终都是需要跳转到zend_timeout来处理超时的。那windows下如何进入zend_timeout呢？

window下仅在execute函数中（zend_vm_execute.h刚开始的地方），可以看到调用zend_timeout：

while (1) {
  int ret;
#ifdef ZEND_WIN32
  if (EG(timed_out)) {  // windows下的超时，执行每条opcode之前都判断是否需要调用zend_timeout
    zend_timeout(0);
  }
#endif
 
  if ((ret = OPLINE->handler(execute_data TSRMLS_CC)) > 0) {
  ...
  }
}

上述代码可以看到：

在windows下，每执行完成一条opcode指令，就会进行一次超时判断。

因为主线程执行opcode的同时，子线程可能已经发生超时，而windows并没有什么机制可以让主线程停止手头的工作，直接跳入zend_timeout。所以只好利用子线程先将EG(timed_out)设置为1，然后主线程在等到当前opcode执行完成、进入下一条opcode之前，判断一下EG(timed_out)再调用zend_timeout。

因此准确的讲，windows的超时，其实是有一点点延时的。至少在某一个opcode执行的过程中，无法被打断。当然，正常情况下，单条opcode的执行时间会很短。但是可以很容易人为构造出一些很耗时的函数，使得function call需要等待较长时间。此时，如果子线程判断出超时了，则还需要经过漫长的等待，直到主线程完成该条opcode之后，才能调用zend_timeout。

zend_unset_timeout

void zend_unset_timeout(TSRMLS_D) /* {{{ */
{
#ifdef ZEND_WIN32
   
  // 通过发送WM_UNREGISTER_ZEND_TIMEOUT消息来关闭定时器
  if(timeout_thread_initialized) {
    PostThreadMessage(timeout_thread_id, WM_UNREGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) 0);
  }
#else
  if (EG(timeout_seconds)) {
    struct itimerval no_timeout;
    no_timeout.it_value.tv_sec = no_timeout.it_value.tv_usec = no_timeout.it_interval.tv_sec = no_timeout.it_interval.tv_usec = 0;
     
    // 全置0，相当于关闭定时器
    setitimer(ITIMER_PROF, &no_timeout, NULL);
  }
#endif
}

zend_unset_timeout同样分成两种平台的实现。

先看linux：

linux下的关闭定时器也很简单。只要将struct itimerval中的4个值都设置为0，就行了。

再看windows：

由于windows是利用一个独立的线程来计时。因此，zend_unset_timeout会向该线程发送WM_UNREGISTER_ZEND_TIMEOUT消息。WM_UNREGISTER_ZEND_TIMEOUT对应的动作是去调用KillTimer来关闭定时器。注意，线程本身并不退出。

前文留下了一个问题，在php_execute_script中，windows下面要显示调用zend_unset_timeout来关闭定时器，而linux下不需要。因为对于一个linux进程来说，只能存在一个setitimer定时器。也就是说，重复调用setitimer，后面的定时器会直接覆盖前面的。

zend_timeout

ZEND_API void zend_timeout(int dummy) /* {{{ */
{
  TSRMLS_FETCH();
 
  if (zend_on_timeout) {
    zend_on_timeout(EG(timeout_seconds) TSRMLS_CC);
  }
 
  zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
}

如前文所述，zend_timeout是实际处理超时的函数。它的实现也很简单。

如果有配置exit_on_timeout，则zend_on_timeout会尝试调用sapi_terminate_process关闭sapi进程。如果无需exit_on_timeout，则直接进入zend_error进行出错处理。大部分情况下，我们并不会设置exit_on_timeout，毕竟我们期望的是虽然一个请求超时了，但是进程仍然保留下来，服务下一个请求。

zend_error除了会打印错误日志，还会利用longjump跳转到boilout指定的栈帧，一般是zend_end_try或者zend_catch宏所在的地方。关于longjump，可以另起一个话题，本文就不具体叙述了。在php_execute_script里面，zend_error会使得程序跳转到zend_end_try的位置然后继续执行。继续执行是指，会调用php_request_shutdown等函数来完成收尾工作。

直到这里，php脚本的超时机制算是讲清楚了。

最后来看一个疑似php内核的bug。

windows下max_input_time的bug

回忆一下，之前有提到windows下只有一个地方调用了zend_timeout，就是execute函数里，准确讲是每条opcode执行之前。

那么，假如发生max_input_time类型的超时，即使子线程将EG(timed_out)被置为1，也得延迟到execute中才能进行超时处理。貌似一切正常。

La clé du problème est que nous ne pouvons pas garantir que EG (timed_out) sera toujours égal à 1 lorsque le thread principal s'exécutera. Une fois que EG(timed_out) est modifié à 0 par le thread enfant avant d'entrer en exécution, le timeout du type max_input_time ne sera jamais géré.

Pourquoi EG(timed_out) est-il modifié à 0 par le thread enfant ? La raison est la suivante : dans php_execute_script, zend_set_timeout(INI_INT("max_execution_time"), 0) est appelé pour définir le timer.

zend_set_timeout enverra le message WM_REGISTER_ZEND_TIMEOUT au fil de discussion enfant. Lorsque le thread enfant reçoit ce message, en plus de créer un timer, il définira également EG(timed_out) = 0 (voir l'extrait de code zend_timeout_WndProc intercepté ci-dessus pour plus de détails). En raison de l'incertitude de l'exécution du thread, il est impossible de déterminer si le thread enfant a reçu le message et a défini EG (timed_out) sur 0 lorsque le thread principal exécute l'exécution.

Comme le montre la figure,

Si le jugement en exécution se produit au moment marqué par la ligne rouge, alors EG (timed_out) est 1 et exécuter appellera zend_timeout pour effectuer le traitement du délai d'attente.

Si le jugement en exécution se produit au moment marqué par la ligne bleue, EG (timed_out) a été réinitialisé à 0 et le délai d'attente max_input_time est complètement couvert.

Recommandations associées :

Une brève analyse du mécanisme de fonctionnement sous-jacent et des principes de fonctionnement de PHP

Explication détaillée de l'utilisation de la mémoire partagée PHP

PHP génère du code Morse basé sur du texte

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!