mem_block.c 23.7 KB
Newer Older
1 2 3 4 5
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
Cedric Roux's avatar
Cedric Roux committed
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/***************************************************************************
                          mem_block.c  -  description
                             -------------------
  AUTHOR  : Lionel GAUTHIER
  COMPANY : EURECOM
  EMAIL   : Lionel.Gauthier@eurecom.fr


 ***************************************************************************/
#define MEM_BLOCK_C
//#include "rtos_header.h"
#include "mem_block.h"
#include "mem_pool.h"
#include "list.h"
#include "LAYER2/MAC/extern.h"

roux's avatar
roux committed
38 39 40 41 42 43 44 45 46 47 48 49 50 51
/* all function calls are protected by a mutex
 * to ensure that many threads calling them at
 * the same time don't mess up.
 * We might be more clever in the future, it's a
 * bit overkill.
 * Commenting this define removes the protection,
 * so be careful with it.
 */
#define MEMBLOCK_BIG_LOCK

#ifdef MEMBLOCK_BIG_LOCK
static pthread_mutex_t mtex = PTHREAD_MUTEX_INITIALIZER;
#endif

52 53 54 55 56
//-----------------------------------------------------------------------------
//#define DEBUG_MEM_MNGT_FREE
//#define DEBUG_MEM_MNGT_ALLOC_SIZE
//#define DEBUG_MEM_MNGT_ALLOC
//-----------------------------------------------------------------------------
Mongazon's avatar
Mongazon committed
57
#if defined(DEBUG_MEM_MNGT_ALLOC)
58
uint32_t             counters[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
59 60 61 62 63 64
#endif
//-----------------------------------------------------------------------------
/*
 * initialize all ures
 */
void           *
65
pool_buffer_init (void)
66
{
67
  //-----------------------------------------------------------------------------
68

69
  uint32_t             index, mb_index, pool_index;
70 71
  mem_pool       *memory = (mem_pool *) &mem_block_var;
  int             pool_sizes[14] = { MEM_MNGT_MB0_NB_BLOCKS, MEM_MNGT_MB1_NB_BLOCKS,
72 73 74 75 76 77 78
                                     MEM_MNGT_MB2_NB_BLOCKS, MEM_MNGT_MB3_NB_BLOCKS,
                                     MEM_MNGT_MB4_NB_BLOCKS, MEM_MNGT_MB5_NB_BLOCKS,
                                     MEM_MNGT_MB6_NB_BLOCKS, MEM_MNGT_MB7_NB_BLOCKS,
                                     MEM_MNGT_MB8_NB_BLOCKS, MEM_MNGT_MB9_NB_BLOCKS,
                                     MEM_MNGT_MB10_NB_BLOCKS, MEM_MNGT_MB11_NB_BLOCKS,
                                     MEM_MNGT_MB12_NB_BLOCKS, MEM_MNGT_MBCOPY_NB_BLOCKS
                                   };
79

roux's avatar
roux committed
80 81 82 83
#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_lock(&mtex)) abort();
#endif

84 85
  memset (memory, 0, sizeof (mem_pool));
  mb_index = 0;
86

87 88 89
  // LG_TEST
  for (pool_index = 0; pool_index <= MEM_MNGT_POOL_ID_COPY; pool_index++) {
    list_init (&memory->mem_lists[pool_index], "POOL");
90

91 92 93 94
    for (index = 0; index < pool_sizes[pool_index]; index++) {
      //memory->mem_blocks[mb_index + index].previous = NULL; -> done in memset 0
      //memory->mem_blocks[mb_index + index].next     = NULL; -> done in memset 0
      switch (pool_index) {
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
      case 0:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool0[index][0]);
        break;

      case 1:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool1[index][0]);
        break;

      case 2:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool2[index][0]);
        break;

      case 3:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool3[index][0]);
        break;

      case 4:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool4[index][0]);
        break;

      case 5:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool5[index][0]);
        break;

      case 6:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool6[index][0]);
        break;

      case 7:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool7[index][0]);
        break;

      case 8:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool8[index][0]);
        break;

      case 9:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool9[index][0]);
        break;

      case 10:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool10[index][0]);
        break;

      case 11:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool11[index][0]);
        break;

      case 12:
        memory->mem_blocks[mb_index + index].data = (unsigned char*)&(memory->mem_pool12[index][0]);
        break;

      default:
        ;
        memory->mem_blocks[mb_index + index].data = NULL;   // pool copy
