Youta

SCSI-3 persistent reservations

2011-12-18T17:58:00.001+02:00

SCSI-3 Persistent Reservations (SCSI-3 PR) are required for I/O fencing and resolve the issues of using SCSI reservations in a clustered SAN environment. SCSI-3 PR enables access for multiple nodes to a device and simultaneously blocks access for other nodes.

SCSI-3 reservations are persistent across SCSI bus resets and support multiple paths from a host to a disk. In contrast, only one host can use SCSI-2 reservations with one path. If the need arises to block access to a device because of data integrity concerns, only one host and one path remain active. The requirements for larger clusters, with multiple nodes reading and writing to storage in a controlled manner, make SCSI-2 reservations obsolete.

SCSI-3 PR uses a concept of registration and reservation. Each system registers its own "key" with a SCSI-3 device. Multiple systems registering keys form a membership and establish a reservation, typically set to "Write Exclusive Registrants Only." The WERO setting enables only registered systems to perform write operations. For a given disk, only one reservation can exist amidst numerous registrations.

With SCSI-3 PR technology, blocking write access is as simple as removing a registration from a device. Only registered members can "eject" the registration of another member. A member wishing to eject another member issues a "preempt and abort" command. Ejecting a node is final and atomic; an ejected node cannot eject another node. In VCS, a node registers the same key for all paths to the device. A single preempt and abort command ejects a node from all paths to the storage device.

Example for performing SCSI-3 PR reserve and eject:

A good practice (used in SunCluster) is to use the machine IP as the registeration key. To obtain the key in hex format:


$ gethostip -x $HOSTNAME
7F000101

Registering a key:


$ sg_persist --out --register --param-sark=7F000101 /dev/emcpowera1

Reserving device:


$ sg_persist --out --reserve --param-rk=7F000101 --prout-type=3 /dev/emcpowera1

Repeat the key registeration for the peer node and try to preempt the device from the peer node:


$ gethostip -x $HOSTNAME
7F000102

$ sg_persist --out --register --param-sark=7F000102 /dev/emcpowera1

$ sg_persist --out --preempt --param-sark=7F000101 --param-rk=7F000102 --prout-type=5 /dev/emcpowera1

SCSI-2 Erlang port driver

2011-12-18T16:09:00.006+02:00

This is a sample C code that will use SCSI-2 capabilities to acquire/release a shared disk. The code is tested on Solaris 10.

The application reads standard input as sent by the Erlang port driver. It can be tested separately with echo -e option with the first 2 bytes as the command length (in bytes) followed by the command number.

To acquire disk lock use the own function, it forcibly break any previous ownership. Writes to disk are only allowed by the one holding the reservation. Similarly, a lock is released with the release function.

echo -e '\x00\x01\x02' | app 



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stropts.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mhd.h>
#include <sys/param.h>

// MACROS
#define PACKET   2   /* 2 bytes length */
#define BUF_SIZE 256 /* Packet^Byte = 2^8 = 256 */

#define STATUS  1
#define OWN     2
#define RELEASE 3

#define REINSTATE_RESV_DELAY 0
#define MIN_OWNERSHIP_DELAY  1000  /* 1 second */
#define MAX_OWNERSHIP_DELAY  15000 /* 15 seconds */


// TYPEDEF
typedef unsigned char byte;


int read_exact(byte *buf, int len)
{
  int i, got=0;

  do {
    if ((i = read(0, buf+got, len-got)) <= 0)
      return(i);
    got += i;
  } while (got<len);

  return(len);
}


int write_exact(byte *buf, int len)
{
  int i, wrote = 0;

  do {
    if ((i = write(1, buf+wrote, len-wrote)) <= 0)
      return (i);
    wrote += i;
  } while (wrote<len);

  return (len);
}

int read_cmd(byte *buf)
{
  int len;

  if (read_exact(buf, 2) != 2)
    return(-1);
  len = (buf[0] << 8) | buf[1];
  return read_exact(buf, len);
}


