Subversion Repositories or1k_old

/*

 *  linux/fs/proc/array.c

 *

 *  Copyright (C) 1992  by Linus Torvalds

 *  based on ideas by Darren Senn

 *

 * Fixes:

 * Michael. K. Johnson: stat,statm extensions.

 *                      <johnsonm@stolaf.edu>

 *

 * Pauline Middelink :  Made cmdline,envline only break at '\0's, to

 *                      make sure SET_PROCTITLE works. Also removed

 *                      bad '!' which forced address recalculation for

 *                      EVERY character on the current page.

 *                      <middelin@polyware.iaf.nl>

 *

 * Danny ter Haar    :  added cpuinfo

 *                      <dth@cistron.nl>

 *

 * Alessandro Rubini :  profile extension.

 *                      <rubini@ipvvis.unipv.it>

 *

 * Jeff Tranter      :  added BogoMips field to cpuinfo

 *                      <Jeff_Tranter@Mitel.COM>

 *

 * Bruno Haible      :  remove 4K limit for the maps file

 * <haible@ma2s2.mathematik.uni-karlsruhe.de>

 *

 * Yves Arrouye      :  remove removal of trailing spaces in get_array.

 *                      <Yves.Arrouye@marin.fdn.fr>

 *

 * Alan Cox          :  security fixes. <Alan.Cox@linux.org>

 */

/*

 * uClinux revisions for NO_MM

 * Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>,

 *                     The Silver Hammer Group, Ltd.

 */

#include <linux/types.h>

#include <linux/errno.h>

#include <linux/sched.h>

#include <linux/kernel.h>

#include <linux/kernel_stat.h>

#include <linux/tty.h>

#include <linux/user.h>

#include <linux/a.out.h>

#include <linux/string.h>

#include <linux/mman.h>

#include <linux/proc_fs.h>

#include <linux/ioport.h>

#include <linux/config.h>

#include <linux/mm.h>

#include <linux/pagemap.h>

#include <linux/swap.h>

#include <asm/segment.h>

#include <asm/pgtable.h>

#include <asm/io.h>

#define LOAD_INT(x) ((x) >> FSHIFT)

#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)

#ifdef CONFIG_DEBUG_MALLOC

int get_malloc(char * buffer);

#endif

extern unsigned long get_wchan(struct task_struct *);

static int read_core(struct inode * inode, struct file * file,char * buf, int count)

{

        unsigned long p = file->f_pos, memsize;

        int read;

        int count1;

        char * pnt;

        struct user dump;

#ifdef __i386__

#       define FIRST_MAPPED     PAGE_SIZE       /* we don't have page 0 mapped on x86.. */

#else

#       define FIRST_MAPPED     0

#endif

        memset(&dump, 0, sizeof(struct user));

        dump.magic = CMAGIC;

        dump.u_dsize = MAP_NR(high_memory);

#ifdef __alpha__

        dump.start_data = PAGE_OFFSET;

#endif

        if (count < 0)

                return -EINVAL;

        memsize = MAP_NR(high_memory + PAGE_SIZE) << PAGE_SHIFT;

        if (p >= memsize)

                return 0;

        if (count > memsize - p)

                count = memsize - p;

        read = 0;

        if (p < sizeof(struct user) && count > 0) {

                count1 = count;

                if (p + count1 > sizeof(struct user))

                        count1 = sizeof(struct user)-p;

                pnt = (char *) &dump + p;

                memcpy_tofs(buf,(void *) pnt, count1);

                buf += count1;

                p += count1;

                count -= count1;

                read += count1;

        }

        while (count > 0 && p < PAGE_SIZE + FIRST_MAPPED) {

                put_user(0,buf);

                buf++;

                p++;

                count--;

                read++;

        }

        memcpy_tofs(buf, (void *) (PAGE_OFFSET + p - PAGE_SIZE), count);

        read += count;

        file->f_pos += read;

        return read;

}

static struct file_operations proc_kcore_operations = {

        NULL,           /* lseek */

        read_core,

};

struct inode_operations proc_kcore_inode_operations = {

        &proc_kcore_operations,

};

/*

 * This function accesses profiling information. The returned data is

 * binary: the sampling step and the actual contents of the profile

 * buffer. Use of the program readprofile is recommended in order to

 * get meaningful info out of these data.

 */

