There are times when your system runs out of swap space, and you need to add more swap space for the system to run smoothly. You will have three options as shown in the following list:

Adding swap on a new physical hard disk will give better I/O performance, but it requires you to take the server offline for adding new hardware. Once you have installed a new hard disk, you should launch FreeBSD's disklabel editor and create appropriate partitions on the newly installed hard disk.

If, for any reason, you cannot add new hardware to your server, you can still use the existing file system to create a swap file with the desired size and add it as swap space. First of all, you should check to see where you have enough space to create the swap file as shown as follows:

# df -h
Filesystem   Size  Used   Avail  Capacity  Mounted on
/dev/ad0s1a  27G   9.0G  16G      37%       /
devfs        1.0K  1.0K  0B      100%       /dev
procfs       4.0K  4.0K  0B      100%	    /proc
/dev/md0     496M  1.6M  454M     0%        /tmp

Then create a swap file where you have enough space using the following command line:

# dd if=/dev/zero of=/swap0 bs=1024k count=256
256+0 records in
256+0 records out
268435456 bytes transferred in 8.192257 secs (32766972 bytes/sec)

In the above example, I created a 256MB empty file (256 * 1024k blocks) named swap0 in the file system's root directory. Also remember to set the correct permission on the file. Only the root user should have read/write permission on file. This is done using the following command lines:

# chown root:wheel /swap0
# chmod 0600 /swap0
# ls -l /swap0
-rw------- 1 root wheel 268435456 Apr 6 03:15 /swap0

Then add the following swapfile variable in the /etc/rc.conf file to enable swap file on boot time:

swapfile="/swap0"

To make the new swap file active immediately, you should manually configure md(4) device. First of all, let's see if there is any md(4) device configured, using mdconfig(8) command as shown as follows:

# mdconfig -l
md0

Then configure md(4) device as shown here:

# mdconfig -a -t vnode -f /swap0
md1

You can also verify the new md(4) node as follows:

# mdconfig -l -u 1
md1 vnode 256M /swap0

Please note that -u flag in the mdconfig(8) command takes the number of md node (in this case, 1). In order to enable the swap file, you should use swapon(8) command and specify the appropriate md(4) device as shown here:

# swapon /dev/md1

And finally, check the system's swap status using the following swapinfo(8) command:

# swapinfo -h
Device      1K-blocks Used  Avail Capacity
/dev/ad0s1b 1048576   0B    1.0G   0%
/dev/md1    262144    0B    256M   0%
Total       1310720   0B    1.3G   0%

Since swap space contains the contents of the memory, it would have sensitive information like cleartext passwords. In order to prevent an intruder from extracting such information from swap space, you can encrypt your swap space.

There are already two file system encryption methods that are implemented in FreeBSD 7—gbde(8) and geli(8) commands. To enable encryption on the swap partition, you need to add .eli or .bde to the device name in the /etc/fstab file to enable the geli(8) command and the gbde(8) command, respectively. In the following example, the /etc/fstab file shows a swap partition encrypted using geli(8) command:

# cat /etc/fstab
# Device        Mountpoint FStype Options         Dump Pass#
/dev/ad0s1b.eli none        swap   sw               0    0
/dev/ad0s1a     /           ufs   rw,noatime        1    1
/dev/acd0       /           cdrom  cd9660 ro,noauto 0    0

Then you have to reboot the system for the changes to take effect. You can verify the proper operation using the following swapinfo(8) command:

# swapinfo -h
Device          1K-blocks Used Avail Capacity
/dev/ad0s1b.eli 1048576   0B   1.0G    0%
/dev/md0        262144    0B   256M    0%
Total           1310720   0B   1.3G    0%

The edquota(8) utility is the quota editor. You can limit the disk space (block quota) and the number of files (inode quota) using this utility, on quota enabled partitions. Two types of quota limits can be set for both inode quota and block quota:

Hard limit is the implicit limit that cannot be exceeded. For example, if a user has a quota limit of 200 files on a partition, an attempt to create even one additional file, will fail.

