9 November, 2011
By Mark Cox
Oracle has announced availability of Oracle Solaris 11, the first fully virtualized OS, which it is terming the first Cloud OS. Oracle Solaris 11 is designed to meet the security, performance and scalability requirements of cloud-based deployments allowing customers to run their most demanding enterprise applications in private, hybrid, or public clouds.
Oracle Solaris 11 provides comprehensive, built-in virtualization capabilities for OS, network and storage resources. In addition to its built-in virtualization capabilities, Oracle Solaris 11 is engineered for Oracle VM server virtualization on both x86 and SPARC based systems, providing deployment flexibility and secure live migration.
“Oracle Solaris 11 is the most significant operating system release of the past decade,” said John Fowler, executive vice president, Systems, Oracle. “With built-in server, storage and now, network virtualization, Oracle Solaris 11 delivers the industry’s first cloud OS. Customers can simplify their enterprise deployments, drive up utilization of their data center assets, and run Oracle and other enterprise applications faster all within a secure, scalable cloud or traditional enterprise environment.”
Oracle Solaris Zones virtualization scales up to hundreds of zones per physical node at a 15x lower overhead than VMware and without artificial limits on memory, network, CPU and storage resources. New, integrated network virtualization allows customers to create high-performance, low-cost data center topologies within a single OS instance for ultimate flexibility, bandwidth control and observability.
Oracle Solaris 11 runs business-critical enterprise applications in virtualized massive horizontal scale as well as vertically integrated environments on a wide range of SPARC and x86 servers. Customers can run any of the more than 11,000 applications supported today on Oracle Solaris 11, with guaranteed binary compatibility through the Oracle Solaris Binary Application Guarantee Program. Customers can also preserve their existing investments by using P2V and V2V tools to move their existing Oracle Solaris 10 environments to an Oracle Solaris 10 Zone, while gaining access to the latest Oracle Solaris 11 enhancements.
“With Oracle Solaris, we have a unique opportunity to support the industry’s largest and leading business software portfolio on the industry’s best UNIX for both SPARC and x86 servers,” said Thomas Kurian, executive vice president of Oracle Product Development. “Working together, our development teams engineer, test and support advanced solutions to our customers’ toughest problems. We are pleased to announce that our key software products–Oracle Database 11g, Oracle Fusion Middleware, Oracle Enterprise Manager, and Oracle Applications–are available and optimized for Oracle Solaris 11 on SPARC and x86 systems.”
Oracle Enterprise Manager Ops Center, now included in systems support, provides converged systems management, enabling enterprise wide, centralized control over hardware, OS and virtualization resources.
Oracle Solaris 11, Oracle Enterprise Manager Ops Center and Oracle VM software are included as part of systems support with all of Oracle’s Sun servers, providing customers with built-in cloud capabilities.
Partners in Oracle Partner Network (OPN) will find new Oracle Solaris 11 tools and resources in the Oracle Solaris Knowledge Zone including the Oracle Solaris Remote Lab and the Oracle Solaris Development Initiative. New Oracle Solaris 11 Training is also available to help customers and partners take advantage of the best-in-class features of Oracle Solaris 11 and upgrade from Oracle Solaris 10 or earlier versions.
Oracle Exadata WebCast
- Why Consolidate on Exadata?
- Steps to Successful Consolidation
- Findings from Our Internal Case Study
- Key Takeaways
Oracle Exadata WebCast to download pdf file for more information to this WebCast
Oracle related blog closure is that of Joerg Moellenkamp who has closed his Solaris oriented c0t0d0s0.org blog, which was home to the “Lesser Known Solaris Features” (LKSF) tutorial. Moellenkamp, an Oracle employee, says the offlining of the blog is not because of health issues, that there were no technical problems and no copyright issues, but beyond that he will not say why he has taken the decision. The LKSF tutorial has been saved from the shutdown and is available to download. The closure of the c0t0d0s0 blog does though reduce the already meagre number of Solaris blogs further.
It is worth noting that Oracle, as a company, has never been comfortable with employee blogging. Oracle appears to regard blogs as mostly a function of its public relations department and it is said that the complexity of working with the PR department to approve postings is sufficient that many either give up or don’t try.
Oracle has made an interview with Rick Hetherington, Oracle vice president of hardware development available. There is quite a bit of information about the future and development of the SPARC processor, well worth a read.
“Going forward, the SPARC T4 is less than 12 months away. So that’s pretty quick. And there’s a reason behind that. We wanted to get more single thread performance into the SPARC T-series systems sooner rather than later. So we developed a new core for the SPARC T4 that brings together the combination of throughput performance through threading as well as really high-speed single thread performance. It’s really breakthrough technology for us. Referring back to the timeline for development that we have, we developed that core and that technology back in 2006/2007 and we’ll be delivering that to the market in 2011.
And then the SPARC T5 will have 16 cores as opposed to the eight cores that we have in the SPARC T4, in 28 nanometer technology. As we go forward with each of these new introductions we’ll make sure that the interfaces that deal with memory are common and are contemporary with the sweet spot of memory technology.”
Read the whole article . here
Install & configure Xvncserver on Solaris10 OS
You will find SFWvnc package from Solaris10 companion-i386-sol10 CD You can download it from
http://www.realvnc.com/ or install it with command
bash-3.00# pkgadd -d . SFWvnc
and after install vncserver on Solaris you will have service FMRI for it
svcs -a | grep -i x11
and edit 2 files
1 – vi /etc/services or
echo > vnc-server 5900/tcp #Xvnc Server Added by Hosam
2 – vi /etc/X11/gdm/gdm.conf
Enable = true
DisallowTCP = false
AllowRoot = true
AllowRemoteRoot = true
and just run the service from FMRI
svcadm enable svc:/application/x11/xvnc-inetd:default
and try to run vncview from any platform to connect to Solaris BOX ;)
In my previous articles in this series, I introduced the benefits of journaling and the ReiserFS and showed how to set up a rock-solid ReiserFS system. In this article, we’re going to tackle a couple of semi-offbeat topics. First, we’ll take a look at tmpfs, also known as the virtual memory (VM) filesystem. Tmpfs is probably the best RAM disk-like system available for Linux right now, and was introduced with Linux kernel 2.4. Then, we’ll take a look at another capability introduced with Linux kernel 2.4 called “bind mounts”, which allow a great deal of flexibility when it comes to mounting (and remounting) filesystems.
If I had to explain tmpfs in one breath, I’d say that tmpfs is like a ramdisk, but different. Like a ramdisk, tmpfs can use your RAM, but it can also use your swap devices for storage. And while a traditional ramdisk is a block device and requires a mkfs command of some kind before you can actually use it, tmpfs is a filesystem, not a block device; you just mount it, and it’s there. All in all, this makes tmpfs the niftiest RAM-based filesystem I’ve had the opportunity to meet.
Tmpfs and VM
Let’s take a look at some of tmpfs’s more interesting properties. As I mentioned above, tmpfs can use both RAM and swap. This might seem a bit arbitrary at first, but remember that tmpfs is also known as the “virtual memory filesystem”. And, as you probably know, the Linux kernel’s virtual memory resources come from both your RAM and swap devices. The VM subsystem in the kernel allocates these resources to other parts of the system and takes care of managing these resources behind-the-scenes, often transparently moving RAM pages to swap and vice-versa.
The tmpfs filesystem requests pages from the VM subsystem to store files. tmpfs itself doesn’t know whether these pages are on swap or in RAM; it’s the VM subsystem’s job to make those kinds of decisions. All the tmpfs filesystem knows is that it is using some form of virtual memory.
Not a Block Device
Here’s another interesting property of the tmpfs filesystem. Unlike most “normal” filesystems, like ext3, ext2, XFS, JFS, ReiserFS and friends, tmpfs does not exist on top of an underlying block device. Because tmpfs sits on top of VM directly, you can create a tmpfs filesystem with a simple mount command:
# mount tmpfs /mnt/tmpfs -t tmpfs
After executing this command, you’ll have a new tmpfs filesystem mounted at /mnt/tmpfs, ready for use. Note that there’s no need to run mkfs.tmpfs; in fact, it’s impossible, as no such command exists. Immediately after the mount command, the filesystem is mounted and available for use, and is of type tmpfs. This is very different from how Linux ramdisks are used; standard Linux ramdisks are block devices, so they must be formatted with a filesystem of your choice before you can use them. In contrast, tmpfs is a filesystem. So, you can just mount it and go.
Dynamic Filesystem Size
You’re probably wondering about how big that tmpfs filesystem was that we mounted at /mnt/tmpfs, above. The answer to that question is a bit unexpected, especially when compared to disk-based filesystems. /mnt/tmpfs will initially have a very small capacity, but as files are copied and created, the tmpfs filesystem driver will allocate more VM and will dynamically increase the filesystem capacity as needed. And, as files are removed from /mnt/tmpfs, the tmpfs filesystem driver will dynamically shrink the size of the filesystem and free VM resources, and by doing so return VM into circulation so that it can be used by other parts of the system as needed. Since VM is a precious resource, you don’t want anything hogging more VM than it actually needs, and the great thing about tmpfs is that this all happens automatically.
The other major benefit of tmpfs is its blazing speed. Because a typical tmpfs filesystem will reside completely in RAM, reads and writes can be almost instantaneous. Even if some swap is used, performance is still excellent and those parts of the tmpfs filesystem will be moved to RAM as more free VM resources become available. Having the VM subsystem automatically move parts of the tmpfs filesystem to swap can actually be good for performance, since by doing so, the VM subsystem can free up RAM for processes that need it. This, along with its dynamic resizing abilities, allow for much better overall OS performance and flexibility than the alternative of using a traditional RAM disk.
While this may not seem like a positive, tmpfs data is not preserved between reboots, because virtual memory is volatile in nature. I guess you probably figured that tmpfs was called “tmpfs” for a reason, didn’t you? However, this can actually be a good thing. It makes tmpfs an excellent filesystem for holding data that you don’t need to keep, such as temporary files (those found in /tmp) and parts of the /var filesystem tree.
To use tmpfs, all you need is a modern (2.4+) kernel with Virtual memory file system support (former shm fs) enabled; this option lives under the File systems section of the kernel configuration options. Once you have a tmpfs-enabled kernel, you can go ahead and mount tmpfs filesystems. In fact, it’s a good idea to enable tmpfs in all your kernels if you compile them yourself – whether you plan to use tmpfs or not. This is because you need to have kernel tmpfs support in order to use POSIX shared memory. System V shared memory will work without tmpfs in your kernel, however. Note that you do not need a tmpfs filesystem to be mounted for POSIX shared memory to work; you simply need the support in your kernel. POSIX shared memory isn’t used too much right now, but this situation will likely change as time goes on.
Avoiding low VM conditions
The fact that tmpfs dynamically grows and shrinks as needed makes one wonder: what happens when your tmpfs filesystem grows to the point where it exhausts all of your virtual memory, and you have no RAM or swap left? Well, generally, this kind of situation is a bit ugly. With kernel 2.4.4, the kernel would immediately lock up. With more recent kernels, the VM subsystem has in many ways been fixed, and while exhausting VM isn’t exactly a wonderful experience, things don’t blow up completely, either. When a modern kernel gets to the point where it can’t allocate any more VM, you obviously won’t be unable to write any new data to your tmpfs filesystem. In addition, it’s likely that some other things will happen. First, the other processes on the system will be unable to allocate much more memory; generally, this means that the system will most likely become extremely sluggish and almost unresponsive. Thus, it may be tricky or unusually time-consuming for the superuser to take the necessary steps to alleviate this low-VM condition.
In addition, the kernel has a built-in last-ditch system for freeing memory when no more is available; it’ll find a process that’s hogging VM resources and kill it. Unfortunately, this “kill a process” solution generally backfires when tmpfs growth is to blame for VM exhaustion. Here’s the reason. Tmpfs itself can’t (and shouldn’t) be killed, since it is part of the kernel and not a user process, and there’s no easy way for the kernel to find out which process is filling up the tmpfs filesystem. So, the kernel mistakenly attacks the biggest VM-hog of a process it can find, which is generally your X server if you happen to be running one. So, your X server dies, and the root cause of the low-VM condition (tmpfs) isn’t addressed. Ick.
Low VM: the solution
Fortunately, tmpfs allows you to specify a maximum upper bound for the filesystem size when a filesystem is mounted or remounted. Actually, as of kernel 2.4.6 and util-linux-2.11g, these parameters can only be set on mount, not on remount, but we can expect them to be settable on remount sometime in the near future. The optimal maximum tmpfs size setting depends on the resources and usage pattern of your particular Linux box; the idea is to prevent a completely full tmpfs filesystem from exhausting all virtual memory and thus causing the ugly low-VM conditions that we talked about earlier. A good way to find a good tmpfs upper-bound is to use top to monitor your system’s swap usage during peak usage periods. Then, make sure that you specify a tmpfs upper-bound that’s slightly less than the sum of all free swap and free RAM during these peak usage times.
Creating a tmpfs filesystem with a maximum size is easy. To create a new tmpfs filesystem with a maximum filesystem size of 32 MB, type:
# mount tmpfs /dev/shm -t tmpfs -o size=32m
This time, instead of mounting our new tmpfs filesystem at /mnt/tmpfs, we created it at /dev/shm, which is a directory that happens to be the “official” mount point for a tmpfs filesystem. If you happen to be using devfs, you’ll find that this directory has already been created for you.
Also, if we want to limit the filesystem size to 512 KB or 1 GB, we can specify size=512k and size=1g, respectively. In addition to limiting size, we can also limit the number of inodes (filesystem objects) by specifying the nr_inodes=x parameter. When using nr_inodes, x can be a simple integer, and can also be followed with a k, m, or g to specify thousands, millions, or billions (!) of inodes.
Also, if you’d like to add the equivalent of the above mount tmpfs command to your /etc/fstab, it’d look like this:
tmpfs /dev/shm tmpfs size=32m 0 0
Mounting On Top of Existing Mount Points
Back in the 2.2 days, any attempt to mount something to a mount point where something had already been mounted resulted in an error. However, thanks to a rewrite of the kernel mounting code, using mount points multiple times is not a problem. Here’s an example scenario: let’s say that we have an existing filesystem mounted at /tmp. However, we decide that we’d like to start using tmpfs for /tmp storage. In the old days, your only option would be to unmount /tmp and remount your new tmpfs /tmp filesystem in its place, as follows:
# umount /tmp # mount tmpfs /tmp -t tmpfs -o size=64m
However, this solution may not work for you. Maybe there are a number of running processes that have open files in /tmp; if so, when trying to unmount /tmp, you’d get the following error:
umount: /tmp: device is busy
However, with Linux 2.4+, you can mount your new /tmp filesystem without getting the “device is busy” error:
# mount tmpfs /tmp -t tmpfs -o size=64m
With a single command, your new tmpfs /tmp filesystem is mounted at /tmp, on top of the already-mounted partition, which can no longer be directly accessed. However, while you can’t get to the original /tmp, any processes that still have open files on this original filesystem can continue to access them. And, if you umount your tmpfs-based /tmp, your original mounted /tmp filesystem will reappear. In fact, you can mount any number of filesystems to the same mount point, and the mount point will act like a stack; unmount the current filesystem, and the last-most-recently mounted filesystem will reappear from underneath.
Using bind mounts, we can mount all, or even part of an already-mounted filesystem to another location, and have the filesystem accessible from both mount points at the same time! For example, you can use bind mounts to mount your existing root filesystem to /home/drobbins/nifty, as follows:
# mount --bind / /home/drobbins/nifty
Now, if you look inside /home/drobbins/nifty, you’ll see your root filesystem (/home/drobbins/nifty/etc, /home/drobbins/nifty/opt, etc.). And if you modify a file on your root filesystem, you’ll see the modifications in /home/drobbins/nifty as well. This is because they are one and the same filesystem; the kernel is simply mapping the filesystem to two different mount points for us. Note that when you mount a filesystem somewhere else, any filesystems that were mounted to mount points inside the bind-mounted filesystem will not be moved along. In other words, if you have /usr on a separate filesystem, the bind mount we performed above will leave /home/drobbins/nifty/usr empty. You’ll need an additional bind mount command to allow you to browse the contents of /usr at /home/drobbins/nifty/usr:
# mount --bind /usr /home/drobbins/nifty/usr
Bind mounting parts of filesystems
Bind mounting makes even more neat things possible. Let’s say that you have a tmpfs filesystem mounted at /dev/shm, its traditional location, and you decide that you’d like to start using tmpfs for /tmp, which currently lives on your root filesystem. Rather than mounting a new tmpfs filesystem to /tmp (which is possible), you may decide that you’d like the new /tmp to share the currently mounted /dev/shm filesystem. However, while you could bind mount /dev/shm to /tmp and be done with it, your /dev/shm contains some directories that you don’t want to appear in /tmp. So, what do you do? How about this:
# mkdir /dev/shm/tmp # chmod 1777 /dev/shm/tmp # mount --bind /dev/shm/tmp /tmp
In this example, we first create a /dev/shm/tmp directory and then give it 1777 perms, the proper permissions for /tmp. Now that our directory is ready, we can mount /dev/shm/tmp, and only /dev/shm/tmp to /tmp. So, while /tmp/foo would map to /dev/shm/tmp/foo, there’s no way for you to access the /dev/shm/bar file from /tmp.
As you can see, bind mounts are extremely powerful and make it easy to make modifications to your filesystem layout without any fuss. Next article, we’ll check out devfs; for now, you may want to check out the following resources.
The Veritas filesystem and volume manager have their roots in a fault-tolerant proprietary minicomputer built by Veritas in the 1980s. They have been available for Solaris since at least 1993 and have been ported to AIX and Linux. They are integrated into HP-UX and SCO UNIX, and Veritas Volume Manager code has been used (and extensively modified) in Tru64 UNIX and even in Windows. Over the years, Veritas has made a lot of money licensing their tech, and not because it is cheap, but because it works.
VxFS has never been part of Solaris but, when UFS was the only option, it was a popular addition. VxVM and VxFS are tightly integrated. Through vxassist, one may shrink and grow filesystems and their underlying volumes with minimal trouble. VxVM provides online RAID relayout. If you have a RAID5 and want to turn it into a RAID10, no problem, no downtime. If you need more space, just convert it back to a RAID5. VxVM has a reputation for being cryptic, and to some extent it is, but it’s not so bad and the flexibility is impressive.
VxFS is a fast, extent based, journaled, clusterable filesystem. In fact, it essentially introduced these features to the world, along with direct IO. Newer versions of VxFS and VxVM have the ability to do cross-platform disk sharing. If you ever wanted to unmount a volume from your AIX box and mount it on Linux or Solaris, now you can.
VxFS and VxVM are still closed source. A version is available from Symantec that is free on small servers, with limitations, but I imagine that most users still pay. Pricing starts around $2500 and can be shocking for larger machines. VxFS and VxVM are solid choices for critical infrastructure workloads, including databases.