The OpenNET Project / Index page

[ новости /+++ | форум | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

_rtc_hide_region (3)
  • >> _rtc_hide_region (3) ( Solaris man: Библиотечные вызовы )
  • 
    NAME
         _rtc_check_free,   _rtc_check_malloc,    _rtc_check_realloc,
         _rtc_check_malloc_result,         _rtc_check_realloc_result,
         _rtc_hide_region,   _rtc_off,   _rtc_on,   _rtc_record_free,
         _rtc_record_malloc,  _rtc_record_realloc, _rtc_report_error,
         rtc_api - Runtime Checking (RTC) API for the use of  private
         memory allocators.
    
    SYNOPSIS
         #include <rtc_api.h>
    
         RTC_Result _rtc_check_free(void *ptr);
    
         RTC_Result _rtc_check_malloc(size_t size);
    
         RTC_Result _rtc_check_realloc(void *ptr, size_t size);
    
         RTC_Result _rtc_check_malloc_result(void *ptr, size_t size);
    
         RTC_Result  _rtc_check_realloc_result(void  *old_ptr,   void
         *new_ptr, size_t new_size);
    
         RTC_Result _rtc_hide_region(void *ptr, size_t size);
    
         RTC_Result _rtc_off(void );
    
         RTC_Result _rtc_on(void );
    
         RTC_Result _rtc_record_free(void *ptr);
    
         RTC_Result _rtc_record_malloc(void *ptr, size_t size);
    
         RTC_Result _rtc_record_realloc(void *old_ptr, void *new_ptr,
         size_t new_size);
    
         void _rtc_report_error(RTC_Result err);
    
    MT-LEVEL
         MT-Safe
    
    DESCRIPTION
         Runtime Checking  (RTC)  requires  that  the  standard  heap
         management routines in the shared library libc.so be used so
         that RTC can keep track of all the allocation and  dealloca-
         tions  in  the  program.  Many  applications write their own
         memory management routines either on top of  malloc-free  or
         from  scratch.   When  you  use  your own, known as private,
         allocators, RTC cannot automatically  track  them.  However,
         RTC  provides an API for the use of private allocators which
         allows them to to be treated the same as the  standard  heap
         allocators.
    
         Runtime Checking API functions provide an interface for con-
         veying  the  use  of  non-standard memory allocators to RTC.
         This interface supports malloc, free, and realloc as if they
         were  private memory allocators, which can use the API func-
         tions to update RTC's memory  maps  when  it  allocates  and
         frees  memory  regions.  The API enables RTC to check memory
         accesses made by programs that use the allocator.
    
         Some minor differences may exist with  RTC  error  reporting
         when "private allocators" do not use the program heap.  When
         memory access errosr referring a standard heap block occurs,
         an  RTC  error report typically includes the location of the
         heap block allocation.  This may not  be  reported  in  such
         cases.
    
         All entry points in the RTC API are macros which  turn  into
         calls  to appropriate functions in the RTC library when run-
         ning under RTC. You don't need to compile  the  code  condi-
         tionally to use them.
    
         _rtc_check_free() - called to see if the argument passed  to
         the free-like function is valid.
    
         _rtc_check_malloc() - called to see if the arguments  passed
         to the malloc-like function are valid.
    
         _rtc_check_realloc() - called to see if the argument  passed
         to the realloc-like function is valid.
    
         _rtc_check_malloc_result() - called to see if  the  pointer,
         'ptr',  produced as a result of allocating 'size' bytes is a
         valid result of a malloc-like function.
    
         _rtc_check_realloc_result() - called to see if the  pointer,
         'new_ptr',  produced  as a result of re-allocating 'old_ptr'
         to 'size' bytes is a valid result of the realloc-like  func-
         tion.
    
         _rtc_hide_region() - marks 'size' bytes starting at 'ptr' as
         inaccessible  on  the  RTC  memory  map.  Used to invalidate
         accesses to memory acquired with sbrk() or mmap() that  will
         be allocated on demand.
    
         _rtc_off() and _rtc_on() -  enables  private  allocators  to
         shut  off  memory  access  checking  while manipulating data
         structures in memory regions that  RTC  considers  inaccess-
         able.   An  allocator  can  turn  off  checking  by  calling
         _rtc_off() before accessing such a memory region,  and  cal-
         ling _rtc_on() to turn checking back on when finished.
    
         _rtc_record_free(),        _rtc_record_malloc(),         and
         _rtc_record_realloc() - changes RTC's memory maps to reflect
         changes in the accessability of memory  regions  that  occur
         when  the  private  allocator  allocates and frees blocks of
         memory.
    
         _rtc_report_error() - reports errors.
    
    RETURN VALUES
         In   cases   where    the    operation    was    successful,
         _rtc_check_free,    _rtc_check_malloc,   _rtc_check_realloc,
         _rtc_check_malloc_result,         _rtc_check_realloc_result,
         _rtc_hide_region,  _rtc_record_free,  _rtc_record_malloc and
         _rtc_record_realloc all return RTC_SUCCESS. When  unsuccess-
         ful,  they  return  an  error  result which can be passed to
         _rtc_report_error.
    
    EXAMPLES
         These example calls to the RTC API functions illustrate  how
         they  enable a private memory allocator to keep RTC's memory
         maps current.
    
              1. Acquire memory for later allocation:
    
                 {
                         size_t large_block = size_needed;
                         void *old_break_ptr = sbrk((int)large_block);
                         RTC_Result result;
    
                         result = _rtc_hide_region(old_break_ptr, large_block);
                         if (result != RTC_success)
                                 return NULL;
                         return old_break_ptr;
                 }
    
    
              2. Allocate a block (malloc-like function):
    
                 {
                         size_t block_size = request_size;
                         void *ptr = NULL;
                         RTC_Result result = RTC_SUCCESS;
    
                         result = _rtc_check_malloc(block_size);
                         if (result == RTC_SUCCESS) {
                                _rtc_off();
                                ptr = private_alloc(block_size);
                                _rtc_on();
                                result = _rtc_record_malloc(ptr, block_size);
                          if (result == RTC_SUCCESS) {
                             /* If we had guard blocks around the block of memory
                              * we would return to the user then we would mark
                              * the guard blocks as inaccessible by using
                              * _rtc_hide_region()
                              */
                          }
                         }
                         if (result != RTC_SUCCESS)
                                 _rtc_report_error(result);
                         return ptr;
                  }
    
    
              3. Free a block (free-like function):
    
                 {
                         RTC_Result result = RTC_SUCCESS;
    
                         result = _rtc_check_free(ptr);
                         if (result == RTC_SUCCESS) {
                                 _rtc_off();
                                 private_free(ptr);
                                 _rtc_on();
                                 (void)_rtc_record_free(ptr);
                         } else {
                                 _rtc_report_error(result);
                         }
                 }
    
    
              4. Reallocate a block (realloc-like function):
    
                 {
                         void *new_ptr = NULL;
                         size_t size = request_size;
                         void *old_ptr;
                         RTC_Result result = RTC_SUCCESS;
    
                         result = _rtc_check_realloc(old_ptr, size);
                         if (result == RTC_SUCCESS) {
                                 _rtc_off();
                                 new_ptr = private_realloc(old_block_record, size);
                                 _rtc_on();
                                 result = _rtc_check_realloc_result(old_ptr, new_ptr, size);
                                 if (result == RTC_SUCCESS)
                                     result = _rtc_record_realloc(old_ptr, new_ptr, size);
                         }
                         if (result != RTC_SUCCESS)
                                 _rtc_report_error(result);
                         return new_ptr;
                 }
    
    SEE ALSO
         dbx(1), mmap(2), sbrk(2)
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру