INTRODUCTION

Solaris is a Unix operating system originally developed by Sun Microsystems. It

superseded their earlier SunOS in 1992. Oracle Solaris, as it is now known, has
been owned by Oracle Corporation since Oracle's acquisition of Sun in January
2010.
Solaris is known for its scalability, especially on SPARC systems, and for
originating many innovative features such as DTrace, ZFS and Time Slider.
Solaris supports SPARC-based and x86-based workstations and servers from
Sun and other vendors, with efforts underway to port to additional platforms.
Solaris was historically developed as proprietary software, then in June 2005
Sun Microsystems released most of the codebase under the CDDL license, and
founded the OpenSolaris open source project. With OpenSolaris Sun wanted to
build a developer and user community around the software. After the
acquisition of Sun Microsystems in January 2010, Oracle decided to discontinue
the OpenSolaris distribution and the development model. As a result, the
OpenSolaris community forked the OpenIndiana project, as part of the Illumos
Foundation. However, starting with Solaris 11, updates to the Solaris source
code will still be distributed under the CDDL license, after full binary releases
are made Oracle will also begin a technology partner program, called Oracle
Technology Network (OTN), to permit their industry partners access to the in-
development Solaris source code.

HISTORY
In 1987, AT&T and Sun announced that they were collaborating on a project to
merge the most popular Unix variants on the market at that time: BSD, System
V, and Xenix. This became Unix System V Release 4 (SVR4).
On September 4, 1991, Sun announced that it would replace its existing BSD-
derived Unix, SunOS 4, with one based on SVR4. This was identified internally
as SunOS 5, but a new marketing name was introduced at the same time:
Solaris 2. While SunOS 4.1.x micro releases were retroactively named Solaris 1
by Sun, the Solaris name is almost exclusively used to refer to the SVR4-derived
SunOS 5.0 and later.
The justification for this new "overbrand" was that it encompassed not only
SunOS, but also the OpenWindows graphical user interface and Open Network
Computing (ONC) functionality. The SunOS minor version is included in the
Solaris release number; for example, Solaris 2.4 incorporated SunOS 5.4. After
Solaris 2.6, Sun dropped the "2." from number, the so Solaris 7 incorporates
SunOS 5.7, and the latest release SunOS 5.10 forms the core of Solaris 10.

OVERVIEW

Company / developer Orac

le
Corp
orati
on

Programmed in C

OS family Unix

Working state Curr

ent

Source model Mixe

d
open
sourc
e/
 close
d
sourc
e

Initial release 1992

Latest stable release 11

Expr
ess
2010
.11/
Nove
mber
15,
2010
;4
mont
hs
ago

Marketing target Wor

kstati
on,
Serv
er

Available language(s) Engli

sh

Available programming C
languages(s)

Supported platforms SPA

RC,
IA-
32,
x86-
 64,
Pow
erPC
(Sola
ris
2.5.1
only)

Kernel type Mon

olithi
c

Default user interface Open

Solar
is
Desk
top
or
CDE
or
GNO
ME

License Vario
us

Official website oracl

e.co
m/so
laris

INSTALLATION AND USAGE OPTIONS

Solaris can be installed from various pre-packaged software groups, ranging
from a minimalistic "Reduced Network Support" to a complete "Entire Plus
OEM". Installation of Solaris is not necessary for an individual to use the
system. Additional software, like Apache, MySQL, etc. can be installed as well
in a packaged form from sunfreeware, OpenCSW and Blastwave.
Solaris 10 text installation
Solaris 10 graphical installation

Usage with installation

