d8ab12d711ef2f211064573ba857b07c91a1060e
[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  * At the present time the return value is ignored by the caller.
30  */
31 long cm_AddCellProc(void *rockp, struct sockaddr_in *addrp, char *hostnamep)
32 {
33     cm_server_t *tsp;
34     cm_serverRef_t *tsrp;
35     cm_cell_t *cellp;
36         
37     cellp = rockp;
38
39     /* if this server was previously created by fs setserverprefs */
40     if ( tsp = cm_FindServer(addrp, CM_SERVER_VLDB))
41     {
42         if ( !tsp->cellp )
43             tsp->cellp = cellp;
44         else if (tsp->cellp != cellp) {
45             osi_Log3(afsd_logp, "found a vlserver %s associated with two cells named %s and %s",
46                      osi_LogSaveString(afsd_logp,hostnamep),
47                      osi_LogSaveString(afsd_logp,tsp->cellp->name), 
48                      osi_LogSaveString(afsd_logp,cellp->name));
49         }
50     }       
51     else
52         tsp = cm_NewServer(addrp, CM_SERVER_VLDB, cellp);
53
54     /* Insert the vlserver into a sorted list, sorted by server rank */
55     tsrp = cm_NewServerRef(tsp, 0);
56     cm_InsertServerList(&cellp->vlServersp, tsrp);
57     /* drop the allocation reference */
58     lock_ObtainWrite(&cm_serverLock);
59     tsrp->refCount--;
60     lock_ReleaseWrite(&cm_serverLock);
61
62     return 0;
63 }
64
65 /* if it's from DNS, see if it has expired 
66  * and check to make sure we have a valid set of volume servers
67  * this function must be called with a Write Lock on cm_cellLock
68  */
69 cm_cell_t *cm_UpdateCell(cm_cell_t * cp)
70 {
71     long code = 0;
72
73     if (cp == NULL)
74         return NULL;
75
76     lock_ObtainMutex(&cp->mx);
77     if ((cp->vlServersp == NULL 
78 #ifdef AFS_FREELANCE_CLIENT
79           && !(cp->flags & CM_CELLFLAG_FREELANCE)
80 #endif
81           ) || (time(0) > cp->timeout)
82 #ifdef AFS_AFSDB_ENV
83         || (cm_dnsEnabled && (cp->flags & CM_CELLFLAG_DNS) &&
84          ((cp->flags & CM_CELLFLAG_VLSERVER_INVALID)))
85 #endif
86             ) {
87         /* must empty cp->vlServersp */
88         if (cp->vlServersp) {
89             cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
90             cp->vlServersp = NULL;
91         }
92
93         code = cm_SearchCellFile(cp->name, NULL, cm_AddCellProc, cp);
94 #ifdef AFS_AFSDB_ENV
95         if (code) {
96             if (cm_dnsEnabled) {
97                 int ttl;
98
99                 code = cm_SearchCellByDNS(cp->name, NULL, &ttl, cm_AddCellProc, cp);
100                 if (code == 0) {   /* got cell from DNS */
101                     cp->flags |= CM_CELLFLAG_DNS;
102                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
103                     cp->timeout = time(0) + ttl;
104 #ifdef DEBUG
105                     fprintf(stderr, "cell %s: ttl=%d\n", cp->name, ttl);
106 #endif
107                 } else {
108                     /* if we fail to find it this time, we'll just do nothing and leave the
109                      * current entry alone 
110                      */
111                     cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
112                 }
113             }
114         } else 
115 #endif /* AFS_AFSDB_ENV */
116         {
117             cp->timeout = time(0) + 7200;
118         }       
119     }
120     lock_ReleaseMutex(&cp->mx);
121     return code ? NULL : cp;
122 }
123
124 /* load up a cell structure from the cell database, afsdcell.ini */
125 cm_cell_t *cm_GetCell(char *namep, afs_uint32 flags)
126 {
127     return cm_GetCell_Gen(namep, NULL, flags);
128 }
129
130 cm_cell_t *cm_GetCell_Gen(char *namep, char *newnamep, afs_uint32 flags)
131 {
132     cm_cell_t *cp, *cp2;
133     long code;
134     char fullname[200]="";
135     int  hasWriteLock = 0;
136     afs_uint32 hash;
137
138     if (!strcmp(namep,SMB_IOCTL_FILENAME_NOSLASH))
139         return NULL;
140
141     hash = CM_CELL_NAME_HASH(namep);
142
143     lock_ObtainRead(&cm_cellLock);
144     for (cp = cm_data.cellNameHashTablep[hash]; cp; cp=cp->nameNextp) {
145         if (stricmp(namep, cp->name) == 0) {
146             strcpy(fullname, cp->name);
147             break;
148         }
149     }
150
151     if (!cp) {
152         for (cp = cm_data.allCellsp; cp; cp=cp->allNextp) {
153             if (strnicmp(namep, cp->name, strlen(namep)) == 0) {
154                 strcpy(fullname, cp->name);
155                 break;
156             }
157         }   
158     }
159
160     lock_ReleaseRead(&cm_cellLock);
161
162     if (cp) {
163         cm_UpdateCell(cp);
164     } else if (flags & CM_FLAG_CREATE) {
165         lock_ObtainWrite(&cm_cellLock);
166         hasWriteLock = 1;
167
168         /* when we dropped the lock the cell could have been added
169          * to the list so check again while holding the write lock 
170          */
171         for (cp = cm_data.cellNameHashTablep[hash]; cp; cp=cp->nameNextp) {
172             if (stricmp(namep, cp->name) == 0) {
173                 strcpy(fullname, cp->name);
174                 break;
175             }
176         }   
177
178         if (cp)
179             goto done;
180
181         for (cp = cm_data.allCellsp; cp; cp=cp->allNextp) {
182             if (strnicmp(namep, cp->name, strlen(namep)) == 0) {
183                 strcpy(fullname, cp->name);
184                 break;
185             }
186         }   
187
188         if (cp)
189             goto done;
190
191         if ( cm_data.currentCells >= cm_data.maxCells )
192             osi_panic("Exceeded Max Cells", __FILE__, __LINE__);
193
194         /* don't increment currentCells until we know that we 
195          * are going to keep this entry 
196          */
197         cp = &cm_data.cellBaseAddress[cm_data.currentCells];
198         memset(cp, 0, sizeof(cm_cell_t));
199         cp->magic = CM_CELL_MAGIC;
200         
201         code = cm_SearchCellFile(namep, fullname, cm_AddCellProc, cp);
202         if (code) {
203             osi_Log3(afsd_logp,"in cm_GetCell_gen cm_SearchCellFile(%s) returns code= %d fullname= %s", 
204                       osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname));
205
206 #ifdef AFS_AFSDB_ENV
207             if (cm_dnsEnabled) {
208                 int ttl;
209
210                 code = cm_SearchCellByDNS(namep, fullname, &ttl, cm_AddCellProc, cp);
211                 if ( code ) {
212                     osi_Log3(afsd_logp,"in cm_GetCell_gen cm_SearchCellByDNS(%s) returns code= %d fullname= %s", 
213                              osi_LogSaveString(afsd_logp,namep), code, osi_LogSaveString(afsd_logp,fullname));
214                     cp = NULL;
215                     goto done;
216                 } else {   /* got cell from DNS */
217                     cp->flags |= CM_CELLFLAG_DNS;
218                     cp->flags &= ~CM_CELLFLAG_VLSERVER_INVALID;
219                     cp->timeout = time(0) + ttl;
220                 }
221             } else {
222 #endif
223                 cp = NULL;
224                 goto done;
225 #ifdef AFS_AFSDB_ENV
226             }
227 #endif
228         } else {
229             cp->timeout = time(0) + 7200;       /* two hour timeout */
230         }
231
232         /* we have now been given the fullname of the cell.  It may
233          * be that we already have a cell with that name.  If so,
234          * we should use it instead of completing the allocation
235          * of a new cm_cell_t 
236          */
237         hash = CM_CELL_NAME_HASH(fullname);
238         for (cp2 = cm_data.cellNameHashTablep[hash]; cp2; cp2=cp2->nameNextp) {
239             if (stricmp(fullname, cp2->name) == 0) {
240                 break;
241             }
242         }   
243
244         if (cp2) {
245             cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
246             cp = cp2;
247             goto done;
248         }
249
250
251         /* randomise among those vlservers having the same rank*/ 
252         cm_RandomizeServer(&cp->vlServersp);
253
254         /* otherwise we found the cell, and so we're nearly done */
255         lock_InitializeMutex(&cp->mx, "cm_cell_t mutex");
256
257         /* copy in name */
258         strncpy(cp->name, fullname, CELL_MAXNAMELEN);
259         cp->name[CELL_MAXNAMELEN-1] = '\0';
260
261         /* the cellID cannot be 0 */
262         cp->cellID = ++cm_data.currentCells;
263
264                 /* append cell to global list */
265         if (cm_data.allCellsp == NULL) {
266             cm_data.allCellsp = cp;
267         } else {
268             for (cp2 = cm_data.allCellsp; cp2->allNextp; cp2=cp2->allNextp)
269                 ;
270             cp2->allNextp = cp;
271         }
272         cp->allNextp = NULL;
273
274         cm_AddCellToNameHashTable(cp);
275         cm_AddCellToIDHashTable(cp);           
276     }
277
278   done:
279     if (hasWriteLock)
280         lock_ReleaseWrite(&cm_cellLock);
281     
282     /* fullname is not valid if cp == NULL */
283     if (cp && newnamep)
284         strcpy(newnamep, fullname);
285     
286     return cp;
287 }
288
289 cm_cell_t *cm_FindCellByID(afs_int32 cellID)
290 {
291     cm_cell_t *cp;
292     afs_uint32 hash;
293
294     lock_ObtainRead(&cm_cellLock);
295
296     hash = CM_CELL_ID_HASH(cellID);
297
298     for (cp = cm_data.cellIDHashTablep[hash]; cp; cp=cp->idNextp) {
299         if (cellID == cp->cellID) 
300             break;
301     }
302     lock_ReleaseRead(&cm_cellLock);     
303
304     if (cp)
305         cm_UpdateCell(cp);
306
307     return cp;
308 }
309
310 long 
311 cm_ValidateCell(void)
312 {
313     cm_cell_t * cellp;
314     afs_uint32 count;
315
316     for (cellp = cm_data.allCellsp, count = 0; cellp; cellp=cellp->allNextp, count++) {
317         if ( cellp->magic != CM_CELL_MAGIC ) {
318             afsi_log("cm_ValidateCell failure: cellp->magic != CM_CELL_MAGIC");
319             fprintf(stderr, "cm_ValidateCell failure: cellp->magic != CM_CELL_MAGIC\n");
320             return -1;
321         }
322         if ( count != 0 && cellp == cm_data.allCellsp ||
323              count > cm_data.maxCells ) {
324             afsi_log("cm_ValidateCell failure: cm_data.allCellsp infinite loop");
325             fprintf(stderr, "cm_ValidateCell failure: cm_data.allCellsp infinite loop\n");
326             return -2;
327         }
328     }
329
330     if ( count != cm_data.currentCells ) {
331         afsi_log("cm_ValidateCell failure: count != cm_data.currentCells");
332         fprintf(stderr, "cm_ValidateCell failure: count != cm_data.currentCells\n");
333         return -3;
334     }
335     
336     return 0;
337 }
338
339
340 long 
341 cm_ShutdownCell(void)
342 {
343     cm_cell_t * cellp;
344
345     for (cellp = cm_data.allCellsp; cellp; cellp=cellp->allNextp)
346         lock_FinalizeMutex(&cellp->mx);
347
348     return 0;
349 }
350
351
352 void cm_InitCell(int newFile, long maxCells)
353 {
354     static osi_once_t once;
355         
356     if (osi_Once(&once)) {
357         cm_cell_t * cellp;
358
359         lock_InitializeRWLock(&cm_cellLock, "cell global lock");
360
361         if ( newFile ) {
362             cm_data.allCellsp = NULL;
363             cm_data.currentCells = 0;
364             cm_data.maxCells = maxCells;
365             memset(cm_data.cellNameHashTablep, 0, sizeof(cm_cell_t *) * cm_data.cellHashTableSize);
366             memset(cm_data.cellIDHashTablep, 0, sizeof(cm_cell_t *) * cm_data.cellHashTableSize);
367         
368 #ifdef AFS_FREELANCE_CLIENT
369             /* Generate a dummy entry for the Freelance cell whether or not 
370              * freelance mode is being used in this session 
371              */
372
373             cellp = &cm_data.cellBaseAddress[cm_data.currentCells++];
374             memset(cellp, 0, sizeof(cm_cell_t));
375             cellp->magic = CM_CELL_MAGIC;
376
377             lock_InitializeMutex(&cellp->mx, "cm_cell_t mutex");
378
379             /* copy in name */
380             strncpy(cellp->name, "Freelance.Local.Cell", CELL_MAXNAMELEN); /*safe*/
381
382             /* thread on global list */
383             cellp->allNextp = cm_data.allCellsp;
384             cm_data.allCellsp = cellp;
385                 
386             cellp->cellID = AFS_FAKE_ROOT_CELL_ID;
387             cellp->vlServersp = NULL;
388             cellp->flags = CM_CELLFLAG_FREELANCE;
389
390             cm_AddCellToNameHashTable(cellp);
391             cm_AddCellToIDHashTable(cellp);           
392 #endif  
393         } else {
394             for (cellp = cm_data.allCellsp; cellp; cellp=cellp->allNextp) {
395                 lock_InitializeMutex(&cellp->mx, "cm_cell_t mutex");
396                 cellp->vlServersp = NULL;
397             }
398         }
399
400         osi_EndOnce(&once);
401     }
402 }
403
404 void cm_ChangeRankCellVLServer(cm_server_t *tsp)
405 {
406     cm_cell_t *cp;
407     int code;
408
409     cp = tsp->cellp;    /* cell that this vlserver belongs to */
410     if (cp) {
411         lock_ObtainMutex(&cp->mx);
412         code = cm_ChangeRankServer(&cp->vlServersp, tsp);
413
414         if ( !code )            /* if the server list was rearranged */
415             cm_RandomizeServer(&cp->vlServersp);
416
417         lock_ReleaseMutex(&cp->mx);
418     }
419 }       
420
421 int cm_DumpCells(FILE *outputFile, char *cookie, int lock)
422 {
423     cm_cell_t *cellp;
424     int zilch;
425     char output[1024];
426
427     if (lock)
428         lock_ObtainRead(&cm_cellLock);
429
430     sprintf(output, "%s - dumping cells - cm_data.currentCells=%d, cm_data.maxCells=%d\r\n", 
431             cookie, cm_data.currentCells, cm_data.maxCells);
432     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
433
434     for (cellp = cm_data.allCellsp; cellp; cellp=cellp->allNextp) {
435         sprintf(output, "%s cellp=0x%p,name=%s ID=%d flags=0x%x\r\n", 
436                 cookie, cellp, cellp->name, cellp->cellID, cellp->flags);
437         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
438     }
439
440     sprintf(output, "%s - Done dumping cells.\r\n", cookie);
441     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
442
443     if (lock)
444         lock_ReleaseRead(&cm_cellLock);
445
446     return(0);
447 }
448
449 /* call with volume write-locked and mutex held */
450 void cm_AddCellToNameHashTable(cm_cell_t *cellp)
451 {
452     int i;
453     
454     if (cellp->flags & CM_CELLFLAG_IN_NAMEHASH)
455         return;
456
457     i = CM_CELL_NAME_HASH(cellp->name);
458
459     cellp->nameNextp = cm_data.cellNameHashTablep[i];
460     cm_data.cellNameHashTablep[i] = cellp;
461     cellp->flags |= CM_CELLFLAG_IN_NAMEHASH;
462 }
463
464 /* call with cell write-locked and mutex held */
465 void cm_RemoveCellFromNameHashTable(cm_cell_t *cellp)
466 {
467     cm_cell_t **lcellpp;
468     cm_cell_t *tcellp;
469     int i;
470         
471     if (cellp->flags & CM_CELLFLAG_IN_NAMEHASH) {
472         /* hash it out first */
473         i = CM_CELL_NAME_HASH(cellp->name);
474         for (lcellpp = &cm_data.cellNameHashTablep[i], tcellp = cm_data.cellNameHashTablep[i];
475              tcellp;
476              lcellpp = &tcellp->nameNextp, tcellp = tcellp->nameNextp) {
477             if (tcellp == cellp) {
478                 *lcellpp = cellp->nameNextp;
479                 cellp->flags &= ~CM_CELLFLAG_IN_NAMEHASH;
480                 cellp->nameNextp = NULL;
481                 break;
482             }
483         }
484     }
485 }
486
487 /* call with cell write-locked and mutex held */
488 void cm_AddCellToIDHashTable(cm_cell_t *cellp)
489 {
490     int i;
491     
492     if (cellp->flags & CM_CELLFLAG_IN_IDHASH)
493         return;
494
495     i = CM_CELL_ID_HASH(cellp->cellID);
496
497     cellp->idNextp = cm_data.cellIDHashTablep[i];
498     cm_data.cellIDHashTablep[i] = cellp;
499     cellp->flags |= CM_CELLFLAG_IN_IDHASH;
500 }
501
502 /* call with cell write-locked and mutex held */
503 void cm_RemoveCellFromIDHashTable(cm_cell_t *cellp)
504 {
505     cm_cell_t **lcellpp;
506     cm_cell_t *tcellp;
507     int i;
508         
509     if (cellp->flags & CM_CELLFLAG_IN_IDHASH) {
510         /* hash it out first */
511         i = CM_CELL_ID_HASH(cellp->cellID);
512         for (lcellpp = &cm_data.cellIDHashTablep[i], tcellp = cm_data.cellIDHashTablep[i];
513              tcellp;
514              lcellpp = &tcellp->idNextp, tcellp = tcellp->idNextp) {
515             if (tcellp == cellp) {
516                 *lcellpp = cellp->idNextp;
517                 cellp->flags &= ~CM_CELLFLAG_IN_IDHASH;
518                 cellp->idNextp = NULL;
519                 break;
520             }
521         }
522     }
523 }
524