mkproto Command

Purpose

Constructs a prototype file system.

Syntax

mkproto Special Prototype

Description

The mkproto command is used to construct a prototype for a new file system. It exists solely for Berkeley Software Distribution (BSD) compatibility.

The Special parameter can be a block device name, raw device name, or file system name. The Prototype parameter is the name of the prototype file that specifies the structure and contents of the file system to be created. The mkproto command calls the mkfs command with the Prototype and Special parameters.

Prototype Files

The mkproto and mkfs commands require an extended prototype file to create a Journaled File System (JFS). A prototype file is a formatted listing of the contents and structure of a file system. A prototype file describes the file system by a series of tokens separated by spaces and new lines. The main body of a prototype file defines the objects of the file system.

A JFS prototype file consists of the main body, which can be created by the proto command, preceded by five special tokens. These five tokens are defined as follows:

Prototype Files
Item Description
1st token Name of a file to be copied onto block 0 as the bootstrap program or the special token <noboot>.
2nd token Size of the file system. For a JFS, the size is expressed in units of 512-byte blocks. If the 2nd token is 0, the mkfs command creates the file system to fill the entire logical volume.
3rd token Number of i-nodes on the file system. This token is not used by a JFS but must be provided to preserve the position.
4th token Size of the file system fragment in bytes. If the 4th token is 0 (zero), the mkfs command uses the default fragment size. For JFS, the token must be either 0 (default value used), 512, 1024, 2048, or 4096. The default fragment size is 4096 for a JFS. An invalid fragment size causes the mkfs command to fail.
5th token Number of bytes per i-node (nbpi). If this token is 0, the mkfs command uses the default nbpi. For a JFS, this token must be either 0 (default value used), 512, 1024, 2048, 4096, 8192, or 16384. The default number of bytes per i-node is 4096 for a JFS. An invalid nbpi causes the mkfs command to fail.

The remaining tokens define the contents and structure of the file system. These tokens are grouped into sets, with each set defining one object of the file system. The syntax of each set is as follows:

