Solaris Software Companion (SSC) Buildable Source for OpenSolaris

This delivery of SSC buildable source for OpenSolaris consists of a single archive:

source tarball (ssc-src-DATE.tar.bz2)

Note that the source is also available via Subversion. See 'Obtaining the Source via Subversion' below.

General Prerequisites

Building SSC is similar to building the SFW and Operating System/Networking (ON) consolidations from source. If you are not familiar with building SFW or ON from opensolaris.org, please read the build instructions for ON and SFW and the detailed documentation before starting your build. You will also need the following shared build/install-time tools:

compiler: Sun Studio 10 with patches as delivered for ON
compiler: gcc 3.4.3 with patches as delivered with Solaris Express build 22 or later, or SFW build 22 or later.
ON build tools package (SUNWonbld-DATE.PLATFORM.tar.bz2) from ON
Tcl and Tk source packages installed

Like SFW, SSC does not use BFU or BFU archives. There are no closed binaries; the entire consolidation is Open Source.

Build the SSC consolidation on any OpenSolaris distribution compatible with the Solaris Express release two builds older than the SSC sources. Consult your vendor's documentation for more information about compatibility with Solaris Express. For example, to build SSC sources for build 36, your distribution must be compatible with Solaris Express build 34 or later.

You must also have installed the full set of SSC packages that are less than two builds old. This requirement exists because of the way some components reference binaries and headers during the build. Ocaml and emacs are the most noticeable, but other components may also have this requirement. If you are building only a subset of SSC components, it may be possible to skip installing the entire SSC. However, this is not recommended.

The release notes will always contain information about new or additional build environment requirements that may arise from time to time.

SSC requires the same compilers and support tools as SFW. Be sure you have installed a recent SUNWonbld package. Note that, like SFW, SSC does not contain these build tools, so you must install them in advance rather than relying on nightly's 't' option. In general, your build tools must be no more than 2 builds old. You can obtain the latest SUNWonbld package from the ON download site. The required Studio 10 compilers can be obtained from the Tools community. You must also have the standard Solaris gcc (from Nevada build 22 or later) installed. Note that compilers other than these specific versions have not been tested and may fail to build SSC correctly.

You must install the SUNWTclS and SUNWTkS source packages from a recent Solaris Express distribution. These are required in order to build tclx and expect.

The buildable source may contain source for high key-strength crypto. Please note that certain countries restrict the redistribution of high key-strength crypto. If you live in one of these countries, it is your responsibility to ensure that you are complying with your country's laws in this area.

Special Requirements for build 41

None.

Known Issues for build 41

If you are building x86 binaries, you must use a 64-bit build machine running the 64 bit kernel (6401063). (XXX - applicable to SSC?)
Non-root builds do not work (6418795). You must have root access to your build machine.

For Further Information

General questions on the SSC consolidation should be directed to the discussion list at companion-discuss@opensolaris.org. Please note that the mailing lists are configured to only allow posts from list subscribers or via the web forum interface. To subscribe, see the Companion project home.

Obtaining the Source

If you wish, you can obtain the most recent source via Subversion rather than using the snapshot tarball. You will need to have a recent version (1.3.0 is best) of subversion on your system. See the DSCM evaluation page for binary Subversion packages for Solaris. Your distribution may already include Subversion; check your vendor's documentation. Once you have installed Subversion on your system, you can check out the SSC consolidation from XXX (need URL); for example, if you wish to use /export/companion as your workspace, you could do:

    $ cd /export
    $ /opt/dscm/bin/svn co http://66.193.208.83/companion (XXX URL)

XXX anonymous access via svn/svn+ssh? XXX opensolaris.org svn? XXX need more XXXs here for all the stuff we're missing

Installing from Source

Once you have downloaded the SSC source, follow these steps to build it. Suppose you are using /export/companion as your workspace.

If your build machine is already configured for building ON and/or SFW, skip ahead to step 2. Otherwise, follow the compiler and onbld installation instructions in the ON README. These are steps 2, 3, and 4 in the onnv_41 README.

Be sure that your installed copy of gcc is up to date:

    $ /usr/sfw/bin/gcc --version
    gcc (GCC) 3.4.3 (csl-sol210-3_4-20050802)