static int read_profile(struct inode *inode, struct file *file, char *buf, int count)

{

        unsigned long p = file->f_pos;

        int read;

        char * pnt;

        unsigned int sample_step = 1 << prof_shift;

        if (count < 0)

                return -EINVAL;

        if (p >= (prof_len+1)*sizeof(unsigned int))

                return 0;

        if (count > (prof_len+1)*sizeof(unsigned int) - p)

                count = (prof_len+1)*sizeof(unsigned int) - p;

        read = 0;

        while (p < sizeof(unsigned int) && count > 0) {

                put_user(*((char *)(&sample_step)+p),buf);

                buf++; p++; count--; read++;

        }

        pnt = (char *)prof_buffer + p - sizeof(unsigned int);

        memcpy_tofs(buf,(void *)pnt,count);

        read += count;

        file->f_pos += read;

        return read;

}

/* Writing to /proc/profile resets the counters */

static int write_profile(struct inode * inode, struct file * file, const char * buf, int count)

{

    int i=prof_len;

    while (i--)

            prof_buffer[i]=0UL;

    return count;

}

static struct file_operations proc_profile_operations = {

        NULL,           /* lseek */

        read_profile,

        write_profile,

};

struct inode_operations proc_profile_inode_operations = {

        &proc_profile_operations,

};

static int get_loadavg(char * buffer)

{

        int a, b, c;

        a = avenrun[0] + (FIXED_1/200);

        b = avenrun[1] + (FIXED_1/200);

        c = avenrun[2] + (FIXED_1/200);

        return sprintf(buffer,"%d.%02d %d.%02d %d.%02d %d/%d %d\n",

                LOAD_INT(a), LOAD_FRAC(a),

                LOAD_INT(b), LOAD_FRAC(b),

                LOAD_INT(c), LOAD_FRAC(c),

                nr_running, nr_tasks, last_pid);

}

static int get_kstat(char * buffer)

{

        int i, len;

        unsigned sum = 0;

        extern unsigned long total_forks;

        for (i = 0 ; i < NR_IRQS ; i++)

                sum += kstat.interrupts[i];

        len = sprintf(buffer,

                "cpu  %u %u %u %lu\n"

                "disk %u %u %u %u\n"

                "disk_rio %u %u %u %u\n"

                "disk_wio %u %u %u %u\n"

                "disk_rblk %u %u %u %u\n"

                "disk_wblk %u %u %u %u\n"

                "page %u %u\n"

                "swap %u %u\n"

                "intr %u",

                kstat.cpu_user,

                kstat.cpu_nice,

                kstat.cpu_system,

                jiffies - (kstat.cpu_user + kstat.cpu_nice + kstat.cpu_system),

                kstat.dk_drive[0], kstat.dk_drive[1],

                kstat.dk_drive[2], kstat.dk_drive[3],

                kstat.dk_drive_rio[0], kstat.dk_drive_rio[1],

                kstat.dk_drive_rio[2], kstat.dk_drive_rio[3],

                kstat.dk_drive_wio[0], kstat.dk_drive_wio[1],

                kstat.dk_drive_wio[2], kstat.dk_drive_wio[3],

                kstat.dk_drive_rblk[0], kstat.dk_drive_rblk[1],

                kstat.dk_drive_rblk[2], kstat.dk_drive_rblk[3],

                kstat.dk_drive_wblk[0], kstat.dk_drive_wblk[1],

                kstat.dk_drive_wblk[2], kstat.dk_drive_wblk[3],

                kstat.pgpgin,

                kstat.pgpgout,

                kstat.pswpin,

                kstat.pswpout,

                sum);

        for (i = 0 ; i < NR_IRQS ; i++)

                len += sprintf(buffer + len, " %u", kstat.interrupts[i]);

        len += sprintf(buffer + len,

                "\nctxt %u\n"

                "btime %lu\n"

                "processes %lu\n",

                kstat.context_swtch,

                xtime.tv_sec - jiffies / HZ,

                total_forks);

        return len;

}

static int get_uptime(char * buffer)

