B L O G G E R

Installation Process of 2 Open Source OS

2009-09-17T02:42:00.000-07:00

Linux OS (GENTOO)

Gentoo Linux

1. Introduction

This guide is based on an example with two IDE hard disks. It means that you will more than likely need to change the drive, partition names and partition sizes to match your own setup and needs.

Warning: This document is not intended to be an LVM2 tutorial. It serves as a supplement to the Gentoo installation procedure as described in the Handbook, Part 1. Make sure you read the Gentoo Installation Manual before you start your installation process.

Note: For a complete LVM HOWTO point your browser to http://tldp.org/HOWTO/LVM-HOWTO

Initial requirements

If you do a fresh install of Gentoo, you will need to use a bootable CD with LVM2 support such as a Gentoo Installation CD. You can find the Installation CDs for an x86 architecture on our mirrors under /releases/x86/current/installcd. Other architectures might be supported as well.

If you install LVM2 on a currently running system with some spare hard disk space, you will need to enable the LVM2 module (dm-mod). This module is available in gentoo-sources. Compiling your kernel and getting LVM2 to work is covered later in this guide.

Not all 2.4 kernels provided by Gentoo support LVM2!

Partitions

Our example system has two IDE hard disks and will be partitioned as follows:

/dev/hda1 -- /boot

/dev/hda2 -- (swap)

/dev/hda3 -- /

/dev/hda4 -- Will be used by LVM2

/dev/hdb1 -- Will be used by LVM2

Important: Pay attention to the partition names as it is easy to confuse the a's and b's, and the partition numbers. One false move could wipe out the wrong partition. You have been warned!

OK, time to start...

2. Installation

Follow the handbook, but with the following amendments to chapter 4. Preparing the Disks:

Use fdisk as described in the handbook, but use the partition scheme mentioned above as an example. It is only an example, adapt it to your own needs.

Create a small physical /boot partition (hda1). In this example, /boot will be not managed by LVM2. This partition will contain your bootloader and your kernel(s). A 64MB partition should be well enough for quite a few kernel generations.

Create a swap partition (hda2).

Create a / (root) partition (hda3). If you are interested in trying to put your root partition under LVM management (which we do not recommend), see the resources section at the end of this guide for a link to a mini-howto on how to do this. The size of the root partition need not be large if you will keep /opt /usr /home /var and /tmp in an LVM2 Volume Group (vg). In this case, 1GB should be sufficient.

Note: It is not recommended to put the following directories in an LVM2 partition: /etc, /lib, /mnt, /proc, /sbin, /dev, and /root. This way, you would still be able to log into your system (crippled, but still somewhat usable, as root) if something goes terribly wrong.

Assuming the /boot, swap and root partitions do not use the whole physical disk, create a fourth partition on this disk and set it to type 8e (Linux LVM). If you have more physical drives you would like to use with LVM, create one partition on each and give them the same type (8e).

Note: Considering the huge size of current disks, you might consider splitting your hard disks into smaller partitions instead of creating a big partition that will be added to an LVM2 volume group in one block. LVM2 makes it easy to extend your volumes after all. This leaves you some unallocated partitions you might need to use outside of an LVM2 group. In short, don't use your disk space until you know you need it. As an example, one contributor had split his 160 Gb hard disk into 8 partitions of 20 Gb each.

Create the filesystems on /dev/hda1 and /dev/hda3, and create and activate the swap on /dev/hda2 as described in the handbook.

Load the LVM2 dm-mod module.

Code Listing 2.1: Loading the LVM2 module

# modprobe dm-mod

Before scanning and activating LVM, you might want to edit /etc/lvm/lvm.conf to exclude some devices. By default, LVM2 will scan all devices, even your CDROM which can generate error messages. In the following example, the line that allows scanning of all devices is replaced by one that rejects every device but our two IDE disks.

Code Listing 2.2: Activating LVM

(Avoid scanning all devices but our disks)
# nano -w /etc/lvm/lvm.conf
(Look for the following line)
   filter = [ "a/.*/" ]
(Replace it with the following one to scan
/dev/hda and /dev/hdb and reject anything else)
   filter = [ "a/dev/hd[ab]", "r/.*/" ]
(Save the file and quit nano)
# vgscan
 Reading all physical volumes.  This may take a while...
 No volume groups found
(Make any previously set up volume groups available)
# vgchange -a y

Prepare the partitions.

Code Listing 2.3: Preparing the partitions

# pvcreate /dev/hda4 /dev/hdb1
 No physical volume label read from /dev/hda4
 Physical volume "/dev/hda4" successfully created
 No physical volume label read from /dev/hdb1
 Physical volume "/dev/hdb1" successfully created

Setup a volume group. A volume group is the result of combining several physical units into a single logical device.

In our example, /dev/hda1, /dev/hda2 and /dev/hda3 are the /boot, swap and root partitions so we need to combine /dev/hda4 and /dev/hdb1. It can be done with a single command, but, as an example, we will create our volume group and extend it.

Code Listing 2.4: Creating and extending a volume group

(Create a volume group named vg)
# vgcreate vg /dev/hda4
/etc/lvm/backup: fsync failed: Invalid argument (Ignore this warning)
Volume group "vg" successfully created
(Extending an existing volume group)
# vgextend vg /dev/hdb1
/etc/lvm/backup: fsync failed: Invalid argument (Ignore this warning,

again and later as well) Volume group "vg" successfully extended

Create the logical volumes. Logical volumes are the equivalent of partitions you would create using fdisk in a non LVM2 environment. In our example, we create the following partitions:

Directory	Size
/usr	10 GB
/home	5 GB
/opt	5 GB
/var	10 GB
/tmp	2 GB

Since we are going to use LVM2, we should not worry too much about partition sizes because they can always be expanded as needed.

Note: As Terje Kvernes commented, it is easier to increase the size of a partition then to shrink it. You might therefore want to start with smaller partitions and increase their size as needed.

Code Listing 2.5: Creating and extending logical volumes

# lvcreate -L10G -nusr  vg
 Logical volume "usr" created (Further similar messages not displayed)
