libmosix.c

OpenMosix工具

/*  Author(s): Ariel Rosenblatt for Mosix                               */
/*  Adapted to OpenMosix from Mosix and bugfixing by David Santo Orcero */
/*  [e-mail]  http://www.orcero.org/irbis                       */
/* Mosix is (c) of prof. Amnon Barak http://www.mosix.org               */
/* Original code is (c) of prof. Amnon Barak http://www.mosix.org       */
/* OpenMosix is (c) of Moshe Bar http://www.openmosix.com               */
/* Each respective trademark is of its own owner                        */
/* All rights reserved.                                                 */
/* This software is distributed under GPL 2                             */

/* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTY IS ASSUMED.               */
/* NO LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING            */
/* FROM THE USE OF THIS SOFTWARE WILL BE ACCEPTED. IT CAN BURN              */
/* YOUR HARD DISK, ERASE ALL YOUR DATA AND BROKE DOWN YOUR                  */
/* MICROWAVE OVEN. YOU ARE ADVISED.                                         */


/* THIS SOFTWARE IS PROVIDED IN ITS "AS IS" CONDITION, WITH NO WARRANTY     */
/* WHATSOEVER. NO LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING*/
/* FROM THE USE OF THIS SOFTWARE WILL BE ACCEPTED.                          */





#include "mos.h"

int
msx_is_mosix ()
{
  return (!access ("/proc/hpc/", 0));
}

int
msx_is_configured ()
{
  return (msx_read ("/proc/hpc/admin/mospe") == -1 ? 0 : 1);
}

int
msx_readval (const char *fn, int64_t * val)
{
  int fd = open (fn, 0);
  int r;
  char num[30];

  if (fd == -1)
    return (0);
  num[sizeof (num) - 1] = '\0';
  r = read (fd, num, sizeof (num) - 1);
  close (fd);
  return (r >= 0 && sscanf (num, "%lld", val) == 1);
}

int
msx_readval2 (const char *fn, int *val1, int *val2)
{
  int fd = open (fn, 0);
  int r;
  char num[30];

  if (fd == -1)
    return (0);
  num[sizeof (num) - 1] = '\0';
  r = read (fd, num, sizeof (num) - 1);
  close (fd);
  if (r < 0)
    return (0);
  r = sscanf (num, "%d %d", val1, val2);
  if (r == 1)
    *val2 = 0;
  else if (r != 2)
    return (0);
  return (1);
}

int
msx_write (const char *fn, int64_t val)
{
  int fd = open (fn, 1);
  size_t l, r;
  char num[30];
  if (fd == -1)
    return (0);
  sprintf (num, "%lld\n", val);
  r = write (fd, num, l = strlen (num));
  close (fd);
  return (r == l);
}

int
msx_write2 (const char *fn, int val1, int64_t val2)
{
  int fd = open (fn, 1);
  size_t l, r;
  char num[30];

  if (fd == -1)
    return (0);
  sprintf (num, "%d %lld\n", val1, val2);
  r = write (fd, num, l = strlen (num));
  close (fd);
  return (r == l);
}

int
msx_replace (const char *fn, int64_t val)
{
  int fd = open (fn, 2);
  size_t l, r;
  char num[30];
  int ret;

  if (fd == -1)
    return (0);
  num[sizeof (num) - 1] = '\0';
  r = read (fd, num, sizeof (num) - 1);
  if (r < 0 || sscanf (num, "%d", &ret) != 1)
    return (-1);
  sprintf (num, "%lld\n", val);
  r = write (fd, num, l = strlen (num));
  close (fd);
  return (r == l ? ret : -1);
}

int
msx_read (const char *fn)
{
  int64_t val;

  return (msx_readval (fn, &val) ? (int) val : -1);
}

int64_t
msx_readnode (int node, const char *item)
{
  char fn[40];
  int64_t val;

  if (!node && !(node = msx_read ("/proc/hpc/admin/mospe")))
    return (-1);
  sprintf (fn, "/proc/hpc/nodes/%d/%s", node, item);
  if (!msx_readval (fn, &val))
    return (-1);
  if (val >= 0)
    return (val);
  errno = -val;
  return (-1);
}

int
msx_writeproc (int pid, const char *item, int64_t val)
{
  char fn[30];

  sprintf (fn, "/proc/%d/%s", pid, item);
  return (msx_write (fn, val));
}

int
msx_readproc (int pid, const char *item)
{
  char fn[30];

  sprintf (fn, "/proc/%d/%s", pid, item);
  return (msx_read (fn));
}

int
msx_readdata (const char *fn, void *into, int max, int size)
{
  int fd = open (fn, 0);
  size_t r;

  if (fd == -1)
    return (0);
  r = read (fd, into, (size_t) max * size);
  close (fd);
  if (r == -1 || (r % size))
    return (0);
  return (r / size);
}

int
msx_count_ints (const char *fn)
{
  int fd = open (fn, 0);
  int r;
  char buf[4096];
  char *p = buf, *np;
  int n = 0;

  if (fd == -1)
    return (0);
  r = read (fd, buf, sizeof (buf));
  close (fd);
  if (r < 0)
    return (-1);
  if (r == sizeof (buf))
    {
      errno = E2BIG;
      return (-1);
    }
  buf[r] = '\0';
  for (p = buf; strtol (p, &np, 0), np != p; p = np)
    n++;
  return (n);
}

int
msx_fill_ints (const char *fn, int *into, int max)
{
  int fd = open (fn, 0);
  int r;
  char buf[4096];
  char *p = buf, *np;
  int n = 0;

  if (fd == -1)
    return (0);
  r = read (fd, buf, sizeof (buf));
  close (fd);
  if (r < 0)
    return (-1);
  if (r == sizeof (buf))
    {
      errno = E2BIG;
      return (-1);
    }
  buf[r] = '\0';
  for (p = buf; n < max && (into[n] = strtol (p, &np, 0), np != p); p = np)
    n++;
  return (n);
}