int write_cmd(byte *buf, int len)
{
  byte li;

  li = (len >> 8);
  write_exact(&li, 1);

  li = len;
  write_exact(&li, 1);

  return write_exact(buf, len);
}


// Multihost disk control operations
int open_device(char* device)
{
  return open(device, O_RDWR | O_NDELAY);
}

// Forcefully acquires exclusive access rights to the multihost disk for the
// local host. Revokes all access rights to the multihost disk from remote
// hosts. Causes the disk to enter the exclusive access state.
int own(int fd)
{
  struct mhioctkown t = {
    REINSTATE_RESV_DELAY,
    MIN_OWNERSHIP_DELAY,
    MAX_OWNERSHIP_DELAY
  };
  return ioctl(fd, MHIOCTKOWN, &t);
}


// Probes a multihost disk to determine whether the local host has access rights
// to the disk. Returns 0 if the local host has access to the disk, 1 if it
// doesn't, and -1 with errno set to EIO if the probe failed for some other
// reason.
int status(int fd)
{
  return ioctl(fd, MHIOCSTATUS);
}

// Relinquishes exclusive access rights to the multihost disk for the localhost.
// On success, causes the disk to enter the non- exclusive access state.
int release(int fd)
{
  return ioctl(fd, MHIOCRELEASE);
}

int main(int argc, char *argv[]) {
  int fn, fd, result;
  byte buf[BUF_SIZE];

  if(argc != 2) {
    abort();
  }

  fd = open_device(argv[1]);
  if(fd < 0) {
    perror("open");
    abort();
  }

  while (read_cmd(buf) > 0) {
    fn = buf[0];
    errno = 0;

    switch(fn)
      {
      case STATUS:
        result = status(fd);
        break;
      case OWN:
        result = own(fd);
        break;
      case RELEASE:
        result = release(fd);
        break;
      }

    buf[0] = result;
    strerror_r(errno, buf+1, sizeof(buf) - 2);
    write_cmd(buf, 1 + strlen(buf+1));
  }

  return EXIT_FAILURE;
}



syntax highlighted by Code2HTML, v. 0.9.1



Erlang logs and crashdump
2011-04-13T13:16:00.006+02:00
While running the Erlang runtime in the daemon mode, the VM writes its log files in the log/ directory under the Erlang root directory "$ROOTDIR".

The log files are named erlang.log.n and is rotated when it reaches the max configured size. The default maximum is 100KB which is rotated over 5 generations.

root@erix-laptop:/usr/local/lib/erlang/log# ls
erlang.log.2  erlang.log.3  erlang.log.4  erlang.log.5

In many cases we will need to increase this number. This is fairly easy, just set the following shell variables. These variables can also be added to the "start" script to be used by the run_erl command.

export RUN_ERL_LOG_GENERATIONS=10
export RUN_ERL_LOG_MAXSIZE=1000000

Check the values after starting the Erlang VM with os:getenv/1

1> os:getenv("RUN_ERL_LOG_GENERATIONS").
"10"
2> os:getenv("RUN_ERL_LOG_MAXSIZE").
"1000000"



Object-Oriented ANSI C
2009-11-21T11:26:00.001+02:00

I used to know that Object Orietned programming is only available with C++/Java but not C. After thinking about it for some time, I found that it could be, I know that for C++/Java guys this doesn't look like Object Oriented programming, but lets give it a try!

The code below uses function pointers to demonstrate "instantiating" a new object, followed by performing "member functions" on the object, and then deleting the object.


/**********************************************************************/
/*                                                                    */
/* Object Oriented C !                                                */
/*                                                                    */
/* Advanced STRUCTURE simulating OO design using function pointers.   */
/**********************************************************************/

#include <stdlib.h>

#define delete(a) a->finalize(a)

