Loading...
Searching...
No Matches
jfs_types.h File Reference

Go to the source code of this file.

## Data Structures

struct | cdll_entry
struct | cdll_header
struct | component_name
struct | dasd
struct | dxd_t
struct | lxd_t
struct | lxdlist_t
struct | pxd_t
struct | pxdlist_t
struct | timestruc_t

## Macros

#define | _ULS_UNICHAR_DEFINED
#define | addressDXD addressPXD
#define | addressPXD(pxd)
#define | CDLL_ENTRY(type)
#define | CDLL_HEADER(type)
#define | CDLL_INIT(header)
#define | CDLL_INSERT_AFTER(header, listelm, elm, field)
#define | CDLL_INSERT_BEFORE(header, listelm, elm, field)
#define | CDLL_INSERT_HEAD(header, elm, field)
#define | CDLL_INSERT_TAIL(header, elm, field)
#define | CDLL_MOVE_TO_HEAD(header, elm, field)
#define | CDLL_MOVE_TO_TAIL(header, elm, field)
#define | CDLL_REMOVE(header, elm, field)
#define | CDLL_SELF(elm, field)
#define | DASDLIMIT(dasdp)
#define | DASDUSED(dasdp)
#define | DXD_CORRUPT 0x08 /* Inconsistency detected */
#define | DXD_EXTENT 0x20 /* out-of-line single extent */
#define | DXD_FILE 0x10 /* out-of-line file (inode) */
#define | DXD_INDEX 0x80 /* B+-tree index */
#define | DXD_INLINE 0x40 /* in-line data extent */
#define | DXDaddress PXDaddress
#define | DXDlength PXDlength
#define | FALSE 0
#define | HIGHORDER 0x80000000u /* high order bit on */
#define | LEFTMOSTONE 0x80000000
#define | lengthDXD lengthPXD
#define | lengthLXD(lxd)
#define | lengthPXD(pxd)
#define | LIST_ENTRY(type)
#define | LIST_HEADER(type)
#define | LIST_INIT(header)
#define | LIST_INSERT_AFTER(listelm, elm, field)
#define | LIST_INSERT_HEAD(header, elm, field)
#define | LIST_REMOVE(elm, field)
#define | LIST_SELF(elm, field)
#define | LXDlength(lxd, length32)
#define | LXDoffset(lxd, offset64)
#define | MAX(a, b)
#define | MAXPATHLEN 255
#define | MIN(a, b)
#define | offsetLXD(lxd)
#define | ONES 0xffffffffu /* all bit on */
#define | PXDaddress(pxd, address64)
#define | PXDlength(pxd, length32)
#define | ROUNDUP(x, y)
#define | setDASDLIMIT(dasdp, limit)
#define | setDASDUSED(dasdp, used)
#define | TRUE 1

## Typedefs

typedef int | boolean_t
typedef struct component_name | component_t
typedef struct dasd | dasd_t
typedef void * | PVOID
typedef unsigned char | UCHAR
typedef unsigned long | ULONG
typedef unsigned short | UniChar
typedef unsigned short | USHORT

## Macro Definition Documentation

## _ULS_UNICHAR_DEFINED

#define _ULS_UNICHAR_DEFINED

## addressDXD

#define addressDXD addressPXD

## addressPXD

#define addressPXD | ( |  | pxd | ) |

Value:
( ((s64)((pxd)->addr1)) << 32 | __le32_to_cpu((pxd)->addr2))

## CDLL_ENTRY

#define CDLL_ENTRY | ( |  | type | ) |

Value:
struct {\
struct type *next;\
struct type *prev;\
}
type
uint8_t type
Definition dos.c:2

## CDLL_HEADER

#define CDLL_HEADER | ( |  | type | ) |

Value:
struct {\
struct type *head;\
struct type *tail;\
}
head
uint8_t head
Definition pc98.c:8

## CDLL_INIT

#define CDLL_INIT | ( |  | header | ) |

Value:
{\
(header)->head = (void *)(header);\
(header)->tail = (void *)(header);\
}

## CDLL_INSERT_AFTER

#define CDLL_INSERT_AFTER | ( |  | header,
|  |  | listelm,
|  |  | elm,
|  |  | field )

