generic: test file writers racing with FIDEDUPERANGE
[xfstests-dev.git] / include / write_log.h
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #ifndef _WRITE_LOG_H_
7 #define _WRITE_LOG_H_
8
9 /*
10  * Constants defining the max size of various wlog_rec fields.  ANY SIZE
11  * CHANGES HERE MUST BE REFLECTED IN THE WLOG_REC_DISK STRUCTURE DEFINED
12  * BELOW.
13  */
14
15 #define WLOG_MAX_PATH           128
16 #define WLOG_MAX_PATTERN        64
17 #define WLOG_MAX_HOST           8
18 #define WLOG_REC_MAX_SIZE       (sizeof(struct wlog_rec)+WLOG_MAX_PATH+WLOG_MAX_PATTERN+WLOG_MAX_HOST+2)
19
20 /*
21  * User view of a write log record.  Note that this is not necessiliary
22  * how the data is formatted on disk (signifigant compression occurrs), so
23  * don't expect to od the write log file and see things formatted this way.
24  */
25
26 struct wlog_rec {
27     int     w_pid;          /* pid doing the write          */
28     int     w_offset;       /* file offset                  */
29     int     w_nbytes;       /* # bytes written              */
30     int     w_oflags;       /* low-order open() flags       */
31     int     w_done;         /* 1 if io confirmed done       */
32     int     w_async;        /* 1 if async write (writea)    */
33
34     char    w_host[WLOG_MAX_HOST+1];            /* host doing write -   */
35                                                 /* null terminated */
36     int     w_hostlen;                          /* host name length     */
37     char    w_path[WLOG_MAX_PATH+1];            /* file written to -    */
38                                                 /* null terminated */
39     int     w_pathlen;                          /* file name length     */
40     char    w_pattern[WLOG_MAX_PATTERN+1];      /* pattern written -    */
41                                                 /* null terminated */
42     int     w_patternlen;                       /* pattern length       */
43 };
44
45 #ifndef uint
46 #define uint    unsigned int
47 #endif
48
49 /*
50  * On-disk structure of a wlog_rec.  Actually, the record consists of
51  * 3 parts:  [wlog_rec_disk structure][variable length data][length]
52  * where length is a 2 byte field containing the total record length
53  * (including the 2 bytes).  It is used for scanning the logfile in reverse
54  * order.
55  *
56  * The variable length data includes the path, host, and pattern (in that
57  * order).  The lengths of these pieces of data are held in the
58  * wlog_rec_disk structure.  Thus, the actual on-disk record looks like
59  * this (top is lower byte offset):
60  *
61  *              struct wlog_rec_disk
62  *              path    (w_pathlen bytes - not null terminated)
63  *              host    (w_hostlen bytes - not null terminated)
64  *              pattern (w_patternlen bytes - not null terminated)
65  *              2-byte record length
66  *
67  * Another way of looking at it is:
68  *
69  * <struct wlog_rec_disk><path (wpathlen bytes)>-->
70  * --><host (w_hostlen bytes)><pattern (w_patternlen bytes)><length (2 bytes)>
71  *
72  * The maximum length of this record is defined by the WLOG_REC_MAX_SIZE
73  * record.  Note that the 2-byte record length forces this to be
74  * <= 64k bytes.
75  *
76  * Note that there is lots of bit-masking done here.  The w_pathlen,
77  * w_hostlen, and w_patternlen fields MUST have enough bits to hold
78  * WLOG_MAX_PATH, WLOG_MAX_HOST, and WLOG_MAX_PATTERN bytes respectivly.
79  */
80
81 struct wlog_rec_disk {
82 #ifdef linux
83     uint    w_offset    : 32;       /* file offset                  */
84     uint    w_extra0    : 32;       /* EXTRA BITS IN WORD 0         */
85 #endif
86
87     uint    w_nbytes    : 32;       /* # bytes written              */
88     uint    w_oflags    : 32;       /* low-order open() flags       */
89
90     uint    w_pid       : 17;       /* pid doing the write          */
91     uint    w_pathlen   :  7;       /* length of file path          */
92     uint    w_patternlen:  6;       /* length of pattern            */
93     uint    w_hostlen   :  4;       /* length of host               */
94     uint    w_done      :  1;       /* 1 if io confirmed done       */
95     uint    w_async     :  1;       /* 1 if async write (writea)    */
96     uint    w_extra2    : 28;       /* EXTRA BITS IN WORD 2         */
97 };
98
99 /*
100  * write log file datatype.  wlog_open() initializes this structure
101  * which is then passed around to the various wlog_xxx routines.
102  */
103
104 struct wlog_file {
105     int         w_afd;                  /* append fd                    */
106     int         w_rfd;                  /* random-access fd             */
107     char        w_file[1024];           /* name of the write_log        */
108 };
109
110 /*
111  * return value defines for the user-supplied function to
112  * wlog_scan_backward().
113  */
114
115 #define WLOG_STOP_SCAN          0
116 #define WLOG_CONTINUE_SCAN      1
117
118 /*
119  * wlog prototypes
120  */
121
122 #if __STDC__
123 extern int      wlog_open(struct wlog_file *wfile, int trunc, int mode);
124 extern int      wlog_close(struct wlog_file *wfile);
125 extern int      wlog_record_write(struct wlog_file *wfile,
126                                   struct wlog_rec *wrec, long offset);
127 extern int      wlog_scan_backward(struct wlog_file *wfile, int nrecs,
128                                    int (*func)(struct wlog_rec *rec),
129                                    long data);
130 #else
131 int     wlog_open();
132 int     wlog_close();
133 int     wlog_record_write();
134 int     wlog_scan_backward();
135 #endif
136
137 extern char     Wlog_Error_String[];
138
139 #endif /* _WRITE_LOG_H_ */
140