Reputation: 309
Can any one look into this and suggest me with an API.
We have APIs for a process which can create and/or attach a shared memory to its own process. But I don't find an API to attach a shared memory to one process by other process(for e.g., process A should call one API(like shmat()) to attach the shared memory to process B).
Upvotes: 0
Views: 1720
Reputation: 26930
You are asking to attach the process memory of other process, right?
Just open(2)
the file /proc/<pid>/mem
and use it. Check the /proc/<pid>/map
for the list of usable address in the file.
Upvotes: 0
Reputation: 33655
Let's see, allow one process to force a shared memory segment on to another? What is the receiver going to do with it? How will it know it now has mapped this block in - what is expected of it.
You're thinking about the problem the wrong way - simply hoisting a block of memory on to a second process is not going to allow you to do what you want. You need to notify the second process also that it has now mapped this block and so can start doing stuff with it. I suggest you take a step back and really look at your design and what you are doing. My recommended approach would be
As for wrapping shared memory in a nice library - consider boost::interprocess.
Upvotes: 0
Reputation: 882806
Shared memory doesn't belong to any particular process (unless you create it with a private IPC_PRIVATE
key). It belongs to the system.
So, when you use shmget
with a non-private key (and the IPC_CREAT
flag), you will either create a shared memory block or attach to an existing one.
You need a way for both processes to use the same IPC key and this is often done by using ftok
which uses a file specification and an identifier to give you an IPC key for use in the shmget
call (and other IPC type calls, such as msgget
or semget
).
For example, in the programs pax1
and pax2
, you may have a code segment like:
int getMyShMem (void) {
key_t mykey = ftok ("/var/pax.cfg", 0); // only one shm block so use id of 0
if (mykey == (key_t)-1) // no go.
return -1;
return shmget (mykey, 1024, IPC_CREAT); // get (or make) a 1K block.
}
By having both processes use the same file specification and ID, they'll get the same shared memory block.
You can use different IDs to give you distinct shared memory blocks all based on the same file (you may, for example, want one for a configuration shared memory block and another for storing shared state).
And, given that it's your configuration file the IPC key is based on, the chances of other programs using it is minuscule (I think it may be zero but I'm not 100% sure).
You can't forcefully inject shared memory into a process from outside that process (well, you may be able to but it would be both dangerous and require all sorts of root-level permissions). That would break the protected process model and turn you system into something about as secure as MS-DOS :-)
Upvotes: 1