{ [ Name ] { - | { - | d | b | c | l | L | p } { - | u } { - | g } { - | t } Mode Owner Group { Major Minor | SourceFile | DirectoryListing } } | { $ }

where:

Tokens
Item Description
Name Specifies the name of the object as it is to appear in the new file system. The Name token is required for every object except for the root directory definition.
  { - | d | b | c | l | L | p } { - | u } { - | g } { - | t } Represents a string of 4 positional characters, where:
{ - | d | b | c | l | L | p }
Defines the object type. Valid types are:
-
Regular file
d
Directory
b
Block special file
c
Character special file
l
Symbolic link
L
Hard link
p
Named pipe
{ - | u }
Toggles the set UID bit of the object, as follows:
u
Set UID on execution
-
Do not set UID on execution
{ - | g }
Toggles the set group ID (GID) bit of the object, as follows:
g
Set GID on execution
-
Do not set GID on execution
{ - | t }
Toggles the sticky bit of the object, as follows:
t
Sticky bit on
-
Sticky bit off

This 4-character token is required for every object.
Mode Represents a string of 3 octal characters defining the read, write, and execute permissions of the object. The Mode token is required of every object. See the chmod command for more information about permissions.
Owner Specifies the UID of the owner of the object. The owner token is required for every object.
Group Specifies the GID of the owner of the object. The group token is required for every object.
Major Minor Specifies the major and minor device numbers of the object if its type is a block or character special file. If the object is not a block or character special file, these tokens are omitted.
SourceFile Applies only to regular file, hard link, and symbolic link objects. For regular files, this token is the path name to the file from which the object file is to be initialized. For both symbolic and hard links, this token is the source of the link. The source of the link is relative to the new file system for hard links.
DirectoryListing Defines the contents of the object if it is a directory. The contents of the directory are defined using the token syntax described here. For example, a directory listing can include one or more regular files, one or more block files, and one or more directory listings. The mkfs command creates the directory entries . (dot) and .. (dot dot). Each directory listing is terminated with the special $ token.
$ Ends the current directory listing or indicates the end of the prototype file.

Example Prototype Specification

The following prototype specification describes a JFS that does not have a boot program in block 0 and occupies the entire device. The 3rd token is ignored. The 4th and 5th tokens define the fragment size as 1024 bytes and the number of bytes per i-node as 2048. The main body of this prototype defines the file system contents.

<noboot> 0 0 1024 2048
d---  755 0 0
 dir1    d--- 755 0 2
  block_dev   b--- 644 0 0   880 881
  char_dev    c--- 644 0 0   990 991
  named_pipe  p--- 644 0 0
  regfile3    ---- 644 0 0   /tmp/proto.examp/dir1/regfile3
  regfile4    ---- 644 0 0   /tmp/proto.examp/dir1/regfile4
  $
 dir2    d--- 755 205 300
  regfile6   ---- 644 0 0    /tmp/proto.examp/dir2/regfile6
  symlnOutofFS l--- 644 0 0  /tmp/proto.examp/dir2/regfile6
  symlnNoExist l--- 644 0 0  /home/foobar
  symlnInFs  l--- 644 0 0    /dir2/regfile6
  regfile5   ---- 644 0 0    /tmp/proto.examp/dir2/regfile5
  hardlink   L--- 644 0 0    /dir2/regfile5
  $
 dir3   d--- 755 0 0
  setgid     --g- 755 0 0    /tmp/proto.examp/dir3/setgid
  setuid     -u-- 755 0 0    /tmp/proto.examp/dir3/setuid
  sticky     ---t 755 0 0    /tmp/proto.examp/dir3/sticky
  $
 dir4   d--- 755 0 0
  dir5  d--- 755 0 0
   dir6 d--- 755 0 0
    $
   dir7 d--- 755 0 0
    $
   $
  regfile7   ---- 644 0 0    /tmp/proto.examp/dir4/regfile7
  $
 regfile1    ---- 555 205 1  /tmp/proto.examp/regfile1
 regfile2    ---- 744 0 0    /tmp/proto.examp/regfile2
 $
$

Three entries for the dir2 object deserve further examination:

dir2 object
Item Description
symlnOutofFS l—- 644 0 0 /tmp/proto.examp/dir2/regfile6 This entry defines a symbolic link to a file outside the file system to be created. The command ls -l lists something similar to symlnOutofFS -> /tmp/proto.examp/dir2/regfile6.
symlnNoExist l—- 644 0 0 /home/foobar This entry defines a symbolic link to a file outside the file system to be created to a file that does not exist. The command ls -l lists something similar to symlnNoExist -> /home/foobar.
symlnInFs l—- 644 0 0 /dir2/regfile6 This entry defines a symbolic link to a file within the file system to be created. The command ls -l lists something similar to symlnInFS -> /dir/regfile6.

Examples

To make a prototype JFS using the prototype file described in the "Example Prototype File Specification" :

  1. Generate the main body of the prototype file using the proto command or a text editor. For the purposes of this example, call the file /tmp/ProtoFile.
  2. Add the first 5 tokens as required for a JFS. In the example prototype file, the tokens are: 
    <noboot> 0 0 1024 2048
  3. Create a logical volume to hold the file system, as follows:

    mklv -y protolv -t jfs SomeVGname 5

    This command creates a logical volume named protolv in the SomeVGname volume group. The size of the logical volume is 5 logical partitions.
  4. Add an appropriate stanza to the /etc/filesystem file. A minimal example stanza is: 
    /protofs:
  dev             = /dev/protolv
  vfs             = jfs
  log             = /dev/loglv00
  mount           = false
  5. Run the following mkproto command: 
    mkproto /dev/protolv /tmp/ProtoFile
    This command creates a JFS on the protolv logical volume. The size of the JFS is 5 logical partitions, its fragment size is 1024 bytes, and its nbpi ratio is 2048. The structure and contents of the file system are as specified in the prototype file /tmp/ProtoFile.

Files

Files
Item Description
/usr/sbin/mkproto Contains the mkproto command.