Fawkes API Fawkes Development Version
|
00001 00002 00003 /*************************************************************************** 00004 * shm.h - shared memory segment 00005 * 00006 * Generated: Thu Jan 12 13:12:24 2006 00007 * Copyright 2005-2006 Tim Niemueller [www.niemueller.de] 00008 * 00009 ****************************************************************************/ 00010 00011 /* This program is free software; you can redistribute it and/or modify 00012 * it under the terms of the GNU General Public License as published by 00013 * the Free Software Foundation; either version 2 of the License, or 00014 * (at your option) any later version. A runtime exception applies to 00015 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00016 * 00017 * This program is distributed in the hope that it will be useful, 00018 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00020 * GNU Library General Public License for more details. 00021 * 00022 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00023 */ 00024 00025 #ifndef __UTILS_IPC_SHM_H_ 00026 #define __UTILS_IPC_SHM_H_ 00027 00028 // for size_t 00029 #include <sys/types.h> 00030 00031 namespace fawkes { 00032 00033 class SharedMemoryHeader { 00034 public: 00035 virtual ~SharedMemoryHeader() {} 00036 virtual bool matches(void *memptr) = 0; 00037 virtual size_t size() = 0; 00038 virtual void initialize(void *memptr) = 0; 00039 virtual void set(void *memptr) = 0; 00040 virtual void reset() = 0; 00041 virtual size_t data_size() = 0; 00042 virtual SharedMemoryHeader * clone() const = 0; 00043 virtual bool operator==(const SharedMemoryHeader &s) const = 0; 00044 }; 00045 00046 class SharedMemoryLister; 00047 class SemaphoreSet; 00048 00049 class SharedMemory 00050 { 00051 00052 public: 00053 00054 static const unsigned int MagicTokenSize; 00055 static const short MaxNumConcurrentReaders; 00056 00057 SharedMemory(const char *magic_token, 00058 SharedMemoryHeader *header, 00059 bool is_read_only, bool create, 00060 bool destroy_on_delete); 00061 00062 SharedMemory(const SharedMemory &s); 00063 00064 virtual ~SharedMemory(); 00065 00066 bool is_read_only(); 00067 bool is_destroyed(); 00068 bool is_swapable(); 00069 bool is_valid(); 00070 bool is_creator(); 00071 bool is_protected(); 00072 void * memptr(); 00073 size_t data_size(); 00074 void set(void *memptr); 00075 void set_destroy_on_delete(bool destroy); 00076 void add_semaphore(); 00077 void set_swapable(bool swapable); 00078 00079 void lock_for_read(); 00080 bool try_lock_for_read(); 00081 void lock_for_write(); 00082 bool try_lock_for_write(); 00083 void unlock(); 00084 00085 void * ptr(void *addr); 00086 void * addr(void *ptr); 00087 00088 static void list(const char *magic_token, 00089 SharedMemoryHeader *header, SharedMemoryLister *lister); 00090 00091 static void erase(const char *magic_token, 00092 SharedMemoryHeader *header, SharedMemoryLister *lister = 0); 00093 00094 static void erase_orphaned(const char *magic_token, 00095 SharedMemoryHeader *header, 00096 SharedMemoryLister *lister = 0); 00097 00098 static bool exists(const char *magic_token, 00099 SharedMemoryHeader *header); 00100 00101 static bool is_destroyed(int shm_id); 00102 static bool is_swapable(int shm_id); 00103 static unsigned int num_attached(int shm_id); 00104 00105 class SharedMemoryIterator 00106 { 00107 public: 00108 SharedMemoryIterator(); 00109 SharedMemoryIterator(const SharedMemoryIterator &shmit); 00110 SharedMemoryIterator(const char *magic_token, SharedMemoryHeader *header); 00111 ~SharedMemoryIterator(); 00112 00113 SharedMemoryIterator & operator++ (); // prefix 00114 SharedMemoryIterator operator++ (int inc); // postfix 00115 SharedMemoryIterator & operator+ (unsigned int i); 00116 SharedMemoryIterator & operator+= (unsigned int i); 00117 bool operator== (const SharedMemoryIterator & s) const; 00118 bool operator!= (const SharedMemoryIterator & s) const; 00119 const SharedMemoryHeader * operator* () const; 00120 SharedMemoryIterator & operator= (const SharedMemoryIterator & shmit); 00121 00122 const char * magic_token() const; 00123 int shmid() const; 00124 int semaphore() const; 00125 size_t segmsize() const; 00126 size_t segmnattch() const; 00127 void * databuf() const; 00128 00129 private: 00130 void attach(); 00131 void reset(); 00132 00133 char *__magic_token; 00134 int __max_id; 00135 int __cur_shmid; 00136 int __cur_id; 00137 SharedMemoryHeader *__header; 00138 void *__shm_buf; 00139 void *__data_buf; 00140 int __semaphore; 00141 size_t __segmsize; 00142 size_t __segmnattch; 00143 }; 00144 00145 static SharedMemoryIterator find(const char *magic_token, SharedMemoryHeader *header); 00146 static SharedMemoryIterator end(); 00147 00148 protected: 00149 00150 /** General header. 00151 * This header is stored right after the magic token. 00152 */ 00153 typedef struct { 00154 void *shm_addr; /**< Desired shared memory address */ 00155 int semaphore; /**< Semaphore set ID */ 00156 } SharedMemory_header_t; 00157 00158 SharedMemory(const char *magic_token, 00159 bool is_read_only, bool create, bool destroy_on_delete); 00160 00161 void attach(); 00162 void free(); 00163 00164 void *_memptr; 00165 size_t _mem_size; 00166 size_t _data_size; 00167 SharedMemoryHeader *_header; 00168 bool _is_read_only; 00169 bool _destroy_on_delete; 00170 bool _should_create; 00171 char *_magic_token; 00172 char *_shm_magic_token; 00173 SharedMemory_header_t *_shm_header; 00174 void *_shm_upper_bound; 00175 long unsigned int _shm_offset; 00176 00177 00178 private: 00179 void *__shared_mem; 00180 int __shared_mem_id; 00181 void *__shared_mem_upper_bound; 00182 00183 bool __created; 00184 SemaphoreSet *__semset; 00185 00186 bool __lock_aquired; 00187 bool __write_lock_aquired; 00188 00189 }; 00190 00191 00192 } // end namespace fawkes 00193 00194 #endif