00001
00002 /***************************************************************************
00003  *  bb_shmem_header.cpp - BlackBoard shared memory header
00004  *
00005  *  Created: Thu Oct 19 14:21:07 2006 (Anne's 25th Birthday)
00006  *  Copyright  2006  Tim Niemueller [www.niemueller.de]
00007  *
00008  ****************************************************************************/
00009
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023
00024 #include <blackboard/shmem/header.h>
00025 #include <utils/ipc/shm.h>
00026 #include <cstddef>
00027
00028 namespace fawkes {
00029 
00030 /** @class BlackBoardSharedMemoryHeader <blackboard/shmem/header.h>
00031  * BlackBoard Shared Memory Header.
00032  * This class is used identify BlackBoard shared memory headers and
00033  * to interact with the management data in the shared memory segment.
00034  * The basic options stored in the header is a version identifier
00035  * and pointers to the list heads of the free and allocated chunk
00036  * lists.
00037  *
00038  * @author Tim Niemueller
00039  * @see SharedMemoryHeader
00040  */
00041
00042 
00043 /** Constructor
00044  * @param data_size the size of the shared memory segment without the header
00045  *                  that should be allocated.
00046  * @param version The BB version to store in the shared memory segment to prevent
00047  *                conflicts with older software.
00048  */
00049 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(size_t data_size,
00050                                                            unsigned int version)
00051 {
00052   _data_size = data_size;
00053   _version   = version;
00054   data       = NULL;
00055 }
00056
00057 
00058 /** Constructor.
00059  * @param version The BB version to store in the shared memory segment to prevent
00060  *                conflicts with older software.
00061  */
00062 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(unsigned int version)
00063 {
00064   _data_size = 0;
00065   _version   = version;
00066   data       = NULL;
00067 }
00068
00069 
00070 /** Copy constructor.
00071  * @param h header to copy
00072  */
00073 BlackBoardSharedMemoryHeader::BlackBoardSharedMemoryHeader(const BlackBoardSharedMemoryHeader *h)
00074 {
00075   _data_size = h->_data_size;
00076   _version   = h->_version;
00077   data       = h->data;
00078 }
00079
00080 
00081 /** Set SharedMemory instance.
00082  * This is needed for address conversion and must be set right after the constructor
00083  * call of SharedMemory!
00084  * @param shmem SharedMemory segment used for this header
00085  */
00086 void
00087 BlackBoardSharedMemoryHeader::set_shared_memory(SharedMemory *shmem)
00088 {
00089   this->shmem = shmem;
00090 }
00091
00092 
00093 /** Destructor */
00094 BlackBoardSharedMemoryHeader::~BlackBoardSharedMemoryHeader()
00095 {
00096 }
00097
00098
00099
00100 SharedMemoryHeader *
00101 BlackBoardSharedMemoryHeader::clone() const
00102 {
00103   return new BlackBoardSharedMemoryHeader(this);
00104 }
00105
00106 
00107 /** Check if the given shared memory segment is a Fawkes BB segment
00108  * @param memptr Ptr to the segment
00109  * @return true if the version matches, false otherwise
00110  */
00111 bool
00112 BlackBoardSharedMemoryHeader::matches(void *memptr)
00113 {
00114   BlackBoardSharedMemoryHeaderData *md = (BlackBoardSharedMemoryHeaderData *)memptr;
00115   return (_version == md->version);
00116 }
00117
00118
00119 bool
00120 BlackBoardSharedMemoryHeader::operator==(const SharedMemoryHeader &s) const
00121 {
00122   const BlackBoardSharedMemoryHeader *h = dynamic_cast<const BlackBoardSharedMemoryHeader *>(&s);
00123   if ( ! h ) {
00124     return false;
00125   } else {
00126     return ( (_version == h->_version) &&
00127              (_data_size == h->_data_size) &&
00128              (data == h->data) );
00129   }
00130 }
00131 
00132 /** Get the size of the header data.
00133  * @return size of the header data
00134  */
00135 size_t
00136 BlackBoardSharedMemoryHeader::size()
00137 {
00138   return sizeof(BlackBoardSharedMemoryHeaderData);
00139 }
00140
00141 
00142 /** Initialize shared memory segment
00143  * This copies basic management header data into the shared memory segment.
00144  * Basically sets the version and list heads to NULL
00145  * @param memptr pointer to the memory
00146  */
00147 void
00148 BlackBoardSharedMemoryHeader::initialize(void *memptr)
00149 {
00150   data = (BlackBoardSharedMemoryHeaderData *)memptr;
00151   data->version         = _version;
00152   data->shm_addr        = memptr;
00153   data->free_list_head  = NULL;
00154   data->alloc_list_head = NULL;
00155 }
00156
00157 
00158 /** Set data of this header
00159  * Sets the internal pointer to the shared memory header data 
00160  * to the data retrieved from the shared memory segment.
00161  * @param memptr pointer to the memory
00162  */
00163 void
00164 BlackBoardSharedMemoryHeader::set(void *memptr)
00165 {
00166   data = (BlackBoardSharedMemoryHeaderData *)memptr;
00167 }
00168
00169
00170 void
00171 BlackBoardSharedMemoryHeader::reset()
00172 {
00173   data = NULL;
00174 }
00175
00176 
00177 /** Data segment size.
00178  * @return size of the data segment without header
00179  */
00180 size_t
00181 BlackBoardSharedMemoryHeader::data_size()
00182 {
00183   return _data_size;
00184 }
00185
00186 
00187 /** Get the head of the free chunks list.
00188  * @return pointer to the free list head, local pointer, already transformed,
00189  * you can use this without further conversion.
00190  */
00191 chunk_list_t *
00192 BlackBoardSharedMemoryHeader::free_list_head()
00193 {
00194   return (chunk_list_t *)shmem->ptr(data->free_list_head);
00195 }
00196
00197 
00198 /** Get the head of the allocated chunks list.
00199  * @return pointer to the allocated list head, local pointer, already transformed,
00200  * you can use this without further conversion.
00201  */
00202 chunk_list_t *
00203 BlackBoardSharedMemoryHeader::alloc_list_head()
00204 {
00205   return (chunk_list_t *)shmem->ptr(data->alloc_list_head);
00206 }
00207
00208 
00209 /** Set the head of the free chunks list.
00210  * @param flh pointer to the new free list head, must be a pointer to the local
00211  * shared memory segment. Will be transformed to a shared memory address.
00212  */
00213 void
00214 BlackBoardSharedMemoryHeader::set_free_list_head(chunk_list_t *flh)
00215 {
00216   data->free_list_head = (chunk_list_t *)shmem->addr(flh);
00217 }
00218
00219 
00220 /** Set the head of the allocated chunks list.
00221  * @param alh pointer to the new allocated list head, must be a pointer to the local
00222  * shared memory segment. Will be transformed to a shared memory address.
00223  */
00224 void
00225 BlackBoardSharedMemoryHeader::set_alloc_list_head(chunk_list_t *alh)
00226 {
00227   data->alloc_list_head = (chunk_list_t *)shmem->addr(alh);
00228 }
00229
00230 
00231 /** Get BlackBoard version.
00232  * @return BlackBoard version
00233  */
00234 unsigned int
00235 BlackBoardSharedMemoryHeader::version() const
00236 {
00237   return data->version;
00238 }
00239
00240 } // end namespace fawkes