150 151

      }
152

153 154 155
      memory->mem_blocks[mb_index + index].pool_id = pool_index;
      list_add_tail_eurecom (&memory->mem_blocks[mb_index + index], &memory->mem_lists[pool_index]);
    }
156

157 158
    mb_index += pool_sizes[pool_index];
  }
159

roux's avatar
roux committed
160 161 162 163
#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_unlock(&mtex)) abort();
#endif

164 165 166 167 168 169 170
  return 0;
}

//-----------------------------------------------------------------------------
void           *
pool_buffer_clean (void *arg)
{
171
  //-----------------------------------------------------------------------------
172 173 174 175
  return 0;
}
//-----------------------------------------------------------------------------
void
176
free_mem_block (mem_block_t * leP, const char* caller)
177
{
178
  //-----------------------------------------------------------------------------
179 180

  if (!(leP)) {
181
    LOG_W (RLC,"[MEM_MNGT][FREE] WARNING FREE NULL MEM_BLOCK\n");
182 183
    return;
  }
184

roux's avatar
roux committed
185 186 187 188
#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_lock(&mtex)) abort();
#endif

189
#ifdef DEBUG_MEM_MNGT_FREE
190
  LOG_D (RLC,"[MEM_MNGT][FREE] free_mem_block() %p pool: %d\n", leP, leP->pool_id);
191 192
#endif
#ifdef DEBUG_MEM_MNGT_ALLOC
193
  check_free_mem_block (leP);
194
#endif
195 196 197

  if (leP->pool_id <= MEM_MNGT_POOL_ID_COPY) {
    list_add_tail_eurecom (leP, &mem_block_var.mem_lists[leP->pool_id]);
198
#ifdef DEBUG_MEM_MNGT_ALLOC
199
    counters[leP->pool_id] -= 1;
200
    LGO_D (RLC,"[%s][MEM_MNGT][INFO] after pool[%2d] freed: counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n",
201 202 203 204
        caller, leP->pool_id,
        counters[0],counters[1],counters[2],counters[3],counters[4],
        counters[5],counters[6],counters[7],counters[8],counters[9],
        counters[10],counters[11]);
205
#endif
206 207
    leP = NULL;                 // this prevent from freeing the block twice
  } else {
208
    LOG_E (RLC,"[MEM_MNGT][FREE] ERROR free_mem_block() unknown pool_id : %d\n", leP->pool_id);
209
  }
roux's avatar
roux committed
210 211 212 213

#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_unlock(&mtex)) abort();
#endif
214 215 216 217
}

//-----------------------------------------------------------------------------
mem_block_t      *
218
get_free_mem_block (uint32_t sizeP, const char* caller)
219
{
220
  //-----------------------------------------------------------------------------
221 222 223 224
  mem_block_t      *le = NULL;
  int             pool_selected;
  int             size;

225
  if (sizeP > MEM_MNGT_MB12_BLOCK_SIZE) {
226
    LOG_E (RLC,"[MEM_MNGT][ERROR][FATAL] size requested %d out of bounds\n", sizeP);
227
    display_mem_load ();
228
    AssertFatal(1==0,"get_free_mem_block size requested out of bounds");
229 230
    return NULL;
  }
roux's avatar
roux committed
231 232 233 234 235

#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_lock(&mtex)) abort();
#endif

236 237 238 239 240 241 242 243 244 245 246 247
  size = sizeP >> 6;
  pool_selected = 0;

  while ((size)) {
    pool_selected += 1;
    size = size >> 1;
  }

  // pool is selected according to the size requested, now get a block
  // if no block is available pick one in an other pool
  do {
    if ((le = list_remove_head (&mem_block_var.mem_lists[pool_selected]))) {
248
#ifdef DEBUG_MEM_MNGT_ALLOC
249
      counters[pool_selected] += 1;
250
      LOG_D (RLC,"[%s][MEM_MNGT][INFO] after pool[%2d] allocated: counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n",
251 252 253 254 255
          caller,
          pool_selected,
          counters[0],counters[1],counters[2],counters[3],counters[4],
          counters[5],counters[6],counters[7],counters[8],counters[9],
          counters[10],counters[11]);
256 257
#endif
#ifdef DEBUG_MEM_MNGT_ALLOC_SIZE
258
      LOG_D (RLC,"[MEM_MNGT][INFO] ALLOC MEM_BLOCK SIZE %d bytes pool %d (%p)\n", sizeP, pool_selected,le);
259
#endif
roux's avatar
roux committed
260

261 262
      AssertFatal(le->pool_id == pool_selected, "Unexpected pool ID!");

roux's avatar
roux committed
263 264 265 266
#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_unlock(&mtex)) abort();
#endif

267 268
      return le;
    }
269 270

#ifdef DEBUG_MEM_MNGT_ALLOC
271
    LOG_E (RLC,"[MEM_MNGT][ERROR][MINOR] memory pool %d is empty trying next pool alloc count = %d\n", pool_selected, counters[pool_selected]);
272 273
    //    display_mem_load ();
    //    check_mem_area ((void *)&mem_block_var);
274
#endif
275 276
  } while (pool_selected++ < 12);

277
  LOG_E(PHY, "[MEM_MNGT][ERROR][FATAL] failed allocating MEM_BLOCK size %d byes (pool_selected=%d size=%d)\n", sizeP, pool_selected, size);
278
  display_mem_load();
279
  AssertFatal(1==0,"get_free_mem_block failed");
roux's avatar
roux committed
280 281 282 283 284

#ifdef MEMBLOCK_BIG_LOCK
  if (pthread_mutex_unlock(&mtex)) abort();
#endif

285 286 287 288 289 290 291
  return NULL;
};