# lvcreate -L5G  -nhome vg
# lvcreate -L5G  -nopt  vg
# lvcreate -L10G -nvar  vg
# lvcreate -L2G  -ntmp  vg
(As an example, let's extend a logical volume with 5 extra Gbytes)
# lvextend -L+5G /dev/vg/home

Create filesystems on the logical volumes the same way you would on a regular partition. We use ext3 on the logical volumes but any filesystem of your choice will work:

Code Listing 2.6: Creating the filesystems

# mke2fs -j /dev/vg/usr
# mke2fs -j /dev/vg/home
# mke2fs -j /dev/vg/opt
# mke2fs -j /dev/vg/var
# mke2fs -j /dev/vg/tmp

Mount your partitions as described in the handbook and mount your LVM2 logical volumes as if they were partitions. Replace the usual /dev/hdxx with /dev/vg/logical_volumename.

Code Listing 2.7: Mounting your logical volumes

(Make sure you have mounted your root partition as described in the

handbook first)
# mkdir /mnt/gentoo/usr
# mount /dev/vg/usr /mnt/gentoo/usr
# mkdir /mnt/gentoo/home
# mount /dev/vg/home /mnt/gentoo/home
# mkdir /mnt/gentoo/opt
# mount /dev/vg/opt /mnt/gentoo/opt
# mkdir /mnt/gentoo/var
# mount /dev/vg/var /mnt/gentoo/var
# mkdir /mnt/gentoo/tmp
# mount /dev/vg/tmp /mnt/gentoo/tmp

Note: The rest of the installation handbook is mostly unchanged so we shall not walk you through it again except to point out differences.

When configuring your kernel, make sure to configure your kernel to support LVM2 (not all 2.4 kernels do). Select the LVM2 module as follows:

Code Listing 2.8: Selecting the LVM2 module in a 2.4.x kernel

Multi-device support (RAID and LVM)  --->
 [*] Multiple devices driver support (RAID and LVM)
 < >  RAID support
(Note that LVM is not selected on purpose, this was for LVM1)
 < >  Logical volume manager (LVM) support
   Device-mapper support
 < >   Mirror (RAID-1) support

Code Listing 2.9: Selecting the LVM2 module in a 2.6.x kernel

Device Drivers  --->
Multi-device support (RAID and LVM)  --->
  [*] Multiple devices driver support (RAID and LVM)
  < >   RAID support
     Device mapper support

The compiled module is called dm-mod.ko

After you have built your kernel and installed its modules, add the following line to your /etc/modules.autoload.d/kernel-{KV} where {KV} represents your kernel version (2.4 or 2.6) so that the LVM2 module gets loaded when your machine is booted:

Code Listing 2.10: Adding the LVM2 module into /etc/modules.autoload.d/kernel-2.6

# nano -w /etc/modules.autoload.d/kernel-2.6
(Add the following line)
dm-mod

Now, install the lvm2 package.

Important: Make sure your /usr/src/linux link points to the kernel sources you are using because the lvm2 ebuild depends on the device-mapper ebuild which will check the presence of a required source file under /usr/src/linux/include/linux.

Code Listing 2.11: Emerging the LVM2 package

# emerge lvm2

Edit /etc/lvm/lvm.conf as described earlier. The file you previously edited is part of your installation environment and will disappear after the next reboot. This time, you edit the real one inside your new Gentoo install.

When editing your /etc/fstab file, follow the handbook and add your LVM2 logical volumes as needed. Again, here are a few lines needed for our example:

Code Listing 2.12: Extract of /etc/fstab

/dev/hda1     /boot   ext3    noauto,noatime 1 2
/dev/hda2     none    swap    sw             0 0
/dev/hda3     /       ext3    noatime        0 1
# Logical volumes
/dev/vg/usr   /usr    ext3    noatime        0 2
/dev/vg/home  /home   ext3    noatime        0 2
/dev/vg/opt   /opt    ext3    noatime        0 2
/dev/vg/var   /var    ext3    noatime        0 2
/dev/vg/tmp   /tmp    ext3    noatime        0 2

When you reach the end of the installation part of the handbook, don't forget to umount all your LVM2 logical volumes as well and for a good measure run the following command before you reboot:

Code Listing 2.13: Shutting down LVM2

# vgchange -a n

Restart your machine and all partitions should be visible and mounted.

3. Continuing After a Reboot

If you have interrupted the Gentoo installation at one point and want to continue, you need to create the volume device nodes first:

Code Listing 3.1: Reactivating the volumes

# vgscan --mknodes

Installation CDs with less recent tools might need to reactivate the volumes instead:

Code Listing 3.2: Reactivating the volumes

(Deactivate all volumes first)
# vgchange -a n
(Export all the volumes)
# vgexport -a vg
(Import all volumes)
# vgimport -a vg
(Reactivate all volumes)
# vgchange -a y

4. Resources

The official LVM2 home page

The LVM Howto

Daniel Robbins's articles on LVM for IBM's DeveloperWorks: Part 1 and Part 2

How to boot your root FS off of LVM1: http://www.the-infinite.org/archive/docs/lvm/howto-boot-off-root-lv.txt

5. Acknowledgements

Thanks Thilo Bangert and Terje Kvernes for their help and comments on this document.

<<---------------------------->>

Linux OS (UBUNTU)

Ubuntu Linux

GET UBUNTU

To get Ubuntu, click on the following link:
http://www.ubuntu.com/getubuntu/download

For this installation I recommend you simply choose the Desktop Edition of Ubuntu.

Start now by selecting the closest location to you in the dropdown.
Scroll down and ensure 32bit version is selected.
Select Begin Download.
Once finished, locate the downloaded file; it will be named something similar to
ubuntu-9.04-desktop-i386.iso

To create a bootable disk from the .iso, you may wish to use the useful tool named Burn. Go to the following link to get this tool, or simply choose a burner of your preference:
http://burn-osx.sourceforge.net/Pages/English/home.html

No, you do NOT have to use this tool, but it has several advantages and I include it in the process simply as an example of the ISO burning process. The nice thing about Burn is that you simply download, install, and open. PLUS, often the biggest issue with an install is an improperly burned ISO, and this tool helped me get quick and correct burns each time.

In Burn, go to the copy tab as shown below:

Now just Drag the .iso file you downloaded to where it says, "Drop discs and images here."

Insert a blank cd.
Select Burn.
Ensure Maximum possible is selected.
Select Burn.
Once complete, this is the Ubuntu Linux boot disk you will need for the next steps.

DOWNLOAD VIRTUALBOX
Virtual box is a fantastic and enterprise capable virtualizer for Mac hardware. For those not familiar with virtualizers, this tool allows you to install Ubuntu in a shared manner with another Operating System such as MacOS or Windows.

You may wish to find out more about this SUN Microsystem's tool, as it is very useful for many virtualizing scenerios. Best of all, it is one of the only virtualization tools that is also Open Source Software.

To get VirtualBox simply go to this link:
http://www.virtualbox.org/wiki/Downloads

Under VirtualBox Binaries, where it says VirtualBox 3.0.0 for OS X hosts, select "Intel Macs"
Open the VirtualBox disk image and run the installer

ADVANCED TIP: If you're a more advanced user, it's important to let you know that rather than burning the ISO to CDROM, then using the CD to install into Virtualbox, the CDROM drive in virtual box can be configured to point at the ISO file, eliminating the need to burn a disk.

START THE INSTALLATION

When you're ready, open VirtualBox from the Applications folder on your Mac.

Begin the following series of steps:

Register (optional)
Select the "New" icon in the toolbar.

A new window will open.

Select Next.
Enter a Name for the virtual machine e.g. Ubuntu Linux.
Change Operating System to Linux.
Change Version to Ubuntu.

Obviously you can apply this method to other Linux flavours if you wish.

Select Next.
Select amount of RAM to be used on the virtual machine.
(384 recommended, I recommend 512 if you have 1GB RAM on your Mac).

Select Next.
Ensure Boot Hard Disk (Primary Master) is selected.
Select "Create new hard disk."

Now you need to again Select Next and once more Select Next.

Choose "Dynamically expanding storage" ("Fixed-size storage" creates a fixed hard drive for Ubuntu, but "Dynamically expanding storage" only uses as much hard drive space as it needs to install and will thereafter expand as needed).
Select Next.

The Name you chose for the Virtual Machine earlier should now show under Location; if not then enter the same name as before under Location e.g. Ubuntu Linux, and select the amount of maximum space that the hard drive can use.

TIP: This will automatically be something like 8 GB but you can change it depending on your requirements. Or just leave it as it is and move on.

Select Next.
Now Select Finish.
Finally Select Finish once more.

You should now see something similar to this:

When you're ready, please press the "Start" icon at the top.

Now start this process:
Select OK.
Select Next.
Ensure CD/DVD-ROM Device and Host Drive are selected (should be the default).
Select Next.
Insert previously created Ubuntu Linux bootable disk.
Select Finish.

At this point the disk will start booting.

Select English or your preferred language.

If a screen appears regarding the mouse or keyboard, take note of the host key; something like the Left Command key (also shown at the bottom right of the VirtualBox window). This is important so please don't forget what it indicates.
Now select the checkbox "Don't show this message again" and select Capture (This will make the mouse change automatically when you select the virtual system.)

Select Install Ubuntu.

At this point you should get the following loading screen, which is Ubuntu starting:

INITIAL UBUNTU SETUP
Once finished loading (this may take a few minutes), ensure your language is selected once again on the left panel and select Forward.

Select your Time Zone on the map or by your region and city.
Select Forward.
Choose keyboard layout depending on the type of keyboard you have (to test, simply type digits into the typing box, ensuring that it enters the correct digits as on your keyboard).
Select Forward.
Choose "Use the entire disk."
Select Forward.
Fill in your name, account username, password (minimum eight digits recommended), and computer name for network visibility.
Choose whether to log in automatically or require a password to log in.
(I recommend that you do require a password, just take note of what you choose).
Select Forward.
Now, please Select Install.

It should show the following installing system box with a status on the installation.

Be patient, as this is nearly the final step, but unfortunately takes time. It can take anywhere from 10 minutes to an hour to install, depending on your system. Look at it this way, now is a perfect time to grab a tasty snack, sit back and enjoy an episode of your favourite TV show.

You can check on the status of the installation, as shown below:

When completed, please Select Restart Now (you should not restart the Mac itself, the VirtualBox will merely restart Ubuntu for you within the program).

It will say on the Ubuntu restart "Please remove the disc, close the tray (if any) and press ENTER to continue"; when this happens, the eject button in OS X will not work therefore in the VirtualBox window, select Devices (on the top toolbar in OS X).

Select Unmount CD/DVD-ROM and press ENTER.
Now you will be able to eject the disk from the computer.

Enter your Username and Password (the one you should have noted earlier!).

TIP: If you need more details with regard to Users and user privileges in Ubuntu, you may wish to review this article: http://www.reallylinux.com/docs/usersubuntu.shtml

Ubuntu will open and the Update Manager should automatically open (if not, it can be found in System/Administration).
Select Install Updates (this may take a while depending on your internet speed).

OUTSTANDING!You should now have a virtual machine Ubuntu running inside OS X.

(Optional to increase graphics performance)
Whilst in Ubuntu,
Select Devices at the top of the screen again
Select Install Guest Additions
This will open on your Ubuntu desktop as something similar to VBOXADDITIONS_3.0.0_49315
Double click it to open
Double click autorun.sh
Select Run
Enter your password
It will open a terminal window and may take a couple of minutes to complete
Once finished, it will say, "Successfully installed the VirtualBox Guest Additions."
Press ENTER
Restart Ubuntu
Go to System/Preferences/Display to customize the screen size.

CONGRATUALTIONS and I give you a hearty welcome to Linux!
For further help with Linux, look over the list of the other articles here on the reallylinux.com website, as there are plenty more beginner articles to get you started.

TROUBLESHOOTING

The process is fairly straightforward, but in case you encounter an issue, I try to provide some tips for the more common anomalies.

If you get this message,

Select "Do not show this message again" and select OK

To change the mouse back and forth simply click the Linux window to use Linux. To change back to Mac OS X, press the host key once (as indicated at the bottom right of the Linux window)

If you get a black screen on the Linux window, simply double click to restore session.

Note: to close VirtualBox, in the open Ubuntu window, select your name on the menubar and select shutdown; when it says Aborted or Powered Off under your Ubuntu Linux boot in the VirtualBox program, it is safe to close VirtualBox. To run in the future, simply open VirtualBox, select your operating system e.g. Ubuntu Linux and select Start

or

If the installation fails for some reason or another, select the operating system name, while in VirtualBox, and then select Discard. Unfortunately, if a complete fail occurs, you will need to restart the installation process. Make sure your ISO burn is correct.

You may also wish to review the article Exploring Linux with Ubuntu.

Installation Process of 2 Windows OS

2009-09-17T02:32:00.002-07:00

Windows 2000

Windows 2000

The text-based portion of the Setup program
The setup process begins loading a blue-looking text screen (not GUI). In that phase you will be asked to accept the EULA and choose a partition on which to install W2K, and if that partition is new, you'll be asked to format it by using either FAT, FAT32 or NTFS.
Start the computer from the CD.
You can press F6 if you need to install additional SCSI adapters or other mass-storage devices. If you do you will be asked to supply a floppy disk with the drivers and you CANNOT browse it (or a CD for that matter). Make sure you have one handy.

Setup will load all the needed files and drivers.
Select To Setup W2K Now. If you want, and if you have a previous installation of the OS, you can try to fix it by pressing R. If not, just press ENTER.

In case your server is a new one, or it is using a new hard disk that hasn't been partitioned yet, you'll get a warning message. Read it, and if you want to continue, press C.

Read and accept the licensing agreement and press F8 if you accept it.

Select or create the partition on which you will install W2K. Depending upon your existing disk configuration choose one of the following:
If the hard disk is not yet partitioned, you can create and size the partition on which you will install Windows 2000. Press C.

If the hard disk is new and you want to create a partition that will span the entire hard disk's size - press Enter.
Other optionsL
If the hard disk is already partitioned, but has enough unpartitioned disk space, you can create an additional partition in the unpartitioned space.
If the hard disk already has a partition that is large enough, you can install Windows 2000 on that partition. If the partition has an existing operating system, you will overwrite that operating system if you accept the default installation path. However, files other than the operating system files, such as program files and data files, will not be overwritten.
If the hard disk has an existing partition, you can delete it to create more unpartitioned space for the new partition. Deleting an existing partition erases all data on that partition.
If you select a new partition during Setup, create and size only the partition on which you will install Windows 2000. After installation, use Disk Management to partition the remaining space on the hard disk.
Select a file system for the installation partition. After you create the partition on which you will install W2K, you can use Setup to select the file system with which to format the partition. W2K supports the NTFS file system in addition to the file allocation table (FAT) and FAT32 file systems. Windows Server 2003, Windows XP Professional, Windows 2000, and Windows NT are the only Microsoft operating systems that you can use to gain access to data on a local hard disk that is formatted with NTFS. If you plan to gain access to files that are on a local W2K partition with the Microsoft Windows 95 or Windows 98 operating systems, you should format the partition with a FAT or FAT32 file system. We will use NTFS.

Setup will then begin copying necessary files from the installation point (CD, local I386 or network share).
Note: If you began the installation process from an MS-DOS floppy, make sure you have and run SMARTDRV from the floppy, otherwise the copying process will probably last more than an hour, perhaps even more. With SMARTDRV (or if setup was run by booting from CD) the copying will probably last a few minutes, no more than 5 max.

The computer will restart in graphical mode, and the installation will continue.

The GUI-based portion of the Setup program
The setup process reboots and loads a GUI mode phase.
It will then begin to load device drivers based upon what it finds on your computer. You don't need to do anything at this stage.

If your computer stops responding during this phase (the progress bar is stuck almost half-way, and there is no disk activity) - shut down your computer and begin removing hardware such as PCI and ISA cards. If it works for you then later try to figure out how to make that specific piece of hardware work (it's probably not in the HCL).
Click Customize to change regional settings, if necessary.
Current System Locale - Affects how programs display dates, times, currency, and numbers. Choose the locale that matches your location, for example, French (Canada).
Current Keyboard Layout - Accommodates the special characters and symbols used in different languages. Your keyboard layout determines which characters appear when you press keys on the keyboard.
If you don't need to make any changes just press Next.

If you do need to make changes press Customize and add your System Locale etc.
Note for Hebrew users: In W2K it is NOT SAFE to install Hebrew language support at this phase!!! Trust me, do it later. If you don't listen to me, good chances are that you'll get ???? fonts in some Office applications such as Outlook and others.
Type your name and organization.

Type the product key

If you'd like to skip this step in the future, please read Install Windows 2000 Without Supplying the CD Key.

Enter the appropriate license type and number of purchased licenses.

Type the computer name and a password for the local Administrator account. The local Administrator account resides in the SAM of the computer, not in Active Directory. If you will be installing in a domain, you need either a pre-assigned computer name for which a domain account has been created, or the right to create a computer account within the domain.

Choose which components to install or remove from the system.

Select the date, time, and time zone settings.

Setup will now install the networking components.
After a few seconds you will receive the Networking Settings window. BTW, if you have a NIC that is not in the HCL (see the What's the HCL? page) and W2K cannot detect it, or if you don't have a NIC at all, setup will skip this step and you will immediately go to the final phase of the setup process.

Press Next to accept the Typical settings option if you have one of the following situations:
You have a functional DHCP on your network.
You have a computer running Internet Connection Sharing (ICS).
You're in a workgroup environment and do not plan to have any other servers or Active Directory at all, and all other workgroup members are configured in the same manner.
Otherwise select Custom Settings and press Next to customize your network settings.
Highlight the TCP/IP selection and press Properties.
In the General tab enter the required information. You must specify the IP address of the computer, and if you don't know what the Subnet Mask entry should be - you can simply place your mouse pointer over the empty area in the Subnet Mask box and click it. The OS will automatically select the value it thinks is good for the IP address you provided.

Lamer note: In the above screenshot I've configured the computer with a valid IP address for MY network, along with the Default Gateway and the address of MY DNS server. Your settings may differ.
If you don't know what these values mean, or if you don't know what to write in them, press cancel and select the Typical Settings option. You can easily change these values later.
In the Workgroup or Domain window enter the name of your workgroup or domain.
A workgroup is a small group of computers on a network that enables users to work together and does not support centralized administration.
A domain is a logical grouping of computers on a network that has a central security database for storing security information. Centralized security and administration are important for computers in a domain because they enable an administrator to easily manage computers that are geographically distant from each other. A domain is administered as a unit with common rules and procedures. Each domain has a unique name, and each computer within a domain has a unique name.
If you're a stand-alone computer, or if you don't know what to enter, or if you don't have the sufficient rights to join a domain - leave the default entry selected and press Next.

If you want to join a domain (NT 4.0 domain of W2K/2003 Active Directory domain) enter the domain's name in the "Yes, make this computer a member of the following domain" box.

<<--------------------->>
Windows XP

Windows XP

This procedure demonstrates how to install Windows XP Professional. The procedure to install Windows XP home edition is very similar to the professional edition. Since Windows XP Pro is more advanced operating system, it will be used to demonstrate the installation procedure.
The best way to install Windows XP is to do a clean install. It is not difficult to perform a clean installation. Before you perform the installation I recommend that you check Windows XP Compatibility List to ensure that your hardware is supported by XP. If your hardware is not on the compatibility list you can check your hardware manufactures website to download the drivers for Windows XP. Save all the necessary drivers onto floppy disks or CD before you start the installation.
All versions of Windows XP CD are bootable. In order to boot from CD/DVD-ROM you need to set the boot sequence. Look for the boot sequence under your BIOS setup and make sure that the first boot device is set to CD/DVD-ROM. You can then perform the following steps to install Windows XP:

Step 1 - Start your PC and place your Windows XP CD in your CD/DVD-ROM drive. Your PC should automatically detect the CD and you will get a message saying "Press any key to boot from CD". Soon as computer starts booting from the CD your will get the following screen:

Step 2 - At this stage it will ask you to press F6 if you want to install a third party Raid or SCSI driver. If you are using a an IDE Hard Drive then you do not need to press F6. If you are using a SCSI or SATA Hard drive then you must press F6 otherwise Windows will not detect your Hard Drive during the installation. Please make sure you have the Raid drivers on a floppy disk. Normally the drivers are supplied on a CD which you can copy to a floppy disk ready to be installed. If you are not sure how to do this then please read your motherboard manuals for more information.

Step 3 - Press S to Specify that you want to install additional device.

Step 4 - You will be asked to insert the floppy disk with the Raid or SCSI drivers. Press enter after you have inserted the disk.

Step 5 - You will see a list of Raid drivers for your HDD. Select the correct driver for your device and press enter.

Step 6 - You will then get a Windows XP Professional Setup screen. You have the option to do a new Windows install, Repair previous install or quit. Since we are doing a new install we just press Enter to continue.

Step 7 - You will be presented with the End User Licensing Agreement. Press F8 to accept and continue

Step 8 - This step is very important. Here we will create the partition where Windows will be installed. If you have a brand new unformatted drive you will get a screen similar to below. In our case the drive size is 8190MB. We can choose to install Windows in this drive without creating a partition, hence use the entire size of the drive. If you wish to do this you can just press enter and Windows will automatically partition and format the drive as one large drive.
However for this demonstration I will create two partition. The first partition will be 6000MB (C: drive) and second partition would be 2180MB (E: drive). By creating two partition we can have one which stores Windows and Applications and the other which stores our data. So in the future if anything goes wrong with our Windows install such as virus or spyware we can re-install Windows on C: drive and our data on E: drive will not be touched. Please note you can choose whatever size partition your like. For example if you have 500GB hard drive you can have two partition of 250GB each.
Press C to create a partition.

Step 8 - Windows will show the total size of the hard drive and ask you how much you want to allocate for the partition you are about to create. I will choose 6000MB. You will then get the screen below. Notice it shows C: Partition 1 followed by the size 6000 MB. This indicates the partition has been created. We still have an unpartitioned space of 2189MB. Next heighlight the unpartitioned space by pressing down the arrow key. Then press C to create another partition. You will see the total space available for the new partition. Just choose all the space left over, in our case 2180MB.

Step 9 - Now you will see both partition listed. Partition 1 (C: Drive) 6000MB and Partition 2 (E: Drive) 2180MB. You will also have 8MB of unpartitioned space. Don't worry about that. Just leave it how its is. Windows normally has some unpartitioned space. You might wonder what happened to D: drive. Windows has automatically allocated D: drive to CD/DVD-ROM.
Select Partition 1 (C: Drive) and press Enter.

Step 10 - Choose format the partition using NTFS file system.This is the recommended file system. If the hard drive has been formatted before then you can choose quick NTFS format. We chose NTFS because it offers many security features, supports larger drive size, and bigger size files.

Windows will now start formatting drive C: and start copying setup files as shown on the two images below :

Step 11 - After the setup has completed copying the files the computer will restart. Leave the XP CD in the drive but this time DO NOT press any key when the message "Press any key to boot from CD" is displayed. In few seconds setup will continue. Windows XP Setup wizard will guide you through the setup process of gathering information about your computer.

Step 12 - Choose your region and language.

Step 13 - Type in your name and organization.

Step 14 - Enter your product key.

Step 15 - Name the computer, and enter an Administrator password. Don't forget to write down your Administrator password.

Step 16 - Enter the correct date, time and choose your time zone.

Step 17 - For the network setting choose typical and press next.

Step 18 - Choose workgroup or domain name. If you are not a member of a domain then leave the default settings and press next. Windows will restart again and adjust the display.

Step 19 - Finally Windows will start and present you with a Welcome screen. Click next to continue.

Step 20 - Choose 'help protect my PC by turning on automatic updates now' and press next.

Step 21 - Will this computer connect to the internet directly, or through a network? If you are connected to a router or LAN then choose: 'Yes, this computer will connect through a local area network or home network'. If you have dial up modem choose: 'No, this computer will connect directly to the internet'. Then click Next.

Step 22 - Ready to activate Windows? Choose yes if you wish to active Windows over the internet now. Choose no if you want to activate Windows at a later stage.

Step 23 - Add users that will sign on to this computer and click next.

Step 24 - You will get a Thank you screen to confirm setup is complete. Click finish

Step 25 - Log in, to your PC for the first time.

Step 26 - You now need to check the device manager to confirm that all the drivers has been loaded or if there are any conflicts. From the start menu select Start -> Settings -> Control Panel. Click on the System icon and then from the System Properties window select the Hardware tab, then click on Device Manager.

If there are any yellow exclamation mark "!" next to any of the listed device, it means that no drivers or incorrect drivers has been loaded for that device. In our case we have a Video Controller (VGA card) which has no drivers installed.
Your hardware should come with manufacturer supplied drivers. You need to install these drivers using the automatic setup program provided by the manufacturer or you need to manually install these drivers. If you do not have the drivers, check the manufacturers website to download them.
To install a driver manually use the following procedure:
(a) From the device manager double click on the device containing the exclamation mark.
(b) This would open a device properties window.
(c) Click on the Driver tab.
(d) Click Update Driver button. The Wizard for updating device driver pops up as shown below:

You now get two options. The first option provides an automatic search for the required driver. The second option allows you to specify the location of the driver. If you don't know the location of the driver choose the automatic search which would find the required driver from the manufacturer supplied CD or Floppy disk. Windows would install the required driver and may ask you to restart the system for the changes to take affect. Use this procedure to install drivers for all the devices that contain an exclamation mark. Windows is completely setup when there are no more exclamation marks in the device manager.

Check this one out:
What is WINDOWS XP?

2.) All Graphs in Chapter 8 (Deadlock) with their explanation

2009-08-27T02:37:00.000-07:00

Resource-Allocation Graph Algorithm
● Claim edge Pi → Rj indicated that process Pj may request resource Rj; represented by a dashed line.
● Claim edge converts to request edge when a process requests a resource.
● When a resource is released by a process, assignment edge reconverts to a claim edge.
● Resources must be claimed a priori in the system.

Resource-Allocation Graph

EXPLANATION:
A set of vertices V and a set of edges E.
● V is partitioned into two types:
- P = {P1, P2, …, Pn}, the set consisting of all the processes in the system.
- R = {R1, R2, …, Rm}, the set consisting of all resource types in the system.
● request edge – directed edge P1  Rj
● assignment edge – directed edge Rj  Pi
----
● Process
● Resource Type with 4 instances
● Pi requests instance of Rj
● Pi is holding an instance of Rj

● The Resource Allocation Graph (RAG) above is composed of 3 processes and four resources.
● R1 or resource 1 is composed of only one instance
● R2 has 2 instances
● R3 has one instance
● R4 has 3 instances
● P1 requests instance of R1
● P2 is holding an instance of R1
● P2 requests instance of R3
● P3 holds an instance of R3
● There is no deadlock found

------------------------

Resource Allocation Graph With A Deadlock

EXPLANATION:
If graph contains a cycle
=> if only one instance per resource type, then deadlock.
=> if several instances per resource type, possibility of deadlock.

● The Resource Allocation Graph (RAG) above is composed of 3 processes and four resources.
● R1 or resource 1 is composed of only one instance
● R2 has 2 instances
● R3 has one instance
● R4 has 3 instances
● P1 requests instance of R1
● P2 is holding an instance of R1
● P2 requests instance of R3
● P3 holds an instance of R3
● P3 requests an instance of R1
● There is deadlock based of the RAG no. 2 because all of the instances of R2 are held by the P1 and P2, then P3 is requesting for instances of R2. R2 cannot give any instances to P3 that is why a deadlock occurred.

------------------------

Resource Allocation Graph With A Cycle But No Deadlock

EXPLANATION:
If graph contains no cycles => no deadlock.

● The Resource Allocation Graph (RAG) above is composed of4 processes and 2 resources.
● R1 and R2 has composed of 2 instances
● P1 requests instance of R1
● P2 is holding an instance of R1
● P3 also holds an instance of R1
● P3 requests an instance of R2
● P4 holds an instance of R2
● P1 also holds an instance of R2
● There is no deadlock.

------------------------

Safe, Unsafe , Deadlock State

EXPLANATION:
If a system is in safe state => no deadlocks.
If a system is in unsafe state => possibility of deadlock.
Avoidance => ensure that a system will never enter an unsafe state.

------------------------

Resource-Allocation Graph For Deadlock Avoidance

EXPLANATION:
Requires that the system has some additional a priori information available.
● Simplest and most useful model requires that each process declare the maximum number of resources of each type that it may need.
● The deadlock-avoidance algorithm dynamically examines the resource-allocation state to ensure that there can never be a circular-wait condition.
● Resource-allocation state is defined by the number of available and allocated resources, and the maximum demands of the processes.

● The Resource Allocation Graph (RAG) above is composed of 2 processes and 2 resources.
● P1 holds an instance of R1
● P2 requests an instance of R1
● P1 and P2 may request an instance of R2

------------------------

Unsafe State In Resource-Allocation Graph

EXPLANATION:
● Basic fact:
If a system is in unsafe state => possibility of deadlock.
● The RAG above is compose of 2 resources and 2 processes
● P1 holds an instance of R1
● P2 is requesting an instance of R1
● P2 holds an instance of R2
● P1 may request an instance of R2

------------------------

Resource-Allocation Graph and Wait-for Graph

EXPLANATION:
Single Instance of Each Resource Type
● Maintain wait-for graph
- Nodes are processes.
- Pi → Pj if Pi is waiting for Pj.
● Periodically invoke an algorithm that searches for a cycle in the graph.
● An algorithm to detect a cycle in a graph requires an order of n^2 operations, where n is the number of vertices in the graph.
Several Instances of a Resource Type
● Available: A vector of length m indicates the number of available resources of each type.
● Allocation: An n x m matrix defines the number of resources of each type currently allocated to each process.
● Request: An n x m matrix indicates the current request of each process. If Request [ij] = k, then process Pi is requesting k more instances of resource type. Rj.

additional...
A Wait-For Graph in computer science is a directed graph used for deadlock detection in operating systems and relational database systems.
In Computer Science, a system that allows concurrent operation of multiple processes and locking of resources and which does not provide mechanisms to avoid or prevent deadlock must support a mechanism to detect deadlocks and an algorithm for recovering from them.
One such deadlock detection algorithm makes use of a Wait-For Graph to track which other processes a process is currently blocking on. In a Wait-for Graph, processes are represented as nodes, and an edge from process Pi to Pj implies Pj is holding a resource that Pi needs and thus Pi is waiting for Pj to release its lock on that resource.

1.) Resource Allocation Graph

2009-08-27T01:49:00.000-07:00

Example of a Resource Allocation Graph

Resource Allocation Graph With A Deadlock

Resource Allocation Graph With A Cycle But No Deadlock

Resource-Allocation Graph For Deadlock Avoidance

Unsafe State In Resource-Allocation Graph

Resource-Allocation Graph and Wait-for Graph

Resource-Allocation Graph
● Process

● Resource Type with 4 instances

● Pi requests instance of Rj

● Pi is holding an instance of Rj

---------------------------------

QUESTION:
=>How would you know if there's a DEADLOCK based on the resource allocation graph?

ANSWER:
If graph contains no cycles => no deadlock.
If graph contains a cycle
=> if only one instance per resource type, then deadlock (meaning if the cycle goes on a single path, it will result to a DEALOCK).
=> if several instances per resource type, possibility of deadlock (meaning if the resource allocation graph has several cycles it has a POSSIBILITY for DEADLOCK).

Recovery from Deadlock

2009-08-20T04:21:00.000-07:00

Recovery from Deadlock: Process Termination
• Abort all deadlocked processes.
• Abort one process at a time until the deadlock cycle is eliminated.
• In which order should we choose to abort?
– Priority of the process.
– How long process has computed, and how much longer to completion.
– Resources the process has used.
– Resources process needs to complete.
– How many processes will need to be terminated.
– Is process interactive or batch?

Recovery from Deadlock: Resource Preemption
• Selecting a victim – minimize cost
• Rollback – return to some safe state, restart process from that state
– Require the system to keep more information about the state of all the running processes
• Starvation – same process may always be picked as victim, include number of rollback in cost factor

Deadlock Detection

2009-08-20T04:12:00.000-07:00

Overview
• Allow system to enter a deadlock state
• Detection algorithm: examine the system state to determine whether a deadlock has occurred
• Recovery scheme: recover from the deadlock

Single Instance of Each Resource Type
• Maintain wait-for graph
– Nodes are processes.
– This graph is obtained from the resource-allocation graph by removing the nodes of type resource and collapsing the appropriate edges
– Pi  Pj if Pi is waiting for Pj.
• Periodically invoke an algorithm that searches for a cycle in the graph.
• An algorithm to detect a cycle in a graph requires an order of n2 operations, where n is the number of vertices in the graph.

Resource-Allocation Graph And Wait-for Graph

Several Instances of a Resource Type
• Available: A vector of length m indicates the number of available resources of each type
• Allocation: An n x m matrix defines the number of resources of each type currently allocated to each process
• Request: An n x m matrix indicates the current request of each process. If Request [i,j] = k, then process Pi is requesting k more instances of resource type Rj

Combined Approach to Deadlock Handling
• Combine the three basic approaches
– Prevention
– Avoidance
– Detection
• Allowing the use of the optimal approach for each of resources in the system
• Partition resources into hierarchically ordered classes.
• Use most appropriate technique for handling deadlocks within each class
• Group resources into a number of different resource classes
• Use the linear ordering strategy defined previously for the prevention of circular wait to prevent deadlocks between resource classes
• Within a resource class, use the algorithm that is most appropriate for that class
• Swappable space
Hold-and-Wait prevention strategy + avoidance
• Process resources: Assignable devices such as tape drives, files…
Avoidance + Resource ordering
• Main memory: assignable in pages or segments
Preemption
• Internal resources: PCB, I/O channels…
Resource ordering

Deadlock Prevention

2009-08-20T04:06:00.000-07:00

Ensure that at least one of the necessary conditions cannot hold
Prevent deadlocks by constraining how requests for resources can be made

• Mutual Exclusion – not required for sharable resources; must hold for non-sharable resources
• Hold and Wait – must guarantee that whenever a process requests a resource, it does not hold any other resources.
– Method 1: require each process to request and be allocated all its resources before it begins execution
– Method 2: allow a process to request resources only when the process has none
– Example: copy data from tape drive to disk file, sort disk file, print
Disadvantage
• Low resource utilization
• Starvation possible
• No Preemption – if process A holding resources requests another resource that cannot be immediately allocated to it
– Method 1: All resources currently being held by A are preempted
• Preempted resources are added to A’s waiting resource list
• A will be restarted only when it can regain its old resources, as well as the new ones that it is requesting.
– Method 2: Check the requested resources for following conditions
• If it is allocated to a process waiting for additional resources, preempt it from the waiting process and allocate it to A
• If it is held by a process not waiting, A must wait
– A’s resources may be preempted, but only if another process requests them

Often applied to resources whose state can be easily saved and restored later, such as CPU registers and memory space

• Circular Wait – impose a total ordering of all resource types
– Example: F(tape drive) = 1, F(disk drive) = 5, F(Printer) = 12
• F is defined according to the normal order of resource usage
– Method 1: require that each process requests resources in an increasing order of enumeration
• OK if tape drive  disk drive  Printer
• Not OK if disk drive  tape drive  Printer
– Method 2: Whenever a process requests an instance of Rj, it has released any resources Ri such that F(Ri) > F(Rj)

Methods for Handling Deadlock

2009-08-20T04:04:00.000-07:00

Methods for Handling Deadlocks
• Use a protocol to prevent or avoid deadlocks, ensuring that the system will never enter a deadlock state
– Deadlock prevention
– Deadlock avoidance
• Allow the system to enter a deadlock state, detect it and then recover
• Ignore the problem and pretend that deadlocks never occur in the system
– Used by most operating systems, including UNIX
– The undetected deadlock will result in the deterioration of the system performance. Eventually, the system will stop functioning and will need to be restarted manually

Deadlock Characterization

2009-08-20T03:36:00.000-07:00

Necessary Conditions
• Mutual exclusion: At least one resource must be held in a non-sharable mode
• Hold and wait: a process holding at least one resource is waiting to acquire additional resources held by others
• No preemption: a resource can be released only voluntarily by the process holding it, after it has completed its task
• Circular wait: there exists a set {P0, P1, …, P0} of waiting processes such that P0 is waiting for a resource that is held by P1, P1 is waiting for a resource that is held by P2, …, Pn–1 is waiting for a resource that is held by Pn, and Pn is waiting for a resource that is held by P0.

Deadlock can arise if four conditions hold simultaneously.

Resource-Allocation Graph
• A set of vertices V and a set of edges E.
• V is partitioned into two types:
– P = {P1, P2, …, Pn} (All processes in the system)
– R = {R1, R2, …, Rm} (All resources in the system)
• Two kinds of edges
– Request edge – directed edge P1  Rj
– Assignment edge – directed edge Rj  Pi

continuation..
• Process

• Resource Type with 4 instances

• Pi requests instance of Rj

• Pi is holding an instance of Rj

Example of a Resource Allocation Graph

Resource Allocation Graph With A Cycle But No Deadlock

RAG And Deadlock
• If graph contains no cycles  no deadlock.
• If graph contains a cycle 
– If only one instance per resource type, then deadlock.
– If several instances per resource type, possibility of deadlock.

Thread Scheduling

2009-08-16T01:23:00.000-07:00

Thread scheduler, part of the OS (usually) that is responsible for sharing the available CPUs out between the various threads. How exactly the scheduler works depends on the individual platform, but various modern operating systems (notably Windows and Linux) use largely similar techniques that we'll describe here. We'll also mention some key varitions between the platforms.

Note that we'll continue to talk about a single thread scheduler. On multiprocessor systems, there is generally some kind of scheduler per processor, which then need to be coordinated in some way. (On some systems, switching on different processors is staggered to avoid contention on shared scheduling tables.) Unless otherwise specified, we'll use the term thread scheduler to refer to this overall system of coordinated per-CPU schedulers.

Across platforms, thread scheduling1 tends to be based on at least the following criteria:

****a priority, or in fact usually multiple "priority" settings that we'll discuss below;

****a quantum, or number of allocated timeslices of CPU, which essentially determines the amount of CPU time a thread is allotted before it is forced to yield the CPU to another thread of the same or lower priority (the system will keep track of the remaining quantum at any given time, plus its default quantum, which could depend on thread type and/or system configuration);

****a state, notably "runnable" vs "waiting";

****metrics about the behaviour of threads, such as recent CPU usage or the time since it last ran (i.e. had a share of CPU), or the fact that it has "just received an event it was waiting for".

Most systems use what we might dub priority-based round-robin scheduling to some extent. The general principles are:

****a thread of higher priority (which is a function of base and local priorities) will preempt a thread of lower priority;

****otherwise, threads of equal priority will essentially take turns at getting an allocated slice or quantum of CPU;

****there are a few extra "tweaks" to make things work

Multi-processor Scheduling

2009-08-16T01:22:00.000-07:00

*Will consider only shared memory multiprocessor

*Salient features:
-One or more caches: cache affinity is important
-Semaphores/locks typically implemented as spin-locks: preemption during critical sections

Real-Time Scheduling

2009-08-13T04:04:00.000-07:00

Distinctive Embedded System Attributes
● Reactive: computations occur in response to external events
Periodic events (e.g. rotating machinery and control loops).
Aperiodic events (e.g. button click).
● Real Time: correctness is partially a function of time
Hard real time.
– Absolute deadline, beyond which answer is useless
– May include minimum time as well as maximum time
Soft real time.
– Approximate deadline
– Utility of answer degrades with time difference from deadline

Real-Time Review
● Real time is not just “real fast”
Real time means that correctness of result depends on both functional correctness and time that the result is delivered.
● Soft real time
Utility degrades with distance from deadline.
● Hard real time
System fails if deadline window is missed.
● Firm real time
Result has no utility outside deadline window, but system can withstand a few missed results.

Type of Real-Time Scheduling

Taxonomy of Real-Time Scheduling
● Dynamic vs. Static
Dynamic schedule computed at run-time based on tasks really executing.
Static schedule done at compile time for all possible tasks.
● Preemptive permits one task to preempt another one of lower priority

Schedulability
● NP-hard if there are any resources dependencies
Prove it definitely cannot be scheduled.
Find a schedule if it is easy to do.
Stuck in the middle somewhere.

Necessary and sufficient schedulability test

Scheduling Parameters
● Assume N CPUs available for execution of a single task set
● Set of tasks {Ti}
Periods pi.
Deadline di (completion deadline after task is queued).
Execution time ci (amount of CPU time to complete).
● Handy values:
Laxity li = di – ci (amount of slack time before Ti must begin execution).
Utilization factor ui = ci/pi(portion of CPU used).

Static Schedule
● Assume non-preemptive system with 5 Restrictions:
1. Tasks {Ti} are periodic, with hard deadlines and no jitter
2. Tasks are completely independent
3. Deadline = period pi = di
4. Computation time ci is known and constant
5. Context switching is free (zero cost) INCLUDING network messages to send context to another CPU(!)
● Consider least common multiple of periods pi
This considers all possible cases of period phase differences.
Worst case is time that is product of all periods; usually not that bad.
If you can figure out (somehow) how to schedule this, you win.
● Performance
Optimal if all tasks always run; can get up to 100% utilization.
If it runs once, it will always work.

EDF: Earliest Deadline First
● Assume a preemptive system with dynamic priorities, and (same 5 restrictions)
● Scheduling policy:
Always execute the task with the nearest deadline
● Performance
Optimal for uniprocessor (supports up to 100% of CPU usage in all situations)
If you’re overloaded, ensures that a lot of tasks don’t complete
– Gives everyone a chance to fail at the expense of the later tasks

Least Laxity
● Assume a preemptive system with dynamic priorities, and (same 5 restrictions)
● Scheduling policy:
Always execute the task with the smallest laxity.
● Performance:
Optimal for uniprocessor (supports up to 100% of CPU usage in all situations).
– Similar in properties to EDF
A little more general than EDF for multiprocessors.
– Takes into account that slack time is more meaningful than deadline for tasks of mixed computing sizes
Probably more graceful degradations.
– Laxity measure permits dumping tasks that are hopeless causes

EDF/Least Laxity Tradeoffs
● Pro:
If it works, it can get 100% efficiency (on a uniprocessor)
● Con:
It is not always feasible to prove that it will work in all cases.
– And having it work for a while doesn’t mean it will always work
Requires dynamic prioritization.
The laxity time hack for global priority has limits.
– May take too many bits to achieve fine-grain temporal ordering
– May take too many bits to achieve a long enough time horizon

Rate Monotonic
● Assume a preemptive system with static priorities, and (same 5 restrictions) plus

● Scheduling policy:
Highest static priority goes to shortest period; always execute highest priority.
● Performance:
Provides a guarantee for schedulability with CPU load of ~70%.
– Even with arbitrarily selected task periods
– Can do better if you know about periods & offsets
If all periods are multiple of shortest period, works for CPU load of 100%.

SUBSTANTIAL INFORMATION ABOUT THREAD OF ATLEAST THREE OS

2009-08-09T03:23:00.000-07:00

LINUX THREADS
- Linux refers to them as tasks rather than threads
- Thread creation is done through clone() system call
- clone() allows a child task to share the address space of the parent task (process)

----------

WINDOWS NT’s Threads
Processes in NT can consist of one or more threads.

- Primary thread - When a process is created, one thread is generated along with it.

This object is then scheduled on a system wide basis by the kernel to execute on a processor.
After the primary thread has started, it can create other threads that share its address space and system resources but have independent contexts, which include execution stacks and thread specific data. A thread can execute any part of a process' code, including a part currently being executed by another thread.

It is through threads, provided in the Win32 application programmer interface (API), that Windows NT allows programmers to exploit the benefits of concurrency and parallelism.

- Fiber - is NT’s smallest user-level object of execution. It executes in the context of a thread and is unknown to the operating system kernel. A thread can consist of one or more fibers as determined by the application programmer. ˝Some literature ˝[1,11] assume that there is a one-to-one mapping of userlevel objects to kernel-level objects, this is inaccurate. Windows NT does ˝provide the means for many-to-many ˝scheduling. However, NT's design is poorly documented and the application programmer is responsible for the control of fibers such as allocating memory, scheduling them on threads and preemption.

----------

WINDOWS XP THREAD
Implements the one-to-one mapping
Each thread contains
- A thread id
- Register set
- Separate user and kernel stacks
- Private data storage area
The register set, stacks, and private storage area are known as the context of the threads
The primary data structures of a thread include:
- ETHREAD (executive thread block)
- KTHREAD (kernel thread block)
- TEB (thread environment block)

CPU SCHEDULING ALGORITMS

2009-08-09T03:10:00.000-07:00

Scheduling Algorithms
1.First-come, first-served (FCFS) scheduling
2.Shortest-job first (SJF) scheduling
3.Priority scheduling
4.Round-robin scheduling
5.Multilevel queue scheduling
6.Multilevel feedback queue scheduling

First-come, First-served(FCFS) scheduling
-is the simplest scheduling algorithm, but it can cause short processes to wait for very long processes.

Shortest-job-first (SJF) scheduling
-is provably optimal, providing the shortest average waiting time. Implementing SJF scheduling is difficult because predicting the length of the next CPU burst is difficult. The SJF algorithm is a special case of the general

Priority-scheduling algorithm,
- which simply allocates the CPU to the highest-priority process. Both priority and SJF scheduling may suffer from starvation. Aging is a technique to prevent starvation.

Round-robin (RR) scheduling
- is more appropriate for a time-shared (interactive) system. RR scheduling allocates the CPU to the first process in the ready queue for q time units, where q is the time quantum. After q time units, if the process has not relinquished the CPU, it is preempted and the process is put at the tail of the ready queue. The major problem is the selection of the time quantum. If the quantum is too large, RR scheduling degenerates to FCFS scheduling; if the quantum is too small, scheduling overhead in the form of context-switch time becomes excessive.

The FCFS algorithm is nonpreemptive, the RR algorithm is preemptive. The SJF and priority algorithms may be either preemptive or nonpreemptive.

Multilevel queue algorithms
-allow different algorithms to be used for various classes of processes. The most common is a foreground interactive queue which uses RR scheduling, and a background batch queue, which uses FCFS scheduling.

Multilevel feedback queues
-allow processes to move from one queue to another.

Because such a wide variety of scheduling algorithms are available, we need methods to select among them. Analytic methods use mathematical analysis to determine the performance of an algorithm. Simulation methods determine performance by imitating the scheduling algorithm on a “representative” sample of processes, and computing the resulting performance.

Operating Systems supporting threads at the kernel level must schedule threads - not processes - for execution. This is the case with Solaris 2 and Windows 2000 where both systems schedule threads using preemptive priority based on scheduling algorithm including support for real-time threads. The Linux process scheduler also uses a priority-based algorithm with real-time supports as well. The scheduling algorithms for these three operating systems typically favor interactive over batch and CPU-bound processes.systems typically favor interactive over batch and CPU-bound processes.

Thread Library

2009-07-30T04:14:00.000-07:00

• Thread library provides programmer with API for creating and managing threads

• Two primary ways of implementing
- Library entirely in user space
- Kernel-level library supported by the OS

Multithreading Methods

2009-07-30T04:05:00.000-07:00

Multithreading Methods
• Many-to-One
• One-to-One
• Many-to-Many

MANY-TO-ONE
• Many user-level threads mapped to single kernel thread
• Examples:
- Solaris Green Threads
- GNU Portable Threads

----------

ONE-TO-ONE
• Each user-level thread maps to kernel thread
• Examples
- Windows NT/XP/2000
- Linux
- Solaris 9 and later

----------

MANY-TO-MANY
• Allows many user level threads to be mapped to many kernel threads
• Allows the operating system to create a sufficient number of kernel threads
• Solaris prior to version 9
• Windows NT/2000 with the ThreadFiber package

Kernel Thread

2009-07-30T04:03:00.000-07:00

• Supported by the Kernel

• OS manages threads
- Slower to create and manage because of system calls
- A blocking system call will not cause the entire process to block.
- The kernel can schedule threads on different CPUs.

User Thread

2009-07-30T03:59:00.000-07:00

• Thread management done by user-level threads library

• A blocking system call will cause the entire process to block
- OS is unaware of threads

• The kernel cannot schedule threads on different CPUs.

• Example: Pthread, a POSIX standard (IEEE 1003.1c) API for thread creation and synchronization.

Benefits of Multi-Threaded Programming

2009-07-30T03:52:00.000-07:00

• Responsiveness
- User interaction in parallel with data retrieval

• Utilization of MP Architectures

• Resource Sharing between Threads (vs. Process)
E.g. Synchronization by accessing shared data

• Economy (vs. Process)
- If the task is the same, why not share the code?
- In Solaris 2, creating a process is about 30 times slower than threads. Context switch threads is about 5 times slower.

Thread

2009-07-30T03:09:00.000-07:00

• A piece of code that run in concurrent with other threads.

• Each thread is a statically ordered sequence of instructions.

• Threads are being extensively used express concurrency on both single and multiprocessors machines.

• Programming a task having multiple threads of control – Multithreading or Multithreaded Programming.

• SINGLE and MULTI-THREADED PROCESSES

Interprocess Communication

2009-07-30T02:10:00.000-07:00

DIRECT COMMUNICATION
• Processes must name each other explicitly:
– send (P, message) – send a message to process P
– receive (Q, message) – receive a message from
process Q
• Properties of communication link
– Links are established automatically.
– A link is associated with exactly one pair of
communicating processes.
– The link may be unidirectional (e.g. signaling), but is
usually bi-directional (e.g. sockets).

----------

INDIRECT COMMUNICATION
• Messages are directed and received from
mailboxes (also referred to as ports).
– Each mailbox has a unique id. (e.g. shared memory,
shared file, message Q)
– Processes can communicate only if they share a
mailbox.
• Properties of communication link
– A link may be associated with many processes.
– Each pair of processes may share several
communication links.
– Link may be unidirectional or bi-directional.
• Operations
– create a new mailbox
– send and receive messages through mailbox
– destroy a mailbox
• Primitives are defined as:
send(A, message) – send a message to
mailbox A
receive(A, message) – receive a message
from mailbox A

----------

SYNCHRONIZATION
• Blocking send
- suspend sending process until message received
• Nonblocking send
- resume process immediately after sending message
• Blocking receive
- suspend receiving process until data is received
• Nonblocking receive
- return either a message or
- null if no message is immediately available

Synchronization Trade-Offs
• Blocking
- guarantees message has been delivered
- drastically reduces performance
• Non-Blocking
- much better performance (hides latency of message sending)
- could cause errors if messages are lost

----------

BUFFERING
• Buffering allows messages to be saved and read or transmitted later
• Requires sufficient memory to store messages
• Can drastically improve performance of applications

Types of Buffering
• Zero Capacity
- no buffering at all
- must be "listening" when a message comes in
• Bounded Capacity
- some max, n, of messages will be buffered
- be careful when queue gets full
• Unbounded Capacity
- no limit to the number of message
- not usually very realistic assumption
- this is not very realistic, buffers usually have finite capacity

Buffering Example

----------

Producer-Consumer Example
• One process generates data – the producer

• The other process uses it – the consumer

• If directly connected – time coordination

- How would they coordinate the time ??

• One process generates data – the producer

• The other process uses it – the consumer

• If not directly connected – have a buffer

- Buffer must be accessible to both

- Finite Capacity N – Number in use - K

5) Inter-Process Communication (IPC)

