unx003 - Backing up and Restoring apricot

SCO Unix 3.2v4.2 / OpenServer Release 5

Backing up and Restoring

John Buckley
Unix Support Department

Release 1.0

Table of Contents

  1. Introduction
    1. Why Backup?
    2. About this guide
  2. Basic Requirements
    1. Creating the Root and Boot floppies
    2. Create the tape backups
      1. Additional filesystems
    3. Determining the disk division table layout
  3. Rebuilding the System
    1. Rebuilding the root operating system disk
      1. Rebuilding on original disk
      2. Restoring other filesystems
      3. Rebuilding on new root disk
        1. Creating lost+found
      4. Rebuilding non-root disks


Throughout this Info Guide the following typefaces have special meaning:

unix            - The name of a command, file, menu item,
                  or on screen option.
Boot            - Output displayed on screen.
mkdev fd        - Keyboard input

Why Backup?

No computer system can be ever described as 100% reliable. External influences such as mains fluctuations, unauthorised interference with the system, badly written code and of course, the people who use it, are all possible sources of system failure. Computers are now becoming more than ever `Business Critical', and as such are instruments to the likely success or failure of the company's day to day operations.

Most systems will suffer `down-time' at some point in their operational life for any number of reasons, so it becomes essential that the impact this has is minimised. A sensible system recovery policy, coupled with regular backups and precautions will go along way toward this.

This may all sound familiar, but suprisingly enough, the majority of systems in daily use now, are still not being backed up properly, and much time is being wasted in re-installing software from scratch.

About this guide

This guide was written to address a requirement that many people do not have the basic knowledge to backup or recover a SCO UNIX system in the event of a major failure. What is covered is not an exhaustive set of methods, but those which will enable the user to get out of the worst scenarios fairly quickly.

It is possible to restore a system onto a new blank disk, without using the SCO master floppies, or having to start off by carrying out a basic UNIX installation. As a rough guide it should take about 20 minutes to partition, division and make bootable a new disk prior to restoring the backup tape.

Basic Requirements

With any SCO UNIX system, the absolute minimum requirement for any backup should be regarded as:

  1. Root and Boot floppies (created using mkdev fd)

  2. Root filesystem backup on cartridge tape, cpio format. (not tar as this does not backup empty directories, empty files, or device nodes)

  3. Separate backups of other filesystems (usually containing customers data)

  4. Printouts of hard disk(s) division table (output from divvy)

Additionally, for SCO OpenServer 5:

  1. Backup of Boot filesystem (/stand)

These must be created as soon as the system is installed, and maintained up to date to reflect the changes in the system as time goes on.

Creating the Root and Boot floppies

Make sure that you have to hand, 2 DSHD 1.44Mb floppy disks. These need not be formatted beforehand, as the system will ask you if you want to format during creation of the disk set.

As root, type in:

  # mkdev fd

and the floppy creation will start. Use the menu options to create a "Boot" floppy and a "Root filesystem" floppy. Note that the installed kernel on floppy will take on the characteristics of the main kernel, so all the currently configured devices will be recognised when the system is booted from the floppies. In these later versions of UNIX, most of the utilities you will need are automatically copied over to the root filesystem disk. In earlier versions including Xenix, these had to be added manually.

Ensure that the disks are not write protected.

Your emergency floppies are now ready. Label them as `boot disk' and `root filesystem disk' as appropriate: If the system configuration changes significantly, it may pay to re-create them from time to time.

Create the tape backups

This can also be done from sysadmsh (up to 4.2) or scoadmin (OpenServer5), using the menu-driven backup options. However, for service requirements, it is often more convenient to do it manually from the command prompt.

As root, this can be done from single or multiuser mode. It is preferable to be in single user mode, as this also ensures that only root can be logged in during the backup process. Identify first which filesystems are currently mounted. Ensure that only root is mounted.

Type in:

  # mount

This should show:

On SCO UNIX 3.2v4.x:

  / on /dev/root read/write on (some date)

On SCO OpenServer 5.0:

  / on /dev/root read/write on (some date)
  /stand on /dev/boot read only on (some date)