//-----------------------------------------------------------------------------
mem_block_t      *
get_free_copy_mem_block (void)
{
292
  //-----------------------------------------------------------------------------
293 294
  mem_block_t      *le;

roux's avatar
roux committed
295 296 297 298
#ifdef MEMBLOCK_BIG_LOCK
  AssertFatal(0, "This function is not handled properly but not used anywhere. FIXME?\n");
#endif

299 300
  if ((le = list_remove_head (&mem_block_var.mem_lists[MEM_MNGT_POOL_ID_COPY]))) {
#ifdef DEBUG_MEM_MNGT_ALLOC_SIZE
301
    LOG_D (RLC,"[MEM_MNGT][INFO] ALLOC COPY MEM BLOCK (%p)\n",le);
302 303 304
#endif
#ifdef DEBUG_MEM_MNGT_ALLOC
      counters[MEM_MNGT_POOL_ID_COPY] += 1;
305
      LOG_D (RLC,"[MEM_MNGT][INFO] pool counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n",
306 307 308
          counters[0],counters[1],counters[2],counters[3],counters[4],
          counters[5],counters[6],counters[7],counters[8],counters[9],
          counters[10],counters[11]);
309 310 311
#endif
    return le;
  } else {
312
    LOG_E (RLC,"[MEM_MNGT][ERROR] POOL COPY IS EMPTY\n");
313 314 315 316 317
    //#ifdef DEBUG_MEM_MNGT_ALLOC
    check_mem_area ();
    //    break_point ();
    //#endif

318
    AssertFatal(1==0,"mem pool is empty");
319 320 321 322 323 324 325 326
    return NULL;
  }
}

//-----------------------------------------------------------------------------
mem_block_t      *
copy_mem_block (mem_block_t * leP, mem_block_t * destP)
{
327
  //-----------------------------------------------------------------------------
328

roux's avatar
roux committed
329 330 331 332
#ifdef MEMBLOCK_BIG_LOCK
  AssertFatal(0, "This function is not handled properly but not used anywhere. FIXME?\n");
#endif

333 334 335
  if ((destP != NULL) && (leP != NULL) && (destP->pool_id == MEM_MNGT_POOL_ID_COPY)) {
    destP->data = leP->data;
  } else {
336
    LOG_E (RLC,"[MEM_MNGT][COPY] copy_mem_block() pool dest src or dest is NULL\n");
337
  }
338

339 340 341 342 343 344 345
  return destP;
}

