linux IPC util.c分析

#include
#include
#include
#include
#include
#include
#include
#include
#include

#if defined(CONFIG_SYSVIPC)

#include "util.h"

struct ipc_ids {
    int size;
    int in_use;
    int max_id;
    unsigned short seq;
    unsigned short seq_max;
    struct semaphore sem;    
    spinlock_t ary;
    struct ipc_id* entries;
};

struct ipc_id {
    struct kern_ipc_perm* p;
};


/**
 *    初始化ipc子系统
 *
 *    The various system5 IPC resources (semaphores, messages and shared
 *    memory are initialised
 */
 
void __init ipc_init (void)
{
    sem_init();
    msg_init();
    shm_init();
    return;
}

/**
初始化ipc标识
 *
 *    Given a size for the ipc identifier range (limited below IPCMNI)
 *    set up the sequence range to use then allocate and initialise the
 *    array itself.
 */
 
void __init ipc_init_ids(struct ipc_ids* ids, int size)
{
    int i;
    sema_init(&ids->sem,1);
//限定size大小不超过IPCMNI
    if(size > IPCMNI)
        size = IPCMNI;
    ids->size = size;
    ids->in_use = 0;
    ids->max_id = -1;
    ids->seq = 0;
    {
        int seq_limit = INT_MAX/SEQ_MULTIPLIER;
        if(seq_limit > USHRT_MAX)
            ids->seq_max = USHRT_MAX;
         else
             ids->seq_max = seq_limit;
    }
//分配size大小的struct ipc_id空间
    ids->entries = ipc_alloc(sizeof(struct ipc_id)*size);

    if(ids->entries == NULL) {
        printk(KERN_ERR "ipc_init_ids() failed, ipc service disabled.\n");
        ids->size = 0;
    }
    ids->ary = SPIN_LOCK_UNLOCKED;
//初始化entries指针
    for(i=0;isize;i++)
        ids->entries[i].p = NULL;
}

/**
 *    在ipc标识集中查找键值为key的ipc标识
 *
 *    Returns the identifier if found or -1 if not.
 */
 
int ipc_findkey(struct ipc_ids* ids, key_t key)
{
    int id;
    struct kern_ipc_perm* p;

    for (id = 0; id <= ids->max_id; id++) {
        p = ids->entries[id].p;
        if(p==NULL)
            continue;
        if (key == p->key)
            return id;
    }
    return -1;
}

static int grow_ary(struct ipc_ids* ids, int newsize)
{
    struct ipc_id* new;
    struct ipc_id* old;
    int i;
//限定newsize大小不超过IPCMNI
    if(newsize > IPCMNI)
        newsize = IPCMNI;
    if(newsize <= ids->size)
        return newsize;
//分配newsize大小的struct ipc_id空间
    new = ipc_alloc(sizeof(struct ipc_id)*newsize);
    if(new == NULL)
        return ids->size;
    memcpy(new, ids->entries, sizeof(struct ipc_id)*ids->size);
    for(i=ids->size;i        new[i].p = NULL;
    }
    spin_lock(&ids->ary);

    old = ids->entries;
    ids->entries = new;
    i = ids->size;
    ids->size = newsize;
    spin_unlock(&ids->ary);
//回收原先分配的struct ipc_id空间
    ipc_free(old, sizeof(struct ipc_id)*i);
    return ids->size;
}

/**
 在ipc标识集中添加一个新标识符
 *
 *    Add an entry 'new' to the IPC arrays. The permissions object is
 *    initialised and the first free entry is set up and the id assigned
 *    is returned. The list is returned in a locked state on success.
 *    On failure the list is not locked and -1 is returned.
 */
 