{

        unsigned long uptime;

        unsigned long idle;

        uptime = jiffies;

        idle = task[0]->utime + task[0]->stime;

        /* The formula for the fraction parts really is ((t * 100) / HZ) % 100, but

           that would overflow about every five days at HZ == 100.

           Therefore the identity a = (a / b) * b + a % b is used so that it is

           calculated as (((t / HZ) * 100) + ((t % HZ) * 100) / HZ) % 100.

           The part in front of the '+' always evaluates as 0 (mod 100). All divisions

           in the above formulas are truncating. For HZ being a power of 10, the

           calculations simplify to the version in the #else part (if the printf

           format is adapted to the same number of digits as zeroes in HZ.

         */

#if HZ!=100

        return sprintf(buffer,"%lu.%02lu %lu.%02lu\n",

                uptime / HZ,

                (((uptime % HZ) * 100) / HZ) % 100,

                idle / HZ,

                (((idle % HZ) * 100) / HZ) % 100);

#else

        return sprintf(buffer,"%lu.%02lu %lu.%02lu\n",

                uptime / HZ,

                uptime % HZ,

                idle / HZ,

                idle % HZ);

#endif

}

static int get_meminfo(char * buffer)

{

        struct sysinfo i;

        int len;

        si_meminfo(&i);

        si_swapinfo(&i);

        len = sprintf(buffer, "        total:    used:    free:  shared: buffers:  cached:\n"

                "Mem:  %8lu %8lu %8lu %8lu %8lu %8lu\n"

                "Swap: %8lu %8lu %8lu\n",

                i.totalram, i.totalram-i.freeram, i.freeram, i.sharedram, i.bufferram, page_cache_size*PAGE_SIZE,

                i.totalswap, i.totalswap-i.freeswap, i.freeswap);

        /*

         * Tagged format, for easy grepping and expansion. The above will go away

         * eventually, once the tools have been updated.

         */

        return len + sprintf(buffer+len,

                "MemTotal:  %8lu kB\n"

                "MemFree:   %8lu kB\n"

                "MemShared: %8lu kB\n"

                "Buffers:   %8lu kB\n"

                "Cached:    %8lu kB\n"

                "SwapTotal: %8lu kB\n"

                "SwapFree:  %8lu kB\n",

                i.totalram >> 10,

                i.freeram >> 10,

                i.sharedram >> 10,

                i.bufferram >> 10,

                page_cache_size << (PAGE_SHIFT - 10),

                i.totalswap >> 10,

                i.freeswap >> 10);

}

static int get_version(char * buffer)

{

        extern const char *linux_banner;

        strcpy(buffer, linux_banner);

        return strlen(buffer);

}

static int get_cmdline(char * buffer)

{

        extern char saved_command_line[];

        return sprintf(buffer, "%s\n", saved_command_line);

}

static struct task_struct ** get_task(pid_t pid)

{

        struct task_struct ** p;

        p = task;

        while (++p < task+NR_TASKS) {

                if (*p && (*p)->pid == pid)

                        return p;

        }

        return NULL;

}

static unsigned long get_phys_addr(struct task_struct * p, unsigned long ptr)

{

#ifndef NO_MM

        pgd_t *page_dir;

        pmd_t *page_middle;

        pte_t pte;

        if (!p || !p->mm || ptr >= TASK_SIZE)

                return 0;

        page_dir = pgd_offset(p->mm,ptr);

        if (pgd_none(*page_dir))

                return 0;

        if (pgd_bad(*page_dir)) {

                printk("bad page directory entry %08lx\n", pgd_val(*page_dir));

                pgd_clear(page_dir);

                return 0;

        }

        page_middle = pmd_offset(page_dir,ptr);

        if (pmd_none(*page_middle))

                return 0;

        if (pmd_bad(*page_middle)) {

                printk("bad page middle entry %08lx\n", pmd_val(*page_middle));

                pmd_clear(page_middle);

                return 0;

        }

        pte = *pte_offset(page_middle,ptr);

        if (!pte_present(pte))

                return 0;

        return pte_page(pte) + (ptr & ~PAGE_MASK);

#else /* NO_MM */

        return ptr;

#endif /* NO_MM */

}

static int get_array(struct task_struct ** p, unsigned long start, unsigned long end, char * buffer)