2009-07-16T03:23:00.000-07:00

~ Mechanism for processes to communicate and to synchronize their actions

~ Message system – processes communicate with each other without resorting to shared variables

~ IPC facility provides two operations:
>> send(message) – message size fixed or variable
>> receive(message)

~ If P and Q wish to communicate, they need to:
>> establish a communication link between them
>> exchange messages via send/receive

~ Implementation of communication link
>> physical (e.g., shared memory, hardware bus)
>> logical (e.g., logical properties)

4) Cooperating Process

2009-07-16T03:20:00.000-07:00

~ Independent process cannot affect or be affected by the execution of another process

~ Cooperating process can affect or be affected by the execution of another process

~ Advantages of process cooperation
>>Information sharing
>>Computation speed-up
>>Modularity
>>Convenience

3) Operations on Process (Process Operations)

2009-07-16T02:56:00.000-07:00

PROCESS CREATION
~ Parent process create children processes, which, in turn create other processes, forming a tree of processes

~ Resource sharing
>>Parent and children share all resources
>>Children share subset of parent’s resources
>>Parent and child share no resources

~ Execution
>>Parent and children execute concurrently
>>Parent waits until children terminate

~ Address space
>>Child duplicate of parent
>>Child has a program loaded into it

~ UNIX examples
>>fork system call creates new process
>>exec system call used after a fork to replace the process’ memory space with a new program