If the output shows additional filesystems that are mounted, type:

  # cd /
  # umountall

Ensure the tape is in the appropriate drive. Make sure you are in the root directory:

  # pwd

Enter the cpio backup command as follows:

  # find . -mount -depth -print|cpio -ov >/dev/rStp0

Substitute your own tape device name for `rStp0'

The -mount option to cpio ensures that only the current filesystem contents are archived. This is particularly important for OpenServer 5, where the /stand filesystem has to be archived separately.

Label this tape as `root filesystem backup'.

Additionally, for SCO OpenServer 5 only

Insert new tape:

  # cd /stand
  # find . -print -depth|cpio -ov >/dev/rStp0

Substitute your own tape device name for `rStp0'

Label this tape as `boot filesystem backup'.

Additional Filesystems

Mount up any additional filesystems that you might have, and back these up on separate tapes as required. In the example, there is a /u filesystem:

  # mountall -f
  # mount
  / on /dev/root read/write on (some date)
  /stand on /dev/boot read only on (some date)
  /u on /dev/u read/write on (some date)
  # cd /u
  # find . -print -depth|cpio -ov >/dev/rStp0

Substitute your own tape device name for `rStp0'

Label this up as `/u filesystem backup'

Store these in a safe place with the root/boot floppies.

Determining the disk division table layout

This step is absolutely necessary in order to keep an accurate record of the way the disk is partitioned and split up into filesystems. When the original software is restored, the filesystems will have to be set up exactly as they were previously. This information is not stored on the root and boot floppies, and therefore has to be manually configured when the system is rebuilt.

The command divvy will report the appropriate information as follows for UNIX 3.2v4.2. To produce a file for printing with the information below, use the command:

  divvy > filename

and then enter


followed by


(divvy command quit and exit options):

  # divvy /dev/hd0a

Name Type New FS # First Block Last Block root EAFS no 0 0 209715 swap NON FS no 1 209716 335544 u EAFS no 2 335545 1056757 NOT USED no 3 - - NOT USED no 4 - - NOT USED no 5 - - recover NON FS no 6 1056758 1056767 hd0a WHOLE DISK no 7 0 1057775 1056768 1K blocks for divisions,1008 1K blocks reserved for the system.

The previous example corresponds to the root drive. (divvy with no arguments defaults to the root drive). This drive is 1Gb in total size, with a 200Mb root filesystem, a 32Mb swap area and the remainder of the drive is divided up between a separate filesystem called u, and the recovery area.

In SCO OpenServer 5.0, there will be an additional entry called boot. This will appear at the top of the table followed by swap and root. Any subsequent filesystems will appear after that.

The table entry hd0a refers to drive 0 active partition (root disk). If there are other disks on the system, use divvy specifying the appropriate drive number. I.e.:

# divvy /dev/hd1a

For the second drive, active partition.

Print these out and keep a copy of them with the backup media.

Do not under any circumstances alter the current settings or names while you are in divvy. This will seriously compromise the integrity of the data already on the target drive. If you intend to alter the drive partitioning information to add an another filesystem or expand an existing filesystem for example, then you must backup the whole target disk first. If you are in any doubt, call UNIX Support first.

Use the options `q to quit' and `e to Exit without installing a division table' to quit the program. This will exit the program without saving any changes whether accidental or otherwise.

Rebuilding the System

Rebuilding the root operating system disk

In general, the drive that tends to suffer after a crash, or just through general wear and tear is the root drive. This contains the main bulk of the operating system, and any corruption occurring in this area can be regarded as generally critical. If the drive has failed through excessive bad block reporting, or for any other reason, then it should be replaced with a new one of the same type if possible.

If the problem can be traced to other sources such as accidental power down or deletion of system data by the operator, then the disk obviously need not be changed. In this case, the original partition table will most likely still be intact. Typically, the system will be unbootable and assuming that all other possible solutions have been exhausted, a re-build from the backups will be necessary.

Rebuilding on original disk

