Initial revision

1 files changed, 263 insertions, 0 deletions

diff --git a/src/unexaix.c b/src/unexaix.c
new file mode 100644
index 00000000000..2957f966902
--- /dev/null
+++ b/src/unexaix.c
@@ -0,0 +1,263 @@
+/* Dumping and loading data areas, for Emacs under AIX.
+   (It may also work on other kinds of system V.)
+   Copyright (C) 1990 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that 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 GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This is based on a public domain program written by IBM.  */
+
+/*************** SYSTEM DEFINES *********************************/
+
+#include "config.h"
+#include "paths.h"
+#include <sys/types.h>
+#include <sys/files.h>
+#include <fcntl.h>
+#include <sys/mode.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <malloc.h>
+#include <stdio.h>                              /* MWW */
+#include "lisp.h"
+
+/*************** LOCAL DEFINES **********************************/
+
+struct data_header              /* saved data header            */
+{
+  char *start;                  /* dump _data addr              */
+  char *end;                    /* dump _end addr               */
+  char *sbrk1;                  /* dump original sbrk addr      */
+  char *sbrk2;                  /* dump final sbrk addr */
+  int puresize;                 /* size of pure data dumped  */
+};
+
+#define EMACSSHMKEY "EMACSSHMKEY"
+#define EMACS_DATA_FILE "EMACS-DATA"
+#define NEW_SHMGET_FLAGS (IPC_CREAT | S_IWUSR | S_IRUSR \
+      | S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH)
+#define OLD_SHMAT_FLAGS SHM_RDONLY
+#define OLD_SHMGET_FLAGS (S_IRUSR | S_IRGRP | S_IROTH) 
+#define OLD_OPEN_FLAGS O_RDONLY
+#define NEW_OPEN_FLAGS (O_RDWR | O_CREAT | O_TRUNC)
+
+/*************** EXTERNAL / GLOBAL DATA AREA ********************/
+
+extern char _data;              /* start of data addr           */
+extern char _end;               /* end of all data + 1 addr     */
+static char *original_sbrk;     /* sbrk when dump first run     */
+
+void
+map_in_data (use_dumped_data)
+     int use_dumped_data;
+{
+  int bufsize;                  /* malloc buffer size           */
+  struct data_header dh;        /* saved data header            */
+  int fd;                       /* saved data file descriptor   */
+  char *finaladdr;              /* last addr in bucket          */
+  char *ipckey = getenv (EMACSSHMKEY); /* env ipc key string    */
+  int length;                   /* dumped data lengths          */
+  char *newaddr;                /* new malloc buffer addr       */
+  int numblks;                  /* number of remaining mallocs  */
+  int shmid;                    /* shared memory id             */
+  key_t shmkey;                 /* shared memory key            */
+  /* Note that using malloc here may not be safe.  */
+  char name[sizeof (PATH_EXEC) + sizeof (EMACS_DATA_FILE) + 2];
+
+  /* Consume remaining malloc space without increasing          */
+  /* the end of data space                                      */
+  original_sbrk = sbrk (0);
+  for (bufsize = 16; bufsize < getpagesize (); bufsize *= 2)
+    {
+      while ((newaddr = (char *)malloc (bufsize - 8)) < original_sbrk)
+        ;
+      for (numblks = (getpagesize () / bufsize) - 1; numblks > 0; numblks--)
+        malloc (bufsize - 8);
+      finaladdr = sbrk (0);
+    }
+  original_sbrk = sbrk (0);
+
+  /* If we don't want the dumped data, get an unshared segment.  */
+  if (!use_dumped_data)
+    {
+      shmid = shmget (IPC_PRIVATE, PURESIZE, NEW_SHMGET_FLAGS);
+      if (shmid == -1
+          || shmat (shmid, (char *)PURE_SEG_BITS, 0) == -1)
+        {
+          fprintf (stderr, "emacs: failure obtaining new unshared memory segment.\n");
+          exit (1);
+        }
+      return;
+    }
+
+  /* Compute the file name with the dumped data.  */
+  strcpy (name, PATH_EXEC);
+  strcat (name, "/");
+  strcat (name, EMACS_DATA_FILE);
+
+  /* Open the file and make sure the addresses have not changed.  */
+  fd = open (name, OLD_OPEN_FLAGS, 0);
+  if (fd < 0)
+    {
+      fprintf (stderr, "emacs: failure opening `%s'\n", name);
+      exit (1);
+    }
+  if (read (fd, (char *)&dh, sizeof (dh)) != sizeof (dh)
+      || dh.start != &_data
+      || dh.end != &_end
+      || dh.sbrk1 != original_sbrk
+      || dh.puresize != PURESIZE)
+    {
+      fprintf (stderr, "emacs: header mismatch in `%s'\n", name);
+      exit (1);
+    }
+
+  /* Load in the unshared contents.  */
+  if (!(length = dh.end - dh.start)
+      || read (fd, (char *)&_data, length) != length
+      || !(length = dh.sbrk2 - dh.sbrk1)
+      || brk (dh.sbrk2) == -1
+      || read (fd, dh.sbrk1, length) != length)
+    {
+      fprintf (stderr, "emacs: failure loading unshared data.\n");
+      exit (1);
+    }
+
+  /* Determine ipc key from environment or default              */
+  if (ipckey && *ipckey)
+    shmkey = atoi (ipckey);
+  else
+    shmkey = SHMKEY;
+
+  /* Attach to "pure data" shared memory segment                */
+  if ((shmid = shmget (shmkey, 0, 0)) == -1
+      || (newaddr = shmat (shmid, (char *)PURE_SEG_BITS, OLD_SHMAT_FLAGS)) == -1)
+    {
+      /* We were unable to open an existing segment.  Make a new one.  */
+      struct shmid_ds buf;
+
+      /* First get rid of the one we tried to get.  */
+      shmdt ((char *)PURE_SEG_BITS);
+      shmctl (shmid, IPC_RMID, 0);
+
+      /* If we could not write the data file,
+         don't make a shared segment that we could write.
+         Make an unshared segment instead.  */
+      if (access (name, W_OK) == 0)
+        {
+          shmid = shmget (IPC_PRIVATE, PURESIZE, NEW_SHMGET_FLAGS);
+          if (shmid == -1
+              || shmat (shmid, (char *)PURE_SEG_BITS, 0) == -1)
+            {
+              fprintf (stderr, "emacs: failure obtaining new unshared memory segment.\n");
+              exit (1);
+            }
+
+          /* Load the proper data into it.  */
+          if (read (fd, PURE_SEG_BITS, PURESIZE) != PURESIZE)
+            {
+              fprintf (stderr, "emacs: failure loading shared memory data.\n");
+              shmdt ((char *)PURE_SEG_BITS);
+              shmctl (shmid, IPC_RMID, 0);
+              exit (1);
+            }
+
+          close (fd);
+          return;
+        }
+
+      /* Allocate the new shared segment and arrange to write it.  */
+      if ((shmid = shmget (shmkey, PURESIZE, NEW_SHMGET_FLAGS)) == -1
+          || shmat (shmid, (char *)PURE_SEG_BITS, 0) == -1)
+        {
+          fprintf (stderr, "emacs: failure obtaining new shared memory segment.\n");
+          shmdt ((char *)PURE_SEG_BITS);
+          shmctl (shmid, IPC_RMID, 0);
+          exit (1);
+        }
+
+      /* Load the proper data into it.  */
+      if (read (fd, PURE_SEG_BITS, PURESIZE) != PURESIZE)
+        {
+          fprintf (stderr, "emacs: failure loading shared memory data.\n");
+          shmdt ((char *)PURE_SEG_BITS);
+          shmctl (shmid, IPC_RMID, 0);
+          exit (1);
+        }
+
+      /* Detach from the segment and bring it back readonly.  */
+      shmdt ((char *)PURE_SEG_BITS);
+
+      shmctl (shmid, IPC_STAT, &buf);
+      buf.shm_perm.mode = OLD_SHMGET_FLAGS;
+      shmctl (shmid, IPC_SET, &buf);
+
+      newaddr = shmat (shmid, (char *)PURE_SEG_BITS, OLD_SHMAT_FLAGS);
+      if (newaddr == -1)
+        {
+          fprintf (stderr, "emacs: failure reattaching shared memory segment.\n");
+          shmctl (shmid, IPC_RMID, 0);
+          exit (1);
+        }
+    }
+
+  close (fd);
+}
+
+/* Dump the appropriate parts of memory into a file named NEW
+   from which the shared segment can be initialized.  */
+
+void
+map_out_data (new)
+     char *new;
+{
+  struct data_header dh;        /* saved data header                    */
+  int fd;                       /* saved data file descriptor           */
+  int length;                   /* dumped data length; */
+
+                                   
+  /* Create "saved data" file header */
+  dh.start = &_data;
+  dh.end = &_end;
+  dh.sbrk1 = original_sbrk;
+  dh.sbrk2 = sbrk (0);
+  dh.puresize = PURESIZE;
+
+  /* Create new "saved data" dump file                          */
+  unlink (new);
+  fd = open (new, NEW_OPEN_FLAGS, 0666);
+  if (fd < 0)
+    report_file_error ("Opening dump file", Fcons (build_string (new), Qnil));
+
+  /* Write saved header and data                                */
+  length = sizeof (dh);
+  if (write (fd, (char *)&dh, length) != length)
+    report_file_error ("Writing dump file header",
+                       Fcons (build_string (new), Qnil));
+  length = dh.end - dh.start;
+  if (write (fd, dh.start, length) != length)
+    report_file_error ("Writing low core in dump file",
+                       Fcons (build_string (new), Qnil));
+  length = dh.sbrk2 - dh.sbrk1;
+  if (write (fd, dh.sbrk1, length) != length)
+    report_file_error ("Writing heap in dump file",
+                       Fcons (build_string (new), Qnil));
+  length = PURESIZE;
+  if (write (fd, PURE_SEG_BITS, length) != length)
+    report_file_error ("Writing pure data in dump file",
+                       Fcons (build_string (new), Qnil));
+  close (fd);
+}