PROCESS TERMINATION
~ Process executes last statement and asks the OS to delete it (exit)
>>Output data from child to parent (via wait)
>>Process’ resources are deallocated by OS

~ Parent may terminate execution of children processes (abort)
>>Child has exceeded allocated resources
>>Task assigned to child is no longer required
>>If parent is exiting
-->Some OS do not allow child to continue if its parent terminates
--All children terminated - cascading termination

2) Process Scheduling

2009-07-16T02:41:00.000-07:00

Representation of Process Scheduling

-----------------

SCHEDULING QUEUES
~ Job queue – set of all processes in the system

~ Ready queue – set of all processes residing in main memory, ready and waiting to execute

~ Device queues – set of processes waiting for an I/O device

~ Processes migrate among the various queues

Ready Queue and Various I/O Device Queues

SCHEDULERS
~ Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue

~ Short-term scheduler (or CPU scheduler) – selects which process should be executed next and allocates CPU

Addition of Medium Term Scheduling

~ Short-term scheduler is invoked very frequently (milliseconds)  must be fast

~ Long-term scheduler is invoked very infrequently (seconds, minutes)  may be slow

~ The long-term scheduler controls the degree of multiprogramming

~ Processes can be described as either:
>> I/O-bound process – spends more time doing I/O than computations, many short CPU bursts
>> CPU-bound process – spends more time doing computations; few very long CPU bursts

