Subversion Repositories or1k

/*

 * linux/ipc/shm.c

 * Copyright (C) 1992, 1993 Krishna Balasubramanian

 *       Many improvements/fixes by Bruno Haible.

 * Replaced `struct shm_desc' by `struct vm_area_struct', July 1994.

 * Fixed the shm swap deallocation (shm_unuse()), August 1998 Andrea Arcangeli.

 *

 * /proc/sysvipc/shm support (c) 1999 Dragos Acostachioaie <dragos@iname.com>

 * BIGMEM support, Andrea Arcangeli <andrea@suse.de>

 * SMP thread shm, Jean-Luc Boyard <jean-luc.boyard@siemens.fr>

 * HIGHMEM support, Ingo Molnar <mingo@redhat.com>

 * Make shmmax, shmall, shmmni sysctl'able, Christoph Rohland <cr@sap.com>

 * Shared /dev/zero support, Kanoj Sarcar <kanoj@sgi.com>

 * Move the mm functionality over to mm/shmem.c, Christoph Rohland <cr@sap.com>

 *

 */

#include <linux/config.h>

#include <linux/slab.h>

#include <linux/shm.h>

#include <linux/init.h>

#include <linux/file.h>

#include <linux/mman.h>

#include <linux/proc_fs.h>

#include <asm/uaccess.h>

#include "util.h"

struct shmid_kernel /* private to the kernel */

{

        struct kern_ipc_perm    shm_perm;

        struct file *           shm_file;

        int                     id;

        unsigned long           shm_nattch;

        unsigned long           shm_segsz;

        time_t                  shm_atim;

        time_t                  shm_dtim;

        time_t                  shm_ctim;

        pid_t                   shm_cprid;

        pid_t                   shm_lprid;

};

#define shm_flags       shm_perm.mode

static struct file_operations shm_file_operations;

static struct vm_operations_struct shm_vm_ops;

static struct ipc_ids shm_ids;

#define shm_lock(id)    ((struct shmid_kernel*)ipc_lock(&shm_ids,id))

#define shm_unlock(id)  ipc_unlock(&shm_ids,id)

#define shm_lockall()   ipc_lockall(&shm_ids)

#define shm_unlockall() ipc_unlockall(&shm_ids)

#define shm_get(id)     ((struct shmid_kernel*)ipc_get(&shm_ids,id))

#define shm_buildid(id, seq) \

        ipc_buildid(&shm_ids, id, seq)

static int newseg (key_t key, int shmflg, size_t size);

static void shm_open (struct vm_area_struct *shmd);

static void shm_close (struct vm_area_struct *shmd);

#ifdef CONFIG_PROC_FS

static int sysvipc_shm_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data);

#endif

size_t  shm_ctlmax = SHMMAX;

size_t  shm_ctlall = SHMALL;

int     shm_ctlmni = SHMMNI;

static int shm_tot; /* total number of shared memory pages */

void __init shm_init (void)

{

        ipc_init_ids(&shm_ids, 1);

#ifdef CONFIG_PROC_FS

        create_proc_read_entry("sysvipc/shm", 0, 0, sysvipc_shm_read_proc, NULL);

#endif

}

static inline int shm_checkid(struct shmid_kernel *s, int id)

{

        if (ipc_checkid(&shm_ids,&s->shm_perm,id))

                return -EIDRM;

        return 0;

}

static inline struct shmid_kernel *shm_rmid(int id)

{

        return (struct shmid_kernel *)ipc_rmid(&shm_ids,id);

}

static inline int shm_addid(struct shmid_kernel *shp)

{

        return ipc_addid(&shm_ids, &shp->shm_perm, shm_ctlmni+1);

}

static inline void shm_inc (int id) {

        struct shmid_kernel *shp;

        if(!(shp = shm_lock(id)))

                BUG();

        shp->shm_atim = CURRENT_TIME;

        shp->shm_lprid = current->pid;

        shp->shm_nattch++;

        shm_unlock(id);

}

/* This is called by fork, once for every shm attach. */

static void shm_open (struct vm_area_struct *shmd)

{

        shm_inc (shmd->vm_file->f_dentry->d_inode->i_ino);

}