Value:
{\
(elm)->field.next = (listelm)->field.next;\
(elm)->field.prev = (listelm);\
if ((listelm)->field.next == (void *)(header))\
(header)->tail = (elm);\
else\
(listelm)->field.next->field.prev = (elm);\
(listelm)->field.next = (elm);\
}

## CDLL_INSERT_BEFORE

#define CDLL_INSERT_BEFORE | ( |  | header,
|  |  | listelm,
|  |  | elm,
|  |  | field )

Value:
{\
(elm)->field.next = (listelm);\
(elm)->field.prev = (listelm)->field.prev;\
if ((listelm)->field.prev == (void *)(header))\
(header)->head = (elm);\
else\
(listelm)->field.prev->field.next = (elm);\
(listelm)->field.prev = (elm);\
}

## CDLL_INSERT_HEAD

#define CDLL_INSERT_HEAD | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
(elm)->field.next = (header)->head;\
(elm)->field.prev = (void *)(header);\
if ((header)->tail == (void *)(header))\
(header)->tail = (elm);\
else\
(header)->head->field.prev = (elm);\
(header)->head = (elm);\
}

## CDLL_INSERT_TAIL

#define CDLL_INSERT_TAIL | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
(elm)->field.next = (void *)(header);\
(elm)->field.prev = (header)->tail;\
if ((header)->head == (void *)(header))\
(header)->head = (elm);\
else\
(header)->tail->field.next = (elm);\
(header)->tail = (elm);\
}

## CDLL_MOVE_TO_HEAD

#define CDLL_MOVE_TO_HEAD | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
if ((elm)->field.prev != (void *)(header))\
{\
if ((elm)->field.next == (void *)(header))\
(header)->tail = (elm)->field.prev;\
else\
(elm)->field.next->field.prev = (elm)->field.prev;\
(elm)->field.prev->field.next = (elm)->field.next;\
(elm)->field.next = (header)->head;\
(elm)->field.prev = (void *)(header);\
(header)->head->field.prev = (elm);\
(header)->head = (elm);\
}\
}

## CDLL_MOVE_TO_TAIL

#define CDLL_MOVE_TO_TAIL | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
if ((elm)->field.next != (void *)(header))\
{\
(elm)->field.next->field.prev = (elm)->field.prev;\
if ((elm)->field.prev == (void *)(header))\
(header)->head = (elm)->field.next;\
else\
(elm)->field.prev->field.next = (elm)->field.next;\
(elm)->field.next = (void *)(header);\
(elm)->field.prev = (header)->tail;\
(header)->tail->field.next = (elm);\
(header)->tail = (elm);\
}\
}

## CDLL_REMOVE

#define CDLL_REMOVE | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
if ((elm)->field.next == (void *)(header))\
(header)->tail = (elm)->field.prev;\
else\
(elm)->field.next->field.prev = (elm)->field.prev;\
if ((elm)->field.prev == (void *)(header))\
(header)->head = (elm)->field.next;\
else\
(elm)->field.prev->field.next = (elm)->field.next;\
}

## CDLL_SELF

#define CDLL_SELF | ( |  | elm,
|  |  | field )

Value:
(elm)->field.next = (elm)->field.prev = (elm);

## DASDLIMIT

#define DASDLIMIT | ( |  | dasdp | ) |

Value:
(((u64)((dasdp)->limit_hi) << 32) + __le32_to_cpu((dasdp)->limit_lo))

## DASDUSED

#define DASDUSED | ( |  | dasdp | ) |

Value:
(((u64)((dasdp)->used_hi) << 32) + __le32_to_cpu((dasdp)->used_lo))

## DXD_CORRUPT

#define DXD_CORRUPT 0x08 /* Inconsistency detected */

## DXD_EXTENT

#define DXD_EXTENT 0x20 /* out-of-line single extent */

## DXD_FILE

#define DXD_FILE 0x10 /* out-of-line file (inode) */

## DXD_INDEX

#define DXD_INDEX 0x80 /* B+-tree index */

## DXD_INLINE

#define DXD_INLINE 0x40 /* in-line data extent */

## DXDaddress

#define DXDaddress PXDaddress

## DXDlength

#define DXDlength PXDlength

## FALSE

#define FALSE 0

## HIGHORDER

#define HIGHORDER 0x80000000u /* high order bit on */

## LEFTMOSTONE

#define LEFTMOSTONE 0x80000000

## lengthDXD

#define lengthDXD lengthPXD

## lengthLXD

