xrootd
XrdCnsLogRec.hh
Go to the documentation of this file.
1 #ifndef __XRDCnsLogRec_H_
2 #define __XRDCnsLogRec_H_
3 /******************************************************************************/
4 /* */
5 /* X r d C n s L o g R e c . h h */
6 /* */
7 /* (c) 2009 by the Board of Trustees of the Leland Stanford, Jr., University */
8 /* All Rights Reserved */
9 /* Produced by Andrew Hanushevsky for Stanford University under contract */
10 /* DE-AC02-76-SFO0515 with the Department of Energy */
11 /******************************************************************************/
12 
13 // $Id$
14 
15 #include <stddef.h>
16 #include <stdio.h>
17 #include <string.h>
18 #include <time.h>
19 #include <sys/param.h>
20 #include <sys/types.h>
21 
22 #include "XrdSys/XrdSysPlatform.hh"
23 #include "XrdSys/XrdSysPthread.hh"
24 
25 class XrdCnsLogRec
26 {
27 public:
28 
29 static const int maxClients = 4;
30 
31 struct Ctl
32  {short dataLen; // Length of data in Arg (eof when 0)
33  short lfn1Len; // strlen(lfn1)
34  short lfn2Len; // strlen(lfn2)
35  short Mode; // File mode (create and mkdir)
36  char Done[maxClients]; // 1->Record processed
37  int Rsvd; // Reserved field
38  long long Size; // Valid when Closew
39  };
40 
41 struct Arg
42  {char Type; // Event code
43  char Mode[3]; // Mode (create, inv, mkdir)
44  char SorT[12]; // Size (closew, inv) | TOD (eol)
45  char Mount; // Mount Index
46  char Space; // Space Index
47  char Rsvd[6]; // Reserved (blank filled)
48  char lfn[MAXPATHLEN*2+3]; // lfn1 [lfn2] \n
49  };
50 
51 struct LogRec
52  {struct Ctl Hdr;
53  struct Arg Data;
54  };
55 
56 static const int OffDone = offsetof(LogRec, Hdr.Done);
57 static const int FixDLen = offsetof(Arg, lfn);
58 static const int MinSize = sizeof(Ctl); // Header
59 static const int MaxSize = sizeof(Arg); // Data
60 static const long tBase = 1248126834L;
61 
62 static const char lrClosew = 't';
63 static const char lrCreate = 'c';
64 static const char lrEOL = 'E'; // Internal
65 static const char lrInvD = 'I'; // Internal dir inventory
66 static const char lrInvF = 'i'; // Internal file inventory
67 static const char lrMkdir = 'd';
68 static const char lrMount = 'M'; // Internal Mount inventory
69 static const char lrMv = 'm';
70 static const char lrRm = 'r';
71 static const char lrRmdir = 'D';
72 static const char lrSpace = 'S'; // Internal Space inventory
73 static const char lrTOD = 'T'; // Internal TOD
74 
75 static const char *IArg;
76 static const char *iArg;
77 
78 static XrdCnsLogRec *Alloc();
79 
80 inline const char *Data() {return (const char *)&Rec.Data;}
81 
82 inline int DLen() {return Rec.Hdr.dataLen;}
83 
84 inline int Done(int iPos) {return Rec.Hdr.Done[iPos];}
85 
86 static XrdCnsLogRec *Get(char &lrType);
87 
88 inline const char *Lfn1() {return Rec.Data.lfn;}
89 
90 inline const char *Lfn1(int &Len) {Len=Rec.Hdr.lfn1Len; return Rec.Data.lfn;}
91 
92 inline const char *Lfn2() {return Rec.Data.lfn+Rec.Hdr.lfn1Len+1;}
93 
94 inline mode_t Mode() {return static_cast<mode_t>(Rec.Hdr.Mode);}
95 
96  void Queue();
97 
98  void Recycle();
99 
100 inline char *Record() {return (char *)&Rec;}
101 
102 // setLfn1() must be called prior to calling setLfn2() or setData()
103 //
104  int setData(const char *dP1, const char *dP2=0);
105 
106  void setDone(int iPos, char Val=1) {Rec.Hdr.Done[iPos] = Val;}
107 
108  int setLen() {if (Rec.Hdr.lfn1Len)
109  {Rec.Hdr.dataLen = FixDLen+Rec.Hdr.lfn1Len+1;
110  if (Rec.Hdr.lfn2Len)
111  Rec.Hdr.dataLen += Rec.Hdr.lfn2Len+1;
112  } else Rec.Hdr.dataLen = 0;
113  return static_cast<int>(Rec.Hdr.dataLen);
114  }
115 
116 inline int setLfn1(const char *lfn)
117  {int n;
118  n = strlcpy(Rec.Data.lfn, lfn, MAXPATHLEN+1);
119  if (n > MAXPATHLEN) return 0;
120  Rec.Hdr.lfn1Len = n;
121  return n;
122  }
123 
124 inline int setLfn2(const char *lfn)
125  {int n;
126  setSize(static_cast<long long>(Rec.Hdr.lfn1Len));
127  n = strlcpy(Rec.Data.lfn + Rec.Hdr.lfn1Len + 1,
128  lfn, MAXPATHLEN+1);
129  if (n > MAXPATHLEN) return 0;
130  Rec.Hdr.lfn2Len = n;
131  return n;
132  }
133 
134 inline void setMode(mode_t Mode) {char Save = *Rec.Data.SorT;
135  Rec.Hdr.Mode = Mode;
136  snprintf(Rec.Data.Mode,
137  sizeof(Rec.Data.Mode), "%03o",
138  511 & static_cast<int>(Mode));
139  *Rec.Data.SorT = Save;
140  }
141 
142 inline void setMount(char mCode) {Rec.Data.Mount = mCode;}
143 
144 inline void setSize(long long Size) {char Save = Rec.Data.Mount;
145  Rec.Hdr.Size = Size;
146  snprintf(Rec.Data.SorT,
147  sizeof(Rec.Data.SorT), "%12lld",
148  (Size > 0 ? Size & 0x7fffffffffLL
149  : Size));
150  Rec.Data.Mount = Save;
151  }
152 
153 inline void setSpace(char sCode) {Rec.Data.Space = sCode;}
154 
155 inline void setTime(long TOD=time(0)){char Save = Rec.Data.Mount;
156  snprintf(Rec.Data.SorT,
157  sizeof(Rec.Data.SorT), "%12ld",
158  TOD-tBase);
159  Rec.Data.Mount = Save;
160  }
161 
162 inline void setType(const char evt) {Rec.Data.Type = evt;}
163 
164  int setType(const char *evt);
165 
166 inline long long Size() {return Rec.Hdr.Size;}
167 
168 inline char Space(){return Rec.Data.Space;}
169 
170 inline int L1sz() {return Rec.Hdr.lfn1Len;}
171 
172 inline int L2sz() {return Rec.Hdr.lfn2Len;}
173 
174  char Type() {return Rec.Data.Type;}
175 
176  XrdCnsLogRec(const char rType=0) : Next(0)
177  {memset(&Rec, 0, sizeof(Rec.Hdr));
178  memset(&Rec.Data,' ', FixDLen);
179  Rec.Data.Type = rType;
180  if (rType == lrEOL || rType == lrTOD)
181  {setTime();
182  Rec.Hdr.dataLen=FixDLen;
183  if (rType == lrTOD)
184  {Rec.Data.lfn[0] = ' ';
185  Rec.Data.lfn[1] = '\0';
186  Rec.Hdr.lfn1Len = 1;
187  }
188  }
189  }
190  ~XrdCnsLogRec() {}
191 
192 private:
193 
194 static XrdSysSemaphore qSem;
195 static XrdSysMutex qMutex;
196 static XrdSysMutex fMutex;
197 static XrdCnsLogRec *freeRec;
198 static XrdCnsLogRec *frstRec;
199 static XrdCnsLogRec *lastRec;
200 static int Running;
201 
202 XrdCnsLogRec *Next;
203  LogRec Rec;
204 };
205 #endif
Generated by   doxygen 1.8.1.2