First, power the system down and insert the floppy labelled `Boot disk'. Power the system on and allow the machine to boot from the floppy. When this prompt appears:


press return. After the initial system load, you will be prompted to insert the filesystem disk. Remove the boot floppy and insert the `root filesystem' disk.

The system will complete its initialisation and leave you at the `#' prompt.

Do not remove the floppy at any time from now on until you re-boot the system. This is because the system is running from the floppy, and requires read/write access to it at all times.

The hard disk root file system will now need to be cleaned. To do this, type:

  # fsck -y /dev/hd0root

and the system should then start the filesystem check. If it responds instead with:

  /dev/hd0root:cannot stat

Or something similar, then the problem may be more severe. In this case, the root filesystem will need to be re-created from scratch, as it probably contains one or more incorrect files. Do this as described in the section Rebuilding on new root disk.

Additionally, for Openserver 5.0 only

  # fsck -y /dev/boot

Once fsck has completed without errors, mount the root filesystem as follows:

  #  mount /dev/hd0root /mnt

Change directory to /mnt

  # cd /mnt

Make sure that you are in the /mnt directory by using:


Insert your root filesystem backup tape into the tape drive. Use the following command to restore the data. Substitute your own tape device name for `rStp0'. (Note that rStp0 will always be the first SCSI tape drive defined in /etc/conf/cf.d/mscsi):

  # cpio -ivdum </dev/rStp0

This will restore the root filesystem data.

For SCO Openserver 5.0 only, unmount the root filesystem and mount the boot filesystem:

  # cd /
  # umount /mnt
  # mount /dev/boot /mnt

Insert the `boot filesystem backup' tape. Continue as before:

  # cd /mnt
  # cpio -ivdum </dev/rStp0

For All Versions

Once this has completed check that the root filesystem (and for OpenServer 5, the boot filesystem) are clean by running fsck again after unmounting them first. Use the following commands:

  # cd /
  # umountall
  # fsck /dev/hd0root
  # fsck /dev/boot

For SCO Openserver 5.0 only

  # haltsys

And wait for the system to reply with:

  ***     Safe to power off       ***
  ***  Press any key to reboot    ***

Power the machine off, remove the floppy disk, and try to reboot from the hard disk. If the system still fails to boot, attempt to re-write the boot tracks as described in Rebuilding on new root disk. Failing that, contact UNIX Support.

Restoring other filesystems

If there were additional filesystems on the root filesystem disk, try to ascertain their condition. If they were auto mount filesystems, the system will try to clean them automatically when going multiuser. If this was successful, examine the contents to check their integrity. If the data looks suspect or behaves incorrectly, you will have to restore this from the backup you made of this too.

Note that it is preferable to be in single user mode to do the restore. If the system was allowed to go multiuser, use the following command at the console (tty01) responds instead with:

  # init 1

Use mount to check if the filesystem is already mounted:

  # mount
  / on /dev/root read/write on (some date)
  /stand on /dev/boot read only on (some date)
  /u on /dev/u read/write on (some date)

/u is only used as an example in this document. In practice, there may be more filesystems of widely differing names on other systems. If the filesystem(s) is/are not mounted, mount it/them now:

  # mountall -f

Change directory to the relevant mount point. In this case:

  # cd /u

Insert the appropriate filesystem backup tape. Start the restore:

  # cpio -ivdum </dev/rStp0

Again, `rStp0' is only an example. Use your own tape device name if different.

Once the restore has completed, check the integrity of the data on that filesystem using fsck.

Use the same procedure as detailed previously, if the additional filesystems were residing on separate disks.

Rebuilding on new root disk

This section applies too to an existing disk that has been low level formatted or has lost its boot track and/or its fdisk table.

The majority of the procedure is the same as if you were re-installing an original drive, with the notable exception that the drive has to be manually partitioned and made bootable before the restore can take place. Proceed as follows.

For a new drive, ensure that the drive is installed correctly. In the case of SCSI drives, make sure that the ID matches that of the original drive, and that it is terminated appropriately for it's position on the SCSI bus.

Boot off of the root/boot floppy set as detailed at the beginning of the previous section.