/**************************/
/* Define a car structure */
/**************************/
typedef struct car_st CAR;
struct car_st {
    unsigned int bTurbo:1; /* 1-bit flag */
    unsigned int maxSpeed;
    unsigned int fuelLevel;
    void (*start)();
    void (*turbo)();
    void (*stop)();
    void (*finalize)(struct car_st*);
    void (*funcPtrArr[2])();
};

void start()
{
    puts("VooVooo");
}

void turbo()
{
    puts("Fly baby ... fly");
}

void stop()
{
    puts("Race is over baby");
}

/***********************/
/* Simulate distructor */
/***********************/
void finalize( CAR* car )
{
    free( car );
}

/**************************/
/* Simualting constructor */
/**************************/
CAR* newCar ()
{
    /* Allocating & setting struct elements to Zero */
    CAR* newCar = calloc( 1, sizeof(CAR) );

    newCar->start = start;
    newCar->turbo = turbo;
    newCar->stop = stop;
    newCar->finalize = finalize;
    newCar->funcPtrArr[0] = &start;
    newCar->funcPtrArr[1] = &stop;    
    return newCar;
}

/***********************************************************/
/* Create instances of cars and try to use their functions */
/***********************************************************/
int main (int argc, char* argv[])
{
    CAR* dawoo = newCar();
    CAR* porsche = newCar();

    porsche->bTurbo = 1;

    dawoo->start(); 
    dawoo->bTurbo ? dawoo->turbo() : dawoo->stop();
    dawoo->funcPtrArr[1]();
    
    porsche->funcPtrArr[0]();
    porsche->start();
    porsche->bTurbo ? porsche->turbo() : porsche->stop();



    delete (porsche);
    delete (dawoo);
getchar();
    return ( EXIT_SUCCESS );
} /* end main */




The output of this code looks like

VooVooo
Race is over baby
Race is over baby
VooVooo
VooVooo
Fly baby ... fly



Ftp Scripting
2008-05-10T14:17:00.004+03:00
Here we demonstrate some ways of doing Ftp within shell scripts and the famous problem of passing the password!

First this an example using Here document:


#
# Here document
#
ftp -vn localhost << !
user $USER $PASSWD
pwd
quit
!



Another way using quote Ftp command:
ftp -n $HOST << !
quote USER $USER
quote PASS $PASSWD
pwd
quit
!




The previous ways are good as long as we don't need to do some logic inside the Ftp connection, like for example looping or conditional statements.

Instead, to able to do so, we have to use another method using "co-process" technique in the Korn shell (ksh) or of course Perl.
#
# Using co-process
# The "|&" turns the process into a co-process that allows subsequent
# "print -p" statements to send lines to the co-process standard-in and
# "read -p" to read from its standard-out.
#
exec 4>&1
ftp -nv >&4 2>&4 |&

print -p open localhost
print -p user ericsson ericsson
print -p pwd
for i in 1 2 3   ; do
      print -p pwd
done
print -p bye
wait

References:
Inlumine Consulting

Unix forums




In-Place String Filter
2008-05-10T14:04:00.002+03:00
This C function would remove  from the source string "str" a set of characters that you supply to the it "delims".

It returns a new string with out these characters, just like filtering the string.
The filtering is done in place, meaning that only N memory is used in the processing.

We first mark all occurrence of "delims" in "str" with nulls, then we concatenate the result to itself.



char *removeCharsInPlace(const char *str,const char *delims)
{
   char * const result = strdup(str);
   const int srcStrLen = strlen(str);
   const int delimsStrLen = strlen(delims);
   int i1, i2, j, tmp;

   // Replace all the characters in 'result' string, which are like
    // delims chars with null
    for(i1 = 0; i1 < srcStrLen ; i1++) {
       // Loop through the 'delims' string
        for (i2 = 0; i2 < delimsStrLen ; i2++) {
           if (result[i1] == delims[i2])
              result[i1] = '\0';
       }
   }

   // Loop through the 'result' string
    j = 0;
   while(j < srcStrLen) {
       // Calculate the position of the next null
        for(j; result[j] != '\0'; j++);

       // Get the start of next string
        j++;
       tmp = j;

       // Calculate next position to start search for the null
        j += strlen(&result[j]);

       // Append result to itself
        strcat(result, &result[tmp]);
   }

   return result;
}