{

        unsigned long addr;

        int size = 0, result = 0;

        char c;

        if (start >= end)

                return result;

        for (;;) {

                addr = get_phys_addr(*p, start);

                if (!addr)

                        return result;

                do {

                        c = *(char *) addr;

                        if (!c)

                                result = size;

                        if (size < PAGE_SIZE)

                                buffer[size++] = c;

                        else

                                return result;

                        addr++;

                        start++;

                        if (!c && start >= end)

                                return result;

                } while (addr & ~PAGE_MASK);

        }

        return result;

}

static int get_env(int pid, char * buffer)

{

        struct task_struct ** p = get_task(pid);

        if (!p || !*p || !(*p)->mm)

                return 0;

        return get_array(p, (*p)->mm->env_start, (*p)->mm->env_end, buffer);

}

static int get_arg(int pid, char * buffer)

{

        struct task_struct ** p = get_task(pid);

        if (!p || !*p || !(*p)->mm)

                return 0;

        return get_array(p, (*p)->mm->arg_start, (*p)->mm->arg_end, buffer);

}

#if defined(__i386__)

# define KSTK_EIP(tsk)  (((unsigned long *)tsk->kernel_stack_page)[1019])

# define KSTK_ESP(tsk)  (((unsigned long *)tsk->kernel_stack_page)[1022])

#elif defined(__alpha__)

  /*

   * See arch/alpha/kernel/ptrace.c for details.

   */

# define PT_REG(reg)            (PAGE_SIZE - sizeof(struct pt_regs)     \

                                 + (long)&((struct pt_regs *)0)->reg)

# define KSTK_EIP(tsk)  (*(unsigned long *)(tsk->kernel_stack_page + PT_REG(pc)))

# define KSTK_ESP(tsk)  ((tsk) == current ? rdusp() : (tsk)->tss.usp)

#elif defined(__sparc__)

# define PT_REG(reg)            (PAGE_SIZE - sizeof(struct pt_regs)     \

                                 + (long)&((struct pt_regs *)0)->reg)

# define KSTK_EIP(tsk)  (*(unsigned long *)(tsk->kernel_stack_page + PT_REG(pc)))

# define KSTK_ESP(tsk)  (*(unsigned long *)(tsk->kernel_stack_page + PT_REG(u_regs[UREG_FP])))

#endif

/* Gcc optimizes away "strlen(x)" for constant x */

#define ADDBUF(buffer, string) \

do { memcpy(buffer, string, strlen(string)); \

     buffer += strlen(string); } while (0)

static inline char * task_name(struct task_struct *p, char * buf)

{

        int i;

        char * name;

        ADDBUF(buf, "Name:\t");

        name = p->comm;

        i = sizeof(p->comm);

        do {

                unsigned char c = *name;

                name++;

                i--;

                *buf = c;

                if (!c)

                        break;

                if (c == '\\') {

                        buf[1] = c;

                        buf += 2;

                        continue;

                }

                if (c == '\n') {

                        buf[0] = '\\';

                        buf[1] = 'n';

                        buf += 2;

                        continue;

                }

                buf++;

        } while (i);

        *buf = '\n';

        return buf+1;

}

static inline char * task_state(struct task_struct *p, char *buffer)

{

#define NR_STATES (sizeof(states)/sizeof(const char *))

        unsigned int n = p->state;

        static const char * states[] = {

                "R (running)",

                "S (sleeping)",

                "D (disk sleep)",

                "Z (zombie)",

                "T (stopped)",

                "W (paging)",

                ". Huh?"

        };

        if (n >= NR_STATES)

                n = NR_STATES-1;

        buffer += sprintf(buffer,

                "State:\t%s\n"

                "Pid:\t%d\n"

                "PPid:\t%d\n"

                "Uid:\t%d\t%d\t%d\t%d\n"

                "Gid:\t%d\t%d\t%d\t%d\n",

                states[n],

                p->pid, p->p_pptr->pid,

                p->uid, p->euid, p->suid, p->fsuid,

                p->gid, p->egid, p->sgid, p->fsgid);

        return buffer;

}

static inline char * task_mem(struct task_struct *p, char *buffer)

