Fawkes API  Fawkes Development Version
shm.h
1 
2 /***************************************************************************
3  * shm.h - shared memory segment
4  *
5  * Created: Thu Jan 12 13:12:24 2006
6  * Copyright 2005-2011 Tim Niemueller [www.niemueller.de]
7  *
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version. A runtime exception applies to
14  * this software (see LICENSE.GPL_WRE file mentioned below for details).
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Library General Public License for more details.
20  *
21  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22  */
23 
24 #ifndef _UTILS_IPC_SHM_H_
25 #define _UTILS_IPC_SHM_H_
26 
27 // for size_t
28 #include <sys/types.h>
29 #include <utils/ipc/shm_registry.h>
30 
31 namespace fawkes {
32 
34 {
35 public:
37  {
38  }
39  virtual bool matches(void *memptr) = 0;
40  virtual size_t size() = 0;
41  virtual void initialize(void *memptr) = 0;
42  virtual void set(void *memptr) = 0;
43  virtual void reset() = 0;
44  virtual size_t data_size() = 0;
45  virtual SharedMemoryHeader *clone() const = 0;
46  virtual bool operator==(const SharedMemoryHeader &s) const = 0;
47 };
48 
49 class SharedMemoryLister;
50 class SemaphoreSet;
51 
53 {
54 public:
55  static const unsigned int MagicTokenSize;
56  static const short MaxNumConcurrentReaders;
57 
58  SharedMemory(const char * magic_token,
59  SharedMemoryHeader *header,
60  bool is_read_only,
61  bool create,
62  bool destroy_on_delete,
63  const char * registry_name = 0);
64 
65  SharedMemory(const SharedMemory &s);
66 
67  virtual ~SharedMemory();
68 
70 
71  bool is_read_only() const;
72  bool is_destroyed() const;
73  bool is_swapable() const;
74  bool is_valid() const;
75  bool is_creator() const;
76  bool is_protected() const;
77  void * memptr() const;
78  size_t data_size() const;
79  int shmem_id() const;
80  unsigned int num_attached() const;
81 
82  void set(void *memptr);
83  void set_destroy_on_delete(bool destroy);
84  void add_semaphore();
85  void set_swapable(bool swapable);
86 
87  void lock_for_read();
88  bool try_lock_for_read();
89  void lock_for_write();
90  bool try_lock_for_write();
91  void unlock();
92 
93  void *ptr(void *addr) const;
94  void *addr(void *ptr) const;
95 
96  static void list(const char * magic_token,
97  SharedMemoryHeader *header,
98  SharedMemoryLister *lister,
99  const char * registry_name = 0);
100 
101  static void erase(const char * magic_token,
102  SharedMemoryHeader *header,
103  SharedMemoryLister *lister = 0,
104  const char * registry_name = 0);
105 
106  static void erase_orphaned(const char * magic_token,
107  SharedMemoryHeader *header,
108  SharedMemoryLister *lister = 0,
109  const char * registry_name = 0);
110 
111  static bool
112  exists(const char *magic_token, SharedMemoryHeader *header, const char *registry_name = 0);
113 
114  static bool is_destroyed(int shm_id);
115  static bool is_swapable(int shm_id);
116  static unsigned int num_attached(int shm_id);
117 
119  {
120  public:
123  SharedMemoryIterator(std::list<SharedMemoryRegistry::SharedMemID> ids,
124  SharedMemoryHeader * header);
126 
127  SharedMemoryIterator & operator++(); // prefix
128  SharedMemoryIterator operator++(int inc); // postfix
129  SharedMemoryIterator & operator+(unsigned int i);
130  SharedMemoryIterator & operator+=(unsigned int i);
131  bool operator==(const SharedMemoryIterator &s) const;
132  bool operator!=(const SharedMemoryIterator &s) const;
133  const SharedMemoryHeader *operator*() const;
135 
136  const char *magic_token() const;
137  int shmid() const;
138  int semaphore() const;
139  size_t segmsize() const;
140  size_t segmnattch() const;
141  void * databuf() const;
142 
143  private:
144  void attach();
145  void reset();
146 
147  bool initialized_;
148  std::list<SharedMemoryRegistry::SharedMemID> ids_;
149  std::list<SharedMemoryRegistry::SharedMemID>::iterator id_it_;
150  int cur_shmid_;
151  SharedMemoryHeader * header_;
152  void * shm_buf_;
153  void * data_buf_;
154  int semaphore_;
155  size_t segmsize_;
156  size_t segmnattch_;
157  };
158 
159  static SharedMemoryIterator
160  find(const char *magic_token, SharedMemoryHeader *header, const char *registry_name = 0);
161  static SharedMemoryIterator end();
162 
163 protected:
164  /** General header.
165  * This header is stored right after the magic token.
166  */
167  typedef struct
168  {
169  void *shm_addr; /**< Desired shared memory address */
170  int semaphore; /**< Semaphore set ID */
172 
173  SharedMemory(const char *magic_token,
174  bool is_read_only,
175  bool create,
176  bool destroy_on_delete,
177  const char *registry_name = 0);
178 
179  void attach();
180  void free();
181 
182  void * _memptr;
183  size_t _mem_size;
184  size_t _data_size;
189  char * _magic_token;
193  long unsigned int _shm_offset;
194 
195 private:
196  SharedMemoryRegistry *shm_registry_;
197  char * registry_name_;
198 
199  void *shared_mem_;
200  int shared_mem_id_;
201  void *shared_mem_upper_bound_;
202 
203  bool created_;
204  SemaphoreSet *semset_;
205 
206  bool lock_aquired_;
207  bool write_lock_aquired_;
208 };
209 
210 } // end namespace fawkes
211 
212 #endif
fawkes::SharedMemory::_shm_magic_token
char * _shm_magic_token
Magic token as stored in the shared memory segment.
Definition: shm.h:190
fawkes::SharedMemoryHeader::matches
virtual bool matches(void *memptr)=0
Method to check if the given memptr matches this header.
fawkes::SharedMemory::_magic_token
char * _magic_token
Magic token.
Definition: shm.h:189
fawkes::SharedMemory::_is_read_only
bool _is_read_only
Read-only.
Definition: shm.h:186
fawkes::SharedMemoryHeader::size
virtual size_t size()=0
Size of the header.
fawkes::SharedMemory::is_creator
bool is_creator() const
Determine if the shared memory segment has been created by this instance.
Definition: shm.cpp:722
fawkes::SharedMemory::set_swapable
void set_swapable(bool swapable)
Set shared memory swapable.
Definition: shm.cpp:890
fawkes::SharedMemory::SharedMemoryIterator::shmid
int shmid() const
Get shared memory ID.
Definition: shm.cpp:1591
fawkes::SharedMemory::SharedMemory_header_t::shm_addr
void * shm_addr
Desired shared memory address.
Definition: shm.h:169
fawkes::SharedMemory
Shared memory segment.
Definition: shm.h:53
fawkes::SharedMemory::shmem_id
int shmem_id() const
Get shared memory ID.
Definition: shm.cpp:754
fawkes::SharedMemoryHeader::reset
virtual void reset()=0
Reset information previously set with set().
fawkes::SharedMemory::set
void set(void *memptr)
Copies data from the memptr to shared memory.
Definition: shm.cpp:774
fawkes::SharedMemory::_destroy_on_delete
bool _destroy_on_delete
destroy on delete.
Definition: shm.h:187
fawkes::SharedMemory::list
static void list(const char *magic_token, SharedMemoryHeader *header, SharedMemoryLister *lister, const char *registry_name=0)
List shared memory segments of a given type.
Definition: shm.cpp:1116
fawkes::SharedMemory::SharedMemory_header_t::semaphore
int semaphore
Semaphore set ID.
Definition: shm.h:170
fawkes::SharedMemoryLister
Format list output for shared memory segments.
Definition: shm_lister.h:38
fawkes::SharedMemory::SharedMemoryIterator::~SharedMemoryIterator
~SharedMemoryIterator()
Destructor.
Definition: shm.cpp:1363
fawkes::SharedMemory::attach
void attach()
Attach to the shared memory segment.
Definition: shm.cpp:512
fawkes::SharedMemory::MagicTokenSize
static const unsigned int MagicTokenSize
The magic token size.
Definition: shm.h:55
fawkes::SharedMemory::is_read_only
bool is_read_only() const
Check for read-only mode.
Definition: shm.cpp:706
fawkes::SharedMemory::free
void free()
Detach from and maybe destroy the shared memory segment.
Definition: shm.cpp:486
fawkes::SharedMemory::SharedMemoryIterator::operator+
SharedMemoryIterator & operator+(unsigned int i)
Advance by i steps.
Definition: shm.cpp:1491
fawkes::SharedMemory::SharedMemoryIterator::magic_token
const char * magic_token() const
Get magic token.
Definition: shm.cpp:1578
fawkes::SharedMemory::_shm_offset
long unsigned int _shm_offset
Offset to the master's base addr.
Definition: shm.h:193
fawkes::SharedMemory::SharedMemoryIterator::operator+=
SharedMemoryIterator & operator+=(unsigned int i)
Advance by i steps.
Definition: shm.cpp:1504
fawkes::SharedMemoryHeader
Interface for shared memory header.
Definition: shm.h:34
fawkes::SharedMemory::num_attached
unsigned int num_attached() const
Get number of attached processes.
Definition: shm.cpp:763
fawkes::SharedMemory::erase_orphaned
static void erase_orphaned(const char *magic_token, SharedMemoryHeader *header, SharedMemoryLister *lister=0, const char *registry_name=0)
Erase orphaned (attach count = 0) shared memory segments of a given type.
Definition: shm.cpp:1199
fawkes::SharedMemoryHeader::initialize
virtual void initialize(void *memptr)=0
Initialize the header.
fawkes::SharedMemory::unlock
void unlock()
Unlock memory.
Definition: shm.cpp:1025
fawkes::SharedMemory::memptr
void * memptr() const
Get a pointer to the shared memory This method returns a pointer to the data-segment of the shared me...
Definition: shm.cpp:734
fawkes::SharedMemoryHeader::data_size
virtual size_t data_size()=0
Return the size of the data.
fawkes::SharedMemory::~SharedMemory
virtual ~SharedMemory()
Destructor.
Definition: shm.cpp:397
fawkes::SharedMemoryHeader::set
virtual void set(void *memptr)=0
Set information from memptr.
fawkes::SharedMemory::SharedMemoryIterator::operator*
const SharedMemoryHeader * operator*() const
Get SharedMemoryHeader.
Definition: shm.cpp:1536
fawkes::SharedMemory::_header
SharedMemoryHeader * _header
Data-specific header.
Definition: shm.h:185
fawkes::SharedMemory::data_size
size_t data_size() const
Get the size of the data-segment.
Definition: shm.cpp:745
fawkes::SharedMemory::SharedMemoryIterator::semaphore
int semaphore() const
Get semaphore.
Definition: shm.cpp:1600
fawkes::SharedMemory::SharedMemoryIterator::operator=
SharedMemoryIterator & operator=(const SharedMemoryIterator &shmit)
Make this instance point to the same segment as shmit.
Definition: shm.cpp:1546
fawkes::SharedMemory::SharedMemory
SharedMemory(const char *magic_token, SharedMemoryHeader *header, bool is_read_only, bool create, bool destroy_on_delete, const char *registry_name=0)
Create a new shared memory segment.
Definition: shm.cpp:348
fawkes::SharedMemory::SharedMemoryIterator::operator==
bool operator==(const SharedMemoryIterator &s) const
Check iterators for equality.
Definition: shm.cpp:1517
fawkes::SharedMemory::_should_create
bool _should_create
Create shared memory segment.
Definition: shm.h:188
fawkes::SharedMemory::_mem_size
size_t _mem_size
Total size of the segment, including headers.
Definition: shm.h:183
fawkes::SharedMemory::lock_for_write
void lock_for_write()
Lock shared memory segment for writing.
Definition: shm.cpp:959
fawkes::SharedMemory::is_swapable
bool is_swapable() const
Check if memory can be swapped out.
Definition: shm.cpp:798
fawkes::SharedMemory::SharedMemoryIterator::operator!=
bool operator!=(const SharedMemoryIterator &s) const
Check iterators for inequality.
Definition: shm.cpp:1527
fawkes::SharedMemory::_shm_upper_bound
void * _shm_upper_bound
Upper bound of memory.
Definition: shm.h:192
fawkes
Fawkes library namespace.
fawkes::SharedMemory::SharedMemoryIterator::segmsize
size_t segmsize() const
Get segment size.
Definition: shm.cpp:1609
fawkes::SharedMemory::_data_size
size_t _data_size
Size of the data segment only.
Definition: shm.h:184
fawkes::SharedMemory::addr
void * addr(void *ptr) const
Get an address from a real pointer.
Definition: shm.cpp:690
fawkes::SharedMemory::SharedMemoryIterator
Shared Memory iterator.
Definition: shm.h:119
fawkes::SharedMemory::is_valid
bool is_valid() const
Check validity of shared memory segment.
Definition: shm.cpp:811
fawkes::SharedMemory::erase
static void erase(const char *magic_token, SharedMemoryHeader *header, SharedMemoryLister *lister=0, const char *registry_name=0)
Erase shared memory segments of a given type.
Definition: shm.cpp:1151
fawkes::SharedMemory::try_lock_for_read
bool try_lock_for_read()
Try to aquire lock on shared memory segment for reading.
Definition: shm.cpp:938
fawkes::SharedMemory::SharedMemoryIterator::segmnattch
size_t segmnattch() const
Get number of attached parties.
Definition: shm.cpp:1618
fawkes::SharedMemory::is_destroyed
bool is_destroyed() const
Check if segment has been destroyed This can be used if the segment has been destroyed.
Definition: shm.cpp:788
fawkes::SharedMemoryHeader::operator==
virtual bool operator==(const SharedMemoryHeader &s) const =0
Check for equality of headers.
fawkes::SharedMemory::is_protected
bool is_protected() const
Check if memory segment is protected.
Definition: shm.cpp:827
fawkes::SharedMemory::end
static SharedMemoryIterator end()
Get invalid iterator.
Definition: shm.cpp:1283
fawkes::SharedMemory::operator=
SharedMemory & operator=(const SharedMemory &s)
Assignment operator.
Definition: shm.cpp:421
fawkes::SharedMemory::ptr
void * ptr(void *addr) const
Get the real pointer to the data based on an address.
Definition: shm.cpp:659
fawkes::SharedMemory::SharedMemoryIterator::SharedMemoryIterator
SharedMemoryIterator()
Constructor.
Definition: shm.cpp:1298
fawkes::SharedMemory::SharedMemoryIterator::operator++
SharedMemoryIterator & operator++()
Prefix increment.
Definition: shm.cpp:1428
fawkes::SharedMemory::exists
static bool exists(const char *magic_token, SharedMemoryHeader *header, const char *registry_name=0)
Check if a specific shared memory segment exists.
Definition: shm.cpp:1255
fawkes::SharedMemory::_shm_header
SharedMemory_header_t * _shm_header
general header as stored in the shared memory segment
Definition: shm.h:191
fawkes::SharedMemoryHeader::~SharedMemoryHeader
virtual ~SharedMemoryHeader()
Virtual destructor.
Definition: shm.h:36
fawkes::SharedMemory::_memptr
void * _memptr
Pointer to the data segment.
Definition: shm.h:182
fawkes::SemaphoreSet
IPC semaphore set.
Definition: semset.h:32
fawkes::SharedMemoryRegistry
Shared memory registry.
Definition: shm_registry.h:38
fawkes::SharedMemory::add_semaphore
void add_semaphore()
Add semaphore to shared memory segment.
Definition: shm.cpp:852
fawkes::SharedMemory::SharedMemory_header_t
General header.
Definition: shm.h:168
fawkes::SharedMemory::try_lock_for_write
bool try_lock_for_write()
Try to aquire lock on shared memory segment for writing.
Definition: shm.cpp:993
fawkes::SharedMemory::lock_for_read
void lock_for_read()
Lock shared memory segment for reading.
Definition: shm.cpp:909
fawkes::SharedMemoryHeader::clone
virtual SharedMemoryHeader * clone() const =0
Clone this shared memory header.
fawkes::SharedMemory::find
static SharedMemoryIterator find(const char *magic_token, SharedMemoryHeader *header, const char *registry_name=0)
Find SharedMemory segments.
Definition: shm.cpp:1268
fawkes::SharedMemory::set_destroy_on_delete
void set_destroy_on_delete(bool destroy)
Set deletion behaviour.
Definition: shm.cpp:839
fawkes::SharedMemory::SharedMemoryIterator::databuf
void * databuf() const
Get pointer to data buffer.
Definition: shm.cpp:1627
fawkes::SharedMemory::MaxNumConcurrentReaders
static const short MaxNumConcurrentReaders
Maximum number of concurrent readers.
Definition: shm.h:56