Solaris can be installed from physical media or a network for use on a desktop
or server.
Solaris can be interactively installed from a text console on platforms without a
video display and mouse. This may be selected for servers, in a rack, in a
remote data center, from a terminal server or even dial up modem.
Solaris can be interactively installed from a graphical console. This may be
selected for personal workstations or laptops, in a local area, where a console
may normally be used.
Solaris can be automatically installed over a network. System administrators
can customize installations with scripts and configuration files, including
configuration and automatic installation of third-party software, without
purchasing additional software management utilities.
When Solaris is installed, the operating system will reside on the same system
where the installation occurred. Applications may be individually installed on
the local system, or can be mounted via the network from a remote system.
Usage without installation
Solaris can be used without separately installing the operating system on a
desktop or server.
Solaris can be booted from a remote server providing an OS image in a diskless
environment, or in an environment where an internal disk is only used for swap
space. In this configuration, the operating system still runs locally on the
system. Applications may or may not reside locally when they are running. This
may be selected for businesses or educational institutions where rapid setup is
required (workstations can be "rolled off" of a loading dock, the MAC address
registered into a central server, plugged in, and be immediately usable) or rapid
replacement is required (if a desktop hardware failure occurs, a new workstation
is pulled from a closet, plugged in, and a user can resume their work from their
last saved point.)
Solaris can also be used from a thin client. Applications, operating system,
window manager, and graphical rendering runs on one or more remote servers.
Administrators can add a user account to a central Solaris system and a thin
client can be rolled from a closet, placed on a desktop, and a user can start work
immediately. If there is a hardware failure, the thin client can be swapped and
the user can resume their work from the exact point of failure, whether or not
the work was saved.
DESKTOP ENVIRONMENTS
Early releases of Solaris used OpenWindows as the standard desktop
environment. In Solaris 2.0 to 2.2, OpenWindows supported both NeWS and X
applications, and provided backward compatibility for SunView applications
from Sun's older desktop environment. NeWS allowed applications to be built
in an object oriented way using PostScript, a common printing language
released in 1982. The X Window System originated from MIT's Project Athenain
1984 and allowed for the display of an application to be disconnected
from the machine where the application was running, separated by a network
connection. Sun’s original bundled SunView application suite was ported to X.
Sun later dropped support for legacy SunView applications and NeWS with
OpenWindows 3.3, which shipped with Solaris 2.3, and switched to X11R5 with
Display Postscript support. The graphical look and feel remained based upon
OPEN LOOK. OpenWindows 3.6.2 was the last release under Solaris 8. The
OPEN LOOK Window Manager (olwm) with other OPEN LOOK specific
applications were dropped in Solaris 9, but support libraries were still bundled,
providing long term binary backwards compatibility with existing applications.
The OPEN LOOK Virtual Window Manager (olvwm) can still be downloaded for
Solaris from sunfreeware and works on releases as recent as Solaris 10.
Sun and other Unix vendors created an industry alliance to standardize Unix
desktops. As a member of COSE, the Common Open Software Environment
initiative, Sun helped co-develop the Common Desktop Environment. CDE was
an initiative to create a standard Unix desktop environment. Each vendor
contributed different components: Hewlett-Packard contributed the window
manager, IBM provided the file manager, and Sun provided the e-mail and
calendar facilities as well as drag-and-drop support (ToolTalk). This new
desktop environment was based upon the Motif look and feel and the old
OPEN LOOK desktop environment was considered legacy. Solaris 2.5 onwards
supported CDE. CDE unified Unix desktops across multiple open system
vendors.
In 2001, Sun issued a preview release of the open-source desktop environment
GNOME 1.4, based on the GTK+ toolkit, for Solaris 8. Solaris 9 8/03 introduced
GNOME 2.0 as an alternative to CDE. Solaris 10 includes Sun's Java Desktop
System (JDS), which is based on GNOME and comes with a large set of
applications, including StarOffice, Sun's office suite. Sun describes JDS as a
"major component" of Solaris 10.
The open source desktop environments KDE and Xfce, along with numerous
other window managers, also compile and run on recent versions of Solaris.

KEY FEATURES OF SOLARIS

 Oracle Solaris Containers—Virtualization functionality included in

Oracle Solaris that enables customers to create multiple application
environments within a single instance of the OS; through the use of software-
defined boundaries, customers can achieve greater efficiency of IT resources by
consolidating systems and securely isolating applications and services
 Oracle Solaris DTrace—Allows you to use the dynamic instrumentation
and tracing capabilities in Oracle Solaris to see what's really going on in the
system; it is designed to be safely used on production systems—without
modifying applications
 Oracle Solaris Predictive Self Healing—Allows the server to
accurately predict component failures and mitigate many potentially serious
problems before they actually occur; if an application or service fails, the built-
in restart mechanism automatically restarts the application or service
 Oracle Solaris Trusted Extensions—This advanced security feature
implements labels to protect your data and applications based on their
sensitivity level, not just on who owns or runs them
 Oracle Solaris ZFS—An advanced file system that simplifies