int ipc_addid(struct ipc_ids* ids, struct kern_ipc_perm* new, int size)
{
    int id;

    size = grow_ary(ids,size);
//依次查找,直到发现第一个非空项
    for (id = 0; id < size; id++) {
        if(ids->entries[id].p == NULL)
            goto found;
    }
    return -1;
found:
    ids->in_use++;
    if (id > ids->max_id)
        ids->max_id = id;

    new->cuid = new->uid = current->euid;
    new->gid = new->cgid = current->egid;

    new->seq = ids->seq++;
    if(ids->seq > ids->seq_max)
        ids->seq = 0;

    spin_lock(&ids->ary);
    ids->entries[id].p = new;
    return id;
}

/**
从ipc标识集中删除一个标识符
 *    The identifier must be valid, and in use. The kernel will panic if
 *    fed an invalid identifier. The entry is removed and internal
 *    variables recomputed. The object associated with the identifier
 *    is returned.
 */
 
struct kern_ipc_perm* ipc_rmid(struct ipc_ids* ids, int id)
{
    struct kern_ipc_perm* p;
    int lid = id % SEQ_MULTIPLIER;
    if(lid >= ids->size)
        BUG();
    p = ids->entries[lid].p;
    ids->entries[lid].p = NULL;
    if(p==NULL)
        BUG();
    ids->in_use--;

    if (lid == ids->max_id) {
        do {
            lid--;
            if(lid == -1)
                break;
        } while (ids->entries[lid].p == NULL);
        ids->max_id = lid;
    }
    return p;
}

/**
 分配size大小的空间
 *    Allocate memory from the appropriate pools and return a pointer to it.
 *    NULL is returned if the allocation fails
 */
 
void* ipc_alloc(int size)
{
    void* out;
    if(size > PAGE_SIZE)
        out = vmalloc(size);
    else
        out = kmalloc(size, GFP_KERNEL);
    return out;
}

/**
 释放ptr指向的空间
 *
 *    Free a block created with ipc_alloc. The caller must know the size
 *    used in the allocation call.
 */
 
void ipc_free(void* ptr, int size)
{
    if(size > PAGE_SIZE)
        vfree(ptr);
    else
        kfree(ptr);
}

/**
 查看ipc访问权限
 *    Check user, group, other permissions for access
 *    to ipc resources. return 0 if allowed
 */
 
int ipcperms (struct kern_ipc_perm *ipcp, short flag)
{    /* flag will most probably be 0 or S_...UGO from */
    int requested_mode, granted_mode;

    requested_mode = (flag >> 6) | (flag >> 3) | flag;
    granted_mode = ipcp->mode;
    if (current->euid == ipcp->cuid || current->euid == ipcp->uid)
        granted_mode >>= 6;
    else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
        granted_mode >>= 3;
    /* is there some bit set in requested_mode but not in granted_mode? */
    if ((requested_mode & ~granted_mode & 0007) &&
        !capable(CAP_IPC_OWNER))
        return -1;

    return 0;
}

/**
 转换struct kern_ipc_perm数据到用户空间
 *
 *    Turn the kernel object 'in' into a set of permissions descriptions
 *    for returning to userspace (out).
 */
 

void kernel_to_ipc64_perm (struct kern_ipc_perm *in, struct ipc64_perm *out)
{
    out->key    = in->key;
    out->uid    = in->uid;
    out->gid    = in->gid;
    out->cuid    = in->cuid;
    out->cgid    = in->cgid;
    out->mode    = in->mode;
    out->seq    = in->seq;
}

/**
 转换struct ipc64_perm数据到struct ipc_perm
 *    Turn the new style permissions object in into a compatibility
 *    object and store it into the 'out' pointer.
 */
 
void ipc64_perm_to_ipc_perm (struct ipc64_perm *in, struct ipc_perm *out)
{
    out->key    = in->key;
    out->uid    = NEW_TO_OLD_UID(in->uid);
    out->gid    = NEW_TO_OLD_GID(in->gid);
    out->cuid    = NEW_TO_OLD_UID(in->cuid);
    out->cgid    = NEW_TO_OLD_GID(in->cgid);
    out->mode    = in->mode;
    out->seq    = in->seq;
}

#endif /* CONFIG_SYSVIPC */