Return to ioport.c CVS log

Up to [Early Linux] / linux / kernel

Annotation of linux/kernel/ioport.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     linux/kernel/ioport.c
        !             3:  *
        !             4:  * This contains the io-permission bitmap code - written by obz, with changes
        !             5:  * by Linus.
        !             6:  */
        !             7: 
        !             8: #include <linux/sched.h>
        !             9: #include <linux/kernel.h>
        !            10: 
        !            11: #include <sys/types.h>
        !            12: #include <errno.h>
        !            13: 
        !            14: #define _IODEBUG
        !            15: 
        !            16: #ifdef IODEBUG
        !            17: static char * ios(unsigned long l)
        !            18: {
        !            19:        static char str[33] = { '\0' };
        !            20:        int i;
        !            21:        unsigned long mask;
        !            22: 
        !            23:        for (i = 0, mask = 0x80000000; i < 32; ++i, mask >>= 1)
        !            24:                str[i] = (l & mask) ? '1' : '0';
        !            25:        return str;
        !            26: }
        !            27: 
        !            28: static void dump_io_bitmap(void)
        !            29: {
        !            30:        int i, j;
        !            31:        int numl = sizeof(current->tss.io_bitmap) >> 2;
        !            32: 
        !            33:        for (i = j = 0; j < numl; ++i)
        !            34:        {
        !            35:                printk("%4d [%3x]: ", 64*i, 64*i);
        !            36:                printk("%s ", ios(current->tss.io_bitmap[j++]));
        !            37:                if (j < numl)
        !            38:                        printk("%s", ios(current->tss.io_bitmap[j++]));
        !            39:                printk("\n");
        !            40:        }
        !            41: }
        !            42: #endif
        !            43: 
        !            44: /*
        !            45:  * this changes the io permissions bitmap in the current task.
        !            46:  */
        !            47: int sys_ioperm(unsigned long from, unsigned long num, int turn_on)
        !            48: {
        !            49:        unsigned long froml, lindex, tnum, numl, rindex, mask;
        !            50:        unsigned long *iop;
        !            51: 
        !            52:        froml = from >> 5;
        !            53:        lindex = from & 0x1f;
        !            54:        tnum = lindex + num;
        !            55:        numl = (tnum + 0x1f) >> 5;
        !            56:        rindex = tnum & 0x1f;
        !            57: 
        !            58:        if (!suser())
        !            59:                return -EPERM;
        !            60:        if (froml * 32 + tnum > sizeof(current->tss.io_bitmap) * 8 - 8)
        !            61:                return -EINVAL;
        !            62: 
        !            63: #ifdef IODEBUG
        !            64:        printk("io: from=%d num=%d %s\n", from, num, (turn_on ? "on" : "off"));
        !            65: #endif
        !            66: 
        !            67:        if (numl) {
        !            68:                iop = (unsigned long *)current->tss.io_bitmap + froml;
        !            69:                if (lindex != 0) {
        !            70:                        mask = (~0 << lindex);
        !            71:                        if (--numl == 0 && rindex)
        !            72:                                mask &= ~(~0 << rindex);
        !            73:                        if (turn_on)
        !            74:                                *iop++ &= ~mask;
        !            75:                        else
        !            76:                                *iop++ |= mask;
        !            77:                }
        !            78:                if (numl) {
        !            79:                        if (rindex)
        !            80:                                --numl;
        !            81:                        mask = (turn_on ? 0 : ~0);
        !            82:                        while (numl--)
        !            83:                                *iop++ = mask;
        !            84:                        if (numl && rindex) {
        !            85:                                mask = ~(~0 << rindex);
        !            86:                                if (turn_on)
        !            87:                                        *iop++ &= ~mask;
        !            88:                                else
        !            89:                                        *iop++ |= mask;
        !            90:                        }
        !            91:                }
        !            92:        }
        !            93:        return 0;
        !            94: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.