Return to sys._dir.h CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / ndir / old

Annotation of coherent/b/lib/libc/ndir/old/sys._dir.h, revision 1.1.1.1

1.1       root        1: /*
                      2:        <sys/_dir.h> -- definitions for 4.2,4.3BSD directories
                      3: 
                      4:        last edit:      25-Apr-1987     D A Gwyn
                      5: 
                      6:        A directory consists of some number of blocks of DIRBLKSIZ bytes each,
                      7:        where DIRBLKSIZ is chosen such that it can be transferred to disk in a
                      8:        single atomic operation (e.g., 512 bytes on most machines).
                      9: 
                     10:        Each DIRBLKSIZ-byte block contains some number of directory entry
                     11:        structures, which are of variable length.  Each directory entry has the
                     12:        beginning of a (struct direct) at the front of it, containing its
                     13:        filesystem-unique ident number, the length of the entry, and the length
                     14:        of the name contained in the entry.  These are followed by the NUL-
                     15:        terminated name padded to a (long) boundary with 0 bytes.  The maximum
                     16:        length of a name in a directory is MAXNAMELEN.
                     17: 
                     18:        The macro DIRSIZ(dp) gives the amount of space required to represent a
                     19:        directory entry.  Free space in a directory is represented by entries
                     20:        that have dp->d_reclen > DIRSIZ(dp).  All DIRBLKSIZ bytes in a
                     21:        directory block are claimed by the directory entries; this usually
                     22:        results in the last entry in a directory having a large dp->d_reclen.
                     23:        When entries are deleted from a directory, the space is returned to the
                     24:        previous entry in the same directory block by increasing its
                     25:        dp->d_reclen.  If the first entry of a directory block is free, then
                     26:        its dp->d_fileno is set to 0; entries other than the first in a
                     27:        directory do not normally have  dp->d_fileno set to 0.
                     28: 
                     29:        prerequisite:   <sys/types.h>
                     30: */
                     31: 
                     32: #if defined(accel) || defined(sun) || defined(vax)
                     33: #define        DIRBLKSIZ       512             /* size of directory block */
                     34: #else
                     35: #ifdef alliant
                     36: #define        DIRBLKSIZ       4096            /* size of directory block */
                     37: #else
                     38: #ifdef gould
                     39: #define        DIRBLKSIZ       1024            /* size of directory block */
                     40: #else
                     41: #ifdef ns32000 /* Dynix System V */
                     42: #define        DIRBLKSIZ       2600            /* size of directory block */
                     43: #else  /* be conservative; multiple blocks are okay but fractions are not */
                     44: #define        DIRBLKSIZ       4096            /* size of directory block */
                     45: #endif
                     46: #endif
                     47: #endif
                     48: #endif
                     49: 
                     50: #define        MAXNAMELEN      255             /* maximum filename length */
                     51: /* NOTE:  not MAXNAMLEN, which has been preempted by SVR3 <dirent.h> */
                     52: 
                     53: struct direct                          /* data from read()/_getdirentries() */
                     54:        {
                     55:        unsigned long   d_fileno;       /* unique ident of entry */
                     56:        unsigned short  d_reclen;       /* length of this record */
                     57:        unsigned short  d_namlen;       /* length of string in d_name */
                     58:        char            d_name[MAXNAMELEN+1];   /* NUL-terminated filename */
                     59:        /* typically shorter */
                     60:        };
                     61: 
                     62: /*
                     63:        The DIRSIZ macro gives the minimum record length which will hold the
                     64:        directory entry.  This requires the amount of space in a (struct
                     65:        direct) without the d_name field, plus enough space for the name with a
                     66:        terminating NUL character, rounded up to a (long) boundary.
                     67: 
                     68:        (Note that Berkeley didn't properly compensate for struct padding,
                     69:        but we nevertheless have to use the same size as the actual system.)
                     70: */
                     71: 
                     72: #define        DIRSIZ( dp )    ((sizeof(struct direct) - (MAXNAMELEN+1) \
                     73:                        + sizeof(long) + (dp)->d_namlen) \
                     74:                        / sizeof(long) * sizeof(long))

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