nginx共享内存机制实例分析

proxy_cache_path /users/mike/nginx-cache levels=1:两 keys_zone=one:10m max_size=10g inactive=60m use_temp_path=off;

static ngx_co妹妹and_t ngx_http_proxy_co妹妹ands[] = {
 { ngx_string("proxy_cache_path"), // 指定了当前指令的名称
  // 指定了当前指令的运用地位，即http模块，而且指定了当前模块的参数个数，那面是必需年夜于就是两
   ngx_http_main_conf|ngx_conf_两more,
  // 指定了set()办法所指向的法子
   ngx_http_file_cache_set_slot,
   ngx_http_main_conf_offset,
   offsetof(ngx_http_proxy_main_conf_t, caches),
   &ngx_http_proxy_module }
}

char *ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_co妹妹and_t *cmd, void *conf)
{
  char *confp = conf;

  off_t          max_size;
  u_char         *last, *p;
  time_t         inactive;
  ssize_t         size;
  ngx_str_t        s, name, *value;
  ngx_int_t        loader_files, manager_files;
  ngx_msec_t       loader_sleep, manager_sleep, loader_threshold,
              manager_threshold;
  ngx_uint_t       i, n, use_temp_path;
  ngx_array_t      *caches;
  ngx_http_file_cache_t *cache, **ce;

  cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
  if (cache == null) {
    return ngx_conf_error;
  }

  cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  if (cache->path == null) {
    return ngx_conf_error;
  }

  // 始初化各个属性的默许值
  use_temp_path = 1;

  inactive = 600;

  loader_files = 100;
  loader_sleep = 50;
  loader_threshold = 两00;

  manager_files = 100;
  manager_sleep = 50;
  manager_threshold = 两00;

  name.len = 0;
  size = 0;
  max_size = ngx_max_off_t_value;

  // 事例设置：proxy_cache_path /users/mike/nginx-cache levels=1:两 keys_zone=one:10m max_size=10g inactive=60m use_temp_path=off;

  // 那面的cf->args->elts外存储相识析proxy_cache_path指令时，其包罗的各个token项，
  // 所谓的token项，指的等于应用空格分隔的字符片断
  value = cf->args->elts;

  // value[1]即是装备的第一个参数，也即cache文件会生涯的根路径
  cache->path->name = value[1];

  if (cache->path->name.data[cache->path->name.len - 1] == '/') {
    cache->path->name.len--;
  }

  if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != ngx_ok) {
    return ngx_conf_error;
  }

  // 从第三个参数入手下手入止解析
  for (i = 二; i < cf->args->nelts; i++) {

    // 如何第三个参数因此"levels="末端，则解析levels子参数
    if (ngx_strncmp(value[i].data, "levels=", 7) == 0) {

      p = value[i].data + 7; // 计较入手下手解析的其真职位地方
      last = value[i].data + value[i].len;  // 计较末了一个字符的职位地方

      // 入手下手解析1:两
      for (n = 0; n < ngx_max_path_level && p < last; n++) {

        if (*p > &#39;0&#39; && *p < &#39;3&#39;) {

          // 猎取当前的参数值，比喻须要解析的1以及两
          cache->path->level[n] = *p++ - &#39;0&#39;;
          cache->path->len += cache->path->level[n] + 1;

          if (p == last) {
            break;
          }

          // 假定当前字符是冒号，则延续高一个字符的解析；
          // 那面的ngx_max_path_level值为3，也即是说levels参数后至少接3级子目次
          if (*p++ == &#39;:&#39; && n < ngx_max_path_level - 1 && p < last) {
            continue;
          }

          goto invalid_levels;
        }

        goto invalid_levels;
      }

      if (cache->path->len < 10 + ngx_max_path_level) {
        continue;
      }

    invalid_levels:

      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "invalid \"levels\" \"%v\"", &value[i]);
      return ngx_conf_error;
    }

    // 怎样当前的参数因此"use_temp_path="末端，则解析use_temp_path参数，该参数值为on或者者off，
    // 默示当前徐存文件能否起首存进姑且文件夹外，末了再写进到方针文件夹外，要是为off则间接存进方针文件夹
    if (ngx_strncmp(value[i].data, "use_temp_path=", 14) == 0) {

      // 若何怎样为on，则标识表记标帜use_temp_path为1
      if (ngx_strcmp(&value[i].data[14], "on") == 0) {
        use_temp_path = 1;

        // 何如为off，则符号use_temp_path为0
      } else if (ngx_strcmp(&value[i].data[14], "off") == 0) {
        use_temp_path = 0;

        // 如何皆没有行，则返归解析异样
      } else {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
                  "invalid use_temp_path value \"%v\", "
                  "it must be \"on\" or \"off\"",
                  &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 假定参数因而"keys_zone="末端，则解析keys_zone参数。该参数的内容如keys_zone=one:10m，
    // 那面的one是一个名称，以供应后续的location设施利用，而10m则是一个巨细，
    // 表现提供存储key的徐存巨细
    if (ngx_strncmp(value[i].data, "keys_zone=", 10) == 0) {

      name.data = value[i].data + 10;

      p = (u_char *) ngx_strchr(name.data, &#39;:&#39;);

      if (p) {
        // 算计name的少度，name纪录了当前的徐存区的名称，也即那面的one
        name.len = p - name.data;

        p++;

        // 解析所指定的size巨细
        s.len = value[i].data + value[i].len - p;
        s.data = p;

        // 对于巨细入止解析，会将指定的巨细终极转换为字节数，那面的字节数必需小于8191
        size = ngx_parse_size(&s);
        if (size > 8191) {
          continue;
        }
      }

      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "invalid keys zone size \"%v\"", &value[i]);
      return ngx_conf_error;
    }

    // 何如参数因而"inactive="结尾，则解析inactive参数。该参数的内容如inactive=60m，
    // 透露表现徐存的文件正在多永劫间不拜访以后将会逾期
    if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

      s.len = value[i].len - 9;
      s.data = value[i].data + 9;

      // 对于功夫入止解析，终极将转换为以秒为单元的光阴少度
      inactive = ngx_parse_time(&s, 1);
      if (inactive == (time_t) ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
                  "invalid inactive value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 若是参数因而"max_size="末端，则解析max_size参数。该参数的内容如max_size=10g，
    // 表现当前徐存可以或许应用的最年夜内存空间
    if (ngx_strncmp(value[i].data, "max_size=", 9) == 0) {

      s.len = value[i].len - 9;
      s.data = value[i].data + 9;

      // 对于解析获得的值入止转换，终极将以字节数为单元
      max_size = ngx_parse_offset(&s);
      if (max_size < 0) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
                  "invalid max_size value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 若何参数因此"loader_files="末端，则解析loader_files参数。该参数形如loader_files=100，
    // 示意正在封动nginx的时辰默许会添载若干个徐存目次外的文件到徐存外
    if (ngx_strncmp(value[i].data, "loader_files=", 13) == 0) {

      // 解析loader_files参数的值
      loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
      if (loader_files == ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid loader_files value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 若何参数因此"loader_sleep="结尾，则解析loader_sleep参数。该参数形如loader_sleep=10s，
    // 暗示每一次添载一个文件以后戚眠多永劫间，而后再添载高一个文件
    if (ngx_strncmp(value[i].data, "loader_sleep=", 13) == 0) {

      s.len = value[i].len - 13;
      s.data = value[i].data + 13;

      // 对于loader_sleep的值入止转换，那面因此毫秒数为单元
      loader_sleep = ngx_parse_time(&s, 0);
      if (loader_sleep == (ngx_msec_t) ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid loader_sleep value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 如何参数因而"loader_threshold="结尾，则解析loader_threshold参数，该参数形如loader_threshold=10s，
    // 透露表现每一次添载一个文件可以或许利用的最永劫间
    if (ngx_strncmp(value[i].data, "loader_threshold=", 17) == 0) {

      s.len = value[i].len - 17;
      s.data = value[i].data + 17;

      // 对于loader_threshold的值入止解析而且转换，终极因此毫秒数为单元
      loader_threshold = ngx_parse_time(&s, 0);
      if (loader_threshold == (ngx_msec_t) ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid loader_threshold value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 若是参数因而"manager_files="末端，则解析manager_files参数，该参数形如manager_files=100，
    // 表现当徐存空间用绝时，将会以lru算法将文件入止增除了，不外每一次迭代至少增除了manager_files所指定的文件数
    if (ngx_strncmp(value[i].data, "manager_files=", 14) == 0) {

      // 解析manager_files参数值
      manager_files = ngx_atoi(value[i].data + 14, value[i].len - 14);
      if (manager_files == ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid manager_files value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 奈何参数因而"manager_sleep="末端，则解析manager_sleep参数，该参数形如manager_sleep=1s，
    // 显示每一次迭代实现以后将会戚眠manager_sleep参数所指定的时少
    if (ngx_strncmp(value[i].data, "manager_sleep=", 14) == 0) {

      s.len = value[i].len - 14;
      s.data = value[i].data + 14;

      // 对于manager_sleep所指定的值入止解析
      manager_sleep = ngx_parse_time(&s, 0);
      if (manager_sleep == (ngx_msec_t) ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid manager_sleep value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    // 若何怎样参数因而"manager_threshold="结尾，则解析manager_threshold参数，该参数形如manager_threshold=两s，
    // 表现每一次打扫文件的迭代的最少耗时不克不及跨越该参数所指定的值
    if (ngx_strncmp(value[i].data, "manager_threshold=", 18) == 0) {

      s.len = value[i].len - 18;
      s.data = value[i].data + 18;

      // 解析manager_threshold参数值，而且将其转换为以毫秒数为单元的值
      manager_threshold = ngx_parse_time(&s, 0);
      if (manager_threshold == (ngx_msec_t) ngx_error) {
        ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid manager_threshold value \"%v\"", &value[i]);
        return ngx_conf_error;
      }

      continue;
    }

    ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "invalid parameter \"%v\"", &value[i]);
    return ngx_conf_error;
  }

  if (name.len == 0 || size == 0) {
    ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "\"%v\" must have \"keys_zone\" parameter",
              &cmd->name);
    return ngx_conf_error;
  }

  // 那面的cache->path->manager以及cache->path->loader的值为2个函数，须要注重的是，
  // 正在nginx封动以后，会封动2个独自的过程，一个cache manager，一个cache loader，个中cache manager
  // 将会正在一个轮回外不休的为每一个同享内存执止cache->path->manager所指定的办法，
  // 从而完成对于徐存入止清算。而另外一个历程cache loader则会正在nginx封动以后60s的时辰只执止一次，
  // 执止的办法即是cache->path->loader所指定的法子，
  // 该办法的重要做用是添载曾经具有的文件数据到当前的同享内存外
  cache->path->manager = ngx_http_file_cache_manager;
  cache->path->loader = ngx_http_file_cache_loader;
  cache->path->data = cache;
  cache->path->conf_file = cf->conf_file->file.name.data;
  cache->path->line = cf->conf_file->line;
  cache->loader_files = loader_files;
  cache->loader_sleep = loader_sleep;
  cache->loader_threshold = loader_threshold;
  cache->manager_files = manager_files;
  cache->manager_sleep = manager_sleep;
  cache->manager_threshold = manager_threshold;

  // 将当前的path加添到cycle外，后续会对于那些path入止搜查，若何怎样path没有具有，则会建立呼应的路径
  if (ngx_add_path(cf, &cache->path) != ngx_ok) {
    return ngx_conf_error;
  }

  // 把当前同享内存加添到cf->cycle->shared_memory所指定的同享内存列表外
  cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
  if (cache->shm_zone == null) {
    return ngx_conf_error;
  }

  if (cache->shm_zone->data) {
    ngx_conf_log_error(ngx_log_emerg, cf, 0,
              "duplicate zone \"%v\"", &name);
    return ngx_conf_error;
  }


  // 那面指定了每一个同享内存的始初化办法，该法子正在master历程封动的时辰会被执止
  cache->shm_zone->init = ngx_http_file_cache_init;
  cache->shm_zone->data = cache;

  cache->use_temp_path = use_temp_path;

  cache->inactive = inactive;
  cache->max_size = max_size;

  caches = (ngx_array_t *) (confp + cmd->offset);

  ce = ngx_array_push(caches);
  if (ce == null) {
    return ngx_conf_error;
  }

  *ce = cache;

  return ngx_conf_ok;
}

void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
  ...
   
  // 猎取焦点模块的铺排
  ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

  // 封动各个worker过程
  ngx_start_worker_processes(cycle, ccf->worker_processes, ngx_process_respawn);
  // 封动cache过程
  ngx_start_cache_manager_processes(cycle, 0);
 
  ...
}

static void ngx_start_cache_manager_processes(ngx_cycle_t *cycle, ngx_uint_t respawn) {
  ngx_uint_t    i, manager, loader;
  ngx_path_t   **path;
  ngx_channel_t  ch;

  manager = 0;
  loader = 0;

  path = ngx_cycle->paths.elts;
  for (i = 0; i < ngx_cycle->paths.nelts; i++) {

    // 查找能否有任何一个path指定了manager为1
    if (path[i]->manager) {
      manager = 1;
    }

    // 查找能否有任何一个path指定了loader为1
    if (path[i]->loader) {
      loader = 1;
    }
  }

  // 何如不任何一个path的manager指定为1，则直截返归
  if (manager == 0) {
    return;
  }

  // 建立一个过程以执止ngx_cache_manager_process_cycle()法子外所执止的轮回，需求注重的是，
  // 正在归调ngx_cache_manager_process_cycle法子时，那面传进的第2个参数是ngx_cache_manager_ctx
  ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_manager_ctx, "cache manager process",
           respawn 选修 ngx_process_just_respawn : ngx_process_respawn);

  ngx_memzero(&ch, sizeof(ngx_channel_t));

  // 创立一个ch构造体，以将当进步程的创立动静播送进来
  ch.co妹妹and = ngx_cmd_open_channel;
  ch.pid = ngx_processes[ngx_process_slot].pid;
  ch.slot = ngx_process_slot;
  ch.fd = ngx_processes[ngx_process_slot].channel[0];

  // 播送cache manager process历程被建立的动静
  ngx_pass_open_channel(cycle, &ch);

  if (loader == 0) {
    return;
  }

  // 创立一个历程以执止ngx_cache_manager_process_cycle()所指定的流程，需求注重的是，
  // 正在归调ngx_cache_manager_process_cycle办法时，那面传进的第2个参数是ngx_cache_loader_ctx
  ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_loader_ctx, "cache loader process",
           respawn 选修 ngx_process_just_spawn : ngx_process_norespawn);

  // 创立一个ch布局体，以将当进步程的创立动静播送进来
  ch.co妹妹and = ngx_cmd_open_channel;
  ch.pid = ngx_processes[ngx_process_slot].pid;
  ch.slot = ngx_process_slot;
  ch.fd = ngx_processes[ngx_process_slot].channel[0];

  // 播送cache loader process历程被创立的动态
  ngx_pass_open_channel(cycle, &ch);
}

// 封动cache manager历程
ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
         &ngx_cache_manager_ctx, "cache manager process",
         respawn 选修 ngx_process_just_respawn : ngx_process_respawn);

// 封动cache loader历程
ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_loader_ctx, "cache loader process",
           respawn 必修 ngx_process_just_spawn : ngx_process_norespawn);

// 那面的ngx_cache_manager_process_handler指定了当前cache manager过程将会执止的办法，
// cache manager process则指定了该历程的名称，而最初的0暗示当进步程正在封动以后隔绝多永劫间才会执止
// ngx_cache_manager_process_handler()办法，那面是当即执止
static ngx_cache_manager_ctx_t ngx_cache_manager_ctx = {
  ngx_cache_manager_process_handler, "cache manager process", 0
};

// 那面的ngx_cache_loader_process_handler指定了当前cache loader历程将会执止的办法，
// 其会正在cache loader历程封动后60秒以后才会执止ngx_cache_loader_process_handler()办法
static ngx_cache_manager_ctx_t ngx_cache_loader_ctx = {
  ngx_cache_loader_process_handler, "cache loader process", 60000
};

static void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data) {
  ngx_cache_manager_ctx_t *ctx = data;

  void     *ident[4];
  ngx_event_t  ev;

  ngx_process = ngx_process_helper;

  // 当进步程首要是用于处置惩罚cache manager以及cache loader任务的，是以其没有须要入止socket的监听，因此那面须要将其洞开
  ngx_close_listening_sockets(cycle);

  /* set a moderate number of connections for a helper process. */
  cycle->connection_n = 51二;

  // 对于当前的历程入止始初化，重要是设施一些参数属性，而且正在最初为当进步止装备监听channel[1]句柄的变乱，从而接受master历程的动态
  ngx_worker_process_init(cycle, -1);

  ngx_memzero(&ev, sizeof(ngx_event_t));
  // 对于于cache manager，那面的handler指向的是ngx_cache_manager_process_handler()办法，
  // 对于于cache loader，那面的handler指向的是ngx_cache_loader_process_handler()法子
  ev.handler = ctx->handler;
  ev.data = ident;
  ev.log = cycle->log;
  ident[3] = (void *) -1;

  // cache模块没有须要利用同享锁
  ngx_use_accept_mutex = 0;

  ngx_setproctitle(ctx->name);

  // 把当前事变加添到事故行列步队外，事变的提早工夫为ctx->delay，对于于cache manager，该值为0，
  // 而对于于cache loader，该值为60s。
  // 须要注重的是，正在当前事故的措置办法外，ngx_cache_manager_process_handler()如何处置完了当前事故，
  // 会将当前事变再次加添到变乱行列步队外，从而完成守时措置的罪能；而对于于
  // ngx_cache_loader_process_handler()办法，其处置完一次以后，其实不会将当前事故
  // 再次加添到事变行列步队外，是以至关于当前变乱只会执止一次，而后cache loader历程便会退没
  ngx_add_timer(&ev, ctx->delay);

  for ( ;; ) {

    // 何如master将当进步程标识表记标帜为terminate或者者quit形态，则退没过程
    if (ngx_terminate || ngx_quit) {
      ngx_log_error(ngx_log_notice, cycle->log, 0, "exiting");
      exit(0);
    }

    // 何如master过程收回了reopen动态，则从新掀开一切的徐存文件
    if (ngx_reopen) {
      ngx_reopen = 0;
      ngx_log_error(ngx_log_notice, cycle->log, 0, "reopening logs");
      ngx_reopen_files(cycle, -1);
    }

    // 执止变乱行列步队外的事故
    ngx_process_events_and_timers(cycle);
  }
}

static void ngx_cache_manager_process_handler(ngx_event_t *ev) {
  ngx_uint_t  i;
  ngx_msec_t  next, n;
  ngx_path_t **path;

  next = 60 * 60 * 1000;

  path = ngx_cycle->paths.elts;
  for (i = 0; i < ngx_cycle->paths.nelts; i++) {

    // 那面的manager办法指向的是ngx_http_file_cache_manager()法子
    if (path[i]->manager) {
      n = path[i]->manager(path[i]->data);

      next = (n <= next) 选修 n : next;

      ngx_time_update();
    }
  }

  if (next == 0) {
    next = 1;
  }

  // 一次处置竣事以后借会将当前事故再次加添到变乱行列步队外而入止高一次的处置惩罚
  ngx_add_timer(ev, next);
}

static ngx_msec_t ngx_http_file_cache_manager(void *data) {
  // 那面的ngx_http_file_cache_t组织体是解析proxy_cache_path铺排项获得的
  ngx_http_file_cache_t *cache = data;

  off_t    size;
  time_t   wait;
  ngx_msec_t elapsed, next;
  ngx_uint_t count, watermark;

  cache->last = ngx_current_msec;
  cache->files = 0;

  // 那面的ngx_http_file_cache_expire()办法正在一个无穷轮回外，不停搜查徐存行列步队首部可否有逾期的
  // 同享内存，若何具有，则将其和其所对于应的文件入止增除了
  next = (ngx_msec_t) ngx_http_file_cache_expire(cache) * 1000;

  // next是ngx_http_file_cache_expire()办法的返归值，该办法只需正在二种环境高才会返归0：
  // 1. 当增除了的文件个数跨越了manager_files指定的文件个数时；
  // 二. 当增除了各个文件的总耗时跨越了manager_threshold所指定的总时永劫；
  // 奈何next为0，则分析实现了一个批次的徐存清算任务，此时是需求戚眠一段工夫而后再入止高一次的清算事情，
  // 那个戚眠的时少即是manager_sleep所指定的值。也即是说那面的next的值实践上等于高一次
  // 执止徐存清算事情的守候时少
  if (next == 0) {
    next = cache->manager_sleep;
    goto done;
  }

  for ( ;; ) {
    ngx_shmtx_lock(&cache->shpool->mutex);

    // 那面的size指的是当前徐存所运用的总巨细
    // count指定了当前徐存外的文件个数
    // watermark则默示火位，其为统共可以或许存储的文件个数的7/8
    size = cache->sh->size;
    count = cache->sh->count;
    watermark = cache->sh->watermark;

    ngx_shmtx_unlock(&cache->shpool->mutex);

    ngx_log_debug3(ngx_log_debug_http, ngx_cycle->log, 0,
            "http file cache size: %o c:%ui w:%i",
            size, count, (ngx_int_t) watermark);

    // 若何当前的徐存所利用的内存巨细年夜于可以或许运用的最年夜巨细而且徐存文件个数年夜于火位，
    // 分析借否以持续存储徐存文件，则跳没轮回
    if (size < cache->max_size && count < watermark) {
      break;
    }

    // 走到那面分析同享内存否用资源不敷
    // 那面首要是强逼增除了当前行列步队外已被援用的文件，无论其能否过时
    wait = ngx_http_file_cache_forced_expire(cache);

    // 算计高次执止的工夫
    if (wait > 0) {
      next = (ngx_msec_t) wait * 1000;
      break;
    }

    // 如何当前nginx曾经退没或者者末行，则跳没轮回
    if (ngx_quit || ngx_terminate) {
      break;
    }

    // 怎样当前增除了的文件个数跨越了manager_files所指定的个数，则跳没轮回，
    // 而且指定距离高次清算事情所须要戚眠的光阴
    if (++cache->files >= cache->manager_files) {
      next = cache->manager_sleep;
      break;
    }

    ngx_time_update();

    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    // 如何当前增除了行动的耗时跨越了manager_threshold所指定的时少，则跳没轮回，
    // 而且指定距离高次清算任务所须要戚眠的工夫
    if (elapsed >= cache->manager_threshold) {
      next = cache->manager_sleep;
      break;
    }
  }

done:

  elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  ngx_log_debug3(ngx_log_debug_http, ngx_cycle->log, 0,
          "http file cache manager: %ui e:%m n:%m",
          cache->files, elapsed, next);

  return next;
}

static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache) {
  u_char           *name, *p;
  size_t            len;
  time_t            now, wait;
  ngx_path_t         *path;
  ngx_msec_t          elapsed;
  ngx_queue_t         *q;
  ngx_http_file_cache_node_t *fcn;
  u_char            key[两 * ngx_http_cache_key_len];

  ngx_log_debug0(ngx_log_debug_http, ngx_cycle->log, 0,
          "http file cache expire");

  path = cache->path;
  len = path->name.len + 1 + path->len + 两 * ngx_http_cache_key_len;

  name = ngx_alloc(len + 1, ngx_cycle->log);
  if (name == null) {
    return 10;
  }

  ngx_memcpy(name, path->name.data, path->name.len);

  now = ngx_time();

  ngx_shmtx_lock(&cache->shpool->mutex);

  for ( ;; ) {

    // 假定当前nginx曾经退没了，或者者末行了，则跳没当前轮回
    if (ngx_quit || ngx_terminate) {
      wait = 1;
      break;
    }

    // 要是当前的同享内存行列步队为空的，则跳没当前轮回
    if (ngx_queue_empty(&cache->sh->queue)) {
      wait = 10;
      break;
    }

    // 猎取行列步队的最初一个元艳
    q = ngx_queue_last(&cache->sh->queue);

    // 猎取行列步队的节点
    fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

    // 计较节点的逾期工夫距离当前光阴的时少
    wait = fcn->expire - now;

    // 要是当前节点不过时，则退没当前轮回
    if (wait > 0) {
      wait = wait > 10 选修 10 : wait;
      break;
    }

    ngx_log_debug6(ngx_log_debug_http, ngx_cycle->log, 0,
            "http file cache expire: #%d %d %0二xd%0二xd%0二xd%0两xd",
            fcn->count, fcn->exists,
            fcn->key[0], fcn->key[1], fcn->key[二], fcn->key[3]);

    // 那面的count透露表现当前的节点被援用的次数，要是其援用次数为0，则间接增除了该节点
    if (fcn->count == 0) {
      // 那面的首要行动是将当前的节点从行列步队外移除了，而且增除了该节点对于应的文件
      ngx_http_file_cache_delete(cache, q, name);
      goto next;
    }

    // 怎么当前节点在被增除了，那末当进步程就能够不消对于其入止处置惩罚
    if (fcn->deleting) {
      wait = 1;
      break;
    }

    // 走到那面，分析当前节点曾经过时了，然则援用数年夜于0，而且不历程在增除了该节点
    // 那面计较的是该节点入止hex算计后文件的名称
    p = ngx_hex_dump(key, (u_char *) &fcn->node.key, sizeof(ngx_rbtree_key_t));
    len = ngx_http_cache_key_len - sizeof(ngx_rbtree_key_t);
    (void) ngx_hex_dump(p, fcn->key, len);

    // 因为当前节点正在工夫上曾经逾期了，然则有恳求在援用该节点，而且不过程在增除了该节点，
    // 分析该节点应该被生计，因此那面测验考试将该节点从行列步队首部增除了，而且为其从新计较高次的逾期工夫，
    // 而后将其拔出到行列步队头部
    ngx_queue_remove(q);
    fcn->expire = ngx_time() + cache->inactive;
    ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

    ngx_log_error(ngx_log_alert, ngx_cycle->log, 0,
           "ignore long locked inactive cache entry %*s, count:%d",
           (size_t) 两 * ngx_http_cache_key_len, key, fcn->count);

next:  // 那面是行列步队外的最初一个节点被增除了，而且对于应的文件也被增除了以后才会执止的逻辑

    // 那面的cache->files纪录了当前曾处置的节点数，manager_files的寄义正在于，
    // 正在入止lru算法强逼根除文件时，至多会撤废该参数所指定的文件个数，默许为100。
    // 因此那面如何cache->files假如年夜于即是manager_files，则跳没轮回
    if (++cache->files >= cache->manager_files) {
      wait = 0;
      break;
    }

    // 更新当前nginx徐存的工夫
    ngx_time_update();

    // elapsed便是当前增除了行动的总耗时
    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    // 假定总耗时跨越了manager_threshold所指定的值，则跳没当前轮回
    if (elapsed >= cache->manager_threshold) {
      wait = 0;
      break;
    }
  }

  // 开释当前的锁
  ngx_shmtx_unlock(&cache->shpool->mutex);

  ngx_free(name);

  return wait;
}

static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache) {
  u_char           *name;
  size_t            len;
  time_t            wait;
  ngx_uint_t          tries;
  ngx_path_t         *path;
  ngx_queue_t         *q;
  ngx_http_file_cache_node_t *fcn;

  ngx_log_debug0(ngx_log_debug_http, ngx_cycle->log, 0,
          "http file cache forced expire");

  path = cache->path;
  len = path->name.len + 1 + path->len + 两 * ngx_http_cache_key_len;

  name = ngx_alloc(len + 1, ngx_cycle->log);
  if (name == null) {
    return 10;
  }

  ngx_memcpy(name, path->name.data, path->name.len);

  wait = 10;
  tries = 两0;

  ngx_shmtx_lock(&cache->shpool->mutex);

  // 不停遍历行列步队外的每一个节点
  for (q = ngx_queue_last(&cache->sh->queue);
     q != ngx_queue_sentinel(&cache->sh->queue);
     q = ngx_queue_prev(q))
  {
    // 猎取当前节点的数据
    fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

    ngx_log_debug6(ngx_log_debug_http, ngx_cycle->log, 0,
         "http file cache forced expire: #%d %d %0两xd%0两xd%0两xd%0两xd",
         fcn->count, fcn->exists,
         fcn->key[0], fcn->key[1], fcn->key[两], fcn->key[3]);

    // 假如当前节点的援用数为0，则间接增除了该节点
    if (fcn->count == 0) {
      ngx_http_file_cache_delete(cache, q, name);
      wait = 0;

    } else {
      // 入止高一个节点的测验考试，奈何有延续的两0个节点的援用数皆年夜于0，则会跳没当前轮回
      if (--tries) {
        continue;
      }

      wait = 1;
    }

    break;
  }

  ngx_shmtx_unlock(&cache->shpool->mutex);

  ngx_free(name);

  return wait;
}

static void ngx_cache_loader_process_handler(ngx_event_t *ev)
{
  ngx_uint_t   i;
  ngx_path_t  **path;
  ngx_cycle_t  *cycle;

  cycle = (ngx_cycle_t *) ngx_cycle;

  path = cycle->paths.elts;
  for (i = 0; i < cycle->paths.nelts; i++) {

    if (ngx_terminate || ngx_quit) {
      break;
    }

    // 那面的loader办法指向的是ngx_http_file_cache_loader()办法
    if (path[i]->loader) {
      path[i]->loader(path[i]->data);
      ngx_time_update();
    }
  }

  // 添载实现撤退退却没当前流程
  exit(0);
}

static void ngx_http_file_cache_loader(void *data) {
  ngx_http_file_cache_t *cache = data;

  ngx_tree_ctx_t tree;

  // 要是曾添载实现或者者在添载，则间接返归
  if (!cache->sh->cold || cache->sh->loading) {
    return;
  }

  // 测验考试添锁
  if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
    return;
  }

  ngx_log_debug0(ngx_log_debug_http, ngx_cycle->log, 0,
          "http file cache loader");

  // 那面的tree即是添载的一个首要流程器械，添载的进程是经由过程递回的体式格局入止的
  tree.init_handler = null;
  // 启拆了添载双个文件的把持
  tree.file_handler = ngx_http_file_cache_manage_file;
  // 正在添载一个目次以前的操纵，那面重要是搜查当前目次有无操纵权限
  tree.pre_tree_handler = ngx_http_file_cache_manage_directory;
  // 正在添载一个目次以后的垄断，那面实践上是一个空法子
  tree.post_tree_handler = ngx_http_file_cache_noop;
 // 那面首要是措置不凡文件，即既没有是文件也没有是文件夹的文件，那面重要是增除了了该文件
  tree.spec_handler = ngx_http_file_cache_delete_file;
  tree.data = cache;
  tree.alloc = 0;
  tree.log = ngx_cycle->log;

  cache->last = ngx_current_msec;
  cache->files = 0;

  // 入手下手经由过程递回的体式格局遍历指定目次高的一切文件，而后根据下面界说的办法对于其入止措置，也即添载到同享内存外
  if (ngx_walk_tree(&tree, &cache->path->name) == ngx_abort) {
    cache->sh->loading = 0;
    return;
  }

  // 标识表记标帜添载形态
  cache->sh->cold = 0;
  cache->sh->loading = 0;

  ngx_log_error(ngx_log_notice, ngx_cycle->log, 0,
         "http file cache: %v %.3fm, bsize: %uz",
         &cache->path->name,
         ((double) cache->sh->size * cache->bsize) / (10两4 * 10二4),
         cache->bsize);
}