CONTEXT SWITCH
~ When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process

~ Context-switch time is overhead; the system does no useful work while switching

~ Time dependent on hardware support

1) The Concept of Process (OS)

2009-07-16T01:46:00.000-07:00

An operating system executes a variety of programs:
~ Batch system – jobs
~ Time-shared systems – user programs or tasks

Textbook uses the terms job and process almost
interchangeably.

Process – a program in execution; process execution
must progress in sequential fashion.

A process includes:
~ program counter
~ stack
~ data section

-----------------

PROCESS STATE
As a process executes, it changes state
~ new: The process is being created.
~ running: Instructions are being executed.
~ waiting: The process is waiting for some event to occur.
~ ready: The process is waiting to be assigned to a processor
~ terminated: The process has finished execution.

Diagram of Process State

PROCESS CONTROL BLOCK(PCB)
Information associated with each process
~ Process state
~ Program counter
~ CPU registers
~ CPU scheduling information
~ Memory-management information
~ Accounting information
~ I/O status information

Process Control Block (PCB)

THREADS

In computer science, a thread of execution results from a fork of a computer program into two or more concurrently running tasks. The implementation of threads and processes differs from one operating system to another, but in most cases, a thread is contained inside a process. Multiple threads can exist within the same process and share resources such as memory, while different processes do not share these resources.