/*

 * shm_destroy - free the struct shmid_kernel

 *

 * @shp: struct to free

 *

 * It has to be called with shp and shm_ids.sem locked,

 * but returns with shp unlocked and freed.

 */

static void shm_destroy (struct shmid_kernel *shp)

{

        shm_tot -= (shp->shm_segsz + PAGE_SIZE - 1) >> PAGE_SHIFT;

        shm_rmid (shp->id);

        shm_unlock(shp->id);

        shmem_lock(shp->shm_file, 0);

        fput (shp->shm_file);

        kfree (shp);

}

/*

 * remove the attach descriptor shmd.

 * free memory for segment if it is marked destroyed.

 * The descriptor has already been removed from the current->mm->mmap list

 * and will later be kfree()d.

 */

static void shm_close (struct vm_area_struct *shmd)

{

        struct file * file = shmd->vm_file;

        int id = file->f_dentry->d_inode->i_ino;

        struct shmid_kernel *shp;

        down (&shm_ids.sem);

        /* remove from the list of attaches of the shm segment */

        if(!(shp = shm_lock(id)))

                BUG();

        shp->shm_lprid = current->pid;

        shp->shm_dtim = CURRENT_TIME;

        shp->shm_nattch--;

        if(shp->shm_nattch == 0 &&

           shp->shm_flags & SHM_DEST)

                shm_destroy (shp);

        else

                shm_unlock(id);

        up (&shm_ids.sem);

}

static int shm_mmap(struct file * file, struct vm_area_struct * vma)

{

        UPDATE_ATIME(file->f_dentry->d_inode);

        vma->vm_ops = &shm_vm_ops;

        shm_inc(file->f_dentry->d_inode->i_ino);

        return 0;

}

static struct file_operations shm_file_operations = {

        mmap:   shm_mmap

};

static struct vm_operations_struct shm_vm_ops = {

        open:   shm_open,       /* callback for a new vm-area open */

        close:  shm_close,      /* callback for when the vm-area is released */

        nopage: shmem_nopage,

};

static int newseg (key_t key, int shmflg, size_t size)

{

        int error;

        struct shmid_kernel *shp;

        int numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;

        struct file * file;

        char name[13];

        int id;

        if (size < SHMMIN || size > shm_ctlmax)

                return -EINVAL;

        if (shm_tot + numpages >= shm_ctlall)

                return -ENOSPC;

        shp = (struct shmid_kernel *) kmalloc (sizeof (*shp), GFP_USER);

        if (!shp)

                return -ENOMEM;

        sprintf (name, "SYSV%08x", key);

        file = shmem_file_setup(name, size);

        error = PTR_ERR(file);

        if (IS_ERR(file))

                goto no_file;

        error = -ENOSPC;

        id = shm_addid(shp);

        if(id == -1)

                goto no_id;

        shp->shm_perm.key = key;

        shp->shm_flags = (shmflg & S_IRWXUGO);

        shp->shm_cprid = current->pid;

        shp->shm_lprid = 0;

        shp->shm_atim = shp->shm_dtim = 0;

        shp->shm_ctim = CURRENT_TIME;

        shp->shm_segsz = size;

        shp->shm_nattch = 0;

        shp->id = shm_buildid(id,shp->shm_perm.seq);

        shp->shm_file = file;

        file->f_dentry->d_inode->i_ino = shp->id;

        file->f_op = &shm_file_operations;

        shm_tot += numpages;

        shm_unlock (id);

        return shp->id;

no_id:

        fput(file);

no_file:

        kfree(shp);

        return error;

}

asmlinkage long sys_shmget (key_t key, size_t size, int shmflg)

{

        struct shmid_kernel *shp;

        int err, id = 0;

        down(&shm_ids.sem);

        if (key == IPC_PRIVATE) {

                err = newseg(key, shmflg, size);

        } else if ((id = ipc_findkey(&shm_ids, key)) == -1) {

                if (!(shmflg & IPC_CREAT))

                        err = -ENOENT;

                else

                        err = newseg(key, shmflg, size);

        } else if ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL)) {

                err = -EEXIST;

        } else {

                shp = shm_lock(id);

                if(shp==NULL)

                        BUG();

                if (shp->shm_segsz < size)

                        err = -EINVAL;

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

                        err = -EACCES;

                else

                        err = shm_buildid(id, shp->shm_perm.seq);

                shm_unlock(id);

        }

        up(&shm_ids.sem);

        return err;

}

