Logo Search packages:      
Sourcecode: linux version File versions  Download package

kspd.c

/*
 * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.
 *
 *  This program is free software; you can distribute it and/or modify it
 *  under the terms of the GNU General Public License (Version 2) as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/unistd.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/syscalls.h>
#include <linux/workqueue.h>
#include <linux/errno.h>
#include <linux/list.h>

#include <asm/vpe.h>
#include <asm/rtlx.h>
#include <asm/kspd.h>

static struct workqueue_struct *workqueue = NULL;
static struct work_struct work;

extern unsigned long cpu_khz;

struct mtsp_syscall {
      int cmd;
      unsigned char abi;
      unsigned char size;
};

struct mtsp_syscall_ret {
      int retval;
      int errno;
};

struct mtsp_syscall_generic {
      int arg0;
      int arg1;
      int arg2;
      int arg3;
      int arg4;
      int arg5;
      int arg6;
};

static struct list_head kspd_notifylist;
static int sp_stopping = 0;

/* these should match with those in the SDE kit */
#define MTSP_SYSCALL_BASE     0
#define MTSP_SYSCALL_EXIT     (MTSP_SYSCALL_BASE + 0)
#define MTSP_SYSCALL_OPEN     (MTSP_SYSCALL_BASE + 1)
#define MTSP_SYSCALL_READ     (MTSP_SYSCALL_BASE + 2)
#define MTSP_SYSCALL_WRITE    (MTSP_SYSCALL_BASE + 3)
#define MTSP_SYSCALL_CLOSE    (MTSP_SYSCALL_BASE + 4)
#define MTSP_SYSCALL_LSEEK32  (MTSP_SYSCALL_BASE + 5)
#define MTSP_SYSCALL_ISATTY   (MTSP_SYSCALL_BASE + 6)
#define MTSP_SYSCALL_GETTIME  (MTSP_SYSCALL_BASE + 7)
#define MTSP_SYSCALL_PIPEFREQ (MTSP_SYSCALL_BASE + 8)
#define MTSP_SYSCALL_GETTOD   (MTSP_SYSCALL_BASE + 9)
#define MTSP_SYSCALL_IOCTL     (MTSP_SYSCALL_BASE + 10)

#define MTSP_O_RDONLY         0x0000
#define MTSP_O_WRONLY         0x0001
#define MTSP_O_RDWR           0x0002
#define MTSP_O_NONBLOCK       0x0004
#define MTSP_O_APPEND         0x0008
#define MTSP_O_SHLOCK         0x0010
#define MTSP_O_EXLOCK         0x0020
#define MTSP_O_ASYNC          0x0040
#define MTSP_O_FSYNC          O_SYNC
#define MTSP_O_NOFOLLOW       0x0100
#define MTSP_O_SYNC           0x0080
#define MTSP_O_CREAT          0x0200
#define MTSP_O_TRUNC          0x0400
#define MTSP_O_EXCL           0x0800
#define MTSP_O_BINARY         0x8000

extern int tclimit;

struct apsp_table  {
      int sp;
      int ap;
};

/* we might want to do the mode flags too */
struct apsp_table open_flags_table[] = {
      { MTSP_O_RDWR, O_RDWR },
      { MTSP_O_WRONLY, O_WRONLY },
      { MTSP_O_CREAT, O_CREAT },
      { MTSP_O_TRUNC, O_TRUNC },
      { MTSP_O_NONBLOCK, O_NONBLOCK },
      { MTSP_O_APPEND, O_APPEND },
      { MTSP_O_NOFOLLOW, O_NOFOLLOW }
};

struct apsp_table syscall_command_table[] = {
      { MTSP_SYSCALL_OPEN, __NR_open },
      { MTSP_SYSCALL_CLOSE, __NR_close },
      { MTSP_SYSCALL_READ, __NR_read },
      { MTSP_SYSCALL_WRITE, __NR_write },
      { MTSP_SYSCALL_LSEEK32, __NR_lseek },
      { MTSP_SYSCALL_IOCTL, __NR_ioctl }
};