On a single processor, multithreading generally occurs by time-division multiplexing (as in multitasking): the processor switches between different threads. This context switching generally happens frequently enough that the user perceives the threads or tasks as running at the same time. On a multiprocessor or multi-core system, the threads or tasks will generally run at the same time, with each processor or core running a particular thread or task. Support for threads in programming languages varies: a number of languages simply do not support having more than one execution context inside the same program executing at the same time. Examples of such languages include Python, and OCaml, because the parallel support of their runtime support is limited by the use of a central lock, called "Global Interpreter Lock" in Python, "master lock" in Ocaml. Other languages may be limited because they use threads that are user threads, which are not visible to the kernel, and thus cannot be scheduled to run concurrently. On the other hand, kernel threads, which are visible to the kernel, can run concurrently.

Many modern operating systems directly support both time-sliced and multiprocessor threading with a process scheduler. The kernel of an operating system allows programmers to manipulate threads via the system call interface. Some implementations are called a kernel thread, whereas a lightweight process (LWP) is a specific type of kernel thread that shares the same state and information.

Programs can have user-space threads when threading with timers, signals, or other methods to interrupt their own execution, performing a sort of ad-hoc time-slicing.

Threads compared with processes
Threads differ from traditional multitasking operating system processes in that:

~ processes are typically independent, while threads exist as subsets of a process
~ processes carry considerable state information, where multiple threads within a process share state as well as memory and other resources
~ processes have separate address spaces, where threads share their address space
~ processes interact only through system-provided inter-process communication mechanisms.
~ Context switching between threads in the same process is typically faster than context switching between processes.

Systems like Windows NT and OS/2 are said to have "cheap" threads and "expensive" processes; in other operating systems there is not so great a difference except the cost of address space switch which implies a TLB flush.

Question and Answer

2009-07-16T00:36:00.000-07:00

1. What are the major activities of an Operating System with regards to Process Management?

The operating system is responsible for the following activities in connection with process management.
Process creation and deletion.

Process suspension (process is in I/O wait queue, or “swapped” out to disk, …) and resumption (move to ready queue or execution) – manage the state of the process.
Provision of mechanisms for:
Process synchronization - concurrent processing is supported thus the need for synchronization of processes or threads.

Process communication

Deadlock handling

2. What are the major activities of an Operating System with regards to Memory Management?

Keep track of which parts of memory are currently being used and by whom.
Decide which processes to load when memory space becomes available - long term or medium term scheduler.
Mapping addresses in a process to absolute memory addresses - at load time or run time.
Allocate and deallocate memory space as needed.
Memory partitioning, allocation, paging (VM), address translation, defrag, …
Memory protection

3. What are the major activities of an Operating System with regards to Secondary-Storage Management?

- Free space management
- Storage allocation
- Disk scheduling – minimize seeks (arm movement … very slow operation)
- Disk as the media for mapping virtual memory space
- Disk caching for performance
- Disk utilities: defrag, recovery of lost clusters, etc.

4. What are the major activities of an Operating System with regards to File Management?

- File creation and deletion - system calls or commands.
- Directory creation and deletion - system calls or commands.
- Support of primitives for manipulating files and directories in an efficient manner - system calls or commands.
- Mapping files onto secondary storage.
- File backup on stable (nonvolatile) storage media.
EX: File Allocation Table (FAT) for Windows/PC systems

5. What is the purpose of the command-interpreter?

- The program that reads and interprets control statements is called variously:
·command-line interpreter (Control card interpreter in the “old batch days”)
·shell (in UNIX)
- Command.com for external commands in DOS
- Its function is to get and execute the next command statement.

System Boot

2009-07-07T04:01:00.000-07:00

~ Operating system must be made available to hardware so hardware can start it

~ Small piece of code – bootstrap loader, locates the kernel, loads it into memory, and starts it

~Sometimes two-step process where boot block at fixed location loads bootstrap loader
When power initialized on system, execution starts at a fixed memory location

~Firmware used to hold initial boot code

Virtual Machine

2009-07-07T03:38:00.000-07:00

=> A virtual machine is a tightly isolated software container that can run its own operating systems and applications as if it were a physical computer. A virtual machine behaves exactly like a physical computer and contains it own virtual (ie, software-based) CPU, RAM hard disk and network interface card (NIC).

An operating system can’t tell the difference between a virtual machine and a physical machine, nor can applications or other computers on a network. Even the virtual machine thinks it is a “real” computer. Nevertheless, a virtual machine is composed entirely of software and contains no hardware components whatsoever. As a result, virtual machines offer a number of distinct advantages over physical hardware.

