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