Subversion Repositories or1k

/*

 * linux/drivers/scsi/scsi_proc.c

 *

 * The functions in this file provide an interface between

 * the PROC file system and the SCSI device drivers

 * It is mainly used for debugging, statistics and to pass

 * information directly to the lowlevel driver.

 *

 * (c) 1995 Michael Neuffer neuffer@goofy.zdv.uni-mainz.de

 * Version: 0.99.8   last change: 95/09/13

 *

 * generic command parser provided by:

 * Andreas Heilwagen <crashcar@informatik.uni-koblenz.de>

 *

 * generic_proc_info() support of xxxx_info() by:

 * Michael A. Griffith <grif@acm.org>

 */

#include <linux/config.h>       /* for CONFIG_PROC_FS */

#define __NO_VERSION__

#include <linux/module.h>

#include <linux/string.h>

#include <linux/mm.h>

#include <linux/slab.h>

#include <linux/proc_fs.h>

#include <linux/errno.h>

#include <linux/stat.h>

#include <linux/blk.h>

#include <asm/uaccess.h>

#include "scsi.h"

#include "hosts.h"

#ifndef TRUE

#define TRUE  1

#define FALSE 0

#endif

#ifdef CONFIG_PROC_FS

/* generic_proc_info

 * Used if the driver currently has no own support for /proc/scsi

 */

int generic_proc_info(char *buffer, char **start, off_t offset, int length,

                      const char *(*info) (struct Scsi_Host *),

                      struct Scsi_Host *sh)

{

        int len, pos, begin;

        begin = 0;

        if (info && sh) {

                pos = len = sprintf(buffer, "%s\n", info(sh));

        } else {

                pos = len = sprintf(buffer,

                        "The driver does not yet support the proc-fs\n");

        }

        if (pos < offset) {

                len = 0;

                begin = pos;

        }

        *start = buffer + (offset - begin);     /* Start of wanted data */

        len -= (offset - begin);

        if (len > length)

                len = length;

        return (len);

}

/* dispatch_scsi_info is the central dispatcher

 * It is the interface between the proc-fs and the SCSI subsystem code

 */

static int proc_scsi_read(char *buffer, char **start, off_t offset,

        int length, int *eof, void *data)

{

        struct Scsi_Host *hpnt = data;

        int n;

        if (hpnt->hostt->proc_info == NULL)

                n = generic_proc_info(buffer, start, offset, length,

                                      hpnt->hostt->info, hpnt);

        else

                n = (hpnt->hostt->proc_info(buffer, start, offset,

                                           length, hpnt->host_no, 0));

        *eof = (n<length);

        return n;

}

#define PROC_BLOCK_SIZE (3*1024)     /* 4K page size, but our output routines 

                                      * use some slack for overruns

                                      */

static int proc_scsi_write(struct file * file, const char * buf,

                           unsigned long count, void *data)

{

        struct Scsi_Host *hpnt = data;

        ssize_t ret = 0;

        char * page;

        char *start;

        if (hpnt->hostt->proc_info == NULL)

                ret = -ENOSYS;

        if (count > PROC_BLOCK_SIZE)

                return -EOVERFLOW;

        if (!(page = (char *) __get_free_page(GFP_KERNEL)))

                return -ENOMEM;

        if(copy_from_user(page, buf, count))

        {

                free_page((ulong) page);

                return -EFAULT;

        }

        ret = hpnt->hostt->proc_info(page, &start, 0, count,

                                     hpnt->host_no, 1);

        free_page((ulong) page);

        return(ret);

}

void build_proc_dir_entries(Scsi_Host_Template * tpnt)

{

        struct Scsi_Host *hpnt;

        char name[10];  /* see scsi_unregister_host() */

        tpnt->proc_dir = proc_mkdir(tpnt->proc_name, proc_scsi);

        if (!tpnt->proc_dir) {

                printk(KERN_ERR "Unable to proc_mkdir in scsi.c/build_proc_dir_entries");

                return;

        }

        tpnt->proc_dir->owner = tpnt->module;

        hpnt = scsi_hostlist;

        while (hpnt) {

                if (tpnt == hpnt->hostt) {

                        struct proc_dir_entry *p;

                        sprintf(name,"%d",hpnt->host_no);

                        p = create_proc_read_entry(name,

                                        S_IFREG | S_IRUGO | S_IWUSR,

                                        tpnt->proc_dir,

                                        proc_scsi_read,

                                        (void *)hpnt);

                        if (!p)

                                panic("Not enough memory to register SCSI HBA in /proc/scsi !\n");

                        p->write_proc=proc_scsi_write;

                        p->owner = tpnt->module;

                }

                hpnt = hpnt->next;

        }

}

/*

 *  parseHandle *parseInit(char *buf, char *cmdList, int cmdNum);

 *              gets a pointer to a null terminated data buffer

 *              and a list of commands with blanks as delimiter

 *      in between.

 *      The commands have to be alphanumerically sorted.

 *      cmdNum has to contain the number of commands.

 *              On success, a pointer to a handle structure

 *              is returned, NULL on failure

 *

 *      int parseOpt(parseHandle *handle, char **param);

 *              processes the next parameter. On success, the

 *              index of the appropriate command in the cmdList

 *              is returned, starting with zero.

 *              param points to the null terminated parameter string.

 *              On failure, -1 is returned.

 *

 *      The databuffer buf may only contain pairs of commands

 *          options, separated by blanks:

 *              <Command> <Parameter> [<Command> <Parameter>]*

 */

