Shm是Unix进程间通信最常见也最重要的方法之一。

它是如何实现的呢？

我们来看下入下内容。

初始化：

void shm_init (void)

{

int id;

for (id = 0; id < SHMMNI; id++)

shm_segs[id] = (struct shmid_ds *) IPC_UNUSED;

shm_tot = shm_rss = shm_seq = max_shmid = used_segs = 0;

shm_lock = NULL;

return;

}寻找共享内存的ID。

static int findkey (key_t key)

{

int id;

struct shmid_ds *shp;

for (id=0; id <= max_shmid; id++) {

while ((shp = shm_segs[id]) == IPC_NOID)

sleep_on (&shm_lock);

if (shp == IPC_UNUSED)

continue;

if (key == shp->shm_perm.key)

return id;

}

return -1;

}

获取共享内存：

int sys_shmget (key_t key, int size, int shmflg)

{

struct shmid_ds *shp;

int id = 0;

if (size < 0 || size > SHMMAX)

return -EINVAL;

if (key == IPC_PRIVATE)

return newseg(key, shmflg, size);

if ((id = findkey (key)) == -1) {

if (!(shmflg & IPC_CREAT))

return -ENOENT;

return newseg(key, shmflg, size);

}

if ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL))

return -EEXIST;

shp = shm_segs[id];

if (shp->shm_perm.mode & SHM_DEST)

return -EIDRM;

if (size > shp->shm_segsz)

return -EINVAL;

if (ipcperms (&shp->shm_perm, shmflg))

return -EACCES;

return shp->shm_perm.seq*SHMMNI + id;

}

共享内存属性设置：

int sys_shmctl (int shmid, int cmd, struct shmid_ds *buf)

{

struct shmid_ds *shp, tbuf;

struct ipc_perm *ipcp;

int id, err;

if (cmd < 0 || shmid < 0)

return -EINVAL;

if (cmd == IPC_SET) {

if (!buf)

return -EFAULT;

err = verify_area (VERIFY_READ, buf, sizeof (*buf));

if (err)

return err;

memcpy_fromfs (&tbuf, buf, sizeof (*buf));

}

switch (cmd) { /* replace with proc interface ? */

case IPC_INFO:

{

struct shminfo shminfo;

if (!buf)

return -EFAULT;

shminfo.shmmni = SHMMNI;

shminfo.shmmax = SHMMAX;

shminfo.shmmin = SHMMIN;

shminfo.shmall = SHMALL;

shminfo.shmseg = SHMSEG;

err = verify_area (VERIFY_WRITE, buf, sizeof (struct shminfo));

if (err)

return err;

memcpy_tofs (buf, &shminfo, sizeof(struct shminfo));

return max_shmid;

}

case SHM_INFO:

{

struct shm_info shm_info;

if (!buf)

return -EFAULT;

err = verify_area (VERIFY_WRITE, buf, sizeof (shm_info));

if (err)

return err;

shm_info.used_ids = used_segs;

shm_info.shm_rss = shm_rss;

shm_info.shm_tot = shm_tot;

shm_info.shm_swp = shm_swp;

shm_info.swap_attempts = swap_attempts;

shm_info.swap_successes = swap_successes;

memcpy_tofs (buf, &shm_info, sizeof(shm_info));

return max_shmid;

}

case SHM_STAT:

if (!buf)

return -EFAULT;

err = verify_area (VERIFY_WRITE, buf, sizeof (*shp));

if (err)

return err;

if (shmid > max_shmid)

return -EINVAL;

shp = shm_segs[shmid];

if (shp == IPC_UNUSED || shp == IPC_NOID)

return -EINVAL;

if (ipcperms (&shp->shm_perm, S_IRUGO))

return -EACCES;

id = shmid + shp->shm_perm.seq * SHMMNI;

memcpy_tofs (buf, shp, sizeof(*shp));

return id;

}

shp = shm_segs[id = shmid % SHMMNI];

if (shp == IPC_UNUSED || shp == IPC_NOID)

return -EINVAL;

ipcp = &shp->shm_perm;

if (ipcp->seq != shmid / SHMMNI)

return -EIDRM;

switch (cmd) {

case SHM_UNLOCK:

if (!suser())

return -EPERM;

if (!(ipcp->mode & SHM_LOCKED))

return -EINVAL;

ipcp->mode &= ~SHM_LOCKED;

break;

case SHM_LOCK:

/* Allow superuser to lock segment in memory */

/* Should the pages be faulted in here or leave it to user? */

/* need to determine interaction with current->swappable */

if (!suser())

return -EPERM;

if (ipcp->mode & SHM_LOCKED)

return -EINVAL;

ipcp->mode |= SHM_LOCKED;

break;

case IPC_STAT:

if (ipcperms (ipcp, S_IRUGO))

return -EACCES;

if (!buf)

return -EFAULT;

err = verify_area (VERIFY_WRITE, buf, sizeof (*shp));

if (err)

return err;

memcpy_tofs (buf, shp, sizeof(*shp));

break;

case IPC_SET:

if (suser() || current->euid == shp->shm_perm.uid ||

current->euid == shp->shm_perm.cuid) {

ipcp->uid = tbuf.shm_perm.uid;

ipcp->gid = tbuf.shm_perm.gid;

ipcp->mode = (ipcp->mode & ~S_IRWXUGO)

| (tbuf.shm_perm.mode & S_IRWXUGO);

shp->shm_ctime = CURRENT_TIME;

break;

}

return -EPERM;

case IPC_RMID:

if (suser() || current->euid == shp->shm_perm.uid ||

current->euid == shp->shm_perm.cuid) {

shp->shm_perm.mode |= SHM_DEST;

if (shp->shm_nattch <= 0)

killseg (id);

break;

}

return -EPERM;

default:

return -EINVAL;

}

return 0;

}