IMPLEMENTATION
Modes:
- virtual user mode and virtual monitor mode,
- Actual user mode and actual monitor mode

Time
- Whereas the real I/O might have taken 100 milliseconds, the virtual I/O might take less time (because it is spooled) or more time (because it is interpreted.)
- The CPU is being multi-programmed among many virtual machines, further slowing down the virtual machines in unpredictable ways.

BENEFITS
In general, VMware virtual machines possess four key characteristics that benefit the user:

Compatibility: Virtual machines are compatible with all standard x86 computers
Isolation: Virtual machines are isolated from each other as if physically separated
Encapsulation: Virtual machines encapsulate a complete computing environment
Hardware independence: Virtual machines run independently of underlying hardware

Two advantages
To provide a robust level of security
- no direct sharing of resources.
- Two solutions
To allow system development to be done easily
- A perfect vehicle for OS research and development.
- difficult to implement due to the effort required to provide an exact duplicate to the underlying machine.
- Wine for Linux.

EXAMPLES
~ Compiled Java programs are platform-neutral bytecodes executed by a Java Virtual Machine (JVM).
~ JVM consists of
- class loader
- class verifier
- runtime interpreter
~ Just-In-Time (JIT) compilers increase performance

System Generation (SYSGEN)

2009-07-07T03:08:00.000-07:00

~ Operating systems are designed to run on any of a class
of machines; the system must be configured for each
specific computer site.

~ SYSGEN program obtains information concerning the
specific configuration of the hardware system.

~ Booting – starting a computer by loading the kernel.

~ Bootstrap program – code stored in ROM that is able to
locate the kernel, load it into memory, and start its
execution.

~ How to generate a system?
- Recompile
- Cause the creation of tables and selection of modules from a precompiled library
Link modules together to form the generated OS
SYSGEN is faster, but the generated OS may be overly general
- Completed table driven
All the code is always part of the system, and selection occurs at execution time
Most modern OS are constructed in this manner

~ Size and generality of the generated system and the ease of modification as the hardware configuration changes

System Structure

2009-07-05T05:20:00.000-07:00

• Simple Structure

• Layered Approach

The operating system is divided into a number of layers (levels), each built on top of lower layers. The bottom layer (layer 0), is the hardware; the highest (layer N) is the user interface.

With modularity, layers are selected such that each uses functions (operations) and services of only lower-level layers

Properties

Simplicity of construction

Simplicity of Debugging

Problems

Precise definition of layers

Example: Memory manager requires device driver of backing store (due to virtual memory)

The device driver requires CPU scheduler (since if the driver waits for IO, another task should be scheduled)

CPU scheduler may require virtual memory for large amount of information of some processes

Less efficiency: due to the number of layers a request should pass

System Calls

2009-07-05T05:13:00.000-07:00

System calls provide the interface between a running program and the operating system
Generally available as assembly-language instructions
Languages defined to replace assembly language for systems programming allow system calls to be made directly (e.g., C, C++)

Types of System Calls

• Process control
create/terminate a process (including self)

• File management

Also referred to as simply a file system or filesystem. The system that an operating system or program uses to organize and keep track of files. For example, a hierarchical file system is one that uses directories to organize files into a tree structure.Although the operating system provides its own file management system, you can buy separate file management systems. These systems interact smoothly with the operating system but provide more features, such as improved backup procedures and stricter file protection.

• Device management
Device Management is a set of technologies, protocols and standards used to allow the remote management of mobile devices, often involving updates of firmware over the air (FOTA). The network operator, handset OEM or in some cases even the end-user (usually via a web portal) can use Device Management, also known as Mobile Device Management, or MDM, to update the handset firmware/OS, install applications and fix bugs, all over the air. Thus, large numbers of devices can be managed with single commands and the end-user is freed from the requirement to take the phone to a shop or service center to refresh or update.

• Information maintenance
– get time
– set system data (OS parameters)
– get process information (id, time used)

• Communications
– establish a connection
– send, receive messages
– terminate a connectionlProcess control
– create/terminate a process (including self)

Sytem Components

2009-07-02T04:01:00.000-07:00

OPERATING SYSTEMS PROCESS MANAGEMENT
~ A process is a program in execution. A process needs
certain resources, including CPU time, memory, files, and
I/O devices, to accomplish its task.

~ The operating system is responsible for the following
activities in connection with process management.
> Process creation and deletion.
> process suspension and resumption.
> Provision of mechanisms for:
-> process synchronization
-> process communication

MAIN MEMORY MANAGEMENT
~ Memory is a large array of words or bytes, each with its
own address. It is a repository of quickly accessible data
shared by the CPU and I/O devices.

~ Main memory is a volatile storage device. It loses its
contents in the case of system failure.

~ The operating system is responsible for the following
activities in connections with memory management:
> Keep track of which parts of memory are currently being
used and by whom.
> Decide which processes to load when memory space
becomes available.
> Allocate and deallocate memory space as needed.

FILE MANAGEMENT
~ A file is a collection of related information defined by its
creator. Commonly, files represent programs (both
source and object forms) and data.

~ The operating system is responsible for the following
activities in connections with file management:
> File creation and deletion.
> Directory creation and deletion.
> Support of primitives for manipulating files and directories.
> Mapping files onto secondary storage.
> File backup on stable (nonvolatile) storage media.

I/O SYSTEM MANAGEMENT
~ The I/O system consists of:
> A buffer-caching system
> A general device-driver interface
> Drivers for specific hardware devices

SECONDARY STORAGE MANAGEMENT
~ Since main memory (primary storage) is volatile and too
small to accommodate all data and programs
permanently, the computer system must provide
secondary storage to back up main memory.

~ Most modern computer systems use disks as the
principle on-line storage medium, for both programs and
data.

~ The operating system is responsible for the following
activities in connection with disk management:
> Free space management
> Storage allocation
> Disk scheduling

PROTECTION SYSTEM
~ Protection refers to a mechanism for controlling access
by programs, processes, or users to both system and
user resources.

~ The protection mechanism must:
> distinguish between authorized and unauthorized usage.
> specify the controls to be imposed.
> provide a means of enforcement.

COMMAND INTERPRETER SYSTEM
~ Many commands are given to the operating system by
control statements which deal with:
> process creation and management
> I/O handling
> secondary-storage management
> main-memory management
> file-system access
> protection
> networking

Operating System Services

2009-07-02T03:42:00.000-07:00

1. Program execution – system capability to load a program into memory and to run it
2. I/O operations – since user programs cannot execute I/O operations directly, the operating system must provide some means to perform I/On
3. File-system manipulation – program capability to read, write, create, and delete files
4. Communications – exchange of information between processes executing either on the same computer or on different systems tied together by a network. Implemented via shared memory or message passing
5. Error detection – ensure correct computing by detecting errors in the CPU and memory hardware, in I/O devices, or in user program

9. Hardware Protection

2009-06-25T03:22:00.000-07:00

-> DUAL-MODE PROTECTION
• Sharing system resources requires operating system to ensure
that an incorrect program cannot cause other programs to
execute incorrectly.

• Provide hardware support to differentiate between at least two
modes of operations.
1. User mode – execution done on behalf of a user.
2. Monitor mode (also supervisor mode or system mode) –
execution done on behalf of operating system.

• Mode bit added to computer hardware to indicate the current
mode: monitor (0) or user (1).

• When an interrupt or fault occurs hardware switches to monitor
mode

• Privileged instructions can be issued only in monitor mode.

-> I/O PROTECTION
• All I/O instructions are privileged instructions.
• Must ensure that a user program could never gain control of the computer in monitor mode (i.e., a user program that, aspart of its execution, stores a new address in the interrupt vector).

Use of a System Call to Perform an I/O

-> MEMORY PROTECTION
• Must provide memory protection at least for the interrupt vectorand the interrupt service routines.
• In order to have memory protection, add two registers thatdetermine the range of legal addresses a program may access:

– base register
– holds the smallest legal physical memoryaddress.
– limit register
– contains the size of the range.

• Memory outside the deﬁned range is protected.

-> CPU PROTECTION
• Timer
– interrupts computer after specified period to ensure operating system maintains control.
– Timer is decremented every clock tick.
– When timer reaches the value 0, an interrupt occurs.
• Timer commonly used to implement time sharing.
• Time also used to compute the current time.
• Load-timer is a privileged instruction.

8. Storage Structure

2009-06-25T02:26:00.000-07:00

-> MAIN MEMORY
main memory (main store, main storage, RAM, primary memory). The storage that is closely associated with the processor of a computer system and from which the program instruction and data can be directly retrieved and to which the resulting data is written prior to transfer to backing store or output device. In modern machines this is semiconductor memory but in earlier machines core stores and delay lines were used.

The majority of storage activity generated by a processor in the execution of a program is directed at the main memory. In a modern processor, however, there is usually a further small high-speed memory interposed between the processor and main memory that holds recently accessed main-memory data for rapid re-access. This small high-speed memory is known as a cache. The main memory is normally used in conjunction with a backing store with a much larger capacity.

-> MAGNETIC DISK
magnetic disk. Plastic disk coated with magnetic material and used for storing computer programs and data (information) as a series of magnetic spots. Most computers contain a hard disk unit for general storage. Hard magnetic disks can store larger amounts of data and come in cartridges that slot into a special drive unit. Computers also often have a disk drive for inserting portable, lower-capacity compact discs or floppy disks. Data is stored magnetically on both sides of a floppy disk, and is read by magnetic heads in the computer as the disk rotates.

It provide the bulk of secondary storage for modern computer systems. Conceptually, disks are relatively simple. Each disk platter has a flat circular shape, like a CD. Common platter diameters range from 1.8 to 5.25 inches. the two surfaces of a platter are covered with a magnetic material. We store information be recording it magnetically on the platters.

Moving-head disk mechanism

-> MAGNETIC TAPES
magnetic tape. It was used as an early secondary-storage medium. Although it is relatively permanent and can hold large quantities of data, its access time is slow in comparison to that of main memory. In addition, random access to magnetic tape is about a thousand times slower than random access to magnetic disk, so tapes are not very useful for secondary storage. Tapes are used mainly for backup, for storage of infrequently used information, and as a medium for transfering information from one system to another.

A tape is kept in a spool, and is wound or rewound past a read-write head. Moving to the correct spot on a tape can take minutes, but once positioned, tape drives can write data at speeds comparable to disk drives. Tape capacities vary greatly, depending on the particular kind of tape drive. Some tapes hold 2 to 3 times more data than does a large disk drive. Tapes and their drivers are usually categorized by width, including 4, 8, and 19 millimeters, 1/4 and 1/2 inch.

5. Device Status Table

2009-06-24T20:54:00.000-07:00

-> Device-Status Table contains entry for each I/O device indicating its type, address, and state.

->>A diagram of a Device-Status Table<<-

10. Storage Hierarchy

2009-06-24T20:48:00.000-07:00

• Storage systems organized in hierarchy.
– Speed
– Cost
– Size
– Volatility

STORAGE HEIRARCHY(MEMORY HEIRARCHY)

-> CACHING
copying information into faster storage system; main memory can be viewed as a cache for secondary storage.

