Add printf format checks to util's log functions
[openafs.git] / src / viced / callback.h
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  *
9  * Portions Copyright (c) 2006 Sine Nomine Associates
10  */
11
12 #ifndef _AFS_VICED_CALLBACK_H
13 #define _AFS_VICED_CALLBACK_H
14
15 /* Maximum number of call backs to break at once, single fid
16  * There is some debate as to just how large this value should be
17  * Ideally, it would be very very large, but I am afraid that the
18  * cache managers will all send in their responses simultaneously,
19  * thereby swamping the file server.  As a result, something like
20  * 10 or 15 might be a better bet.
21  */
22 #define MAX_CB_HOSTS    10
23
24 /* max time to break a callback, otherwise client is dead or net is hosed */
25 #define MAXCBT 25
26
27 #define u_byte  unsigned char
28
29 struct cbcounters {
30     afs_int32 DeleteFiles;
31     afs_int32 DeleteCallBacks;
32     afs_int32 BreakCallBacks;
33     afs_int32 AddCallBacks;
34     afs_int32 GotSomeSpaces;
35     afs_int32 DeleteAllCallBacks;
36     afs_int32 nFEs, nCBs, nblks;
37     afs_int32 CBsTimedOut;
38     afs_int32 nbreakers;
39     afs_int32 GSS1, GSS2, GSS3, GSS4, GSS5;
40 };
41 extern struct cbcounters cbstuff;
42
43 struct cbstruct {
44     struct host *hp;
45     afs_uint32 thead;
46 };
47
48 /* structure MUST be multiple of 8 bytes, otherwise the casts to
49  * struct object will have alignment issues on *P64 userspaces */
50 struct FileEntry {
51     afs_uint32 vnode;
52     afs_uint32 unique;
53     afs_uint32 volid;
54     afs_uint32 fnext;           /* index of next FE in hash chain */
55     afs_uint32 ncbs;            /* number of callbacks for this FE */
56     afs_uint32 firstcb;         /* index of first cb in per-FE list */
57     afs_uint32 status;          /* status bits for this FE */
58     afs_uint32 spare;
59 };
60 #define FE_LATER 0x1
61
62 /* structure MUST be multiple of 8 bytes, otherwise the casts to
63  * struct object will have alignment issues on *P64 userspaces */
64 struct CallBack {
65     afs_uint32 cnext;           /* index of next cb in per-FE list */
66     afs_uint32 fhead;           /* index of associated FE */
67     u_byte thead;               /* Head of timeout chain */
68     u_byte status;              /* Call back status; see definitions, below */
69     unsigned short spare;       /* ensure proper alignment */
70     afs_uint32 hhead;           /* Head of host table chain */
71     afs_uint32 tprev, tnext;    /* per-timeout circular list of callbacks */
72     afs_uint32 hprev, hnext;    /* per-host circular list of callbacks */
73 };
74
75 struct VCBParams {
76     struct cbstruct cba[MAX_CB_HOSTS];  /* re-entrant storage */
77     unsigned int ncbas;
78     afs_uint32 thead;           /* head of timeout queue for youngest callback */
79     struct AFSFid *fid;
80 };
81
82
83 /* callback hash macros */
84 #define FEHASH_SIZE 512         /* Power of 2 */
85 #define FEHASH_MASK (FEHASH_SIZE-1)
86 #define FEHash(volume, unique) (((volume)+(unique))&(FEHASH_MASK))
87
88 #define CB_NUM_TIMEOUT_QUEUES 128
89
90
91 /* status values for status field of CallBack structure */
92 #define CB_NORMAL   1           /* Normal call back */
93 #define CB_DELAYED  2           /* Delayed call back due to rpc problems.
94                                  * The call back entry will be added back to the
95                                  * host list at the END of the list, so that
96                                  * searching backwards in the list will find all
97                                  * the (consecutive)host. delayed call back entries */
98 #define CB_VOLUME   3           /* Callback for a volume */
99 #define CB_BULK     4           /* Normal callbacks, handed out from FetchBulkStatus */
100
101 /* call back indices to pointers, and vice-versa */
102 #define itocb(i)    ((i)?CB+(i):0)
103 #define cbtoi(cbp)  ((afs_uint32)(!(cbp)?0:(cbp)-CB))
104
105 /* file entry indices to pointers, and vice-versa */
106 #define itofe(i)    ((i)?FE+(i):0)
107 #define fetoi(fep)  ((afs_uint32)(!(fep)?0:(fep)-FE))
108
109 /* Timeouts:  there are 128 possible timeout values in effect at any
110  * given time.  Each timeout represents timeouts in an interval of 128
111  * seconds.  So the maximum timeout for a call back is 128*128=16384
112  * seconds, or 4 1/2 hours.  The timeout cleanup stuff is called only
113  * if space runs out or by the file server every 5 minutes.  This 5
114  * minute slack should be allowed for--so a maximum time of 4 hours
115  * is safer.
116  *
117  * Timeouts must be chosen to correspond to an exact multiple
118  * of 128, because all times are truncated to a 128 multiple, and
119  * timed out if the current truncated time is <= to the truncated time
120  * corresponding to the timeout queue.
121  */
122
123 /* Unix time to Call Back time, and vice-versa.  Call back time is
124    in units of 128 seconds, corresponding to time queues. */
125 #define CBtime(uxtime)  ((uxtime)>>7)
126 #define UXtime(cbtime)  ((cbtime)<<7)
127
128 /* Given a Unix time, compute the closest Unix time that corresponds to
129    a time queue, rounding up */
130 #define TimeCeiling(uxtime)     (((uxtime)+127)&~127)
131
132 #define TimeOutCutoff   ((sizeof(TimeOuts)/sizeof(TimeOuts[0]))*8)
133 #define TimeOut(nusers)  ((nusers)>=TimeOutCutoff? MinTimeOut: TimeOuts[(nusers)>>3])
134
135 /* time out at server is 3 minutes more than ws */
136 #define ServerBias        (3*60)
137
138 /* Convert cbtime to timeout queue index */
139 #define TIndex(cbtime)  (((cbtime)&127)+1)
140
141 /* Convert cbtime to pointer to timeout queue head */
142 #define THead(cbtime)   (&timeout[TIndex(cbtime)-1])
143
144 /* Normalize index into timeout array so that two such indices will be
145    ordered correctly, so that they can be compared to see which times
146    sooner, or so that the difference in time out times between them
147    can be computed. */
148 #define TNorm(index)   ((index)<TIndex(tfirst)?(index)+128:(index))
149
150 /* This converts a timeout index into the actual time it will expire */
151 #define TIndexToTime(index) (UXtime(TNorm(index) - TIndex(tfirst) + tfirst))
152
153
154 /* Convert pointer to timeout queue head to index, and vice versa */
155 #define ttoi(t)         ((t-timeout)+1)
156 #define itot(i)         ((timeout)+(i-1))
157
158 #endif /* _AFS_VICED_CALLBACK_H */