LwIP分配内存失败该怎么办？

LwIP中发送小数据可以，发送140个字节的数据发送失败，查找原因，是分配内存失败，返回是men->used 为121
按道理说即使分配失败，used返回的数据也是1也不会是121？
mem_malloc(mem_size_t size){  mem_size_t ptr, ptr2;  struct mem *mem, *mem2;#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT  u8_t local_mem_free_count = 0;#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */  LWIP_MEM_ALLOC_DECL_PROTECT();
  if (size == 0) {    return NULL;  }printf("size %d n",size);  /* Expand the size of the allocated memory region so that we can     adjust for alignment. */  size = LWIP_MEM_ALIGN_SIZE(size);
  if(size < MIN_SIZE_ALIGNED) {    /* every data block must be at least MIN_SIZE_ALIGNED long */    size = MIN_SIZE_ALIGNED;  }
  if (size > MEM_SIZE_ALIGNED) {    return NULL;  }
  /* protect the heap from concurrent access */  sys_arch_sem_wait(mem_sem, 0);  LWIP_MEM_ALLOC_PROTECT();#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT  /* run as long as a mem_free disturbed mem_malloc */  do {    local_mem_free_count = 0;#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
    /* Scan through the heap searching for a free block that is big enough,     * beginning with the lowest free block.     */    for (ptr = (u8_t *)lfree - ram; ptr < MEM_SIZE_ALIGNED - size;         ptr = ((struct mem *)&ram[ptr])->next) {  mem = (struct mem *)&ram[ptr];#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT      mem_free_count = 0;      LWIP_MEM_ALLOC_UNPROTECT();      /* allow mem_free to run */      LWIP_MEM_ALLOC_PROTECT();      if (mem_free_count != 0) {        local_mem_free_count = mem_free_count;      }      mem_free_count = 0;#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */printf("mem->used %d n",mem->used);      if ((!mem->used) &&          (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) {        /* mem is not used and at least perfect fit is possible:         * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */     if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) {          /* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing           * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')           * -> split large block, create empty remainder,           * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if           * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,           * struct mem would fit in but no data between mem2 and mem2->next           * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty           *       region that couldn't hold data, but when mem->next gets freed,           *       the 2 regions would be combined, resulting in more free memory           */          ptr2 = ptr + SIZEOF_STRUCT_MEM + size;          /* create mem2 struct */          mem2 = (struct mem *)&ram[ptr2];          mem2->used = 0;          mem2->next = mem->next;          mem2->prev = ptr;          /* and insert it between mem and mem->next */          mem->next = ptr2;          mem->used = 1;
          if (mem2->next != MEM_SIZE_ALIGNED) {            ((struct mem *)&ram[mem2->next])->prev = ptr2;          }          MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM));        } else {          /* (a mem2 struct does no fit into the user data space of mem and mem->next will always           * be used at this point: if not we have 2 unused structs in a row, plug_holes should have           * take care of this).           * -> near fit or excact fit: do not split, no mem2 creation           * also can't move mem->next directly behind mem, since mem->next           * will always be used at this point!           */          mem->used = 1;          MEM_STATS_INC_USED(used, mem->next - ((u8_t *)mem - ram));        }
        if (mem == lfree) {          /* Find next free block after mem and update lowest free pointer */          while (lfree->used && lfree != ram_end) {            LWIP_MEM_ALLOC_UNPROTECT();            /* prevent high interrupt latency... */            LWIP_MEM_ALLOC_PROTECT();            lfree = (struct mem *)&ram[lfree->next];          }          LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used)));        }        LWIP_MEM_ALLOC_UNPROTECT();        sys_sem_signal(mem_sem);        LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.",         (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end);        LWIP_ASSERT("mem_malloc: allocated memory properly aligned.",         ((mem_ptr_t)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0);        LWIP_ASSERT("mem_malloc: sanity check alignment",          (((mem_ptr_t)mem) & (MEM_ALIGNMENT-1)) == 0);
        return (u8_t *)mem + SIZEOF_STRUCT_MEM;      }    }#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT    /* if we got interrupted by a mem_free, try again */  } while(local_mem_free_count != 0);#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */  LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_malloc: could not allocate %"S16_F" bytesn", (s16_t)size));  MEM_STATS_INC(err);  LWIP_MEM_ALLOC_UNPROTECT();  sys_sem_signal(mem_sem);  return NULL;}
#endif /* MEM_USE_POOLS */