#define lengthLXD | ( |  | lxd | ) |

Value:
( (lxd)->len )

## lengthPXD

#define lengthPXD | ( |  | pxd | ) |

Value:
__le24_to_cpu((pxd)->len)

## LIST_ENTRY

#define LIST_ENTRY | ( |  | type | ) |

Value:
struct {\
struct type *next;\
struct type **prev;\
}

## LIST_HEADER

#define LIST_HEADER | ( |  | type | ) |

Value:
struct {\
struct type *head;\
}

## LIST_INIT

#define LIST_INIT | ( |  | header | ) |

Value:
{ (header)->head = NULL; }

## LIST_INSERT_AFTER

#define LIST_INSERT_AFTER | ( |  | listelm,
|  |  | elm,
|  |  | field )

Value:
{\
if (((elm)->field.next = (listelm)->field.next) != NULL)\
(listelm)->field.next->field.prev = &(elm)->field.next;\
(listelm)->field.next = (elm);\
(elm)->field.prev = &(listelm)->field.next;\
}

## LIST_INSERT_HEAD

#define LIST_INSERT_HEAD | ( |  | header,
|  |  | elm,
|  |  | field )

Value:
{\
if (((elm)->field.next = (header)->head) != NULL)\
(header)->head->field.prev = &(elm)->field.next;\
(header)->head = (elm);\
(elm)->field.prev = &(header)->head;\
}

## LIST_REMOVE

#define LIST_REMOVE | ( |  | elm,
|  |  | field )

Value:
{\
if ((elm)->field.next != NULL)\
(elm)->field.next->field.prev = (elm)->field.prev;\
*(elm)->field.prev = (elm)->field.next;\
}

## LIST_SELF

#define LIST_SELF | ( |  | elm,
|  |  | field )

Value:
{\
(elm)->field.next = NULL;\
(elm)->field.prev = &(elm)->field.next;\
}

## LXDlength

#define LXDlength | ( |  | lxd,
|  |  | length32 )

Value:
( (lxd)->len = length32 )

## LXDoffset

#define LXDoffset | ( |  | lxd,
|  |  | offset64 )

Value:
{\
(lxd)->off1 = ((s64)offset64) >> 32;\
(lxd)->off2 = (offset64) & 0xffffffff;\
}

## MAX

#define MAX | ( |  | a,
|  |  | b )

Value:
(((a)>(b))?(a):(b))

## MAXPATHLEN

#define MAXPATHLEN 255

## MIN

#define MIN | ( |  | a,
|  |  | b )

Value:
(((a)<(b))?(a):(b))

## offsetLXD

#define offsetLXD | ( |  | lxd | ) |

Value:
( ((s64)((lxd)->off1)) << 32 | (lxd)->off2 )

## ONES

#define ONES 0xffffffffu /* all bit on */

## PXDaddress

#define PXDaddress | ( |  | pxd,
|  |  | address64 )

Value:
{\
(pxd)->addr1 = ((s64)address64) >> 32;\
(pxd)->addr2 = __cpu_to_le32((address64) & 0xffffffff);\
}

## PXDlength

#define PXDlength | ( |  | pxd,
|  |  | length32 )

Value:
((pxd)->len = __cpu_to_le24(length32))

## ROUNDUP

#define ROUNDUP | ( |  | x,
|  |  | y )

Value:
( ((x) + ((y) - 1)) & ~((y) - 1) )

## setDASDLIMIT

#define setDASDLIMIT | ( |  | dasdp,
|  |  | limit )

Value:
{\
(dasdp)->limit_hi = ((u64)limit) >> 32;\
(dasdp)->limit_lo = __cpu_to_le32(limit);\
}

## setDASDUSED

#define setDASDUSED | ( |  | dasdp,
|  |  | used )

Value:
{\
(dasdp)->used_hi = ((u64)used) >> 32;\
(dasdp)->used_lo = __cpu_to_le32(used);\
}

## TRUE

#define TRUE 1

## Typedef Documentation

## boolean_t

typedef int boolean_t

## component_t

typedef struct component_name component_t

## dasd_t

typedef struct dasd dasd_t

## PVOID

typedef void* PVOID

## UCHAR

typedef unsigned char UCHAR

## ULONG

typedef unsigned long ULONG

## UniChar

typedef unsigned short UniChar

## USHORT

typedef unsigned short USHORT