SHM的SWAP：

/*

* Goes through counter = (shm_rss << prio) present shm pages.

*/

static unsigned long swap_id = 0; /* currently being swapped */

static unsigned long swap_idx = 0; /* next to swap */

int shm_swap (int prio)

{

unsigned long page;

struct shmid_ds *shp;

struct shm_desc *shmd;

unsigned int swap_nr;

unsigned long id, idx, invalid = 0;

int counter;

counter = shm_rss >> prio;

if (!counter || !(swap_nr = get_swap_page()))

return 0;

check_id:

shp = shm_segs[swap_id];

if (shp == IPC_UNUSED || shp == IPC_NOID || shp->shm_perm.mode & SHM_LOCKED ) {

swap_idx = 0;

if (++swap_id > max_shmid)

swap_id = 0;

goto check_id;

}

id = swap_id;

check_table:

idx = swap_idx++;

if (idx >= shp->shm_npages) {

swap_idx = 0;

if (++swap_id > max_shmid)

swap_id = 0;

goto check_id;

}

page = shp->shm_pages[idx];

if (!(page & PAGE_PRESENT))

goto check_table;

swap_attempts++;

if (--counter < 0) { /* failed */

if (invalid)

invalidate();

swap_free (swap_nr);

return 0;

}

for (shmd = shp->attaches; shmd; shmd = shmd->seg_next) {

unsigned long tmp, *pte;

if ((shmd->shm_sgn >> SHM_ID_SHIFT & SHM_ID_MASK) != id) {

printk ("shm_swap: id=%ld does not match shmd\n", id);

continue;

}

tmp = shmd->start + (idx << PAGE_SHIFT);

if (tmp >= shmd->end) {

printk ("shm_swap: too large idx=%ld id=%ld PANIC\n",idx, id);

continue;

}

pte = PAGE_DIR_OFFSET(shmd->task->tss.cr3,tmp);

if (!(*pte & 1)) {

printk("shm_swap: bad pgtbl! id=%ld start=%lx idx=%ld\n",

id, shmd->start, idx);

*pte = 0;

continue;

}

pte = (ulong *) (PAGE_MASK & *pte);

pte += ((tmp >> PAGE_SHIFT) & (PTRS_PER_PAGE-1));

tmp = *pte;

if (!(tmp & PAGE_PRESENT))

continue;

if (tmp & PAGE_ACCESSED) {

*pte &= ~PAGE_ACCESSED;

continue;

}

tmp = shmd->shm_sgn | idx << SHM_IDX_SHIFT;

*pte = tmp;

mem_map[MAP_NR(page)]--;

shmd->task->rss--;

invalid++;

}

if (mem_map[MAP_NR(page)] != 1)

goto check_table;

page &= PAGE_MASK;

shp->shm_pages[idx] = swap_nr;

if (invalid)

invalidate();

write_swap_page (swap_nr, (char *) page);

free_page (page);

swap_successes++;

shm_swp++;

shm_rss--;

return 1;

} 其实，共享内存并非神秘的魔域。它也就仅仅是个资源管理方案而已。