Soft limit is the conditional limit that may be exceeded for a limited period of time, called grace period. If a user stays over the soft limit for more than the grace period (which is one week by default), the soft limit will turn into hard limit and the user will be unable to make any more allocations. However, if the user frees the disk space down to a soft quota limit, the grace period will be reset.

Running the edquota(8) command invokes your default text editor (taken from EDITOR environment variable), and loads current quota assignment status for the specified user:

# edquota jdoe
Quotas for user jdoe:
/: kbytes in use: 626, limits (soft = 0, hard = 0)
inodes in use: 47, limits (soft = 0, hard = 0)

In the above case, user jdoe currently has forty seven files which use 626 kilobytes on the disk. You can modify the soft and hard values for either the block (first line) or the inode (second line). Once you finish setting quota limits, save and exit from your editor, and the edquota(8) utility will take care of applying new quota limits to the file system.

You can also change the default grace period using the edquota(8) utility. As in the previous example, edquota(8) invokes the default text editor to edit the current setting for the grace period:

# edquota -t0
Time units may be: days, hours, minutes, or seconds
Grace period before enforcing soft limits for users:
/: block grace period: 0 days, file grace period: 0 days

The example, above, displays the current status of the grace period on a per-partition basis. You can edit the value of the grace period, save it, and exit from the editor to apply new grace period settings. For your new grace period settings to take effect, you should also turn quota off, for the relevant file system, and then turn it back on. This can be done using the quotaon(8) and quotaoff(8) commands.

And finally, repquota(8) is used to display the summary of quotas for a specified file system. The repquota(8) command can be used to have an overview of the current inode and block usage, as well as quota limits on a per-user or per-group basis (if -g flag on command line is specified).

When using quotas, always remember the following important notes:

The dump(8) utility is the most reliable and portable backup solution to take backups on UNIX systems. The dump utility, in conjunction with restore(8), creates your basic backup toolbox in FreeBSD. The dump command is able to create full and incremental backups from the whole disk or any partition of your choice. Even if your file system that you want to take backups from, is live (which in most cases is), the dump utility creates a snapshot of your file system before the back up, to ensure that your file system does not change during the process.

By default, dump creates backups on a tape drive unless you specify another file or a special device.

A typical full backup using dump may look like the following example:

# dump -0auL -f /usr/dump1 /dev/ad0s1a
DUMP: Date of this level 0 dump: Sat Apr 14 16:40:03 2007
DUMP: Date of last level 0 dump: the epoch
DUMP: Dumping snapshot of /dev/ad0s1a (/) to /usr/dump1
DUMP: mapping (Pass I) [regular files]
DUMP: mapping (Pass II) [directories]
DUMP: estimated 66071 tape blocks.
DUMP: dumping (Pass III) [directories]
DUMP: dumping (Pass IV) [regular files]
DUMP: DUMP: 66931 tape blocks on 1 volume
DUMP: finished in 15 seconds, throughput 4462 KBytes/sec
DUMP: level 0 dump on Sat Apr 14 16:40:03 2007
DUMP: Closing /usr/dump1
DUMP: DUMP IS DONE

In the above example, dump is used to take a full backup (note the -0 flag) of the /dev/ad0s1a file, which is mounted onto the / mount point to a regular /usr/dump1 file. The -L flag indicates that the partition is a live file system; so dump will create a consistent snapshot from the partition, before performing the backup operation.

And finally -u flag tells dump to record dump information in the /etc/dumpdates file. This information is used by dump for future backups.

The dump command can also create incremental backups using information recorded in the /etc/dumpdates file. In order to create an incremental backup, you should specify a higher backup-level from -1 to -9 in the command line. If backup-level is not specified, dump will assume a full backup (that is -0) should be taken.