//-----------------------------------------------------------------------------
void
display_mem_load (void)
{
346
  //-----------------------------------------------------------------------------
roux's avatar
roux committed
347 348 349
#ifdef MEMBLOCK_BIG_LOCK
  /* this function does not need to be protected, do nothing */
#endif
350 351 352

  mem_pool       *memory = (mem_pool *) &mem_block_var;

353
  LOG_D (RLC,"POOL 0 (%d elements of %d Bytes): ", MEM_MNGT_MB0_NB_BLOCKS, MEM_MNGT_MB0_BLOCK_SIZE);
354
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID0]);
355
  LOG_D (RLC,"POOL 1 (%d elements of %d Bytes): ", MEM_MNGT_MB1_NB_BLOCKS, MEM_MNGT_MB1_BLOCK_SIZE);
356
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID1]);
357
  LOG_D (RLC,"POOL 2 (%d elements of %d Bytes): ", MEM_MNGT_MB2_NB_BLOCKS, MEM_MNGT_MB2_BLOCK_SIZE);
358
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID2]);
359
  LOG_D (RLC,"POOL 3 (%d elements of %d Bytes): ", MEM_MNGT_MB3_NB_BLOCKS, MEM_MNGT_MB3_BLOCK_SIZE);
360
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID3]);
361
  LOG_D (RLC,"POOL 4 (%d elements of %d Bytes): ", MEM_MNGT_MB4_NB_BLOCKS, MEM_MNGT_MB4_BLOCK_SIZE);
362
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID4]);
363
  LOG_D (RLC,"POOL 5 (%d elements of %d Bytes): ", MEM_MNGT_MB5_NB_BLOCKS, MEM_MNGT_MB5_BLOCK_SIZE);
364
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID5]);
365
  LOG_D (RLC,"POOL 6 (%d elements of %d Bytes): ", MEM_MNGT_MB6_NB_BLOCKS, MEM_MNGT_MB6_BLOCK_SIZE);
366
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID6]);
367
  LOG_D (RLC,"POOL 7 (%d elements of %d Bytes): ", MEM_MNGT_MB7_NB_BLOCKS, MEM_MNGT_MB7_BLOCK_SIZE);
368
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID7]);
369
  LOG_D (RLC,"POOL 8 (%d elements of %d Bytes): ", MEM_MNGT_MB8_NB_BLOCKS, MEM_MNGT_MB8_BLOCK_SIZE);
370
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID8]);
371
  LOG_D (RLC,"POOL 9 (%d elements of %d Bytes): ", MEM_MNGT_MB9_NB_BLOCKS, MEM_MNGT_MB9_BLOCK_SIZE);
372
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID9]);
373
  LOG_D (RLC,"POOL 10 (%d elements of %d Bytes): ", MEM_MNGT_MB10_NB_BLOCKS, MEM_MNGT_MB10_BLOCK_SIZE);
374
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID10]);
375
  LOG_D (RLC,"POOL 11 (%d elements of %d Bytes): ", MEM_MNGT_MB11_NB_BLOCKS, MEM_MNGT_MB11_BLOCK_SIZE);
376
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID11]);
377
  LOG_D (RLC,"POOL 12 (%d elements of %d Bytes): ", MEM_MNGT_MB12_NB_BLOCKS, MEM_MNGT_MB12_BLOCK_SIZE);
378
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID12]);
379
  LOG_D (RLC,"POOL C (%d elements): ", MEM_MNGT_MBCOPY_NB_BLOCKS);
380 381 382 383 384 385 386
  list_display (&memory->mem_lists[MEM_MNGT_POOL_ID_COPY]);
}

//-----------------------------------------------------------------------------
void
check_mem_area (void)
{
387
  //-----------------------------------------------------------------------------
388 389 390
  int             index, mb_index;
  mem_pool       *memory = (mem_pool *) &mem_block_var;

roux's avatar
roux committed
391 392 393 394
#ifdef MEMBLOCK_BIG_LOCK
  AssertFatal(0, "This function is not handled properly but not used anywhere. FIXME?\n");
#endif

395
  for (index = 0; index < MEM_MNGT_MB0_NB_BLOCKS; index++) {
396
    if ((memory->mem_blocks[index].data != (unsigned char*)&(memory->mem_pool0[index][0])) && (memory->mem_blocks[index].pool_id != MEM_MNGT_POOL_ID0)) {
397
      LOG_D (RLC,"[MEM] ERROR POOL0 block index %d\n", index);
398 399
    }
  }
400

401
  mb_index = MEM_MNGT_MB0_NB_BLOCKS;
402

403
  for (index = 0; index < MEM_MNGT_MB1_NB_BLOCKS; index++) {
404 405
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool1[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID1)) {
406
      LOG_D (RLC,"[MEM] ERROR POOL1 block index %d\n", index);
407 408
    }
  }