Be sure that your installed copy of cc is up to date. If you've followed the above instructions, you should see:
```
    $ /opt/SUNWspro/bin/cc -V
```
Correct output is architecture-dependent:
```
    cc: Sun C 5.7 Patch 117836-03 2005/05/11		(sparc)
    cc: Sun C 5.7 Patch 117837-04 2005/05/11		(x86)
```
NOTE: BOTH COMPILERS are REQUIRED and must be at the correct revisions!
Obtain and install the Tcl and Tk source packages if you have not done so already. These are available on the Solaris Express DVD for your platform in Solaris_11/Product but are not installed as part of any package metacluster, so you will need to install them manually. To install these, do the following:
```
    # cd /path/to/Solaris_11/Product
    # pkgadd -d . SUNWTclS SUNWTkS
```
cd to /export/companion and unpack the source into your build area, e.g.
```
    $ bzcat ssc-src-DATE.tar.bz2 | tar xf -
```
The sources will unpack into "usr/src." Note that SSC does not require any closed binaries. You can use any convenient location instead of /export/companion, but these instructions will assume you've unpacked the source there.
Create an environment file to guide tools like nightly(1) and bldenv(1). You CANNOT use the same env file you use to build ON or any other consolidation! Copy /export/companion/usr/src/tools/env/ssc-opensolaris.sh to /export/companion. It doesn't have to go in /export/companion, but that's a convenient place to put it. Nor do you have to keep the name ssc-opensolaris.sh, but that's the name we'll use in these notes. Then make the following changes in your ssc-opensolaris.sh:
- change GATE to the name of the top-level directory (e.g., "companion").
- change CODEMGR_WS to the top-level path (e.g., "/export").
- change STAFFER to your login.
- Do NOT set VERSION; this will break your build!
- The default options are recommended. Using other options may cause your build to fail or contain unnecessary noise.
To build a complete set of archives, cd to /export/companion, utter
```
    # /opt/onbld/bin/nightly ./ssc-opensolaris.sh &
```
and find something else to work on for a few hours. You can monitor the build's progress using ptree(1). nightly(1) will send mail to $MAILTO when it has finished.
The results mail from nightly(1) will have an overview of the build results. A copy of the mail text and a more detailed log file will be available in the workspace (/export/companion/log/log.mmdd). Pieces of the detailed log are also available under usr/src. For example, usr/src/install-i386.out will have the log from the x86 "make install" part of the build.

By default nightly(1) will do a "clobber" build, which includes a "make clobber" and blowing away any files that earlier builds installed into $ROOT (/export/companion/proto/root_PLATFORM). To bypass these steps, do an incremental build with "nightly -i ./ssc-opensolaris.sh &".
To build a specific component, first use bldenv(1) to set up various environment variables:
```
    # cd /export/companion
    # bldenv ./ssc-opensolaris.sh
    [status information from bldenv]
```
Next, you must create and partially populate the proto area:
```
    # cd $SRC
    # make rootdirs
    # make tools
    # make headers
```
Finally, cd into the directory containing the component you wish to build, and run make:
```
    # make -f Makefile.sfw
```
Note that all sub-makefiles are called Makefile.sfw.
The packages and other results from a nightly build will be found in the /export/companion directory. Along with the log directory discussed above, you will find the proto and packages directories. The proto directory contains the files produced by the builds. For example, on a SPARC machine, within proto you will find the root_sparc directory, and within that, the opt/sfw directory containing the bin, lib and other directories created during the nightly build. In the packages directory, you will find a sparc/nightly-nd directory containing packages like SFWaalib and SFWaalibS. These directories can be used with pkgadd to install programs in the actual /opt/sfw directory. The S on the end of a package name indicates that this contains the source for that package and when installed goes in the /opt/sfw/src location.

If you wish to create an individual package, you can go into the pkgdefs directory in usr/src and change directory to the appropriate package. For example, you might run
```
  # cd usr/src/pkgdefs
  # cd SFWaalib
  # make clobber
  # make all install
```
This will create the installable SFWaalib package in the packages/sparc/nighly-nd directory.