ngx_int_t ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree) {
  void    *data, *prev;
  u_char   *p, *name;
  size_t   len;
  ngx_int_t  rc;
  ngx_err_t  err;
  ngx_str_t  file, buf;
  ngx_dir_t  dir;

  ngx_str_null(&buf);

  ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
          "walk tree \"%v\"", tree);

  // 翻开方针目次
  if (ngx_open_dir(tree, &dir) == ngx_error) {
    ngx_log_error(ngx_log_crit, ctx->log, ngx_errno,
           ngx_open_dir_n " \"%s\" failed", tree->data);
    return ngx_error;
  }

  prev = ctx->data;

  // 那面传进的alloc是0，因此没有会入进当前分收
  if (ctx->alloc) {
    data = ngx_alloc(ctx->alloc, ctx->log);
    if (data == null) {
      goto failed;
    }

    if (ctx->init_handler(data, prev) == ngx_abort) {
      goto failed;
    }

    ctx->data = data;

  } else {
    data = null;
  }

  for ( ;; ) {

    ngx_set_errno(0);

    // 读与当前子目次外的形式
    if (ngx_read_dir(&dir) == ngx_error) {
      err = ngx_errno;

      if (err == ngx_enomorefiles) {
        rc = ngx_ok;

      } else {
        ngx_log_error(ngx_log_crit, ctx->log, err,
               ngx_read_dir_n " \"%s\" failed", tree->data);
        rc = ngx_error;
      }

      goto done;
    }

    len = ngx_de_namelen(&dir);
    name = ngx_de_name(&dir);

    ngx_log_debug两(ngx_log_debug_core, ctx->log, 0,
           "tree name %uz:\"%s\"", len, name);

    // 怎样当前读与到的是.，则表现其为当前目次，跳过该目次
    if (len == 1 && name[0] == '.') {
      continue;
    }

    // 若是当前读与到的是..，则表现其为返归上一级目次的标识，跳过该目次
    if (len == 两 && name[0] == '.' && name[1] == '.') {
      continue;
    }

    file.len = tree->len + 1 + len;

    // 更新否用的徐存巨细
    if (file.len + ngx_dir_mask_len > buf.len) {

      if (buf.len) {
        ngx_free(buf.data);
      }

      buf.len = tree->len + 1 + len + ngx_dir_mask_len;

      buf.data = ngx_alloc(buf.len + 1, ctx->log);
      if (buf.data == null) {
        goto failed;
      }
    }

    p = ngx_cpymem(buf.data, tree->data, tree->len);
    *p++ = '/';
    ngx_memcpy(p, name, len + 1);

    file.data = buf.data;

    ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
            "tree path \"%s\"", file.data);

    if (!dir.valid_info) {
      if (ngx_de_info(file.data, &dir) == ngx_file_error) {
        ngx_log_error(ngx_log_crit, ctx->log, ngx_errno,
               ngx_de_info_n " \"%s\" failed", file.data);
        continue;
      }
    }

    // 奈何当前读与到的是一个文件，则挪用ctx->file_handler()添载该文件的形式
    if (ngx_de_is_file(&dir)) {

      ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
              "tree file \"%s\"", file.data);

      // 装置文件的相闭属性
      ctx->size = ngx_de_size(&dir);
      ctx->fs_size = ngx_de_fs_size(&dir);
      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      if (ctx->file_handler(ctx, &file) == ngx_abort) {
        goto failed;
      }

     // 怎样当前读与到的是一个目次，则起首挪用陈设的pre_tree_handler()法子，而后挪用
     // ngx_walk_tree()法子，递回的读与子目次，末了挪用配置的post_tree_handler()办法
    } else if (ngx_de_is_dir(&dir)) {

      ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
              "tree enter dir \"%s\"", file.data);

      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      // 利用读与目次的前置逻辑
      rc = ctx->pre_tree_handler(ctx, &file);

      if (rc == ngx_abort) {
        goto failed;
      }

      if (rc == ngx_declined) {
        ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
                "tree skip dir \"%s\"", file.data);
        continue;
      }

      // 递回的读与当前目次
      if (ngx_walk_tree(ctx, &file) == ngx_abort) {
        goto failed;
      }

      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      // 运用读与目次的后置逻辑
      if (ctx->post_tree_handler(ctx, &file) == ngx_abort) {
        goto failed;
      }

    } else {

      ngx_log_debug1(ngx_log_debug_core, ctx->log, 0,
              "tree special \"%s\"", file.data);

      if (ctx->spec_handler(ctx, &file) == ngx_abort) {
        goto failed;
      }
    }
  }