409

410
  mb_index += MEM_MNGT_MB1_NB_BLOCKS;
411

412
  for (index = 0; index < MEM_MNGT_MB2_NB_BLOCKS; index++) {
413 414
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool2[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID2)) {
415
      LOG_D (RLC,"[MEM] ERROR POOL2 block index %d\n", index);
416 417
    }
  }
418

419
  mb_index += MEM_MNGT_MB2_NB_BLOCKS;
420

421
  for (index = 0; index < MEM_MNGT_MB3_NB_BLOCKS; index++) {
422 423
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool3[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID3)) {
424
      LOG_D (RLC,"[MEM] ERROR POOL3 block index %d\n", index);
425 426
    }
  }
427

428
  mb_index += MEM_MNGT_MB3_NB_BLOCKS;
429

430
  for (index = 0; index < MEM_MNGT_MB4_NB_BLOCKS; index++) {
431 432
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool4[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID4)) {
433
      LOG_D (RLC,"[MEM] ERROR POOL4 block index %d\n", index);
434 435
    }
  }
436

437
  mb_index += MEM_MNGT_MB4_NB_BLOCKS;
438

439
  for (index = 0; index < MEM_MNGT_MB5_NB_BLOCKS; index++) {
440 441
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool5[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID5)) {
442
      LOG_D (RLC,"[MEM] ERROR POOL5 block index %d\n", index);
443 444
    }
  }
445

446
  mb_index += MEM_MNGT_MB5_NB_BLOCKS;
447

448
  for (index = 0; index < MEM_MNGT_MB6_NB_BLOCKS; index++) {
449 450
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool6[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID6)) {
451
      LOG_D (RLC,"[MEM] ERROR POOL6 block index %d\n", index);
452 453
    }
  }
454

455
  mb_index += MEM_MNGT_MB6_NB_BLOCKS;
456

457
  for (index = 0; index < MEM_MNGT_MB7_NB_BLOCKS; index++) {
458 459
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool7[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID7)) {
460
      LOG_D (RLC,"[MEM] ERROR POOL7 block index %d\n", index);
461 462
    }
  }
463

464
  mb_index += MEM_MNGT_MB7_NB_BLOCKS;
465

466
  for (index = 0; index < MEM_MNGT_MB8_NB_BLOCKS; index++) {
467 468
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool8[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID8)) {
469
      LOG_D (RLC,"[MEM] ERROR POOL8 block index %d\n", index);
470 471
    }
  }
472

473
  mb_index += MEM_MNGT_MB8_NB_BLOCKS;
474

475
  for (index = 0; index < MEM_MNGT_MB9_NB_BLOCKS; index++) {
476 477
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool9[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID9)) {
478
      LOG_D (RLC,"[MEM] ERROR POOL9 block index %d\n", index);
479 480
    }
  }
481

482
  mb_index += MEM_MNGT_MB9_NB_BLOCKS;
483

484
  for (index = mb_index; index < MEM_MNGT_MB10_NB_BLOCKS; index++) {
485 486
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool10[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID10)) {
487
      LOG_D (RLC,"[MEM] ERROR POOL10 block index %d\n", index);
488
    }
489
  }
490

491
  mb_index += MEM_MNGT_MB10_NB_BLOCKS;
492

493
  for (index = mb_index; index < MEM_MNGT_MB11_NB_BLOCKS; index++) {
494 495
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool11[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID11)) {
496
      LOG_D (RLC,"[MEM] ERROR POOL11 block index %d\n", index);
497
    }
498
  }
499

500
  mb_index += MEM_MNGT_MB11_NB_BLOCKS;
501

502
  for (index = mb_index; index < MEM_MNGT_MB12_NB_BLOCKS; index++) {
503 504
    if ((memory->mem_blocks[mb_index + index].data != (unsigned char*)&(memory->mem_pool12[index][0]))
        && (memory->mem_blocks[mb_index + index].pool_id != MEM_MNGT_POOL_ID12)) {
505
      LOG_D (RLC,"[MEM] ERROR POOL12 block index %d\n", index);
506
    }
507
  }
