OSProcess for Unix Squeak - Version 0.3 OSProcess provides access to operating system functions, including pipes and child process creation. It is implemented using pluggable primitives in a loadable module for Linux and will probably work on most Unix systems. The Smalltalk code, including the classes which implement pluggable primitives for Unix operating system functions, may be loaded into any Squeak image, but the primitives are only useful on Unix systems. Placeholder classes are provided for Mac and Windows, but are not implemented here. Current capabilities include: - Inspect the OS process in which Squeak is running: "OSProcess forThisOSProcess inspect" - Read standard input, and write standard output and standard error streams. - Create operating system pipes and attach them to AttachableFileStream streams. - Create Unix child processes with protocol similar to (same as?) VisualWorks. - Clean up child processes automatically on exit (a Semaphore is set after receiving a SIGCHLD signal), with child exit status available in Squeak. - Start a second Squeak in a child process, restarting the child from the last saved image file: "UnixProcess squeak" - Clone the running Squeak image, producing two nearly identical Squeaks running from the same object memory at the time of cloning: "UnixProcess forkSqueak" - Clone the running Squeak image, but with no display connection for the child: "UnixProcess forkHeadlessSqueakAndDo: aBlock" - Clone the running Squeak image with no display connection, execute a block, and exit (similar to running a command from a Unix shell, except that the "command" is a Smalltalk block): "UnixProcess forkHeadlessSqueakAndDoThenQuit: aBlock" If you are using a non-Unix platform, you can just file in the Smalltalk files and have a look around. All of the code except for some minor patches to the existing Unix support files is written in Smalltalk. On Unix systems, some patches to sqXWindow.c (the C main program) are required in order to permit access to the command line, environment, stdio, stdout, and stderr. A patch file for this and for the makefile changes is included here. There are also changes to the interpreter support files to provide access to SQFile data structures from pluggable primitives. The changes do not effect the rest of the Squeak system, but they do require a one time rebuild of the virtual machine and all the dynamically loaded modules. The OSProcess primitives are implemented as pluggable primitives in a loadable module. There are no changes to the base VM other than those described above. Installation ------------ To add OS Process support to Squeak on Linux (and probably other Unix systems), follow these steps for the quick installation, or (for the more patient and inquisitive) the bootstrap installation. Quick install: For a quick installation on Unix, do the following. 1) Build a virtual machine from Ian's 2.4 sources. Make sure it works, and back up your files before proceeding. 2) Change directory to the top of your 2.4 source tree, and unpack the tar file or the zip archive, overlaying the existing files. 3) Rebuild the virtual machine. Copy the VM and the loadable modules (*.so files) to their proper locations. If in doubt, put copies of the loadable modules in the directory from which you run Squeak. 4) Run Squeak using the new VM and the new loadable modules. File in the change set for OSProcess, and try the examples in OSProcess class and UnixProcess class. Bootstrap install: For a not-so-quick installation follow these steps. 1) Starting with your existing Squeak 2.4, make sure that you can build a new virtual machine from sources. Back up your source code and image. Get a copy of Ian's Unix source distribution if you have not already done so. Build a VM and any loadable modules (*.so files), and make sure that they work on your system. 2) Make sure you can build a VM with an interp.c which you generate from Squeak. First generate a new interp.c from your Squeak image ("Interpreter translate: 'interp.c' doInlining: true"), then copy it into your source tree and repeat step 1 (use the sqcat utility to copy the file if your Squeak did not write the files using Unix line end conventions). 3) If step 2 fails to link due to unresolved symbols ioSetDisplayMode and ioHasDisplayDepth, then add dummy functions for them. This is most easily done by concatenating the file fix.c in this directory to the end of your new interp.c, then repeating step 2. This resolves a bug in the Squeak 2.4 release, which was missing code for a couple of new primitives. 4) Patch your sqXWindow.c file using the supplied sqXWindow.diff (or simply replace it with the sqXWindow.c in this directory). Rebuild your VM once more to verify that your sqXWindow.c patch works. 5) Add a directory in your Squeak source tree in parallel with the other pluggable modules, and call it ./src/UnixOSProcessAccessor (currently you should also have ./src/SoundCodecPrims and ./src/Squeak3D in your source tree). Also make a subdirectory for the new plugin in the directory for your machine architecture (./i386-linux-2.0.35/UnixOSProcessAccessor on my machine). Edit your ./src/GNUmakefile (the one in your ./src directory, not ./GNUmakefile), and edit line 102 to add UnixOSProcessAccessor to the list of plugins to be built, like this: PLUGINS:= SoundCodecPrims Squeak3D UnixOSProcessAccessor 6) Start Squeak, and file in the change set OSProcess.5July250pm.cs. This will load all the new classes, as well as the changes to the interpreter support files. Save your image. 7) Write out a new set of interpreter support files using "InterpreterSupportCode writeSupportFiles". This will generate new C files and headers with the changes needed to support access to SQFile data structures in the pluggable primitives. 8) Write out the C source code for the UnixOSProcessAccessor module using "UnixOSProcessAccessor translate: 'UnixOSProcessAccessor.c' doInlining: true". See the comment in UnixOSProcessAccessor>>moduleName. 8) Copy the new files into your Squeak source tree (using the sqcat utility if needed for Unix line end conventions). 9) Move the UnixOSProcessAccessor.c source file from ./src/UnixOSProcessAccessor.c into its subdirectory as ./src/UnixOSProcessAccessor/UnixOSProcessAccessor.c. Likewise, move the file ./src/sqGSMCodecPlugin.c to ./src/SoundCodecPrims/sqGSMCodecPlugin.c so that it will be in its correct subdirectory. 10) Run "make" to rebuild the VM and all the loadable modules. Move the executable (i386-linux-2.0.35 on my system) to wherever you want the VM to be located. 11) Copy the loadable module files (*.so), including the new UnixOSProcessAccessor.so loadable module, from the machine architecture directory (./i386-linux-2.0.35 on my machine) to the directory where your Squeak loadable modules live. At this point, you have a working VM with access to the UnixOSProcessAccessor plugin primitives. 12) Restart your image. Try the examples in OSProcess class and UnixProcess class. 13) Let me know what you think. Suggestions for making this work on other Unix flavors, and (better yet) other operating systems would be most welcome. Mon Jul 5 17:42:43 EDT 1999 Dave Lewis lewis@mail.msen.com Linux dtlewis 2.0.35 #3 Fri Jan 1 17:22:57 EST 1999 i586 unknown