Bypassing Firewall
2007-10-24T12:14:00.000+02:00
We can use a proxy http server to view blocked sites by our firewall like Youtube or facebook, the remote proxy server is opened over the internet and will do the connection on behalf of us, then forward the requested page to us :)
Note that not all the web proxies supports javascript, this may prevent some pages from displaying correctly.
A good one is the http://www.sloxy.com/, if we can access the proxy server then we can view whatever sites the server can access :)
To keep updated, we should frequently visit http://www.freeproxysite.com/.
Another simple way if we only need to view a single link, like a Youtube link <http://www.youtube.com/watch?v=r43yCiKlbCo//n>, just replace the URL with the IP <http://208.65.153.238/watch?v=r43yCiKlbCo//n>. 
To get the IP simply ping the host 
$ ping www.youtube.com
if the ping is blocked, we can use a webping www.fifi.org/services/ping
The above may not work for the messengers, To get the messengers working, we may use another 3rd parity program like www.hopster.com/ that will connect to the MSN or other servers on behalf. One should read their privacy policy before using it.



Shell Clock
2007-10-10T16:16:00.000+02:00
A useful clock that is displayed inside your terminal window, it displays the time on the top right edge of your terminal :)

This is done by manipulating the terminal escape sequence, this could be done with any language but I will list here the shell script version (just to save compile effort).

We can learn about terminal escape sequences using the dtterm manual pages ($ man -s5 dtterm), here we will use the "Esc 7" (DECSC), "Esc 8" (DECRC) and "Esc [ p1 ; p2 H" sequences.

The "Esc 7" sequence is used to save cursor position, "Esc 8" is used to restore cursor position and "Esc [ p1 ; p2 H" is used to position the cursor as follows:
A p1 value 0 or 1 moves the cursor to row one. A p1 value of N moves the cursor to row N.  A p2 value 0 or 1 moves the cursor to column one.  A p2 value of N moves the cursor to column N.

Save the following shell code in a script called for example "clock" and run it in the background as follows

$ clock &


#! /bin/sh

while true
do
 # Get time
 TIME=$(date +%T)

 # Save cursor position
 printf "\0337"

 # Set color
 printf "\033[1;31m"

 # Goto row 1, column 70
 printf "\033[1;70H$TIME"

 # Restore cursor position
 printf "\0338"

 sleep 1
done




In-place String Reverse
2007-10-10T14:59:00.000+02:00
This is an in-place function for reversing null terminated strings (in-place means that no additional space is required for the reverse process)


/***************************************/
/* In-place reverse                    */
/* Swap array elements (inner to outer)*/
/* ex:   "abcde", "Rock"               */
/* swap   adcbe    Rcok                */
/* swap   edcba    kcoR                */
/*                                     */
/***************************************/
void reverse (char* str)
{
     char temp;
     /* right & left to be swapped */
     int r, l;
     int len = strlen(str);

     if (len % 2 == 0)
     {
        r = len / 2;
        l = (len / 2) - 1;
     }
     else
     {
        r = (len / 2) + 1;
        l = (len / 2) - 1;
     }

     /***************************************/
     /* Swap array elements (inner to outer)*/
     /***************************************/
     while(l != 0)
     {
         temp = str[l];
         str[l] = str[r];
         str[r] = temp;
         l--;
         r++;
     }

     return;
}





UNIX Command Piping
2007-10-01T14:27:00.000+02:00
It took me some time to master the "Piping" skills so I thought this would be useful to share.
The following is a multi-piping program that connect any number of commands.

Steps:


Calculate the number of needed pipes.

Create the pipes and note that all coming childs will inherit it (remember to close all the pipes in the parent).