static inline unsigned long copy_shmid_to_user(void *buf, struct shmid64_ds *in, int version)

{

        switch(version) {

        case IPC_64:

                return copy_to_user(buf, in, sizeof(*in));

        case IPC_OLD:

            {

                struct shmid_ds out;

                ipc64_perm_to_ipc_perm(&in->shm_perm, &out.shm_perm);

                out.shm_segsz   = in->shm_segsz;

                out.shm_atime   = in->shm_atime;

                out.shm_dtime   = in->shm_dtime;

                out.shm_ctime   = in->shm_ctime;

                out.shm_cpid    = in->shm_cpid;

                out.shm_lpid    = in->shm_lpid;

                out.shm_nattch  = in->shm_nattch;

                return copy_to_user(buf, &out, sizeof(out));

            }

        default:

                return -EINVAL;

        }

}

struct shm_setbuf {

        uid_t   uid;

        gid_t   gid;

        mode_t  mode;

};

static inline unsigned long copy_shmid_from_user(struct shm_setbuf *out, void *buf, int version)

{

        switch(version) {

        case IPC_64:

            {

                struct shmid64_ds tbuf;

                if (copy_from_user(&tbuf, buf, sizeof(tbuf)))

                        return -EFAULT;

                out->uid        = tbuf.shm_perm.uid;

                out->gid        = tbuf.shm_perm.gid;

                out->mode       = tbuf.shm_flags;

                return 0;

            }

        case IPC_OLD:

            {

                struct shmid_ds tbuf_old;

                if (copy_from_user(&tbuf_old, buf, sizeof(tbuf_old)))

                        return -EFAULT;

                out->uid        = tbuf_old.shm_perm.uid;

                out->gid        = tbuf_old.shm_perm.gid;

                out->mode       = tbuf_old.shm_flags;

                return 0;

            }

        default:

                return -EINVAL;

        }

}

static inline unsigned long copy_shminfo_to_user(void *buf, struct shminfo64 *in, int version)

{

        switch(version) {

        case IPC_64:

                return copy_to_user(buf, in, sizeof(*in));

        case IPC_OLD:

            {

                struct shminfo out;

                if(in->shmmax > INT_MAX)

                        out.shmmax = INT_MAX;

                else

                        out.shmmax = (int)in->shmmax;

                out.shmmin      = in->shmmin;

                out.shmmni      = in->shmmni;

                out.shmseg      = in->shmseg;

                out.shmall      = in->shmall;

                return copy_to_user(buf, &out, sizeof(out));

            }

        default:

                return -EINVAL;

        }

}

static void shm_get_stat (unsigned long *rss, unsigned long *swp)

{

        struct shmem_inode_info *info;

        int i;

        *rss = 0;

        *swp = 0;

        for(i = 0; i <= shm_ids.max_id; i++) {

                struct shmid_kernel* shp;

                struct inode * inode;

                shp = shm_get(i);

                if(shp == NULL)

                        continue;

                inode = shp->shm_file->f_dentry->d_inode;

                info = SHMEM_I(inode);

                spin_lock (&info->lock);

                *rss += inode->i_mapping->nrpages;

                *swp += info->swapped;

                spin_unlock (&info->lock);

        }

}

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