administrative tasks, protects data from corruption, and scales from the desktop
to the datacenter
Additional Features
 Guaranteed binary compatibility—Applications run unchanged across
Oracle Solaris releases
 Oracle Solaris Live Upgrade—Allows Oracle Solaris to continue to run
while performing upgrades or maintenance
 Interoperability—Seamless interoperability between Oracle Solaris and
Linux-based systems.
 Role-Based Access Control (RBAC)—Delegate administration function
to the users who need them
 Oracle Solaris Service Manager—A key functionality of Predictive
Self Healing, Service Manager ensures your applications will keep running
even through hardware and software faults
 to hardware and software errors and automatically diagnoses the
underlying problem and responds by offlining Oracle Solaris Fault Manager
—A key functionality of Predictive Self Healing, Fault Manager continually
monitors data relating faulty components.
SOME HANDY SOLARIS COMMANDS
df -n (or fstyp device) show type of file system (ufs/vxfs)
fuser and pfiles open files
prtconf -V OBP level
pgrep, pkill, prstat -a process info and manipulation
logins -p|-d local users without passwords | duplicate uids
mpstat, prtdiag, psrinfo -v processor information and more
traceroute since Solaris 7
troff -man man.1 | dpost | lp print old style man pages
sgml2roff lpfilter.1m | troff -man | dpost | lp print sgml (new) man pages
fstyp -v list superblock including minfree %
tput nice screen output
what, ldd, strings information about binaries
ctrl-V in vi insert control character
ftp> get README | more
ufsdump 0f - /filesystem | (cd /mnt; dump restore pipe
ufsrestore rf -); rm /mnt/restoresymtable
echo \007 get bell to ring
comm common (non-common) lines from two files
pkgchk -lp /usr/bin/ls which package does ls belong to?
df -oi -F ufs free inodes
icheck -b blockno filesystem block to file mapping
dircmp, rsync, filesync compare directories, sync utilities
nohup /var/tmp/myscript.ksh > for things which have to complete (no risk of t
/var/tmp/myscript.out &
netstat -pn arp like output when name services are down
 pwdx, pldd, ptree and more in /usr/proc/bin
uname -X basic system information - one item on each li

read read a line

listusers another way of listing users
tcopy copy tape
nfsstat -m (or check /etc/rmtab) current nfs mount
clear_locks clear nfs locks
df -h, du -h, ls -lh since Solaris 9 - output in powers of 1024

SOLARIS INTERNALS

Solaris Process
Scheduling
In Solaris, highest priorities are
scheduled first. Kernel thread
scheduling information can be
revealed with ps -elcL.
A process can exist in one of the
following states: running,
sleeping or ready.

Kernel Threads Model

The Solaris 10 kernel threads model consists of the following major
objects:
 kernel threads
 user threads
 process: The object that tracks the execution environment of a
program.
 lightweight process (lwp)
Associates a user thread with a kernel thread.
In the Solaris 10 kernel, kernel services and tasks are executed as kern
threads. When a user thread is created, the associated lwp and kernel
threads are also created and linked to the user thread.
(This single-level model was first introduced in Solaris 8's alternative
threads library, which was made the default in Solaris 9. Prior to that,
threads had to bind to an available lwp before becoming eligible to run
the processor.)
Priority Model
The Solaris kernel is fully preemptible. This means that all threads,
including the threads that support the kernel's own activities, can be
deferred to allow a higher- priority thread to run.
Solaris recognizes 170 different priorities, 0-169. Within these prioriti
fall a number of different scheduling classes:
 TS (timeshare)
associated kernel threads. Priorities within this class range 0-59
are dynamically adjusted in an attempt to allocate processor
resources evenly.
 IA (interactive)
applies to the in-focus window in the GUI. Its intent is to give e
resources to processes associated with that specific window. Lik
IA's range is 0-59.
 FSS (fair-share scheduler)
priority- based. Threads managed by FSS are scheduled based o
their associated shares and the processor's utilization. FSS also h
range 0-59.
 FX (fixed-priority)
class are fixed. (In other words, they do not vary dynamically o
the lifetime of the thread.) FX also has a range 0-59.
 SYS (system)
Threads in this class are "bound" threads, which means that they
until they block or complete. Priorities for SYS threads are in th
99 range.
 RT (real-time)
fixed time quantum. Their priorities range 100-159, so an RT th
will preempt a system thread.
Fair Share Scheduler
The default Timesharing (TS) scheduling class in Solaris attempts to a
each process on the system to have relatively equal CPU access. The n
command allows some management of process priority, but the new F
Share Scheduler (FSS) allows more flexible process priority managem
that integrates with the
Each project is allocated a certain number of CPU shares via the
project.cpu-shares resource control. Each project is allocated CPU tim
based on its cpu-shares value divided by the sum of the cpu-shares val
for all active projects.
Anything with a zero cpu-shares value will not be granted CPU time u
all projects with non-zero cpu-shares are done with the CPU.
The maximum number of shares that can be assigned to any one proje
65535.
FSS can be assigned to processor sets, resulting in more sensitive cont
priorities on a server than raw processor sets. The dispadmin comman
command controls the assignment of schedulers to processor sets, usin
form like:
dispadmin -d FSS

The Fair Share Scheduler should not be combined with the TS, FX (fix
priority) or IA (interactive) scheduling classes on the same CPU or
processor set. All of these scheduling classes use priorities in the same
range, so unexpected behavior can result from combining FSS with an
these. (There is no problem, however, with running TS and IA on the s
processor set.)
To move a specific project's processes into FSS, run something like:
priocntl -s -c FSS -i projid
All processes can be moved into FSS by first converting init, then the
of the processes:
priocntl -s -c FSS -i pid 1
priocntl -s -c FSS -i all
Implementation Details
Time Slicing for TS and IA
TS and IA scheduling classes implement an adaptive time slicing sche
that increases the priority of I/O-bound processes at the expense of
compute-bound processes. The exact values that are used to implemen
can be found in the dispatch table. To examine the TS dispatch table, r
the command dispadmin -c TS -g. (If units are not specified, dispadmi
reports time values in ms.)
The following values are reported in the dispatch table:
 ts_quantum
with the specified priority.
 ts_tqexp: This is the new priority that is assigned to a process th
uses its entire time quantum.
 ts_slpret: The new priority assigned to a process that blocks bef
using its entire time quantum.
  ts_maxwait
interval of ts_maxwait, its priority is raised to ts_lwait.
 ts_lwait:

Time Slicing for FSS

In FSS, the time quantum
run before it has to release the processor. This can be checked using
dispadmin -c FSS -g
The QUANTUM is reported in ms. (The output of the above comman
displays the resolution in the RES parameter. The default is 1000 slice
second.) It can be adjusted using dispadmin as well. First, run the abov
command and capture the output to a text file (
command:
dispadmin -c FSS -s
Callouts
Solaris handles callouts with a callout thread that runs at maximum sy
priority, which is still lower than any RT thread. RT callouts are handl
separately and are invoked at the lowest interrupt level, which ensures
prompt processing.
Priority Inheritance
Each thread has two priorities: global priority and inherited priority. T
inherited priority is normally zero unless the thread is sitting on a reso
that is required by a higher priority thread.
When a thread blocks on a resource, it attempts to "will" or pass on its
priority to all threads that are directly or indirectly blocking it. The
pi_willto() function checks each thread that is blocking the resource or
is blocking a thread in the syncronization chain. When it sees threads t
are a lower priority, those threads inherit the priority of the blocked th
It stops traversing the syncronization chain when it hits an object that
blocked or is higher priority than the willing thread.
This mechanism is of limited use when considering condition variable
semaphore or read/write locks. In the latter case, an
defined, and the inheritance works as above. If there are several thread
sharing a read lock, however, the inheritance only works on one thread
time.
Thundering Herd
When a resource is freed, all threads awaiting that resource are woken
results in a footrace to obtain access to that object; one succeeds and th
others return to sleep. This can lead to wasted overhead for context
switches, as well as a problem with lower priority threads obtaining ac
to an object before a higher-priority thread. This is called a "thunderin
herd" problem.
Priority inheritance is an attempt to deal with this problem, but some t
of syncronization do not use inheritance.
Turnstiles
Each syncronization object (lock) contains a pointer to a structure kno
a turnstile. These contain the data needed to manipulate the syncroniza
object, such as a queue of blocked threads and a pointer to the thread t
currently using the resource. Turnstiles are dynamically allocated base
the number of allocated threads on the system. A turnstile is allocated
the first thread that blocks on a resource and is freed when no more th
are blocked on the resource.
Turnstiles queue the blocked threads according to their priority. Turnst
may issue a signal
a broadcast to wake up all sleeping threads.
Adjusting Priorities
The priority of a process can be adjusted with priocntl or nice, and the
priority of an LWP can be controlled with priocntl().
Real Time Issues
STREAMS processing is moved into its own kernel threads, which run
lower priority than RT threads. If an RT thread places a STREAMS re
it may be serviced at a lower priority level than is merited.
Real time processes also lock all their pages in memory. This can caus
problems on a system that is underconfigured for the amount of memo
that is required.
Since real time processes run at such a high priority, system daemons
suffer if the real time process does not permit them to run.
When a real time process forks, the new process also inherits real time
privileges. The programmer must take care to prevent unintended
consequences. Loops can also be hard to stop, so the programmer also
needs to make sure that the program does not get caught in an infinite
Interrupts
Interrupt levels run between 0 and 15. Some typical interrupts include
 soft interrupts
 SCSI/FC disks (3)
 Tape, Ethernet
 Video/graphics
 clock() (10)
 serial communications
 real-time CPU clock
 Nonmaskable interrupts (15)
Process Management
Multiprogramming systems explicitly allow multiple processes to exist
any given time, where only one is using the CPU at any given moment
while the remaining processes are performing I/O or are waiting.
The process manager is of the four major parts of the operating syste
implements the process abstraction. It does this by creating a model f
the way the process uses CPU and any system resources. Much of the
complexity of the operating system stems from the need for multiple
processes to share the hardware at the same time. As a conseuence o
goal, the process manager implements CPU sharing ( called
process synchronization
the process manager implements part of the operating system's prote
and security.

List of Solaris commands for process management

apptrace – for tracing library calls

dtrace – debugger, new in version 10
pargs – get list of arguments and environment variables with which
process was started
pfiles – list of file descriptors, associated with process
pgrep – get the PID's of processes by name i.e. Something like ps -efl|
-v grep|grep process_name
pkill – send signal to process. For example pkill -9 init
pldd – list dynamic libraries, associated with process, similar to ldd fo
executable
plockstat – see list of locked by process files. Lock can be mutex i.e.
exclusive and reader/writer for shared access
pmap – get memory map (segments) of process
preap – try to kick-off zombie process
prstat – fullscreen view of processes sorted by different criteria, simila
Linux top command
prun – continue hold with pstop process
ps - print process information and status. In Solaris exist SYSV and BSD
variants, respectively /usr/bin/ps and /usr/ucb/ps
psig – list signals that can be handled by process
pstack – get backtrace stack of process for debugging purposes
pstop – temporary hold process
ptree - print the tree of processes
pwait – wait till process finish
pwdx – list working directory for process, like pwd command
truss – for tracing user/library/system calls and signals

INTER PROCESS COMMUNICATION

Interprocess communication (IPC) is used for programs to communica
data to each other and to synchronize their activities. Semaphores, sh
memory, and internal message queues are common methods of
interprocess communication.

Shared memory, semaphores

appropriate kernel modules are loaded. These are automatically loaded
certain IPC functions are called, but they can also be forced to load via
/etc/system forceload commands or root modload commands.
Each of these three facilities runs on top of the /kernel/misc/ipc modul
Shared memory connects to the ipc module via /kernel/sys/shmsys,
semaphores connect via /kernel/sys/semsys and message queues conne
via /kernel/sys/msgsys.
Other IPC mechanisms exist (such as named pipes), but they are not
tuneable in the sense of this discussion.
Each IPC resource has at least these attributes: key (identifies this inst
of the resource), creator (UID/GID of the creating process), owner
(UID/GID of the resource owner), and permissions (similar to filesyst
read/write/execute owner/group/other permissions).
Each object is created by calling the appropriate *get function ( shmge
semget / msgget ) with the desired key. If no objects of that type with
key exist, it is created and a resource ID is passed back to the caller.
Once created, the IPC objects can be controlled with the appropriate *
function ( shmctl / semctl / msgctl ).
The ipcs command presents information on IPC services that are curre
loaded. It presents a "facility not in system" message if a given modul
not been loaded yet.
Shared Memory
Shared memory provides the fastest way for processes to pass large
amounts of data to one another. As the name implies, shared memory r
to physical pages of memory that are shared by more than one process
Database applications are the heaviest users of shared memory. Vendo
recommendations should be consulted when tuning the shared memor
parameters.
Semaphores
Semaphores are a shareable resource that take on a non-negative integ
value. They are manipulted by the P (wait) and V (signal) functions, w
decrement and increment the semaphore, respectively. When a process
needs a resource, a "wait" is issued and the semaphore is decremented
When the semaphore contains a value of zero, the resources are not
available and the calling process spins or blocks (as appropriate) until
resources are available. When a process releases a resource controlled
semaphore, it increments the semaphore and the waiting processes are
notified.

Message Queues
Unix uses message queues for asynchronous message passing between
processes. Each message has a type field, which can be used for priori
messaging or directing a message to a chosen recipient.
Message queues are implemented as FIFO (first-in first-out) mechanis
They consist of a header pointing to a linked list.

Solaris 10 What's New?

Solaris 10+ IPC Resource
Management
The Solaris 10 IPC resource
management framework was
designed to overcome several
shortcomings of the older SVR4-
based system. Several parameters
were converted to be dynamically
resized, the defaults were
increased, the names were
changed to be more human-
readable, the resource limits were
system-wide (permitting potential
conflicts) and reboots were
required for even minor changes.
The Solaris 10 system allows
changes to be associated with a
project and monitored via prctl.
For the purposes of IPC resource
management, the following are
the important parameters:
 project.max-shm-ids:
Maximum shared memory
IDs for a project. Replaces
shmmni
 project.max-sem-ids:
Maximum semaphore IDs
for a project. Replaces
semmni
 project.max-msg-ids:
Maximum message queue
IDs for a project. Replaces
msgmni
 project.max-shm-memory:
Total amount of shared
memory allowed for a
project. Replaces shmmax
 process.max-sem-nsems:
Maximum number of
semaphores allowed per
semaphore set. Replaces
semmsl
 process.max-sem-ops:
Maximum number of
semaphore operations
allowed per semop.
Replaces semopm
 process.max-msg-qbytes:
Maximum number of bytes
of messages on a message
queue. Replaces msgmnb
 process.max-msg-
messages: Maximum
number of messages on a
message queue. Replaces
msgtql
Solaris Filesystem
Choices
When it comes to dealing with
storage, Solaris 10 provides
admins with more choices than
any other operating system. Right
out of the box, it offers two
filesystems, two volume
managers, an iscsi target and
initiator, and, naturally, an NFS
server. Add a couple of Sun
packages and you have volume
replication, a cluster filesystem,
and a hierarchical storage
manager. Trust your data to the
still-in-development features
found in OpenSolaris, and you
can have a fibre channel target
and an in-kernel CIFS server,
among other things. True, some
of these features can be found in
any enterprise-ready UNIX OS.
But Solaris 10 integrates all of
them into one well-tested
package.

INPUT AND OUTPUT

Input/Output Completion Port

(IOCP) is an API for
performing multiple
simultaneous asynchronous
input/output operations in
Solaris 10 and later.[2] An
input/output completion port
object is created and associated
with a number of sockets or file
handles. When I/O services are
requested on the object,
completion is indicated by a
message queued to the I/O
completion port. A process
requesting I/O services is not
notified of completion of the I/O
services, but instead checks the
I/O completion port's message
queue to determine the status of
its I/O requests. The I/O
completion port manages
multiple threads and their
concurrency.

Oracle Solaris:
Virtualization

BENEFITS

Rapidly move or replicate applications—Containers provides the

ability to detach/attach and to clone in conjunction with ZFS file
system cloning
Lower administrative costs—Safely consolidate multiple applications
on a single system; Containers provide fault isolation, security
isolation, and dynamic resource allocation
Reduce conflicts among applications running on the same system—A
practically limitless number of virtual environments can be set up,
each with its own separate system resources and assignments
Minimize fault propagation and unplanned downtime—Oracle Solaris
Containers are fully integrated with the
Healing feature, providing for automatic recovery in the face of
unexpected interruptions
Enhance security—Unauthorized access into one application cannot b
exploited to attack other Containers or the global system
administration environmenit
Highly efficent—Unlike hypervisor-based virtualization, Containers
run within a single OS instance; there is little to no greater number of
applications can be consolidated onto a single system with bare-metal
performance yielding across-the-board cost savings additional
overhead with running applications, and a
applications can be consolidated onto a single system with bare-metal
performance yielding across-the-board cost savings.

DIFFERENCE
BETWEEN SOLARIS
AND LINUX

 The first Solaris OS was

released in 1983 while Linux
was first released in 1991.
Solaris OS started as
proprietary software and
recently moved to freeware
while Linux started as open
source freeware.
 Linux boasts a smaller kernel
and its code was rewritten
from the ground up while
Solaris was originally based
on Berkeley UNIX or BSD.
With the release of SunOS 5
(see version history) Sun
 switched from a BSD based
OS to a SRV4 based OS. For a
chronological relational list
showing 100's of the major
names in UNIX.
 Solaris was originally a
proprietary product and
operated strictly on SPARC
platforms while Linux
operates on x86 platforms.
Solaris now supports x86
platforms in addition to
SPARC.
 Solaris also boasts full Linux
compatibility
 Solaris UNIX is
trademarked by The Open Group
and Linux is not. Acquiring a
trademark is challenging and
costly.

 There is an ongoing debate
about what is a "true" UNIX OS
and what is a UNIX-like or
UNIX-flavor OS. However, there
is no official definition that
distinguishes between the
thousands of products that use
UNIX commands and primarily
for the various UNIX OS's.

 However, Windows does
provide some POSIX
compatibility. UNIX shells. The
only official way to differentiate
is by the trademark controlled by
The Open Group .
 POSIX (Portable Operating
System Interface) is a family of
standards to define the API .

WHY ORACLE
SOLARIS?
SOLARIS
ADVANTAGES
Compatibility - software that
works on one release or for a
given patch revision of Solaris is
pretty well guaranteed to run
subsequently. This is huge, and
isn't generally true for other
platforms. I've got 20-year old
applications running happily day
in, day out. By and large,
everything just works, and
continues to work.

Installation Automation -
jumpstart is a huge competitive
advantage. You can trivially
deploy systems, being able to
completely reproduce a
configuration, and roll out
systems and updates effortlessly.

Lightweight virtualization -
Zones, especially sparse root
zones, allow you to consolidate
large numbers of small systems
onto a server, with minimal
overhead and without adding to
the management overhead
normally associated with adding
another system to your network.
(Note that the real advantage here
comes from the use of sparse root
zones, which not only guarantee
that the zone looks like its parent,
but mean that you don't manage
the software on the zones at all
but just manage the parent host.
Whole root zones aren't as
lightweight and don't have
anything like the same
advantages, and branded zones -
while a neat trick - don't have any
compelling advantages over other
virtualization solutions.)

ZFS - for storage on a massive

scale, combined with ease of
management, and the ability to
verify that your data is what you
though it was, this is key. To that
you can add snapshots (which we
use automatically now any time
we change something, which
makes our backout plans for a
change request way simpler than
they used to be), and compression
(storing text - or xml - files just
got a whole lot cheaper), and it's
free.

Ease of management - while

Sun have generally failed
completely to provide advanced
management tools, the fact is that
you don't need them - the
underlying facilities in Solaris are
pretty solid and it's trivial to write
your own layer of tools on top,
and integrate Solaris into a range
of other tools. Not only that, but
the tools are consistent - while
things do evolve, you don't have
to completely relearn how to
manage the system on a regular
and frequent basis.

Cheap - it's free, and not only

that but you don't have to pay for
a 3rd-party virtualization solution,
I/O multipathing, volume
manager, or filesystem, as they're
all included.
Advantages of Solaris and
OpenSolaris over Linux
OpenSolaris

Why use OpenSolaris if I already

have Linux?

 OpenSolaris has a very

welcoming community
where novice and
beginners can easily find
help. Community members
are very co-operative and
encouraging.
 As engineers, our work is
to __MAKE__ technology
more "accessible" and
"easy to use" and not look
for technologies which
__ARE__ "accessible" and
"easy to use". OpenSolaris
has made a big switch from
being a server OS to
Desktop OS and has very
cool technologies built into
it, but it might not be as
easy to use as other OSes
like Linux or Windows.
And thus its an opportunity
for the developers to work
towards __MAKING__
these cool stuff of
OpenSolaris more
"accessible" and "easy to
use" for general public.
  Linux as a Desktop OS is
quite mature and its
difficult for a beginner to
make a drastic difference in
the community.
OpenSolaris on the other
hand is on its way to
become a OS which would
work perfectly out-of-the-
box! So any help in this
would be appreciated by
the community.
Solaris versus Red Hat
Advantages of Solaris.

 Solairs is free. Both

Regular Solaris and
OpenSolaris
 Solaris with support is
often less expensive than
Red Hat with support on
the same hardware.
 Linux sometimes is faster
than Solaris when running
on the platform for which it
was originally designed: A
single 32-bit x86 CPU PC.
When you get to multiple
CPUs, multiple cores, etc.
Solaris will usually be
better. Even on the original
Linux target platform,
Solaris usually wins the
speed battle.
 Solaris 10 is secure and
certified as secure.
 If you have a problem with
a part of Linux other than
the kernel, you may end up
 at the short end of the "we
don't support that particular
add-on, but we're sending a
request out to the
community and we hope
that the grad student who
developed it three years
ago will see it and respond"
stick from your Linux
vendor. With Solaris you
contact Sun and we fix it.
 ZFS is definitely something
database people want.
Faster and more reliable
storage makes for better
databases.
 Dtrace is something
database people want. If
their production system is
underperforming, being
able to diagnose what's
going on without having to
shut it down is a good
thing.
 Containers are of interest to
database people. Instead of
needing to buy separate
systems for their
production, test, and
development database
environments they can put
them in separate containers
on one system.
 Solaris is and has been
tested in the most rigorous
of enterprise environments.
 OpenSolaris is ahead of
Linux for an obvious
reason, Linux is developed
by lots of [smart] people on
commodity hardware.
Solaris is developed on
specialized hardware,
unless you know lots of
people who have a system
with >200 cpu and 2TB
memory and 1PTbyte File
system. So yes Solaris is
better on big iron and
Linux is good on small
hardware.
Always about trade-offs,
but since 2yr the hardware
is moving up fast (i.e quad-
core CPU's and 16core
systems with far more
underway by intel and
AMD, 1.5TBdisks are
cheap, 16GB on a small
system is common, ..
10Gbit/sec appearing soon
on most system
boards, ... ). As you know
rewriting software is not
easy, so Linux is facing a
lot of issues, which
Solaris has solved years
ago. Taking advantage of
this large hardware will not
be easy from the software
side either, but then Solaris
has Zones and Containers
to consolidate this and
divide a large box in an
efficient way.
Very powerful features in
Solaris for databases and
application servers 
 IPS make
installation/maintain/updat
e very easy.
 ZFS snapshot/rollback your
config/data/tables,
add/remove your storage
space.
 Zones isolate your apps.
clone your apps.
 SMF  make your apps very
reliable.
 DTrace observe every
thing, from the app to the
kernel.

SOLARIS
DISADVANTAGES
 Hardware support is not
nearly as good as many
Linux or Windows
operating systems. It is
improving.

 We can run Solaris for free,

but we can't get updates for
free. Not even security
updates. Not even 0-day
exploits. You have to buy a
support plan, per system,
which can be expensive.
This means that the way to
get updates is to wait for
the next "U" release, and
upgrade at that point.

 OpenSolaris is too bleeding

 edge , it changes too often,
and the releases wander too
close to unstable or
unreliable for needs.

 It's a pain to install and use

at times.

 Uncompatible : It is not
recommended to run
Solaris on other
architectures such as Intel,
AMD. It is possible to
install Solaris on Intel
however, the performance
would degrade
considerably since Solaris
cannot make use of Intel
that efficiently.

 Lack of good GUI : Solaris

does have GUI support -
Common Desktop
Environment,
OpenWindows etc. but they
are far way from the other
GUI environments seen in
Windows or Mac.

 Costlier : With other

cheaper alternatvies such as
Linux available, it proves
to be costlier to acquire a
license of Solaris. Since it
is intended to be used on
SPARC so the end user
often ends up in buying the
hardware as well.
Now it all depends what kind of
need you have. If you are a home
user or a developer with average
needs then it makes sense to
either go for Windows or Linux
(since Linux is POSIX compliant
too). However, if perfromance is
what you want then solaris would
be a good option.
But remember getting Solaris
would make sense only with a
SPARC machine - which means
paying for hardware as well
.
 .