Fork a new child and redirect STDIN & STDOUT and note that first command should not redirect STDIN and last command should not redirect STDOUT.

Close all the pipes after redirection in child and repeat 3 until all commands are done.

Close all pipes in the parent.

Parent wait for the last child.



Usage: pipe cmd1 cmd2 cmd3 ...




#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>


int main (int argc,char* *argv,char* *envp)
{
 int i, j;
 int nProcess = argc - 1;
 int nPipes   = nProcess - 1;
 int   fd[nPipes][2]; // Pipe file descriptors
 pid_t pid;
 char  cmd[20] = "/bin/";

#ifdef DEBUG
 printf("Pipes: [%d] Process [%d]\n", nPipes, nProcess);
#endif

 /********************/
 /* Create the pipes */
 /********************/
 for(i=0;i < nPipes;i++)
 {
  pipe(fd[i]);
 }


 /************************************/
 /* Spawn child(s) for all processes */
 /************************************/
 for(j = 1;j <= nProcess;j++)
 {
#ifdef DEBUG
  printf("Child [%d] spawned.\n", j);
#endif
  pid = fork();
  if (pid == 0)
  {
   /***********************************************/
   /*  -----------                   -----------  */
   /*   fd[j-2]   --> process -->   fd[j-1]   */
   /*  -----------                   -----------  */
   /***********************************************/
   if ( j != 1 ) // First cmd should NOT redirect STDIN
    dup2(fd[j-2][1], STDIN_FILENO);
   if ( j != nProcess ) // Last cmd should NOT redirect STDOUT
    dup2(fd[j-1][0], STDOUT_FILENO);

   /*************************************************************/
   /* Close unuseful file descriptors:                          */
   /* the pipe's writing and reading ends                       */
   /* (the latter is not needed anymore, after the duplication) */
   /*************************************************************/
   for(i=0; i < nPipes;i++)
   {
    close(fd[i][0]);
    close(fd[i][1]);
   }

   /**********************************************************/
   /* Append command to /bin/                                */
   /* Child will have a separate (copy-on-write) copy of cmd */
   /**********************************************************/
   strcat(cmd, argv[j]);
   execlp(cmd, argv[j], (char *)0);
   perror("execlp");
   exit( EXIT_FAILURE );

  } /* end Child section */
 }


 /*****************************/
 /* Parent code will follow   */
 /* If everything goes right! */
 /*****************************/
 for(i=0; i < nPipes;i++)
 {
  close(fd[i][0]);
  close(fd[i][1]);
 }

 /****************************/
 /* Wait for the last child! */
 /****************************/
 waitpid(pid, 0, 0);

 return 0;
}


I have tested this code on Solaris and it worked properly!



Clear your Oracle database schema
2007-08-29T12:54:00.000+03:00
Normally you don't need to clear your working schema, unless you are running test cases that need to update and refresh the data with each run.

I use the following PL/SQL block to do this for me.


DECLARE

/* Variables to hold the result of the query */
t user_tables.TABLE_NAME %TYPE;
CURSOR tablecursor is
select table_namefrom user_tables;
BEGIN

OPEN tablecursor;
LOOP

/* Retrieve each row of the result into PL/SQL variables */
FETCH tablecursor
INTO t;

/* If there are no more rows to fetch, exit the loop */
EXIT WHEN tablecursor % NOTFOUND;
EXECUTE IMMEDIATE 'DROP TABLE "' t '"';
END LOOP;

/* Free cursor used by the query */
CLOSE tablecursor;
END;
/




Displaying X-Window applications on a Windows client
2007-08-24T11:27:00.001+03:00
To start displaying X-Window applications on your Windows system from a remote server, you need to have 2 things.