Use the fdisk command to initialise the UNIX area as follows:

  # fdisk

If the disk needs to contain a DOS partition, make sure that this was installed prior to re-booting in UNIX

Follow the on-screen instructions to either use the whole disk for UNIX or use rest of disk for UNIX if DOS partition is installed. Make the UNIX partition active.

Next, the disk partition containing SCO UNIX or OpenServer 5 needs to be divided into filesystems. This is where you will need the details of the original division table installation.

Use the divvy command as follows:

  # divvy -i /dev/hd0a

The `-i' option to divvy specifies an installation. Answer the questions about root and swap sizes with any legal number. Then answer yes to the question about making manual changes. Edit the start and end blocks of each filesystem according to the original values using the s and e menu options. Ensure that none of the start and end blocks overlap on each filesystem, and that the names of filesystems correspond with the original, using the n (name) menu option to set the names as required.

When each filesystem has been named, and the correct start/end blocks have been selected, use the c (create) option to initialise the filesystems. Do not, however do this on the `swap' area, as this must remain raw. Each filesystem will now have a type assigned to it. Ensure this ties up with the original. The default for UNIX 3.2v4.2 is EAFS and in OpenServer 5 the default is HTFS, apart from /boot which has to be EAFS to be bootable.

Select the q (quit) option followed by the i (inatall) option from the final menu and the machine should report:

  making filesystems

Once this has completed, create a lost+found directory in the new root directory. In order to do this, you need to mount the hard disk first:

  # cd /
  # mount /dev/hd0root  /mnt

Creating lost+found

Create the lost+found directory, and the `slots' in it as follows:

  # cd /mnt
  # mkdir lost+found
  # cd lost+found
  # for a in 1 2 3 4 5 6 7 8 9 0
  > do
  > for b in 1 2 3 4 5 6 7 8 9 0
  >  do
  > >${a}${b}
  > rm ??
  > done
  > done

Next, re-write the boot tracks as follows:

  # dd if=/etc/hdboot0 of=/dev/hd0a
  # dd if=/etc/hdboot1 of=/dev/hd0a bs=1k seek=1
  # dparam -w

At this point, check each filesystem with fsck to ensure integrity - this also acts as a check to ensure that the boot track data has not been written over the start of the disk by mistake, which can easily happen if hd00 is specified instead of hd0a in the dd commands above. If the mistake is made the fdisk and divvy tables will be lost so fsck will give an error.

  # fsck /dev/hd0root
  # fsck /dev/boot      (OpenServer 5 only)

The drive is now ready to have the data restored. You can shut the system down at this point, (haltsys) and proceed as detailed in the section `Rebuilding on original disk'.

Rebuilding non-root disks

For any additional disks that contain good filesystems then the procedure discussed under the section `Rebuilding on original disk' can be followed.

For additional disks that are new, re-formatted, or otherwise wiped, it is best to use the mkdev hd command to create them again. This will run fdisk followed by divvy.

The lost+found directory will need creating with empty slots as per the Creating lost+found sub-section, or an easier method is to use the mkdev fs command. This will ask for the device name, which for a filesystem called user2 would be /dev/user2. Answer the questions about automatically mounting and whether users can mount the filesystem. The mkdev fs script will then say Reserving slots in lost+found directory. Once complete you will need to edit the entry that it has added to the file /etc/default/filesys as one will already exist from the original installation. Below is an example of this file:

  bdev=/dev/users cdev=/dev/rusers \
      desc="users:users:yes:yes:1" \
      mountdir=/users rcmount=yes mount=no
  bdev=/dev/user2 cdev=/dev/ruser2 \
      desc="user2:user2:yes:yes:1" \
      mountdir=/user2 rcmount=yes mount=no
  bdev=/dev/user2 cdev=/dev/ruser2 \
      desc="user2:user2:yes:yes:1" \
      mountdir=/user2 rcmount=yes mount=no

Delete the second entry above. Note that sometimes such entries appear all on one physical line instead of these logical lines where the backslash is treated as a "continuation" mark.