Return to dir.5 CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / man / man5

Annotation of cci/usr/src/man/man5/dir.5, revision 1.1.1.1

1.1       root        1: .TH DIR 5  "15 January 1983"
                      2: .UC 4
                      3: .SH NAME
                      4: dir \- format of directories
                      5: .SH SYNOPSIS
                      6: .B #include <sys/types.h>
                      7: .br
                      8: .B #include <sys/dir.h>
                      9: .SH DESCRIPTION
                     10: A directory behaves exactly like an ordinary file, save that no
                     11: user may write into a directory.
                     12: The fact that a file is a directory is indicated by
                     13: a bit in the flag word of its i-node entry; see
                     14: .IR fs (5).
                     15: The structure of a directory entry as given in the include file is:
                     16: .RS
                     17: .ta 8n +10n +10n
                     18: .PP
                     19: .nf
                     20: /*
                     21:  * A directory consists of some number of blocks of
                     22:  * DIRBLKSIZ bytes, where DIRBLKSIZ is chosen such that
                     23:  * it can be transferred to disk in a single atomic
                     24:  * operation (e.g. 512 bytes on most machines).
                     25:  * 
                     26:  * Each DIRBLKSIZ byte block contains some number of
                     27:  * directory entry structures, which are of variable
                     28:  * length.  Each directory entry has a struct direct at
                     29:  * the front of it, containing its inode number, the
                     30:  * length of the entry, and the length of the name con-
                     31:  * tained in the entry.  These are followed by the name
                     32:  * padded to a 4 byte boundary with null bytes.  All
                     33:  * names are guaranteed null terminated.  The maximum
                     34:  * length of a name in a directory is MAXNAMLEN.  The
                     35:  * macro DIRSIZ(dp) gives the amount of space required
                     36:  * to represent a directory entry.  Free space in a
                     37:  * directory is represented by entries which have dp-
                     38:  * >d_reclen > DIRSIZ(dp).  All DIRBLKSIZ bytes in a
                     39:  * directory block are claimed by the directory en-
                     40:  * tries.  This usually results in the last entry in a
                     41:  * directory having a large dp->d_reclen.  When entries
                     42:  * are deleted from a directory, the space is returned
                     43:  * to the previous entry in the same directory block by
                     44:  * increasing its dp->d_reclen.  If the first entry of
                     45:  * a directory block is free, then its dp->d_ino is set
                     46:  * to 0.  Entries other than the first in a directory
                     47:  * do not normally have dp->d_ino set to 0.
                     48:  */
                     49: #ifdef KERNEL
                     50: #define DIRBLKSIZ DEV_BSIZE
                     51: #else
                     52: #define        DIRBLKSIZ 512
                     53: #endif
                     54: 
                     55: #define MAXNAMLEN 255
                     56: 
                     57: /*
                     58:  * The DIRSIZ macro gives the minimum record length
                     59:  * which will hold the directory entry.  This requires
                     60:  * the amount of space in struct direct without the
                     61:  * d_name field, plus enough space for the name with a
                     62:  * terminating null byte (dp->d_namlen+1), rounded up
                     63:  * to a 4 byte boundary.
                     64:  */
                     65: #undef DIRSIZ
                     66: #define DIRSIZ(dp) \e
                     67:     ((sizeof (struct direct) - (MAXNAMLEN+1)) + \e
                     68:     (((dp)->d_namlen+1 + 3) &~ 3))
                     69: 
                     70: struct direct {
                     71:        u_long  d_ino;
                     72:        short   d_reclen;
                     73:        short   d_namlen;
                     74:        char    d_name[MAXNAMLEN + 1];
                     75:        /* typically shorter */
                     76: };
                     77: 
                     78: struct _dirdesc {
                     79:        int     dd_fd;
                     80:        long    dd_loc;
                     81:        long    dd_size;
                     82:        char    dd_buf[DIRBLKSIZ];
                     83: };
                     84: .fi
                     85: .RE
                     86: .PP
                     87: By convention, the first two entries in each directory
                     88: are for `.' and `..'.  The first is an entry for the
                     89: directory itself.  The second is for the parent directory.
                     90: The meaning of `..' is modified for the root directory
                     91: of the master file system (\*(lq/\*(rq),
                     92: where `..' has the same meaning as `.'.
                     93: .SH "SEE ALSO"
                     94: fs(5)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.