A remote telnet/SSH client
XWin Server 
The best available free tools are PuTTy and Cygwin/X, so lets see how this is done.
PuTTy X Window Configuration
Install PuTTy from http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
Start PuTTy. The PuTTy Configuration window will appear. Enter the hostname, select SSH and enter a Saved Sesssions name.
On Terminal -> Keyboard, change the Backspace key select to Control-H.
On SSH, "Preferred SSH protocol version", check 2. 
On SSH -> Auth, check the Authentication parameters, "Allow agent forwarding". 
On SSH -> Tunnels, check X11 forwarding "Enable X11 forwarding" 
On Session Click "Save" butter, the Saved Sesssions name will appear
When asked for "PuTTY Security Alert", please answer "Yes" to proceed. You will be asked only once in new configuration. 
http://www.msi.umn.edu/user_support/xclient/xwin_config.html

Cygwin/X

To install click on the "Install Cygwin now" link on the http://cygwin.com/ web page. This downloads setup.exe to your system. Once you've downloaded setup.exe, run it and select "X11" and then click on the appropriate field until the above announced version number appears if it is not displayed already.

After installation start the Cygwin and start xwin, the X-Window started within the PuTTy should now be displayed on your screen.


Korn Shell Auto complete feature
2007-08-24T11:25:00.000+03:00
Had to work with the korn shell, I was missing the Bash auto complete "TAB" feature.

For Korn Shell try the following:

Filename completion
$ command + name(ESC + \)

Filelist completion
$ command + name(*)

Searching history
$ (ESC + / + commandToSearchFor + ENTER) 


The Ten Commandments of Egoless Programming
2007-08-23T15:31:00.000+03:00
I was just passing by one of my colleagues desk at work when I found this note, a paper pinned up just behind his monitor.
Reading the first point, I said WOW and I just couldn't help stopping until the last word.
These really touched me, many points had something to do with me.
Being a good programmer is not just as being the perfect coder, the "home alone" guy, some other important things like "Do you have personal discussions with your boss?", "Do you send funny mails?", "How often do you socialize at work place?", I even see some getting flowers at work.
These terms were introduced in the book The Psychology of Computer Programming, chapter 4, worth reading.
1. Understand and accept that you will make mistakes. 
The point is to find them early, before they make it into production. Fortunately, except for the few of us developing rocket guidance software at JPL, mistakes are rarely fatal in our industry, so we can, and should, learn, laugh, and move on.
2. You are not your code.
Remember that the entire point of a review is to find problems, and problems will be found. Don't take it personally when one is uncovered.
3. No matter how much "karate" you know, someone else will always know more.
Such an individual can teach you some new moves if you ask. Seek and accept input from others, especially when you think it's not needed.
4. Don't rewrite code without consultation. 
There's a fine line between "fixing code" and "rewriting code." Know the difference, and pursue stylistic changes within the framework of a code review, not as a lone enforcer.
5. Treat people who know less than you with respect, deference, and patience. 
Nontechnical people who deal with developers on a regular basis almost universally hold the opinion that we are prima donnas at best and crybabies at worst. Don't reinforce this stereotype with anger and impatience.
6. The only constant in the world is change.
Be open to it and accept it with a smile. Look at each change to your requirements, platform, or tool as a new challenge, not as some serious inconvenience to be fought.
7. The only true authority stems from knowledge, not from position.
Knowledge engenders authority, and authority engenders respect -- so if you want respect in an egoless environment, cultivate knowledge.
8. Fight for what you believe, but gracefully accept defeat.
Understand that sometimes your ideas will be overruled. Even if you do turn out to be right, don't take revenge or say, "I told you so" more than a few times at most, and don't make your dearly departed idea a martyr or rallying cry.
9. Don't be "the guy in the room."
Don't be the guy coding in the dark office emerging only to buy cola. The guy in the room is out of touch, out of sight, and out of control and has no place in an open, collaborative environment.

10. Critique code instead of people.
Be kind to the coder, not to the code. As much as possible, make all of your comments positive and oriented to improving the code. Relate comments to local standards, program specs, increased performance, etc. 