static int sp_syscall(int num, int arg0, int arg1, int arg2, int arg3)
{
      register long int _num  __asm__("$2") = num;
      register long int _arg0  __asm__("$4") = arg0;
      register long int _arg1  __asm__("$5") = arg1;
      register long int _arg2  __asm__("$6") = arg2;
      register long int _arg3  __asm__("$7") = arg3;

      mm_segment_t old_fs;

      old_fs = get_fs();
      set_fs(KERNEL_DS);

      __asm__ __volatile__ (
      "     syscall                             \n"
      : "=r" (_num), "=r" (_arg3)
      : "r" (_num), "r" (_arg0), "r" (_arg1), "r" (_arg2), "r" (_arg3));

      set_fs(old_fs);

      /* $a3 is error flag */
      if (_arg3)
            return -_num;

      return _num;
}

static int translate_syscall_command(int cmd)
{
      int i;
      int ret = -1;

      for (i = 0; i < ARRAY_SIZE(syscall_command_table); i++) {
            if ((cmd == syscall_command_table[i].sp))
                  return syscall_command_table[i].ap;
      }

      return ret;
}

static unsigned int translate_open_flags(int flags)
{
      int i;
      unsigned int ret = 0;

      for (i = 0; i < (sizeof(open_flags_table) / sizeof(struct apsp_table));
           i++) {
            if( (flags & open_flags_table[i].sp) ) {
                  ret |= open_flags_table[i].ap;
            }
      }

      return ret;
}


static void sp_setfsuidgid( uid_t uid, gid_t gid)
{
      current->fsuid = uid;
      current->fsgid = gid;

      key_fsuid_changed(current);
      key_fsgid_changed(current);
}

/*
 * Expects a request to be on the sysio channel. Reads it.  Decides whether
 * its a linux syscall and runs it, or whatever.  Puts the return code back
 * into the request and sends the whole thing back.
 */
void sp_work_handle_request(void)
{
      struct mtsp_syscall sc;
      struct mtsp_syscall_generic generic;
      struct mtsp_syscall_ret ret;
      struct kspd_notifications *n;
      unsigned long written;
      mm_segment_t old_fs;
      struct timeval tv;
      struct timezone tz;
      int cmd;

      char *vcwd;
      int size;

      ret.retval = -1;

      old_fs = get_fs();
      set_fs(KERNEL_DS);

      if (!rtlx_read(RTLX_CHANNEL_SYSIO, &sc, sizeof(struct mtsp_syscall))) {
            set_fs(old_fs);
            printk(KERN_ERR "Expected request but nothing to read\n");
            return;
      }

      size = sc.size;

      if (size) {
            if (!rtlx_read(RTLX_CHANNEL_SYSIO, &generic, size)) {
                  set_fs(old_fs);
                  printk(KERN_ERR "Expected request but nothing to read\n");
                  return;
            }
      }

      /* Run the syscall at the priviledge of the user who loaded the
         SP program */

      if (vpe_getuid(tclimit))
            sp_setfsuidgid(vpe_getuid(tclimit), vpe_getgid(tclimit));

      switch (sc.cmd) {
      /* needs the flags argument translating from SDE kit to
         linux */
      case MTSP_SYSCALL_PIPEFREQ:
            ret.retval = cpu_khz * 1000;
            ret.errno = 0;
            break;

      case MTSP_SYSCALL_GETTOD:
            memset(&tz, 0, sizeof(tz));
            if ((ret.retval = sp_syscall(__NR_gettimeofday, (int)&tv,
                                   (int)&tz, 0, 0)) == 0)
            ret.retval = tv.tv_sec;
            break;

      case MTSP_SYSCALL_EXIT:
            list_for_each_entry(n, &kspd_notifylist, list)
                  n->kspd_sp_exit(tclimit);
            sp_stopping = 1;

            printk(KERN_DEBUG "KSPD got exit syscall from SP exitcode %d\n",
                   generic.arg0);
            break;

      case MTSP_SYSCALL_OPEN:
            generic.arg1 = translate_open_flags(generic.arg1);

            vcwd = vpe_getcwd(tclimit);

            /* change to the cwd of the process that loaded the SP program */
            old_fs = get_fs();
            set_fs(KERNEL_DS);
            sys_chdir(vcwd);
            set_fs(old_fs);

            sc.cmd = __NR_open;

            /* fall through */

      default:
            if ((sc.cmd >= __NR_Linux) &&
                (sc.cmd <= (__NR_Linux +  __NR_Linux_syscalls)) )
                  cmd = sc.cmd;
            else
                  cmd = translate_syscall_command(sc.cmd);

            if (cmd >= 0) {
                  ret.retval = sp_syscall(cmd, generic.arg0, generic.arg1,
                                          generic.arg2, generic.arg3);
            } else
                  printk(KERN_WARNING
                         "KSPD: Unknown SP syscall number %d\n", sc.cmd);
            break;
      } /* switch */

      if (vpe_getuid(tclimit))
            sp_setfsuidgid( 0, 0);

      old_fs = get_fs();
      set_fs(KERNEL_DS);
      written = rtlx_write(RTLX_CHANNEL_SYSIO, &ret, sizeof(ret));
      set_fs(old_fs);
      if (written < sizeof(ret))
            printk("KSPD: sp_work_handle_request failed to send to SP\n");
}

