libopenmosix.c

OpenMosix工具

/* Copyright (c) 2006 David Santo Orcero [e-mail]               */
/*  [e-mail]  http://www.orcero.org/irbis                       */
/* Code derived from previous work by Ariel Rosenblatt                  */
/* Mosix is (c) of prof. Amnon Barak http://www.mosix.org               */
/* Original Mosix 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.                                         */




#include "mos.h"


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


int
om_read (const char *path)
{
  int64_t val;

  return (om_readval (path, &val) ? (int) val : -1);

};

char *
om_read_s (const char *path)
{
  char *val;

  return (om_readval_s (path, &val) ? (char *) val : NULL);
};

int
om_readproc (int pid, const char *item)
{
  char fn[64];

  sprintf (fn, "/proc/%d/om/%s", pid, item);
  return (om_read (fn));

};

char *
om_readproc_s (int pid, const char *item)
{
  char fn[64];

  sprintf (fn, "/proc/%d/om/%s", pid, item);
  return (om_read_s (fn));

};

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

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

};

int
om_readval_s (const char *file, char **val)
{
  int fd = open (file, 0);
  int r;
  char *strmax;
  /* This allows to write a letter to your grandma with
   * the name of the node...                            */
  unsigned int maxlen = 1024;

  if (fd == -1)
    return (0);
  strmax = (char *) malloc (maxlen);
  r = read (fd, strmax, maxlen - 1);
  close (fd);
  strmax[maxlen - 1] = '\0';
  *val = (char *) malloc (sizeof (char) * strlen (strmax));
  return (r >= 0 && sscanf (strmax, "%s", *val) == 1);

};


int
om_readval2 (const char *file, int *val1, int *val2)
{
  int fd = open (file, 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);

};

int64_t
om_readnode (char *node, const char *item)
{
/* TODO: Node management */
  printf ("Node management not yet supported.\n");
  return (0);

};

int
om_write (const char *file, int64_t val)
{
  int fd = open (file, 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
om_write2 (const char *file, int val, int64_t val2)
{
  int fd = open (file, 1);
  size_t l, r;
  char num[30];

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

};

int
om_write_s (const char *file, char *val)
{
  int fd = open (file, 1);
  size_t l, r;
  if (fd == -1)
    return (0);
  r = write (fd, val, l = strlen (val));
  close (fd);
  return (r == l);

};

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

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

};

int
om_writeproc_s (int pid, const char *item, char *val)
{
  char fn[64];

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

};

int
om_replace (const char *file, int64_t val)
{
  int fd = open (file, 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
om_count_ints (const char *file)
{
  int fd = open (file, 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
om_fill_ints (const char *file, int *into, int max)
{
  int fd = open (file, 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);

};