One Level Up Top Level

src/core/ngx_slab.c - nginx-1.7.10

Global variables defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */

  7. #include <ngx_config.h>
  8. #include <ngx_core.h>


  11. ‌#define NGX_SLAB_PAGE_MASK   3
  12. ‌#define NGX_SLAB_PAGE        0
  13. ‌#define NGX_SLAB_BIG         1
  14. ‌#define NGX_SLAB_EXACT       2
  15. ‌#define NGX_SLAB_SMALL       3

  17. #if (NGX_PTR_SIZE == 4)

  19. ‌#define NGX_SLAB_PAGE_FREE   0
  20. ‌#define NGX_SLAB_PAGE_BUSY   0xffffffff
  21. ‌#define NGX_SLAB_PAGE_START  0x80000000

  23. ‌#define NGX_SLAB_SHIFT_MASK  0x0000000f
  24. ‌#define NGX_SLAB_MAP_MASK    0xffff0000
  25. ‌#define NGX_SLAB_MAP_SHIFT   16

  27. ‌#define NGX_SLAB_BUSY        0xffffffff

  29. #else /* (NGX_PTR_SIZE == 8) */

  31. ‌#define NGX_SLAB_PAGE_FREE   0
  32. ‌#define NGX_SLAB_PAGE_BUSY   0xffffffffffffffff
  33. ‌#define NGX_SLAB_PAGE_START  0x8000000000000000

  35. ‌#define NGX_SLAB_SHIFT_MASK  0x000000000000000f
  36. ‌#define NGX_SLAB_MAP_MASK    0xffffffff00000000
  37. ‌#define NGX_SLAB_MAP_SHIFT   32

  39. ‌#define NGX_SLAB_BUSY        0xffffffffffffffff

  41. #endif


  44. #if (NGX_DEBUG_MALLOC)

  46. ‌#define ngx_slab_junk(p, size)     ngx_memset(p, 0xA5, size)

  48. #elif (NGX_HAVE_DEBUG_MALLOC)

  50. ‌#define ngx_slab_junk(p, size)                                                \
  51.     if (ngx_debug_malloc)          ngx_memset(p, 0xA5, size)

  53. #else

  55. ‌#define ngx_slab_junk(p, size)

  57. #endif

  59. static ngx_slab_page_t *ngx_slab_alloc_pages(ngx_slab_pool_t *pool,
  60.     ngx_uint_t pages);
  61. static void ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page,
  62.     ngx_uint_t pages);
  63. static void ngx_slab_error(ngx_slab_pool_t *pool, ngx_uint_t level,
  64.     char *text);


  67. ‌static ngx_uint_t  ngx_slab_max_size;
  68. ‌static ngx_uint_t  ngx_slab_exact_size;
  69. ‌static ngx_uint_t  ngx_slab_exact_shift;


  72. void
  73. ‌ngx_slab_init(ngx_slab_pool_t *pool)
  74. {
  75.     u_char           *p;
  76.     size_t            size;
  77.     ngx_int_t         m;
  78.     ngx_uint_t        i, n, pages;
  79.     ngx_slab_page_t  *slots;

  81.     /* STUB */
  82.     if (ngx_slab_max_size == 0) {
  83.         ngx_slab_max_size = ngx_pagesize / 2;
  84.         ngx_slab_exact_size = ngx_pagesize / (8 * sizeof(uintptr_t));
  85.         for (n = ngx_slab_exact_size; n >>= 1; ngx_slab_exact_shift++) {
  86.             /* void */
  87.         }
  88.     }
  89.     /**/

  91.     pool->min_size = 1 << pool->min_shift;

  93.     p = (u_char *) pool + sizeof(ngx_slab_pool_t);
  94.     size = pool->end - p;

  96.     ngx_slab_junk(p, size);

  98.     slots = (ngx_slab_page_t *) p;
  99.     n = ngx_pagesize_shift - pool->min_shift;

  101.     for (i = 0; i < n; i++) {
  102.         slots[i].slab = 0;
  103.         slots[i].next = &slots[i];
  104.         slots[i].prev = 0;
  105.     }

  107.     p += n * sizeof(ngx_slab_page_t);

  109.     pages = (ngx_uint_t) (size / (ngx_pagesize + sizeof(ngx_slab_page_t)));

  111.     ngx_memzero(p, pages * sizeof(ngx_slab_page_t));

  113.     pool->pages = (ngx_slab_page_t *) p;

  115.     pool->free.prev = 0;
  116.     pool->free.next = (ngx_slab_page_t *) p;

  118.     pool->pages->slab = pages;
  119.     pool->pages->next = &pool->free;
  120.     pool->pages->prev = (uintptr_t) &pool->free;

  122.     pool->start = (u_char *)
  123.                   ngx_align_ptr((uintptr_t) p + pages * sizeof(ngx_slab_page_t),
  124.                                  ngx_pagesize);

  126.     m = pages - (pool->end - pool->start) / ngx_pagesize;
  127.     if (m > 0) {
  128.         pages -= m;
  129.         pool->pages->slab = pages;
  130.     }

  132.     pool->last = pool->pages + pages;

  134.     pool->log_nomem = 1;
  135.     pool->log_ctx = &pool->zero;
  136.     pool->zero = '\0';
  137. }


  140. void *
  141. ‌ngx_slab_alloc(ngx_slab_pool_t *pool, size_t size)
  142. {
  143.     void  *p;

  145.     ngx_shmtx_lock(&pool->mutex);

  147.     p = ngx_slab_alloc_locked(pool, size);

  149.     ngx_shmtx_unlock(&pool->mutex);

  151.     return p;
  152. }


  155. void *
  156. ‌ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size)
  157. {
  158.     size_t            s;
  159.     uintptr_t         p, n, m, mask, *bitmap;
  160.     ngx_uint_t        i, slot, shift, map;
  161.     ngx_slab_page_t  *page, *prev, *slots;

  163.     if (size > ngx_slab_max_size) {

  165.         ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
  166.                        "slab alloc: %uz", size);

  168.         page = ngx_slab_alloc_pages(pool, (size >> ngx_pagesize_shift)
  169.                                           + ((size % ngx_pagesize) ? 1 : 0));
  170.         if (page) {
  171.             p = (page - pool->pages) << ngx_pagesize_shift;
  172.             p += (uintptr_t) pool->start;

  174.         } else {
  175.             p = 0;
  176.         }

  178.         goto done;
  179.     }

  181.     if (size > pool->min_size) {
  182.         shift = 1;
  183.         for (s = size - 1; s >>= 1; shift++) { /* void */ }
  184.         slot = shift - pool->min_shift;

  186.     } else {
  187.         size = pool->min_size;
  188.         shift = pool->min_shift;
  189.         slot = 0;
  190.     }

  192.     ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
  193.                    "slab alloc: %uz slot: %ui", size, slot);

  195.     slots = (ngx_slab_page_t *) ((u_char *) pool + sizeof(ngx_slab_pool_t));
  196.     page = slots[slot].next;

  198.     if (page->next != page) {

  200.         if (shift < ngx_slab_exact_shift) {

  202.             do {
  203.                 p = (page - pool->pages) << ngx_pagesize_shift;
  204.                 bitmap = (uintptr_t *) (pool->start + p);

  206.                 map = (1 << (ngx_pagesize_shift - shift))
  207.                           / (sizeof(uintptr_t) * 8);

  209.                 for (n = 0; n < map; n++) {

  211.                     if (bitmap[n] != NGX_SLAB_BUSY) {

  213.                         for (m = 1, i = 0; m; m <<= 1, i++) {
  214.                             if ((bitmap[n] & m)) {
  215.                                 continue;
  216.                             }

  218.                             bitmap[n] |= m;

  220.                             i = ((n * sizeof(uintptr_t) * 8) << shift)
  221.                                 + (i << shift);

  223.                             if (bitmap[n] == NGX_SLAB_BUSY) {
  224.                                 for (n = n + 1; n < map; n++) {
  225.                                      if (bitmap[n] != NGX_SLAB_BUSY) {
  226.                                          p = (uintptr_t) bitmap + i;

  228.                                          goto done;
  229.                                      }
  230.                                 }

  232.                                 prev = (ngx_slab_page_t *)
  233.                                             (page->prev & ~NGX_SLAB_PAGE_MASK);
  234.                                 prev->next = page->next;
  235.                                 page->next->prev = page->prev;

  237.                                 page->next = NULL;
  238.                                 page->prev = NGX_SLAB_SMALL;
  239.                             }

  241.                             p = (uintptr_t) bitmap + i;

  243.                             goto done;
  244.                         }
  245.                     }
  246.                 }

  248.                 page = page->next;

  250.             } while (page);

  252.         } else if (shift == ngx_slab_exact_shift) {

  254.             do {
  255.                 if (page->slab != NGX_SLAB_BUSY) {

  257.                     for (m = 1, i = 0; m; m <<= 1, i++) {
  258.                         if ((page->slab & m)) {
  259.                             continue;
  260.                         }

  262.                         page->slab |= m;

  264.                         if (page->slab == NGX_SLAB_BUSY) {
  265.                             prev = (ngx_slab_page_t *)
  266.                                             (page->prev & ~NGX_SLAB_PAGE_MASK);
  267.                             prev->next = page->next;
  268.                             page->next->prev = page->prev;

  270.                             page->next = NULL;
  271.                             page->prev = NGX_SLAB_EXACT;
  272.                         }

  274.                         p = (page - pool->pages) << ngx_pagesize_shift;
  275.                         p += i << shift;
  276.                         p += (uintptr_t) pool->start;

  278.                         goto done;
  279.                     }
  280.                 }

  282.                 page = page->next;

  284.             } while (page);

  286.         } else { /* shift > ngx_slab_exact_shift */

  288.             n = ngx_pagesize_shift - (page->slab & NGX_SLAB_SHIFT_MASK);
  289.             n = 1 << n;
  290.             n = ((uintptr_t) 1 << n) - 1;
  291.             mask = n << NGX_SLAB_MAP_SHIFT;

  293.             do {
  294.                 if ((page->slab & NGX_SLAB_MAP_MASK) != mask) {

  296.                     for (m = (uintptr_t) 1 << NGX_SLAB_MAP_SHIFT, i = 0;
  297.                          m & mask;
  298.                          m <<= 1, i++)
  299.                     {
  300.                         if ((page->slab & m)) {
  301.                             continue;
  302.                         }

  304.                         page->slab |= m;

  306.                         if ((page->slab & NGX_SLAB_MAP_MASK) == mask) {
  307.                             prev = (ngx_slab_page_t *)
  308.                                             (page->prev & ~NGX_SLAB_PAGE_MASK);
  309.                             prev->next = page->next;
  310.                             page->next->prev = page->prev;

  312.                             page->next = NULL;
  313.                             page->prev = NGX_SLAB_BIG;
  314.                         }

  316.                         p = (page - pool->pages) << ngx_pagesize_shift;
  317.                         p += i << shift;
  318.                         p += (uintptr_t) pool->start;

  320.                         goto done;
  321.                     }
  322.                 }

  324.                 page = page->next;

  326.             } while (page);
  327.         }
  328.     }

  330.     page = ngx_slab_alloc_pages(pool, 1);

  332.     if (page) {
  333.         if (shift < ngx_slab_exact_shift) {
  334.             p = (page - pool->pages) << ngx_pagesize_shift;
  335.             bitmap = (uintptr_t *) (pool->start + p);

  337.             s = 1 << shift;
  338.             n = (1 << (ngx_pagesize_shift - shift)) / 8 / s;

  340.             if (n == 0) {
  341.                 n = 1;
  342.             }

  344.             bitmap[0] = (2 << n) - 1;

  346.             map = (1 << (ngx_pagesize_shift - shift)) / (sizeof(uintptr_t) * 8);

  348.             for (i = 1; i < map; i++) {
  349.                 bitmap[i] = 0;
  350.             }

  352.             page->slab = shift;
  353.             page->next = &slots[slot];
  354.             page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;

  356.             slots[slot].next = page;

  358.             p = ((page - pool->pages) << ngx_pagesize_shift) + s * n;
  359.             p += (uintptr_t) pool->start;

  361.             goto done;

  363.         } else if (shift == ngx_slab_exact_shift) {

  365.             page->slab = 1;
  366.             page->next = &slots[slot];
  367.             page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;

  369.             slots[slot].next = page;

  371.             p = (page - pool->pages) << ngx_pagesize_shift;
  372.             p += (uintptr_t) pool->start;

  374.             goto done;

  376.         } else { /* shift > ngx_slab_exact_shift */

  378.             page->slab = ((uintptr_t) 1 << NGX_SLAB_MAP_SHIFT) | shift;
  379.             page->next = &slots[slot];
  380.             page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;

  382.             slots[slot].next = page;

  384.             p = (page - pool->pages) << ngx_pagesize_shift;
  385.             p += (uintptr_t) pool->start;

  387.             goto done;
  388.         }
  389.     }

  391.     p = 0;

  393. done:

  395.     ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab alloc: %p", p);

  397.     return (void *) p;
  398. }


  401. void *
  402. ‌ngx_slab_calloc(ngx_slab_pool_t *pool, size_t size)
  403. {
  404.     void  *p;

  406.     ngx_shmtx_lock(&pool->mutex);

  408.     p = ngx_slab_calloc_locked(pool, size);

  410.     ngx_shmtx_unlock(&pool->mutex);

  412.     return p;
  413. }


  416. void *
  417. ‌ngx_slab_calloc_locked(ngx_slab_pool_t *pool, size_t size)
  418. {
  419.     void  *p;

  421.     p = ngx_slab_alloc_locked(pool, size);
  422.     if (p) {
  423.         ngx_memzero(p, size);
  424.     }

  426.     return p;
  427. }


  430. void
  431. ‌ngx_slab_free(ngx_slab_pool_t *pool, void *p)
  432. {
  433.     ngx_shmtx_lock(&pool->mutex);

  435.     ngx_slab_free_locked(pool, p);

  437.     ngx_shmtx_unlock(&pool->mutex);
  438. }


  441. void
  442. ‌ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p)
  443. {
  444.     size_t            size;
  445.     uintptr_t         slab, m, *bitmap;
  446.     ngx_uint_t        n, type, slot, shift, map;
  447.     ngx_slab_page_t  *slots, *page;

  449.     ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab free: %p", p);

  451.     if ((u_char *) p < pool->start || (u_char *) p > pool->end) {
  452.         ngx_slab_error(pool, NGX_LOG_ALERT, "ngx_slab_free(): outside of pool");
  453.         goto fail;
  454.     }

  456.     n = ((u_char *) p - pool->start) >> ngx_pagesize_shift;
  457.     page = &pool->pages[n];
  458.     slab = page->slab;
  459.     type = page->prev & NGX_SLAB_PAGE_MASK;

  461.     switch (type) {

  463.     case NGX_SLAB_SMALL:

  465.         shift = slab & NGX_SLAB_SHIFT_MASK;
  466.         size = 1 << shift;

  468.         if ((uintptr_t) p & (size - 1)) {
  469.             goto wrong_chunk;
  470.         }

  472.         n = ((uintptr_t) p & (ngx_pagesize - 1)) >> shift;
  473.         m = (uintptr_t) 1 << (n & (sizeof(uintptr_t) * 8 - 1));
  474.         n /= (sizeof(uintptr_t) * 8);
  475.         bitmap = (uintptr_t *)
  476.                              ((uintptr_t) p & ~((uintptr_t) ngx_pagesize - 1));

  478.         if (bitmap[n] & m) {

  480.             if (page->next == NULL) {
  481.                 slots = (ngx_slab_page_t *)
  482.                                    ((u_char *) pool + sizeof(ngx_slab_pool_t));
  483.                 slot = shift - pool->min_shift;

  485.                 page->next = slots[slot].next;
  486.                 slots[slot].next = page;

  488.                 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;
  489.                 page->next->prev = (uintptr_t) page | NGX_SLAB_SMALL;
  490.             }

  492.             bitmap[n] &= ~m;

  494.             n = (1 << (ngx_pagesize_shift - shift)) / 8 / (1 << shift);

  496.             if (n == 0) {
  497.                 n = 1;
  498.             }

  500.             if (bitmap[0] & ~(((uintptr_t) 1 << n) - 1)) {
  501.                 goto done;
  502.             }

  504.             map = (1 << (ngx_pagesize_shift - shift)) / (sizeof(uintptr_t) * 8);

  506.             for (n = 1; n < map; n++) {
  507.                 if (bitmap[n]) {
  508.                     goto done;
  509.                 }
  510.             }

  512.             ngx_slab_free_pages(pool, page, 1);

  514.             goto done;
  515.         }

  517.         goto chunk_already_free;

  519.     case NGX_SLAB_EXACT:

  521.         m = (uintptr_t) 1 <<
  522.                 (((uintptr_t) p & (ngx_pagesize - 1)) >> ngx_slab_exact_shift);
  523.         size = ngx_slab_exact_size;

  525.         if ((uintptr_t) p & (size - 1)) {
  526.             goto wrong_chunk;
  527.         }

  529.         if (slab & m) {
  530.             if (slab == NGX_SLAB_BUSY) {
  531.                 slots = (ngx_slab_page_t *)
  532.                                    ((u_char *) pool + sizeof(ngx_slab_pool_t));
  533.                 slot = ngx_slab_exact_shift - pool->min_shift;

  535.                 page->next = slots[slot].next;
  536.                 slots[slot].next = page;

  538.                 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;
  539.                 page->next->prev = (uintptr_t) page | NGX_SLAB_EXACT;
  540.             }

  542.             page->slab &= ~m;

  544.             if (page->slab) {
  545.                 goto done;
  546.             }

  548.             ngx_slab_free_pages(pool, page, 1);

  550.             goto done;
  551.         }

  553.         goto chunk_already_free;

  555.     case NGX_SLAB_BIG:

  557.         shift = slab & NGX_SLAB_SHIFT_MASK;
  558.         size = 1 << shift;

  560.         if ((uintptr_t) p & (size - 1)) {
  561.             goto wrong_chunk;
  562.         }

  564.         m = (uintptr_t) 1 << ((((uintptr_t) p & (ngx_pagesize - 1)) >> shift)
  565.                               + NGX_SLAB_MAP_SHIFT);

  567.         if (slab & m) {

  569.             if (page->next == NULL) {
  570.                 slots = (ngx_slab_page_t *)
  571.                                    ((u_char *) pool + sizeof(ngx_slab_pool_t));
  572.                 slot = shift - pool->min_shift;

  574.                 page->next = slots[slot].next;
  575.                 slots[slot].next = page;

  577.                 page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;
  578.                 page->next->prev = (uintptr_t) page | NGX_SLAB_BIG;
  579.             }

  581.             page->slab &= ~m;

  583.             if (page->slab & NGX_SLAB_MAP_MASK) {
  584.                 goto done;
  585.             }

  587.             ngx_slab_free_pages(pool, page, 1);

  589.             goto done;
  590.         }

  592.         goto chunk_already_free;

  594.     case NGX_SLAB_PAGE:

  596.         if ((uintptr_t) p & (ngx_pagesize - 1)) {
  597.             goto wrong_chunk;
  598.         }

  600.         if (slab == NGX_SLAB_PAGE_FREE) {
  601.             ngx_slab_error(pool, NGX_LOG_ALERT,
  602.                            "ngx_slab_free(): page is already free");
  603.             goto fail;
  604.         }

  606.         if (slab == NGX_SLAB_PAGE_BUSY) {
  607.             ngx_slab_error(pool, NGX_LOG_ALERT,
  608.                            "ngx_slab_free(): pointer to wrong page");
  609.             goto fail;
  610.         }

  612.         n = ((u_char *) p - pool->start) >> ngx_pagesize_shift;
  613.         size = slab & ~NGX_SLAB_PAGE_START;

  615.         ngx_slab_free_pages(pool, &pool->pages[n], size);

  617.         ngx_slab_junk(p, size << ngx_pagesize_shift);

  619.         return;
  620.     }

  622.     /* not reached */

  624.     return;

  626. done:

  628.     ngx_slab_junk(p, size);

  630.     return;

  632. wrong_chunk:

  634.     ngx_slab_error(pool, NGX_LOG_ALERT,
  635.                    "ngx_slab_free(): pointer to wrong chunk");

  637.     goto fail;

  639. chunk_already_free:

  641.     ngx_slab_error(pool, NGX_LOG_ALERT,
  642.                    "ngx_slab_free(): chunk is already free");

  644. fail:

  646.     return;
  647. }


  650. static ngx_slab_page_t *
  651. ‌ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_uint_t pages)
  652. {
  653.     ngx_slab_page_t  *page, *p;

  655.     for (page = pool->free.next; page != &pool->free; page = page->next) {

  657.         if (page->slab >= pages) {

  659.             if (page->slab > pages) {
  660.                 page[page->slab - 1].prev = (uintptr_t) &page[pages];

  662.                 page[pages].slab = page->slab - pages;
  663.                 page[pages].next = page->next;
  664.                 page[pages].prev = page->prev;

  666.                 p = (ngx_slab_page_t *) page->prev;
  667.                 p->next = &page[pages];
  668.                 page->next->prev = (uintptr_t) &page[pages];

  670.             } else {
  671.                 p = (ngx_slab_page_t *) page->prev;
  672.                 p->next = page->next;
  673.                 page->next->prev = page->prev;
  674.             }

  676.             page->slab = pages | NGX_SLAB_PAGE_START;
  677.             page->next = NULL;
  678.             page->prev = NGX_SLAB_PAGE;

  680.             if (--pages == 0) {
  681.                 return page;
  682.             }

  684.             for (p = page + 1; pages; pages--) {
  685.                 p->slab = NGX_SLAB_PAGE_BUSY;
  686.                 p->next = NULL;
  687.                 p->prev = NGX_SLAB_PAGE;
  688.                 p++;
  689.             }

  691.             return page;
  692.         }
  693.     }

  695.     if (pool->log_nomem) {
  696.         ngx_slab_error(pool, NGX_LOG_CRIT,
  697.                        "ngx_slab_alloc() failed: no memory");
  698.     }

  700.     return NULL;
  701. }


  704. static void
  705. ‌ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page,
  706.     ngx_uint_t pages)
  707. {
  708.     ngx_uint_t        type;
  709.     ngx_slab_page_t  *prev, *join;

  711.     page->slab = pages--;

  713.     if (pages) {
  714.         ngx_memzero(&page[1], pages * sizeof(ngx_slab_page_t));
  715.     }

  717.     if (page->next) {
  718.         prev = (ngx_slab_page_t *) (page->prev & ~NGX_SLAB_PAGE_MASK);
  719.         prev->next = page->next;
  720.         page->next->prev = page->prev;
  721.     }

  723.     join = page + page->slab;

  725.     if (join < pool->last) {
  726.         type = join->prev & NGX_SLAB_PAGE_MASK;

  728.         if (type == NGX_SLAB_PAGE) {

  730.             if (join->next != NULL) {
  731.                 pages += join->slab;
  732.                 page->slab += join->slab;

  734.                 prev = (ngx_slab_page_t *) (join->prev & ~NGX_SLAB_PAGE_MASK);
  735.                 prev->next = join->next;
  736.                 join->next->prev = join->prev;

  738.                 join->slab = NGX_SLAB_PAGE_FREE;
  739.                 join->next = NULL;
  740.                 join->prev = NGX_SLAB_PAGE;
  741.             }
  742.         }
  743.     }

  745.     if (page > pool->pages) {
  746.         join = page - 1;
  747.         type = join->prev & NGX_SLAB_PAGE_MASK;

  749.         if (type == NGX_SLAB_PAGE) {

  751.             if (join->slab == NGX_SLAB_PAGE_FREE) {
  752.                 join = (ngx_slab_page_t *) (join->prev & ~NGX_SLAB_PAGE_MASK);
  753.             }

  755.             if (join->next != NULL) {
  756.                 pages += join->slab;
  757.                 join->slab += page->slab;

  759.                 prev = (ngx_slab_page_t *) (join->prev & ~NGX_SLAB_PAGE_MASK);
  760.                 prev->next = join->next;
  761.                 join->next->prev = join->prev;

  763.                 page->slab = NGX_SLAB_PAGE_FREE;
  764.                 page->next = NULL;
  765.                 page->prev = NGX_SLAB_PAGE;

  767.                 page = join;
  768.             }
  769.         }
  770.     }

  772.     if (pages) {
  773.         page[pages].prev = (uintptr_t) page;
  774.     }

  776.     page->prev = (uintptr_t) &pool->free;
  777.     page->next = pool->free.next;

  779.     page->next->prev = (uintptr_t) page;

  781.     pool->free.next = page;
  782. }


  785. static void
  786. ‌ngx_slab_error(ngx_slab_pool_t *pool, ngx_uint_t level, char *text)
  787. {
  788.     ngx_log_error(level, ngx_cycle->log, 0, "%s%s", text, pool->log_ctx);
  789. }

One Level Up Top Level