Update copyright to LGPL on all files
[dyninst.git] / valueAdded / sharedMem / h / SharedMem.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 /* $Id: shmMgr.h,v 1.1 2006/11/22 21:45:00 bernat Exp $
33  * shmMgr: an interface to allocating/freeing memory in the 
34  * shared segment. Will eventually support allocating a new
35  * shared segment and attaching to it.
36  */
37
38 #ifndef shmMgr_h
39 #define shmMgr_h
40
41 // these defaults can be overidden by "SHARED_MUTATEE_LIB" env variable
42 #if defined(os_windows)
43 #define SHARED_MUTATEE_LIB "libdynShmMutatee.dll"
44 #else
45 #define SHARED_MUTATEE_LIB "libdynShmMutatee.so"
46 #endif
47
48 class BPatch_process;
49 class ShmSegment;
50 class shmMgrPreallocInternal;
51 class BPatch_type;
52 class BPatch_variableExpr;
53
54 #include "dyntypes.h"
55
56 #include      <sys/types.h>
57 #include      <sys/shm.h>
58 #include "BPatch_Vector.h"
59
60
61 class shMallocHandle {
62     friend class shmMgr;
63  private:
64     Dyninst::Address addrInMutator_;
65     BPatch_variableExpr *expr_;
66     shMallocHandle(Dyninst::Address a, BPatch_variableExpr *e) : addrInMutator_(a), expr_(e) {};
67  public:
68     Dyninst::Address addressInMutatee() const;
69     Dyninst::Address addressInMutator() const { return addrInMutator_; }
70     BPatch_variableExpr *expr() const { return expr_; }
71     ~shMallocHandle();
72 };
73
74 class shmMgr {
75  private:
76     key_t nextKeyToTry;
77     unsigned shmSegSize;
78     
79     BPatch_Vector<ShmSegment *> theShms;
80     unsigned totalShmSize;
81     unsigned freespace;
82
83     BPatch_process *app;
84
85     bool freeWhenDeleted;
86
87     Dyninst::Address  applicToDaemon(Dyninst::Address  addr) const;
88     Dyninst::Address  daemonToApplic(Dyninst::Address  addr) const;
89     Dyninst::Address  getOffsetDaemon(Dyninst::Address  addr) const;
90     Dyninst::Address  getOffsetApplic(Dyninst::Address  addr) const;
91
92     /* Do all the work of creating a new shared memory segment
93        and getting the RT lib to hook to it */
94     void addShmSegment(Dyninst::Address  /*size*/);
95
96     shmMgr(BPatch_process *proc, key_t shmSegKey, unsigned shmSize_, bool freeWhenDel = true);
97     // Fork constructor
98     shmMgr(const shmMgr *par, BPatch_process *child_proc);
99     shmMgr() {};
100
101     bool initialize();
102
103     Dyninst::Address malloc_int(unsigned size, bool align = false);
104
105     Dyninst::Address  translateFromParentDaemon(Dyninst::Address  addr, const shmMgr *parent);
106     Dyninst::Address  translateFromParentApplic(Dyninst::Address  addr, const shmMgr *parent);
107     
108   public:
109     
110     // Create a new shared memory manager and return it. 
111     // proc: the associated BPatch process
112     // shmSegKey: the shared memory key
113     // defaultSegmentSize: the initial size for segments (multiple segments are supported)
114     // automaticFree: delete shared memory when this object is freed?
115     static shmMgr *createSharedManager(BPatch_process *proc,
116                                        key_t shmSegKey,
117                                        unsigned defaultSegmentSize,
118                                        bool automaticFree);
119     ~shmMgr();
120     
121     // Malloc and free equivalents
122     shMallocHandle *malloc(unsigned size, bool align = true, BPatch_type *type = NULL);
123     void free(shMallocHandle *handle);
124     
125     // CALL ON EXEC
126     // TODO: if Dyninst ever supports chaining of handlers,
127     // then register this explicitly.
128     //void handleExec();
129     // Not implemented yet.
130
131     // Call on fork to get a shmMgr for the child process.
132     shmMgr *handleFork(BPatch_process *childProc);    
133     
134     shMallocHandle *getChildHandle(shMallocHandle *parentHandle);
135
136 };
137
138
139
140
141 #endif /*shmMgr_h*/