{

        struct shm_setbuf setbuf;

        struct shmid_kernel *shp;

        int err, version;

        if (cmd < 0 || shmid < 0)

                return -EINVAL;

        version = ipc_parse_version(&cmd);

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

        case IPC_INFO:

        {

                struct shminfo64 shminfo;

                memset(&shminfo,0,sizeof(shminfo));

                shminfo.shmmni = shminfo.shmseg = shm_ctlmni;

                shminfo.shmmax = shm_ctlmax;

                shminfo.shmall = shm_ctlall;

                shminfo.shmmin = SHMMIN;

                if(copy_shminfo_to_user (buf, &shminfo, version))

                        return -EFAULT;

                /* reading a integer is always atomic */

                err= shm_ids.max_id;

                if(err<0)

                        err = 0;

                return err;

        }

        case SHM_INFO:

        {

                struct shm_info shm_info;

                memset(&shm_info,0,sizeof(shm_info));

                down(&shm_ids.sem);

                shm_lockall();

                shm_info.used_ids = shm_ids.in_use;

                shm_get_stat (&shm_info.shm_rss, &shm_info.shm_swp);

                shm_info.shm_tot = shm_tot;

                shm_info.swap_attempts = 0;

                shm_info.swap_successes = 0;

                err = shm_ids.max_id;

                shm_unlockall();

                up(&shm_ids.sem);

                if(copy_to_user (buf, &shm_info, sizeof(shm_info)))

                        return -EFAULT;

                return err < 0 ? 0 : err;

        }

        case SHM_STAT:

        case IPC_STAT:

        {

                struct shmid64_ds tbuf;

                int result;

                memset(&tbuf, 0, sizeof(tbuf));

                shp = shm_lock(shmid);

                if(shp==NULL)

                        return -EINVAL;

                if(cmd==SHM_STAT) {

                        err = -EINVAL;

                        if (shmid > shm_ids.max_id)

                                goto out_unlock;

                        result = shm_buildid(shmid, shp->shm_perm.seq);

                } else {

                        err = shm_checkid(shp,shmid);

                        if(err)

                                goto out_unlock;

                        result = 0;

                }

                err=-EACCES;

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

                        goto out_unlock;

                kernel_to_ipc64_perm(&shp->shm_perm, &tbuf.shm_perm);

                tbuf.shm_segsz  = shp->shm_segsz;

                tbuf.shm_atime  = shp->shm_atim;

                tbuf.shm_dtime  = shp->shm_dtim;

                tbuf.shm_ctime  = shp->shm_ctim;

                tbuf.shm_cpid   = shp->shm_cprid;

                tbuf.shm_lpid   = shp->shm_lprid;

                tbuf.shm_nattch = shp->shm_nattch;

                shm_unlock(shmid);

                if(copy_shmid_to_user (buf, &tbuf, version))

                        return -EFAULT;

                return result;

        }

        case SHM_LOCK:

        case SHM_UNLOCK:

        {

/* 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 (!capable(CAP_IPC_LOCK))

                        return -EPERM;

                shp = shm_lock(shmid);

                if(shp==NULL)

                        return -EINVAL;

                err = shm_checkid(shp,shmid);

                if(err)

                        goto out_unlock;

                if(cmd==SHM_LOCK) {

                        shmem_lock(shp->shm_file, 1);

                        shp->shm_flags |= SHM_LOCKED;

                } else {

                        shmem_lock(shp->shm_file, 0);

                        shp->shm_flags &= ~SHM_LOCKED;

                }

                shm_unlock(shmid);

                return err;

        }

        case IPC_RMID:

        {

                /*

                 *      We cannot simply remove the file. The SVID states

                 *      that the block remains until the last person

                 *      detaches from it, then is deleted. A shmat() on

                 *      an RMID segment is legal in older Linux and if

                 *      we change it apps break...

                 *

                 *      Instead we set a destroyed flag, and then blow

                 *      the name away when the usage hits zero.

                 */

                down(&shm_ids.sem);

                shp = shm_lock(shmid);

                err = -EINVAL;

                if (shp == NULL)

                        goto out_up;

                err = shm_checkid(shp, shmid);

                if(err)

                        goto out_unlock_up;

                if (current->euid != shp->shm_perm.uid &&

                    current->euid != shp->shm_perm.cuid &&

                    !capable(CAP_SYS_ADMIN)) {

                        err=-EPERM;

                        goto out_unlock_up;

                }

                if (shp->shm_nattch){

                        shp->shm_flags |= SHM_DEST;

                        /* Do not find it any more */

                        shp->shm_perm.key = IPC_PRIVATE;

                        shm_unlock(shmid);

                } else

                        shm_destroy (shp);

                up(&shm_ids.sem);

                return err;

        }

        case IPC_SET:

        {

                if(copy_shmid_from_user (&setbuf, buf, version))

                        return -EFAULT;

                down(&shm_ids.sem);

                shp = shm_lock(shmid);

                err=-EINVAL;

                if(shp==NULL)

                        goto out_up;

                err = shm_checkid(shp,shmid);

                if(err)

                        goto out_unlock_up;

                err=-EPERM;

                if (current->euid != shp->shm_perm.uid &&

                    current->euid != shp->shm_perm.cuid &&

                    !capable(CAP_SYS_ADMIN)) {

                        goto out_unlock_up;

                }

                shp->shm_perm.uid = setbuf.uid;

                shp->shm_perm.gid = setbuf.gid;

                shp->shm_flags = (shp->shm_flags & ~S_IRWXUGO)

                        | (setbuf.mode & S_IRWXUGO);

                shp->shm_ctim = CURRENT_TIME;

                break;

        }

        default:

                return -EINVAL;

        }

        err = 0;