# dump -1auL -f /usr/dump2 /dev/ad0s1a
DUMP: Date of this level 1 dump: Sat Apr 14 15:00:36 2007
DUMP: Date of last level 0 dump: Sat Apr 14 14:35:34 2007
DUMP: Dumping snapshot of /dev/ad0s1a (/) to /usr/dump2
DUMP: mapping (Pass I) [regular files]
DUMP: mapping (Pass II) [directories]
DUMP: estimated 53 tape blocks on 0.00 tape(s).
DUMP: dumping (Pass III) [directories]
DUMP: dumping (Pass IV) [regular files]
DUMP: DUMP: 50 tape blocks on 1 volume
DUMP: finished in less than a second
DUMP: level 1 dump on Sat Apr 14 15:00:36 2007
DUMP: Closing /usr/dump2
DUMP: DUMP IS DONE

It also updates /etc/dumpdates with new backup dates:

# cat /etc/dumpdates
/dev/ad0s1a 0 Sat Apr 14 14:35:34 2007
/dev/ad0s1a 1 Sat Apr 14 15:00:36 2007

Once you have created dumps from your file system as regular files, you may want to move the dump file to another safe location (like a backup server), to protect your backups in case of a hardware failure. You can also create dumps directly on a remote server over SSH. This can be done by giving the following command:

# dump -0auL -f - /dev/ad0s1a | bzip2 | ssh [email protected] dd of=/usr/backup/server1.dump

This will create a level 0 (or full) backup from the /dev/ad0s1a device over network using ssh(1) facility to host bkserver with username admin and uses dd(1) to create a file using input stream. And as we create a full backup, which may be a huge file, bzip2(1) is used to compress data stream to reduce the network load.

You can use your favourite compression program (for example, gzip(1), compress(1)) with appropriate parameters, instead of bzip2.

Now that you made your backup on a tape or a remote device, you may also have to verify or restore your backup in future.

The restore(8) utility performs the inverse function of what dump does. Using restore, you can simply restore a backup taken using the dump utility, or extract your files, deleted accidentally. It can also be used to restore backups over the network.

A simple scenario for using restore is restoring a full backup. It is recommended that you restore your backup to an empty partition. You have to format the destination partition, using newfs(8), before restoring your backup. After you restore the full backup, you can proceed to restore the incremental backups, in the order in which they were created.

A typical restore procedure would look like the following command lines:

# newfs /dev/da0s1a
# mount /dev/da0s1a /mnt
# cd /mnt
# restore -r -f /usr/dump1

The restore command fully extracts the dump file to your current directory. So you have to change your current directory to wherever you want to restore the backup using the cd command.

Another interesting feature of the restore utility is the interactive mode. In this mode, you can browse through files and directories inside the dump file, and also mark the files and directories that should be restored. This feature is very useful in restoring the files and directories, deleted accidentally.

There are a number of useful commands in the interactive restore shell to help users choose what they want to extract. The ls, cd, and pwd commands are similar to their equivalents, and are used to navigate through the dump file. Using add and delete commands, you can mark and unmark files and directories that you want to extract. Once you finish selecting the files, you can use the extract command to extract the selected files.

# restore -i -f /usr/dump1
restore >
.:
.cshrc    bin/    dev/    [email protected]    mnt/    sbin/  var/
.profile  boot/   dist/   lib/     proc/   [email protected]
.snap/    cdrom/  entropy libexec/ rescue/ tmp/
COPYRIGHT [email protected] etc/    media/   root/   usr/
restore >  add sbin
restore >  add rescue
restore >   extract
restore >   quit

The restore command is also used to extract dump information from the dump file using the what command in the interactive mode:

restore >  what
Dump date: Sat Apr 14 16:40:03 2007
Dumped from: the epoch
Level 0 dump of / on server.example.com:/dev/ad0s1a
Label: none

There may be scenarios when you may not have to take a full dump of your hard disk or partition. Instead, you may want to archive a series of files and directories to your backup tapes or regular files. This is where tar(1), cpio(1L), and pax(1) utilities come into play.

The tar command is UNIX's original tape manipulation tool. It was created to manipulate streaming archive files for backup tapes. It is not a compression utility and is used in conjunction with an external compression utility such as gzip and bzip2, and compressd, in case compression is required.

Besides tape drives, you can use tar to create regular archive files. The tar archive files are called tarball.

A tarball can be created, updated, verified, and extracted using the tar(1) utility.