• improve performance where a large access-time or transfer-rate disparity exists between two components) Memory caching: add cache (faster and smaller memory) between CPU and main memory
--> When need some data, check if it’s in cache
-->If yes, use the data from cache
--> If not, use data from main memory and put a copy in cache
– Disk caching: main memory can be viewed as a cache for disks

-> Cache COHERENCY and CONSISTENCY
• Cache coherency in multiprocessor systems
- Each CPU has a local cache
- A copy of X may exist in several caches --> must make sure that an update of X in one cache is immediately reflected in all other caches where X resides
- Hardware problem

• Cache consistency in distributed systems
- A master copy of the file resides at the server machine
- Copies of the same file scattered in caches of different client machines
- Must keep the cached copies consistent with the master file
- OS problem

7. Difference of RAM and DRAM

2009-06-24T20:35:00.001-07:00

-> The difference of RAM and DRAM is:

RAM - Random Access Memory - is a form of computer data storage. Takes the form of integrated circuits that allow stored data to be accessed in any order (i.e., at random).

DRAM - Dynamic Random Access Memory - is a type of random access memory that stores each bit of data in a separate capacitor within an integrated circuit. Since real capacitors leak charge, the information eventually fades unless the capacitor charge is refreshed periodically. Because of this refresh requirement, it is a dynamic memory as opposed to SRAM and other static memory.

6. Direct Memory Access

2009-06-24T20:33:00.001-07:00

-> Direct memory access (DMA) is a feature of modern computers and microprocessors that allows certain hardware subsystems within the computer to access system memory for reading and/or writing independently of the central processing unit.
DMA including disk drive controllers, graphics cards, network cards and sound cards. DMA is also used for intra-chip data transfer in multi-core processors, especially in multiprocessor system-on-chips, where its processing element is equipped with a local memory (often called scratchpad memory) and DMA is used for transferring data between the local memory and the main memory.
Computers that have DMA channels can transfer data to and from devices with much less CPU overhead than computers without a DMA channel. Similarly a processing element inside a multi-core processor can transfer data to and from its local memory without occupying its processor time and allowing computation and data transfer concurrency.

4. User Mode

2009-06-24T20:31:00.001-07:00

-> Enables multiple virtual systems (known as guests) to run as an application within a normal system (known as the host). As each guest is just a normal application running as a process in user space, this approach provides the user with a way of running multiple virtual machines on a single piece of hardware, offering excellent security and safety without affecting the host environment's configuration or stability.

3. Monitor Mode

2009-06-23T04:24:00.001-07:00

-> Monitor mode, or RFMON (Radio Frequency Monitor) mode, allows a computer with a wireless network interface card (NIC) to monitor all traffic received from the wireless network. Unlike promiscuous mode, which is also used for packet sniffing, monitor mode allows packets to be captured without having to associate with an access point or ad-hoc network first. Monitor mode only applies to wireless networks, while promiscuous mode can be used on both wired and wireless networks. Monitor mode is one of the six modes that 802.11 wireless cards can operate in: Master (acting as an access point), Managed (client, also known as station), Ad-hoc, Mesh, Repeater, and Monitor mode.

2. Difference of interrupt and trap and their use.

2009-06-23T04:19:00.000-07:00

-> An interrupt is a hardware-generated change-of-ﬂow within the system. An interrupt handler is summoned to deal with the cause of the interrupt; control is then returned to the interrupted context and instruction. A trap is a software-generated interrupt. An interrupt can be used to signal the completion of an I/O to obviate the need for device polling. A trap can be used to call operating system routines or to catch arithmetic errors.

1. Bootstrap Program

2009-06-23T03:52:00.000-07:00

-> Bootstrapping process that starts operating systems when the user turns on a computer system.

3. What's the diference between Batch System, Multiprogrammed system and Time-sharing system?

2009-06-20T21:13:00.001-07:00

* A batch system is one in which jobs are bundled together with the instructions necessary to allow them to be processed without intervention

* As machines with more and more memory became available, it was possible to extend the idea of multiprogramming (or multiprocessing) as used in spooling batch systems to create systems that would load several jobs into memory at once and cycle through them in some order, working on each one for a specified period of time

* The first involved timesharing or timeslicing. The idea of multiprogramming was extended to allow for multiple terminals to be connected to the computer, with each in-use terminal being associated with one or more jobs on the computer. The operating system is responsible for switching between the jobs, now often called processes, in such a way that favored user interaction. If the context-switches occurred quickly enough, the user had the impression that he or she had direct access to the computer.

4. Explain the advantages of Parallel System.

2009-06-18T03:47:00.000-07:00

> Multiprocessor system with more than one CPU in close communication.
> Tightly coupled system - processor share memory and a clock; communication usually takes place through the share memory.

Advantage of Parallel system:
-- Increased throughput
-- Economical
-- Increased reliability
> graceful degradation
> fail-soft systems

1. What is the difference of an OS in terms of user's view and system's view?

2009-06-18T03:45:00.000-07:00

-Differences:

User view

The user view of the computer varies by the interface being used. Most computer users sit in front of a PC, consisting of a monitor, keyboard, mouse and system unit. Such a system is designed for one user to monopolize its resources, to maximize the work that the user is performing. In this case,the operating system is designed mostly for ease of use, with some attention paid to performance, and none paid to resource utilization.

Some users sit at a terminal connected to a mainframe or minicomputer. Other users are accessing the same computer through other terminals. These users share resources and may exchange information. The operating system is designed to maximize resource utilization.

Other users sit at workstations, connected to networks of other workstations and servers. These users have dedicated resources at their disposal, but they also share resources such as networking and servers.

Recently, many varieties of handheld computers have come into fashion. These devices are mostly standalone, used singly by individual users. Some are connected to networks, either directly by wire or through wireless modems. Due to power and interface limitations they perform relatively few remote operations. These operating systems are designed mostly for individual usability, but performance per amount of battery life is important as well.

Some computers have little or no user view. For example, embedded computers in home devices and automobiles may have numeric keypad, and may turn indicator lights on or off to show status, but mostly they and their operating systems are designed to run without user intervention.

System View

We can view an operating system as a resource allocator. A computer system has many resources - hardware and software - that may be required to solve a problem. The operating system acts as the manager of these resources.

An operating system can also be viewed as a control program that manages the execution of user programs to prevent errors and improper use of the computer. It is especially concerned with the operation and control of I/O devices.

We have no universally accepted definition of what is part of the operating system. A simple viewpoint is that it includes everything a vendor ships when you order “the operating system”.

A more common definition is that the operating system is the one program running at all times on the computer (usually called the kernel), with all else being application programs. This is the one that we generally follow.

2. Explain the goals of OS.

2009-06-18T03:44:00.000-07:00

- It is easier to define an operating system by what it does than what it is, but even this can be tricky. The primary goal of some operating system is convenience for the user. The primary goal of other operating system is efficient operation of the computer system. Operating systems and computer architecture have influenced each other a great deal. To facilitate the use of the hardware, researchers developed operating systems. Users of the operating systems then proposed changes in hardware design to simplify them. In this short historical review, notice how identification of operating-system problems led to the introduction of new hardware features.

6. Difference between Client Server System and Peer-to-Peer System.

2009-06-18T03:18:00.001-07:00

The difference between the two are as follows:

Client-server computing or networking is a distributed application architecture that partitions tasks or work loads between service providers (servers) and service requesters, called clients. Often clients and servers operate over a computer network on separate hardware. A server is a high-performance host that is a registering unit and shares its resources with clients. A client does not share any of its resources, but requests a server's content or service function. Clients therefore initiate communication sessions with servers which await (listen to) incoming requests.

->> sample diagram of a Client-server system works:

Peer-to-peer (P2P) networking is a method of delivering computer network services in which the participants share a portion of their own resources, such as processing power, disk storage, network bandwidth, printing facilities. Such resources are provided directly to other participants without intermediary network hosts or servers. Peer-to-peer network participants are providers and consumers of network services simultaneously, which contrasts with other service models, such as traditional client-server computing.

->> sample diagram of a Peer-to-peer system works:

8. Define the essential properties of the following types of OS: (a)Batch, (b)Time Sharing, (c)Real Time, (d)Network, (e)Distributed, and (f)Handheld

2009-06-18T03:02:00.000-07:00

a. Batch. Jobs with similar needs are batched together and run through the computer as a group by an operator or automatic job sequencer. Performance is increased by attempting to keep CPU and I/O devices busy at all times through buffering, off-line operation, spooling, and multiprogramming. Batch is good for executing large jobs that need little interaction; it can be submitted and picked up later.Answers to
b. Time sharing. Uses CPU scheduling and multiprogramming to provide economical interactive use of a system. The CPU switches rapidly from one user to another. Instead of having a job deﬁned by spooled card images, each program reads its next control card from the terminal, and output is normally printed immediately to the screen.
c. Real time. Often used in a dedicated application. The system reads information from sensors and must respond within a ﬁxed amount of time to ensure correct performance.
d. Network. networked systems consist of multiple computers that are networked together, usually with a common operating system and shared resources. Users, however, are aware of the different computers that make up the system.
e. Distributed. Distributes computation among several physical processors. The processors do not share memory or a clock. Instead, each processor has its own local memory. They communicate with each other through various communication lines,
such as a high-speed bus or telephone line.
d. Handheld. designed to provide an environm,ent in which a user easily interface with the computer to execute programs.

7. Differentiate the design issues of Os between Stand Alone PC and Workstation connected to a network.

2009-06-18T03:00:00.000-07:00

- The difference between the two is that a Stand Alone PC practice a none to resource utilization, it imposes monopolization and implies no sharing of resources (like information, file, data, etc.). While a Workstation connected to a network is designed to maximize resource utilization where you can exchange information with a others via internet.

or

- A stand-alone PC works on its own. While in a workstation connected to a network, you can freely share your files and databases to other PC.A desktop or laptop computer that is used on its own without requiring a connection to a local area network (LAN) or wide area network (WAN). Although it may be connected to a network, it is still a stand-alone PC as long as the network connection is not mandatory for its general use.In offices throughout the 1990s, millions of stand-alone PCs were hooked up to the local network for file sharing and mainframe access. Today, computers are commonly networked in the home so that family members can share an Internet connection as well as printers, scanners and other peripherals. When the computer is running local applications without Internet access, the machine is technically a stand-alone PC. A workstation is a high-end microcomputer designed for technical or scientific applications. Intended primarily to be used by one person at a time, they are commonly connected to a local area network and run multi-user operating systems. The term workstation has also been used to refer to a mainframe computer terminal or a PC connected to a network.

5. Difference between Symmetric Multiprocessing and Asymmetric Multiprocessing.

2009-06-18T01:57:00.000-07:00

- Symmetric multiprocessing treats all processors as equals, and I/O can be processed on any CPU. Asymmetric multiprocessing has one master CPU and the remainder CPUs are slaves. The master distributes tasks among the slaves, and I/O is usually done by the master only. Multiprocessors can save money, by not duplicating power supplies, housings, and peripherals. They can execute programs more quickly, and can have increased reliability. They are also more complex in both hardware and software than uniprocessor systems.