508

509
  mb_index += MEM_MNGT_MB12_NB_BLOCKS;
510

511
  for (index = mb_index; index < MEM_MNGT_NB_ELEMENTS; index++) {
512
    if ((memory->mem_blocks[index].data != NULL) && (memory->mem_blocks[index].pool_id != MEM_MNGT_POOL_ID_COPY)) {
513
      LOG_D (RLC,"[MEM] ERROR POOL COPY block index %d\n", index);
514
    }
515 516 517 518 519 520 521
  }
}

//-----------------------------------------------------------------------------
void
check_free_mem_block (mem_block_t * leP)
{
522
  //-----------------------------------------------------------------------------
Cedric Roux's avatar
Cedric Roux committed
523
  ptrdiff_t             block_index;
524

roux's avatar
roux committed
525 526 527 528
#ifdef MEMBLOCK_BIG_LOCK
  /* this function does not SEEM TO need to be protected, do nothing (for the moment) */
#endif

529 530 531 532 533
  if ((leP >= mem_block_var.mem_blocks) && (leP <= &mem_block_var.mem_blocks[MEM_MNGT_NB_ELEMENTS-1])) {
    // the pointer is inside the memory region
    block_index = leP - mem_block_var.mem_blocks;
    // block_index is now: 0 <= block_index < MEM_MNGT_NB_ELEMENTS

534
    if (block_index < MEM_MNGT_MB0_NB_BLOCKS) {
535
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool0[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID0)) {
536
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
537
      }
538

539 540
      return;
    }
541

542 543 544 545
    block_index -= MEM_MNGT_MB0_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB1_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool1[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID1)) {
546
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
547
      }
548

549 550
      return;
    }
551

552 553 554 555
    block_index -= MEM_MNGT_MB1_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB2_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool2[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID2)) {
556
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
557
      }
558

559 560
      return;
    }
561

562 563 564 565
    block_index -= MEM_MNGT_MB2_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB3_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool3[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID3)) {
566
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
567
      }
568

569 570
      return;
    }
571

572 573 574 575
    block_index -= MEM_MNGT_MB3_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB4_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool4[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID4)) {
576
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
577
      }
578

579 580
      return;
    }
581

582 583 584 585
    block_index -= MEM_MNGT_MB4_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB5_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool5[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID5)) {
586
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
587
      }
588

589 590
      return;
    }
591

592 593 594 595
    block_index -= MEM_MNGT_MB5_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB6_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool6[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID6)) {
596
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
597
      }
598

599 600
      return;
    }
601

602 603 604 605
    block_index -= MEM_MNGT_MB6_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB7_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool7[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID7)) {
606
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
607
      }
608

609 610
      return;
    }
611

612 613 614 615
    block_index -= MEM_MNGT_MB7_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB8_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool8[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID8)) {
616
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
617
      }
618

619 620
      return;
    }
621

622 623 624 625
    block_index -= MEM_MNGT_MB8_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB9_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool9[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID9)) {
626
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
627
      }
628

629 630
      return;
    }
631

632 633 634 635
    block_index -= MEM_MNGT_MB9_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB10_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool10[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID10)) {
636
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
Cedric Roux's avatar
Cedric Roux committed
637
      }
638

639 640
      return;
    }
641

642 643 644 645
    block_index -= MEM_MNGT_MB10_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB11_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool11[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID11)) {
646
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
Cedric Roux's avatar
Cedric Roux committed
647
      }
648

649 650
      return;
    }
651

652 653 654 655
    block_index -= MEM_MNGT_MB11_NB_BLOCKS;

    if (block_index < MEM_MNGT_MB12_NB_BLOCKS) {
      if ((leP->data != (unsigned char*)mem_block_var.mem_pool12[block_index]) && (leP->pool_id != MEM_MNGT_POOL_ID12)) {
656
        LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
Cedric Roux's avatar
Cedric Roux committed
657
      }
658

659
      return;
Cedric Roux's avatar
Cedric Roux committed
660
    }
661
  } else {
662
    LOG_D (RLC,"[MEM][ERROR][FATAL] free mem block is corrupted\n");
663
  }
664 665

  // the block is ok
666
}