# tar cvf backup.tar backup/
a backup
a backup/HOME.diff
a backup/make.conf
a backup/rc.conf

In the above example, tar is used to create a tarball called backup.tar from the backup directory. The c flag indicates tar should create a tar ball, v flag tells tar to be verbose and show a list of files on which the operation is being performed and f flag indicates the name of the output tarball (backup.tar) in the command.

To update a tarball, u flag is used:

# tar uvf backup.tar backup/
a backup
a backup/make.conf
a backup/sysctl.conf

And x flag to extract the files from a tarball:

# tar xvf backup.tar
x backup
x backup/HOME.diff
x backup/make.conf
x backup/rc.conf

In all the above examples, the tarball archive was created as a regular file indicated by f flag. While omitting this flag, tar will use the default tape device on the /dev/sa0 file. Other useful tar flags include z for gzip compression and j for bzip2 compression.

The cpio utility is another important archiving utility in the FreeBSD's base system. It is similar to the tar utility in many ways. It was also a POSIX standard until POSIX.1-2001 and was dropped due to the 8GB file size limitation.

The pax utility was created by IEEE STD 1003.2 (POSIX.2) to sort out incompatibilities between tar and cpio. Pax does not depend on any specific file format and supports a handful of different archive formats including tar, cpio, and ustar (POSIX.2 standard). Despite being a POSIX standard that is widely implemented, it is still not as popular as a tar utility.

The -w flag is used to create archive:

# pax -w -f backup.pax backup/

And -r to extract (or read) the archive to current directory:

# pax -r -f backup.pax

The pax utility is also able to read/write different archive types that can be specified by -x flag. The supported parameters of pax are shown in the following list:

Actually, taking snapshots from a file system isn't a backup method, but is very helpful in restoring accidentally removed files. Snapshots can be mounted as regular file systems (even over network) and the system administrator can use regular system commands to browse the mounted file system and restore selected files and directories.

Striping disks is a method to combine multiple physical hard disks into one big logical volume. This is done mostly using relevant hardware RAID controllers, while GEOM provides software support for RAID0 stripe sets.

RAID0 offers improved disk I/O performance, by splitting data into multiple blocks and performing simultaneous disk writes on multiple physical disks, but offers no fault tolerance for hard disk errors. Any disk failure could destroy the array, which is more likely to happen when you have many disks in your set.

Appropriate kernel module should be loaded before creating a RAID0 volume using the following command:

# kldload geom_stripe

This can also be done through the /boot/loader.conf file, to automatically load the module during system boot up, by adding this line:

geom_stripe_load="YES"

The gstripe(8) utility has everything you need to control your RAID0 volume. Using this utility you can create, remove, and query the status of your RAID0 volume.

There are two different methods to create a RAID0 volume using gstripe—manual and automatic. In the manual method, the create parameter is used, and volumes created using this method do not persist during reboots. The volumes should be created at boot time, if persistence is required:

# gstripe create stripe1 /dev/da1 /dev/da2
# newfs /dev/stripe/stripe1

The newly created and formatted device can now be mounted and used as shown here:

# mount /dev/stripe/stripe1 /mnt

In the automatic method, the metadata is stored on the last sector of every device, so that they can be detected and automatically configured during boot time. In order to create automatic RAID0 volume, you should use label parameter:

# gstripe label stripe1 /dev/da1 /dev/da2

Just like manual volumes, you can now format /dev/stripe/stripe1 using newfs and mount it.

To see a list of current GEOM stripe sets, gstripe has the list argument. Using this command, you can see a detailed list of devices that form the stripe set, as well as the current status of those devices :

# gstripe list
Geom name: stripe1
State: UP
Status: Total=2, Online=2
Type: AUTOMATIC
Stripesize: 131072
ID: 1477809630
Providers:
1. Name: stripe/stripe1
Mediasize: 17160732672 (16G)
Sectorsize: 512
Mode: r1w1e0
Consumers:
1. Name: da1s1d
Mediasize: 8580481024 (8.0G)
Sectorsize: 512
Mode: r1w1e1
Number: 1
2. Name: da0s1d
Mediasize: 8580481024 (8.0G)
Sectorsize: 512
Mode: r1w1e1
Number: 0