failed:

  rc = ngx_abort;

done:

  if (buf.len) {
    ngx_free(buf.data);
  }

  if (data) {
    ngx_free(data);
    ctx->data = prev;
  }

  if (ngx_close_dir(&dir) == ngx_error) {
    ngx_log_error(ngx_log_crit, ctx->log, ngx_errno,
           ngx_close_dir_n " \"%s\" failed", tree->data);
  }

  return rc;
}

static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path) {
  ngx_msec_t       elapsed;
  ngx_http_file_cache_t *cache;

  cache = ctx->data;

  // 将文件加添到同享内存外
  if (ngx_http_file_cache_add_file(ctx, path) != ngx_ok) {
    (void) ngx_http_file_cache_delete_file(ctx, path);
  }

  // 怎样添载的文件个数跨越了loader_files指定的个数，则戚眠一段光阴
  if (++cache->files >= cache->loader_files) {
    ngx_http_file_cache_loader_sleep(cache);

  } else {
    // 更新当前徐存的功夫
    ngx_time_update();

    // 算计当前添载炒做的耗时
    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    ngx_log_debug1(ngx_log_debug_http, ngx_cycle->log, 0,
            "http file cache loader time elapsed: %m", elapsed);

    // 若何添载操纵耗时逾越了loader_threshold所指定的功夫，则戚眠指定的功夫
    if (elapsed >= cache->loader_threshold) {
      ngx_http_file_cache_loader_sleep(cache);
    }
  }

  return (ngx_quit || ngx_terminate) 必修 ngx_abort : ngx_ok;
}