Command history facilities for SQL*PLUS
2007-08-22T16:14:00.000+03:00
The SQL*PLUS is a powerful tool for performing SQL and administration tasks, unfortunately it has no command facilities other than on Windows.
If you are lucky enough to have the ied utility in your UNIX system then try the following:

$ ied sqlplus user/pass@db
SQL> [Escape-Key] + [K-Key] or [J-Key]

ied is a utility that act as an interface between you and the sqlplus, providing most of the line editing and history functionality found in the Korn shell.


Connect to Exchange server over the Internet
2007-08-21T18:07:00.001+03:00
This feature requires you to be using a Microsoft Exchange Server 2003 e-mail account.

These steps are for connecting Microsoft Outlook to your Exchange server without using a virtual private network (VPN) or other security hardware to connect behind your organization's firewall. Your Exchange administrator must enable this feature first before you can use it. 

On the Tools menu, click E-mail accounts, select View or change existing e-mail accounts, click Next, select the Exchange e-mail account, and then click Change.

Click More Settings, then click the Connection tab.

Under Exchange over the Internet, select Connect to my Exchange mailbox using HTTP.
To specify a proxy server, click Exchange proxy settings.

So if your webmail is https://xyz.com/exchange then you need to use xyz.com as your proxy server.


Friends Don't Let Friends Type Qwerty
2007-08-21T16:25:00.000+03:00
What is the QWERTY thing!?
If you are one of those who code much every day, then this is a serious issue for you.
Listen carefully; the keyboard layout (named QWERTY) we are using today was designed more than a 100 years ago, it was made to "slow" down the typist so that the typewriter won't get paper jam! It was taken as a standard for computers later.
You won't be happy to know that such layout could (in fact it will) cause you a problem like hand's pain, RSI "Repetitive Strain Injury" or CTS "carpal tunnel syndrome".

You could forget about all of these if you switch to the ANSI standard layout (named DVORAK after its inventor Dr. August Dvorak)
 The Dvorak layout was designed to address the problems of inefficiency and fatigue which characterized the QWERTY keyboard layout. The QWERTY layout was introduced in the 1860s, being used on the first commercially-successful typewriter, the machine invented by Christopher Sholes. The QWERTY layout was designed so that successive keystrokes would alternate between sides of the keyboard so as to avoid jams.
Dvorak Layout Diagram (for printing)
How to Remap Your Keyboard ? 
Windows XP 
From the "Start" menu, select "Settings" and then "Control Panel". From the Control Panel, double-click on "Regional and Language Options", Click the 'Languages' tab
Click the 'Details...' button to open the 'Text Services and Input Languages' window.
Click 'Add...', In the 'keyboard layout/IME' dropdown box, select "United States-Dvorak"
Click 'OK' to close the 'Text Services and Input Languages' window. A little keyboard icon should show up on your task bar*.
Click 'OK' to close the 'Regional and Language Options' window
X Window System
X Window System users (UNIX) can make the translation by running xmodmap on an appropriate keysym file. 
On Linux; KDE allows you to do the same thing as described here for Windows XP with its control center, perhaps Gnome as well.
On Solaris, there is already a keysym file for the Dvorak layout, so you can make it as:
$ /usr/openwin/bin/xmodmap /usr/share/xmodmap/xmodmap.dvorak
If you want this setting to take effect with every reboot, you need to add it to the .xinitrc File.
If a file named .xinitrc exists in your home directory, it will be used to start some initial X clients, e.g. the window manager and some xterms or a desktop environment like GNOME. The .xinitrc file is a shell script that contains the commands to do this. It is not necessary to put the usual #!/bin/sh in the first line and to set the executable bit on the file; xinit will still know how to run it through a shell. 
$ echo /usr/openwin/bin/xmodmap /usr/share/xmodmap/xmodmap.dvorak >> ~/.xinitrc
Here are some platform-independent keysym. To use them, simply save the appropriate file and give it as an argument to xmodmap.
keysym file for the Dvorak keyboard