out_unlock_up:

        shm_unlock(shmid);

out_up:

        up(&shm_ids.sem);

        return err;

out_unlock:

        shm_unlock(shmid);

        return err;

}

/*

 * Fix shmaddr, allocate descriptor, map shm, add attach descriptor to lists.

 */

asmlinkage long sys_shmat (int shmid, char *shmaddr, int shmflg, ulong *raddr)

{

        struct shmid_kernel *shp;

        unsigned long addr;

        unsigned long size;

        struct file * file;

        int    err;

        unsigned long flags;

        unsigned long prot;

        unsigned long o_flags;

        int acc_mode;

        void *user_addr;

        if (shmid < 0)

                return -EINVAL;

        if ((addr = (ulong)shmaddr)) {

                if (addr & (SHMLBA-1)) {

                        if (shmflg & SHM_RND)

                                addr &= ~(SHMLBA-1);       /* round down */

                        else

                                return -EINVAL;

                }

                flags = MAP_SHARED | MAP_FIXED;

        } else {

                if ((shmflg & SHM_REMAP))

                        return -EINVAL;

                flags = MAP_SHARED;

        }

        if (shmflg & SHM_RDONLY) {

                prot = PROT_READ;

                o_flags = O_RDONLY;

                acc_mode = S_IRUGO;

        } else {

                prot = PROT_READ | PROT_WRITE;

                o_flags = O_RDWR;

                acc_mode = S_IRUGO | S_IWUGO;

        }

        /*

         * We cannot rely on the fs check since SYSV IPC does have an

         * additional creator id...

         */

        shp = shm_lock(shmid);

        if(shp == NULL)

                return -EINVAL;

        err = shm_checkid(shp,shmid);

        if (err) {

                shm_unlock(shmid);

                return err;

        }

        if (ipcperms(&shp->shm_perm, acc_mode)) {

                shm_unlock(shmid);

                return -EACCES;

        }

        file = shp->shm_file;

        size = file->f_dentry->d_inode->i_size;

        shp->shm_nattch++;

        shm_unlock(shmid);

        down_write(&current->mm->mmap_sem);

        if (addr && !(shmflg & SHM_REMAP)) {

                user_addr = ERR_PTR(-EINVAL);

                if (find_vma_intersection(current->mm, addr, addr + size))

                        goto invalid;

                /*

                 * If shm segment goes below stack, make sure there is some

                 * space left for the stack to grow (at least 4 pages).

                 */

                if (addr < current->mm->start_stack &&

                    addr > current->mm->start_stack - size - PAGE_SIZE * 5)

                        goto invalid;

        }

        user_addr = (void*) do_mmap (file, addr, size, prot, flags, 0);

invalid:

        up_write(&current->mm->mmap_sem);

        down (&shm_ids.sem);

        if(!(shp = shm_lock(shmid)))

                BUG();

        shp->shm_nattch--;

        if(shp->shm_nattch == 0 &&

           shp->shm_flags & SHM_DEST)

                shm_destroy (shp);

        else

                shm_unlock(shmid);

        up (&shm_ids.sem);