To stop a RAID0 volume, you should use the stop argument in the gstripe utility. The stop argument will stop an existing striped set ,but does not remove the metadata from the device, so that it can be detected and reconfigured after system reboots.

# gstripe stop stripe1

To remove metadata from the device and permanently remove a stripe set, the clear argument should be used;

# gstripe clear stripe1

This level of RAID provides fault tolerance from disk errors and increased READ performance on multithreaded applications. But write performance is slightly lower in this method. In fact, RAID1 is a live backup of your physical disk. Disks used in this method should be of equal size.

The gmirror(8) facility is the control utility of RAID1 mirror sets. Unlike RAID0, all RAID1 volumes are automatic and all components are detected and configured automatically at boot time. The gmirror utility uses the last sector on each device to store metadata needed for automatic reconfiguration. This utility also makes it easy to place a root partition on a mirrored set.

It offers various commands to control mirror sets. Initializing a mirror is done using the label argument as shown here:

# gmirror label b round-robin mirror1 da0 da1

In the above example, we created a mirror set named mirror1 and attached the /dev/da0 and /dev/da1 disks to the mirror set.

The -b flag specifies the "balance algorithm" to be used in the mirror set. There are four different methods used as balance algorithms, which are listed as follows:

You may choose an appropriate algorithm depending on your hardware configuration. For example, if one of your hard disks is slower than the others , you can set higher priority on the fastest hard disk using gmirror's insert argument and use the prefer method as the balance algorithm.

Once you finish initializing your mirror set, you should format the newly created device using newfs command and mount it to relevant mount point:

# newfs /dev/mirror/mirror1
# mount /dev/mirror/mirror1 /mnt

The stop argument stops a given mirror.

Using the activate and deactivate arguments you can active and deactivate a device that is attached to a mirror, which would be useful in removing or replacing a hot-swappable hard disk. When a device is deactivated inside a mirror set, it will not attach itself to the mirror automatically, even after a reboot, unless you re-activate the device using the activate argument.

To add a new device to the mirror set, or to remove a device permanently, the insert and remove arguments can be used, respectively. The remove argument also clears metadata from the given device. This is shown in the following command lines:

# gmirror insert mirror1 da2
# gmirror remove mirror1 da1

If you want to change the configuration of a mirrored volume (for example, changing balance algorithm on the fly), the configure argument can be used:

# gmirror configure -b load mirror1

In case of disk failure, when a device is faulty and cannot be reconnected to the mirror, the forget argument will tell gmirror to remove all faulty components. Once you replace the faulty disk with a brand new one, you can use the insert argument to attach a new disk to the array, and start synchronizing data.

This method is used to concatenate multiple physical hard disks to create bigger volumes, beyond the capacity of one hard disk. The difference between this method and RAID0 's is that, in this method, data is written to the disk sequentially. This means that the system will fill the first device first, and the second device will be used only when there is no space left on the first device. This method does not offer any performance improvements or redundancy.

To create a concatenated volume, the gconcat(8) facility is available. As in RAID0, there are two methods to create a concatenated volume—manual and automatic.

Using the create parameter, you can create a manual concatenated volume and attach the desired physical disks. In this method, as no metadata will be written on the disk, the system will not be able to detect and reconfigure the volume after system reboots.

In order to create an automatic concatenated volume, the label parameter should be used:# gconcat label concat1 da0 da1 da2

Once a volume is created using either the manual or the automatic method, it should be formatted using newfs as shown as follows:

# newfs /dev/concat/concat1
# mount /dev/concat/concat1 /mnt

There is no way to remove a device from a concatenated volume. However, you can add new disks to an existing volume, and grow the size of the file system on the volume:

# gconcat label concat1 da3 da4
# growfs /dev/concat/concat1

To stop a concatenated volume, the stop argument is used. However this will not remove the volume permanently. The clear argument will remove the concatenated volume permanently, and also remove the GEOM metadata from the last sector of the attached devices.