static void sp_cleanup(void)
{
      struct files_struct *files = current->files;
      int i, j;
      struct fdtable *fdt;

      j = 0;

      /*
       * It is safe to dereference the fd table without RCU or
       * ->file_lock
       */
      fdt = files_fdtable(files);
      for (;;) {
            unsigned long set;
            i = j * __NFDBITS;
            if (i >= fdt->max_fds)
                  break;
            set = fdt->open_fds->fds_bits[j++];
            while (set) {
                  if (set & 1) {
                        struct file * file = xchg(&fdt->fd[i], NULL);
                        if (file)
                              filp_close(file, files);
                  }
                  i++;
                  set >>= 1;
            }
      }
}

static int channel_open = 0;

/* the work handler */
static void sp_work(struct work_struct *unused)
{
      if (!channel_open) {
            if( rtlx_open(RTLX_CHANNEL_SYSIO, 1) != 0) {
                  printk("KSPD: unable to open sp channel\n");
                  sp_stopping = 1;
            } else {
                  channel_open++;
                  printk(KERN_DEBUG "KSPD: SP channel opened\n");
            }
      } else {
            /* wait for some data, allow it to sleep */
            rtlx_read_poll(RTLX_CHANNEL_SYSIO, 1);

            /* Check we haven't been woken because we are stopping */
            if (!sp_stopping)
                  sp_work_handle_request();
      }

      if (!sp_stopping)
            queue_work(workqueue, &work);
      else
            sp_cleanup();
}

static void startwork(int vpe)
{
      sp_stopping = channel_open = 0;

      if (workqueue == NULL) {
            if ((workqueue = create_singlethread_workqueue("kspd")) == NULL) {
                  printk(KERN_ERR "unable to start kspd\n");
                  return;
            }

            INIT_WORK(&work, sp_work);
      }

      queue_work(workqueue, &work);
}

static void stopwork(int vpe)
{
      sp_stopping = 1;

      printk(KERN_DEBUG "KSPD: SP stopping\n");
}

void kspd_notify(struct kspd_notifications *notify)
{
      list_add(&notify->list, &kspd_notifylist);
}

static struct vpe_notifications notify;
static int kspd_module_init(void)
{
      INIT_LIST_HEAD(&kspd_notifylist);

      notify.start = startwork;
      notify.stop = stopwork;
      vpe_notify(tclimit, &notify);

      return 0;
}

static void kspd_module_exit(void)
{

}

module_init(kspd_module_init);
module_exit(kspd_module_exit);

MODULE_DESCRIPTION("MIPS KSPD");
MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
MODULE_LICENSE("GPL");

Generated by  Doxygen 1.6.0   Back to index