typedef struct {

        char *buf,              /* command buffer  */

        *cmdList,               /* command list    */

        *bufPos,                /* actual position */

        **cmdPos,               /* cmdList index   */

         cmdNum;                /* cmd number      */

} parseHandle;

inline int parseFree(parseHandle * handle)

{                               /* free memory     */

        kfree(handle->cmdPos);

        kfree(handle);

        return -1;

}

parseHandle *parseInit(char *buf, char *cmdList, int cmdNum)

{

        char *ptr;              /* temp pointer    */

        parseHandle *handle;    /* new handle      */

        if (!buf || !cmdList)   /* bad input ?     */

                return NULL;

        handle = (parseHandle *) kmalloc(sizeof(parseHandle), GFP_KERNEL);

        if (!handle)

                return NULL;    /* out of memory   */

        handle->cmdPos = (char **) kmalloc(sizeof(int) * cmdNum, GFP_KERNEL);

        if (!handle->cmdPos) {

                kfree(handle);

                return NULL;    /* out of memory   */

        }

        handle->buf = handle->bufPos = buf;     /* init handle     */

        handle->cmdList = cmdList;

        handle->cmdNum = cmdNum;

        handle->cmdPos[cmdNum = 0] = cmdList;

        for (ptr = cmdList; *ptr; ptr++) {      /* scan command string */

                if (*ptr == ' ') {      /* and insert zeroes   */

                        *ptr++ = 0;

                        handle->cmdPos[++cmdNum] = ptr++;

                }

        }

        return handle;

}

int parseOpt(parseHandle * handle, char **param)

{

        int cmdIndex = 0, cmdLen = 0;

        char *startPos;

        if (!handle)            /* invalid handle  */

                return (parseFree(handle));

        /* skip spaces     */

        for (; *(handle->bufPos) && *(handle->bufPos) == ' '; handle->bufPos++);

        if (!*(handle->bufPos))

                return (parseFree(handle));     /* end of data     */

        startPos = handle->bufPos;      /* store cmd start */

        for (; handle->cmdPos[cmdIndex][cmdLen] && *(handle->bufPos); handle->bufPos++) {       /* no string end?  */

                for (;;) {

                        if (*(handle->bufPos) == handle->cmdPos[cmdIndex][cmdLen])

                                break;  /* char matches ?  */

                        else if (memcmp(startPos, (char *) (handle->cmdPos[++cmdIndex]), cmdLen))

                                return (parseFree(handle));     /* unknown command */

                        if (cmdIndex >= handle->cmdNum)

                                return (parseFree(handle));     /* unknown command */

                }

                cmdLen++;       /* next char       */

        }

        /* Get param. First skip all blanks, then insert zero after param  */

        for (; *(handle->bufPos) && *(handle->bufPos) == ' '; handle->bufPos++);

        *param = handle->bufPos;

        for (; *(handle->bufPos) && *(handle->bufPos) != ' '; handle->bufPos++);

        *(handle->bufPos++) = 0;

        return (cmdIndex);

}

void proc_print_scsidevice(Scsi_Device * scd, char *buffer, int *size, int len)

{

        int x, y = *size;

        extern const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE];

        y = sprintf(buffer + len,

             "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",

                    scd->host->host_no, scd->channel, scd->id, scd->lun);

        for (x = 0; x < 8; x++) {

                if (scd->vendor[x] >= 0x20)

                        y += sprintf(buffer + len + y, "%c", scd->vendor[x]);

                else

                        y += sprintf(buffer + len + y, " ");

        }

        y += sprintf(buffer + len + y, " Model: ");

        for (x = 0; x < 16; x++) {

                if (scd->model[x] >= 0x20)

                        y += sprintf(buffer + len + y, "%c", scd->model[x]);

                else

                        y += sprintf(buffer + len + y, " ");

        }

        y += sprintf(buffer + len + y, " Rev: ");

        for (x = 0; x < 4; x++) {

                if (scd->rev[x] >= 0x20)

                        y += sprintf(buffer + len + y, "%c", scd->rev[x]);

                else

                        y += sprintf(buffer + len + y, " ");

        }

        y += sprintf(buffer + len + y, "\n");

        y += sprintf(buffer + len + y, "  Type:   %s ",

                     scd->type < MAX_SCSI_DEVICE_CODE ?

               scsi_device_types[(int) scd->type] : "Unknown          ");

        y += sprintf(buffer + len + y, "               ANSI"

                     " SCSI revision: %02x", (scd->scsi_level - 1) ? scd->scsi_level - 1 : 1);

        if (scd->scsi_level == 2)

                y += sprintf(buffer + len + y, " CCS\n");

        else

                y += sprintf(buffer + len + y, "\n");

        *size = y;

        return;

}

#else                           /* if !CONFIG_PROC_FS */

void proc_print_scsidevice(Scsi_Device * scd, char *buffer, int *size, int len)

{

}

#endif                          /* CONFIG_PROC_FS */