shm.h

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

Generated on 1 Mar 2011 for Fawkes API by  doxygen 1.6.1