{

#ifndef NO_MM

        struct mm_struct * mm = p->mm;

        if (mm && mm != &init_mm) {

                struct vm_area_struct * vma = mm->mmap;

                unsigned long data = 0, stack = 0;

                unsigned long exec = 0, lib = 0;

                for (vma = mm->mmap; vma; vma = vma->vm_next) {

                        unsigned long len = (vma->vm_end - vma->vm_start) >> 10;

                        if (!vma->vm_inode) {

                                data += len;

                                if (vma->vm_flags & VM_GROWSDOWN)

                                        stack += len;

                                continue;

                        }

                        if (vma->vm_flags & VM_WRITE)

                                continue;

                        if (vma->vm_flags & VM_EXEC) {

                                exec += len;

                                if (vma->vm_flags & VM_EXECUTABLE)

                                        continue;

                                lib += len;

                        }

                }

                buffer += sprintf(buffer,

                        "VmSize:\t%8lu kB\n"

                        "VmLck:\t%8lu kB\n"

                        "VmRSS:\t%8lu kB\n"

                        "VmData:\t%8lu kB\n"

                        "VmStk:\t%8lu kB\n"

                        "VmExe:\t%8lu kB\n"

                        "VmLib:\t%8lu kB\n",

                        mm->total_vm << (PAGE_SHIFT-10),

                        mm->locked_vm << (PAGE_SHIFT-10),

                        mm->rss << (PAGE_SHIFT-10),

                        data - stack, stack,

                        exec - lib, lib);

        }

#else /* NO_MM */

        unsigned long bytes = 0, sbytes = 0;

        struct mm_tblock_struct * tblock;

        /* Logic: we've got two memory sums for each process, "shared", and

         * "non-shared". Shared memory may get counted more then once, for

         * each process that owns it. Non-shared memory is counted

         * accurately.

         *

         *      -- Kenneth Albanowski

         */

        for(tblock = &p->mm->tblock;tblock;tblock=tblock->next) {

                if (tblock->rblock) {

                        bytes += ksize(tblock);

                        if ((p->mm->count > 1) || (tblock->rblock->refcount > 1)) {

                                sbytes += ksize(tblock->rblock->kblock);

                                sbytes += ksize(tblock->rblock) ;

                        } else {

                                bytes += ksize(tblock->rblock->kblock);

                                bytes += ksize(tblock->rblock) ;

                        }

                }

        }

        ((p->mm->count > 1) ? sbytes : bytes) += ksize(p->mm);

        ((p->fs->count > 1) ? sbytes : bytes) += ksize(p->fs);

        ((p->files->count > 1) ? sbytes : bytes) += ksize(p->files);

        ((p->sig->count > 1) ? sbytes : bytes) += ksize(p->sig);

        bytes += ksize(p);

        bytes += PAGE_SIZE; /* Kernel stack */

        buffer += sprintf(buffer,

                "Mem:\t%8lu bytes\n"

                "Shared:\t%8lu bytes\n",

                bytes,

                sbytes);

#endif /* NO_MM */

        return buffer;

}

static inline char * task_sig(struct task_struct *p, char *buffer)

{

        buffer += sprintf(buffer,

                "SigPnd:\t%08lx\n"

                "SigBlk:\t%08lx\n",

                p->signal, p->blocked);

        if (p->sig) {

                struct sigaction * action = p->sig->action;

                unsigned long sig_ign = 0, sig_caught = 0;

                unsigned long bit = 1;

                int i;

                for (i = 0; i < 32; i++) {

                        switch((unsigned long) action->sa_handler) {

                                case 0:

                                        break;

                                case 1:

                                        sig_ign |= bit;

                                        break;

                                default:

                                        sig_caught |= bit;

                        }

                        bit <<= 1;

                        action++;

                }

                buffer += sprintf(buffer,

                        "SigIgn:\t%08lx\n"

                        "SigCgt:\t%08lx\n",

                        sig_ign, sig_caught);

        }

        return buffer;

}

static int get_status(int pid, char * buffer)

{

        char * orig = buffer;

        struct task_struct ** p = get_task(pid), *tsk;

        if (!p || (tsk = *p) == NULL)

                return 0;

        buffer = task_name(tsk, buffer);

        buffer = task_state(tsk, buffer);