windows-updatecell-20070619
[openafs.git] / src / WINNT / afsd / cm_cell.c
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
10 #include <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #include <nb30.h>
15 #include <winsock2.h>
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <malloc.h>
19 #include <osi.h>
20 #include <string.h>
21
22 #include "afsd.h"
23
24 osi_rwlock_t cm_cellLock;
25
26 /* function called as callback proc from cm_SearchCellFile.  Return 0 to
27  * continue processing.
28  */
29 long cm_AddCellProc(void *rockp, struct sockaddr_in *addrp, char *namep)
30 {
31     cm_server_t *tsp;
32     cm_serverRef_t *tsrp;
33     cm_cell_t *cellp;
34         
35     cellp = rockp;
36
37     /* if this server was previously created by fs setserverprefs */
38     if ( tsp = cm_FindServer(addrp, CM_SERVER_VLDB))
39     {
40         if ( !tsp->cellp )
41             tsp->cellp = cellp;
42     }       
43     else
44         tsp = cm_NewServer(addrp, CM_SERVER_VLDB, cellp);
45
46     /* Insert the vlserver into a sorted list, sorted by server rank */
47     tsrp = cm_NewServerRef(tsp, 0);
48     cm_InsertServerList(&cellp->vlServersp, tsrp);
49     /* drop the allocation reference */
50     lock_ObtainWrite(&cm_serverLock);
51     tsrp->refCount--;
52     lock_ReleaseWrite(&cm_serverLock);
53     return 0;
54 }
55
56 /* if it's from DNS, see if it has expired 
57  * and check to make sure we have a valid set of volume servers
58  * this function must be called with a Write Lock on cm_cellLock
59  */
60 cm_cell_t *cm_UpdateCell(cm_cell_t * cp)
61 {
62     long code = 0;
63
64     if (cp == NULL)
65         return NULL;
66
67     lock_ObtainMutex(&cp->mx);
68     if ((cp->vlServersp == NULL 
69 #ifdef AFS_FREELANCE_CLIENT
70           && !(cp->flags & CM_CELLFLAG_FREELANCE)
71 #endif
72           ) || (time(0) > cp->timeout)
73 #ifdef AFS_AFSDB_ENV
74         || (cm_dnsEnabled && (cp->flags & CM_CELLFLAG_DNS) &&
75          ((cp->flags & CM_CELLFLAG_VLSERVER_INVALID)))
76 #endif
77             ) {
78         /* must empty cp->vlServersp */
79         if (cp->vlServersp) {
80             cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
81             cp->vlServersp = NULL;
82         }
83
84         code = cm_SearchCellFile(cp->name, NULL, cm_AddCellProc, cp);
85 #ifdef AFS_AFSDB_ENV
86         if (code) {
87             if (cm_dnsEnabled) {
88                 int ttl;
89
90                 code = cm_SearchCellByDNS(cp->name, NULL, &ttl, cm_AddCellProc, cp);
91                 if (code == 0) {   /* got cell from DNS */
92                     cp->flags |= CM_CELLFLAG_DNS;
93                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
94                     cp->timeout = time(0) + ttl;
95 #ifdef DEBUG
96                     fprintf(stderr, "cell %s: ttl=%d\n", cp->name, ttl);
97 #endif
98                 } else {
99                     /* if we fail to find it this time, we'll just do nothing and leave the
100                      * current entry alone 
101                      */
102                     cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
103                 }
104             }
105         } else 
106 #endif /* AFS_AFSDB_ENV */
107         {
108             cp->timeout = time(0) + 7200;
109         }       
110     }
111     lock_ReleaseMutex(&cp->mx);
112     return code ? NULL : cp;
113 }
114
115 /* load up a cell structure from the cell database, afsdcell.ini */
116 cm_cell_t *cm_GetCell(char *namep, afs_uint32 flags)
117 {
118     return cm_GetCell_Gen(namep, NULL, flags);
119 }
120
121 cm_cell_t *cm_GetCell_Gen(char *namep, char *newnamep, afs_uint32 flags)
122 {
123     cm_cell_t *cp, *cp2;
124     long code;
125     char fullname[200]="";
126     int  hasWriteLock = 0;
127
128     if (!strcmp(namep,SMB_IOCTL_FILENAME_NOSLASH))
129         return NULL;
130
131     lock_ObtainRead(&cm_cellLock);
132     for (cp = cm_data.allCellsp; cp; cp=cp->nextp) {
133         if (stricmp(namep, cp->name) == 0) {
134             strcpy(fullname, cp->name);
135             break;
136         }
137     }   
138     lock_ReleaseRead(&cm_cellLock);     
139
140     if (cp) {
141         cm_UpdateCell(cp);
142     } else if (flags & CM_FLAG_CREATE) {
143         lock_ObtainWrite(&cm_cellLock);
144         hasWriteLock = 1;
145
146         /* when we dropped the lock the cell could have been added
147          * to the list so check again while holding the write lock 
148          */
149         for (cp = cm_data.allCellsp; cp; cp=cp->nextp) {
150             if (stricmp(namep, cp->name) == 0) {
151                 strcpy(fullname, cp->name);
152                 break;
153             }
154         }   
155
156         if (cp)
157             goto done;
158
159         if ( cm_data.currentCells >= cm_data.maxCells )
160             osi_panic("Exceeded Max Cells", __FILE__, __LINE__);
161
162         /* don't increment currentCells until we know that we 
163          * are going to keep this entry 
164          */
165         cp = &cm_data.cellBaseAddress[cm_data.currentCells];
166         memset(cp, 0, sizeof(cm_cell_t));
167         cp->magic = CM_CELL_MAGIC;
168         
169         code = cm_SearchCellFile(namep, fullname, cm_AddCellProc, cp);
170         if (code) {
171             osi_Log3(afsd_logp,"in cm_GetCell_gen cm_SearchCellFile(%s) returns code= %d fullname= %s", 
172                       osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname));
173
174 #ifdef AFS_AFSDB_ENV
175             if (cm_dnsEnabled) {
176                 int ttl;
177
178                 code = cm_SearchCellByDNS(namep, fullname, &ttl, cm_AddCellProc, cp);
179                 if ( code ) {
180                     osi_Log3(afsd_logp,"in cm_GetCell_gen cm_SearchCellByDNS(%s) returns code= %d fullname= %s", 
181                              osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname));
182                     cp = NULL;
183                     goto done;
184                 } else {   /* got cell from DNS */
185                     cp->flags |= CM_CELLFLAG_DNS;
186                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
187                     cp->timeout = time(0) + ttl;
188                 }
189             } else {
190 #endif
191                 cp = NULL;
192                 goto done;
193 #ifdef AFS_AFSDB_ENV
194             }
195 #endif
196         } else {
197             cp->timeout = time(0) + 7200;       /* two hour timeout */
198         }
199
200         /* we have now been given the fullname of the cell.  It may
201          * be that we already have a cell with that name.  If so,
202          * we should use it instead of completing the allocation
203          * of a new cm_cell_t 
204          */
205         for (cp2 = cm_data.allCellsp; cp2; cp2=cp2->nextp) {
206             if (stricmp(fullname, cp2->name) == 0) {
207                 break;
208             }
209         }   
210
211         if (cp2) {
212             cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
213             cp = cp2;
214             goto done;
215         }
216
217
218         /* randomise among those vlservers having the same rank*/ 
219         cm_RandomizeServer(&cp->vlServersp);
220
221         /* otherwise we found the cell, and so we're nearly done */
222         lock_InitializeMutex(&cp->mx, "cm_cell_t mutex");
223
224         /* copy in name */
225         strncpy(cp->name, fullname, CELL_MAXNAMELEN);
226         cp->name[CELL_MAXNAMELEN-1] = '\0';
227
228         /* thread on global list */
229         cp->nextp = cm_data.allCellsp;
230         cm_data.allCellsp = cp;
231            
232         /* the cellID cannot be 0 */
233         cp->cellID = ++cm_data.currentCells;
234     }
235
236   done:
237     if (hasWriteLock)
238         lock_ReleaseWrite(&cm_cellLock);
239     
240     /* fullname is not valid if cp == NULL */
241     if (cp && newnamep)
242         strcpy(newnamep, fullname);
243     
244     return cp;
245 }
246
247 cm_cell_t *cm_FindCellByID(afs_int32 cellID)
248 {
249     cm_cell_t *cp;
250
251     lock_ObtainRead(&cm_cellLock);
252     for (cp = cm_data.allCellsp; cp; cp=cp->nextp) {
253         if (cellID == cp->cellID) 
254             break;
255     }
256     lock_ReleaseRead(&cm_cellLock);     
257
258     if (cp)
259         cm_UpdateCell(cp);
260
261     return cp;
262 }
263
264 long 
265 cm_ValidateCell(void)
266 {
267     cm_cell_t * cellp;
268     afs_uint32 count;
269
270     for (cellp = cm_data.allCellsp, count = 0; cellp; cellp=cellp->nextp, count++) {
271         if ( cellp->magic != CM_CELL_MAGIC ) {
272             afsi_log("cm_ValidateCell failure: cellp->magic != CM_CELL_MAGIC");
273             fprintf(stderr, "cm_ValidateCell failure: cellp->magic != CM_CELL_MAGIC\n");
274             return -1;
275         }
276         if ( count != 0 && cellp == cm_data.allCellsp ||
277              count > cm_data.maxCells ) {
278             afsi_log("cm_ValidateCell failure: cm_data.allCellsp infinite loop");
279             fprintf(stderr, "cm_ValidateCell failure: cm_data.allCellsp infinite loop\n");
280             return -2;
281         }
282     }
283
284     if ( count != cm_data.currentCells ) {
285         afsi_log("cm_ValidateCell failure: count != cm_data.currentCells");
286         fprintf(stderr, "cm_ValidateCell failure: count != cm_data.currentCells\n");
287         return -3;
288     }
289     
290     return 0;
291 }
292
293
294 long 
295 cm_ShutdownCell(void)
296 {
297     cm_cell_t * cellp;
298
299     for (cellp = cm_data.allCellsp; cellp; cellp=cellp->nextp)
300         lock_FinalizeMutex(&cellp->mx);
301
302     return 0;
303 }
304
305
306 void cm_InitCell(int newFile, long maxCells)
307 {
308     static osi_once_t once;
309         
310     if (osi_Once(&once)) {
311         cm_cell_t * cellp;
312
313         lock_InitializeRWLock(&cm_cellLock, "cell global lock");
314
315         if ( newFile ) {
316             cm_data.allCellsp = NULL;
317             cm_data.currentCells = 0;
318             cm_data.maxCells = maxCells;
319         
320 #ifdef AFS_FREELANCE_CLIENT
321             /* Generate a dummy entry for the Freelance cell whether or not 
322              * freelance mode is being used in this session 
323              */
324
325             cellp = &cm_data.cellBaseAddress[cm_data.currentCells++];
326             memset(cellp, 0, sizeof(cm_cell_t));
327             cellp->magic = CM_CELL_MAGIC;
328
329             lock_InitializeMutex(&cellp->mx, "cm_cell_t mutex");
330
331             /* copy in name */
332             strncpy(cellp->name, "Freelance.Local.Cell", CELL_MAXNAMELEN); /*safe*/
333
334             /* thread on global list */
335             cellp->nextp = cm_data.allCellsp;
336             cm_data.allCellsp = cellp;
337                 
338             cellp->cellID = AFS_FAKE_ROOT_CELL_ID;
339             cellp->vlServersp = NULL;
340             cellp->flags = CM_CELLFLAG_FREELANCE;
341 #endif  
342         } else {
343             for (cellp = cm_data.allCellsp; cellp; cellp=cellp->nextp) {
344                 lock_InitializeMutex(&cellp->mx, "cm_cell_t mutex");
345                 cellp->vlServersp = NULL;
346             }
347         }
348
349         osi_EndOnce(&once);
350     }
351 }
352
353 void cm_ChangeRankCellVLServer(cm_server_t *tsp)
354 {
355     cm_cell_t *cp;
356     int code;
357
358     cp = tsp->cellp;    /* cell that this vlserver belongs to */
359     if (cp) {
360         lock_ObtainMutex(&cp->mx);
361         code = cm_ChangeRankServer(&cp->vlServersp, tsp);
362
363         if ( !code )            /* if the server list was rearranged */
364             cm_RandomizeServer(&cp->vlServersp);
365
366         lock_ReleaseMutex(&cp->mx);
367     }
368 }       
369
370 int cm_DumpCells(FILE *outputFile, char *cookie, int lock)
371 {
372     cm_cell_t *cellp;
373     int zilch;
374     char output[1024];
375
376     if (lock)
377         lock_ObtainRead(&cm_cellLock);
378
379     sprintf(output, "%s - dumping cells - cm_data.currentCells=%d, cm_data.maxCells=%d\r\n", 
380             cookie, cm_data.currentCells, cm_data.maxCells);
381     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
382
383     for (cellp = cm_data.allCellsp; cellp; cellp=cellp->nextp) {
384         sprintf(output, "%s cellp=0x%p,name=%s ID=%d flags=0x%x\r\n", 
385                 cookie, cellp, cellp->name, cellp->cellID, cellp->flags);
386         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
387     }
388
389     sprintf(output, "%s - Done dumping cells.\r\n", cookie);
390     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
391
392     if (lock)
393         lock_ReleaseRead(&cm_cellLock);
394
395     return(0);
396 }
397